

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


A_	:			Any  	=      logging.get_logger(__name__)

A_	:			int  	=      {
    'google/bit-50': 'https://huggingface.co/google/bit-50/resolve/main/config.json',
}



class    _a						(__magic_name__		,       __magic_name__    ):


					'''simple docstring'''






					UpperCAmelCase__:       Union[str, Any]  							=	'''bit'''
					UpperCAmelCase__:       Tuple  							=	['''preactivation''', '''bottleneck''']
					UpperCAmelCase__:       Optional[Any]  							=	['''SAME''', '''VALID''']






					def __init__(			self   ,	A__=3   ,	A__=64   ,	A__=[256, 512, 1024, 2048]   ,	A__=[3, 4, 6, 3]   ,	A__="preactivation"   ,	A__="relu"   ,	A__=None   ,	A__=32   ,	A__=0.0   ,	A__=False   ,	A__=32   ,	A__=1   ,	A__=None   ,	A__=None   ,	**A__   ,	):
						super().__init__(**A__      )
						if layer_type not in self.layer_types:
							raise ValueError(F"""layer_type={layer_type} is not one of {','.join(self.layer_types      )}"""      )
						if global_padding is not None:
							if global_padding.upper() in self.supported_padding:
								A__							:   Union[str, Any]					       =		global_padding.upper()
							else:
								raise ValueError(F"""Padding strategy {global_padding} not supported"""      )
						A__							:   List[Any]					       =		num_channels
						A__							:   str					       =		embedding_size
						A__							:   Tuple					       =		hidden_sizes
						A__							:   Optional[Any]					       =		depths
						A__							:   List[str]					       =		layer_type
						A__							:   Any					       =		hidden_act
						A__							:   List[Any]					       =		global_padding
						A__							:   str					       =		num_groups
						A__							:   List[str]					       =		drop_path_rate
						A__							:   Tuple					       =		embedding_dynamic_padding
						A__							:   str					       =		output_stride
						A__							:   Optional[int]					       =		width_factor

						A__							:   int					       =		["""stem"""] + [F"""stage{idx}""" for idx in range(1   ,	len(A__      ) + 1      )]
						A__							:   Optional[int]					       =		get_aligned_output_features_output_indices(
						    out_features=A__   ,	out_indices=A__   ,	stage_names=self.stage_names      )






import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin



class    _a						(__magic_name__    ):


					'''simple docstring'''






					UpperCAmelCase__:       Optional[Any]  							=	'''MCTCTFeatureExtractor'''
					UpperCAmelCase__:       Optional[int]  							=	'''AutoTokenizer'''






					def __init__(			self   ,	A__   ,	A__      ):
						super().__init__(A__   ,	A__      )
						A__							:   List[str]					       =		self.feature_extractor
						A__							:   Optional[int]					       =		False






					def __call__(			self   ,	*A__   ,	**A__      ):
						# For backward compatibility
						if self._in_target_context_manager:
							return self.current_processor(*A__   ,	**A__      )

						if "raw_speech" in kwargs:
							warnings.warn("""Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."""      )
							A__							:   Dict					       =		kwargs.pop("""raw_speech"""      )
						else:
							A__							:   Tuple					       =		kwargs.pop("""audio"""   ,	A__      )
						A__							:   Union[str, Any]					       =		kwargs.pop("""sampling_rate"""   ,	A__      )
						A__							:   int					       =		kwargs.pop("""text"""   ,	A__      )
						if len(A__      ) > 0:
							A__							:   Optional[int]					       =		args[0]
							A__							:   Dict					       =		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:
							A__							:   List[str]					       =		self.feature_extractor(A__   ,	*A__   ,	sampling_rate=A__   ,	**A__      )
						if text is not None:
							A__							:   Optional[Any]					       =		self.tokenizer(A__   ,	**A__      )

						if text is None:
							return inputs
						elif audio is None:
							return encodings
						else:
							A__							:   List[Any]					       =		encodings["""input_ids"""]
							return inputs






					def   __A      (			self   ,	*A__   ,	**A__      ):
						return self.tokenizer.batch_decode(*A__   ,	**A__      )






					def   __A      (			self   ,	*A__   ,	**A__      ):
						# For backward compatibility
						if self._in_target_context_manager:
							return self.current_processor.pad(*A__   ,	**A__      )

						A__							:   Optional[Any]					       =		kwargs.pop("""input_features"""   ,	A__      )
						A__							:   Union[str, Any]					       =		kwargs.pop("""labels"""   ,	A__      )
						if len(A__      ) > 0:
							A__							:   List[Any]					       =		args[0]
							A__							:   Optional[int]					       =		args[1:]

						if input_features is not None:
							A__							:   Union[str, Any]					       =		self.feature_extractor.pad(A__   ,	*A__   ,	**A__      )
						if labels is not None:
							A__							:   List[Any]					       =		self.tokenizer.pad(A__   ,	**A__      )

						if labels is None:
							return input_features
						elif input_features is None:
							return labels
						else:
							A__							:   Dict					       =		labels["""input_ids"""]
							return input_features






					def   __A      (			self   ,	*A__   ,	**A__      ):
						return self.tokenizer.decode(*A__   ,	**A__      )






					@contextmanager
					def   __A      (			self      ):
						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."""      )
						A__							:   int					       =		True
						A__							:   List[Any]					       =		self.tokenizer
						yield
						A__							:   Tuple					       =		self.feature_extractor
						A__							:   Dict					       =		False



