


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 					__SCREAMING_SNAKE_CASE (      unittest.TestCase ):


      def 							__lowerCamelCase      (				self		):
            lowercase      : Tuple        =		mock.Mock()
            lowercase      : Union[str, Any]        =		500
            lowercase      : Union[str, Any]        =		{}
            lowercase      : Dict        =		HTTPError
            lowercase      : Optional[Any]        =		{}

            # Download this model to make sure it's in the cache.
            lowercase      : List[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:
                  lowercase      : Optional[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		):
            lowercase      : Union[str, Any]        =		WavaVecaFeatureExtractor.from_pretrained(
                '''https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json'''		)







@is_staging_test
class 					__SCREAMING_SNAKE_CASE (      unittest.TestCase ):


      @classmethod
      def 							__lowerCamelCase      (				cls		):
            lowercase      : int        =		TOKEN
            HfFolder.save_token(A_		)


      @classmethod
      def 							__lowerCamelCase      (				cls		):




            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		):
            lowercase      : Dict        =		WavaVecaFeatureExtractor.from_pretrained(A_		)
            feature_extractor.push_to_hub('''test-feature-extractor'''				,    use_auth_token=self._token		)

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

            lowercase      : Optional[int]        =		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		):
            lowercase      : Any        =		WavaVecaFeatureExtractor.from_pretrained(A_		)
            feature_extractor.push_to_hub('''valid_org/test-feature-extractor'''				,    use_auth_token=self._token		)

            lowercase      : Tuple        =		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		)

            lowercase      : Union[str, 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 							__lowerCamelCase      (				self		):
            CustomFeatureExtractor.register_for_auto_class()
            lowercase      : 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'''}				,    )

            lowercase      : Union[str, 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'''		)





from typing import TYPE_CHECKING

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


__snake_case   							=						{'''configuration_unispeech''': ['''UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''UniSpeechConfig''']}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __snake_case   							=						[
        '''UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''UniSpeechForCTC''',
        '''UniSpeechForPreTraining''',
        '''UniSpeechForSequenceClassification''',
        '''UniSpeechModel''',
        '''UniSpeechPreTrainedModel''',
    ]

if TYPE_CHECKING:
    from .configuration_unispeech import UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP, UniSpeechConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_unispeech import (
            UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST,
            UniSpeechForCTC,
            UniSpeechForPreTraining,
            UniSpeechForSequenceClassification,
            UniSpeechModel,
            UniSpeechPreTrainedModel,
        )

else:
    import sys

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


