


from typing import TYPE_CHECKING

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


SCREAMING_SNAKE_CASE       :      Union[str, Any]												= {
    "configuration_electra": ["ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP", "ElectraConfig", "ElectraOnnxConfig"],
    "tokenization_electra": ["ElectraTokenizer"],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      Tuple												= ["ElectraTokenizerFast"]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      Optional[int]												= [
     "ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST",
     "ElectraForCausalLM",
     "ElectraForMaskedLM",
     "ElectraForMultipleChoice",
     "ElectraForPreTraining",
     "ElectraForQuestionAnswering",
     "ElectraForSequenceClassification",
     "ElectraForTokenClassification",
     "ElectraModel",
     "ElectraPreTrainedModel",
     "load_tf_weights_in_electra",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      Union[str, Any]												= [
     "TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST",
     "TFElectraForMaskedLM",
     "TFElectraForMultipleChoice",
     "TFElectraForPreTraining",
     "TFElectraForQuestionAnswering",
     "TFElectraForSequenceClassification",
     "TFElectraForTokenClassification",
     "TFElectraModel",
     "TFElectraPreTrainedModel",
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      Union[str, Any]												= [
     "FlaxElectraForCausalLM",
     "FlaxElectraForMaskedLM",
     "FlaxElectraForMultipleChoice",
     "FlaxElectraForPreTraining",
     "FlaxElectraForQuestionAnswering",
     "FlaxElectraForSequenceClassification",
     "FlaxElectraForTokenClassification",
     "FlaxElectraModel",
     "FlaxElectraPreTrainedModel",
 ]


if TYPE_CHECKING:
 from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
 from .tokenization_electra import ElectraTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_electra_fast import ElectraTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_electra import (
      ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
      ElectraForCausalLM,
      ElectraForMaskedLM,
      ElectraForMultipleChoice,
      ElectraForPreTraining,
      ElectraForQuestionAnswering,
      ElectraForSequenceClassification,
      ElectraForTokenClassification,
      ElectraModel,
      ElectraPreTrainedModel,
      load_tf_weights_in_electra,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_electra import (
      TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFElectraForMaskedLM,
      TFElectraForMultipleChoice,
      TFElectraForPreTraining,
      TFElectraForQuestionAnswering,
      TFElectraForSequenceClassification,
      TFElectraForTokenClassification,
      TFElectraModel,
      TFElectraPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_electra import (
      FlaxElectraForCausalLM,
      FlaxElectraForMaskedLM,
      FlaxElectraForMultipleChoice,
      FlaxElectraForPreTraining,
      FlaxElectraForQuestionAnswering,
      FlaxElectraForSequenceClassification,
      FlaxElectraForTokenClassification,
      FlaxElectraModel,
      FlaxElectraPreTrainedModel,
  )

else:
 import sys

 SCREAMING_SNAKE_CASE       :      Optional[Any]												= _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






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


__A					:  str											=      get_tests_dir("fixtures")






class    __snake_case       (   unittest.TestCase):







    """simple docstring"""



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

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







@is_staging_test
class    __snake_case       (   unittest.TestCase):







    """simple docstring"""



    @classmethod
    def __lowercase   (   cls    :  Tuple		)   ->  str:
      lowerCAmelCase_			:      Dict			=   TOKEN
      HfFolder.save_token(lowerCamelCase		)

    @classmethod
    def __lowercase   (   cls    :  Any		)   ->  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 __lowercase   (   self    :  int		)   ->  str:
      lowerCAmelCase_			:      Tuple			=   WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase		)
      feature_extractor.push_to_hub("""test-feature-extractor"""    ,						use_auth_token=self._token		)

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

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

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

    def __lowercase   (   self    :  Optional[Any]		)   ->  int:
      lowerCAmelCase_			:      Union[str, Any]			=   WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase		)
      feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""    ,						use_auth_token=self._token		)

      lowerCAmelCase_			:      Optional[int]			=   WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor"""		)
      for k, v in feature_extractor.__dict__.items():
        self.assertEqual(lowerCamelCase    ,						getattr(lowerCamelCase    ,						lowerCamelCase		)		)

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

      lowerCAmelCase_			:      Optional[int]			=   WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor-org"""		)
      for k, v in feature_extractor.__dict__.items():
        self.assertEqual(lowerCamelCase    ,						getattr(lowerCamelCase    ,						lowerCamelCase		)		)





    def __lowercase   (   self    :  Optional[Any]		)   ->  Any:
      CustomFeatureExtractor.register_for_auto_class()
      lowerCAmelCase_			:      Dict			=   CustomFeatureExtractor.from_pretrained(lowerCamelCase		)

      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_			:      Union[str, Any]			=   AutoFeatureExtractor.from_pretrained(
          F'{USER}/test-dynamic-feature-extractor'    ,						trust_remote_code=lowerCamelCase		)
      # 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"""		)



