





'''simple docstring'''

import argparse

import torch
from torch import nn

from transformers import SpeechaTextConfig, SpeechaTextForConditionalGeneration

def 						__magic_name__       (							__UpperCAmelCase      )						->					Optional[Any]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       [
       """encoder.version""",
       """decoder.version""",
       """model.encoder.version""",
       """model.decoder.version""",
       """decoder.output_projection.weight""",
       """_float_tensor""",
       """encoder.embed_positions._float_tensor""",
       """decoder.embed_positions._float_tensor""",
   ]
   for k in ignore_keys:
      state_dict.pop(__UpperCAmelCase							,	__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase      )						->					List[str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       list(s_dict.keys()      )
   for key in keys:
      if "transformer_layers" in key:
         __SCREAMING_SNAKE_CASE      							=       s_dict.pop(__UpperCAmelCase      )
      elif "subsample" in key:
         __SCREAMING_SNAKE_CASE      							=       s_dict.pop(__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase      )						->					Dict:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       emb.weight.shape
   __SCREAMING_SNAKE_CASE      							=       nn.Linear(__UpperCAmelCase							,	__UpperCAmelCase							,	bias=__UpperCAmelCase      )
   __SCREAMING_SNAKE_CASE      							=       emb.weight.data
   return lin_layer

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					Union[str, Any]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       torch.load(__UpperCAmelCase							,	map_location="""cpu"""      )
   __SCREAMING_SNAKE_CASE      							=       mam_aaa["""args"""]
   __SCREAMING_SNAKE_CASE      							=       mam_aaa["""model"""]
   __SCREAMING_SNAKE_CASE      							=       state_dict["""decoder.output_projection.weight"""]

   remove_ignore_keys_(__UpperCAmelCase      )
   rename_keys(__UpperCAmelCase      )

   __SCREAMING_SNAKE_CASE      							=       state_dict["""decoder.embed_tokens.weight"""].shape[0]

   __SCREAMING_SNAKE_CASE      							=       args.share_decoder_input_output_embed

   __SCREAMING_SNAKE_CASE      							=       [int(__UpperCAmelCase      ) for i in args.conv_kernel_sizes.split(""","""      )]
   __SCREAMING_SNAKE_CASE      							=       SpeechaTextConfig(
       vocab_size=__UpperCAmelCase							,	max_source_positions=args.max_source_positions							,	max_target_positions=args.max_target_positions							,	encoder_layers=args.encoder_layers							,	decoder_layers=args.decoder_layers							,	encoder_attention_heads=args.encoder_attention_heads							,	decoder_attention_heads=args.decoder_attention_heads							,	encoder_ffn_dim=args.encoder_ffn_embed_dim							,	decoder_ffn_dim=args.decoder_ffn_embed_dim							,	d_model=args.encoder_embed_dim							,	dropout=args.dropout							,	attention_dropout=args.attention_dropout							,	activation_dropout=args.activation_dropout							,	activation_function="""relu"""							,	num_conv_layers=len(__UpperCAmelCase      )							,	conv_channels=args.conv_channels							,	conv_kernel_sizes=__UpperCAmelCase							,	input_feat_per_channel=args.input_feat_per_channel							,	input_channels=args.input_channels							,	tie_word_embeddings=__UpperCAmelCase							,	num_beams=5							,	max_length=200							,	use_cache=__UpperCAmelCase							,	decoder_start_token_id=2							,	early_stopping=__UpperCAmelCase							,	)

   __SCREAMING_SNAKE_CASE      							=       SpeechaTextForConditionalGeneration(__UpperCAmelCase      )
   __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       model.model.load_state_dict(__UpperCAmelCase							,	strict=__UpperCAmelCase      )
   if len(__UpperCAmelCase      ) > 0 and not set(__UpperCAmelCase      ) <= {
       "encoder.embed_positions.weights",
       "decoder.embed_positions.weights",
   }:
      raise ValueError(
          """Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights`  are allowed to be missing,"""
          f""" but all the following weights are missing {missing}"""      )

   if tie_embeds:
      __SCREAMING_SNAKE_CASE      							=       make_linear_from_emb(model.model.decoder.embed_tokens      )
   else:
      __SCREAMING_SNAKE_CASE      							=       lm_head_weights

   model.save_pretrained(__UpperCAmelCase      )


if __name__ == "__main__":
    a        =						argparse.ArgumentParser()
    # Required parameters
    parser.add_argument("--fairseq_path", type=str, help="Path to the fairseq model (.pt) file.")
    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
    a        =						parser.parse_args()
    convert_fairseq_sat_checkpoint_to_tfms(args.fairseq_path, args.pytorch_dump_folder_path)












'''simple docstring'''

def 						__magic_name__       (							__UpperCAmelCase = 1							,	__UpperCAmelCase = 1000      )						->					int:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       1
   __SCREAMING_SNAKE_CASE      							=       0

   for divide_by_number in range(__UpperCAmelCase							,	digit + 1      ):
      __SCREAMING_SNAKE_CASE      							=       []
      __SCREAMING_SNAKE_CASE      							=       numerator
      for _ in range(1							,	digit + 1      ):
         if now_divide in has_been_divided:
            if longest_list_length < len(__UpperCAmelCase      ):
               __SCREAMING_SNAKE_CASE      							=       len(__UpperCAmelCase      )
               __SCREAMING_SNAKE_CASE      							=       divide_by_number
         else:
            has_been_divided.append(__UpperCAmelCase      )
            __SCREAMING_SNAKE_CASE      							=       now_divide * 10 % divide_by_number

   return the_digit


# Tests
if __name__ == "__main__":
    import doctest

    doctest.testmod()





