



'''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


snake_case_					:      Union[str, Any]    			=    get_tests_dir('fixtures/dummy_feature_extractor_config.json')
snake_case_					:      Union[str, Any]    			=    get_tests_dir('fixtures/vocab.json')
snake_case_					:      List[Any]    			=    get_tests_dir('fixtures')






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





	def       UpperCamelCase_    (					self   :							Dict					):







							'''simple docstring'''
							_UpperCamelCase   :						str												=  0





	def       UpperCamelCase_    (					self   :							str					):







							'''simple docstring'''
							_UpperCamelCase   :						List[str]												=  AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'					)
							self.assertIsInstance(lowerCamelCase__					,lowerCamelCase__					)





	def       UpperCamelCase_    (					self   :							List[str]					):







							'''simple docstring'''
							with tempfile.TemporaryDirectory() as tmpdirname:
													_UpperCamelCase   :						List[str]												=  WavaVecaConfig()
													_UpperCamelCase   :						Optional[int]												=  AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'					)

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

													_UpperCamelCase   :						Optional[int]												=  AutoProcessor.from_pretrained(lowerCamelCase__					)

							self.assertIsInstance(lowerCamelCase__					,lowerCamelCase__					)





	def       UpperCamelCase_    (					self   :							Dict					):







							'''simple docstring'''
							with tempfile.TemporaryDirectory() as tmpdirname:
													# copy relevant files
													copyfile(lowerCamelCase__					,os.path.join(lowerCamelCase__					,lowerCamelCase__					)					)
													copyfile(lowerCamelCase__					,os.path.join(lowerCamelCase__					,'vocab.json'					)					)

													_UpperCamelCase   :						int												=  AutoProcessor.from_pretrained(lowerCamelCase__					)

							self.assertIsInstance(lowerCamelCase__					,lowerCamelCase__					)





	def       UpperCamelCase_    (					self   :							str					):







							'''simple docstring'''
							with tempfile.TemporaryDirectory() as tmpdirname:
													_UpperCamelCase   :						Any												=  WavaVecaFeatureExtractor()
													_UpperCamelCase   :						Tuple												=  AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h'					)

													_UpperCamelCase   :						Optional[Any]												=  WavaVecaProcessor(lowerCamelCase__					,lowerCamelCase__					)

													# save in new folder
													processor.save_pretrained(lowerCamelCase__					)

													# drop `processor_class` in tokenizer
													with open(os.path.join(lowerCamelCase__					,lowerCamelCase__					)					,'r'					) as f:
																			_UpperCamelCase   :						Optional[Any]												=  json.load(lowerCamelCase__					)
																			config_dict.pop('processor_class'					)

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

													_UpperCamelCase   :						Optional[Any]												=  AutoProcessor.from_pretrained(lowerCamelCase__					)

							self.assertIsInstance(lowerCamelCase__					,lowerCamelCase__					)





	def       UpperCamelCase_    (					self   :							Optional[int]					):







							'''simple docstring'''
							with tempfile.TemporaryDirectory() as tmpdirname:
													_UpperCamelCase   :						Union[str, Any]												=  WavaVecaFeatureExtractor()
													_UpperCamelCase   :						str												=  AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h'					)

													_UpperCamelCase   :						Any												=  WavaVecaProcessor(lowerCamelCase__					,lowerCamelCase__					)

													# save in new folder
													processor.save_pretrained(lowerCamelCase__					)

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

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

													_UpperCamelCase   :						str												=  AutoProcessor.from_pretrained(lowerCamelCase__					)

							self.assertIsInstance(lowerCamelCase__					,lowerCamelCase__					)





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







							'''simple docstring'''
							with tempfile.TemporaryDirectory() as tmpdirname:
													_UpperCamelCase   :						List[Any]												=  WavaVecaConfig(processor_class='Wav2Vec2Processor'					)
													model_config.save_pretrained(lowerCamelCase__					)
													# copy relevant files
													copyfile(lowerCamelCase__					,os.path.join(lowerCamelCase__					,'vocab.json'					)					)
													# create emtpy sample processor
													with open(os.path.join(lowerCamelCase__					,lowerCamelCase__					)					,'w'					) as f:
																			f.write('{}'					)

													_UpperCamelCase   :						Any												=  AutoProcessor.from_pretrained(lowerCamelCase__					)

							self.assertIsInstance(lowerCamelCase__					,lowerCamelCase__					)





	def       UpperCamelCase_    (					self   :							Optional[int]					):







							'''simple docstring'''
							# If remote code is not set, we will time out when asking whether to load the model.
							with self.assertRaises(lowerCamelCase__					):
													_UpperCamelCase   :						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(lowerCamelCase__					):
													_UpperCamelCase   :						Dict												=  AutoProcessor.from_pretrained(
													    'hf-internal-testing/test_dynamic_processor'					,trust_remote_code=lowerCamelCase__					)

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

							_UpperCamelCase   :						Optional[int]												=  processor.feature_extractor
							self.assertTrue(feature_extractor.special_attribute_present					)
							self.assertEqual(feature_extractor.__class__.__name__					,'NewFeatureExtractor'					)

							_UpperCamelCase   :						Dict												=  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
													_UpperCamelCase   :						List[Any]												=  AutoProcessor.from_pretrained(
													    'hf-internal-testing/test_dynamic_processor'					,trust_remote_code=lowerCamelCase__					,use_fast=lowerCamelCase__					)
													_UpperCamelCase   :						Union[str, Any]												=  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       UpperCamelCase_    (					self   :							List[str]					):







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

													# Now that the config is registered, it can be used as any other config with the auto-API
													_UpperCamelCase   :						Union[str, Any]												=  CustomFeatureExtractor.from_pretrained(lowerCamelCase__					)

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

													_UpperCamelCase   :						str												=  CustomProcessor(lowerCamelCase__					,lowerCamelCase__					)

													with tempfile.TemporaryDirectory() as tmp_dir:
																			processor.save_pretrained(lowerCamelCase__					)
																			_UpperCamelCase   :						Any												=  AutoProcessor.from_pretrained(lowerCamelCase__					)
																			self.assertIsInstance(lowerCamelCase__					,lowerCamelCase__					)

							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       UpperCamelCase_    (					self   :							Optional[Any]					):







							'''simple docstring'''






							class 				lowercase__      (				lowercase  ):
								lowercase__    							=     False






							class 				lowercase__      (				lowercase  ):
								lowercase__    							=     False






							class 				lowercase__      (				lowercase  ):
								lowercase__    							=     """AutoFeatureExtractor"""
								lowercase__    							=     """AutoTokenizer"""
								lowercase__    							=     False

							try:
													AutoConfig.register('custom'					,lowerCamelCase__					)
													AutoFeatureExtractor.register(lowerCamelCase__					,lowerCamelCase__					)
													AutoTokenizer.register(lowerCamelCase__					,slow_tokenizer_class=lowerCamelCase__					)
													AutoProcessor.register(lowerCamelCase__					,lowerCamelCase__					)
													# If remote code is not set, the default is to use local classes.
													_UpperCamelCase   :						Union[str, 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.
													_UpperCamelCase   :						List[Any]												=  AutoProcessor.from_pretrained(
													    'hf-internal-testing/test_dynamic_processor'					,trust_remote_code=lowerCamelCase__					)
													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.
													_UpperCamelCase   :						Dict												=  AutoProcessor.from_pretrained(
													    'hf-internal-testing/test_dynamic_processor'					,trust_remote_code=lowerCamelCase__					)
													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       UpperCamelCase_    (					self   :							Any					):







							'''simple docstring'''
							_UpperCamelCase   :						Tuple												=  AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-bert'					)
							self.assertEqual(processor.__class__.__name__					,'BertTokenizerFast'					)





	def       UpperCamelCase_    (					self   :							Optional[int]					):







							'''simple docstring'''
							_UpperCamelCase   :						int												=  AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-convnext'					)
							self.assertEqual(processor.__class__.__name__					,'ConvNextImageProcessor'					)






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





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







							'''simple docstring'''
							_UpperCamelCase   :						List[str]												=  TOKEN
							HfFolder.save_token(lowerCamelCase__					)





	@classmethod
	def       UpperCamelCase_    (					cls   :							Union[str, Any]					):







							'''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       UpperCamelCase_    (					self   :							List[Any]					):







							'''simple docstring'''
							_UpperCamelCase   :						str												=  WavaVecaProcessor.from_pretrained(lowerCamelCase__					)
							with tempfile.TemporaryDirectory() as tmp_dir:
													processor.save_pretrained(
													    os.path.join(lowerCamelCase__					,'test-processor'					)					,push_to_hub=lowerCamelCase__					,use_auth_token=self._token					)

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





	def       UpperCamelCase_    (					self   :							Tuple					):







							'''simple docstring'''
							_UpperCamelCase   :						str												=  WavaVecaProcessor.from_pretrained(lowerCamelCase__					)

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

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





	def       UpperCamelCase_    (					self   :							Optional[int]					):







							'''simple docstring'''
							CustomFeatureExtractor.register_for_auto_class()
							CustomTokenizer.register_for_auto_class()
							CustomProcessor.register_for_auto_class()

							_UpperCamelCase   :						Any												=  CustomFeatureExtractor.from_pretrained(lowerCamelCase__					)

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

							_UpperCamelCase   :						Tuple												=  CustomProcessor(lowerCamelCase__					,lowerCamelCase__					)

							with tempfile.TemporaryDirectory() as tmp_dir:
													create_repo(F'{USER}/test-dynamic-processor'					,token=self._token					)
													_UpperCamelCase   :						Optional[Any]												=  Repository(lowerCamelCase__					,clone_from=F'{USER}/test-dynamic-processor'					,token=self._token					)
													processor.save_pretrained(lowerCamelCase__					)

													# 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(lowerCamelCase__					,'tokenizer_config.json'					)					) as f:
																			_UpperCamelCase   :						Union[str, Any]												=  json.load(lowerCamelCase__					)
													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(lowerCamelCase__					,'custom_feature_extraction.py'					)					)					)
													self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__					,'custom_tokenization.py'					)					)					)
													self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__					,'custom_processing.py'					)					)					)

													repo.push_to_hub()

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







'''simple docstring'''
def A__       (	UpperCAmelCase_    ,    UpperCAmelCase_				):
						return int((input_a, input_a).count(0				) != 0				)






def A__       (	):
						assert nand_gate(0    ,    0				) == 1
						assert nand_gate(0    ,    1				) == 1
						assert nand_gate(1    ,    0				) == 1
						assert nand_gate(1    ,    1				) == 0


if __name__ == "__main__":
					print(nand_gate(0, 0))
					print(nand_gate(0, 1))
					print(nand_gate(1, 0))
					print(nand_gate(1, 1))


