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


lowercase  :					int													=       logging.get_logger(__name__)

lowercase  :					Dict													=       {
    'facebook/s2t-small-librispeech-asr': (
        'https://huggingface.co/facebook/s2t-small-librispeech-asr/resolve/main/config.json'
    ),
    # See all Speech2Text models at https://huggingface.co/models?filter=speech_to_text
}




class  lowerCamelCase__							(				__lowercase):




	'''simple docstring'''




	_A								=     'speech_to_text'
	_A								=     ['past_key_values']
	_A								=     {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}







	def __init__(					self		:Optional[int]     ,   a		:str=1_0_0_0_0     ,   a		:str=1_2     ,   a		:Dict=2_0_4_8     ,   a		:Dict=4     ,   a		:List[str]=6     ,   a		:int=2_0_4_8     ,   a		:List[str]=4     ,   a		:Any=0.0     ,   a		:Optional[int]=0.0     ,   a		:Tuple=True     ,   a		:Any=True     ,   a		:Tuple="relu"     ,   a		:Optional[int]=2_5_6     ,   a		:Optional[int]=0.1     ,   a		:Tuple=0.0     ,   a		:Optional[int]=0.0     ,   a		:List[str]=0.02     ,   a		:Optional[int]=2     ,   a		:Optional[Any]=True     ,   a		:Optional[Any]=1     ,   a		:Union[str, Any]=0     ,   a		:Union[str, Any]=2     ,   a		:int=6_0_0_0     ,   a		:Dict=1_0_2_4     ,   a		:Tuple=2     ,   a		:int=(5, 5)     ,   a		:List[Any]=1_0_2_4     ,   a		:Union[str, Any]=8_0     ,   a		:List[str]=1     ,   **a		:Union[str, Any]     ,   )		-> Dict:
								__UpperCamelCase	:   int			   =					vocab_size
								__UpperCamelCase	:   Any			   =					d_model
								__UpperCamelCase	:   List[Any]			   =					encoder_ffn_dim
								__UpperCamelCase	:   List[str]			   =					encoder_layers
								__UpperCamelCase	:   List[str]			   =					encoder_attention_heads
								__UpperCamelCase	:   Union[str, Any]			   =					decoder_ffn_dim
								__UpperCamelCase	:   str			   =					decoder_layers
								__UpperCamelCase	:   Union[str, Any]			   =					decoder_attention_heads
								__UpperCamelCase	:   List[str]			   =					dropout
								__UpperCamelCase	:   Any			   =					attention_dropout
								__UpperCamelCase	:   Optional[Any]			   =					activation_dropout
								__UpperCamelCase	:   Dict			   =					activation_function
								__UpperCamelCase	:   Tuple			   =					init_std
								__UpperCamelCase	:   List[str]			   =					encoder_layerdrop
								__UpperCamelCase	:   int			   =					decoder_layerdrop
								__UpperCamelCase	:   Any			   =					use_cache
								__UpperCamelCase	:   int			   =					encoder_layers
								__UpperCamelCase	:   int			   =					scale_embedding  # scale factor will be sqrt(d_model) if True
								__UpperCamelCase	:   Optional[Any]			   =					max_source_positions
								__UpperCamelCase	:   List[Any]			   =					max_target_positions
								__UpperCamelCase	:   int			   =					num_conv_layers
								__UpperCamelCase	:   int			   =					list(a						)
								__UpperCamelCase	:   List[str]			   =					conv_channels
								__UpperCamelCase	:   Dict			   =					input_feat_per_channel
								__UpperCamelCase	:   Dict			   =					input_channels

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

								super().__init__(
								    pad_token_id=a     ,   bos_token_id=a     ,   eos_token_id=a     ,   is_encoder_decoder=a     ,   decoder_start_token_id=a     ,   **a     ,   )

import argparse
import datetime




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			str)					->    str:






							'''simple docstring'''





							__UpperCamelCase	:   str			   =					{
							    "0": "Sunday",
							    "1": "Monday",
							    "2": "Tuesday",
							    "3": "Wednesday",
							    "4": "Thursday",
							    "5": "Friday",
							    "6": "Saturday",
							}

							__UpperCamelCase	:   List[str]			   =					{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

							# Validate
							if not 0 < len(_lowerCamelCase) < 11:
														raise ValueError("Must be 10 characters long")

							# Get month
							__UpperCamelCase	:   int			   =					int(date_input[0] + date_input[1])
							# Validate
							if not 0 < m < 13:
														raise ValueError("Month must be between 1 - 12")

							__UpperCamelCase	:   str			   =					date_input[2]
							# Validate
							if sep_a not in ["-", "/"]:
														raise ValueError("Date separator must be '-' or '/'")

							# Get day
							__UpperCamelCase	:   int			   =					int(date_input[3] + date_input[4])
							# Validate
							if not 0 < d < 32:
														raise ValueError("Date must be between 1 - 31")

							# Get second separator
							__UpperCamelCase	:   str			   =					date_input[5]
							# Validate
							if sep_a not in ["-", "/"]:
														raise ValueError("Date separator must be '-' or '/'")

							# Get year
							__UpperCamelCase	:   int			   =					int(date_input[6] + date_input[7] + date_input[8] + date_input[9])
							# Arbitrary year range
							if not 45 < y < 8_500:
														raise ValueError(
														    "Year out of range. There has to be some sort of limit...right?")

							# Get datetime obj for validation
							__UpperCamelCase	:   Union[str, Any]			   =					datetime.date(int(_lowerCamelCase)						,  int(_lowerCamelCase)						,  int(_lowerCamelCase))

							# Start math
							if m <= 2:
														__UpperCamelCase	:   Any			   =					y - 1
														__UpperCamelCase	:   Optional[Any]			   =					m + 12
							# maths var
							__UpperCamelCase	:   int			   =					int(str(_lowerCamelCase)[:2])
							__UpperCamelCase	:   int			   =					int(str(_lowerCamelCase)[2:])
							__UpperCamelCase	:   int			   =					int(2.6 * m - 5.3_9)
							__UpperCamelCase	:   int			   =					int(c / 4)
							__UpperCamelCase	:   int			   =					int(k / 4)
							__UpperCamelCase	:   int			   =					int(d + k)
							__UpperCamelCase	:   int			   =					int(t + u + v + x)
							__UpperCamelCase	:   int			   =					int(z - (2 * c))
							__UpperCamelCase	:   int			   =					round(w % 7)
							# End math

							# Validate math
							if f != convert_datetime_days[dt_ck.weekday()]:
														raise AssertionError("The date was evaluated incorrectly. Contact developer.")

							# Response
							__UpperCamelCase	:   str			   =					F'Your date {date_input}, is a {days[str(_lowerCamelCase)]}!'
							return response


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		lowercase  :					Optional[int]													=       argparse.ArgumentParser(
		    description=(
		        'Find out what day of the week nearly any date is or was. Enter '
		        'date as a string in the mm-dd-yyyy or mm/dd/yyyy format'
		    )
		)
		parser.add_argument(
		    'date_input', type=str, help='Date as a string (mm-dd-yyyy or mm/dd/yyyy)'
		)
		lowercase  :					Tuple													=       parser.parse_args()
		zeller(args.date_input)