




'''simple docstring'''

import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from huggingface_hub import HfFolder, Repository, create_repo, delete_repo
from requests.exceptions import HTTPError

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoProcessor,
    AutoTokenizer,
    BertTokenizer,
    ProcessorMixin,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
)
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test
from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available


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

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402
from test_module.custom_processing import CustomProcessor  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


a       :						Optional[Any]								=		get_tests_dir('''fixtures/dummy_feature_extractor_config.json''')
a       :						Optional[Any]								=		get_tests_dir('''fixtures/vocab.json''')
a       :						Optional[int]								=		get_tests_dir('''fixtures''')



class 		SCREAMING_SNAKE_CASE__  (			unittest.TestCase	):
			__SCREAMING_SNAKE_CASE    =			["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""]





			def 							A (      self						:    Dict							):



						"""simple docstring"""




						__snake_case			=		0





			def 							A (      self						:    Optional[int]							):



						"""simple docstring"""




						__snake_case			=		AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h"							)
						self.assertIsInstance(a_      ,		a_							)





			def 							A (      self						:    Optional[Any]							):



						"""simple docstring"""




						with tempfile.TemporaryDirectory() as tmpdirname:
									__snake_case			=		WavaVecaConfig()
									__snake_case			=		AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h"							)

									# save in new folder
									model_config.save_pretrained(a_							)
									processor.save_pretrained(a_							)

									__snake_case			=		AutoProcessor.from_pretrained(a_							)

						self.assertIsInstance(a_      ,		a_							)





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



						"""simple docstring"""




						with tempfile.TemporaryDirectory() as tmpdirname:
									# copy relevant files
									copyfile(a_      ,		os.path.join(a_      ,		a_							)							)
									copyfile(a_      ,		os.path.join(a_      ,		"vocab.json"							)							)

									__snake_case			=		AutoProcessor.from_pretrained(a_							)

						self.assertIsInstance(a_      ,		a_							)





			def 							A (      self						:    List[str]							):



						"""simple docstring"""




						with tempfile.TemporaryDirectory() as tmpdirname:
									__snake_case			=		WavaVecaFeatureExtractor()
									__snake_case			=		AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h"							)

									__snake_case			=		WavaVecaProcessor(a_      ,		a_							)

									# save in new folder
									processor.save_pretrained(a_							)

									# drop `processor_class` in tokenizer
									with open(os.path.join(a_      ,		a_							)      ,		"r"							) as f:
												__snake_case			=		json.load(a_							)
												config_dict.pop("processor_class"							)

									with open(os.path.join(a_      ,		a_							)      ,		"w"							) as f:
												f.write(json.dumps(a_							)							)

									__snake_case			=		AutoProcessor.from_pretrained(a_							)

						self.assertIsInstance(a_      ,		a_							)





			def 							A (      self						:    Optional[Any]							):



						"""simple docstring"""




						with tempfile.TemporaryDirectory() as tmpdirname:
									__snake_case			=		WavaVecaFeatureExtractor()
									__snake_case			=		AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h"							)

									__snake_case			=		WavaVecaProcessor(a_      ,		a_							)

									# save in new folder
									processor.save_pretrained(a_							)

									# drop `processor_class` in feature extractor
									with open(os.path.join(a_      ,		a_							)      ,		"r"							) as f:
												__snake_case			=		json.load(a_							)
												config_dict.pop("processor_class"							)

									with open(os.path.join(a_      ,		a_							)      ,		"w"							) as f:
												f.write(json.dumps(a_							)							)

									__snake_case			=		AutoProcessor.from_pretrained(a_							)

						self.assertIsInstance(a_      ,		a_							)





			def 							A (      self						:    Optional[Any]							):



						"""simple docstring"""




						with tempfile.TemporaryDirectory() as tmpdirname:
									__snake_case			=		WavaVecaConfig(processor_class="Wav2Vec2Processor"							)
									model_config.save_pretrained(a_							)
									# copy relevant files
									copyfile(a_      ,		os.path.join(a_      ,		"vocab.json"							)							)
									# create emtpy sample processor
									with open(os.path.join(a_      ,		a_							)      ,		"w"							) as f:
												f.write("{}"							)

									__snake_case			=		AutoProcessor.from_pretrained(a_							)

						self.assertIsInstance(a_      ,		a_							)





			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




						with self.assertRaises(a_							):
									__snake_case			=		AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"							)
						# If remote code is disabled, we can't load this config.
						with self.assertRaises(a_							):
									__snake_case			=		AutoProcessor.from_pretrained(
									    "hf-internal-testing/test_dynamic_processor"      ,		trust_remote_code=a_							)

						__snake_case			=		AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"      ,		trust_remote_code=a_							)
						self.assertTrue(processor.special_attribute_present							)
						self.assertEqual(processor.__class__.__name__      ,		"NewProcessor"							)

						__snake_case			=		processor.feature_extractor
						self.assertTrue(feature_extractor.special_attribute_present							)
						self.assertEqual(feature_extractor.__class__.__name__      ,		"NewFeatureExtractor"							)

						__snake_case			=		processor.tokenizer
						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			=		AutoProcessor.from_pretrained(
									    "hf-internal-testing/test_dynamic_processor"      ,		trust_remote_code=a_      ,		use_fast=a_							)
									__snake_case			=		new_processor.tokenizer
									self.assertTrue(new_tokenizer.special_attribute_present							)
									self.assertEqual(new_tokenizer.__class__.__name__      ,		"NewTokenizer"							)
						else:
									self.assertEqual(tokenizer.__class__.__name__      ,		"NewTokenizer"							)





			def 							A (      self						:    List[str]							):



						"""simple docstring"""




						try:
									AutoConfig.register("custom"      ,		a_							)
									AutoFeatureExtractor.register(a_      ,		a_							)
									AutoTokenizer.register(a_      ,		slow_tokenizer_class=a_							)
									AutoProcessor.register(a_      ,		a_							)
									# Trying to register something existing in the Transformers library will raise an error
									with self.assertRaises(a_							):
												AutoProcessor.register(a_      ,		a_							)

									# Now that the config is registered, it can be used as any other config with the auto-API
									__snake_case			=		CustomFeatureExtractor.from_pretrained(a_							)

									with tempfile.TemporaryDirectory() as tmp_dir:
												__snake_case			=		os.path.join(a_      ,		"vocab.txt"							)
												with open(a_      ,		"w"      ,		encoding="utf-8"							) as vocab_writer:
															vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]							)							)
												__snake_case			=		CustomTokenizer(a_							)

									__snake_case			=		CustomProcessor(a_      ,		a_							)

									with tempfile.TemporaryDirectory() as tmp_dir:
												processor.save_pretrained(a_							)
												__snake_case			=		AutoProcessor.from_pretrained(a_							)
												self.assertIsInstance(a_      ,		a_							)

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





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



						"""simple docstring"""




						class 		SCREAMING_SNAKE_CASE__  (			_UpperCamelCase	):
									__SCREAMING_SNAKE_CASE    =			False







						class 		SCREAMING_SNAKE_CASE__  (			_UpperCamelCase	):
									__SCREAMING_SNAKE_CASE    =			False







						class 		SCREAMING_SNAKE_CASE__  (			_UpperCamelCase	):
									__SCREAMING_SNAKE_CASE    =			"""AutoFeatureExtractor"""
									__SCREAMING_SNAKE_CASE    =			"""AutoTokenizer"""
									__SCREAMING_SNAKE_CASE    =			False

						try:
									AutoConfig.register("custom"      ,		a_							)
									AutoFeatureExtractor.register(a_      ,		a_							)
									AutoTokenizer.register(a_      ,		slow_tokenizer_class=a_							)
									AutoProcessor.register(a_      ,		a_							)
									# If remote code is not set, the default is to use local classes.
									__snake_case			=		AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"							)
									self.assertEqual(processor.__class__.__name__      ,		"NewProcessor"							)
									self.assertFalse(processor.special_attribute_present							)
									self.assertFalse(processor.feature_extractor.special_attribute_present							)
									self.assertFalse(processor.tokenizer.special_attribute_present							)

									# If remote code is disabled, we load the local ones.
									__snake_case			=		AutoProcessor.from_pretrained(
									    "hf-internal-testing/test_dynamic_processor"      ,		trust_remote_code=a_							)
									self.assertEqual(processor.__class__.__name__      ,		"NewProcessor"							)
									self.assertFalse(processor.special_attribute_present							)
									self.assertFalse(processor.feature_extractor.special_attribute_present							)
									self.assertFalse(processor.tokenizer.special_attribute_present							)

									# If remote is enabled, we load from the Hub.
									__snake_case			=		AutoProcessor.from_pretrained(
									    "hf-internal-testing/test_dynamic_processor"      ,		trust_remote_code=a_							)
									self.assertEqual(processor.__class__.__name__      ,		"NewProcessor"							)
									self.assertTrue(processor.special_attribute_present							)
									self.assertTrue(processor.feature_extractor.special_attribute_present							)
									self.assertTrue(processor.tokenizer.special_attribute_present							)

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





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



						"""simple docstring"""




						__snake_case			=		AutoProcessor.from_pretrained("hf-internal-testing/tiny-random-bert"							)
						self.assertEqual(processor.__class__.__name__      ,		"BertTokenizerFast"							)






			def 							A (      self						:    str							):



						"""simple docstring"""




						__snake_case			=		AutoProcessor.from_pretrained("hf-internal-testing/tiny-random-convnext"							)
						self.assertEqual(processor.__class__.__name__      ,		"ConvNextImageProcessor"							)







@is_staging_test
class 		SCREAMING_SNAKE_CASE__  (			unittest.TestCase	):
			__SCREAMING_SNAKE_CASE    =			["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""]





			@classmethod
			def 							A (      cls						:    Optional[Any]							):



						"""simple docstring"""




						__snake_case			=		TOKEN
						HfFolder.save_token(a_							)





			@classmethod
			def 							A (      cls						:    str							):



						"""simple docstring"""




						try:
									delete_repo(token=cls._token      ,		repo_id="test-processor"							)
						except HTTPError:
									pass

						try:
									delete_repo(token=cls._token      ,		repo_id="valid_org/test-processor-org"							)
						except HTTPError:
									pass

						try:
									delete_repo(token=cls._token      ,		repo_id="test-dynamic-processor"							)
						except HTTPError:
									pass





			def 							A (      self						:    List[str]							):



						"""simple docstring"""




						__snake_case			=		WavaVecaProcessor.from_pretrained(a_							)
						with tempfile.TemporaryDirectory() as tmp_dir:
									processor.save_pretrained(
									    os.path.join(a_      ,		"test-processor"							)      ,		push_to_hub=a_      ,		use_auth_token=self._token							)

									__snake_case			=		WavaVecaProcessor.from_pretrained(f'''{USER}/test-processor'''							)
									for k, v in processor.feature_extractor.__dict__.items():
												self.assertEqual(a_      ,		getattr(new_processor.feature_extractor      ,		a_							)							)
									self.assertDictEqual(new_processor.tokenizer.get_vocab()      ,		processor.tokenizer.get_vocab()							)





			def 							A (      self						:    Tuple							):



						"""simple docstring"""




						__snake_case			=		WavaVecaProcessor.from_pretrained(a_							)

						with tempfile.TemporaryDirectory() as tmp_dir:
									processor.save_pretrained(
									    os.path.join(a_      ,		"test-processor-org"							)      ,		push_to_hub=a_      ,		use_auth_token=self._token      ,		organization="valid_org"      ,		)

									__snake_case			=		WavaVecaProcessor.from_pretrained("valid_org/test-processor-org"							)
									for k, v in processor.feature_extractor.__dict__.items():
												self.assertEqual(a_      ,		getattr(new_processor.feature_extractor      ,		a_							)							)
									self.assertDictEqual(new_processor.tokenizer.get_vocab()      ,		processor.tokenizer.get_vocab()							)






			def 							A (      self						:    Any							):



						"""simple docstring"""




						CustomFeatureExtractor.register_for_auto_class()
						CustomTokenizer.register_for_auto_class()
						CustomProcessor.register_for_auto_class()

						__snake_case			=		CustomFeatureExtractor.from_pretrained(a_							)

						with tempfile.TemporaryDirectory() as tmp_dir:
									__snake_case			=		os.path.join(a_      ,		"vocab.txt"							)
									with open(a_      ,		"w"      ,		encoding="utf-8"							) as vocab_writer:
												vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]							)							)
									__snake_case			=		CustomTokenizer(a_							)

						__snake_case			=		CustomProcessor(a_      ,		a_							)

						with tempfile.TemporaryDirectory() as tmp_dir:
									create_repo(f'''{USER}/test-dynamic-processor'''      ,		token=self._token							)
									__snake_case			=		Repository(a_      ,		clone_from=f'''{USER}/test-dynamic-processor'''      ,		token=self._token							)
									processor.save_pretrained(a_							)

									# This has added the proper auto_map field to the feature extractor config
									self.assertDictEqual(
									    processor.feature_extractor.auto_map      ,		{
									        "AutoFeatureExtractor": "custom_feature_extraction.CustomFeatureExtractor",
									        "AutoProcessor": "custom_processing.CustomProcessor",
									    }      ,		)

									# This has added the proper auto_map field to the tokenizer config
									with open(os.path.join(a_      ,		"tokenizer_config.json"							)							) as f:
												__snake_case			=		json.load(a_							)
									self.assertDictEqual(
									    tokenizer_config["auto_map"]      ,		{
									        "AutoTokenizer": ["custom_tokenization.CustomTokenizer", None],
									        "AutoProcessor": "custom_processing.CustomProcessor",
									    }      ,		)

									# The code has been copied from fixtures
									self.assertTrue(os.path.isfile(os.path.join(a_      ,		"custom_feature_extraction.py"							)							)							)
									self.assertTrue(os.path.isfile(os.path.join(a_      ,		"custom_tokenization.py"							)							)							)
									self.assertTrue(os.path.isfile(os.path.join(a_      ,		"custom_processing.py"							)							)							)

									repo.push_to_hub()

						__snake_case			=		AutoProcessor.from_pretrained(f'''{USER}/test-dynamic-processor'''      ,		trust_remote_code=a_							)
						# Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module
						self.assertEqual(new_processor.__class__.__name__      ,		"CustomProcessor"							)







def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int = 10**9)   ->       int:






							'''simple docstring'''





							__UpperCamelCase      :  int       =   1
							__UpperCamelCase      :  Any       =   2

							__UpperCamelCase      :  Dict       =   0
							__UpperCamelCase      :  Any       =   0
							__UpperCamelCase      :  List[Any]       =   0
							while perimeter <= max_perimeter:
														perimeters_sum += perimeter

														prev_value += 2 * value
														value += prev_value

														__UpperCamelCase      :  Optional[int]       =   2 * value + 2 if i % 2 == 0 else 2 * value - 2
														i += 1

							return perimeters_sum


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