



'''simple docstring'''





from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
 import tensorflow as tf


_lowerCAmelCase      						=	logging.get_logger(__name__)






@dataclass
class        lowerCAmelCase_(				SCREAMING_SNAKE_CASE_     ):
  '''simple docstring'''




  __lowercase							:      Any				=      [
      '''no_inference''',
      '''no_cuda''',
      '''no_tpu''',
      '''no_speed''',
      '''no_memory''',
      '''no_env_print''',
      '''no_multi_process''',
  ]




  def __init__(    self  ,**__UpperCAmelCase      )    ->		int:
      for deprecated_arg in self.deprecated_args:
          if deprecated_arg in kwargs:
              lowerCAmelCase__ :  str							      =					deprecated_arg[3:]
              lowerCAmelCase__ :  Union[str, Any]							      =					not kwargs.pop(__UpperCAmelCase      )
              logger.warning(
                  F"""{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"""
                  F""" {positive_arg}={kwargs[positive_arg]}"""      )
      lowerCAmelCase__ :  Union[str, Any]							      =					kwargs.pop("""tpu_name"""  ,self.tpu_name      )
      lowerCAmelCase__ :  str							      =					kwargs.pop("""device_idx"""  ,self.device_idx      )
      lowerCAmelCase__ :  int							      =					kwargs.pop("""eager_mode"""  ,self.eager_mode      )
      lowerCAmelCase__ :  int							      =					kwargs.pop("""use_xla"""  ,self.use_xla      )
      super().__init__(**__UpperCAmelCase      )

  __lowercase							:      str				=      field(
      default=SCREAMING_SNAKE_CASE_						, metadata={'''help''': '''Name of TPU'''}						, )
  __lowercase							:      int				=      field(
      default=0						, metadata={'''help''': '''CPU / GPU device index. Defaults to 0.'''}						, )
  __lowercase							:      bool				=      field(default=SCREAMING_SNAKE_CASE_						, metadata={'''help''': '''Benchmark models in eager model.'''}     )
  __lowercase							:      bool				=      field(
      default=SCREAMING_SNAKE_CASE_						, metadata={
          '''help''': '''Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`.'''
      }						, )




  @cached_property
  def 							UpperCAmelCase_	(    self      )    ->		Tuple["tf.distribute.cluster_resolver.TPUClusterResolver"]:
      requires_backends(self  ,["""tf"""]      )
      lowerCAmelCase__ :  Any							      =					None
      if self.tpu:
          try:
              if self.tpu_name:
                  lowerCAmelCase__ :  List[Any]							      =					tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name      )
              else:
                  lowerCAmelCase__ :  Any							      =					tf.distribute.cluster_resolver.TPUClusterResolver()
          except ValueError:
              lowerCAmelCase__ :  Optional[Any]							      =					None
      return tpu




  @cached_property
  def 							UpperCAmelCase_	(    self      )    ->		Tuple["tf.distribute.Strategy", "tf.distribute.cluster_resolver.TPUClusterResolver"]:
      requires_backends(self  ,["""tf"""]      )
      if self.is_tpu:
          tf.config.experimental_connect_to_cluster(self._setup_tpu      )
          tf.tpu.experimental.initialize_tpu_system(self._setup_tpu      )

          lowerCAmelCase__ :  Any							      =					tf.distribute.TPUStrategy(self._setup_tpu      )
      else:
          # currently no multi gpu is allowed
          if self.is_gpu:
              # TODO: Currently only single GPU is supported
              tf.config.set_visible_devices(self.gpu_list[self.device_idx]  ,"""GPU"""      )
              lowerCAmelCase__ :  str							      =					tf.distribute.OneDeviceStrategy(device=F"""/gpu:{self.device_idx}"""      )
          else:
              tf.config.set_visible_devices([]  ,"""GPU"""      )  # disable GPU
              lowerCAmelCase__ :  str							      =					tf.distribute.OneDeviceStrategy(device=F"""/cpu:{self.device_idx}"""      )

      return strategy




  @property
  def 							UpperCAmelCase_	(    self      )    ->		bool:
      requires_backends(self  ,["""tf"""]      )
      return self._setup_tpu is not None




  @property
  def 							UpperCAmelCase_	(    self      )    ->		"tf.distribute.Strategy":
      requires_backends(self  ,["""tf"""]      )
      return self._setup_strategy




  @property
  def 							UpperCAmelCase_	(    self      )    ->		str:
      requires_backends(self  ,["""tf"""]      )
      return tf.config.list_physical_devices("""GPU"""      )




  @property
  def 							UpperCAmelCase_	(    self      )    ->		int:
      requires_backends(self  ,["""tf"""]      )
      if self.cuda:
          return len(self.gpu_list      )
      return 0






  @property
  def 							UpperCAmelCase_	(    self      )    ->		bool:
      return self.n_gpu > 0








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


UpperCAmelCase_									=	get_tests_dir('fixtures')
UpperCAmelCase_									=	get_tests_dir('fixtures/dummy_feature_extractor_config.json')
UpperCAmelCase_									=	get_tests_dir('fixtures/dummy-config.json')





class     lowerCamelCase__(					unittest.TestCase):
      def 			lowerCAmelCase__						(				self: List[str]   ):
             __lowerCamelCase   =						0
      def 			lowerCAmelCase__						(				self: List[str]   ):
             __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained("""facebook/wav2vec2-base-960h"""   )
             self.assertIsInstance(UpperCamelCase_    ,       UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: Union[str, Any]   ):
             __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained(UpperCamelCase_   )
             self.assertIsInstance(UpperCamelCase_    ,       UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: int   ):
             with tempfile.TemporaryDirectory() as tmpdirname:
                    __lowerCamelCase   =						WavaVecaConfig()

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

                    config_dict.pop("""feature_extractor_type"""   )
                    __lowerCamelCase   =						WavaVecaFeatureExtractor(**UpperCamelCase_   )

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

                    __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained(UpperCamelCase_   )

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

             self.assertIsInstance(UpperCamelCase_    ,       UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: Tuple   ):
             __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained(UpperCamelCase_   )
             self.assertIsInstance(UpperCamelCase_    ,       UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: int   ):
             with self.assertRaisesRegex(
                 UpperCamelCase_    ,       """bert-base is not a local folder and is not a valid model identifier"""   ):
                    __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained("""bert-base"""   )
      def 			lowerCAmelCase__						(				self: Tuple   ):
             with self.assertRaisesRegex(
                 UpperCamelCase_    ,       r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""   ):
                    __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained(UpperCamelCase_    ,       revision="""aaaaaa"""   )
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             with self.assertRaisesRegex(
                 UpperCamelCase_    ,       """hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json."""    ,       ):
                    __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained("""hf-internal-testing/config-no-model"""   )
      def 			lowerCAmelCase__						(				self: Tuple   ):
             # If remote code is not set, we will time out when asking whether to load the model.
             with self.assertRaises(UpperCamelCase_   ):
                    __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained(
                        """hf-internal-testing/test_dynamic_feature_extractor"""   )
             # If remote code is disabled, we can't load this config.
             with self.assertRaises(UpperCamelCase_   ):
                    __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained(
                        """hf-internal-testing/test_dynamic_feature_extractor"""    ,       trust_remote_code=UpperCamelCase_   )

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

             # Test feature extractor can be reloaded.
             with tempfile.TemporaryDirectory() as tmp_dir:
                    feature_extractor.save_pretrained(UpperCamelCase_   )
                    __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained(UpperCamelCase_    ,       trust_remote_code=UpperCamelCase_   )
             self.assertEqual(reloaded_feature_extractor.__class__.__name__    ,       """NewFeatureExtractor"""   )
      def 			lowerCAmelCase__						(				self: Any   ):
             try:
                    AutoConfig.register("""custom"""    ,       UpperCamelCase_   )
                    AutoFeatureExtractor.register(UpperCamelCase_    ,       UpperCamelCase_   )
                    # Trying to register something existing in the Transformers library will raise an error
                    with self.assertRaises(UpperCamelCase_   ):
                           AutoFeatureExtractor.register(UpperCamelCase_    ,       UpperCamelCase_   )

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

             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 			lowerCAmelCase__						(				self: Dict   ):





             class     lowerCamelCase__(					__lowerCamelCase):
                   UpperCAmelCase__      :	str    		=   True

             try:
                    AutoConfig.register("""custom"""    ,       UpperCamelCase_   )
                    AutoFeatureExtractor.register(UpperCamelCase_    ,       UpperCamelCase_   )
                    # If remote code is not set, the default is to use local
                    __lowerCamelCase   =						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.
                    __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained(
                        """hf-internal-testing/test_dynamic_feature_extractor"""    ,       trust_remote_code=UpperCamelCase_   )
                    self.assertEqual(feature_extractor.__class__.__name__    ,       """NewFeatureExtractor"""   )
                    self.assertTrue(feature_extractor.is_local   )

                    # If remote is enabled, we load from the Hub
                    __lowerCamelCase   =						AutoFeatureExtractor.from_pretrained(
                        """hf-internal-testing/test_dynamic_feature_extractor"""    ,       trust_remote_code=UpperCamelCase_   )
                    self.assertEqual(feature_extractor.__class__.__name__    ,       """NewFeatureExtractor"""   )
                    self.assertTrue(not hasattr(UpperCamelCase_    ,       """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]

