



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


a							   =				get_tests_dir('fixtures')






class 						a_		(     unittest.TestCase    ):


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

										# Download this model to make sure it's in the cache.
										snake_case:    List[str]      							=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=a_			) as mock_head:
													snake_case:    Optional[int]      							=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			)			->					List[str]:
										# This test is for deprecated behavior and can be removed in v5
										snake_case:    Any      							=WavaVecaFeatureExtractor.from_pretrained(
										    'https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json'			)






@is_staging_test
class 						a_		(     unittest.TestCase    ):


							@classmethod
							def    UpperCamelCase     (				cls   :						Optional[int]			)			->					int:
										snake_case:    Union[str, Any]      							=TOKEN
										HfFolder.save_token(a_			)


							@classmethod
							def    UpperCamelCase     (				cls   :						List[Any]			)			->					List[Any]:
										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   :						Union[str, Any]			)			->					Union[str, Any]:
										snake_case:    Union[str, Any]      							=WavaVecaFeatureExtractor.from_pretrained(a_			)
										feature_extractor.push_to_hub('test-feature-extractor'      ,						use_auth_token=self._token			)

										snake_case:    Dict      							=WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor'''			)
										for k, v in feature_extractor.__dict__.items():
													self.assertEqual(a_      ,						getattr(a_      ,						a_			)			)

										# 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(
													    a_      ,						repo_id='test-feature-extractor'      ,						push_to_hub=a_      ,						use_auth_token=self._token			)

										snake_case:    Union[str, Any]      							=WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor'''			)
										for k, v in feature_extractor.__dict__.items():
													self.assertEqual(a_      ,						getattr(a_      ,						a_			)			)


							def    UpperCamelCase     (				self   :						List[str]			)			->					Optional[int]:
										snake_case:    Optional[Any]      							=WavaVecaFeatureExtractor.from_pretrained(a_			)
										feature_extractor.push_to_hub('valid_org/test-feature-extractor'      ,						use_auth_token=self._token			)

										snake_case:    Tuple      							=WavaVecaFeatureExtractor.from_pretrained('valid_org/test-feature-extractor'			)
										for k, v in feature_extractor.__dict__.items():
													self.assertEqual(a_      ,						getattr(a_      ,						a_			)			)

										# 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(
													    a_      ,						repo_id='valid_org/test-feature-extractor-org'      ,						push_to_hub=a_      ,						use_auth_token=self._token			)

										snake_case:    str      							=WavaVecaFeatureExtractor.from_pretrained('valid_org/test-feature-extractor-org'			)
										for k, v in feature_extractor.__dict__.items():
													self.assertEqual(a_      ,						getattr(a_      ,						a_			)			)




							def    UpperCamelCase     (				self   :						int			)			->					Any:
										CustomFeatureExtractor.register_for_auto_class()
										snake_case:    Optional[Any]      							=CustomFeatureExtractor.from_pretrained(a_			)

										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'}      ,						)

										snake_case:    Dict      							=AutoFeatureExtractor.from_pretrained(
										    F'''{USER}/test-dynamic-feature-extractor'''      ,						trust_remote_code=a_			)
										# 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 diffusers.utils.testing_utils import require_onnxruntime






@require_onnxruntime
class 						a_		:
							pass




