


'''simple docstring'''
from importlib import import_module

from .logging import get_logger


__snake_case							      =     get_logger(__name__)
class    lowercase	:

		"""simple docstring"""

		def __init__(		self    ,   UpperCamelCase_    ,   UpperCamelCase_=None							):

							'''simple docstring'''


							UpperCamelCase__   :Union[str, Any]												= attrs or []
							if module is not None:
												for key in module.__dict__:
																	if key in attrs or not key.startswith('''__'''							):
																						setattr(self    ,   UpperCamelCase_    ,   getattr(UpperCamelCase_    ,   UpperCamelCase_							)							)
							UpperCamelCase__   :str												= module._original_module if isinstance(UpperCamelCase_    ,   _PatchedModuleObj							) else module



class    lowercase	:

		"""simple docstring"""

		_a     =				[]




		def __init__(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_=None							):

							'''simple docstring'''


							UpperCamelCase__   :Optional[int]												= obj
							UpperCamelCase__   :Tuple												= target
							UpperCamelCase__   :int												= new
							UpperCamelCase__   :Union[str, Any]												= target.split('''.'''							)[0]
							UpperCamelCase__   :Union[str, Any]												= {}
							UpperCamelCase__   :Any												= attrs or []




		def __enter__(		self							):

							'''simple docstring'''


							*UpperCamelCase__					,				UpperCamelCase__   :Union[str, Any]												= self.target.split('''.'''							)

							# Patch modules:
							# it's used to patch attributes of submodules like "os.path.join";
							# in this case we need to patch "os" and "os.path"

							for i in range(len(UpperCamelCase_							)							):
												try:
																	UpperCamelCase__   :List[Any]												= import_module('''.'''.join(submodules[: i + 1]							)							)
												except ModuleNotFoundError:
																	continue
												# We iterate over all the globals in self.obj in case we find "os" or "os.path"
												for attr in self.obj.__dir__():
																	UpperCamelCase__   :int												= getattr(self.obj    ,   UpperCamelCase_							)
																	# We don't check for the name of the global, but rather if its value *is* "os" or "os.path".
																	# This allows to patch renamed modules like "from os import path as ospath".
																	if obj_attr is submodule or (
																	    (isinstance(UpperCamelCase_    ,   _PatchedModuleObj							) and obj_attr._original_module is submodule)
																	):
																						UpperCamelCase__   :Tuple												= obj_attr
																						# patch at top level
																						setattr(self.obj    ,   UpperCamelCase_    ,   _PatchedModuleObj(UpperCamelCase_    ,   attrs=self.attrs							)							)
																						UpperCamelCase__   :List[Any]												= getattr(self.obj    ,   UpperCamelCase_							)
																						# construct lower levels patches
																						for key in submodules[i + 1 :]:
																											setattr(UpperCamelCase_    ,   UpperCamelCase_    ,   _PatchedModuleObj(getattr(UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							)    ,   attrs=self.attrs							)							)
																											UpperCamelCase__   :Tuple												= getattr(UpperCamelCase_    ,   UpperCamelCase_							)
																						# finally set the target attribute
																						setattr(UpperCamelCase_    ,   UpperCamelCase_    ,   self.new							)

        # Patch attribute itself:
        # it's used for builtins like "open",
        # and also to patch "os.path.join" we may also need to patch "join"
        # itself if it was imported as "from os.path import join".

							if submodules:  # if it's an attribute of a submodule like "os.path.join"
												try:
																	UpperCamelCase__   :Dict												= getattr(import_module('''.'''.join(UpperCamelCase_							)							)    ,   UpperCamelCase_							)
												except (AttributeError, ModuleNotFoundError):
																	return
												# We iterate over all the globals in self.obj in case we find "os.path.join"
												for attr in self.obj.__dir__():
																	# We don't check for the name of the global, but rather if its value *is* "os.path.join".
																	# This allows to patch renamed attributes like "from os.path import join as pjoin".
																	if getattr(self.obj    ,   UpperCamelCase_							) is attr_value:
																						UpperCamelCase__   :Optional[int]												= getattr(self.obj    ,   UpperCamelCase_							)
																						setattr(self.obj    ,   UpperCamelCase_    ,   self.new							)
							elif target_attr in globals()["__builtins__"]:  # if it'a s builtin like "open"
												UpperCamelCase__   :Optional[Any]												= globals()['''__builtins__'''][target_attr]
												setattr(self.obj    ,   UpperCamelCase_    ,   self.new							)
							else:
												raise RuntimeError(F'''Tried to patch attribute {target_attr} instead of a submodule.'''							)




		def __exit__(		self    ,   *UpperCamelCase_							):

							'''simple docstring'''


							for attr in list(self.original							):
												setattr(self.obj    ,   UpperCamelCase_    ,   self.original.pop(UpperCamelCase_							)							)




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							self.__enter__()
							self._active_patches.append(self							)




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							try:
												self._active_patches.remove(self							)
							except ValueError:
												# If the patch hasn't been started this will fail
												return None

							return self.__exit__()



'''simple docstring'''
from ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
		if not (is_transformers_available() and is_torch_available()):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
		from .multicontrolnet import MultiControlNetModel
		from .pipeline_controlnet import StableDiffusionControlNetPipeline
		from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
		from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
		from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline