






import argparse
import datetime

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  str					)		->			str:






	"""simple docstring"""



	UpperCamelCase     :Union[str, Any]          =	{
	    """0""": """Sunday""",
	    """1""": """Monday""",
	    """2""": """Tuesday""",
	    """3""": """Wednesday""",
	    """4""": """Thursday""",
	    """5""": """Friday""",
	    """6""": """Saturday""",
	}

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

	# Validate
	if not 0 < len(__magic_name__					) < 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 < 8500:
		raise ValueError(
		    """Year out of range. There has to be some sort of limit...right?"""					)

	# Get datetime obj for validation
	UpperCamelCase     :Optional[Any]          =	datetime.date(int(__magic_name__					)	,			int(__magic_name__					)	,			int(__magic_name__					)					)

	# Start math
	if m <= 2:
		UpperCamelCase     :Dict          =	y - 1
		UpperCamelCase     :Union[str, Any]          =	m + 12
	# maths var
	UpperCamelCase     :int          =	int(str(__magic_name__					)[:2]					)
	UpperCamelCase     :int          =	int(str(__magic_name__					)[2:]					)
	UpperCamelCase     :int          =	int(2.6 * m - 5.39					)
	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(__magic_name__					)]}!"""
	return response


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	UpperCAmelCase_ :						List[Any]      =      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)'''
	)
	UpperCAmelCase_ :						Tuple      =      parser.parse_args()
	zeller(args.date_input)


import argparse
from argparse import Namespace

import torch
from torch import nn

from transformers import XGLMConfig, XGLMForCausalLM

def a__    (       A_					):






  '''simple docstring'''





  __magic_name__				     =       [
      """decoder.version""",
      """decoder.output_projection.weight""",
      """_float_tensor""",
      """decoder.embed_positions._float_tensor""",
  ]
  for k in ignore_keys:
    state_dict.pop(A_,     A_					)

def a__    (       A_					):






  '''simple docstring'''





  __magic_name__     ,    __magic_name__				     =       emb.weight.shape
  __magic_name__				     =       nn.Linear(A_,     A_,     bias=A_					)
  __magic_name__				     =       emb.weight.data
  return lin_layer

def a__    (       A_					):






  '''simple docstring'''





  __magic_name__				     =       torch.load(A_,     map_location="""cpu"""					)
  __magic_name__				     =       Namespace(**checkpoint["""cfg"""]["""model"""]					)
  __magic_name__				     =       checkpoint["""model"""]
  remove_ignore_keys_(A_					)
  __magic_name__				     =       state_dict["""decoder.embed_tokens.weight"""].shape[0]

  __magic_name__				     =       {key.replace("""decoder""",     """model"""					): val for key, val in state_dict.items()}

  __magic_name__				     =       XGLMConfig(
      vocab_size=A_,     max_position_embeddings=args.max_target_positions,     num_layers=args.decoder_layers,     attention_heads=args.decoder_attention_heads,     ffn_dim=args.decoder_ffn_embed_dim,     d_model=args.decoder_embed_dim,     layerdrop=args.decoder_layerdrop,     dropout=args.dropout,     attention_dropout=args.attention_dropout,     activation_dropout=args.activation_dropout,     activation_function="""gelu""",     scale_embedding=not args.no_scale_embedding,     tie_word_embeddings=args.share_decoder_input_output_embed,     )

  __magic_name__				     =       XGLMForCausalLM(A_					)
  __magic_name__				     =       model.load_state_dict(A_,     strict=A_					)
  print(A_					)
  __magic_name__				     =       make_linear_from_emb(model.model.embed_tokens					)

  return model


if __name__ == "__main__":
    __lowerCAmelCase			:     Dict           =   argparse.ArgumentParser()
    # Required parameters
    parser.add_argument('fairseq_path', type=str, help='path to a model.pt on local filesystem.')
    parser.add_argument('pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
    __lowerCAmelCase			:     List[str]           =   parser.parse_args()
    __lowerCAmelCase			:     str           =   convert_fairseq_xglm_checkpoint_from_disk(args.fairseq_path)
    model.save_pretrained(args.pytorch_dump_folder_path)

