




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


_A													=      get_tests_dir("""fixtures""")


class _lowerCamelCase    (					unittest.TestCase						):






   def 	_lowerCAmelCase   (		self       :		str   )			->						Tuple:

         """simple docstring"""
         # A mock response for an HTTP head request to emulate server down
         lowerCAmelCase__      :			Any   =	mock.Mock()
         lowerCAmelCase__      :			List[str]   =	5_00
         lowerCAmelCase__      :			Tuple   =	{}
         lowerCAmelCase__      :			Union[str, Any]   =	HTTPError
         lowerCAmelCase__      :			Union[str, Any]   =	{}

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

         """simple docstring"""
         # This test is for deprecated behavior and can be removed in v5
         lowerCAmelCase__      :			str   =	WavaVecaFeatureExtractor.from_pretrained(
             """https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"""   )






@is_staging_test
class _lowerCamelCase    (					unittest.TestCase						):






   @classmethod
   def 	_lowerCAmelCase   (		cls       :		str   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[Any]   =	TOKEN
         HfFolder.save_token(UpperCamelCase   )






   @classmethod
   def 	_lowerCAmelCase   (		cls       :		Any   )			->						List[Any]:

         """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 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase   )
         feature_extractor.push_to_hub("""test-feature-extractor"""   ,     use_auth_token=self._token   )

         lowerCAmelCase__      :			List[Any]   =	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   )

         lowerCAmelCase__      :			Optional[Any]   =	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       :		Optional[Any]   )			->						Optional[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase   )
         feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""   ,     use_auth_token=self._token   )

         lowerCAmelCase__      :			Optional[Any]   =	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   )

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

         """simple docstring"""
         CustomFeatureExtractor.register_for_auto_class()
         lowerCAmelCase__      :			Tuple   =	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"""}   ,     )

         lowerCAmelCase__      :			Tuple   =	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"""


from argparse import ArgumentParser

from . import BaseTransformersCLICommand



def 	lowercase_				(			__UpperCAmelCase				)						->    List[str]:
      return DownloadCommand(args.model    ,		args.cache_dir    ,		args.force    ,		args.trust_remote_code				)


class _lowerCamelCase    (					a_						):






   @staticmethod
   def 	_lowerCAmelCase   (		UpperCamelCase       :		ArgumentParser   )			->						List[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	parser.add_parser("""download"""   )
         download_parser.add_argument(
             """--cache-dir"""   ,     type=UpperCamelCase   ,     default=UpperCamelCase   ,     help="""Path to location to store the models"""   )
         download_parser.add_argument(
             """--force"""   ,     action="""store_true"""   ,     help="""Force the model to be download even if already in cache-dir"""   )
         download_parser.add_argument(
             """--trust-remote-code"""   ,     action="""store_true"""   ,     help="""Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you've reviewed the code as it will execute on your local machine"""   ,     )
         download_parser.add_argument("""model"""   ,     type=UpperCamelCase   ,     help="""Name of the model to download"""   )
         download_parser.set_defaults(func=UpperCamelCase   )






   def __init__(		self       :		Optional[int]   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		bool   ,     UpperCamelCase       :		bool   )			->						Any:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	model
         lowerCAmelCase__      :			Union[str, Any]   =	cache
         lowerCAmelCase__      :			Optional[int]   =	force
         lowerCAmelCase__      :			Dict   =	trust_remote_code






   def 	_lowerCAmelCase   (		self       :		int   )			->						Any:

         """simple docstring"""
         from ..models.auto import AutoModel, AutoTokenizer

         AutoModel.from_pretrained(
             self._model   ,     cache_dir=self._cache   ,     force_download=self._force   ,     trust_remote_code=self._trust_remote_code   )
         AutoTokenizer.from_pretrained(
             self._model   ,     cache_dir=self._cache   ,     force_download=self._force   ,     trust_remote_code=self._trust_remote_code   )





