






"""simple docstring"""

import doctest
import logging
import os
import unittest
from pathlib import Path
from typing import List, Union

import transformers
from transformers.testing_utils import require_tf, require_torch, slow


lowercase__					:						List[str]												=			logging.getLogger()




@unittest.skip("""Temporarily disable the doc tests.""")
@require_torch
@require_tf
@slow
class  _UpperCAmelCase (    unittest.TestCase):

 def 		_snake_case      (  self	: Tuple						,  lowercase_	: Path						,  lowercase_	: Union[str, None] = None						,  lowercase_	: Union[List[str], None] = None						,  lowercase_	: Union[str, List[str], None] = None						,  lowercase_	: bool = True						,  ):
     snake_case_				:  Any       =			[file for file in os.listdir(lowercase_       ) if os.path.isfile(os.path.join(lowercase_						,  lowercase_       )       )]

     if identifier is not None:
         snake_case_				:  Dict       =			[file for file in files if identifier in file]

     if n_identifier is not None:
         if isinstance(lowercase_						,  lowercase_       ):
             for n_ in n_identifier:
                 snake_case_				:  Any       =			[file for file in files if n_ not in file]
         else:
             snake_case_				:  Dict       =			[file for file in files if n_identifier not in file]

     snake_case_				:  str       =			ignore_files or []
     ignore_files.append('''__init__.py'''       )
     snake_case_				:  Tuple       =			[file for file in files if file not in ignore_files]

     for file in files:
         # Open all files
         print('''Testing'''						,  lowercase_       )

         if only_modules:
             snake_case_				:  Tuple       =			file.split('''.'''       )[0]
             try:
                 snake_case_				:  List[str]       =			getattr(lowercase_						,  lowercase_       )
                 snake_case_				:  List[str]       =			doctest.DocTestSuite(lowercase_       )
                 snake_case_				:  Tuple       =			unittest.TextTestRunner().run(lowercase_       )
                 self.assertIs(len(result.failures       )						,  0       )
             except AttributeError:
                 logger.info(f"{module_identifier} is not a module."       )
         else:
             snake_case_				:  int       =			doctest.testfile(str('''..''' / directory / file       )						,  optionflags=doctest.ELLIPSIS       )
             self.assertIs(result.failed						,  0       )

 def 		_snake_case      (  self	: Any       ):
     snake_case_				:  Any       =			Path('''src/transformers'''       )
     snake_case_				:  List[Any]       =			'''modeling'''
     snake_case_				:  Dict       =			[
         '''modeling_ctrl.py''',
         '''modeling_tf_ctrl.py''',
     ]
     self.analyze_directory(lowercase_						,  identifier=lowercase_						,  ignore_files=lowercase_       )

 def 		_snake_case      (  self	: Union[str, Any]       ):
     snake_case_				:  List[Any]       =			Path('''src/transformers'''       )
     snake_case_				:  Optional[Any]       =			'''tokenization'''
     self.analyze_directory(lowercase_						,  identifier=lowercase_       )

 def 		_snake_case      (  self	: Union[str, Any]       ):
     snake_case_				:  List[Any]       =			Path('''src/transformers'''       )
     snake_case_				:  Dict       =			'''configuration'''
     self.analyze_directory(lowercase_						,  identifier=lowercase_       )

 def 		_snake_case      (  self	: Any       ):
     snake_case_				:  Tuple       =			Path('''src/transformers'''       )
     snake_case_				:  Union[str, Any]       =			['''configuration''', '''modeling''', '''tokenization''']
     self.analyze_directory(lowercase_						,  n_identifier=lowercase_       )






 def 		_snake_case      (  self	: Optional[int]       ):
     snake_case_				:  Tuple       =			Path('''docs/source'''       )
     snake_case_				:  int       =			['''favicon.ico''']
     self.analyze_directory(lowercase_						,  ignore_files=lowercase_						,  only_modules=lowercase_       )










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


lowercase__					:						Any												=			get_tests_dir('''fixtures''')




class  _UpperCAmelCase (    unittest.TestCase):

 def 		_snake_case      (  self	: Tuple       ):
     # A mock response for an HTTP head request to emulate server down
     snake_case_				:  str       =			mock.Mock()
     snake_case_				:  Optional[Any]       =			500
     snake_case_				:  str       =			{}
     snake_case_				:  Optional[int]       =			HTTPError
     snake_case_				:  Tuple       =			{}

     # Download this model to make sure it's in the cache.
     snake_case_				:  List[str]       =			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:
         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 		_snake_case      (  self	: Union[str, Any]       ):
     # This test is for deprecated behavior and can be removed in v5
     snake_case_				:  str       =			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 		_snake_case      (  cls	: int       ):
     snake_case_				:  Dict       =			TOKEN
     HfFolder.save_token(lowercase_       )

 @classmethod
 def 		_snake_case      (  cls	: 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 		_snake_case      (  self	: Any       ):
     snake_case_				:  int       =			WavaVecaFeatureExtractor.from_pretrained(lowercase_       )
     feature_extractor.push_to_hub('''test-feature-extractor'''						,  use_auth_token=self._token       )

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

     snake_case_				:  Optional[int]       =			WavaVecaFeatureExtractor.from_pretrained(f"{USER}/test-feature-extractor"       )
     for k, v in feature_extractor.__dict__.items():
         self.assertEqual(lowercase_						,  getattr(lowercase_						,  lowercase_       )       )

 def 		_snake_case      (  self	: Dict       ):
     snake_case_				:  Union[str, Any]       =			WavaVecaFeatureExtractor.from_pretrained(lowercase_       )
     feature_extractor.push_to_hub('''valid_org/test-feature-extractor'''						,  use_auth_token=self._token       )

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

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






 def 		_snake_case      (  self	: str       ):
     CustomFeatureExtractor.register_for_auto_class()
     snake_case_				:  Optional[Any]       =			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'''}						,  )

     snake_case_				:  Any       =			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'''       )





