


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






       def  __snake_case						(   self  :    Union[str, Any]				):

              '''simple docstring'''






              lowercase		:Any       							=				mock.Mock()
              lowercase		:Union[str, Any]       							=				5_0_0
              lowercase		:Any       							=				{}
              lowercase		:Union[str, Any]       							=				HTTPError
              lowercase		:Optional[Any]       							=				{}

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







       def  __snake_case						(   self  :    List[Any]				):

              '''simple docstring'''






              lowercase		:int       							=				WavaVecaFeatureExtractor.from_pretrained(
                  '''https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json'''				)







@is_staging_test
class 					__magic_name__		(			unittest.TestCase     ):






       @classmethod
       def  __snake_case						(   cls  :    List[str]				):

              '''simple docstring'''






              lowercase		:int       							=				TOKEN
              HfFolder.save_token(__UpperCamelCase				)






       @classmethod
       def  __snake_case						(   cls  :    Any				):

              '''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  __snake_case						(   self  :    int				):

              '''simple docstring'''






              lowercase		:int       							=				WavaVecaFeatureExtractor.from_pretrained(__UpperCamelCase				)
              feature_extractor.push_to_hub('''test-feature-extractor'''  ,     use_auth_token=self._token				)

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

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

              lowercase		:List[Any]       							=				WavaVecaFeatureExtractor.from_pretrained(f"""{USER}/test-feature-extractor"""				)
              for k, v in feature_extractor.__dict__.items():
                     self.assertEqual(__UpperCamelCase  ,     getattr(__UpperCamelCase  ,     __UpperCamelCase				)				)






       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:List[str]       							=				WavaVecaFeatureExtractor.from_pretrained(__UpperCamelCase				)
              feature_extractor.push_to_hub('''valid_org/test-feature-extractor'''  ,     use_auth_token=self._token				)

              lowercase		:str       							=				WavaVecaFeatureExtractor.from_pretrained('''valid_org/test-feature-extractor'''				)
              for k, v in feature_extractor.__dict__.items():
                     self.assertEqual(__UpperCamelCase  ,     getattr(__UpperCamelCase  ,     __UpperCamelCase				)				)

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

              lowercase		:List[Any]       							=				WavaVecaFeatureExtractor.from_pretrained('''valid_org/test-feature-extractor-org'''				)
              for k, v in feature_extractor.__dict__.items():
                     self.assertEqual(__UpperCamelCase  ,     getattr(__UpperCamelCase  ,     __UpperCamelCase				)				)







       def  __snake_case						(   self  :    int				):

              '''simple docstring'''






              CustomFeatureExtractor.register_for_auto_class()
              lowercase		:Dict       							=				CustomFeatureExtractor.from_pretrained(__UpperCamelCase				)

              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		:Any       							=				AutoFeatureExtractor.from_pretrained(
                  f"""{USER}/test-dynamic-feature-extractor"""  ,     trust_remote_code=__UpperCamelCase				)
              # 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_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase      		=			{
    '''configuration_xlm_roberta''': [
        '''XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''XLMRobertaConfig''',
        '''XLMRobertaOnnxConfig''',
    ],
}

try:
 if not is_sentencepiece_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=			['''XLMRobertaTokenizer''']

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=			['''XLMRobertaTokenizerFast''']

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=			[
     '''XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''XLMRobertaForCausalLM''',
     '''XLMRobertaForMaskedLM''',
     '''XLMRobertaForMultipleChoice''',
     '''XLMRobertaForQuestionAnswering''',
     '''XLMRobertaForSequenceClassification''',
     '''XLMRobertaForTokenClassification''',
     '''XLMRobertaModel''',
     '''XLMRobertaPreTrainedModel''',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=			[
     '''TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''TFXLMRobertaForCausalLM''',
     '''TFXLMRobertaForMaskedLM''',
     '''TFXLMRobertaForMultipleChoice''',
     '''TFXLMRobertaForQuestionAnswering''',
     '''TFXLMRobertaForSequenceClassification''',
     '''TFXLMRobertaForTokenClassification''',
     '''TFXLMRobertaModel''',
     '''TFXLMRobertaPreTrainedModel''',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=			[
     '''FLAX_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''FlaxXLMRobertaForMaskedLM''',
     '''FlaxXLMRobertaForCausalLM''',
     '''FlaxXLMRobertaForMultipleChoice''',
     '''FlaxXLMRobertaForQuestionAnswering''',
     '''FlaxXLMRobertaForSequenceClassification''',
     '''FlaxXLMRobertaForTokenClassification''',
     '''FlaxXLMRobertaModel''',
     '''FlaxXLMRobertaPreTrainedModel''',
 ]

if TYPE_CHECKING:
 from .configuration_xlm_roberta import (
     XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP,
     XLMRobertaConfig,
     XLMRobertaOnnxConfig,
 )

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_xlm_roberta import XLMRobertaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_xlm_roberta_fast import XLMRobertaTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_xlm_roberta import (
      XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
      XLMRobertaForCausalLM,
      XLMRobertaForMaskedLM,
      XLMRobertaForMultipleChoice,
      XLMRobertaForQuestionAnswering,
      XLMRobertaForSequenceClassification,
      XLMRobertaForTokenClassification,
      XLMRobertaModel,
      XLMRobertaPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_xlm_roberta import (
      TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFXLMRobertaForCausalLM,
      TFXLMRobertaForMaskedLM,
      TFXLMRobertaForMultipleChoice,
      TFXLMRobertaForQuestionAnswering,
      TFXLMRobertaForSequenceClassification,
      TFXLMRobertaForTokenClassification,
      TFXLMRobertaModel,
      TFXLMRobertaPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_xlm_roberta import (
      FLAX_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
      FlaxXLMRobertaForCausalLM,
      FlaxXLMRobertaForMaskedLM,
      FlaxXLMRobertaForMultipleChoice,
      FlaxXLMRobertaForQuestionAnswering,
      FlaxXLMRobertaForSequenceClassification,
      FlaxXLMRobertaForTokenClassification,
      FlaxXLMRobertaModel,
      FlaxXLMRobertaPreTrainedModel,
  )

else:
 import sys

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

