
from dataclasses import asdict, dataclass
from typing import Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE    :      Dict          =			logging.get_logger(__name__)

# TODO Update this
_SCREAMING_SNAKE_CASE    :      Optional[int]          =			{
    'facebook/esm-1b': 'https://huggingface.co/facebook/esm-1b/resolve/main/config.json',
    # See all ESM models at https://huggingface.co/models?filter=esm
}







class  UpperCamelCase__		(    SCREAMING_SNAKE_CASE_   ):







	'''simple docstring'''
	_lowerCAmelCase							       =				"esm"





	def __init__(			self				,       UpperCamelCase__=None				,       UpperCamelCase__=None				,       UpperCamelCase__=None				,       UpperCamelCase__=768				,       UpperCamelCase__=12				,       UpperCamelCase__=12				,       UpperCamelCase__=3072				,       UpperCamelCase__=0.1				,       UpperCamelCase__=0.1				,       UpperCamelCase__=1026				,       UpperCamelCase__=0.0_2				,       UpperCamelCase__=1e-12				,       UpperCamelCase__="absolute"				,       UpperCamelCase__=True				,       UpperCamelCase__=None				,       UpperCamelCase__=False				,       UpperCamelCase__=False				,       UpperCamelCase__=None				,       UpperCamelCase__=None				,       **UpperCamelCase__				,       ):
					super().__init__(pad_token_id=UpperCamelCase__				,       mask_token_id=UpperCamelCase__				,       **UpperCamelCase__		)

					A__  :	Optional[Any]         =							vocab_size
					A__  :	int         =							hidden_size
					A__  :	List[str]         =							num_hidden_layers
					A__  :	Tuple         =							num_attention_heads
					A__  :	str         =							intermediate_size
					A__  :	List[str]         =							hidden_dropout_prob
					A__  :	Optional[Any]         =							attention_probs_dropout_prob
					A__  :	int         =							max_position_embeddings
					A__  :	List[str]         =							initializer_range
					A__  :	List[Any]         =							layer_norm_eps
					A__  :	int         =							position_embedding_type
					A__  :	Optional[Any]         =							use_cache
					A__  :	Optional[int]         =							emb_layer_norm_before
					A__  :	List[str]         =							token_dropout
					A__  :	Tuple         =							is_folding_model
					if is_folding_model:
									if esmfold_config is None:
													logger.info('''No esmfold_config supplied for folding model, using default values.'''		)
													A__  :	List[Any]         =							EsmFoldConfig()
									elif isinstance(UpperCamelCase__				,       UpperCamelCase__		):
													A__  :	Optional[int]         =							EsmFoldConfig(**UpperCamelCase__		)
									A__  :	int         =							esmfold_config
									if vocab_list is None:
													logger.warning('''No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!'''		)
													A__  :	Any         =							get_default_vocab_list()
									else:
													A__  :	Dict         =							vocab_list
					else:
									A__  :	Optional[Any]         =							None
									A__  :	Tuple         =							None
					if self.esmfold_config is not None and getattr(self.esmfold_config				,       '''use_esm_attn_map'''				,       UpperCamelCase__		):
									raise ValueError('''The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!'''		)





	def   __snake_case				(			self		):
					A__  :	Optional[int]         =							super().to_dict()
					if isinstance(self.esmfold_config				,       UpperCamelCase__		):
									A__  :	Dict         =							self.esmfold_config.to_dict()
					return output







@dataclass
class  UpperCamelCase__		:







	'''simple docstring'''
	_lowerCAmelCase							       =				None
	_lowerCAmelCase							       =				True
	_lowerCAmelCase							       =				False
	_lowerCAmelCase							       =				False
	_lowerCAmelCase							       =				False
	_lowerCAmelCase							       =				0

	_lowerCAmelCase							       =				True
	_lowerCAmelCase							       =				False

	_lowerCAmelCase							       =				128
	_lowerCAmelCase							       =				None





	def   __snake_case				(			self		):
					if self.trunk is None:
									A__  :	Tuple         =							TrunkConfig()
					elif isinstance(self.trunk				,       UpperCamelCase__		):
									A__  :	List[Any]         =							TrunkConfig(**self.trunk		)





	def   __snake_case				(			self		):
					A__  :	Optional[int]         =							asdict(self		)
					A__  :	int         =							self.trunk.to_dict()
					return output







@dataclass
class  UpperCamelCase__		:







	'''simple docstring'''
	_lowerCAmelCase							       =				48
	_lowerCAmelCase							       =				1_024
	_lowerCAmelCase							       =				128
	_lowerCAmelCase							       =				32
	_lowerCAmelCase							       =				32
	_lowerCAmelCase							       =				32
	_lowerCAmelCase							       =				0
	_lowerCAmelCase							       =				0
	_lowerCAmelCase							       =				False
	_lowerCAmelCase							       =				4
	_lowerCAmelCase							       =				128
	_lowerCAmelCase							       =				None





	def   __snake_case				(			self		):
					if self.structure_module is None:
									A__  :	str         =							StructureModuleConfig()
					elif isinstance(self.structure_module				,       UpperCamelCase__		):
									A__  :	str         =							StructureModuleConfig(**self.structure_module		)

					if self.max_recycles <= 0:
									raise ValueError(F"`max_recycles` should be positive, got {self.max_recycles}."		)
					if self.sequence_state_dim % self.sequence_state_dim != 0:
									raise ValueError(
									    '''`sequence_state_dim` should be a round multiple of `sequence_state_dim`, got'''
									    F" {self.sequence_state_dim} and {self.sequence_state_dim}."		)
					if self.pairwise_state_dim % self.pairwise_state_dim != 0:
									raise ValueError(
									    '''`pairwise_state_dim` should be a round multiple of `pairwise_state_dim`, got'''
									    F" {self.pairwise_state_dim} and {self.pairwise_state_dim}."		)

					A__  :	Tuple         =							self.sequence_state_dim // self.sequence_head_width
					A__  :	int         =							self.pairwise_state_dim // self.pairwise_head_width

					if self.sequence_state_dim != sequence_num_heads * self.sequence_head_width:
									raise ValueError(
									    '''`sequence_state_dim` should be equal to `sequence_num_heads * sequence_head_width, got'''
									    F" {self.sequence_state_dim} != {sequence_num_heads} * {self.sequence_head_width}."		)
					if self.pairwise_state_dim != pairwise_num_heads * self.pairwise_head_width:
									raise ValueError(
									    '''`pairwise_state_dim` should be equal to `pairwise_num_heads * pairwise_head_width, got'''
									    F" {self.pairwise_state_dim} != {pairwise_num_heads} * {self.pairwise_head_width}."		)
					if self.pairwise_state_dim % 2 != 0:
									raise ValueError(F"`pairwise_state_dim` should be even, got {self.pairwise_state_dim}."		)

					if self.dropout >= 0.4:
									raise ValueError(F"`dropout` should not be greater than 0.4, got {self.dropout}."		)





	def   __snake_case				(			self		):
					A__  :	List[Any]         =							asdict(self		)
					A__  :	Optional[int]         =							self.structure_module.to_dict()
					return output







@dataclass
class  UpperCamelCase__		:







	'''simple docstring'''
	_lowerCAmelCase							       =				384
	_lowerCAmelCase							       =				128
	_lowerCAmelCase							       =				16
	_lowerCAmelCase							       =				128
	_lowerCAmelCase							       =				12
	_lowerCAmelCase							       =				4
	_lowerCAmelCase							       =				8
	_lowerCAmelCase							       =				0.1
	_lowerCAmelCase							       =				8
	_lowerCAmelCase							       =				1
	_lowerCAmelCase							       =				2
	_lowerCAmelCase							       =				7
	_lowerCAmelCase							       =				10
	_lowerCAmelCase							       =				1e-8
	_lowerCAmelCase							       =				1e5





	def   __snake_case				(			self		):
					return asdict(self		)




def 				SCREAMING_SNAKE_CASE     (      ) ->       Union[str, Any]:

				"""simple docstring"""







				return (
				    "<cls>",
				    "<pad>",
				    "<eos>",
				    "<unk>",
				    "L",
				    "A",
				    "G",
				    "V",
				    "S",
				    "E",
				    "R",
				    "T",
				    "I",
				    "D",
				    "P",
				    "K",
				    "Q",
				    "N",
				    "F",
				    "Y",
				    "M",
				    "H",
				    "W",
				    "C",
				    "X",
				    "B",
				    "U",
				    "Z",
				    "O",
				    ".",
				    "-",
				    "<null_1>",
				    "<mask>",
				)

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


_SCREAMING_SNAKE_CASE    :      List[Any]          =			get_tests_dir('fixtures/dummy_feature_extractor_config.json')
_SCREAMING_SNAKE_CASE    :      int          =			get_tests_dir('fixtures/vocab.json')
_SCREAMING_SNAKE_CASE    :      Tuple          =			get_tests_dir('fixtures')







class  UpperCamelCase__		(    unittest.TestCase   ):







	'''simple docstring'''
	_lowerCAmelCase							       =				["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]





	def   __snake_case				(			self		):
					A__  :	List[Any]         =							0





	def   __snake_case				(			self		):
					A__  :	Dict         =							AutoProcessor.from_pretrained('''facebook/wav2vec2-base-960h'''		)
					self.assertIsInstance(UpperCamelCase__				,       UpperCamelCase__		)





	def   __snake_case				(			self		):
					with tempfile.TemporaryDirectory() as tmpdirname:
									A__  :	Optional[Any]         =							WavaVecaConfig()
									A__  :	Dict         =							AutoProcessor.from_pretrained('''facebook/wav2vec2-base-960h'''		)

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

									A__  :	Any         =							AutoProcessor.from_pretrained(UpperCamelCase__		)

					self.assertIsInstance(UpperCamelCase__				,       UpperCamelCase__		)





	def   __snake_case				(			self		):
					with tempfile.TemporaryDirectory() as tmpdirname:
									# copy relevant files
									copyfile(UpperCamelCase__				,       os.path.join(UpperCamelCase__				,       UpperCamelCase__		)		)
									copyfile(UpperCamelCase__				,       os.path.join(UpperCamelCase__				,       '''vocab.json'''		)		)

									A__  :	List[Any]         =							AutoProcessor.from_pretrained(UpperCamelCase__		)

					self.assertIsInstance(UpperCamelCase__				,       UpperCamelCase__		)





	def   __snake_case				(			self		):
					with tempfile.TemporaryDirectory() as tmpdirname:
									A__  :	Dict         =							WavaVecaFeatureExtractor()
									A__  :	Union[str, Any]         =							AutoTokenizer.from_pretrained('''facebook/wav2vec2-base-960h'''		)

									A__  :	Optional[int]         =							WavaVecaProcessor(UpperCamelCase__				,       UpperCamelCase__		)

									# save in new folder
									processor.save_pretrained(UpperCamelCase__		)

									# drop `processor_class` in tokenizer
									with open(os.path.join(UpperCamelCase__				,       UpperCamelCase__		)				,       '''r'''		) as f:
													A__  :	str         =							json.load(UpperCamelCase__		)
													config_dict.pop('''processor_class'''		)

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

									A__  :	Optional[int]         =							AutoProcessor.from_pretrained(UpperCamelCase__		)

					self.assertIsInstance(UpperCamelCase__				,       UpperCamelCase__		)





	def   __snake_case				(			self		):
					with tempfile.TemporaryDirectory() as tmpdirname:
									A__  :	Optional[int]         =							WavaVecaFeatureExtractor()
									A__  :	List[Any]         =							AutoTokenizer.from_pretrained('''facebook/wav2vec2-base-960h'''		)

									A__  :	str         =							WavaVecaProcessor(UpperCamelCase__				,       UpperCamelCase__		)

									# save in new folder
									processor.save_pretrained(UpperCamelCase__		)

									# drop `processor_class` in feature extractor
									with open(os.path.join(UpperCamelCase__				,       UpperCamelCase__		)				,       '''r'''		) as f:
													A__  :	List[Any]         =							json.load(UpperCamelCase__		)
													config_dict.pop('''processor_class'''		)

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

									A__  :	List[Any]         =							AutoProcessor.from_pretrained(UpperCamelCase__		)

					self.assertIsInstance(UpperCamelCase__				,       UpperCamelCase__		)





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

									A__  :	Union[str, Any]         =							AutoProcessor.from_pretrained(UpperCamelCase__		)

					self.assertIsInstance(UpperCamelCase__				,       UpperCamelCase__		)





	def   __snake_case				(			self		):
					# If remote code is not set, we will time out when asking whether to load the model.
					with self.assertRaises(UpperCamelCase__		):
									A__  :	Union[str, Any]         =							AutoProcessor.from_pretrained('''hf-internal-testing/test_dynamic_processor'''		)
					# If remote code is disabled, we can't load this config.
					with self.assertRaises(UpperCamelCase__		):
									A__  :	str         =							AutoProcessor.from_pretrained(
									    '''hf-internal-testing/test_dynamic_processor'''				,       trust_remote_code=UpperCamelCase__		)

					A__  :	int         =							AutoProcessor.from_pretrained('''hf-internal-testing/test_dynamic_processor'''				,       trust_remote_code=UpperCamelCase__		)
					self.assertTrue(processor.special_attribute_present		)
					self.assertEqual(processor.__class__.__name__				,       '''NewProcessor'''		)

					A__  :	List[Any]         =							processor.feature_extractor
					self.assertTrue(feature_extractor.special_attribute_present		)
					self.assertEqual(feature_extractor.__class__.__name__				,       '''NewFeatureExtractor'''		)

					A__  :	List[Any]         =							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
									A__  :	Dict         =							AutoProcessor.from_pretrained(
									    '''hf-internal-testing/test_dynamic_processor'''				,       trust_remote_code=UpperCamelCase__				,       use_fast=UpperCamelCase__		)
									A__  :	int         =							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   __snake_case				(			self		):
					try:
									AutoConfig.register('''custom'''				,       UpperCamelCase__		)
									AutoFeatureExtractor.register(UpperCamelCase__				,       UpperCamelCase__		)
									AutoTokenizer.register(UpperCamelCase__				,       slow_tokenizer_class=UpperCamelCase__		)
									AutoProcessor.register(UpperCamelCase__				,       UpperCamelCase__		)
									# Trying to register something existing in the Transformers library will raise an error
									with self.assertRaises(UpperCamelCase__		):
													AutoProcessor.register(UpperCamelCase__				,       UpperCamelCase__		)

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

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

									A__  :	Optional[Any]         =							CustomProcessor(UpperCamelCase__				,       UpperCamelCase__		)

									with tempfile.TemporaryDirectory() as tmp_dir:
													processor.save_pretrained(UpperCamelCase__		)
													A__  :	Union[str, Any]         =							AutoProcessor.from_pretrained(UpperCamelCase__		)
													self.assertIsInstance(UpperCamelCase__				,       UpperCamelCase__		)

					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   __snake_case				(			self		):







					class  UpperCamelCase__		(    SCREAMING_SNAKE_CASE_   ):







						'''simple docstring'''
						_lowerCAmelCase							       =				False







					class  UpperCamelCase__		(    SCREAMING_SNAKE_CASE_   ):







						'''simple docstring'''
						_lowerCAmelCase							       =				False







					class  UpperCamelCase__		(    SCREAMING_SNAKE_CASE_   ):







						'''simple docstring'''
						_lowerCAmelCase							       =				"AutoFeatureExtractor"
						_lowerCAmelCase							       =				"AutoTokenizer"
						_lowerCAmelCase							       =				False

					try:
									AutoConfig.register('''custom'''				,       UpperCamelCase__		)
									AutoFeatureExtractor.register(UpperCamelCase__				,       UpperCamelCase__		)
									AutoTokenizer.register(UpperCamelCase__				,       slow_tokenizer_class=UpperCamelCase__		)
									AutoProcessor.register(UpperCamelCase__				,       UpperCamelCase__		)
									# If remote code is not set, the default is to use local classes.
									A__  :	List[Any]         =							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.
									A__  :	Any         =							AutoProcessor.from_pretrained(
									    '''hf-internal-testing/test_dynamic_processor'''				,       trust_remote_code=UpperCamelCase__		)
									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.
									A__  :	Union[str, Any]         =							AutoProcessor.from_pretrained(
									    '''hf-internal-testing/test_dynamic_processor'''				,       trust_remote_code=UpperCamelCase__		)
									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   __snake_case				(			self		):
					A__  :	str         =							AutoProcessor.from_pretrained('''hf-internal-testing/tiny-random-bert'''		)
					self.assertEqual(processor.__class__.__name__				,       '''BertTokenizerFast'''		)





	def   __snake_case				(			self		):
					A__  :	Union[str, Any]         =							AutoProcessor.from_pretrained('''hf-internal-testing/tiny-random-convnext'''		)
					self.assertEqual(processor.__class__.__name__				,       '''ConvNextImageProcessor'''		)







@is_staging_test
class  UpperCamelCase__		(    unittest.TestCase   ):







	'''simple docstring'''
	_lowerCAmelCase							       =				["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]





	@classmethod
	def   __snake_case				(			cls		):
					A__  :	List[str]         =							TOKEN
					HfFolder.save_token(UpperCamelCase__		)





	@classmethod
	def   __snake_case				(			cls		):
					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   __snake_case				(			self		):
					A__  :	Optional[Any]         =							WavaVecaProcessor.from_pretrained(UpperCamelCase__		)
					with tempfile.TemporaryDirectory() as tmp_dir:
									processor.save_pretrained(
									    os.path.join(UpperCamelCase__				,       '''test-processor'''		)				,       push_to_hub=UpperCamelCase__				,       use_auth_token=self._token		)

									A__  :	List[Any]         =							WavaVecaProcessor.from_pretrained(F"{USER}/test-processor"		)
									for k, v in processor.feature_extractor.__dict__.items():
													self.assertEqual(UpperCamelCase__				,       getattr(new_processor.feature_extractor				,       UpperCamelCase__		)		)
									self.assertDictEqual(new_processor.tokenizer.get_vocab()				,       processor.tokenizer.get_vocab()		)





	def   __snake_case				(			self		):
					A__  :	int         =							WavaVecaProcessor.from_pretrained(UpperCamelCase__		)

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

									A__  :	List[str]         =							WavaVecaProcessor.from_pretrained('''valid_org/test-processor-org'''		)
									for k, v in processor.feature_extractor.__dict__.items():
													self.assertEqual(UpperCamelCase__				,       getattr(new_processor.feature_extractor				,       UpperCamelCase__		)		)
									self.assertDictEqual(new_processor.tokenizer.get_vocab()				,       processor.tokenizer.get_vocab()		)





	def   __snake_case				(			self		):
					CustomFeatureExtractor.register_for_auto_class()
					CustomTokenizer.register_for_auto_class()
					CustomProcessor.register_for_auto_class()

					A__  :	Optional[Any]         =							CustomFeatureExtractor.from_pretrained(UpperCamelCase__		)

					with tempfile.TemporaryDirectory() as tmp_dir:
									A__  :	List[Any]         =							os.path.join(UpperCamelCase__				,       '''vocab.txt'''		)
									with open(UpperCamelCase__				,       '''w'''				,       encoding='''utf-8'''		) as vocab_writer:
													vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens]		)		)
									A__  :	Union[str, Any]         =							CustomTokenizer(UpperCamelCase__		)

					A__  :	List[Any]         =							CustomProcessor(UpperCamelCase__				,       UpperCamelCase__		)

					with tempfile.TemporaryDirectory() as tmp_dir:
									create_repo(F"{USER}/test-dynamic-processor"				,       token=self._token		)
									A__  :	Union[str, Any]         =							Repository(UpperCamelCase__				,       clone_from=F"{USER}/test-dynamic-processor"				,       token=self._token		)
									processor.save_pretrained(UpperCamelCase__		)

									# 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(UpperCamelCase__				,       '''tokenizer_config.json'''		)		) as f:
													A__  :	Optional[int]         =							json.load(UpperCamelCase__		)
									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(UpperCamelCase__				,       '''custom_feature_extraction.py'''		)		)		)
									self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__				,       '''custom_tokenization.py'''		)		)		)
									self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__				,       '''custom_processing.py'''		)		)		)

									repo.push_to_hub()

					A__  :	Tuple         =							AutoProcessor.from_pretrained(F"{USER}/test-dynamic-processor"				,       trust_remote_code=UpperCamelCase__		)
					# 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'''		)