code: 
  
  
  
  
  
  import argparse
  
  import torch
  from torch import nn
  
  from transformers import PLBartConfig, PLBartForConditionalGeneration, PLBartForSequenceClassification
  
  
  
  
  
  
  
  def       lowerCAmelCase__(	lowercase       :    List[str]				) ->    Any:
    __snake_case   :				Optional[Any]        =       [
        "encoder.version",
        "decoder.version",
        "model.encoder.version",
        "model.decoder.version",
        "_float_tensor",
        "decoder.output_projection.weight",
    ]
    for k in ignore_keys:
      state_dict.pop(lowercase   ,     lowercase				)
  
  
  
  
  
  
  
  def       lowerCAmelCase__(	lowercase       :    Optional[Any]				) ->    str:
    __snake_case    ,   __snake_case   :				List[Any]        =       emb.weight.shape
    __snake_case   :				Any        =       nn.Linear(lowercase   ,     lowercase   ,     bias=lowercase				)
    __snake_case   :				str        =       emb.weight.data
    return lin_layer
  
  
  
  
  
  
  
  def       lowerCAmelCase__(	lowercase       :    Union[str, Any]   ,     lowercase       :    Tuple="uclanlp/plbart-base"   ,     lowercase       :    Tuple=False   ,     lowercase       :    Union[str, Any]=False				) ->    Optional[int]:
    __snake_case   :				Any        =       torch.load(lowercase   ,     map_location="cpu"				)["model"]
    remove_ignore_keys_(lowercase				)
    __snake_case   :				Union[str, Any]        =       state_dict["encoder.embed_tokens.weight"].shape[0]
  
    __snake_case   :				str        =       PLBartConfig.from_pretrained(lowercase   ,     vocab_size=lowercase				)
  
    __snake_case   :				int        =       state_dict["decoder.embed_tokens.weight"]
    if not classification:
      __snake_case   :				Optional[Any]        =       PLBartForConditionalGeneration(lowercase				)
      model.model.load_state_dict(lowercase				)
      if finetuned:
        __snake_case   :				Optional[int]        =       make_linear_from_emb(model.model.shared				)
  
    else:
      __snake_case   :				int        =       {}
      for key, value in state_dict.copy().items():
        if key.startswith("classification_heads.sentence_classification_head"				):
          __snake_case   :				Any        =       value
          state_dict.pop(lowercase				)
      __snake_case   :				Dict        =       PLBartForSequenceClassification(lowercase				)
      model.model.load_state_dict(lowercase				)
      model.classification_head.load_state_dict(lowercase				)
  
    return model
  
  
  if __name__ == "__main__":
       _UpperCamelCase       = argparse.ArgumentParser()
       # Required parameters
       parser.add_argument('''fairseq_path''', type=str, help='''model.pt on local filesystem.''')
       parser.add_argument('''pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
       parser.add_argument(
           '''--hf_config''',
           default='''uclanlp/plbart-base''',
           type=str,
           help='''Which huggingface architecture to use: plbart-base''',
       )
       parser.add_argument('''--finetuned''', action='''store_true''', help='''whether the model is a fine-tuned checkpoint''')
       parser.add_argument(
           '''--classification''', action='''store_true''', help='''whether the model is a classification checkpoint'''
       )
       _UpperCamelCase       = parser.parse_args()
       _UpperCamelCase       = convert_fairseq_plbart_checkpoint_from_disk(
           args.fairseq_path,
           hf_config_path=args.hf_config,
           finetuned=args.finetuned,
           classification=args.classification,
       )
       model.save_pretrained(args.pytorch_dump_folder_path)
  
  
style_context: 
  
  
  
  
  
  def       lowerCAmelCase__(	lowercase       :    str				) ->    int:
    __snake_case   :				List[str]        =       str(lowercase				).strip()
    if not oct_string:
      raise ValueError("Empty string was passed to the function"				)
    __snake_case   :				int        =       oct_string[0] == "-"
    if is_negative:
      __snake_case   :				Union[str, Any]        =       oct_string[1:]
    if not oct_string.isdigit() or not all(0 <= int(lowercase				) <= 7 for char in oct_string				):
      raise ValueError("Non-octal value was passed to the function"				)
    __snake_case   :				List[Any]        =       0
    for char in oct_string:
      __snake_case   :				Optional[Any]        =       8 * decimal_number + int(lowercase				)
    if is_negative:
      __snake_case   :				Any        =       -decimal_number
    return decimal_number
  
  
  if __name__ == "__main__":
       from doctest import testmod
  
       testmod()
  
  