





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


_lowerCamelCase 					=      logging.get_logger(__name__)

_lowerCamelCase 					=      {
    'google/pegasus-large': 'https://huggingface.co/google/pegasus-large/resolve/main/config.json',
    # See all PEGASUS models at https://huggingface.co/models?filter=pegasus
}




class 	UpperCamelCase_							(  UpperCamelCase__     ):
							lowerCamelCase_							     =       "pegasus"
							lowerCamelCase_							     =       ["past_key_values"]
							lowerCamelCase_							     =       {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}


							def __init__(				self     :Any				,					__A     :Optional[int]=5_0265				,					__A     :int=1024				,					__A     :Union[str, Any]=12				,					__A     :Union[str, Any]=4096				,					__A     :Tuple=16				,					__A     :Union[str, Any]=12				,					__A     :Tuple=4096				,					__A     :int=16				,					__A     :List[Any]=0.0				,					__A     :Tuple=0.0				,					__A     :Dict=True				,					__A     :List[str]=True				,					__A     :Optional[int]="gelu"				,					__A     :int=1024				,					__A     :Optional[Any]=0.1				,					__A     :List[Any]=0.0				,					__A     :str=0.0				,					__A     :List[str]=0.0_2				,					__A     :str=0				,					__A     :str=False				,					__A     :List[Any]=0				,					__A     :int=1				,					__A     :str=1				,					**__A     :Tuple				,					) -> str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   vocab_size
									SCREAMING_SNAKE_CASE__								=   max_position_embeddings
									SCREAMING_SNAKE_CASE__								=   d_model
									SCREAMING_SNAKE_CASE__								=   encoder_ffn_dim
									SCREAMING_SNAKE_CASE__								=   encoder_layers
									SCREAMING_SNAKE_CASE__								=   encoder_attention_heads
									SCREAMING_SNAKE_CASE__								=   decoder_ffn_dim
									SCREAMING_SNAKE_CASE__								=   decoder_layers
									SCREAMING_SNAKE_CASE__								=   decoder_attention_heads
									SCREAMING_SNAKE_CASE__								=   dropout
									SCREAMING_SNAKE_CASE__								=   attention_dropout
									SCREAMING_SNAKE_CASE__								=   activation_dropout
									SCREAMING_SNAKE_CASE__								=   activation_function
									SCREAMING_SNAKE_CASE__								=   init_std
									SCREAMING_SNAKE_CASE__								=   encoder_layerdrop
									SCREAMING_SNAKE_CASE__								=   decoder_layerdrop
									SCREAMING_SNAKE_CASE__								=   use_cache
									SCREAMING_SNAKE_CASE__								=   encoder_layers
									SCREAMING_SNAKE_CASE__								=   scale_embedding  # scale factor will be sqrt(d_model) if True
									super().__init__(
									    pad_token_id=__A				,					eos_token_id=__A				,					is_encoder_decoder=__A				,					decoder_start_token_id=__A				,					forced_eos_token_id=__A				,					**__A				,					)


							@property
							def   _snake_case	(				self     :int		) -> int:



									"""simple docstring"""



									return self.encoder_attention_heads


							@property
							def   _snake_case	(				self     :str		) -> int:



									"""simple docstring"""



									return self.d_model






import argparse
import datetime






def 					SCREAMING_SNAKE_CASE__				(							UpperCamelCase__:				str     ):
		SCREAMING_SNAKE_CASE__								=   {
		    """0""": """Sunday""",
		    """1""": """Monday""",
		    """2""": """Tuesday""",
		    """3""": """Wednesday""",
		    """4""": """Thursday""",
		    """5""": """Friday""",
		    """6""": """Saturday""",
		}

		SCREAMING_SNAKE_CASE__								=   {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

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

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

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

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

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

		# Get year
		SCREAMING_SNAKE_CASE__								=   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
		SCREAMING_SNAKE_CASE__								=   datetime.date(int(UpperCamelCase__     )       , int(UpperCamelCase__     )       , int(UpperCamelCase__     )     )

		# Start math
		if m <= 2:
				SCREAMING_SNAKE_CASE__								=   y - 1
				SCREAMING_SNAKE_CASE__								=   m + 12
		# maths var
		SCREAMING_SNAKE_CASE__								=   int(str(UpperCamelCase__     )[:2]     )
		SCREAMING_SNAKE_CASE__								=   int(str(UpperCamelCase__     )[2:]     )
		SCREAMING_SNAKE_CASE__								=   int(2.6 * m - 5.3_9     )
		SCREAMING_SNAKE_CASE__								=   int(c / 4     )
		SCREAMING_SNAKE_CASE__								=   int(k / 4     )
		SCREAMING_SNAKE_CASE__								=   int(d + k     )
		SCREAMING_SNAKE_CASE__								=   int(t + u + v + x     )
		SCREAMING_SNAKE_CASE__								=   int(z - (2 * c)     )
		SCREAMING_SNAKE_CASE__								=   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
		SCREAMING_SNAKE_CASE__								=   f'''Your date {date_input}, is a {days[str(UpperCamelCase__     )]}!'''
		return response


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	_lowerCamelCase 					=      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)'
	)
	_lowerCamelCase 					=      parser.parse_args()
	zeller(args.date_input)