



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


_lowerCAmelCase    :Dict     =					get_tests_dir('fixtures')
class 							_UpperCAmelCase							( unittest.TestCase      ):





     '''simple docstring'''



     def  __lowerCAmelCase	(					self		)							->					int:
         # A mock response for an HTTP head request to emulate server down
         _UpperCAmelCase							:  List[str]											=    mock.Mock()
         _UpperCAmelCase							:  str											=    5_0_0
         _UpperCAmelCase							:  Tuple											=    {}
         _UpperCAmelCase							:  List[Any]											=    HTTPError
         _UpperCAmelCase							:  Tuple											=    {}

         # Download this model to make sure it's in the cache.
         _UpperCAmelCase							:  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=A		) as mock_head:
             _UpperCAmelCase							:  Any											=    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]:
         # This test is for deprecated behavior and can be removed in v5
         _UpperCAmelCase							:  Tuple											=    WavaVecaFeatureExtractor.from_pretrained(
             '''https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json'''		)



@is_staging_test
class 							_UpperCAmelCase							( unittest.TestCase      ):





     '''simple docstring'''



     @classmethod
     def  __lowerCAmelCase	(					cls		)							->					Optional[Any]:
         _UpperCAmelCase							:  Tuple											=    TOKEN
         HfFolder.save_token(A		)





     @classmethod
     def  __lowerCAmelCase	(					cls		)							->					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  __lowerCAmelCase	(					self		)							->					Any:
         _UpperCAmelCase							:  Optional[Any]											=    WavaVecaFeatureExtractor.from_pretrained(A		)
         feature_extractor.push_to_hub('''test-feature-extractor'''       ,	use_auth_token=self._token		)

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

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

         _UpperCAmelCase							:  Optional[Any]											=    WavaVecaFeatureExtractor.from_pretrained(f'{USER}/test-feature-extractor'		)
         for k, v in feature_extractor.__dict__.items():
             self.assertEqual(A       ,	getattr(A       ,	A		)		)





     def  __lowerCAmelCase	(					self		)							->					Dict:
         _UpperCAmelCase							:  Dict											=    WavaVecaFeatureExtractor.from_pretrained(A		)
         feature_extractor.push_to_hub('''valid_org/test-feature-extractor'''       ,	use_auth_token=self._token		)

         _UpperCAmelCase							:  Union[str, Any]											=    WavaVecaFeatureExtractor.from_pretrained('''valid_org/test-feature-extractor'''		)
         for k, v in feature_extractor.__dict__.items():
             self.assertEqual(A       ,	getattr(A       ,	A		)		)

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

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





     def  __lowerCAmelCase	(					self		)							->					List[Any]:
         CustomFeatureExtractor.register_for_auto_class()
         _UpperCAmelCase							:  List[Any]											=    CustomFeatureExtractor.from_pretrained(A		)

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

         _UpperCAmelCase							:  Any											=    AutoFeatureExtractor.from_pretrained(
             f'{USER}/test-dynamic-feature-extractor'       ,	trust_remote_code=A		)
         # 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 typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_lowerCAmelCase    :List[Any]     =					{'configuration_opt': ['OPT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'OPTConfig']}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCAmelCase    :Any     =					[
      'OPT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'OPTForCausalLM',
      'OPTModel',
      'OPTPreTrainedModel',
      'OPTForSequenceClassification',
      'OPTForQuestionAnswering',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCAmelCase    :Optional[int]     =					['TFOPTForCausalLM', 'TFOPTModel', 'TFOPTPreTrainedModel']

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCAmelCase    :Any     =					[
      'FlaxOPTForCausalLM',
      'FlaxOPTModel',
      'FlaxOPTPreTrainedModel',
  ]


if TYPE_CHECKING:
  from .configuration_opt import OPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPTConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_opt import (
        OPT_PRETRAINED_MODEL_ARCHIVE_LIST,
        OPTForCausalLM,
        OPTForQuestionAnswering,
        OPTForSequenceClassification,
        OPTModel,
        OPTPreTrainedModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_opt import TFOPTForCausalLM, TFOPTModel, TFOPTPreTrainedModel

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_opt import FlaxOPTForCausalLM, FlaxOPTModel, FlaxOPTPreTrainedModel

else:
  import sys

  _lowerCAmelCase    :int     =					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


