


'''simple docstring'''


from math import ceil
from typing import List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import BatchFeature, SequenceFeatureExtractor
from ...utils import TensorType, logging


__lowerCAmelCase	:       Union[str, Any]						       =	logging.get_logger(__name__)






class 						A   (   UpperCAmelCase   ):
							a_        =      ['''audio_values''', '''audio_mask''']





							def __init__(      self				:							int     ,		__a				:							Dict=2_0_4_8     ,		__a				:							List[str]=1     ,		__a				:							str=[1_6, 1_6]     ,		__a				:							str=1_2_8     ,		__a				:							Any=4_4_1_0_0     ,		__a				:							Dict=8_6     ,		__a				:							int=2_0_4_8     ,		__a				:							List[Any]=0.0     ,		**__a				:							List[Any]     ,		)							->	List[Any]:
								super().__init__(
								    feature_size=__a     ,		sampling_rate=__a     ,		padding_value=__a     ,		**__a     ,		)

								__UpperCAmelCase							=			spectrogram_length
								__UpperCAmelCase							=			num_channels
								__UpperCAmelCase							=			patch_size
								__UpperCAmelCase							=			feature_size // self.patch_size[1]
								__UpperCAmelCase							=			n_fft
								__UpperCAmelCase							=			sampling_rate // hop_length_to_sampling_rate
								__UpperCAmelCase							=			sampling_rate
								__UpperCAmelCase							=			padding_value
								__UpperCAmelCase							=			mel_filter_bank(
								    num_frequency_bins=1 + n_fft // 2     ,		num_mel_filters=__a     ,		min_frequency=0.0     ,		max_frequency=2_2_0_5_0.0     ,		sampling_rate=__a     ,		norm='''slaney'''     ,		mel_scale='''slaney'''     ,		).T





							def       snake_case__						(      self				:							Optional[Any]     ,		__a				:							np.array	)							->	np.ndarray:
								__UpperCAmelCase							=			spectrogram(
								    __a     ,		window_function(self.n_fft     ,		'''hann'''	)     ,		frame_length=self.n_fft     ,		hop_length=self.hop_length     ,		power=2.0     ,		mel_filters=self.mel_filters.T     ,		log_mel='''dB'''     ,		db_range=8_0.0     ,		)
								__UpperCAmelCase							=			log_spec[:, :-1]
								__UpperCAmelCase							=			log_spec - 2_0.0
								__UpperCAmelCase							=			np.clip(log_spec / 4_0.0     ,		-2.0     ,		0.0	) + 1.0
								return log_spec






							def __call__(      self				:							Union[str, Any]     ,		__a				:							Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]     ,		__a				:							Optional[Union[str, TensorType]] = None     ,		__a				:							Optional[bool] = True     ,		__a				:							Optional[int] = None     ,		__a				:							bool = False     ,		__a				:							bool = False     ,		**__a				:							Dict     ,		)							->	BatchFeature:

								if sampling_rate is not None:
									if sampling_rate != self.sampling_rate:
										raise ValueError(
										    '''This feature extractor is set to support sampling rate'''
										    f""" of {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled"""
										    f""" with {self.sampling_rate} and not {sampling_rate}."""	)
								else:
									logger.warning(
									    '''It is strongly recommended to pass the `sampling_rate` argument to this function. '''
									    '''Failing to do so can result in silent errors that might be hard to debug.'''	)

								__UpperCAmelCase							=			isinstance(__a     ,		np.ndarray	) and len(raw_speech.shape	) > 1
								if is_batched_numpy and len(raw_speech.shape	) > 2:
									raise ValueError(f"""Only mono-channel audio is supported for input to {self}"""	)
								__UpperCAmelCase							=			is_batched_numpy or (
								    isinstance(__a     ,		(list, tuple)	) and (isinstance(raw_speech[0]     ,		(np.ndarray, tuple, list)	))
								)
								if is_batched:
									__UpperCAmelCase							=			[np.asarray([speech]     ,		dtype=np.floataa	).T for speech in raw_speech]
								elif not is_batched and not isinstance(__a     ,		np.ndarray	):
									__UpperCAmelCase							=			np.asarray(__a     ,		dtype=np.floataa	)
								elif isinstance(__a     ,		np.ndarray	) and raw_speech.dtype is np.dtype(np.floataa	):
									__UpperCAmelCase							=			raw_speech.astype(np.floataa	)
								# always return batch
								if not is_batched:
									__UpperCAmelCase							=			[np.asarray([raw_speech]	).T]

								# Convert audio signals to log mel spectrograms, truncate by time axis
								__UpperCAmelCase							=			[
								    self._np_extract_fbank_features(waveform.squeeze()	).T[: self.spectrogram_length] for waveform in raw_speech
								]
								if isinstance(audio_features[0]     ,		__a	):
									__UpperCAmelCase							=			[np.asarray(__a     ,		dtype=np.floataa	) for feature in audio_features]

								# Create audio attention mask
								__UpperCAmelCase							=			max(
								    [ceil(feature.shape[0] / self.patch_size[0]	) * self.freq_len for feature in audio_features]	)  # The maximum number of audio patches in a batch
								if return_attention_mask:
									__UpperCAmelCase							=			[
									    (ceil(feature.shape[0] / self.patch_size[0]	) * self.freq_len) * [1]
									    + (max_patch_len - ceil(feature.shape[0] / self.patch_size[0]	) * self.freq_len) * [0]
									    for feature in audio_features
									]
									__UpperCAmelCase							=			np.array(__a	).astype(np.floataa	)

								# convert into correct format for padding
								__UpperCAmelCase							=			max_patch_len // self.freq_len * self.patch_size[0]  # The maximum audio size in a batch
								__UpperCAmelCase							=			np.ones([len(__a	), 1, max_time_len, self.feature_size]	).astype(np.floataa	)
								__UpperCAmelCase							=			padded_audio_features * self.padding_value
								for i in range(len(__a	)	):
									__UpperCAmelCase							=			audio_features[i]
									__UpperCAmelCase							=			feature

								# return as BatchFeature
								if return_attention_mask:
									__UpperCAmelCase							=			{'''audio_values''': padded_audio_features, '''audio_mask''': audio_mask}
								else:
									__UpperCAmelCase							=			{'''audio_values''': padded_audio_features}

								__UpperCAmelCase							=			BatchFeature(data=__a     ,		tensor_type=__a	)
								return encoded_inputs

'''simple docstring'''


from ..utils import DummyObject, requires_backends






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							int     ,		**__a				:							List[Any]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							int     ,		*__a				:							Optional[Any]     ,		**__a				:							Tuple	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Tuple     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							str     ,		**__a				:							Tuple	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							List[str]     ,		**__a				:							Optional[int]	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							str     ,		**__a				:							Any	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							Dict     ,		**__a				:							List[str]	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Any     ,		**__a				:							List[Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							Optional[int]     ,		**__a				:							Optional[int]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Dict     ,		**__a				:							List[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							List[str]     ,		**__a				:							List[str]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Optional[int]     ,		**__a				:							Dict	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Tuple     ,		**__a				:							Any	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Tuple     ,		**__a				:							Optional[int]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							str     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							int	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							int     ,		**__a				:							str	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Tuple     ,		*__a				:							str     ,		**__a				:							Tuple	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							List[str]     ,		**__a				:							Optional[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Optional[int]     ,		**__a				:							Union[str, Any]	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[str]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Dict     ,		**__a				:							Union[str, Any]	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Union[str, Any]     ,		**__a				:							Any	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							int     ,		**__a				:							int	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Optional[int]     ,		**__a				:							int	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Tuple     ,		**__a				:							str	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)





def       lowerCAmelCase					(		*UpperCamelCase__				:   int    ,					**UpperCamelCase__				:   Optional[int]       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Optional[int]    ,					**UpperCamelCase__				:   List[Any]       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Any    ,					**UpperCamelCase__				:   List[str]       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   str    ,					**UpperCamelCase__				:   str       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Dict    ,					**UpperCamelCase__				:   Dict       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Tuple    ,					**UpperCamelCase__				:   int       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Union[str, Any]    ,					**UpperCamelCase__				:   Tuple       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							str     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							int     ,		**__a				:							int	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Dict     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							str     ,		**__a				:							List[str]	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							List[Any]     ,		**__a				:							List[Any]	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Tuple     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							int	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Optional[Any]     ,		**__a				:							Tuple	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							str     ,		**__a				:							int	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Dict     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							str     ,		**__a				:							str	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							str	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							int     ,		**__a				:							Tuple	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Tuple     ,		**__a				:							str	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							Dict	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							str     ,		**__a				:							List[str]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							int     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							str     ,		**__a				:							List[Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							int     ,		**__a				:							List[str]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							int     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[Any]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							List[Any]     ,		**__a				:							str	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Optional[Any]     ,		**__a				:							Any	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							int     ,		**__a				:							Dict	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							int     ,		**__a				:							Dict	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Tuple     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							str     ,		**__a				:							Any	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Dict     ,		**__a				:							Optional[Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							str     ,		**__a				:							Union[str, Any]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Optional[Any]     ,		**__a				:							List[str]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Any	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Tuple     ,		*__a				:							Optional[int]     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Optional[Any]     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Any     ,		**__a				:							str	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							int     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							Union[str, Any]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Dict     ,		**__a				:							Union[str, Any]	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Tuple     ,		**__a				:							Optional[int]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Union[str, Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							int	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Optional[Any]     ,		**__a				:							str	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Tuple     ,		**__a				:							int	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Optional[int]     ,		**__a				:							Tuple	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[Any]     ,		*__a				:							Optional[int]     ,		**__a				:							int	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							int     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							Any     ,		**__a				:							int	)							->	Tuple:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Union[str, Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							List[Any]     ,		**__a				:							Dict	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[Any]     ,		*__a				:							int     ,		**__a				:							Optional[int]	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Tuple     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Dict     ,		**__a				:							Optional[int]	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Any     ,		**__a				:							Dict	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Any     ,		**__a				:							Any	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							Tuple     ,		**__a				:							Optional[int]	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Optional[Any]     ,		**__a				:							Optional[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							List[Any]     ,		**__a				:							Dict	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Any     ,		**__a				:							Optional[int]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[str]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Optional[int]     ,		**__a				:							List[Any]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Dict     ,		**__a				:							int	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Optional[int]     ,		**__a				:							Union[str, Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Union[str, Any]     ,		**__a				:							int	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							List[Any]     ,		**__a				:							Optional[int]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Optional[Any]     ,		**__a				:							Optional[int]	)							->	Tuple:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Optional[int]     ,		**__a				:							List[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							Tuple     ,		**__a				:							Tuple	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							List[str]     ,		**__a				:							Tuple	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Tuple     ,		**__a				:							Optional[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Union[str, Any]	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Any     ,		**__a				:							List[str]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							int     ,		**__a				:							int	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Any     ,		**__a				:							List[Any]	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							int     ,		**__a				:							str	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Dict     ,		**__a				:							Optional[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							str     ,		**__a				:							Optional[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Optional[Any]     ,		**__a				:							str	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							List[Any]     ,		**__a				:							Union[str, Any]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							List[str]     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Dict     ,		**__a				:							Optional[Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							str     ,		**__a				:							Any	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Any     ,		**__a				:							Any	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							int     ,		*__a				:							Any     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							int     ,		**__a				:							List[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Tuple     ,		*__a				:							int     ,		**__a				:							Optional[Any]	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Union[str, Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							Optional[int]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							List[str]     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							int     ,		**__a				:							Any	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							List[str]     ,		**__a				:							List[str]	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)
