






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						):





		'''simple docstring'''



		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	int													=   mock.Mock()
						SCREAMING_SNAKE_CASE_   :	Any													=   500
						SCREAMING_SNAKE_CASE_   :	str													=   {}
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   HTTPError
						SCREAMING_SNAKE_CASE_   :	List[Any]													=   {}

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






		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	List[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						):





		'''simple docstring'''



		@classmethod
		def   __snake_case			(						cls       ):
						SCREAMING_SNAKE_CASE_   :	int													=   TOKEN
						HfFolder.save_token(_lowerCamelCase       )


		@classmethod
		def   __snake_case			(						cls       ):





						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   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Optional[int]													=   WavaVecaFeatureExtractor.from_pretrained(_lowerCamelCase       )
						feature_extractor.push_to_hub('test-feature-extractor' ,    use_auth_token=self._token       )

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

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


		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Dict													=   WavaVecaFeatureExtractor.from_pretrained(_lowerCamelCase       )
						feature_extractor.push_to_hub('valid_org/test-feature-extractor' ,    use_auth_token=self._token       )

						SCREAMING_SNAKE_CASE_   :	Optional[int]													=   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       )

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






		def   __snake_case			(						self       ):
						CustomFeatureExtractor.register_for_auto_class()
						SCREAMING_SNAKE_CASE_   :	int													=   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'} ,    )

						SCREAMING_SNAKE_CASE_   :	Optional[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 copy
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, Optional, Union


@dataclass
class 							__a							:





		'''simple docstring'''



		UpperCAmelCase__      :				Optional[Union[str, Path]]				    =						None
		UpperCAmelCase__      :				bool				    =						False
		UpperCAmelCase__      :				bool				    =						False
		UpperCAmelCase__      :				bool				    =						False
		UpperCAmelCase__      :				Optional[Dict]				    =						None
		UpperCAmelCase__      :				Optional[str]				    =						None
		UpperCAmelCase__      :				bool				    =						False
		UpperCAmelCase__      :				bool				    =						False
		UpperCAmelCase__      :				bool				    =						False
		UpperCAmelCase__      :				bool				    =						True
		UpperCAmelCase__      :				Optional[int]				    =						None
		UpperCAmelCase__      :				int				    =						1
		UpperCAmelCase__      :				Optional[Union[str, bool]]				    =						None
		UpperCAmelCase__      :				bool				    =						False
		UpperCAmelCase__      :				Optional[Dict]				    =						None
		UpperCAmelCase__      :				Optional[str]				    =						None


		def   __snake_case			(						self       ):
						return self.__class__(**{k: copy.deepcopy(UpperCamelCase__       ) for k, v in self.__dict__.items()}       )