code: 
  
  
  import glob
  import os
  from typing import Dict, List, Union
  
  import torch
  
  from diffusers.utils import is_safetensors_available
  
  
  if is_safetensors_available():
  	import safetensors.torch
  
  from huggingface_hub import snapshot_download
  
  from diffusers import DiffusionPipeline, __version__
  from diffusers.schedulers.scheduling_utils import SCHEDULER_CONFIG_NAME
  from diffusers.utils import CONFIG_NAME, DIFFUSERS_CACHE, ONNX_WEIGHTS_NAME, WEIGHTS_NAME
  
  
  
  
  
  class    A					(     A_				):
  
  
  							def __init__(self      ):
  									self.register_to_config()
  									super().__init__()
  
  
  							def     _A (self   ,       lowerCAmelCase   ,       lowerCAmelCase      ):
  									if dicta == dicta:
  											return True
  									else:
  											__lowercase,							__lowercase=    self._remove_meta_keys(lowerCAmelCase      )
  											__lowercase,							__lowercase=    self._remove_meta_keys(lowerCAmelCase      )
  											if configa == configa:
  													print(f'Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}.'      )
  													return True
  									return False
  
  
  							def     _A (self   ,       lowerCAmelCase      ):
  									__lowercase=    []
  									__lowercase=    config_dict.copy()
  									for key in config_dict.keys():
  											if key.startswith('_'      ):
  													temp_dict.pop(lowerCAmelCase      )
  													meta_keys.append(lowerCAmelCase      )
  									return (temp_dict, meta_keys)
  
  
  							@torch.no_grad()
  							def     _A (self   ,       lowerCAmelCase   ,       **lowerCAmelCase      ):
  									__lowercase=    kwargs.pop('cache_dir'   ,       lowerCAmelCase      )
  									__lowercase=    kwargs.pop('resume_download'   ,       lowerCAmelCase      )
  									__lowercase=    kwargs.pop('force_download'   ,       lowerCAmelCase      )
  									__lowercase=    kwargs.pop('proxies'   ,       lowerCAmelCase      )
  									__lowercase=    kwargs.pop('local_files_only'   ,       lowerCAmelCase      )
  									__lowercase=    kwargs.pop('use_auth_token'   ,       lowerCAmelCase      )
  									__lowercase=    kwargs.pop('revision'   ,       lowerCAmelCase      )
  									__lowercase=    kwargs.pop('torch_dtype'   ,       lowerCAmelCase      )
  									__lowercase=    kwargs.pop('device_map'   ,       lowerCAmelCase      )
  
  									__lowercase=    kwargs.pop('alpha'   ,       0.5      )
  									__lowercase=    kwargs.pop('interp'   ,       lowerCAmelCase      )
  
  									print('Received list'   ,       lowerCAmelCase      )
  									print(f'Combining with alpha={alpha}, interpolation mode={interp}'      )
  
  									__lowercase=    len(lowerCAmelCase      )
  									# Ignore result from model_index_json comparision of the two checkpoints
  									__lowercase=    kwargs.pop('force'   ,       lowerCAmelCase      )
  
  									# If less than 2 checkpoints, nothing to merge. If more than 3, not supported for now.
  									if checkpoint_count > 3 or checkpoint_count < 2:
  											raise ValueError(
  											    'Received incorrect number of checkpoints to merge. Ensure that either 2 or 3 checkpoints are being'
  											    ' passed.'      )
  
  									print('Received the right number of checkpoints'      )
  									# chkpt0, chkpt1 = pretrained_model_name_or_path_list[0:2]
  									# chkpt2 = pretrained_model_name_or_path_list[2] if checkpoint_count == 3 else None
  
  									# Validate that the checkpoints can be merged
  									# Step 1: Load the model config and compare the checkpoints. We'll compare the model_index.json first while ignoring the keys starting with '_'
  									__lowercase=    []
  									for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
  											__lowercase=    DiffusionPipeline.load_config(
  											    lowerCAmelCase   ,       cache_dir=lowerCAmelCase   ,       resume_download=lowerCAmelCase   ,       force_download=lowerCAmelCase   ,       proxies=lowerCAmelCase   ,       local_files_only=lowerCAmelCase   ,       use_auth_token=lowerCAmelCase   ,       revision=lowerCAmelCase   ,       )
  											config_dicts.append(lowerCAmelCase      )
  
  									__lowercase=    True
  									for idx in range(1   ,       len(lowerCAmelCase      )      ):
  											comparison_result &= self._compare_model_configs(config_dicts[idx - 1]   ,       config_dicts[idx]      )
  											if not force and comparison_result is False:
  													raise ValueError('Incompatible checkpoints. Please check model_index.json for the models.'      )
  													print(config_dicts[0]   ,       config_dicts[1]      )
  									print('Compatible model_index.json files found'      )
  									# Step 2: Basic Validation has succeeded. Let's download the models and save them into our local files.
  									__lowercase=    []
  									for pretrained_model_name_or_path, config_dict in zip(lowerCAmelCase   ,       lowerCAmelCase      ):
  											__lowercase=    [k for k in config_dict.keys() if not k.startswith('_'      )]
  											__lowercase=    [os.path.join(lowerCAmelCase   ,       '*'      ) for k in folder_names]
  											allow_patterns += [
  											    WEIGHTS_NAME,
  											    SCHEDULER_CONFIG_NAME,
  											    CONFIG_NAME,
  											    ONNX_WEIGHTS_NAME,
  											    DiffusionPipeline.config_name,
  											]
  											__lowercase=    config_dict.get('_class_name'      )
  											__lowercase=    {'diffusers': __version__, 'pipeline_class': requested_pipeline_class}
  
  											__lowercase=    (
  											    pretrained_model_name_or_path
  											    if os.path.isdir(lowerCAmelCase      )
  											    else snapshot_download(
  											        lowerCAmelCase   ,       cache_dir=lowerCAmelCase   ,       resume_download=lowerCAmelCase   ,       proxies=lowerCAmelCase   ,       local_files_only=lowerCAmelCase   ,       use_auth_token=lowerCAmelCase   ,       revision=lowerCAmelCase   ,       allow_patterns=lowerCAmelCase   ,       user_agent=lowerCAmelCase   ,       )
  											)
  											print('Cached Folder'   ,       lowerCAmelCase      )
  											cached_folders.append(lowerCAmelCase      )
  
  									# Step 3:-
  									# Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
  									__lowercase=    DiffusionPipeline.from_pretrained(
  									    cached_folders[0]   ,       torch_dtype=lowerCAmelCase   ,       device_map=lowerCAmelCase      )
  									final_pipe.to(self.device      )
  
  									__lowercase=    None
  									if len(lowerCAmelCase      ) > 2:
  											__lowercase=    os.path.join(cached_folders[2]      )
  
  									if interp == "sigmoid":
  											__lowercase=    CheckpointMergerPipeline.sigmoid
  									elif interp == "inv_sigmoid":
  											__lowercase=    CheckpointMergerPipeline.inv_sigmoid
  									elif interp == "add_diff":
  											__lowercase=    CheckpointMergerPipeline.add_difference
  									else:
  											__lowercase=    CheckpointMergerPipeline.weighted_sum
  
  									# Find each module's state dict.
  									for attr in final_pipe.config.keys():
  											if not attr.startswith('_'      ):
  													__lowercase=    os.path.join(cached_folders[1]   ,       lowerCAmelCase      )
  													if os.path.exists(lowerCAmelCase      ):
  															__lowercase=    [
  															    *glob.glob(os.path.join(lowerCAmelCase   ,       '*.safetensors'      )      ),
  															    *glob.glob(os.path.join(lowerCAmelCase   ,       '*.bin'      )      ),
  															]
  															__lowercase=    files[0] if len(lowerCAmelCase      ) > 0 else None
  													if len(lowerCAmelCase      ) < 3:
  															__lowercase=    None
  													else:
  															__lowercase=    os.path.join(cached_folders[2]   ,       lowerCAmelCase      )
  															if os.path.exists(lowerCAmelCase      ):
  																	__lowercase=    [
  																	    *glob.glob(os.path.join(lowerCAmelCase   ,       '*.safetensors'      )      ),
  																	    *glob.glob(os.path.join(lowerCAmelCase   ,       '*.bin'      )      ),
  																	]
  																	__lowercase=    files[0] if len(lowerCAmelCase      ) > 0 else None
                  # For an attr if both checkpoint_path_1 and 2 are None, ignore.
                  # If atleast one is present, deal with it according to interp method, of course only if the state_dict keys match.
  													if checkpoint_path_a is None and checkpoint_path_a is None:
  															print(f'Skipping {attr}: not present in 2nd or 3d model'      )
  															continue
  													try:
  															__lowercase=    getattr(lowerCAmelCase   ,       lowerCAmelCase      )
  															if isinstance(lowerCAmelCase   ,       lowerCAmelCase      ):  # ignore requires_safety_checker boolean
  																	continue
  															__lowercase=    getattr(lowerCAmelCase   ,       'state_dict'      )
  															__lowercase=    theta_a()
  
  															__lowercase=    getattr(lowerCAmelCase   ,       'load_state_dict'      )
  															__lowercase=    (
  															    safetensors.torch.load_file(lowerCAmelCase      )
  															    if (is_safetensors_available() and checkpoint_path_a.endswith('.safetensors'      ))
  															    else torch.load(lowerCAmelCase   ,       map_location='cpu'      )
  															)
  															__lowercase=    None
  															if checkpoint_path_a:
  																	__lowercase=    (
  																	    safetensors.torch.load_file(lowerCAmelCase      )
  																	    if (is_safetensors_available() and checkpoint_path_a.endswith('.safetensors'      ))
  																	    else torch.load(lowerCAmelCase   ,       map_location='cpu'      )
  																	)
  
  															if not theta_a.keys() == theta_a.keys():
  																	print(f'Skipping {attr}: key mismatch'      )
  																	continue
  															if theta_a and not theta_a.keys() == theta_a.keys():
  																	print(f'Skipping {attr}:y mismatch'      )
  													except Exception as e:
  															print(f'Skipping {attr} do to an unexpected error: {str(lowerCAmelCase      )}'      )
  															continue
  													print(f'MERGING {attr}'      )
  
  													for key in theta_a.keys():
  															if theta_a:
  																	__lowercase=    theta_func(theta_a[key]   ,       theta_a[key]   ,       theta_a[key]   ,       lowerCAmelCase      )
  															else:
  																	__lowercase=    theta_func(theta_a[key]   ,       theta_a[key]   ,       lowerCAmelCase   ,       lowerCAmelCase      )
  
  													del theta_a
  													del theta_a
  													update_theta_a(lowerCAmelCase      )
  
  													del theta_a
  									return final_pipe
  
  
  							@staticmethod
  							def     _A (lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase      ):
  									return ((1 - alpha) * thetaa) + (alpha * thetaa)
  
  
  							@staticmethod
  							def     _A (lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase      ):
  									__lowercase=    alpha * alpha * (3 - (2 * alpha))
  									return thetaa + ((thetaa - thetaa) * alpha)
  
  
  							@staticmethod
  							def     _A (lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase      ):
  									import math
  
  									__lowercase=    0.5 - math.sin(math.asin(1.0 - 2.0 * alpha      ) / 3.0      )
  									return thetaa + ((thetaa - thetaa) * alpha)
  
  
  
  
  
  
  
  							@staticmethod
  							def     _A (lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase      ):
  									return thetaa + (thetaa - thetaa) * (1.0 - alpha)
  
  
  
  
  
  
  
style_context: 
  
  
  from __future__ import annotations
  
  from enum import Enum
  
  
  
  
  
  class    A					(     A_				):
  							UpperCamelCase_     :							List[Any] =24
  							UpperCamelCase_     :							List[Any] =21
  							UpperCamelCase_     :							int =18
  							UpperCamelCase_     :							Optional[int] =15
  							UpperCamelCase_     :							Tuple =12
  							UpperCamelCase_     :							List[str] =9
  							UpperCamelCase_     :							Any =6
  							UpperCamelCase_     :							List[str] =3
  							UpperCamelCase_     :							str =2
  							UpperCamelCase_     :							str =1
  							UpperCamelCase_     :							Optional[int] =-1
  							UpperCamelCase_     :							List[Any] =-2
  							UpperCamelCase_     :							str =-3
  							UpperCamelCase_     :							Tuple =-6
  							UpperCamelCase_     :							Tuple =-9
  							UpperCamelCase_     :							Optional[int] =-12
  							UpperCamelCase_     :							str =-15
  							UpperCamelCase_     :							Optional[Any] =-18
  							UpperCamelCase_     :							Any =-21
  							UpperCamelCase_     :							List[str] =-24
  
  
  
  
  
  class    A					(     A_				):
  							UpperCamelCase_     :							str =8
  							UpperCamelCase_     :							Optional[Any] =7
  							UpperCamelCase_     :							Tuple =6
  							UpperCamelCase_     :							List[Any] =5
  							UpperCamelCase_     :							Optional[Any] =4
  							UpperCamelCase_     :							Union[str, Any] =3
  							UpperCamelCase_     :							Union[str, Any] =2
  							UpperCamelCase_     :							int =1
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__     ,				lowercase__     ,				lowercase__     ,				)		->			float:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if isinstance(lowercase__     ,				lowercase__			):
  				__lowercase=    SIUnit[known_prefix.lower()]
  		if isinstance(lowercase__     ,				lowercase__			):
  				__lowercase=    SIUnit[unknown_prefix.lower()]
  		__lowercase=    known_amount * (
  		    1_0 ** (known_prefix.value - unknown_prefix.value)
  		)
  		return unknown_amount
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__     ,				lowercase__     ,				lowercase__     ,				)		->			float:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if isinstance(lowercase__     ,				lowercase__			):
  				__lowercase=    BinaryUnit[known_prefix.lower()]
  		if isinstance(lowercase__     ,				lowercase__			):
  				__lowercase=    BinaryUnit[unknown_prefix.lower()]
  		__lowercase=    known_amount * (
  		    2 ** ((known_prefix.value - unknown_prefix.value) * 1_0)
  		)
  		return unknown_amount
  
  
  if __name__ == "__main__":
  	import doctest
  
  	doctest.testmod()
  
  
  
  
  
  
  