


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 					lowerCAmelCase__	(    a):




     '''simple docstring'''


     def __init__(						self)      ->    Dict:
            self.register_to_config()
            super().__init__()


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						__lowerCamelCase)      ->    Dict:
            if dicta == dicta:
                   return True
            else:
                   _A   ,      _A				:	Tuple       =			self._remove_meta_keys(__lowerCamelCase)
                   _A   ,      _A				:	List[Any]       =			self._remove_meta_keys(__lowerCamelCase)
                   if configa == configa:
                          print(F"Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}.")
                          return True
            return False


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase)      ->    int:
            _A				:	Optional[Any]       =			[]
            _A				:	str       =			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 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						**__lowerCamelCase)      ->    Dict:
            _A				:	str       =			kwargs.pop("cache_dir"			,						__lowerCamelCase)
            _A				:	Union[str, Any]       =			kwargs.pop("resume_download"			,						__lowerCamelCase)
            _A				:	Optional[Any]       =			kwargs.pop("force_download"			,						__lowerCamelCase)
            _A				:	Optional[Any]       =			kwargs.pop("proxies"			,						__lowerCamelCase)
            _A				:	Any       =			kwargs.pop("local_files_only"			,						__lowerCamelCase)
            _A				:	Optional[int]       =			kwargs.pop("use_auth_token"			,						__lowerCamelCase)
            _A				:	Any       =			kwargs.pop("revision"			,						__lowerCamelCase)
            _A				:	Optional[int]       =			kwargs.pop("torch_dtype"			,						__lowerCamelCase)
            _A				:	Any       =			kwargs.pop("device_map"			,						__lowerCamelCase)

            _A				:	Tuple       =			kwargs.pop("alpha"			,						0.5)
            _A				:	Optional[int]       =			kwargs.pop("interp"			,						__lowerCamelCase)

            print("Received list"			,						__lowerCamelCase)
            print(F"Combining with alpha={alpha}, interpolation mode={interp}")

            _A				:	Any       =			len(__lowerCamelCase)
            # Ignore result from model_index_json comparision of the two checkpoints
            _A				:	List[Any]       =			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 '_'
            _A				:	Union[str, Any]       =			[]
            for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
                   _A				:	List[Any]       =			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)

            _A				:	Optional[Any]       =			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.
            _A				:	Optional[int]       =			[]
            for pretrained_model_name_or_path, config_dict in zip(__lowerCamelCase			,						__lowerCamelCase):
                   _A				:	Optional[int]       =			[k for k in config_dict.keys() if not k.startswith("_")]
                   _A				:	Union[str, Any]       =			[os.path.join(__lowerCamelCase			,						"*") for k in folder_names]
                   allow_patterns += [
                       WEIGHTS_NAME,
                       SCHEDULER_CONFIG_NAME,
                       CONFIG_NAME,
                       ONNX_WEIGHTS_NAME,
                       DiffusionPipeline.config_name,
                   ]
                   _A				:	List[str]       =			config_dict.get("_class_name")
                   _A				:	Tuple       =			{"diffusers": __version__, "pipeline_class": requested_pipeline_class}

                   _A				:	Optional[Any]       =			(
                       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
            _A				:	List[Any]       =			DiffusionPipeline.from_pretrained(
                cached_folders[0]			,						torch_dtype=__lowerCamelCase			,						device_map=__lowerCamelCase)
            final_pipe.to(self.device)

            _A				:	Tuple       =			None
            if len(__lowerCamelCase) > 2:
                   _A				:	Optional[int]       =			os.path.join(cached_folders[2])

            if interp == "sigmoid":
                   _A				:	str       =			CheckpointMergerPipeline.sigmoid
            elif interp == "inv_sigmoid":
                   _A				:	Any       =			CheckpointMergerPipeline.inv_sigmoid
            elif interp == "add_diff":
                   _A				:	List[str]       =			CheckpointMergerPipeline.add_difference
            else:
                   _A				:	Optional[Any]       =			CheckpointMergerPipeline.weighted_sum

            # Find each module's state dict.
            for attr in final_pipe.config.keys():
                   if not attr.startswith("_"):
                          _A				:	Union[str, Any]       =			os.path.join(cached_folders[1]			,						__lowerCamelCase)
                          if os.path.exists(__lowerCamelCase):
                                 _A				:	Tuple       =			[
                                     *glob.glob(os.path.join(__lowerCamelCase			,						"*.safetensors")),
                                     *glob.glob(os.path.join(__lowerCamelCase			,						"*.bin")),
                                 ]
                                 _A				:	Any       =			files[0] if len(__lowerCamelCase) > 0 else None
                          if len(__lowerCamelCase) < 3:
                                 _A				:	Optional[Any]       =			None
                          else:
                                 _A				:	List[str]       =			os.path.join(cached_folders[2]			,						__lowerCamelCase)
                                 if os.path.exists(__lowerCamelCase):
                                        _A				:	Dict       =			[
                                            *glob.glob(os.path.join(__lowerCamelCase			,						"*.safetensors")),
                                            *glob.glob(os.path.join(__lowerCamelCase			,						"*.bin")),
                                        ]
                                        _A				:	int       =			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:
                                 _A				:	Tuple       =			getattr(__lowerCamelCase			,						__lowerCamelCase)
                                 if isinstance(__lowerCamelCase			,						__lowerCamelCase):  # ignore requires_safety_checker boolean
                                        continue
                                 _A				:	Dict       =			getattr(__lowerCamelCase			,						"state_dict")
                                 _A				:	int       =			theta_a()

                                 _A				:	List[str]       =			getattr(__lowerCamelCase			,						"load_state_dict")
                                 _A				:	Dict       =			(
                                     safetensors.torch.load_file(__lowerCamelCase)
                                     if (is_safetensors_available() and checkpoint_path_a.endswith(".safetensors"))
                                     else torch.load(__lowerCamelCase			,						map_location="cpu")
                                 )
                                 _A				:	Tuple       =			None
                                 if checkpoint_path_a:
                                        _A				:	Tuple       =			(
                                            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:
                                        _A				:	Any       =			theta_func(theta_a[key]			,						theta_a[key]			,						theta_a[key]			,						__lowerCamelCase)
                                 else:
                                        _A				:	Optional[Any]       =			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 			_lowerCamelCase			(						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase)      ->    str:
            return ((1 - alpha) * thetaa) + (alpha * thetaa)


     @staticmethod
     def 			_lowerCamelCase			(						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase)      ->    Dict:
            _A				:	Any       =			alpha * alpha * (3 - (2 * alpha))
            return thetaa + ((thetaa - thetaa) * alpha)


     @staticmethod
     def 			_lowerCamelCase			(						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase)      ->    str:
            import math

            _A				:	str       =			0.5 - math.sin(math.asin(1.0 - 2.0 * alpha) / 3.0)
            return thetaa + ((thetaa - thetaa) * alpha)


     @staticmethod
     def 			_lowerCamelCase			(						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase)      ->    Optional[Any]:
            return thetaa + (thetaa - thetaa) * (1.0 - alpha)




from itertools import permutations
def 							_UpperCAmelCase    ():
       _A				:	List[Any]       =			list(map("".join    ,							permutations("0123456789"						)						)						)
       return result[999999]


if __name__ == "__main__":
    print(solution())
