


from unittest import TestCase

from datasets import Sequence, Value
from datasets.arrow_dataset import Dataset






class    _UpperCamelCase     (       __snake_case					):

				"""simple docstring"""







				def   _UpperCAmelCase       (    self )						->					List[Any]:
					return [
					    {"col_1": 3, "col_2": "a"},
					    {"col_1": 2, "col_2": "b"},
					    {"col_1": 1, "col_2": "c"},
					    {"col_1": 0, "col_2": "d"},
					]

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					A             =					{"""col_1""": [3, 2, 1, 0], """col_2""": ["""a""", """b""", """c""", """d"""]}
					return Dataset.from_dict(a__ )

				def   _UpperCAmelCase       (    self )						->					Tuple:
					A             =					self._create_example_records()
					A             =					Dataset.from_list(a__ )
					self.assertListEqual(dset.column_names					, ["""col_1""", """col_2"""] )
					for i, r in enumerate(a__ ):
						self.assertDictEqual(a__					, example_records[i] )

				def   _UpperCAmelCase       (    self )						->					Union[str, Any]:
					A             =					self._create_example_records()
					A             =					Dataset.from_list(a__ )
					A             =					Dataset.from_dict({k: [r[k] for r in example_records] for k in example_records[0]} )
					self.assertEqual(dset.info					, dset_from_dict.info )

				def   _UpperCAmelCase       (    self )						->					Tuple:  # checks what happens with missing columns
					A             =					[{"""col_1""": 1}, {"""col_2""": """x"""}]
					A             =					Dataset.from_list(a__ )
					self.assertDictEqual(dset[0]					, {"""col_1""": 1} )
					self.assertDictEqual(dset[1]					, {"""col_1""": None} )  # NB: first record is used for columns

				def   _UpperCAmelCase       (    self )						->					List[str]:  # checks if the type can be inferred from the second record
					A             =					[{"""col_1""": []}, {"""col_1""": [1, 2]}]
					A             =					Dataset.from_list(a__ )
					self.assertEqual(dset.info.features["""col_1"""]					, Sequence(Value("""int64""" ) ) )

				def   _UpperCAmelCase       (    self )						->					Dict:
					A             =					Dataset.from_list([] )
					self.assertEqual(len(a__ )					, 0 )
					self.assertListEqual(dset.column_names					, [] )







from ....configuration_utils import PretrainedConfig
from ....utils import logging


_lowercase							:   List[Any]						=						logging.get_logger(__name__)

_lowercase							:   List[str]						=						{
    "speechbrain/m-ctc-t-large": "https://huggingface.co/speechbrain/m-ctc-t-large/resolve/main/config.json",
    # See all M-CTC-T models at https://huggingface.co/models?filter=mctct
}






class    _UpperCamelCase     (       __snake_case					):

				"""simple docstring"""







				lowerCAmelCase					=			'mctct'

				def __init__(    self					, a__=8065					, a__=1536					, a__=36					, a__=6144					, a__=4					, a__=384					, a__=920					, a__=1e-5					, a__=0.3					, a__="relu"					, a__=0.02					, a__=0.3					, a__=0.3					, a__=1					, a__=0					, a__=2					, a__=1					, a__=0.3					, a__=1					, a__=(7,)					, a__=(3,)					, a__=80					, a__=1					, a__=None					, a__="sum"					, a__=False					, **a__					, )						->					Optional[Any]:
					super().__init__(**a__					, pad_token_id=a__					, bos_token_id=a__					, eos_token_id=a__ )
					A             =					vocab_size
					A             =					hidden_size
					A             =					num_hidden_layers
					A             =					intermediate_size
					A             =					num_attention_heads
					A             =					attention_head_dim
					A             =					max_position_embeddings
					A             =					layer_norm_eps
					A             =					layerdrop
					A             =					hidden_act
					A             =					initializer_range
					A             =					hidden_dropout_prob
					A             =					attention_probs_dropout_prob
					A             =					pad_token_id
					A             =					bos_token_id
					A             =					eos_token_id
					A             =					conv_glu_dim
					A             =					conv_dropout
					A             =					num_conv_layers
					A             =					input_feat_per_channel
					A             =					input_channels
					A             =					conv_channels
					A             =					ctc_loss_reduction
					A             =					ctc_zero_infinity

					# prevents config testing fail with exporting to json
					A             =					list(a__ )
					A             =					list(a__ )

					if len(self.conv_kernel ) != self.num_conv_layers:
						raise ValueError(
						    """Configuration for convolutional module is incorrect. """
						    """It is required that `len(config.conv_kernel)` == `config.num_conv_layers` """
						    f'but is `len(config.conv_kernel) = {len(self.conv_kernel )}`, '
						    f'`config.num_conv_layers = {self.num_conv_layers}`.' )



