


'''simple docstring'''
import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
  from test_module.custom_tokenization_fast import CustomTokenizerFast




class      lowerCamelCase_  (      unittest.TestCase ):






      def lowercase_				(   self							:       int					):


          '''simple docstring'''


          UpperCAmelCase__     :						Optional[int]						=							0






      @slow
      def lowercase_				(   self							:       Any					):


          '''simple docstring'''


          for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
              UpperCAmelCase__     :						Any						=							AutoTokenizer.from_pretrained(__snake_case					)
              self.assertIsNotNone(__snake_case					)
              self.assertIsInstance(__snake_case		,		(BertTokenizer, BertTokenizerFast)					)
              self.assertGreater(len(__snake_case					)		,		0					)

          for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
              UpperCAmelCase__     :						Any						=							AutoTokenizer.from_pretrained(__snake_case					)
              self.assertIsNotNone(__snake_case					)
              self.assertIsInstance(__snake_case		,		(GPTaTokenizer, GPTaTokenizerFast)					)
              self.assertGreater(len(__snake_case					)		,		0					)






      def lowercase_				(   self							:       List[Any]					):


          '''simple docstring'''


          UpperCAmelCase__     :						str						=							AutoTokenizer.from_pretrained(__snake_case					)
          self.assertIsInstance(__snake_case		,		(BertTokenizer, BertTokenizerFast)					)
          self.assertEqual(tokenizer.vocab_size		,		12					)






      def lowercase_				(   self							:       List[str]					):


          '''simple docstring'''


          UpperCAmelCase__     :						List[str]						=							AutoTokenizer.from_pretrained(__snake_case					)
          self.assertIsInstance(__snake_case		,		(RobertaTokenizer, RobertaTokenizerFast)					)
          self.assertEqual(tokenizer.vocab_size		,		20					)






      def lowercase_				(   self							:       Any					):


          '''simple docstring'''


          UpperCAmelCase__     :						str						=							AutoConfig.from_pretrained(__snake_case					)
          self.assertIsInstance(__snake_case		,		__snake_case					)
          # Check that tokenizer_type ≠ model_type
          UpperCAmelCase__     :						Optional[int]						=							AutoTokenizer.from_pretrained(__snake_case		,		config=__snake_case					)
          self.assertIsInstance(__snake_case		,		(BertTokenizer, BertTokenizerFast)					)
          self.assertEqual(tokenizer.vocab_size		,		12					)






      def lowercase_				(   self							:       Tuple					):


          '''simple docstring'''


          with tempfile.TemporaryDirectory() as tmp_dir:
              shutil.copy('''./tests/fixtures/vocab.txt'''		,		os.path.join(__snake_case		,		'''vocab.txt'''					)					)

              UpperCAmelCase__     :						int						=							AutoTokenizer.from_pretrained(__snake_case		,		tokenizer_type='''bert'''		,		use_fast=__snake_case					)
              self.assertIsInstance(__snake_case		,		__snake_case					)

          with tempfile.TemporaryDirectory() as tmp_dir:
              shutil.copy('''./tests/fixtures/vocab.json'''		,		os.path.join(__snake_case		,		'''vocab.json'''					)					)
              shutil.copy('''./tests/fixtures/merges.txt'''		,		os.path.join(__snake_case		,		'''merges.txt'''					)					)

              UpperCAmelCase__     :						int						=							AutoTokenizer.from_pretrained(__snake_case		,		tokenizer_type='''gpt2'''		,		use_fast=__snake_case					)
              self.assertIsInstance(__snake_case		,		__snake_case					)






      @require_tokenizers
      def lowercase_				(   self							:       Union[str, Any]					):


          '''simple docstring'''


          with tempfile.TemporaryDirectory() as tmp_dir:
              shutil.copy('''./tests/fixtures/vocab.txt'''		,		os.path.join(__snake_case		,		'''vocab.txt'''					)					)

              UpperCAmelCase__     :						Dict						=							AutoTokenizer.from_pretrained(__snake_case		,		tokenizer_type='''bert'''					)
              self.assertIsInstance(__snake_case		,		__snake_case					)

          with tempfile.TemporaryDirectory() as tmp_dir:
              shutil.copy('''./tests/fixtures/vocab.json'''		,		os.path.join(__snake_case		,		'''vocab.json'''					)					)
              shutil.copy('''./tests/fixtures/merges.txt'''		,		os.path.join(__snake_case		,		'''merges.txt'''					)					)

              UpperCAmelCase__     :						Union[str, Any]						=							AutoTokenizer.from_pretrained(__snake_case		,		tokenizer_type='''gpt2'''					)
              self.assertIsInstance(__snake_case		,		__snake_case					)






      def lowercase_				(   self							:       Union[str, Any]					):


          '''simple docstring'''


          with pytest.raises(__snake_case					):
              AutoTokenizer.from_pretrained('''./'''		,		tokenizer_type='''xxx'''					)






      @require_tokenizers
      def lowercase_				(   self							:       int					):


          '''simple docstring'''


          for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
              UpperCAmelCase__     :						str						=							tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased'''					)
              self.assertIsInstance(__snake_case		,		(BertTokenizer, BertTokenizerFast)					)

              if isinstance(__snake_case		,		__snake_case					):
                  self.assertEqual(tokenizer.basic_tokenizer.do_lower_case		,		__snake_case					)
              else:
                  self.assertEqual(tokenizer.do_lower_case		,		__snake_case					)

              self.assertEqual(tokenizer.model_max_length		,		512					)






      @require_tokenizers
      def lowercase_				(   self							:       Optional[Any]					):


          '''simple docstring'''


          for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
              with self.assertRaisesRegex(
                  __snake_case		,		'''julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'''		,		):
                  UpperCAmelCase__     :						Union[str, Any]						=							tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists'''					)






      def lowercase_				(   self							:       Tuple					):


          '''simple docstring'''


          UpperCAmelCase__     :						str						=							TOKENIZER_MAPPING.values()
          UpperCAmelCase__     :						List[str]						=							[]

          for slow_tok, fast_tok in tokenizers:
              if slow_tok is not None:
                  tokenizer_names.append(slow_tok.__name__					)

              if fast_tok is not None:
                  tokenizer_names.append(fast_tok.__name__					)

          for tokenizer_name in tokenizer_names:
              # must find the right class
              tokenizer_class_from_name(__snake_case					)






      @require_tokenizers
      def lowercase_				(   self							:       Dict					):


          '''simple docstring'''


          self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''		,		use_fast=__snake_case					)		,		__snake_case					)
          self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''					)		,		__snake_case					)






      @require_tokenizers
      def lowercase_				(   self							:       Tuple					):


          '''simple docstring'''


          UpperCAmelCase__     :						List[str]						=							AutoTokenizer.from_pretrained('''distilbert-base-uncased'''		,		do_lower_case=__snake_case					)
          UpperCAmelCase__     :						str						=							'''Hello, world. How are you?'''
          UpperCAmelCase__     :						Optional[int]						=							tokenizer.tokenize(__snake_case					)
          self.assertEqual('''[UNK]'''		,		tokens[0]					)

          UpperCAmelCase__     :						Dict						=							AutoTokenizer.from_pretrained('''microsoft/mpnet-base'''		,		do_lower_case=__snake_case					)
          UpperCAmelCase__     :						Dict						=							tokenizer.tokenize(__snake_case					)
          self.assertEqual('''[UNK]'''		,		tokens[0]					)






      @require_tokenizers
      def lowercase_				(   self							:       List[str]					):


          '''simple docstring'''


          UpperCAmelCase__     :						Union[str, Any]						=							AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config'''					)
          self.assertEqual(type(__snake_case					)		,		__snake_case					)
          self.assertEqual(tokenizer.model_max_length		,		512					)
          self.assertEqual(tokenizer.vocab_size		,		30_000					)
          self.assertEqual(tokenizer.unk_token		,		'''[UNK]'''					)
          self.assertEqual(tokenizer.padding_side		,		'''right'''					)
          self.assertEqual(tokenizer.truncation_side		,		'''right'''					)






      def lowercase_				(   self							:       Dict					):


          '''simple docstring'''


          UpperCAmelCase__     :						Tuple						=							AutoTokenizer.from_pretrained(__snake_case					)
          self.assertIsInstance(__snake_case		,		(BertTokenizer, BertTokenizerFast)					)
          with tempfile.TemporaryDirectory() as tmp_dir:
              tokenizer.save_pretrained(__snake_case					)
              UpperCAmelCase__     :						Any						=							AutoTokenizer.from_pretrained(__snake_case					)

          self.assertIsInstance(__snake_case		,		tokenizer.__class__					)
          self.assertEqual(tokenizera.vocab_size		,		12					)






      def lowercase_				(   self							:       Union[str, Any]					):


          '''simple docstring'''


          UpperCAmelCase__     :						Tuple						=							AutoTokenizer.from_pretrained('''ctrl'''					)
          # There is no fast CTRL so this always gives us a slow tokenizer.
          self.assertIsInstance(__snake_case		,		__snake_case					)






      def lowercase_				(   self							:       Union[str, Any]					):


          '''simple docstring'''


          UpperCAmelCase__     :						Any						=							get_tokenizer_config('''bert-base-cased'''					)
          UpperCAmelCase__     :						Dict						=							config.pop('''_commit_hash'''		,		__snake_case					)
          # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
          self.assertEqual(__snake_case		,		{'''do_lower_case''': False}					)

          # This model does not have a tokenizer_config so we get back an empty dict.
          UpperCAmelCase__     :						int						=							get_tokenizer_config(__snake_case					)
          self.assertDictEqual(__snake_case		,		{}					)

          # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
          UpperCAmelCase__     :						Union[str, Any]						=							AutoTokenizer.from_pretrained(__snake_case					)
          with tempfile.TemporaryDirectory() as tmp_dir:
              tokenizer.save_pretrained(__snake_case					)
              UpperCAmelCase__     :						Dict						=							get_tokenizer_config(__snake_case					)

          # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
          self.assertEqual(config['''tokenizer_class''']		,		'''BertTokenizer'''					)






      def lowercase_				(   self							:       List[str]					):


          '''simple docstring'''


          try:
              AutoConfig.register('''custom'''		,		__snake_case					)

              AutoTokenizer.register(__snake_case		,		slow_tokenizer_class=__snake_case					)
              # Trying to register something existing in the Transformers library will raise an error
              with self.assertRaises(__snake_case					):
                  AutoTokenizer.register(__snake_case		,		slow_tokenizer_class=__snake_case					)

              UpperCAmelCase__     :						List[Any]						=							CustomTokenizer.from_pretrained(__snake_case					)
              with tempfile.TemporaryDirectory() as tmp_dir:
                  tokenizer.save_pretrained(__snake_case					)

                  UpperCAmelCase__     :						Union[str, Any]						=							AutoTokenizer.from_pretrained(__snake_case					)
                  self.assertIsInstance(__snake_case		,		__snake_case					)

          finally:
              if "custom" in CONFIG_MAPPING._extra_content:
                  del CONFIG_MAPPING._extra_content["custom"]
              if CustomConfig in TOKENIZER_MAPPING._extra_content:
                  del TOKENIZER_MAPPING._extra_content[CustomConfig]






      @require_tokenizers
      def lowercase_				(   self							:       str					):


          '''simple docstring'''


          try:
              AutoConfig.register('''custom'''		,		__snake_case					)

              # Can register in two steps
              AutoTokenizer.register(__snake_case		,		slow_tokenizer_class=__snake_case					)
              self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,		(CustomTokenizer, None)					)
              AutoTokenizer.register(__snake_case		,		fast_tokenizer_class=__snake_case					)
              self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,		(CustomTokenizer, CustomTokenizerFast)					)

              del TOKENIZER_MAPPING._extra_content[CustomConfig]
              # Can register in one step
              AutoTokenizer.register(
                  __snake_case		,		slow_tokenizer_class=__snake_case		,		fast_tokenizer_class=__snake_case					)
              self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,		(CustomTokenizer, CustomTokenizerFast)					)

              # Trying to register something existing in the Transformers library will raise an error
              with self.assertRaises(__snake_case					):
                  AutoTokenizer.register(__snake_case		,		fast_tokenizer_class=__snake_case					)

              # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
              # and that model does not have a tokenizer.json
              with tempfile.TemporaryDirectory() as tmp_dir:
                  UpperCAmelCase__     :						Tuple						=							BertTokenizerFast.from_pretrained(__snake_case					)
                  bert_tokenizer.save_pretrained(__snake_case					)
                  UpperCAmelCase__     :						Dict						=							CustomTokenizerFast.from_pretrained(__snake_case					)

              with tempfile.TemporaryDirectory() as tmp_dir:
                  tokenizer.save_pretrained(__snake_case					)

                  UpperCAmelCase__     :						Optional[Any]						=							AutoTokenizer.from_pretrained(__snake_case					)
                  self.assertIsInstance(__snake_case		,		__snake_case					)

                  UpperCAmelCase__     :						Any						=							AutoTokenizer.from_pretrained(__snake_case		,		use_fast=__snake_case					)
                  self.assertIsInstance(__snake_case		,		__snake_case					)

          finally:
              if "custom" in CONFIG_MAPPING._extra_content:
                  del CONFIG_MAPPING._extra_content["custom"]
              if CustomConfig in TOKENIZER_MAPPING._extra_content:
                  del TOKENIZER_MAPPING._extra_content[CustomConfig]






      def lowercase_				(   self							:       List[str]					):


          '''simple docstring'''


          with self.assertRaises(__snake_case					):
              UpperCAmelCase__     :						int						=							AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''					)
          # If remote code is disabled, we can't load this config.
          with self.assertRaises(__snake_case					):
              UpperCAmelCase__     :						List[Any]						=							AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer'''		,		trust_remote_code=__snake_case					)

          UpperCAmelCase__     :						Tuple						=							AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''		,		trust_remote_code=__snake_case					)
          self.assertTrue(tokenizer.special_attribute_present					)
          # Test tokenizer can be reloaded.
          with tempfile.TemporaryDirectory() as tmp_dir:
              tokenizer.save_pretrained(__snake_case					)
              UpperCAmelCase__     :						Union[str, Any]						=							AutoTokenizer.from_pretrained(__snake_case		,		trust_remote_code=__snake_case					)
          self.assertTrue(reloaded_tokenizer.special_attribute_present					)

          if is_tokenizers_available():
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizerFast'''					)
              self.assertEqual(reloaded_tokenizer.__class__.__name__		,		'''NewTokenizerFast'''					)

              # Test we can also load the slow version
              UpperCAmelCase__     :						Optional[Any]						=							AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer'''		,		trust_remote_code=__snake_case		,		use_fast=__snake_case					)
              self.assertTrue(tokenizer.special_attribute_present					)
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizer'''					)
              # Test tokenizer can be reloaded.
              with tempfile.TemporaryDirectory() as tmp_dir:
                  tokenizer.save_pretrained(__snake_case					)
                  UpperCAmelCase__     :						Union[str, Any]						=							AutoTokenizer.from_pretrained(__snake_case		,		trust_remote_code=__snake_case		,		use_fast=__snake_case					)
              self.assertEqual(reloaded_tokenizer.__class__.__name__		,		'''NewTokenizer'''					)
              self.assertTrue(reloaded_tokenizer.special_attribute_present					)
          else:
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizer'''					)
              self.assertEqual(reloaded_tokenizer.__class__.__name__		,		'''NewTokenizer'''					)






      @require_tokenizers
      def lowercase_				(   self							:       str					):


          '''simple docstring'''


          class      lowerCamelCase_  (      _SCREAMING_SNAKE_CASE ):
                lowerCAmelCase__							=	False




          class      lowerCamelCase_  (      _SCREAMING_SNAKE_CASE ):
                lowerCAmelCase__							=	NewTokenizer
                lowerCAmelCase__							=	False

          try:
              AutoConfig.register('''custom'''		,		__snake_case					)
              AutoTokenizer.register(__snake_case		,		slow_tokenizer_class=__snake_case					)
              AutoTokenizer.register(__snake_case		,		fast_tokenizer_class=__snake_case					)
              # If remote code is not set, the default is to use local
              UpperCAmelCase__     :						List[Any]						=							AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''					)
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizerFast'''					)
              self.assertFalse(tokenizer.special_attribute_present					)
              UpperCAmelCase__     :						Union[str, Any]						=							AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''		,		use_fast=__snake_case					)
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizer'''					)
              self.assertFalse(tokenizer.special_attribute_present					)

              # If remote code is disabled, we load the local one.
              UpperCAmelCase__     :						int						=							AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer'''		,		trust_remote_code=__snake_case					)
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizerFast'''					)
              self.assertFalse(tokenizer.special_attribute_present					)
              UpperCAmelCase__     :						str						=							AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer'''		,		trust_remote_code=__snake_case		,		use_fast=__snake_case					)
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizer'''					)
              self.assertFalse(tokenizer.special_attribute_present					)

              # If remote is enabled, we load from the Hub
              UpperCAmelCase__     :						Optional[int]						=							AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer'''		,		trust_remote_code=__snake_case					)
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizerFast'''					)
              self.assertTrue(tokenizer.special_attribute_present					)
              UpperCAmelCase__     :						Any						=							AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer'''		,		trust_remote_code=__snake_case		,		use_fast=__snake_case					)
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizer'''					)
              self.assertTrue(tokenizer.special_attribute_present					)

          finally:
              if "custom" in CONFIG_MAPPING._extra_content:
                  del CONFIG_MAPPING._extra_content["custom"]
              if CustomConfig in TOKENIZER_MAPPING._extra_content:
                  del TOKENIZER_MAPPING._extra_content[CustomConfig]






      def lowercase_				(   self							:       Dict					):


          '''simple docstring'''


          UpperCAmelCase__     :						str						=							AutoTokenizer.from_pretrained(
              '''hf-internal-testing/test_dynamic_tokenizer_legacy'''		,		trust_remote_code=__snake_case					)
          self.assertTrue(tokenizer.special_attribute_present					)
          if is_tokenizers_available():
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizerFast'''					)

              # Test we can also load the slow version
              UpperCAmelCase__     :						Dict						=							AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer_legacy'''		,		trust_remote_code=__snake_case		,		use_fast=__snake_case					)
              self.assertTrue(tokenizer.special_attribute_present					)
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizer'''					)
          else:
              self.assertEqual(tokenizer.__class__.__name__		,		'''NewTokenizer'''					)






      def lowercase_				(   self							:       str					):


          '''simple docstring'''


          with self.assertRaisesRegex(
              __snake_case		,		'''bert-base is not a local folder and is not a valid model identifier'''					):
              UpperCAmelCase__     :						int						=							AutoTokenizer.from_pretrained('''bert-base'''					)






      def lowercase_				(   self							:       Optional[Any]					):


          '''simple docstring'''


          with self.assertRaisesRegex(
              __snake_case		,		R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''					):
              UpperCAmelCase__     :						Tuple						=							AutoTokenizer.from_pretrained(__snake_case		,		revision='''aaaaaa'''					)






      def lowercase_				(   self							:       Optional[int]					):


          '''simple docstring'''


          UpperCAmelCase__     :						Optional[Any]						=							AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''					)
          with RequestCounter() as counter:
              UpperCAmelCase__     :						Any						=							AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''					)
              self.assertEqual(counter.get_request_count		,		0					)
              self.assertEqual(counter.head_request_count		,		1					)
              self.assertEqual(counter.other_request_count		,		0					)







def      UpperCAmelCase_    (    _UpperCAmelCase							:list				)	->				list:
     '''simple docstring'''


     if len(_UpperCAmelCase				) < 2:
          return collection

     def circle_sort_util(_UpperCAmelCase							:list  ,						_UpperCAmelCase							:int  ,						_UpperCAmelCase							:int				) -> bool:
          A_          =       False

          if low == high:
               return swapped

          A_          =       low
          A_          =       high

          while left < right:
               if collection[left] > collection[right]:
                    A_   ,    A_          =       (
                        collection[right],
                        collection[left],
                    )
                    A_          =       True

               left += 1
               right -= 1

          if left == right and collection[left] > collection[right + 1]:
               A_   ,    A_          =       (
                   collection[right + 1],
                   collection[left],
               )

               A_          =       True

          A_          =       low + int((high - low) / 2				)
          A_          =       circle_sort_util(_UpperCAmelCase  ,						_UpperCAmelCase  ,						_UpperCAmelCase				)
          A_          =       circle_sort_util(_UpperCAmelCase  ,						mid + 1  ,						_UpperCAmelCase				)

          return swapped or left_swap or right_swap

     A_          =       True

     while is_not_sorted is True:
          A_          =       circle_sort_util(_UpperCAmelCase  ,						0  ,						len(_UpperCAmelCase				) - 1				)

     return collection


if __name__ == "__main__":
      a__      :     Optional[Any]         =		input('Enter numbers separated by a comma:\n').strip()
      a__      :     List[str]         =		[int(item) for item in user_input.split(',')]
      print(circle_sort(unsorted))



