


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     snake_case__  (      _A  ):
				def __init__(  self      ):




										"""simple docstring"""




										self.register_to_config()
										super().__init__()
				def  UpperCamelCase_						(  self     ,      _UpperCAmelCase     ,      _UpperCAmelCase      ):




										"""simple docstring"""




										if dicta == dicta:
																return True
										else:
																__magic_name__		, __magic_name__				:							Any				=      self._remove_meta_keys(_UpperCAmelCase      )
																__magic_name__		, __magic_name__				:							Any				=      self._remove_meta_keys(_UpperCAmelCase      )
																if configa == configa:
																						print(F"Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}."      )
																						return True
										return False
				def  UpperCamelCase_						(  self     ,      _UpperCAmelCase      ):




										"""simple docstring"""




										__magic_name__				:							List[str]				=      []
										__magic_name__				:							Union[str, Any]				=      config_dict.copy()
										for key in config_dict.keys():
																if key.startswith('_'      ):
																						temp_dict.pop(_UpperCAmelCase      )
																						meta_keys.append(_UpperCAmelCase      )
										return (temp_dict, meta_keys)
				@torch.no_grad()
				def  UpperCamelCase_						(  self     ,      _UpperCAmelCase     ,      **_UpperCAmelCase      ):




										"""simple docstring"""




										__magic_name__				:							Any				=      kwargs.pop('cache_dir'     ,      _UpperCAmelCase      )
										__magic_name__				:							Optional[Any]				=      kwargs.pop('resume_download'     ,      _UpperCAmelCase      )
										__magic_name__				:							str				=      kwargs.pop('force_download'     ,      _UpperCAmelCase      )
										__magic_name__				:							Optional[Any]				=      kwargs.pop('proxies'     ,      _UpperCAmelCase      )
										__magic_name__				:							Union[str, Any]				=      kwargs.pop('local_files_only'     ,      _UpperCAmelCase      )
										__magic_name__				:							Union[str, Any]				=      kwargs.pop('use_auth_token'     ,      _UpperCAmelCase      )
										__magic_name__				:							int				=      kwargs.pop('revision'     ,      _UpperCAmelCase      )
										__magic_name__				:							str				=      kwargs.pop('torch_dtype'     ,      _UpperCAmelCase      )
										__magic_name__				:							Any				=      kwargs.pop('device_map'     ,      _UpperCAmelCase      )

										__magic_name__				:							str				=      kwargs.pop('alpha'     ,      0.5      )
										__magic_name__				:							Dict				=      kwargs.pop('interp'     ,      _UpperCAmelCase      )

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

										__magic_name__				:							List[Any]				=      len(_UpperCAmelCase      )
										# Ignore result from model_index_json comparision of the two checkpoints
										__magic_name__				:							List[Any]				=      kwargs.pop('force'     ,      _UpperCAmelCase      )

										# 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 '_'
										__magic_name__				:							Optional[int]				=      []
										for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
																__magic_name__				:							Union[str, Any]				=      DiffusionPipeline.load_config(
																    _UpperCAmelCase     ,      cache_dir=_UpperCAmelCase     ,      resume_download=_UpperCAmelCase     ,      force_download=_UpperCAmelCase     ,      proxies=_UpperCAmelCase     ,      local_files_only=_UpperCAmelCase     ,      use_auth_token=_UpperCAmelCase     ,      revision=_UpperCAmelCase     ,      )
																config_dicts.append(_UpperCAmelCase      )

										__magic_name__				:							Union[str, Any]				=      True
										for idx in range(1     ,      len(_UpperCAmelCase      )      ):
																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.
										__magic_name__				:							List[str]				=      []
										for pretrained_model_name_or_path, config_dict in zip(_UpperCAmelCase     ,      _UpperCAmelCase      ):
																__magic_name__				:							Optional[Any]				=      [k for k in config_dict.keys() if not k.startswith('_'      )]
																__magic_name__				:							Dict				=      [os.path.join(_UpperCAmelCase     ,      '*'      ) for k in folder_names]
																allow_patterns += [
																    WEIGHTS_NAME,
																    SCHEDULER_CONFIG_NAME,
																    CONFIG_NAME,
																    ONNX_WEIGHTS_NAME,
																    DiffusionPipeline.config_name,
																]
																__magic_name__				:							List[Any]				=      config_dict.get('_class_name'      )
																__magic_name__				:							Optional[Any]				=      {'diffusers': __version__, 'pipeline_class': requested_pipeline_class}

																__magic_name__				:							Tuple				=      (
																    pretrained_model_name_or_path
																    if os.path.isdir(_UpperCAmelCase      )
																    else snapshot_download(
																        _UpperCAmelCase     ,      cache_dir=_UpperCAmelCase     ,      resume_download=_UpperCAmelCase     ,      proxies=_UpperCAmelCase     ,      local_files_only=_UpperCAmelCase     ,      use_auth_token=_UpperCAmelCase     ,      revision=_UpperCAmelCase     ,      allow_patterns=_UpperCAmelCase     ,      user_agent=_UpperCAmelCase     ,      )
																)
																print('Cached Folder'     ,      _UpperCAmelCase      )
																cached_folders.append(_UpperCAmelCase      )

										# Step 3:-
										# Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
										__magic_name__				:							str				=      DiffusionPipeline.from_pretrained(
										    cached_folders[0]     ,      torch_dtype=_UpperCAmelCase     ,      device_map=_UpperCAmelCase      )
										final_pipe.to(self.device      )

										__magic_name__				:							Any				=      None
										if len(_UpperCAmelCase      ) > 2:
																__magic_name__				:							Optional[Any]				=      os.path.join(cached_folders[2]      )

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

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

																												__magic_name__				:							int				=      getattr(_UpperCAmelCase     ,      'load_state_dict'      )
																												__magic_name__				:							int				=      (
																												    safetensors.torch.load_file(_UpperCAmelCase      )
																												    if (is_safetensors_available() and checkpoint_path_a.endswith('.safetensors'      ))
																												    else torch.load(_UpperCAmelCase     ,      map_location='cpu'      )
																												)
																												__magic_name__				:							List[str]				=      None
																												if checkpoint_path_a:
																																		__magic_name__				:							Tuple				=      (
																																		    safetensors.torch.load_file(_UpperCAmelCase      )
																																		    if (is_safetensors_available() and checkpoint_path_a.endswith('.safetensors'      ))
																																		    else torch.load(_UpperCAmelCase     ,      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(_UpperCAmelCase      )}"      )
																												continue
																						print(F"MERGING {attr}"      )

																						for key in theta_a.keys():
																												if theta_a:
																																		__magic_name__				:							Union[str, Any]				=      theta_func(theta_a[key]     ,      theta_a[key]     ,      theta_a[key]     ,      _UpperCAmelCase      )
																												else:
																																		__magic_name__				:							int				=      theta_func(theta_a[key]     ,      theta_a[key]     ,      _UpperCAmelCase     ,      _UpperCAmelCase      )

																						del theta_a
																						del theta_a
																						update_theta_a(_UpperCAmelCase      )

																						del theta_a
										return final_pipe
				@staticmethod
				def  UpperCamelCase_						(  _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase      ):




										"""simple docstring"""




										return ((1 - alpha) * thetaa) + (alpha * thetaa)
				@staticmethod
				def  UpperCamelCase_						(  _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase      ):




										"""simple docstring"""




										__magic_name__				:							int				=      alpha * alpha * (3 - (2 * alpha))
										return thetaa + ((thetaa - thetaa) * alpha)
				@staticmethod
				def  UpperCamelCase_						(  _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase      ):




										"""simple docstring"""




										import math

										__magic_name__				:							Optional[int]				=      0.5 - math.sin(math.asin(1.0 - 2.0 * alpha      ) / 3.0      )
										return thetaa + ((thetaa - thetaa) * alpha)





				@staticmethod
				def  UpperCamelCase_						(  _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase     ,      _UpperCAmelCase      ):




										"""simple docstring"""




										return thetaa + (thetaa - thetaa) * (1.0 - alpha)






# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import ast
import difflib
from collections.abc import Mapping
from typing import Any, Callable, Dict



class     snake_case__  (      _A  ):
				pass






def  __SCREAMING_SNAKE_CASE       (				lowercase__  :str      ,						lowercase__  :Dict[str, Callable]      ,						lowercase__  :Union[str, Any]=None      ,						lowercase__  :str=False				)       ->  List[str]:
						try:
												__magic_name__				:							str				=      ast.parse(lowercase__				)
						except SyntaxError as e:
												print('The code generated by the agent is not valid.\n'      ,						lowercase__				)
												return
						if state is None:
												__magic_name__				:							Optional[Any]				=      {}
						__magic_name__				:							Dict				=      None
						for idx, node in enumerate(expression.body				):
												try:
																		__magic_name__				:							Any				=      evaluate_ast(lowercase__      ,						lowercase__      ,						lowercase__				)
												except InterpretorError as e:
																		__magic_name__				:							Tuple				=      f"Evaluation of the code stopped at line {idx} before the end because of the following error"
																		if chat_mode:
																								msg += (
																								    f". Copy paste the following error message and send it back to the agent:\nI get an error: '{e}'"
																								)
																		else:
																								msg += f":\n{e}"
																		print(lowercase__				)
																		break
												if line_result is not None:
																		__magic_name__				:							List[str]				=      line_result

						return result
def  __SCREAMING_SNAKE_CASE       (				lowercase__  :ast.AST      ,						lowercase__  :Dict[str, Any]      ,						lowercase__  :Dict[str, Callable]				)       ->  Dict:
						if isinstance(lowercase__      ,						ast.Assign				):
												# Assignement -> we evaluate the assignement which should update the state
												# We return the variable assigned as it may be used to determine the final result.
												return evaluate_assign(lowercase__      ,						lowercase__      ,						lowercase__				)
						elif isinstance(lowercase__      ,						ast.Call				):
												# Function call -> we return the value of the function call
												return evaluate_call(lowercase__      ,						lowercase__      ,						lowercase__				)
						elif isinstance(lowercase__      ,						ast.Constant				):
												# Constant -> just return the value
												return expression.value
						elif isinstance(lowercase__      ,						ast.Dict				):
												# Dict -> evaluate all keys and values
												__magic_name__				:							Any				=      [evaluate_ast(lowercase__      ,						lowercase__      ,						lowercase__				) for k in expression.keys]
												__magic_name__				:							Dict				=      [evaluate_ast(lowercase__      ,						lowercase__      ,						lowercase__				) for v in expression.values]
												return dict(zip(lowercase__      ,						lowercase__				)				)
						elif isinstance(lowercase__      ,						ast.Expr				):
												# Expression -> evaluate the content
												return evaluate_ast(expression.value      ,						lowercase__      ,						lowercase__				)
						elif isinstance(lowercase__      ,						ast.For				):
												# For loop -> execute the loop
												return evaluate_for(lowercase__      ,						lowercase__      ,						lowercase__				)
						elif isinstance(lowercase__      ,						ast.FormattedValue				):
												# Formatted value (part of f-string) -> evaluate the content and return
												return evaluate_ast(expression.value      ,						lowercase__      ,						lowercase__				)
						elif isinstance(lowercase__      ,						ast.If				):
												# If -> execute the right branch
												return evaluate_if(lowercase__      ,						lowercase__      ,						lowercase__				)
						elif hasattr(lowercase__      ,						'Index'				) and isinstance(lowercase__      ,						ast.Index				):
												return evaluate_ast(expression.value      ,						lowercase__      ,						lowercase__				)
						elif isinstance(lowercase__      ,						ast.JoinedStr				):
												return "".join([str(evaluate_ast(lowercase__      ,						lowercase__      ,						lowercase__				)				) for v in expression.values]				)
						elif isinstance(lowercase__      ,						ast.List				):
												# List -> evaluate all elements
												return [evaluate_ast(lowercase__      ,						lowercase__      ,						lowercase__				) for elt in expression.elts]
						elif isinstance(lowercase__      ,						ast.Name				):
												# Name -> pick up the value in the state
												return evaluate_name(lowercase__      ,						lowercase__      ,						lowercase__				)
						elif isinstance(lowercase__      ,						ast.Subscript				):
												# Subscript -> return the value of the indexing
												return evaluate_subscript(lowercase__      ,						lowercase__      ,						lowercase__				)
						else:
												# For now we refuse anything else. Let's add things as we need them.
												raise InterpretorError(f"{expression.__class__.__name__} is not supported."				)
def  __SCREAMING_SNAKE_CASE       (				lowercase__  :List[Any]      ,						lowercase__  :Optional[Any]      ,						lowercase__  :Union[str, Any]				)       ->  List[Any]:
						__magic_name__				:							Union[str, Any]				=      assign.targets
						__magic_name__				:							int				=      evaluate_ast(assign.value      ,						lowercase__      ,						lowercase__				)

						if len(lowercase__				) == 1:
												__magic_name__				:							Any				=      result
						else:
												if len(lowercase__				) != len(lowercase__				):
																		raise InterpretorError(f"Expected {len(lowercase__				)} values but got {len(lowercase__				)}."				)
												for var_name, r in zip(lowercase__      ,						lowercase__				):
																		__magic_name__				:							str				=      r
						return result
def  __SCREAMING_SNAKE_CASE       (				lowercase__  :List[str]      ,						lowercase__  :List[str]      ,						lowercase__  :Tuple				)       ->  Optional[Any]:
						if not isinstance(call.func      ,						ast.Name				):
												raise InterpretorError(
												    f"It is not permitted to evaluate other functions than the provided tools (tried to execute {call.func} of "
												    f"type {type(call.func				)}."				)
						__magic_name__				:							Dict				=      call.func.id
						if func_name not in tools:
												raise InterpretorError(
												    f"It is not permitted to evaluate other functions than the provided tools (tried to execute {call.func.id})."				)

						__magic_name__				:							Tuple				=      tools[func_name]
						# Todo deal with args
						__magic_name__				:							List[str]				=      [evaluate_ast(lowercase__      ,						lowercase__      ,						lowercase__				) for arg in call.args]
						__magic_name__				:							int				=      {keyword.arg: evaluate_ast(keyword.value      ,						lowercase__      ,						lowercase__				) for keyword in call.keywords}
						return func(*lowercase__      ,						**lowercase__				)
def  __SCREAMING_SNAKE_CASE       (				lowercase__  :Union[str, Any]      ,						lowercase__  :int      ,						lowercase__  :int				)       ->  List[Any]:
						__magic_name__				:							Optional[int]				=      evaluate_ast(subscript.slice      ,						lowercase__      ,						lowercase__				)
						__magic_name__				:							Union[str, Any]				=      evaluate_ast(subscript.value      ,						lowercase__      ,						lowercase__				)
						if isinstance(lowercase__      ,						(list, tuple)				):
												return value[int(lowercase__				)]
						if index in value:
												return value[index]
						if isinstance(lowercase__      ,						lowercase__				) and isinstance(lowercase__      ,						lowercase__				):
												__magic_name__				:							Any				=      difflib.get_close_matches(lowercase__      ,						list(value.keys()				)				)
												if len(lowercase__				) > 0:
																		return value[close_matches[0]]

						raise InterpretorError(f"Could not index {value} with '{index}'."				)
def  __SCREAMING_SNAKE_CASE       (				lowercase__  :List[str]      ,						lowercase__  :Optional[Any]      ,						lowercase__  :Optional[int]				)       ->  int:
						if name.id in state:
												return state[name.id]
						__magic_name__				:							Union[str, Any]				=      difflib.get_close_matches(name.id      ,						list(state.keys()				)				)
						if len(lowercase__				) > 0:
												return state[close_matches[0]]
						raise InterpretorError(f"The variable `{name.id}` is not defined."				)
def  __SCREAMING_SNAKE_CASE       (				lowercase__  :Any      ,						lowercase__  :Union[str, Any]      ,						lowercase__  :Optional[Any]				)       ->  List[str]:
						if len(condition.ops				) > 1:
												raise InterpretorError('Cannot evaluate conditions with multiple operators'				)

						__magic_name__				:							int				=      evaluate_ast(condition.left      ,						lowercase__      ,						lowercase__				)
						__magic_name__				:							Optional[int]				=      condition.ops[0]
						__magic_name__				:							Union[str, Any]				=      evaluate_ast(condition.comparators[0]      ,						lowercase__      ,						lowercase__				)

						if isinstance(lowercase__      ,						ast.Eq				):
												return left == right
						elif isinstance(lowercase__      ,						ast.NotEq				):
												return left != right
						elif isinstance(lowercase__      ,						ast.Lt				):
												return left < right
						elif isinstance(lowercase__      ,						ast.LtE				):
												return left <= right
						elif isinstance(lowercase__      ,						ast.Gt				):
												return left > right
						elif isinstance(lowercase__      ,						ast.GtE				):
												return left >= right
						elif isinstance(lowercase__      ,						ast.Is				):
												return left is right
						elif isinstance(lowercase__      ,						ast.IsNot				):
												return left is not right
						elif isinstance(lowercase__      ,						ast.In				):
												return left in right
						elif isinstance(lowercase__      ,						ast.NotIn				):
												return left not in right
						else:
												raise InterpretorError(f"Operator not supported: {comparator}"				)
def  __SCREAMING_SNAKE_CASE       (				lowercase__  :Optional[int]      ,						lowercase__  :str      ,						lowercase__  :Tuple				)       ->  int:
						__magic_name__				:							Optional[int]				=      None
						if evaluate_condition(if_statement.test      ,						lowercase__      ,						lowercase__				):
												for line in if_statement.body:
																		__magic_name__				:							List[Any]				=      evaluate_ast(lowercase__      ,						lowercase__      ,						lowercase__				)
																		if line_result is not None:
																								__magic_name__				:							Tuple				=      line_result
						else:
												for line in if_statement.orelse:
																		__magic_name__				:							Optional[int]				=      evaluate_ast(lowercase__      ,						lowercase__      ,						lowercase__				)
																		if line_result is not None:
																								__magic_name__				:							List[Any]				=      line_result
						return result

def  __SCREAMING_SNAKE_CASE       (				lowercase__  :Optional[Any]      ,						lowercase__  :Union[str, Any]      ,						lowercase__  :List[str]				)       ->  Dict:
						__magic_name__				:							int				=      None
						__magic_name__				:							List[Any]				=      evaluate_ast(for_loop.iter      ,						lowercase__      ,						lowercase__				)
						for counter in iterator:
												__magic_name__				:							Tuple				=      counter
												for expression in for_loop.body:
																		__magic_name__				:							Dict				=      evaluate_ast(lowercase__      ,						lowercase__      ,						lowercase__				)
																		if line_result is not None:
																								__magic_name__				:							Dict				=      line_result
						return result


