



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


_UpperCamelCase											=		get_tests_dir('fixtures')






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




  def 		_lowercase	(					self :      Union[str, Any]  )   ->   Tuple:
    # A mock response for an HTTP head request to emulate server down
    __lowerCamelCase			:			int       			=					mock.Mock()
    __lowerCamelCase			:			Optional[int]       			=					500
    __lowerCamelCase			:			List[Any]       			=					{}
    __lowerCamelCase			:			Dict       			=					HTTPError
    __lowerCamelCase			:			List[Any]       			=					{}

    # Download this model to make sure it's in the cache.
    __lowerCamelCase			:			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:
      __lowerCamelCase			:			Any       			=					WavaVecaFeatureExtractor.from_pretrained('hf-internal-testing/tiny-random-wav2vec2'  )
      # This check we did call the fake head request
      mock_head.assert_called()




  def 		_lowercase	(					self :      List[str]  )   ->   Tuple:
    # This test is for deprecated behavior and can be removed in v5
    __lowerCamelCase			:			int       			=					WavaVecaFeatureExtractor.from_pretrained(
        'https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json'  )






@is_staging_test
class    lowerCamelCase_       (							unittest.TestCase	):
  """simple docstring"""




  @classmethod
  def 		_lowercase	(					cls :      Dict  )   ->   str:
    __lowerCamelCase			:			List[str]       			=					TOKEN
    HfFolder.save_token(_a  )




  @classmethod
  def 		_lowercase	(					cls :      str  )   ->   int:
    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 		_lowercase	(					self :      Dict  )   ->   Optional[int]:
    __lowerCamelCase			:			List[str]       			=					WavaVecaFeatureExtractor.from_pretrained(_a  )
    feature_extractor.push_to_hub('test-feature-extractor'     ,      use_auth_token=self._token  )

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

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




  def 		_lowercase	(					self :      List[Any]  )   ->   Union[str, Any]:
    __lowerCamelCase			:			Union[str, Any]       			=					WavaVecaFeatureExtractor.from_pretrained(_a  )
    feature_extractor.push_to_hub('valid_org/test-feature-extractor'     ,      use_auth_token=self._token  )

    __lowerCamelCase			:			List[str]       			=					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  )

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




  def 		_lowercase	(					self :      Tuple  )   ->   str:
    CustomFeatureExtractor.register_for_auto_class()
    __lowerCamelCase			:			str       			=					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'}     ,      )

    __lowerCamelCase			:			Tuple       			=					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_torch_available


_UpperCamelCase											=		{'configuration_ibert': ['IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'IBertConfig', 'IBertOnnxConfig']}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase											=		[
       'IBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'IBertForMaskedLM',
       'IBertForMultipleChoice',
       'IBertForQuestionAnswering',
       'IBertForSequenceClassification',
       'IBertForTokenClassification',
       'IBertModel',
       'IBertPreTrainedModel',
   ]

if TYPE_CHECKING:
   from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_ibert import (
          IBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          IBertForMaskedLM,
          IBertForMultipleChoice,
          IBertForQuestionAnswering,
          IBertForSequenceClassification,
          IBertForTokenClassification,
          IBertModel,
          IBertPreTrainedModel,
      )

else:
   import sys

   _UpperCamelCase											=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






