code: 
  
  
  
  
  
  import os
  from pathlib import Path
  from typing import Dict, List
  
  import fire
  import torch
  
  from transformers import AutoModelForSeqaSeqLM, AutoTokenizer
  from transformers.utils.logging import get_logger
  
  
  lowerCAmelCase_   =   get_logger(__name__)
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_  )			->						Any:
         if text.startswith(lowercase_  ):
                return text[len(lowercase_  ) :]
         return text  # or whatever
  
  
  
  
  def 						A_			(  lowercase_  )			->						Optional[Any]:
         return {remove_prefix(lowercase_      ,		'''model.'''  ): v for k, v in sd.items()}
  
  
  
  
  def 						A_			(  lowercase_  )			->						Optional[Any]:
         _snake_case      :							Dict     				=						{}
         for k in state_dicts[0].keys():
                _snake_case      :							Dict     				=						[sd[k] for sd in state_dicts]
                _snake_case      :							Tuple     				=						sum(lowercase_  ) / len(lowercase_  )
                assert isinstance(lowercase_      ,		torch.Tensor  )
                _snake_case      :							List[str]     				=						new_t
         return new_sd
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_  )			->						None:
         _snake_case      :							int     				=						AutoModelForSeqaSeqLM.from_pretrained(lowercase_  )
         if os.path.isfile(lowercase_  ):
                _snake_case      :							Any     				=						[pl_ckpt_path]
         else:
                assert os.path.isdir(lowercase_  )
                _snake_case      :							List[Any]     				=						list(Path(lowercase_  ).glob('''*.ckpt'''  )  )
                assert ckpt_files, f'''could not find any ckpt files inside the {pl_ckpt_path} directory'''
  
         if len(lowercase_  ) > 1:
                logger.info(f'''averaging the weights of {ckpt_files}'''  )
  
         _snake_case      :							List[Any]     				=						[sanitize(torch.load(lowercase_      ,		map_location='''cpu'''  )['''state_dict''']  ) for x in ckpt_files]
         _snake_case      :							List[Any]     				=						average_state_dicts(lowercase_  )
  
         _snake_case				,    _snake_case      :							int     				=						hf_model.load_state_dict(lowercase_      ,		strict=lowercase_  )
         assert not missing, f'''missing keys: {missing}'''
         hf_model.save_pretrained(lowercase_  )
         try:
                _snake_case      :							str     				=						AutoTokenizer.from_pretrained(lowercase_  )
                tok.save_pretrained(lowercase_  )
         except Exception:
                pass
                # dont copy tokenizer if cant
  
  
  if __name__ == "__main__":
     fire.Fire(convert_pl_to_hf)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  def 						A_			(  lowercase_  )			->						list:
         if len(lowercase_  ) <= 1:
                return data
         else:
                return [
                    *quick_sort([e for e in data[1:] if e <= data[0]]  ),
                    data[0],
                    *quick_sort([e for e in data[1:] if e > data[0]]  ),
                ]
  
  
  if __name__ == "__main__":
     import doctest
  
     doctest.testmod()
  
  
  
  
  
  
  