


'''simple docstring'''
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

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

from transformers import AutoFeatureExtractor, WavaVecaFeatureExtractor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


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

from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


__SCREAMING_SNAKE_CASE					:				Union[str, Any]									=		get_tests_dir('''fixtures''')






class 					__lowerCAmelCase   (   unittest.TestCase						):

						"""simple docstring"""






						def 				_UpperCAmelCase       (  self							:      Union[str, Any]	):
													# A mock response for an HTTP head request to emulate server down
													A_			    =		mock.Mock()
													A_			    =		5_00
													A_			    =		{}
													A_			    =		HTTPError
													A_			    =		{}

													# Download this model to make sure it's in the cache.
													A_			    =		WavaVecaFeatureExtractor.from_pretrained("hf-internal-testing/tiny-random-wav2vec2"	)
													# Under the mock environment we get a 500 error when trying to reach the model.
													with mock.patch("requests.Session.request" ,  return_value=lowerCAmelCase	) as mock_head:
																				A_			    =		WavaVecaFeatureExtractor.from_pretrained("hf-internal-testing/tiny-random-wav2vec2"	)
																				# This check we did call the fake head request
																				mock_head.assert_called()






						def 				_UpperCAmelCase       (  self							:      Dict	):
													# This test is for deprecated behavior and can be removed in v5
													A_			    =		WavaVecaFeatureExtractor.from_pretrained(
													    "https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"	)






@is_staging_test
class 					__lowerCAmelCase   (   unittest.TestCase						):

						"""simple docstring"""






						@classmethod
						def 				_UpperCAmelCase       (  cls							:      Optional[Any]	):
													A_			    =		TOKEN
													HfFolder.save_token(lowerCAmelCase	)






						@classmethod
						def 				_UpperCAmelCase       (  cls							:      str	):
													try:
																				delete_repo(token=cls._token ,  repo_id="test-feature-extractor"	)
													except HTTPError:
																				pass

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

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






						def 				_UpperCAmelCase       (  self							:      List[str]	):
													A_			    =		WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase	)
													feature_extractor.push_to_hub("test-feature-extractor" ,  use_auth_token=self._token	)

													A_			    =		WavaVecaFeatureExtractor.from_pretrained(F"{USER}/test-feature-extractor"	)
													for k, v in feature_extractor.__dict__.items():
																				self.assertEqual(lowerCAmelCase ,  getattr(lowerCAmelCase ,  lowerCAmelCase	)	)

													# Reset repo
													delete_repo(token=self._token ,  repo_id="test-feature-extractor"	)

													# Push to hub via save_pretrained
													with tempfile.TemporaryDirectory() as tmp_dir:
																				feature_extractor.save_pretrained(
																				    lowerCAmelCase ,  repo_id="test-feature-extractor" ,  push_to_hub=lowerCAmelCase ,  use_auth_token=self._token	)

													A_			    =		WavaVecaFeatureExtractor.from_pretrained(F"{USER}/test-feature-extractor"	)
													for k, v in feature_extractor.__dict__.items():
																				self.assertEqual(lowerCAmelCase ,  getattr(lowerCAmelCase ,  lowerCAmelCase	)	)






						def 				_UpperCAmelCase       (  self							:      Optional[int]	):
													A_			    =		WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase	)
													feature_extractor.push_to_hub("valid_org/test-feature-extractor" ,  use_auth_token=self._token	)

													A_			    =		WavaVecaFeatureExtractor.from_pretrained("valid_org/test-feature-extractor"	)
													for k, v in feature_extractor.__dict__.items():
																				self.assertEqual(lowerCAmelCase ,  getattr(lowerCAmelCase ,  lowerCAmelCase	)	)

													# Reset repo
													delete_repo(token=self._token ,  repo_id="valid_org/test-feature-extractor"	)

													# Push to hub via save_pretrained
													with tempfile.TemporaryDirectory() as tmp_dir:
																				feature_extractor.save_pretrained(
																				    lowerCAmelCase ,  repo_id="valid_org/test-feature-extractor-org" ,  push_to_hub=lowerCAmelCase ,  use_auth_token=self._token	)

													A_			    =		WavaVecaFeatureExtractor.from_pretrained("valid_org/test-feature-extractor-org"	)
													for k, v in feature_extractor.__dict__.items():
																				self.assertEqual(lowerCAmelCase ,  getattr(lowerCAmelCase ,  lowerCAmelCase	)	)






						def 				_UpperCAmelCase       (  self							:      Optional[int]	):
													CustomFeatureExtractor.register_for_auto_class()
													A_			    =		CustomFeatureExtractor.from_pretrained(lowerCAmelCase	)

													feature_extractor.push_to_hub("test-dynamic-feature-extractor" ,  use_auth_token=self._token	)

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

													A_			    =		AutoFeatureExtractor.from_pretrained(
													    F"{USER}/test-dynamic-feature-extractor" ,  trust_remote_code=lowerCAmelCase	)
													# Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module
													self.assertEqual(new_feature_extractor.__class__.__name__ ,  "CustomFeatureExtractor"	)









'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


if is_sentencepiece_available():
							from ..ta.tokenization_ta import TaTokenizer
else:
							from ...utils.dummy_sentencepiece_objects import TaTokenizer

__SCREAMING_SNAKE_CASE					:				str									=		TaTokenizer

if is_tokenizers_available():
							from ..ta.tokenization_ta_fast import TaTokenizerFast
else:
							from ...utils.dummy_tokenizers_objects import TaTokenizerFast

__SCREAMING_SNAKE_CASE					:				Any									=		TaTokenizerFast

__SCREAMING_SNAKE_CASE					:				Tuple									=		{'''configuration_mt5''': ['''MT5Config''', '''MT5OnnxConfig''']}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__SCREAMING_SNAKE_CASE					:				List[Any]									=		[
							    '''MT5EncoderModel''',
							    '''MT5ForConditionalGeneration''',
							    '''MT5ForQuestionAnswering''',
							    '''MT5Model''',
							    '''MT5PreTrainedModel''',
							    '''MT5Stack''',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__SCREAMING_SNAKE_CASE					:				str									=		['''TFMT5EncoderModel''', '''TFMT5ForConditionalGeneration''', '''TFMT5Model''']

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__SCREAMING_SNAKE_CASE					:				List[str]									=		['''FlaxMT5EncoderModel''', '''FlaxMT5ForConditionalGeneration''', '''FlaxMT5Model''']


if TYPE_CHECKING:
							from .configuration_mta import MTaConfig, MTaOnnxConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_mta import (
														    MTaEncoderModel,
														    MTaForConditionalGeneration,
														    MTaForQuestionAnswering,
														    MTaModel,
														    MTaPreTrainedModel,
														    MTaStack,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel

else:
							import sys

							__SCREAMING_SNAKE_CASE					:				Union[str, Any]									=		_LazyModule(
							    __name__,
							    globals()['''__file__'''],
							    _import_structure,
							    extra_objects={'''MT5Tokenizer''': MTaTokenizer, '''MT5TokenizerFast''': MTaTokenizerFast},
							    module_spec=__spec__,
							)





