
"""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			:			List[str]			):
       _snake_case					     =       0







     @slow
     def      lowercase	(							self			:			Tuple			):
       for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
         _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase			)
         self.assertIsNotNone(_lowerCamelCase			)
         self.assertIsInstance(_lowerCamelCase    ,      (BertTokenizer, BertTokenizerFast)			)
         self.assertGreater(len(_lowerCamelCase			)    ,      0			)

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







     def      lowercase	(							self			:			Union[str, Any]			):
       _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase			)
       self.assertIsInstance(_lowerCamelCase    ,      (BertTokenizer, BertTokenizerFast)			)
       self.assertEqual(tokenizer.vocab_size    ,      12			)







     def      lowercase	(							self			:			int			):
       _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase			)
       self.assertIsInstance(_lowerCamelCase    ,      (RobertaTokenizer, RobertaTokenizerFast)			)
       self.assertEqual(tokenizer.vocab_size    ,      20			)







     def      lowercase	(							self			:			Tuple			):
       _snake_case					     =       AutoConfig.from_pretrained(_lowerCamelCase			)
       self.assertIsInstance(_lowerCamelCase    ,      _lowerCamelCase			)
       # Check that tokenizer_type ≠ model_type
       _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase    ,      config=_lowerCamelCase			)
       self.assertIsInstance(_lowerCamelCase    ,      (BertTokenizer, BertTokenizerFast)			)
       self.assertEqual(tokenizer.vocab_size    ,      12			)







     def      lowercase	(							self			:			Tuple			):
       with tempfile.TemporaryDirectory() as tmp_dir:
         shutil.copy('''./tests/fixtures/vocab.txt'''    ,      os.path.join(_lowerCamelCase    ,      '''vocab.txt'''			)			)

         _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase    ,      tokenizer_type='''bert'''    ,      use_fast=_lowerCamelCase			)
         self.assertIsInstance(_lowerCamelCase    ,      _lowerCamelCase			)

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

         _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase    ,      tokenizer_type='''gpt2'''    ,      use_fast=_lowerCamelCase			)
         self.assertIsInstance(_lowerCamelCase    ,      _lowerCamelCase			)







     @require_tokenizers
     def      lowercase	(							self			:			Dict			):
       with tempfile.TemporaryDirectory() as tmp_dir:
         shutil.copy('''./tests/fixtures/vocab.txt'''    ,      os.path.join(_lowerCamelCase    ,      '''vocab.txt'''			)			)

         _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase    ,      tokenizer_type='''bert'''			)
         self.assertIsInstance(_lowerCamelCase    ,      _lowerCamelCase			)

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

         _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase    ,      tokenizer_type='''gpt2'''			)
         self.assertIsInstance(_lowerCamelCase    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]			):
       with pytest.raises(_lowerCamelCase			):
         AutoTokenizer.from_pretrained('''./'''    ,      tokenizer_type='''xxx'''			)







     @require_tokenizers
     def      lowercase	(							self			:			Optional[Any]			):
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
         _snake_case					     =       tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased'''			)
         self.assertIsInstance(_lowerCamelCase    ,      (BertTokenizer, BertTokenizerFast)			)

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

         self.assertEqual(tokenizer.model_max_length    ,      512			)







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







     def      lowercase	(							self			:			Dict			):
       # 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
       _snake_case					     =       TOKENIZER_MAPPING.values()
       _snake_case					     =       []

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







     @require_tokenizers
     def      lowercase	(							self			:			Dict			):
       self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''    ,      use_fast=_lowerCamelCase			)    ,      _lowerCamelCase			)
       self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''			)    ,      _lowerCamelCase			)







     @require_tokenizers
     def      lowercase	(							self			:			Optional[int]			):
       _snake_case					     =       AutoTokenizer.from_pretrained('''distilbert-base-uncased'''    ,      do_lower_case=_lowerCamelCase			)
       _snake_case					     =       '''Hello, world. How are you?'''
       _snake_case					     =       tokenizer.tokenize(_lowerCamelCase			)
       self.assertEqual('''[UNK]'''    ,      tokens[0]			)

       _snake_case					     =       AutoTokenizer.from_pretrained('''microsoft/mpnet-base'''    ,      do_lower_case=_lowerCamelCase			)
       _snake_case					     =       tokenizer.tokenize(_lowerCamelCase			)
       self.assertEqual('''[UNK]'''    ,      tokens[0]			)







     @require_tokenizers
     def      lowercase	(							self			:			Optional[Any]			):
       _snake_case					     =       AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config'''			)
       self.assertEqual(type(_lowerCamelCase			)    ,      _lowerCamelCase			)
       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      lowercase	(							self			:			Optional[int]			):
       _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase			)
       self.assertIsInstance(_lowerCamelCase    ,      (BertTokenizer, BertTokenizerFast)			)
       with tempfile.TemporaryDirectory() as tmp_dir:
         tokenizer.save_pretrained(_lowerCamelCase			)
         _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase			)

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







     def      lowercase	(							self			:			Union[str, Any]			):
       _snake_case					     =       AutoTokenizer.from_pretrained('''ctrl'''			)
       # There is no fast CTRL so this always gives us a slow tokenizer.
       self.assertIsInstance(_lowerCamelCase    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]			):
       # Check we can load the tokenizer config of an online model.
       _snake_case					     =       get_tokenizer_config('''bert-base-cased'''			)
       _snake_case					     =       config.pop('''_commit_hash'''    ,      _lowerCamelCase			)
       # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
       self.assertEqual(_lowerCamelCase    ,      {'''do_lower_case''': False}			)

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

       # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
       _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase			)
       with tempfile.TemporaryDirectory() as tmp_dir:
         tokenizer.save_pretrained(_lowerCamelCase			)
         _snake_case					     =       get_tokenizer_config(_lowerCamelCase			)

       # 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]			):
       try:
         AutoConfig.register('''custom'''    ,      _lowerCamelCase			)

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

         _snake_case					     =       CustomTokenizer.from_pretrained(_lowerCamelCase			)
         with tempfile.TemporaryDirectory() as tmp_dir:
           tokenizer.save_pretrained(_lowerCamelCase			)

           _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase			)
           self.assertIsInstance(_lowerCamelCase    ,      _lowerCamelCase			)

       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			:			List[Any]			):
       try:
         AutoConfig.register('''custom'''    ,      _lowerCamelCase			)

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

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

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

         # 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:
           _snake_case					     =       BertTokenizerFast.from_pretrained(_lowerCamelCase			)
           bert_tokenizer.save_pretrained(_lowerCamelCase			)
           _snake_case					     =       CustomTokenizerFast.from_pretrained(_lowerCamelCase			)

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

           _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase			)
           self.assertIsInstance(_lowerCamelCase    ,      _lowerCamelCase			)

           _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase    ,      use_fast=_lowerCamelCase			)
           self.assertIsInstance(_lowerCamelCase    ,      _lowerCamelCase			)

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

       _snake_case					     =       AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''    ,      trust_remote_code=_lowerCamelCase			)
       self.assertTrue(tokenizer.special_attribute_present			)
       # Test tokenizer can be reloaded.
       with tempfile.TemporaryDirectory() as tmp_dir:
         tokenizer.save_pretrained(_lowerCamelCase			)
         _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase    ,      trust_remote_code=_lowerCamelCase			)
       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
         _snake_case					     =       AutoTokenizer.from_pretrained(
             '''hf-internal-testing/test_dynamic_tokenizer'''    ,      trust_remote_code=_lowerCamelCase    ,      use_fast=_lowerCamelCase			)
         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(_lowerCamelCase			)
           _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase    ,      trust_remote_code=_lowerCamelCase    ,      use_fast=_lowerCamelCase			)
         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			:			int			):

       class       lowerCAmelCase__				(						A_	):
            __a						=					False






       class       lowerCAmelCase__				(						A_	):
            __a						=					NewTokenizer
            __a						=					False

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

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

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

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







     def      lowercase	(							self			:			Optional[int]			):
       with self.assertRaisesRegex(
           _lowerCamelCase    ,      '''bert-base is not a local folder and is not a valid model identifier'''			):
         _snake_case					     =       AutoTokenizer.from_pretrained('''bert-base'''			)







     def      lowercase	(							self			:			str			):
       with self.assertRaisesRegex(
           _lowerCamelCase    ,      R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''			):
         _snake_case					     =       AutoTokenizer.from_pretrained(_lowerCamelCase    ,      revision='''aaaaaa'''			)







     def      lowercase	(							self			:			Tuple			):
       # Make sure we have cached the tokenizer.
       _snake_case					     =       AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''			)
       with RequestCounter() as counter:
         _snake_case					     =       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"""



from math import sqrt
def 					_UpperCAmelCase      ( __lowerCamelCase   :       int = 1_00_00_00		)     ->					int:
  _snake_case					     =       0
  _snake_case					     =       0
  _snake_case					     =       42

  while num_cuboids <= limit:
    max_cuboid_size += 1
    for sum_shortest_sides in range(2 ,					2 * max_cuboid_size + 1		):
      if sqrt(sum_shortest_sides**2 + max_cuboid_size**2		).is_integer():
        num_cuboids += (
            min(__lowerCamelCase ,					sum_shortest_sides // 2		)
            - max(1 ,					sum_shortest_sides - max_cuboid_size		)
            + 1
        )

  return max_cuboid_size


if __name__ == "__main__":
 print(F"{solution() = }")



