




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


__lowerCAmelCase	:       List[str]     =	get_tests_dir('fixtures')




class 					snake_case__							(unittest.TestCase     ):
    """simple docstring"""



    def 							__UpperCAmelCase							(   self       :  Tuple							)      ->  Union[str, Any]:
       # 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=lowerCAmelCase__							) 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 							__UpperCAmelCase							(   self       :  List[Any]							)      ->  Dict:
       # 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 					snake_case__							(unittest.TestCase     ):
    """simple docstring"""



    @classmethod
    def 							__UpperCAmelCase							(   cls       :  List[str]							)      ->  List[Any]:
       a					=    TOKEN
       HfFolder.save_token(lowerCAmelCase__							)





    @classmethod
    def 							__UpperCAmelCase							(   cls       :  Optional[int]							)      ->  Union[str, 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       :  Any							)      ->  Any:
       a					=    WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase__							)
       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(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							)

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





    def 							__UpperCAmelCase							(   self       :  List[Any]							)      ->  Tuple:
       a					=    WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase__							)
       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(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							)

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





    def 							__UpperCAmelCase							(   self       :  Dict							)      ->  List[str]:
       CustomFeatureExtractor.register_for_auto_class()
       a					=    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"}      ,   )

       a					=    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"							)












def     __magic_name__       (				A	:      int,						A	:      int,						A	:      int     ):






			'''simple docstring'''







			if exponent == 1:
						return base
			if exponent % 2 == 0:
						a					=    _modexpt(A,						exponent // 2,						A     ) % modulo_value
						return (x * x) % modulo_value
			else:
						return (base * _modexpt(A,						exponent - 1,						A     )) % modulo_value




def     __magic_name__       (				A	:      int = 1777,						A	:      int = 1855,						A	:      int = 8     ):






			'''simple docstring'''







			a					=    base
			for _ in range(1,						A     ):
						a					=    _modexpt(A,						A,						10**digits     )

			return result


if __name__ == "__main__":
		print(F'''{solution() = }''')






