






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      :       Tuple				  =   get_tests_dir("fixtures/dummy_feature_extractor_config.json")
__a      :       Dict				  =   get_tests_dir("fixtures/vocab.json")
__a      :       str				  =   get_tests_dir("fixtures")


class       __lowercase      (	unittest.TestCase  ):







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




					def 		lowerCAmelCase_     (				self       :			Tuple				):


									"""simple docstring"""



									__A         =	0




					def 		lowerCAmelCase_     (				self       :			List[Any]				):


									"""simple docstring"""



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




					def 		lowerCAmelCase_     (				self       :			List[Any]				):


									"""simple docstring"""



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

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

													__A         =	AutoProcessor.from_pretrained(__lowercase				)

									self.assertIsInstance(__lowercase ,	__lowercase				)




					def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


									"""simple docstring"""



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

													__A         =	AutoProcessor.from_pretrained(__lowercase				)

									self.assertIsInstance(__lowercase ,	__lowercase				)




					def 		lowerCAmelCase_     (				self       :			List[str]				):


									"""simple docstring"""



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

													__A         =	WavaVecaProcessor(__lowercase ,	__lowercase				)

													# save in new folder
													processor.save_pretrained(__lowercase				)

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

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

													__A         =	AutoProcessor.from_pretrained(__lowercase				)

									self.assertIsInstance(__lowercase ,	__lowercase				)




					def 		lowerCAmelCase_     (				self       :			Dict				):


									"""simple docstring"""



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

													__A         =	WavaVecaProcessor(__lowercase ,	__lowercase				)

													# save in new folder
													processor.save_pretrained(__lowercase				)

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

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

													__A         =	AutoProcessor.from_pretrained(__lowercase				)

									self.assertIsInstance(__lowercase ,	__lowercase				)




					def 		lowerCAmelCase_     (				self       :			Dict				):


									"""simple docstring"""



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

													__A         =	AutoProcessor.from_pretrained(__lowercase				)

									self.assertIsInstance(__lowercase ,	__lowercase				)




					def 		lowerCAmelCase_     (				self       :			List[Any]				):


									"""simple docstring"""



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

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

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

									__A         =	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         =	AutoProcessor.from_pretrained(
													    """hf-internal-testing/test_dynamic_processor""" ,	trust_remote_code=__lowercase ,	use_fast=__lowercase				)
													__A         =	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 		lowerCAmelCase_     (				self       :			int				):


									"""simple docstring"""



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

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

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

													__A         =	CustomProcessor(__lowercase ,	__lowercase				)

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

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


									"""simple docstring"""



									class       __lowercase      (	lowercase__  ):







														'''simple docstring'''
														SCREAMING_SNAKE_CASE   						=				False


									class       __lowercase      (	lowercase__  ):







														'''simple docstring'''
														SCREAMING_SNAKE_CASE   						=				False


									class       __lowercase      (	lowercase__  ):







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

									try:
													AutoConfig.register("""custom""" ,	__lowercase				)
													AutoFeatureExtractor.register(__lowercase ,	__lowercase				)
													AutoTokenizer.register(__lowercase ,	slow_tokenizer_class=__lowercase				)
													AutoProcessor.register(__lowercase ,	__lowercase				)
													# If remote code is not set, the default is to use local classes.
													__A         =	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         =	AutoProcessor.from_pretrained(
													    """hf-internal-testing/test_dynamic_processor""" ,	trust_remote_code=__lowercase				)
													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         =	AutoProcessor.from_pretrained(
													    """hf-internal-testing/test_dynamic_processor""" ,	trust_remote_code=__lowercase				)
													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 		lowerCAmelCase_     (				self       :			Optional[Any]				):


									"""simple docstring"""



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





					def 		lowerCAmelCase_     (				self       :			str				):


									"""simple docstring"""



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


@is_staging_test
class       __lowercase      (	unittest.TestCase  ):







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




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


									"""simple docstring"""



									__A         =	TOKEN
									HfFolder.save_token(__lowercase				)




					@classmethod
					def 		lowerCAmelCase_     (				cls       :			int				):


									"""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 		lowerCAmelCase_     (				self       :			Dict				):


									"""simple docstring"""



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

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




					def 		lowerCAmelCase_     (				self       :			Tuple				):


									"""simple docstring"""



									__A         =	WavaVecaProcessor.from_pretrained(__lowercase				)

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

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





					def 		lowerCAmelCase_     (				self       :			List[Any]				):


									"""simple docstring"""



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

									__A         =	CustomFeatureExtractor.from_pretrained(__lowercase				)

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

									__A         =	CustomProcessor(__lowercase ,	__lowercase				)

									with tempfile.TemporaryDirectory() as tmp_dir:
													create_repo(F"{USER}/test-dynamic-processor" ,	token=self._token				)
													__A         =	Repository(__lowercase ,	clone_from=F"{USER}/test-dynamic-processor" ,	token=self._token				)
													processor.save_pretrained(__lowercase				)

													# 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(__lowercase ,	"""tokenizer_config.json"""				)				) as f:
																	__A         =	json.load(__lowercase				)
													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(__lowercase ,	"""custom_feature_extraction.py"""				)				)				)
													self.assertTrue(os.path.isfile(os.path.join(__lowercase ,	"""custom_tokenization.py"""				)				)				)
													self.assertTrue(os.path.isfile(os.path.join(__lowercase ,	"""custom_processing.py"""				)				)				)

													repo.push_to_hub()

									__A         =	AutoProcessor.from_pretrained(F"{USER}/test-dynamic-processor" ,	trust_remote_code=__lowercase				)
									# 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"""				)












from collections.abc import Sequence



def 			_SCREAMING_SNAKE_CASE						( __lowercase   :			Sequence[float]			,				__lowercase   :			float    )						->      float:





    """simple docstring"""

    return sum(c * (x**i) for i, c in enumerate(__lowercase    )    )



def 			_SCREAMING_SNAKE_CASE						( __lowercase   :			Sequence[float]			,				__lowercase   :			float    )						->      float:





    """simple docstring"""

    __A         =	0.0
    for coeff in reversed(__lowercase    ):
        __A         =	result * x + coeff
    return result


if __name__ == "__main__":
  __a      :       Dict				  =   (0.0, 0.0, 5.0, 9.3, 7.0)
  __a      :       Optional[Any]				  =   1_0.0
  print(evaluate_poly(poly, x))
  print(horner(poly, x))




