






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


__magic_name__:					Tuple							=     get_tests_dir("fixtures")





class 	snake_case__ (							unittest.TestCase				):
	def       __magic_name__    (    self			)							->				Any:
							# A mock response for an HTTP head request to emulate server down
							__magic_name__      :       Optional[int]       						= mock.Mock()
							__magic_name__      :       Union[str, Any]       						= 5_00
							__magic_name__      :       List[str]       						= {}
							__magic_name__      :       Any       						= HTTPError
							__magic_name__      :       List[str]       						= {}

							# Download this model to make sure it's in the cache.
							__magic_name__      :       int       						= 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:
													__magic_name__      :       Optional[Any]       						= WavaVecaFeatureExtractor.from_pretrained("""hf-internal-testing/tiny-random-wav2vec2"""			)
													# This check we did call the fake head request
													mock_head.assert_called()







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





@is_staging_test
class 	snake_case__ (							unittest.TestCase				):
	@classmethod
	def       __magic_name__    (    cls			)							->				Tuple:
							__magic_name__      :       Optional[int]       						= TOKEN
							HfFolder.save_token(lowerCAmelCase__			)
	@classmethod
	def       __magic_name__    (    cls			)							->				List[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       __magic_name__    (    self			)							->				Dict:
							__magic_name__      :       int       						= WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase__			)
							feature_extractor.push_to_hub("""test-feature-extractor"""      ,       use_auth_token=self._token			)

							__magic_name__      :       str       						= 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			)

							__magic_name__      :       Dict       						= WavaVecaFeatureExtractor.from_pretrained(F'{USER}/test-feature-extractor'			)
							for k, v in feature_extractor.__dict__.items():
													self.assertEqual(lowerCAmelCase__      ,       getattr(lowerCAmelCase__      ,       lowerCAmelCase__			)			)
	def       __magic_name__    (    self			)							->				Any:
							__magic_name__      :       int       						= WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase__			)
							feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""      ,       use_auth_token=self._token			)

							__magic_name__      :       List[str]       						= 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			)

							__magic_name__      :       List[Any]       						= WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor-org"""			)
							for k, v in feature_extractor.__dict__.items():
													self.assertEqual(lowerCAmelCase__      ,       getattr(lowerCAmelCase__      ,       lowerCAmelCase__			)			)







	def       __magic_name__    (    self			)							->				Union[str, Any]:
							CustomFeatureExtractor.register_for_auto_class()
							__magic_name__      :       Optional[Any]       						= 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"""}      ,       )

							__magic_name__      :       Union[str, Any]       						= 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"""			)








import unittest

from transformers import is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, require_torch, slow


if is_flax_available():
		import optax
		from flax.training.common_utils import onehot

		from transformers import AutoTokenizer, FlaxMTaForConditionalGeneration
		from transformers.models.ta.modeling_flax_ta import shift_tokens_right





@require_torch
@require_sentencepiece
@require_tokenizers
@require_flax
class 	snake_case__ (							unittest.TestCase				):
	@slow
	def       __magic_name__    (    self			)							->				Optional[Any]:
							__magic_name__      :       Any       						= FlaxMTaForConditionalGeneration.from_pretrained("""google/mt5-small"""			)
							__magic_name__      :       Dict       						= AutoTokenizer.from_pretrained("""google/mt5-small"""			)

							__magic_name__      :       Tuple       						= tokenizer("""Hello there"""      ,       return_tensors="""np"""			).input_ids
							__magic_name__      :       List[Any]       						= tokenizer("""Hi I am"""      ,       return_tensors="""np"""			).input_ids

							__magic_name__      :       Any       						= shift_tokens_right(lowerCAmelCase__      ,       model.config.pad_token_id      ,       model.config.decoder_start_token_id			)

							__magic_name__      :       List[Any]       						= model(lowerCAmelCase__      ,       decoder_input_ids=lowerCAmelCase__			).logits
							__magic_name__      :       Tuple       						= optax.softmax_cross_entropy(lowerCAmelCase__      ,       onehot(lowerCAmelCase__      ,       logits.shape[-1]			)			).mean()

							__magic_name__      :       List[Any]       						= -(labels.shape[-1] * loss.item())

							__magic_name__      :       List[Any]       						= -8_4.9_1_2_7
							self.assertTrue(abs(mtf_score - EXPECTED_SCORE			) < 1e-4			)
