


'''simple docstring'''
import dataclasses
import json
import warnings
from dataclasses import dataclass, field
from time import time
from typing import List

from ..utils import logging


__snake_case							   =  logging.get_logger(__name__)


def     a   (    __a=None				,      __a=None     )						->			Any:



					'''simple docstring'''






					return field(default_factory=lambda: default				,      metadata=__a     )







@dataclass
class      lowercase			:

		"""simple docstring"""

		_a									=       list_field(
		    default=[]			,	metadata={
		        'help': (
		            'Model checkpoints to be provided to the AutoModel classes. Leave blank to benchmark the base version'
		            ' of all available models'
		        )
		    }			,	)

		_a									=       list_field(
		    default=[8]			,	metadata={'help': 'List of batch sizes for which memory and time performance will be evaluated'}      )

		_a									=       list_field(
		    default=[8, 32, 1_28, 5_12]			,	metadata={'help': 'List of sequence lengths for which memory and time performance will be evaluated'}			,	)

		_a									=       field(
		    default=A__			,	metadata={'help': 'Whether to benchmark inference of model. Inference can be disabled via --no-inference.'}			,	)
		_a									=       field(
		    default=A__			,	metadata={'help': 'Whether to run on available cuda devices. Cuda can be disabled via --no-cuda.'}			,	)
		_a									=       field(
		    default=A__			,	metadata={'help': 'Whether to run on available tpu devices. TPU can be disabled via --no-tpu.'}      )
		_a									=       field(default=A__			,	metadata={'help': 'Use FP16 to accelerate inference.'}      )
		_a									=       field(default=A__			,	metadata={'help': 'Benchmark training of model'}      )
		_a									=       field(default=A__			,	metadata={'help': 'Verbose memory tracing'}      )
		_a									=       field(
		    default=A__			,	metadata={'help': 'Whether to perform speed measurements. Speed measurements can be disabled via --no-speed.'}			,	)
		_a									=       field(
		    default=A__			,	metadata={
		        'help': 'Whether to perform memory measurements. Memory measurements can be disabled via --no-memory'
		    }			,	)
		_a									=       field(default=A__			,	metadata={'help': 'Trace memory line by line'}      )
		_a									=       field(default=A__			,	metadata={'help': 'Save result to a CSV file'}      )
		_a									=       field(default=A__			,	metadata={'help': 'Save all print statements in a log file'}      )
		_a									=       field(default=A__			,	metadata={'help': 'Whether to print environment information'}      )
		_a									=       field(
		    default=A__			,	metadata={
		        'help': (
		            'Whether to use multiprocessing for memory and speed measurement. It is highly recommended to use'
		            ' multiprocessing for accurate CPU and GPU memory measurements. This option should only be disabled'
		            ' for debugging / testing and on TPU.'
		        )
		    }			,	)
		_a									=       field(
		    default=f'''inference_time_{round(time()      )}.csv'''			,	metadata={'help': 'CSV filename used if saving time results to csv.'}			,	)
		_a									=       field(
		    default=f'''inference_memory_{round(time()      )}.csv'''			,	metadata={'help': 'CSV filename used if saving memory results to csv.'}			,	)
		_a									=       field(
		    default=f'''train_time_{round(time()      )}.csv'''			,	metadata={'help': 'CSV filename used if saving time results to csv for training.'}			,	)
		_a									=       field(
		    default=f'''train_memory_{round(time()      )}.csv'''			,	metadata={'help': 'CSV filename used if saving memory results to csv for training.'}			,	)
		_a									=       field(
		    default=f'''env_info_{round(time()      )}.csv'''			,	metadata={'help': 'CSV filename used if saving environment information.'}			,	)
		_a									=       field(
		    default=f'''log_{round(time()      )}.csv'''			,	metadata={'help': 'Log filename used if print statements are saved in log.'}			,	)
		_a									=       field(default=3			,	metadata={'help': 'Times an experiment will be run.'}      )
		_a									=       field(
		    default=A__			,	metadata={
		        'help': (
		            'Instead of loading the model as defined in `config.architectures` if exists, just load the pretrain'
		            ' model weights.'
		        )
		    }			,	)




		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							warnings.warn(
							    F'''The class {self.__class__} is deprecated. Hugging Face Benchmarking utils'''
							    ''' are deprecated in general and it is advised to use external Benchmarking libraries '''
							    ''' to benchmark Transformer models.'''					,     UpperCamelCase_					,     )




		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							return json.dumps(dataclasses.asdict(self							)					,     indent=2							)




		@property
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							if len(self.models							) <= 0:
												raise ValueError(
												    '''Please make sure you provide at least one model name / model identifier, *e.g.* `--models'''
												    ''' bert-base-cased` or `args.models = [\'bert-base-cased\'].'''							)
							return self.models




		@property
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							if not self.multi_process:
												return False
							elif self.is_tpu:
												logger.info('''Multiprocessing is currently not possible on TPU.'''							)
												return False
							else:
												return True



'''simple docstring'''
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
class      lowercase			(							A__      ):

		"""simple docstring"""

		_a									=       'Speech2TextFeatureExtractor'
		_a									=       'Speech2TextTokenizer'




		def __init__(	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							super().__init__(UpperCamelCase_					,     UpperCamelCase_							)
							UpperCamelCase__     :List[str]							      =				self.feature_extractor
							UpperCamelCase__     :Optional[Any]							      =				False




		def __call__(	self					,     *UpperCamelCase_					,     **UpperCamelCase_							):

							'''simple docstring'''


							if self._in_target_context_manager:
												return self.current_processor(*UpperCamelCase_					,     **UpperCamelCase_							)

							if "raw_speech" in kwargs:
												warnings.warn('''Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'''							)
												UpperCamelCase__     :Optional[Any]							      =				kwargs.pop('''raw_speech'''							)
							else:
												UpperCamelCase__     :List[Any]							      =				kwargs.pop('''audio'''					,     UpperCamelCase_							)
							UpperCamelCase__     :List[Any]							      =				kwargs.pop('''sampling_rate'''					,     UpperCamelCase_							)
							UpperCamelCase__     :Dict							      =				kwargs.pop('''text'''					,     UpperCamelCase_							)
							if len(UpperCamelCase_							) > 0:
												UpperCamelCase__     :Tuple							      =				args[0]
												UpperCamelCase__     :Optional[int]							      =				args[1:]

							if audio is None and text is None:
												raise ValueError('''You need to specify either an `audio` or `text` input to process.'''							)

							if audio is not None:
												UpperCamelCase__     :Any							      =				self.feature_extractor(UpperCamelCase_					,     *UpperCamelCase_					,     sampling_rate=UpperCamelCase_					,     **UpperCamelCase_							)
							if text is not None:
												UpperCamelCase__     :Dict							      =				self.tokenizer(UpperCamelCase_					,     **UpperCamelCase_							)

							if text is None:
												return inputs
							elif audio is None:
												return encodings
							else:
												UpperCamelCase__     :Dict							      =				encodings['''input_ids''']
												return inputs




		def 					lowerCAmelCase__       (	self					,     *UpperCamelCase_					,     **UpperCamelCase_							):

							'''simple docstring'''


							return self.tokenizer.batch_decode(*UpperCamelCase_					,     **UpperCamelCase_							)




		def 					lowerCAmelCase__       (	self					,     *UpperCamelCase_					,     **UpperCamelCase_							):

							'''simple docstring'''


							return self.tokenizer.decode(*UpperCamelCase_					,     **UpperCamelCase_							)




		@contextmanager
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							warnings.warn(
							    '''`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '''
							    '''labels by using the argument `text` of the regular `__call__` method (either in the same call as '''
							    '''your audio inputs, or in a separate call.'''							)
							UpperCamelCase__     :Optional[Any]							      =				True
							UpperCamelCase__     :Any							      =				self.tokenizer
							yield
							UpperCamelCase__     :Any							      =				self.feature_extractor
							UpperCamelCase__     :Any							      =				False