






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			):







		'''simple docstring'''



		def 					__UpperCAmelCase			(							self   )	->							int:
							UpperCAmelCase_    :      int            =						0



		@slow
		def 					__UpperCAmelCase			(							self   )	->							List[Any]:
							for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
												UpperCAmelCase_    :      Optional[int]            =						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():
												UpperCAmelCase_    :      int            =						AutoTokenizer.from_pretrained(_UpperCamelCase   )
												self.assertIsNotNone(_UpperCamelCase   )
												self.assertIsInstance(_UpperCamelCase				,		(GPTaTokenizer, GPTaTokenizerFast)   )
												self.assertGreater(len(_UpperCamelCase   )				,		0   )



		def 					__UpperCAmelCase			(							self   )	->							Tuple:
							UpperCAmelCase_    :      Tuple            =						AutoTokenizer.from_pretrained(_UpperCamelCase   )
							self.assertIsInstance(_UpperCamelCase				,		(BertTokenizer, BertTokenizerFast)   )
							self.assertEqual(tokenizer.vocab_size				,		1_2   )



		def 					__UpperCAmelCase			(							self   )	->							Any:
							UpperCAmelCase_    :      Tuple            =						AutoTokenizer.from_pretrained(_UpperCamelCase   )
							self.assertIsInstance(_UpperCamelCase				,		(RobertaTokenizer, RobertaTokenizerFast)   )
							self.assertEqual(tokenizer.vocab_size				,		2_0   )



		def 					__UpperCAmelCase			(							self   )	->							Union[str, Any]:
							UpperCAmelCase_    :      List[Any]            =						AutoConfig.from_pretrained(_UpperCamelCase   )
							self.assertIsInstance(_UpperCamelCase				,		_UpperCamelCase   )
							# Check that tokenizer_type ≠ model_type
							UpperCAmelCase_    :      List[str]            =						AutoTokenizer.from_pretrained(_UpperCamelCase				,		config=_UpperCamelCase   )
							self.assertIsInstance(_UpperCamelCase				,		(BertTokenizer, BertTokenizerFast)   )
							self.assertEqual(tokenizer.vocab_size				,		1_2   )



		def 					__UpperCAmelCase			(							self   )	->							int:
							with tempfile.TemporaryDirectory() as tmp_dir:
												shutil.copy('./tests/fixtures/vocab.txt'				,		os.path.join(_UpperCamelCase				,		'vocab.txt'   )   )

												UpperCAmelCase_    :      int            =						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'   )   )

												UpperCAmelCase_    :      Union[str, Any]            =						AutoTokenizer.from_pretrained(_UpperCamelCase				,		tokenizer_type='gpt2'				,		use_fast=_UpperCamelCase   )
												self.assertIsInstance(_UpperCamelCase				,		_UpperCamelCase   )



		@require_tokenizers
		def 					__UpperCAmelCase			(							self   )	->							Any:
							with tempfile.TemporaryDirectory() as tmp_dir:
												shutil.copy('./tests/fixtures/vocab.txt'				,		os.path.join(_UpperCamelCase				,		'vocab.txt'   )   )

												UpperCAmelCase_    :      Optional[Any]            =						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'   )   )

												UpperCAmelCase_    :      Dict            =						AutoTokenizer.from_pretrained(_UpperCamelCase				,		tokenizer_type='gpt2'   )
												self.assertIsInstance(_UpperCamelCase				,		_UpperCamelCase   )



		def 					__UpperCAmelCase			(							self   )	->							List[str]:
							with pytest.raises(_UpperCamelCase   ):
												AutoTokenizer.from_pretrained('./'				,		tokenizer_type='xxx'   )



		@require_tokenizers
		def 					__UpperCAmelCase			(							self   )	->							Optional[Any]:
							for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
												UpperCAmelCase_    :      Tuple            =						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				,		5_1_2   )



		@require_tokenizers
		def 					__UpperCAmelCase			(							self   )	->							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'				,		):
																	UpperCAmelCase_    :      Tuple            =						tokenizer_class.from_pretrained('julien-c/herlolip-not-exists'   )



		def 					__UpperCAmelCase			(							self   )	->							int:
							# 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
							UpperCAmelCase_    :      Dict            =						TOKENIZER_MAPPING.values()
							UpperCAmelCase_    :      Union[str, 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 					__UpperCAmelCase			(							self   )	->							List[str]:
							self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'				,		use_fast=_UpperCamelCase   )				,		_UpperCamelCase   )
							self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'   )				,		_UpperCamelCase   )



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

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



		@require_tokenizers
		def 					__UpperCAmelCase			(							self   )	->							Optional[int]:
							UpperCAmelCase_    :      Optional[int]            =						AutoTokenizer.from_pretrained('robot-test/dummy-tokenizer-fast-with-model-config'   )
							self.assertEqual(type(_UpperCamelCase   )				,		_UpperCamelCase   )
							self.assertEqual(tokenizer.model_max_length				,		5_1_2   )
							self.assertEqual(tokenizer.vocab_size				,		3_0_0_0_0   )
							self.assertEqual(tokenizer.unk_token				,		'[UNK]'   )
							self.assertEqual(tokenizer.padding_side				,		'right'   )
							self.assertEqual(tokenizer.truncation_side				,		'right'   )



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

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



		def 					__UpperCAmelCase			(							self   )	->							List[Any]:
							UpperCAmelCase_    :      str            =						AutoTokenizer.from_pretrained('ctrl'   )
							# There is no fast CTRL so this always gives us a slow tokenizer.
							self.assertIsInstance(_UpperCamelCase				,		_UpperCamelCase   )



		def 					__UpperCAmelCase			(							self   )	->							List[str]:
							# Check we can load the tokenizer config of an online model.
							UpperCAmelCase_    :      int            =						get_tokenizer_config('bert-base-cased'   )
							UpperCAmelCase_    :      Optional[Any]            =						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.
							UpperCAmelCase_    :      Optional[int]            =						get_tokenizer_config(_UpperCamelCase   )
							self.assertDictEqual(_UpperCamelCase				,		{}   )

							# A tokenizer saved with `save_pretrained` always creates a tokenizer config.
							UpperCAmelCase_    :      List[Any]            =						AutoTokenizer.from_pretrained(_UpperCamelCase   )
							with tempfile.TemporaryDirectory() as tmp_dir:
												tokenizer.save_pretrained(_UpperCamelCase   )
												UpperCAmelCase_    :      Tuple            =						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 					__UpperCAmelCase			(							self   )	->							Union[str, Any]:
							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   )

												UpperCAmelCase_    :      int            =						CustomTokenizer.from_pretrained(_UpperCamelCase   )
												with tempfile.TemporaryDirectory() as tmp_dir:
																	tokenizer.save_pretrained(_UpperCamelCase   )

																	UpperCAmelCase_    :      Union[str, 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 					__UpperCAmelCase			(							self   )	->							Any:
							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:
																	UpperCAmelCase_    :      Any            =						BertTokenizerFast.from_pretrained(_UpperCamelCase   )
																	bert_tokenizer.save_pretrained(_UpperCamelCase   )
																	UpperCAmelCase_    :      Dict            =						CustomTokenizerFast.from_pretrained(_UpperCamelCase   )

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

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

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

							UpperCAmelCase_    :      Tuple            =						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   )
												UpperCAmelCase_    :      str            =						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
												UpperCAmelCase_    :      int            =						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   )
																	UpperCAmelCase_    :      int            =						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 					__UpperCAmelCase			(							self   )	->							Optional[Any]:



							class   lowerCamelCase      (_snake_case			):







									'''simple docstring'''



									_snake_case    :    Any       						=  False





							class   lowerCamelCase      (_snake_case			):







									'''simple docstring'''



									_snake_case    :    Tuple       						=  NewTokenizer
									_snake_case    :    int       						=  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
												UpperCAmelCase_    :      Tuple            =						AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'   )
												self.assertEqual(tokenizer.__class__.__name__				,		'NewTokenizerFast'   )
												self.assertFalse(tokenizer.special_attribute_present   )
												UpperCAmelCase_    :      Dict            =						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.
												UpperCAmelCase_    :      str            =						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   )
												UpperCAmelCase_    :      str            =						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
												UpperCAmelCase_    :      Dict            =						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   )
												UpperCAmelCase_    :      int            =						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 					__UpperCAmelCase			(							self   )	->							Optional[int]:
							UpperCAmelCase_    :      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
												UpperCAmelCase_    :      int            =						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 					__UpperCAmelCase			(							self   )	->							Dict:
							with self.assertRaisesRegex(
							    _UpperCamelCase				,		'bert-base is not a local folder and is not a valid model identifier'   ):
												UpperCAmelCase_    :      Any            =						AutoTokenizer.from_pretrained('bert-base'   )



		def 					__UpperCAmelCase			(							self   )	->							str:
							with self.assertRaisesRegex(
							    _UpperCamelCase				,		r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'   ):
												UpperCAmelCase_    :      Dict            =						AutoTokenizer.from_pretrained(_UpperCamelCase				,		revision='aaaaaa'   )



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


					'''simple docstring'''


					UpperCAmelCase_    :      list[list[int]]            =						[[0 for _ in range(__snake_case  )] for _ in range(m + 1  )]
					for i in range(m + 1  ):
										UpperCAmelCase_    :      Optional[Any]            =						1

					for n in range(m + 1  ):
										for k in range(1     ,       __snake_case  ):
															memo[n][k] += memo[n][k - 1]
															if n - k > 0:
																				memo[n][k] += memo[n - k - 1][k]

					return memo[m][m - 1]


if __name__ == "__main__":
		import sys

		if len(sys.argv) == 1:
				try:
						__UpperCAmelCase								=						int(input('Enter a number: ').strip())
						print(partition(n))
				except ValueError:
						print('Please enter a number.')
		else:
				try:
						__UpperCAmelCase								=						int(sys.argv[1])
						print(partition(n))
				except ValueError:
						print('Please pass a number.')






