





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      snake_case_							(     self						:   Dict       )    ->		str:
        _a							:  List[Any]				= 0







  @slow
  def      snake_case_							(     self						:   Union[str, Any]       )    ->		int:
        for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
              _a							:  List[str]				= AutoTokenizer.from_pretrained(_UpperCamelCase       )
              self.assertIsNotNone(_UpperCamelCase       )
              self.assertIsInstance(_UpperCamelCase  ,					(BertTokenizer, BertTokenizerFast)       )
              self.assertGreater(len(_UpperCamelCase       )  ,					0       )

        for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
              _a							:  str				= AutoTokenizer.from_pretrained(_UpperCamelCase       )
              self.assertIsNotNone(_UpperCamelCase       )
              self.assertIsInstance(_UpperCamelCase  ,					(GPTaTokenizer, GPTaTokenizerFast)       )
              self.assertGreater(len(_UpperCamelCase       )  ,					0       )







  def      snake_case_							(     self						:   List[str]       )    ->		Optional[Any]:
        _a							:  Dict				= AutoTokenizer.from_pretrained(_UpperCamelCase       )
        self.assertIsInstance(_UpperCamelCase  ,					(BertTokenizer, BertTokenizerFast)       )
        self.assertEqual(tokenizer.vocab_size  ,					12       )







  def      snake_case_							(     self						:   Optional[int]       )    ->		str:
        _a							:  Any				= AutoTokenizer.from_pretrained(_UpperCamelCase       )
        self.assertIsInstance(_UpperCamelCase  ,					(RobertaTokenizer, RobertaTokenizerFast)       )
        self.assertEqual(tokenizer.vocab_size  ,					20       )







  def      snake_case_							(     self						:   Optional[int]       )    ->		List[Any]:
        _a							:  Any				= AutoConfig.from_pretrained(_UpperCamelCase       )
        self.assertIsInstance(_UpperCamelCase  ,					_UpperCamelCase       )
        # Check that tokenizer_type ≠ model_type
        _a							:  Optional[int]				= AutoTokenizer.from_pretrained(_UpperCamelCase  ,					config=_UpperCamelCase       )
        self.assertIsInstance(_UpperCamelCase  ,					(BertTokenizer, BertTokenizerFast)       )
        self.assertEqual(tokenizer.vocab_size  ,					12       )







  def      snake_case_							(     self						:   str       )    ->		List[str]:
        with tempfile.TemporaryDirectory() as tmp_dir:
              shutil.copy('''./tests/fixtures/vocab.txt'''  ,					os.path.join(_UpperCamelCase  ,					'''vocab.txt'''       )       )

              _a							:  List[Any]				= AutoTokenizer.from_pretrained(_UpperCamelCase  ,					tokenizer_type='''bert'''  ,					use_fast=_UpperCamelCase       )
              self.assertIsInstance(_UpperCamelCase  ,					_UpperCamelCase       )

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

              _a							:  Optional[int]				= AutoTokenizer.from_pretrained(_UpperCamelCase  ,					tokenizer_type='''gpt2'''  ,					use_fast=_UpperCamelCase       )
              self.assertIsInstance(_UpperCamelCase  ,					_UpperCamelCase       )







  @require_tokenizers
  def      snake_case_							(     self						:   Optional[int]       )    ->		Tuple:
        with tempfile.TemporaryDirectory() as tmp_dir:
              shutil.copy('''./tests/fixtures/vocab.txt'''  ,					os.path.join(_UpperCamelCase  ,					'''vocab.txt'''       )       )

              _a							:  List[str]				= AutoTokenizer.from_pretrained(_UpperCamelCase  ,					tokenizer_type='''bert'''       )
              self.assertIsInstance(_UpperCamelCase  ,					_UpperCamelCase       )

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

              _a							:  List[Any]				= AutoTokenizer.from_pretrained(_UpperCamelCase  ,					tokenizer_type='''gpt2'''       )
              self.assertIsInstance(_UpperCamelCase  ,					_UpperCamelCase       )







  def      snake_case_							(     self						:   Optional[Any]       )    ->		Optional[Any]:
        with pytest.raises(_UpperCamelCase       ):
              AutoTokenizer.from_pretrained('''./'''  ,					tokenizer_type='''xxx'''       )







  @require_tokenizers
  def      snake_case_							(     self						:   int       )    ->		List[str]:
        for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
              _a							:  str				= tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased'''       )
              self.assertIsInstance(_UpperCamelCase  ,					(BertTokenizer, BertTokenizerFast)       )

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

              self.assertEqual(tokenizer.model_max_length  ,					512       )







  @require_tokenizers
  def      snake_case_							(     self						:   Tuple       )    ->		Any:
        for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
              with self.assertRaisesRegex(
                  _UpperCamelCase  ,					'''julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'''  ,					):
                    _a							:  Tuple				= tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists'''       )







  def      snake_case_							(     self						:   str       )    ->		Union[str, Any]:
        # tests: https://github.com/huggingface/transformers/pull/13251
        # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
        # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
        _a							:  str				= TOKENIZER_MAPPING.values()
        _a							:  List[Any]				= []

        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(_UpperCamelCase       )







  @require_tokenizers
  def      snake_case_							(     self						:   Any       )    ->		Any:
        self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''  ,					use_fast=_UpperCamelCase       )  ,					_UpperCamelCase       )
        self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''       )  ,					_UpperCamelCase       )







  @require_tokenizers
  def      snake_case_							(     self						:   List[Any]       )    ->		Tuple:
        _a							:  str				= AutoTokenizer.from_pretrained('''distilbert-base-uncased'''  ,					do_lower_case=_UpperCamelCase       )
        _a							:  Optional[Any]				= '''Hello, world. How are you?'''
        _a							:  Optional[int]				= tokenizer.tokenize(_UpperCamelCase       )
        self.assertEqual('''[UNK]'''  ,					tokens[0]       )

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







  @require_tokenizers
  def      snake_case_							(     self						:   Any       )    ->		Optional[Any]:
        _a							:  str				= AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config'''       )
        self.assertEqual(type(_UpperCamelCase       )  ,					_UpperCamelCase       )
        self.assertEqual(tokenizer.model_max_length  ,					512       )
        self.assertEqual(tokenizer.vocab_size  ,					30000       )
        self.assertEqual(tokenizer.unk_token  ,					'''[UNK]'''       )
        self.assertEqual(tokenizer.padding_side  ,					'''right'''       )
        self.assertEqual(tokenizer.truncation_side  ,					'''right'''       )







  def      snake_case_							(     self						:   Union[str, Any]       )    ->		List[Any]:
        _a							:  List[Any]				= AutoTokenizer.from_pretrained(_UpperCamelCase       )
        self.assertIsInstance(_UpperCamelCase  ,					(BertTokenizer, BertTokenizerFast)       )
        with tempfile.TemporaryDirectory() as tmp_dir:
              tokenizer.save_pretrained(_UpperCamelCase       )
              _a							:  int				= AutoTokenizer.from_pretrained(_UpperCamelCase       )

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







  def      snake_case_							(     self						:   Tuple       )    ->		Optional[int]:
        _a							:  Any				= AutoTokenizer.from_pretrained('''ctrl'''       )
        # There is no fast CTRL so this always gives us a slow tokenizer.
        self.assertIsInstance(_UpperCamelCase  ,					_UpperCamelCase       )







  def      snake_case_							(     self						:   int       )    ->		Tuple:
        # Check we can load the tokenizer config of an online model.
        _a							:  List[Any]				= get_tokenizer_config('''bert-base-cased'''       )
        _a							:  int				= config.pop('''_commit_hash'''  ,					_UpperCamelCase       )
        # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
        self.assertEqual(_UpperCamelCase  ,					{'''do_lower_case''': False}       )

        # This model does not have a tokenizer_config so we get back an empty dict.
        _a							:  List[Any]				= get_tokenizer_config(_UpperCamelCase       )
        self.assertDictEqual(_UpperCamelCase  ,					{}       )

        # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
        _a							:  Optional[int]				= AutoTokenizer.from_pretrained(_UpperCamelCase       )
        with tempfile.TemporaryDirectory() as tmp_dir:
              tokenizer.save_pretrained(_UpperCamelCase       )
              _a							:  Dict				= get_tokenizer_config(_UpperCamelCase       )

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







  def      snake_case_							(     self						:   List[str]       )    ->		Dict:
        try:
              AutoConfig.register('''custom'''  ,					_UpperCamelCase       )

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

              _a							:  str				= CustomTokenizer.from_pretrained(_UpperCamelCase       )
              with tempfile.TemporaryDirectory() as tmp_dir:
                    tokenizer.save_pretrained(_UpperCamelCase       )

                    _a							:  List[Any]				= AutoTokenizer.from_pretrained(_UpperCamelCase       )
                    self.assertIsInstance(_UpperCamelCase  ,					_UpperCamelCase       )

        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      snake_case_							(     self						:   str       )    ->		str:
        try:
              AutoConfig.register('''custom'''  ,					_UpperCamelCase       )

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

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

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

              # 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:
                    _a							:  Dict				= BertTokenizerFast.from_pretrained(_UpperCamelCase       )
                    bert_tokenizer.save_pretrained(_UpperCamelCase       )
                    _a							:  Optional[int]				= CustomTokenizerFast.from_pretrained(_UpperCamelCase       )

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

                    _a							:  Dict				= AutoTokenizer.from_pretrained(_UpperCamelCase       )
                    self.assertIsInstance(_UpperCamelCase  ,					_UpperCamelCase       )

                    _a							:  Tuple				= AutoTokenizer.from_pretrained(_UpperCamelCase  ,					use_fast=_UpperCamelCase       )
                    self.assertIsInstance(_UpperCamelCase  ,					_UpperCamelCase       )

        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      snake_case_							(     self						:   List[str]       )    ->		List[str]:
        # If remote code is not set, we will time out when asking whether to load the model.
        with self.assertRaises(_UpperCamelCase       ):
              _a							:  Dict				= AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''       )
        # If remote code is disabled, we can't load this config.
        with self.assertRaises(_UpperCamelCase       ):
              _a							:  int				= AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer'''  ,					trust_remote_code=_UpperCamelCase       )

        _a							:  Optional[int]				= AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''  ,					trust_remote_code=_UpperCamelCase       )
        self.assertTrue(tokenizer.special_attribute_present       )
        # Test tokenizer can be reloaded.
        with tempfile.TemporaryDirectory() as tmp_dir:
              tokenizer.save_pretrained(_UpperCamelCase       )
              _a							:  Any				= AutoTokenizer.from_pretrained(_UpperCamelCase  ,					trust_remote_code=_UpperCamelCase       )
        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
              _a							:  Dict				= AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer'''  ,					trust_remote_code=_UpperCamelCase  ,					use_fast=_UpperCamelCase       )
              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(_UpperCamelCase       )
                    _a							:  Any				= AutoTokenizer.from_pretrained(_UpperCamelCase  ,					trust_remote_code=_UpperCamelCase  ,					use_fast=_UpperCamelCase       )
              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      snake_case_							(     self						:   Union[str, Any]       )    ->		Optional[Any]:


        class 			lowerCamelCase						(		SCREAMING_SNAKE_CASE  ):
          UpperCAmelCase		:       Any										=     False


        class 			lowerCamelCase						(		SCREAMING_SNAKE_CASE  ):
          UpperCAmelCase		:       Optional[Any]										=     NewTokenizer
          UpperCAmelCase		:       List[Any]										=     False

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

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

              # If remote is enabled, we load from the Hub
              _a							:  Tuple				= AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer'''  ,					trust_remote_code=_UpperCamelCase       )
              self.assertEqual(tokenizer.__class__.__name__  ,					'''NewTokenizerFast'''       )
              self.assertTrue(tokenizer.special_attribute_present       )
              _a							:  str				= AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer'''  ,					trust_remote_code=_UpperCamelCase  ,					use_fast=_UpperCamelCase       )
              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      snake_case_							(     self						:   List[Any]       )    ->		List[str]:
        _a							:  Dict				= AutoTokenizer.from_pretrained(
            '''hf-internal-testing/test_dynamic_tokenizer_legacy'''  ,					trust_remote_code=_UpperCamelCase       )
        self.assertTrue(tokenizer.special_attribute_present       )
        if is_tokenizers_available():
              self.assertEqual(tokenizer.__class__.__name__  ,					'''NewTokenizerFast'''       )

              # Test we can also load the slow version
              _a							:  List[str]				= AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer_legacy'''  ,					trust_remote_code=_UpperCamelCase  ,					use_fast=_UpperCamelCase       )
              self.assertTrue(tokenizer.special_attribute_present       )
              self.assertEqual(tokenizer.__class__.__name__  ,					'''NewTokenizer'''       )
        else:
              self.assertEqual(tokenizer.__class__.__name__  ,					'''NewTokenizer'''       )







  def      snake_case_							(     self						:   int       )    ->		List[Any]:
        with self.assertRaisesRegex(
            _UpperCamelCase  ,					'''bert-base is not a local folder and is not a valid model identifier'''       ):
              _a							:  Optional[int]				= AutoTokenizer.from_pretrained('''bert-base'''       )







  def      snake_case_							(     self						:   Union[str, Any]       )    ->		List[Any]:
        with self.assertRaisesRegex(
            _UpperCamelCase  ,					r'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''       ):
              _a							:  Optional[Any]				= AutoTokenizer.from_pretrained(_UpperCamelCase  ,					revision='''aaaaaa'''       )







  def      snake_case_							(     self						:   int       )    ->		Any:
        # Make sure we have cached the tokenizer.
        _a							:  List[str]				= AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''       )
        with RequestCounter() as counter:
              _a							:  Optional[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       )









'''simple docstring'''
def 					lowerCamelCase_ ( __UpperCamelCase					:       list							,    __UpperCamelCase					:       int							,    __UpperCamelCase					:       int = 0							,    __UpperCamelCase					:       int = 0		)					->	int:







     """simple docstring"""
     _A				=							right or len(__UpperCamelCase		) - 1
     if left > right:
          return -1
     elif list_data[left] == key:
          return left
     elif list_data[right] == key:
          return right
     else:
          return search(__UpperCamelCase							,    __UpperCamelCase							,    left + 1							,    right - 1		)


if __name__ == "__main__":
    import doctest

    doctest.testmod()





