





import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY







@is_pipeline_test
class 			__A       (      unittest.TestCase  ):




      """simple docstring"""







      UpperCAmelCase__						=      MODEL_FOR_MASKED_LM_MAPPING
      UpperCAmelCase__						=      TF_MODEL_FOR_MASKED_LM_MAPPING


      def 				__snake_case			(		self):



             """simple docstring"""





             super().tearDown()
             # clean-up as much as possible GPU memory occupied by PyTorch
             gc.collect()
             if is_torch_available():
                    import torch

                    torch.cuda.empty_cache()


      @require_tf
      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     Dict	=		pipeline(task='''fill-mask'''      ,							model='''sshleifer/tiny-distilroberta-base'''      ,							top_k=2      ,							framework='''tf''')
             _lowerCamelCase							:     int	=		unmasker('''My name is <mask>''')
             self.assertEqual(
                 nested_simplify(a__      ,							decimals=6)      ,							[
                     {'''sequence''': '''My name is grouped''', '''score''': 2.1e-05, '''token''': 3_8015, '''token_str''': ''' grouped'''},
                     {'''sequence''': '''My name is accuser''', '''score''': 2.1e-05, '''token''': 2_5506, '''token_str''': ''' accuser'''},
                 ]      ,							)

             _lowerCamelCase							:     List[str]	=		unmasker('''The largest city in France is <mask>''')
             self.assertEqual(
                 nested_simplify(a__      ,							decimals=6)      ,							[
                     {
                         '''sequence''': '''The largest city in France is grouped''',
                         '''score''': 2.1e-05,
                         '''token''': 3_8015,
                         '''token_str''': ''' grouped''',
                     },
                     {
                         '''sequence''': '''The largest city in France is accuser''',
                         '''score''': 2.1e-05,
                         '''token''': 2_5506,
                         '''token_str''': ''' accuser''',
                     },
                 ]      ,							)

             _lowerCamelCase							:     str	=		unmasker('''My name is <mask>'''      ,							targets=[''' Patrick''', ''' Clara''', ''' Teven''']      ,							top_k=3)
             self.assertEqual(
                 nested_simplify(a__      ,							decimals=6)      ,							[
                     {'''sequence''': '''My name is Clara''', '''score''': 2e-05, '''token''': 1_3606, '''token_str''': ''' Clara'''},
                     {'''sequence''': '''My name is Patrick''', '''score''': 2e-05, '''token''': 3499, '''token_str''': ''' Patrick'''},
                     {'''sequence''': '''My name is Te''', '''score''': 1.9e-05, '''token''': 2941, '''token_str''': ''' Te'''},
                 ]      ,							)


      @require_torch
      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     Union[str, Any]	=		pipeline(task='''fill-mask'''      ,							model='''sshleifer/tiny-distilroberta-base'''      ,							top_k=2      ,							framework='''pt''')

             _lowerCamelCase							:     Optional[int]	=		unmasker('''My name is <mask>''')
             self.assertEqual(
                 nested_simplify(a__      ,							decimals=6)      ,							[
                     {'''sequence''': '''My name is Maul''', '''score''': 2.2e-05, '''token''': 3_5676, '''token_str''': ''' Maul'''},
                     {'''sequence''': '''My name isELS''', '''score''': 2.2e-05, '''token''': 1_6416, '''token_str''': '''ELS'''},
                 ]      ,							)

             _lowerCamelCase							:     List[str]	=		unmasker('''The largest city in France is <mask>''')
             self.assertEqual(
                 nested_simplify(a__      ,							decimals=6)      ,							[
                     {
                         '''sequence''': '''The largest city in France is Maul''',
                         '''score''': 2.2e-05,
                         '''token''': 3_5676,
                         '''token_str''': ''' Maul''',
                     },
                     {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2e-05, '''token''': 1_6416, '''token_str''': '''ELS'''},
                 ]      ,							)

             _lowerCamelCase							:     Optional[Any]	=		unmasker('''My name is <mask>'''      ,							targets=[''' Patrick''', ''' Clara''', ''' Teven''']      ,							top_k=3)
             self.assertEqual(
                 nested_simplify(a__      ,							decimals=6)      ,							[
                     {'''sequence''': '''My name is Patrick''', '''score''': 2.1e-05, '''token''': 3499, '''token_str''': ''' Patrick'''},
                     {'''sequence''': '''My name is Te''', '''score''': 2e-05, '''token''': 2941, '''token_str''': ''' Te'''},
                     {'''sequence''': '''My name is Clara''', '''score''': 2e-05, '''token''': 1_3606, '''token_str''': ''' Clara'''},
                 ]      ,							)

             _lowerCamelCase							:     Union[str, Any]	=		unmasker('''My name is <mask> <mask>'''      ,							top_k=2)

             self.assertEqual(
                 nested_simplify(a__      ,							decimals=6)      ,							[
                     [
                         {
                             '''score''': 2.2e-05,
                             '''token''': 3_5676,
                             '''token_str''': ''' Maul''',
                             '''sequence''': '''<s>My name is Maul<mask></s>''',
                         },
                         {'''score''': 2.2e-05, '''token''': 1_6416, '''token_str''': '''ELS''', '''sequence''': '''<s>My name isELS<mask></s>'''},
                     ],
                     [
                         {
                             '''score''': 2.2e-05,
                             '''token''': 3_5676,
                             '''token_str''': ''' Maul''',
                             '''sequence''': '''<s>My name is<mask> Maul</s>''',
                         },
                         {'''score''': 2.2e-05, '''token''': 1_6416, '''token_str''': '''ELS''', '''sequence''': '''<s>My name is<mask>ELS</s>'''},
                     ],
                 ]      ,							)


      @require_torch_gpu
      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     int	=		pipeline('''fill-mask'''      ,							model='''hf-internal-testing/tiny-random-distilbert'''      ,							device=0      ,							framework='''pt''')

             # convert model to fp16
             pipe.model.half()

             _lowerCamelCase							:     Tuple	=		pipe('''Paris is the [MASK] of France.''')
             # We actually don't care about the result, we just want to make sure
             # it works, meaning the float16 tensor got casted back to float32
             # for postprocessing.
             self.assertIsInstance(a__      ,							a__)


      @slow
      @require_torch
      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     Optional[int]	=		pipeline(task='''fill-mask'''      ,							model='''distilroberta-base'''      ,							top_k=2      ,							framework='''pt''')
             self.run_large_test(a__)


      @slow
      @require_tf
      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     Optional[int]	=		pipeline(task='''fill-mask'''      ,							model='''distilroberta-base'''      ,							top_k=2      ,							framework='''tf''')
             self.run_large_test(a__)


      def 				__snake_case			(		self      ,							a__):



             """simple docstring"""





             _lowerCamelCase							:     Any	=		unmasker('''My name is <mask>''')
             self.assertEqual(
                 nested_simplify(a__)      ,							[
                     {'''sequence''': '''My name is John''', '''score''': 0.008, '''token''': 610, '''token_str''': ''' John'''},
                     {'''sequence''': '''My name is Chris''', '''score''': 0.007, '''token''': 1573, '''token_str''': ''' Chris'''},
                 ]      ,							)
             _lowerCamelCase							:     Union[str, Any]	=		unmasker('''The largest city in France is <mask>''')
             self.assertEqual(
                 nested_simplify(a__)      ,							[
                     {
                         '''sequence''': '''The largest city in France is Paris''',
                         '''score''': 0.251,
                         '''token''': 2201,
                         '''token_str''': ''' Paris''',
                     },
                     {
                         '''sequence''': '''The largest city in France is Lyon''',
                         '''score''': 0.214,
                         '''token''': 1_2790,
                         '''token_str''': ''' Lyon''',
                     },
                 ]      ,							)

             _lowerCamelCase							:     List[Any]	=		unmasker('''My name is <mask>'''      ,							targets=[''' Patrick''', ''' Clara''', ''' Teven''']      ,							top_k=3)
             self.assertEqual(
                 nested_simplify(a__)      ,							[
                     {'''sequence''': '''My name is Patrick''', '''score''': 0.005, '''token''': 3499, '''token_str''': ''' Patrick'''},
                     {'''sequence''': '''My name is Clara''', '''score''': 0.000, '''token''': 1_3606, '''token_str''': ''' Clara'''},
                     {'''sequence''': '''My name is Te''', '''score''': 0.000, '''token''': 2941, '''token_str''': ''' Te'''},
                 ]      ,							)


      @require_torch
      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     int	=		pipeline(task='''fill-mask'''      ,							model='''sshleifer/tiny-distilroberta-base'''      ,							framework='''pt''')
             _lowerCamelCase							:     List[str]	=		None
             _lowerCamelCase							:     Any	=		None
             self.run_pipeline_test(a__      ,							[])


      @require_tf
      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     Optional[int]	=		pipeline(task='''fill-mask'''      ,							model='''sshleifer/tiny-distilroberta-base'''      ,							framework='''tf''')
             _lowerCamelCase							:     Optional[Any]	=		None
             _lowerCamelCase							:     int	=		None
             self.run_pipeline_test(a__      ,							[])


      def 				__snake_case			(		self      ,							a__      ,							a__      ,							a__):



             """simple docstring"""





             if tokenizer is None or tokenizer.mask_token_id is None:
                    self.skipTest('''The provided tokenizer has no mask token, (probably reformer or wav2vec2)''')

             _lowerCamelCase							:     str	=		FillMaskPipeline(model=a__      ,							tokenizer=a__)
             _lowerCamelCase							:     Optional[int]	=		[
                 F"""This is another {tokenizer.mask_token} test""",
             ]
             return fill_masker, examples


      def 				__snake_case			(		self      ,							a__      ,							a__):



             """simple docstring"""





             _lowerCamelCase							:     List[Any]	=		fill_masker.tokenizer
             _lowerCamelCase							:     List[str]	=		fill_masker.model

             _lowerCamelCase							:     Union[str, Any]	=		fill_masker(
                 F"""This is a {tokenizer.mask_token}"""      ,							)
             self.assertEqual(
                 a__      ,							[
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 ]      ,							)

             _lowerCamelCase							:     Optional[int]	=		fill_masker([F"""This is a {tokenizer.mask_token}"""])
             self.assertEqual(
                 a__      ,							[
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 ]      ,							)

             _lowerCamelCase							:     Any	=		fill_masker([F"""This is a {tokenizer.mask_token}""", F"""Another {tokenizer.mask_token} great test."""])
             self.assertEqual(
                 a__      ,							[
                     [
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     ],
                     [
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     ],
                 ]      ,							)

             with self.assertRaises(a__):
                    fill_masker([None])
             # No mask_token is not supported
             with self.assertRaises(a__):
                    fill_masker('''This is''')

             self.run_test_top_k(a__      ,							a__)
             self.run_test_targets(a__      ,							a__)
             self.run_test_top_k_targets(a__      ,							a__)
             self.fill_mask_with_duplicate_targets_and_top_k(a__      ,							a__)
             self.fill_mask_with_multiple_masks(a__      ,							a__)


      def 				__snake_case			(		self      ,							a__      ,							a__):



             """simple docstring"""





             _lowerCamelCase							:     str	=		tokenizer.get_vocab()
             _lowerCamelCase							:     Optional[int]	=		sorted(vocab.keys())[:2]
             # Pipeline argument
             _lowerCamelCase							:     List[str]	=		FillMaskPipeline(model=a__      ,							tokenizer=a__      ,							targets=a__)
             _lowerCamelCase							:     Any	=		fill_masker(F"""This is a {tokenizer.mask_token}""")
             self.assertEqual(
                 a__      ,							[
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 ]      ,							)
             _lowerCamelCase							:     Optional[int]	=		{vocab[el] for el in targets}
             self.assertEqual({el['''token'''] for el in outputs}      ,							a__)
             _lowerCamelCase							:     Dict	=		[tokenizer.decode([x]) for x in target_ids]
             self.assertEqual({el['''token_str'''] for el in outputs}      ,							set(a__))

             # Call argument
             _lowerCamelCase							:     Optional[int]	=		FillMaskPipeline(model=a__      ,							tokenizer=a__)
             _lowerCamelCase							:     int	=		fill_masker(F"""This is a {tokenizer.mask_token}"""      ,							targets=a__)
             self.assertEqual(
                 a__      ,							[
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 ]      ,							)
             _lowerCamelCase							:     List[Any]	=		{vocab[el] for el in targets}
             self.assertEqual({el['''token'''] for el in outputs}      ,							a__)
             _lowerCamelCase							:     Dict	=		[tokenizer.decode([x]) for x in target_ids]
             self.assertEqual({el['''token_str'''] for el in outputs}      ,							set(a__))

             # Score equivalence
             _lowerCamelCase							:     Optional[int]	=		fill_masker(F"""This is a {tokenizer.mask_token}"""      ,							targets=a__)
             _lowerCamelCase							:     Dict	=		[top_mask['''token_str'''] for top_mask in outputs]
             _lowerCamelCase							:     str	=		[top_mask['''score'''] for top_mask in outputs]

             # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
             if set(a__) == set(a__):
                    _lowerCamelCase							:     List[Any]	=		fill_masker(F"""This is a {tokenizer.mask_token}"""      ,							targets=a__)
                    _lowerCamelCase							:     List[Any]	=		[top_mask['''score'''] for top_mask in unmasked_targets]
                    self.assertEqual(nested_simplify(a__)      ,							nested_simplify(a__))

             # Raises with invalid
             with self.assertRaises(a__):
                    _lowerCamelCase							:     Any	=		fill_masker(F"""This is a {tokenizer.mask_token}"""      ,							targets=[])
             # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
             if "" not in tokenizer.get_vocab():
                    with self.assertRaises(a__):
                           _lowerCamelCase							:     str	=		fill_masker(F"""This is a {tokenizer.mask_token}"""      ,							targets=[''''''])
                    with self.assertRaises(a__):
                           _lowerCamelCase							:     Union[str, Any]	=		fill_masker(F"""This is a {tokenizer.mask_token}"""      ,							targets='''''')


      def 				__snake_case			(		self      ,							a__      ,							a__):



             """simple docstring"""





             _lowerCamelCase							:     Any	=		FillMaskPipeline(model=a__      ,							tokenizer=a__      ,							top_k=2)
             _lowerCamelCase							:     Union[str, Any]	=		fill_masker(F"""This is a {tokenizer.mask_token}""")
             self.assertEqual(
                 a__      ,							[
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 ]      ,							)

             _lowerCamelCase							:     Tuple	=		FillMaskPipeline(model=a__      ,							tokenizer=a__)
             _lowerCamelCase							:     List[Any]	=		fill_masker(F"""This is a {tokenizer.mask_token}"""      ,							top_k=2)
             self.assertEqual(
                 a__      ,							[
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 ]      ,							)
             self.assertEqual(nested_simplify(a__)      ,							nested_simplify(a__))


      def 				__snake_case			(		self      ,							a__      ,							a__):



             """simple docstring"""





             _lowerCamelCase							:     Dict	=		tokenizer.get_vocab()
             _lowerCamelCase							:     Any	=		FillMaskPipeline(model=a__      ,							tokenizer=a__)

             # top_k=2, ntargets=3
             _lowerCamelCase							:     List[Any]	=		sorted(vocab.keys())[:3]
             _lowerCamelCase							:     Tuple	=		fill_masker(F"""This is a {tokenizer.mask_token}"""      ,							top_k=2      ,							targets=a__)

             # If we use the most probably targets, and filter differently, we should still
             # have the same results
             _lowerCamelCase							:     Union[str, Any]	=		[el['''token_str'''] for el in sorted(a__      ,							key=lambda a__: x["score"]      ,							reverse=a__)]
             # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
             if set(a__).issubset(a__):
                    _lowerCamelCase							:     Tuple	=		fill_masker(F"""This is a {tokenizer.mask_token}"""      ,							top_k=3      ,							targets=a__)
                    # They should yield exactly the same result
                    self.assertEqual(nested_simplify(a__)      ,							nested_simplify(a__))


      def 				__snake_case			(		self      ,							a__      ,							a__):



             """simple docstring"""





             _lowerCamelCase							:     str	=		FillMaskPipeline(model=a__      ,							tokenizer=a__)
             _lowerCamelCase							:     Any	=		tokenizer.get_vocab()
             # String duplicates + id duplicates
             _lowerCamelCase							:     Any	=		sorted(vocab.keys())[:3]
             _lowerCamelCase							:     str	=		[targets[0], targets[1], targets[0], targets[2], targets[1]]
             _lowerCamelCase							:     str	=		fill_masker(F"""My name is {tokenizer.mask_token}"""      ,							targets=a__      ,							top_k=10)

             # The target list contains duplicates, so we can't output more
             # than them
             self.assertEqual(len(a__)      ,							3)



      def 				__snake_case			(		self      ,							a__      ,							a__):



             """simple docstring"""





             _lowerCamelCase							:     Tuple	=		FillMaskPipeline(model=a__      ,							tokenizer=a__)

             _lowerCamelCase							:     Union[str, Any]	=		fill_masker(
                 F"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}"""      ,							top_k=2)
             self.assertEqual(
                 a__      ,							[
                     [
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     ],
                     [
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     ],
                     [
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                         {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     ],
                 ]      ,							)








def    __UpperCAmelCase(      lowercase_      ):
       # if the collection is empty, returns empty
       if collection == []:
              return []

       # get some information about the collection
       _lowerCamelCase							:     Tuple	=		len(lowercase_      )
       _lowerCamelCase							:     List[str]	=		max(lowercase_      )
       _lowerCamelCase							:     Any	=		min(lowercase_      )

       # create the counting array
       _lowerCamelCase							:     str	=		coll_max + 1 - coll_min
       _lowerCamelCase							:     Union[str, Any]	=		[0] * counting_arr_length

       # count how much a number appears in the collection
       for number in collection:
              counting_arr[number - coll_min] += 1

       # sum each position with it's predecessors. now, counting_arr[i] tells
       # us how many elements <= i has in the collection
       for i in range(1 ,    lowercase_      ):
              _lowerCamelCase							:     Union[str, Any]	=		counting_arr[i] + counting_arr[i - 1]

       # create the output collection
       _lowerCamelCase							:     Dict	=		[0] * coll_len

       # place the elements in the output, respecting the original order (stable
       # sort) from end to begin, updating counting_arr
       for i in reversed(range(0 ,    lowercase_      )      ):
              _lowerCamelCase							:     Union[str, Any]	=		collection[i]
              counting_arr[collection[i] - coll_min] -= 1

       return ordered




def    __UpperCAmelCase(      lowercase_      ):
       return "".join([chr(lowercase_      ) for i in counting_sort([ord(lowercase_      ) for c in string]      )]      )


if __name__ == "__main__":
       # Test string sort
       assert counting_sort_string('thisisthestring') == "eghhiiinrsssttt"

       _lowerCamelCase			       =      input('Enter numbers separated by a comma:\n').strip()
       _lowerCamelCase			       =      [int(item) for item in user_input.split(',')]
       print(counting_sort(unsorted))

