code: 
  
  
  class 						UpperCAmelCase__   :
  
  
  
       '''simple docstring'''
  
       class 						UpperCAmelCase__   :
  
  
  
            '''simple docstring'''
            UpperCAmelCase_         =  '''_prev''', '''_data''', '''_next'''
  
  
  
  
            def __init__( self       :       int	,      UpperCamelCase       :       int	,      UpperCamelCase       :       List[str]	,      UpperCamelCase       :       int		):
  
  
  
  
  
                   """simple docstring"""
  
  
  
                   _lowercase					:				Union[str, Any]           =			link_p
                   _lowercase					:				Union[str, Any]           =			element
                   _lowercase					:				Any           =			link_n
  
  
  
  
            def   lowerCAmelCase_   ( self       :       Dict		):
  
  
  
  
  
                   """simple docstring"""
  
  
  
                   return (
                       F' Prev -> {self._prev is not None}, Next -> {self._next is not None}'
                   )
  
  
  
  
       def __init__( self       :       List[Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				Optional[int]           =			self._Node(UpperCamelCase	,      UpperCamelCase	,      UpperCamelCase		)
              _lowercase					:				Tuple           =			self._Node(UpperCamelCase	,      UpperCamelCase	,      UpperCamelCase		)
              _lowercase					:				Any           =			self._trailer
              _lowercase					:				List[Any]           =			self._header
              _lowercase					:				int           =			0
  
  
  
  
       def __len__( self       :       Dict		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              return self._size
  
  
  
  
       def   lowerCAmelCase_   ( self       :       List[str]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              return self.__len__() == 0
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Optional[int]	,      UpperCamelCase       :       int	,      UpperCamelCase       :       List[Any]	,      UpperCamelCase       :       int		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				str           =			self._Node(UpperCamelCase	,      UpperCamelCase	,      UpperCamelCase		)
              _lowercase					:				int           =			new_node
              _lowercase					:				List[Any]           =			new_node
              self._size += 1
              return self
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Tuple	,      UpperCamelCase       :       int		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				int           =			node._prev
              _lowercase					:				List[str]           =			node._next
  
              _lowercase					:				str           =			successor
              _lowercase					:				Optional[int]           =			predecessor
              self._size -= 1
              _lowercase					:				List[Any]           =			node._data
              _lowercase					:				List[Any]           =			None
              del node
              return temp
  
  
  
  
  class 						UpperCAmelCase__   (      _DoublyLinkedBase		):
  
  
  
       '''simple docstring'''
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Tuple		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              if self.is_empty():
                     raise Exception('''List is empty'''		)
              return self._header._next._data
  
  
  
  
       def   lowerCAmelCase_   ( self       :       int		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              if self.is_empty():
                     raise Exception('''List is empty'''		)
              return self._trailer._prev._data
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Optional[Any]	,      UpperCamelCase       :       str		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              return self._insert(self._header	,      UpperCamelCase	,      self._header._next		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Optional[Any]	,      UpperCamelCase       :       Any		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              return self._insert(self._trailer._prev	,      UpperCamelCase	,      self._trailer		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       int		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              if self.is_empty():
                     raise IndexError('''remove_first from empty list'''		)
              return self._delete(self._header._next		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       List[Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              if self.is_empty():
                     raise IndexError('''remove_first from empty list'''		)
              return self._delete(self._trailer._prev		)
style_context: 
  
  
  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
  
  
  UpperCamelCase__				       =			get_logger(__name__)
  
  def   UpperCamelCase__   (    UpperCAmelCase_    ,     UpperCAmelCase_			)						->							List[str]:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         if text.startswith(UpperCAmelCase_			):
                return text[len(UpperCAmelCase_			) :]
         return text  # or whatever
  
  def   UpperCamelCase__   (    UpperCAmelCase_			)						->							Optional[int]:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         return {remove_prefix(UpperCAmelCase_    ,     '''model.'''			): v for k, v in sd.items()}
  
  def   UpperCamelCase__   (    UpperCAmelCase_			)						->							Any:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         _lowercase					:				Optional[int]           =			{}
         for k in state_dicts[0].keys():
                _lowercase					:				Tuple           =			[sd[k] for sd in state_dicts]
                _lowercase					:				Union[str, Any]           =			sum(UpperCAmelCase_			) / len(UpperCAmelCase_			)
                assert isinstance(UpperCAmelCase_    ,     torch.Tensor			)
                _lowercase					:				Union[str, Any]           =			new_t
         return new_sd
  
  def   UpperCamelCase__   (    UpperCAmelCase_    ,     UpperCAmelCase_    ,     UpperCAmelCase_			)						->							None:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         _lowercase					:				List[str]           =			AutoModelForSeqaSeqLM.from_pretrained(UpperCAmelCase_			)
         if os.path.isfile(UpperCAmelCase_			):
                _lowercase					:				Optional[Any]           =			[pl_ckpt_path]
         else:
                assert os.path.isdir(UpperCAmelCase_			)
                _lowercase					:				List[str]           =			list(Path(UpperCAmelCase_			).glob('''*.ckpt'''			)			)
                assert ckpt_files, F'could not find any ckpt files inside the {pl_ckpt_path} directory'
  
         if len(UpperCAmelCase_			) > 1:
                logger.info(F'averaging the weights of {ckpt_files}'			)
  
         _lowercase					:				List[Any]           =			[sanitize(torch.load(UpperCAmelCase_    ,     map_location='''cpu'''			)['''state_dict''']			) for x in ckpt_files]
         _lowercase					:				Optional[Any]           =			average_state_dicts(UpperCAmelCase_			)
  
         _lowercase       ,	_lowercase					:				str           =			hf_model.load_state_dict(UpperCAmelCase_    ,     strict=UpperCAmelCase_			)
         assert not missing, F'missing keys: {missing}'
         hf_model.save_pretrained(UpperCAmelCase_			)
         try:
                _lowercase					:				Union[str, Any]           =			AutoTokenizer.from_pretrained(UpperCAmelCase_			)
                tok.save_pretrained(UpperCAmelCase_			)
         except Exception:
                pass
                # dont copy tokenizer if cant
  
  
  if __name__ == "__main__":
     fire.Fire(convert_pl_to_hf)