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




class     UpperCAmelCase_	(						unittest.TestCase					):






						'''simple docstring'''






						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					mock.Mock()
												_lowerCAmelCase    		=					500
												_lowerCAmelCase    		=					{}
												_lowerCAmelCase    		=					HTTPError
												_lowerCAmelCase    		=					{}

												# Download this model to make sure it's in the cache.
												_lowerCAmelCase    		=					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:
																		_lowerCAmelCase    		=					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 ):

												"""simple docstring"""



												_lowerCAmelCase    		=					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    _lowercase      (   cls ):

												"""simple docstring"""



												_lowerCAmelCase    		=					TOKEN
												HfFolder.save_token(_lowercase )




						@classmethod
						def    _lowercase      (   cls ):

												"""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    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					WavaVecaFeatureExtractor.from_pretrained(_lowercase )
												feature_extractor.push_to_hub("""test-feature-extractor"""       ,  use_auth_token=self._token )

												_lowerCAmelCase    		=					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 )

												_lowerCAmelCase    		=					WavaVecaFeatureExtractor.from_pretrained(F'{USER}/test-feature-extractor' )
												for k, v in feature_extractor.__dict__.items():
																		self.assertEqual(_lowercase       ,  getattr(_lowercase       ,  _lowercase ) )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					WavaVecaFeatureExtractor.from_pretrained(_lowercase )
												feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""       ,  use_auth_token=self._token )

												_lowerCAmelCase    		=					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 )

												_lowerCAmelCase    		=					WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor-org""" )
												for k, v in feature_extractor.__dict__.items():
																		self.assertEqual(_lowercase       ,  getattr(_lowercase       ,  _lowercase ) )




						def    _lowercase      (   self ):

												"""simple docstring"""



												CustomFeatureExtractor.register_for_auto_class()
												_lowerCAmelCase    		=					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"""}       ,  )

												_lowerCAmelCase    		=					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""" )

'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


A_     :						Optional[Any]    							={
    '''configuration_squeezebert''': [
        '''SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''SqueezeBertConfig''',
        '''SqueezeBertOnnxConfig''',
    ],
    '''tokenization_squeezebert''': ['''SqueezeBertTokenizer'''],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 A_     :						Dict    							=['''SqueezeBertTokenizerFast''']

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 A_     :						Optional[int]    							=[
     '''SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''SqueezeBertForMaskedLM''',
     '''SqueezeBertForMultipleChoice''',
     '''SqueezeBertForQuestionAnswering''',
     '''SqueezeBertForSequenceClassification''',
     '''SqueezeBertForTokenClassification''',
     '''SqueezeBertModel''',
     '''SqueezeBertModule''',
     '''SqueezeBertPreTrainedModel''',
 ]


if TYPE_CHECKING:
 from .configuration_squeezebert import (
     SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
     SqueezeBertConfig,
     SqueezeBertOnnxConfig,
 )
 from .tokenization_squeezebert import SqueezeBertTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_squeezebert_fast import SqueezeBertTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_squeezebert import (
      SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      SqueezeBertForMaskedLM,
      SqueezeBertForMultipleChoice,
      SqueezeBertForQuestionAnswering,
      SqueezeBertForSequenceClassification,
      SqueezeBertForTokenClassification,
      SqueezeBertModel,
      SqueezeBertModule,
      SqueezeBertPreTrainedModel,
  )

else:
 import sys

 A_     :						List[str]    							=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





