# flake8: noqa
# Lint as: python3

from typing import Dict, List, Optional, Type

from .. import config
from ..utils import logging
from .formatting import (
    ArrowFormatter,
    CustomFormatter,
    Formatter,
    PandasFormatter,
    PythonFormatter,
    TensorFormatter,
    format_table,
    query_table,
)
from .np_formatter import NumpyFormatter


__lowerCamelCase      :			Dict							       =		logging.get_logger(__name__)

__lowerCamelCase      :			Dict[Optional[str], Type[Formatter]]							       =		{}
__lowerCamelCase      :			Dict[Optional[str], str]							       =		{}
__lowerCamelCase      :			Dict[Optional[str], Exception]							       =		{}



def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	type			,					__UpperCamelCase   :	Optional[str]			,					__UpperCamelCase   :	Optional[List[str]] = None			,					)							-> Dict:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				aliases if aliases is not None else []
  if format_type in _FORMAT_TYPES:
    logger.warning(
        f"""Overwriting format type '{format_type}' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})"""     )
  SCREAMING_SNAKE_CASE__      							=				formatter_cls
  for alias in set(aliases + [format_type]     ):
    if alias in _FORMAT_TYPES_ALIASES:
      logger.warning(
          f"""Overwriting format type alias '{alias}' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})"""     )
    SCREAMING_SNAKE_CASE__      							=				format_type



def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Exception			,					__UpperCamelCase   :	Optional[str]			,					__UpperCamelCase   :	Optional[List[str]] = None     )							-> Any:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				aliases if aliases is not None else []
  for alias in set(aliases + [format_type]     ):
    SCREAMING_SNAKE_CASE__      							=				unavailable_error


# Here we define all the available formatting functions that can be used by `Dataset.set_format`
_register_formatter(PythonFormatter, None, aliases=['''python'''])
_register_formatter(ArrowFormatter, '''arrow''', aliases=['''pa''', '''pyarrow'''])
_register_formatter(NumpyFormatter, '''numpy''', aliases=['''np'''])
_register_formatter(PandasFormatter, '''pandas''', aliases=['''pd'''])
_register_formatter(CustomFormatter, '''custom''')

if config.TORCH_AVAILABLE:
   from .torch_formatter import TorchFormatter

   _register_formatter(TorchFormatter, '''torch''', aliases=['''pt''', '''pytorch'''])
else:
   __lowerCamelCase      :			List[str]							       =		ValueError('''PyTorch needs to be installed to be able to return PyTorch tensors.''')
   _register_unavailable_formatter(_torch_error, '''torch''', aliases=['''pt''', '''pytorch'''])

if config.TF_AVAILABLE:
   from .tf_formatter import TFFormatter

   _register_formatter(TFFormatter, '''tensorflow''', aliases=['''tf'''])
else:
   __lowerCamelCase      :			Any							       =		ValueError('''Tensorflow needs to be installed to be able to return Tensorflow tensors.''')
   _register_unavailable_formatter(_tf_error, '''tensorflow''', aliases=['''tf'''])

if config.JAX_AVAILABLE:
   from .jax_formatter import JaxFormatter

   _register_formatter(JaxFormatter, '''jax''', aliases=[])
else:
   __lowerCamelCase      :			Any							       =		ValueError('''JAX needs to be installed to be able to return JAX arrays.''')
   _register_unavailable_formatter(_jax_error, '''jax''', aliases=[])



def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Optional[str]     )							-> Optional[str]:







  """simple docstring"""





  if format_type in _FORMAT_TYPES_ALIASES:
    return _FORMAT_TYPES_ALIASES[format_type]
  else:
    return format_type






def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Optional[str]			,					**__UpperCamelCase   :	List[Any]     )							-> Formatter:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				get_format_type_from_alias(__UpperCamelCase     )
  if format_type in _FORMAT_TYPES:
    return _FORMAT_TYPES[format_type](**__UpperCamelCase     )
  if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
    raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
  else:
    raise ValueError(
        f"""Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None     )}, but got '{format_type}'"""     )

import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


sys.path.append(str(Path(__file__).parent.parent.parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


__lowerCamelCase      :			List[Any]							       =		get_tests_dir('''fixtures''')
__lowerCamelCase      :			Optional[int]							       =		get_tests_dir('''fixtures/dummy_feature_extractor_config.json''')
__lowerCamelCase      :			Any							       =		get_tests_dir('''fixtures/dummy-config.json''')







class __snake_case    (						unittest.TestCase		):




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				0




   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained("""facebook/wav2vec2-base-960h"""				)
     self.assertIsInstance(_lowercase	,     _lowercase				)




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



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(_lowercase				)
     self.assertIsInstance(_lowercase	,     _lowercase				)




   def      __a						(   self      :    Optional[int]				):



     """simple docstring"""






     with tempfile.TemporaryDirectory() as tmpdirname:
       SCREAMING_SNAKE_CASE__      							=				WavaVecaConfig()

       # remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally
       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(_lowercase				).to_dict()

       config_dict.pop("""feature_extractor_type"""				)
       SCREAMING_SNAKE_CASE__      							=				WavaVecaFeatureExtractor(**_lowercase				)

       # save in new folder
       model_config.save_pretrained(_lowercase				)
       config.save_pretrained(_lowercase				)

       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(_lowercase				)

       # make sure private variable is not incorrectly saved
       SCREAMING_SNAKE_CASE__      							=				json.loads(config.to_json_string()				)
       self.assertTrue("""_processor_class""" not in dict_as_saved				)

     self.assertIsInstance(_lowercase	,     _lowercase				)




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(_lowercase				)
     self.assertIsInstance(_lowercase	,     _lowercase				)




   def      __a						(   self      :    Dict				):



     """simple docstring"""






     with self.assertRaisesRegex(
         _lowercase	,     """bert-base is not a local folder and is not a valid model identifier"""				):
       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained("""bert-base"""				)




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



     """simple docstring"""






     with self.assertRaisesRegex(
         _lowercase	,     R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""				):
       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(_lowercase	,     revision="""aaaaaa"""				)




   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






     with self.assertRaisesRegex(
         _lowercase	,     """hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json."""	,     ):
       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained("""hf-internal-testing/config-no-model"""				)




   def      __a						(   self      :    str				):



     """simple docstring"""






     with self.assertRaises(_lowercase				):
       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(
           """hf-internal-testing/test_dynamic_feature_extractor"""				)
     # If remote code is disabled, we can't load this config.
     with self.assertRaises(_lowercase				):
       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(
           """hf-internal-testing/test_dynamic_feature_extractor"""	,     trust_remote_code=_lowercase				)

     SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(
         """hf-internal-testing/test_dynamic_feature_extractor"""	,     trust_remote_code=_lowercase				)
     self.assertEqual(feature_extractor.__class__.__name__	,     """NewFeatureExtractor"""				)

     # Test feature extractor can be reloaded.
     with tempfile.TemporaryDirectory() as tmp_dir:
       feature_extractor.save_pretrained(_lowercase				)
       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(_lowercase	,     trust_remote_code=_lowercase				)
     self.assertEqual(reloaded_feature_extractor.__class__.__name__	,     """NewFeatureExtractor"""				)




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



     """simple docstring"""






     try:
       AutoConfig.register("""custom"""	,     _lowercase				)
       AutoFeatureExtractor.register(_lowercase	,     _lowercase				)
       # Trying to register something existing in the Transformers library will raise an error
       with self.assertRaises(_lowercase				):
         AutoFeatureExtractor.register(_lowercase	,     _lowercase				)

       # Now that the config is registered, it can be used as any other config with the auto-API
       SCREAMING_SNAKE_CASE__      							=				CustomFeatureExtractor.from_pretrained(_lowercase				)
       with tempfile.TemporaryDirectory() as tmp_dir:
         feature_extractor.save_pretrained(_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(_lowercase				)
         self.assertIsInstance(_lowercase	,     _lowercase				)

     finally:
       if "custom" in CONFIG_MAPPING._extra_content:
         del CONFIG_MAPPING._extra_content["custom"]
       if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
         del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]




   def      __a						(   self      :    Any				):



     """simple docstring"""






     class __snake_case    (						lowerCamelCase_		):
        lowerCAmelCase_														=							True

     try:
       AutoConfig.register("""custom"""	,     _lowercase				)
       AutoFeatureExtractor.register(_lowercase	,     _lowercase				)
       # If remote code is not set, the default is to use local
       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(
           """hf-internal-testing/test_dynamic_feature_extractor"""				)
       self.assertEqual(feature_extractor.__class__.__name__	,     """NewFeatureExtractor"""				)
       self.assertTrue(feature_extractor.is_local				)

       # If remote code is disabled, we load the local one.
       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(
           """hf-internal-testing/test_dynamic_feature_extractor"""	,     trust_remote_code=_lowercase				)
       self.assertEqual(feature_extractor.__class__.__name__	,     """NewFeatureExtractor"""				)
       self.assertTrue(feature_extractor.is_local				)

       # If remote is enabled, we load from the Hub
       SCREAMING_SNAKE_CASE__      							=				AutoFeatureExtractor.from_pretrained(
           """hf-internal-testing/test_dynamic_feature_extractor"""	,     trust_remote_code=_lowercase				)
       self.assertEqual(feature_extractor.__class__.__name__	,     """NewFeatureExtractor"""				)
       self.assertTrue(not hasattr(_lowercase	,     """is_local"""				)				)

     finally:
       if "custom" in CONFIG_MAPPING._extra_content:
         del CONFIG_MAPPING._extra_content["custom"]
       if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
         del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
