
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     _SCREAMING_SNAKE_CASE     (      unittest.TestCase						):



	def     SCREAMING_SNAKE_CASE_(    self )				->       List[str]:
					# A mock response for an HTTP head request to emulate server down
					lowerCamelCase_						=			mock.Mock()
					lowerCamelCase_						=			500
					lowerCamelCase_						=			{}
					lowerCamelCase_						=			HTTPError
					lowerCamelCase_						=			{}

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



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




@is_staging_test
class     _SCREAMING_SNAKE_CASE     (      unittest.TestCase						):



	@classmethod
	def     SCREAMING_SNAKE_CASE_(    cls )				->       Optional[Any]:
					lowerCamelCase_						=			TOKEN
					HfFolder.save_token(lowercase )



	@classmethod
	def     SCREAMING_SNAKE_CASE_(    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     SCREAMING_SNAKE_CASE_(    self )				->       Optional[Any]:
					lowerCamelCase_						=			WavaVecaFeatureExtractor.from_pretrained(lowercase )
					feature_extractor.push_to_hub("test-feature-extractor"						,  use_auth_token=self._token )

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

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

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



	def     SCREAMING_SNAKE_CASE_(    self )				->       List[Any]:
					lowerCamelCase_						=			WavaVecaFeatureExtractor.from_pretrained(lowercase )
					feature_extractor.push_to_hub("valid_org/test-feature-extractor"						,  use_auth_token=self._token )

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

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

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



	def     SCREAMING_SNAKE_CASE_(    self )				->       Any:
					CustomFeatureExtractor.register_for_auto_class()
					lowerCamelCase_						=			CustomFeatureExtractor.from_pretrained(lowercase )

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

					lowerCamelCase_						=			AutoFeatureExtractor.from_pretrained(
					    f'{USER}/test-dynamic-feature-extractor'						,  trust_remote_code=lowercase )
					# 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" )




__A				={str(digit): digit**5 for digit in range(1_0)}





def 			lowerCamelCase_ (				lowerCamelCase__    ):
				return sum(DIGITS_FIFTH_POWER[digit] for digit in str(lowerCamelCase__    )    )





def 			lowerCamelCase_ (				):
				return sum(
				    number
				    for number in range(1_0_0_0	, 1_0_0_0_0_0_0    )
				    if number == digits_fifth_powers_sum(lowerCamelCase__    )    )


if __name__ == "__main__":
			print(solution())


