
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							=       get_tests_dir("""fixtures""")






class   UpperCAmelCase		(						unittest.TestCase ):



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Any:


          '''simple docstring'''


          snake_case       :   Dict							=      mock.Mock()
          snake_case       :   Tuple							=      5_00
          snake_case       :   Tuple							=      {}
          snake_case       :   int							=      HTTPError
          snake_case       :   Optional[Any]							=      {}

          # Download this model to make sure it's in the cache.
          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=snake_case__ ) as mock_head:
                 snake_case       :   int							=      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		:					Tuple )		->	Union[str, Any]:


          '''simple docstring'''


          snake_case       :   Any							=      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 				_SCREAMING_SNAKE_CASE   (cls		:					List[str] )		->	Optional[int]:


          '''simple docstring'''


          snake_case       :   int							=      TOKEN
          HfFolder.save_token(snake_case__ )



   @classmethod
   def 				_SCREAMING_SNAKE_CASE   (cls		:					str )		->	Tuple:


          '''simple docstring'''


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


          '''simple docstring'''


          snake_case       :   Any							=      WavaVecaFeatureExtractor.from_pretrained(snake_case__ )
          feature_extractor.push_to_hub("test-feature-extractor"    ,						use_auth_token=self._token )

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

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

          snake_case       :   List[Any]							=      WavaVecaFeatureExtractor.from_pretrained(f"""{USER}/test-feature-extractor""" )
          for k, v in feature_extractor.__dict__.items():
                 self.assertEqual(snake_case__    ,						getattr(snake_case__    ,						snake_case__ ) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	Dict:


          '''simple docstring'''


          snake_case       :   List[Any]							=      WavaVecaFeatureExtractor.from_pretrained(snake_case__ )
          feature_extractor.push_to_hub("valid_org/test-feature-extractor"    ,						use_auth_token=self._token )

          snake_case       :   List[str]							=      WavaVecaFeatureExtractor.from_pretrained("valid_org/test-feature-extractor" )
          for k, v in feature_extractor.__dict__.items():
                 self.assertEqual(snake_case__    ,						getattr(snake_case__    ,						snake_case__ ) )

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



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	Any:


          '''simple docstring'''


          CustomFeatureExtractor.register_for_auto_class()
          snake_case       :   Union[str, Any]							=      CustomFeatureExtractor.from_pretrained(snake_case__ )

          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       :   Optional[int]							=      AutoFeatureExtractor.from_pretrained(
              f"""{USER}/test-dynamic-feature-extractor"""    ,						trust_remote_code=snake_case__ )
          # 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 ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase					:     Optional[Any]												=logging.get_logger(__name__)

lowerCAmelCase					:     Tuple												={
    '''facebook/vit-mae-base''': '''https://huggingface.co/facebook/vit-mae-base/resolve/main/config.json''',
    # See all ViT MAE models at https://huggingface.co/models?filter=vit-mae
}
class       a_   (				_lowerCAmelCase							):
     __A      =			"vit_mae"





     def __init__( self		:					Any	,      lowercase		:					int=768	,      lowercase		:					Tuple=12	,      lowercase		:					str=12	,      lowercase		:					Optional[Any]=3_072	,      lowercase		:					List[Any]="gelu"	,      lowercase		:					Tuple=0.0	,      lowercase		:					Union[str, Any]=0.0	,      lowercase		:					str=0.02	,      lowercase		:					Optional[int]=1e-1_2	,      lowercase		:					List[Any]=224	,      lowercase		:					str=16	,      lowercase		:					List[str]=3	,      lowercase		:					Optional[Any]=True	,      lowercase		:					int=16	,      lowercase		:					Optional[Any]=512	,      lowercase		:					Optional[Any]=8	,      lowercase		:					Optional[Any]=2_048	,      lowercase		:					List[str]=0.75	,      lowercase		:					str=False	,      **lowercase		:					Union[str, Any]	,      ):





        """simple docstring"""




        super().__init__(**lowercase						)

        lowercase_			:Any    			= hidden_size
        lowercase_			:Optional[Any]    			= num_hidden_layers
        lowercase_			:Optional[Any]    			= num_attention_heads
        lowercase_			:int    			= intermediate_size
        lowercase_			:Optional[int]    			= hidden_act
        lowercase_			:str    			= hidden_dropout_prob
        lowercase_			:Optional[Any]    			= attention_probs_dropout_prob
        lowercase_			:str    			= initializer_range
        lowercase_			:Optional[int]    			= layer_norm_eps
        lowercase_			:str    			= image_size
        lowercase_			:Union[str, Any]    			= patch_size
        lowercase_			:Dict    			= num_channels
        lowercase_			:Any    			= qkv_bias
        lowercase_			:Optional[int]    			= decoder_num_attention_heads
        lowercase_			:Optional[Any]    			= decoder_hidden_size
        lowercase_			:Union[str, Any]    			= decoder_num_hidden_layers
        lowercase_			:List[Any]    			= decoder_intermediate_size
        lowercase_			:Optional[Any]    			= mask_ratio
        lowercase_			:Optional[Any]    			= norm_pix_loss


