





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


_snake_case     :		Optional[int]       						= get_tests_dir('fixtures')






class 					_UpperCAmelCase   (	unittest.TestCase ):


					def 	lowerCamelCase       (					self			:str		):
												# 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=__UpperCamelCase		) 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 	lowerCamelCase       (					self			:Optional[Any]		):
												# 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 					_UpperCAmelCase   (	unittest.TestCase ):


					@classmethod
					def 	lowerCamelCase       (					cls			:Dict		):
												A		=  TOKEN
												HfFolder.save_token(__UpperCamelCase		)


					@classmethod
					def 	lowerCamelCase       (					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 	lowerCamelCase       (					self			:str		):
												A		=  WavaVecaFeatureExtractor.from_pretrained(__UpperCamelCase		)
												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(__UpperCamelCase     ,       getattr(__UpperCamelCase     ,       __UpperCamelCase		)		)

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

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


					def 	lowerCamelCase       (					self			:str		):
												A		=  WavaVecaFeatureExtractor.from_pretrained(__UpperCamelCase		)
												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(__UpperCamelCase     ,       getattr(__UpperCamelCase     ,       __UpperCamelCase		)		)

												# 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(
																			    __UpperCamelCase     ,       repo_id="valid_org/test-feature-extractor-org"     ,       push_to_hub=__UpperCamelCase     ,       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(__UpperCamelCase     ,       getattr(__UpperCamelCase     ,       __UpperCamelCase		)		)


					def 	lowerCamelCase       (					self			:Dict		):
												CustomFeatureExtractor.register_for_auto_class()
												A		=  CustomFeatureExtractor.from_pretrained(__UpperCamelCase		)

												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=__UpperCamelCase		)
												# 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"""
import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format






class 					_UpperCAmelCase   :
					UpperCamelCase      =							None


					def 	lowerCamelCase       (					self			:List[Any]		):
												A		=  self.feature_extraction_class(**self.feat_extract_dict		)
												A		=  json.loads(feat_extract.to_json_string()		)
												for key, value in self.feat_extract_dict.items():
																			self.assertEqual(obj[key]     ,       __UpperCamelCase		)


					def 	lowerCamelCase       (					self			:Dict		):
												A		=  self.feature_extraction_class(**self.feat_extract_dict		)

												with tempfile.TemporaryDirectory() as tmpdirname:
																			A		=  os.path.join(__UpperCamelCase     ,       "feat_extract.json"		)
																			feat_extract_first.to_json_file(__UpperCamelCase		)
																			A		=  self.feature_extraction_class.from_json_file(__UpperCamelCase		)

												self.assertEqual(feat_extract_second.to_dict()     ,       feat_extract_first.to_dict()		)


					def 	lowerCamelCase       (					self			:Dict		):
												A		=  self.feature_extraction_class(**self.feat_extract_dict		)

												with tempfile.TemporaryDirectory() as tmpdirname:
																			A		=  feat_extract_first.save_pretrained(__UpperCamelCase		)[0]
																			check_json_file_has_correct_format(__UpperCamelCase		)
																			A		=  self.feature_extraction_class.from_pretrained(__UpperCamelCase		)

												self.assertEqual(feat_extract_second.to_dict()     ,       feat_extract_first.to_dict()		)


					def 	lowerCamelCase       (					self			:Tuple		):
												A		=  self.feature_extraction_class()
												self.assertIsNotNone(__UpperCamelCase		)


