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
  
  
  snake_case_    						=				get_logger(__name__)
  
  def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					str			,  SCREAMING_SNAKE_CASE_	:					str    ):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       if text.startswith(SCREAMING_SNAKE_CASE_    ):
            return text[len(SCREAMING_SNAKE_CASE_    ) :]
       return text  # or whatever
  
  def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					Dict    ):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       return {remove_prefix(SCREAMING_SNAKE_CASE_			,  'model.'    ): v for k, v in sd.items()}
  
  def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					List[Dict[str, torch.Tensor]]    ):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       lowercase__					:     Optional[int]   = {}
       for k in state_dicts[0].keys():
            lowercase__					:     Optional[int]   = [sd[k] for sd in state_dicts]
            lowercase__					:     Any   = sum(SCREAMING_SNAKE_CASE_    ) / len(SCREAMING_SNAKE_CASE_    )
            assert isinstance(SCREAMING_SNAKE_CASE_			,  torch.Tensor    )
            lowercase__					:     str   = new_t
       return new_sd
  
  def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					str			,  SCREAMING_SNAKE_CASE_	:					str			,  SCREAMING_SNAKE_CASE_	:					str    ):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       lowercase__					:     int   = AutoModelForSeqaSeqLM.from_pretrained(SCREAMING_SNAKE_CASE_    )
       if os.path.isfile(SCREAMING_SNAKE_CASE_    ):
            lowercase__					:     Union[str, Any]   = [pl_ckpt_path]
       else:
            assert os.path.isdir(SCREAMING_SNAKE_CASE_    )
            lowercase__					:     int   = list(Path(SCREAMING_SNAKE_CASE_    ).glob('*.ckpt'    )    )
            assert ckpt_files, f"""could not find any ckpt files inside the {pl_ckpt_path} directory"""
  
       if len(SCREAMING_SNAKE_CASE_    ) > 1:
            logger.info(f"""averaging the weights of {ckpt_files}"""    )
  
       lowercase__					:     Optional[Any]   = [sanitize(torch.load(SCREAMING_SNAKE_CASE_			,  map_location='cpu'    )['state_dict']    ) for x in ckpt_files]
       lowercase__					:     str   = average_state_dicts(SCREAMING_SNAKE_CASE_    )
  
       lowercase__   ,				lowercase__					:     Tuple   = hf_model.load_state_dict(SCREAMING_SNAKE_CASE_			,  strict=SCREAMING_SNAKE_CASE_    )
       assert not missing, f"""missing keys: {missing}"""
       hf_model.save_pretrained(SCREAMING_SNAKE_CASE_    )
       try:
            lowercase__					:     Union[str, Any]   = AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_    )
            tok.save_pretrained(SCREAMING_SNAKE_CASE_    )
       except Exception:
            pass
            # dont copy tokenizer if cant
  
  
  if __name__ == "__main__":
         fire.Fire(convert_pl_to_hf)
  
  
style_context: 
  
  from dataclasses import dataclass
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  
  from ...utils import BaseOutput, is_invisible_watermark_available, is_torch_available, is_transformers_available
  
  
  @dataclass
  class    SCREAMING_SNAKE_CASE__      (__snake_case  ):
      __lowerCamelCase		: Union[List[PIL.Image.Image], np.ndarray]
  
  
  if is_transformers_available() and is_torch_available() and is_invisible_watermark_available():
         from .pipeline_stable_diffusion_xl import StableDiffusionXLPipeline
         from .pipeline_stable_diffusion_xl_imgaimg import StableDiffusionXLImgaImgPipeline
  
  