



'''simple docstring'''






from typing import List, Optional, Union

import torch

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)


UpperCamelCase__:   Dict								=			logging.get_logger(__name__)  # pylint: disable=invalid-name

UpperCamelCase__:   str								=			"\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline\n        >>> import torch\n\n        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\"kandinsky-community/kandinsky-2-2-prior\")\n        >>> pipe_prior.to(\"cuda\")\n        >>> prompt = \"red cat, 4k photo\"\n        >>> out = pipe_prior(prompt)\n        >>> image_emb = out.image_embeds\n        >>> zero_image_emb = out.negative_image_embeds\n        >>> pipe = KandinskyV22Pipeline.from_pretrained(\"kandinsky-community/kandinsky-2-2-decoder\")\n        >>> pipe.to(\"cuda\")\n        >>> image = pipe(\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=zero_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=50,\n        ... ).images\n        >>> image[0].save(\"cat.png\")\n        ```\n"


def  snake_case_     (					_lowerCAmelCase  :						List[Any]   ,      _lowerCAmelCase  :						Optional[Any]   ,      _lowerCAmelCase  :						Optional[Any]=8  )      ->   Any:
							UpperCAmelCase :       Union[str, Any] 							=		height // scale_factor**2
							if height % scale_factor**2 != 0:
														new_height += 1
							UpperCAmelCase :       List[Any] 							=		width // scale_factor**2
							if width % scale_factor**2 != 0:
														new_width += 1
							return new_height * scale_factor, new_width * scale_factor




class 				SCREAMING_SNAKE_CASE(							A__			):







	"""simple docstring"""






	def __init__(						self			:     List[str]		,			__snake_case			:     UNetaDConditionModel		,			__snake_case			:     DDPMScheduler		,			__snake_case			:     VQModel		,			)			->		Dict:
								super().__init__()

								self.register_modules(
								    unet=__snake_case		,			scheduler=__snake_case		,			movq=__snake_case		,			)
								UpperCAmelCase :       Any 							=		2 ** (len(self.movq.config.block_out_channels		) - 1)







	def      A	(						self			:     Tuple		,			__snake_case			:     Tuple		,			__snake_case			:     List[str]		,			__snake_case			:     Any		,			__snake_case			:     int		,			__snake_case			:     Optional[Any]		,			__snake_case			:     int		)			->		Optional[int]:
								if latents is None:
															UpperCAmelCase :       Optional[int] 							=		randn_tensor(__snake_case		,			generator=__snake_case		,			device=__snake_case		,			dtype=__snake_case		)
								else:
															if latents.shape != shape:
																						raise ValueError(F"""Unexpected latents shape, got {latents.shape}, expected {shape}"""		)
															UpperCAmelCase :       List[Any] 							=		latents.to(__snake_case		)

								UpperCAmelCase :       Optional[int] 							=		latents * scheduler.init_noise_sigma
								return latents







	def      A	(						self			:     Dict		,			__snake_case			:     Dict=0		)			->		Any:
								if is_accelerate_available():
															from accelerate import cpu_offload
								else:
															raise ImportError('''Please install accelerate via `pip install accelerate`'''		)

								UpperCAmelCase :       Tuple 							=		torch.device(F"""cuda:{gpu_id}"""		)

								UpperCAmelCase :       Tuple 							=		[
								    self.unet,
								    self.movq,
								]
								for cpu_offloaded_model in models:
															if cpu_offloaded_model is not None:
																						cpu_offload(__snake_case		,			__snake_case		)







	def      A	(						self			:     List[str]		,			__snake_case			:     Tuple=0		)			->		List[Any]:
								if is_accelerate_available() and is_accelerate_version('''>='''		,			'''0.17.0.dev0'''		):
															from accelerate import cpu_offload_with_hook
								else:
															raise ImportError('''`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.'''		)

								UpperCAmelCase :       Dict 							=		torch.device(F"""cuda:{gpu_id}"""		)

								if self.device.type != "cpu":
															self.to('''cpu'''		,			silence_dtype_warnings=__snake_case		)
															torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

								UpperCAmelCase :       Union[str, Any] 							=		None
								for cpu_offloaded_model in [self.unet, self.movq]:
															UpperCAmelCase							,		UpperCAmelCase :       Any 							=		cpu_offload_with_hook(__snake_case		,			__snake_case		,			prev_module_hook=__snake_case		)

								# We'll offload the last model manually.
								UpperCAmelCase :       Tuple 							=		hook







	@property
	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
	def      A	(						self			:     List[str]		)			->		Dict:
								if not hasattr(self.unet		,			'''_hf_hook'''		):
															return self.device
								for module in self.unet.modules():
															if (
															    hasattr(__snake_case		,			'''_hf_hook'''		)
															    and hasattr(module._hf_hook		,			'''execution_device'''		)
															    and module._hf_hook.execution_device is not None
															):
																						return torch.device(module._hf_hook.execution_device		)
								return self.device







	@torch.no_grad()
	@replace_example_docstring(__snake_case		)
	def __call__(						self			:     Tuple		,			__snake_case			:     Union[torch.FloatTensor, List[torch.FloatTensor]]		,			__snake_case			:     Union[torch.FloatTensor, List[torch.FloatTensor]]		,			__snake_case			:     int = 512		,			__snake_case			:     int = 512		,			__snake_case			:     int = 100		,			__snake_case			:     float = 4.0		,			__snake_case			:     int = 1		,			__snake_case			:     Optional[Union[torch.Generator, List[torch.Generator]]] = None		,			__snake_case			:     Optional[torch.FloatTensor] = None		,			__snake_case			:     Optional[str] = "pil"		,			__snake_case			:     bool = True		,			)			->		str:
								UpperCAmelCase :       int 							=		self._execution_device

								UpperCAmelCase :       Optional[int] 							=		guidance_scale > 1.0

								if isinstance(__snake_case		,			__snake_case		):
															UpperCAmelCase :       Union[str, Any] 							=		torch.cat(__snake_case		,			dim=0		)
								UpperCAmelCase :       str 							=		image_embeds.shape[0] * num_images_per_prompt
								if isinstance(__snake_case		,			__snake_case		):
															UpperCAmelCase :       Tuple 							=		torch.cat(__snake_case		,			dim=0		)

								if do_classifier_free_guidance:
															UpperCAmelCase :       Optional[Any] 							=		image_embeds.repeat_interleave(__snake_case		,			dim=0		)
															UpperCAmelCase :       int 							=		negative_image_embeds.repeat_interleave(__snake_case		,			dim=0		)

								UpperCAmelCase :       Union[str, Any] 							=		torch.cat([negative_image_embeds, image_embeds]		,			dim=0		).to(dtype=self.unet.dtype		,			device=__snake_case		)

								self.scheduler.set_timesteps(__snake_case		,			device=__snake_case		)
								UpperCAmelCase :       Optional[int] 							=		self.scheduler.timesteps

								UpperCAmelCase :       Dict 							=		self.unet.config.in_channels

								UpperCAmelCase							,		UpperCAmelCase :       str 							=		downscale_height_and_width(__snake_case		,			__snake_case		,			self.movq_scale_factor		)

								# create initial latent
								UpperCAmelCase :       Optional[Any] 							=		self.prepare_latents(
								    (batch_size, num_channels_latents, height, width)		,			image_embeds.dtype		,			__snake_case		,			__snake_case		,			__snake_case		,			self.scheduler		,			)

								for i, t in enumerate(self.progress_bar(__snake_case		)		):
															# expand the latents if we are doing classifier free guidance
															UpperCAmelCase :       Optional[Any] 							=		torch.cat([latents] * 2		) if do_classifier_free_guidance else latents

															UpperCAmelCase :       str 							=		{'''image_embeds''': image_embeds}
															UpperCAmelCase :       Tuple 							=		self.unet(
															    sample=__snake_case		,			timestep=__snake_case		,			encoder_hidden_states=__snake_case		,			added_cond_kwargs=__snake_case		,			return_dict=__snake_case		,			)[0]

															if do_classifier_free_guidance:
																						UpperCAmelCase							,		UpperCAmelCase :       List[Any] 							=		noise_pred.split(latents.shape[1]		,			dim=1		)
																						UpperCAmelCase							,		UpperCAmelCase :       str 							=		noise_pred.chunk(2		)
																						UpperCAmelCase							,		UpperCAmelCase :       int 							=		variance_pred.chunk(2		)
																						UpperCAmelCase :       Any 							=		noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																						UpperCAmelCase :       Optional[Any] 							=		torch.cat([noise_pred, variance_pred_text]		,			dim=1		)

															if not (
															    hasattr(self.scheduler.config		,			'''variance_type'''		)
															    and self.scheduler.config.variance_type in ["learned", "learned_range"]
															):
																						UpperCAmelCase							,		UpperCAmelCase :       Dict 							=		noise_pred.split(latents.shape[1]		,			dim=1		)

															# compute the previous noisy sample x_t -> x_t-1
															UpperCAmelCase :       Optional[int] 							=		self.scheduler.step(
															    __snake_case		,			__snake_case		,			__snake_case		,			generator=__snake_case		,			)[0]
								# post-processing
								UpperCAmelCase :       Optional[int] 							=		self.movq.decode(__snake_case		,			force_not_quantize=__snake_case		)['''sample''']

								if output_type not in ["pt", "np", "pil"]:
															raise ValueError(F"""Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}"""		)

								if output_type in ["np", "pil"]:
															UpperCAmelCase :       List[Any] 							=		image * 0.5 + 0.5
															UpperCAmelCase :       int 							=		image.clamp(0		,			1		)
															UpperCAmelCase :       Any 							=		image.cpu().permute(0		,			2		,			3		,			1		).float().numpy()

								if output_type == "pil":
															UpperCAmelCase :       Optional[Any] 							=		self.numpy_to_pil(__snake_case		)

								if not return_dict:
															return (image,)

								return ImagePipelineOutput(images=__snake_case		)










'''simple docstring'''






import argparse
import os
import re

import packaging.version


UpperCamelCase__:   Union[str, Any]								=			"examples/"
UpperCamelCase__:   Optional[Any]								=			{
    "examples": (re.compile(r"^check_min_version\(\"[^\"]+\"\)\s*$", re.MULTILINE), "check_min_version(\"VERSION\")\n"),
    "init": (re.compile(r"^__version__\s+=\s+\"([^\"]+)\"\s*$", re.MULTILINE), "__version__ = \"VERSION\"\n"),
    "setup": (re.compile(r"^(\s*)version\s*=\s*\"[^\"]+\",", re.MULTILINE), r"\1version=\"VERSION\","),
    "doc": (re.compile(r"^(\s*)release\s*=\s*\"[^\"]+\"$", re.MULTILINE), "release = \"VERSION\"\n"),
}
UpperCamelCase__:   Optional[int]								=			{
    "init": "src/diffusers/__init__.py",
    "setup": "setup.py",
}
UpperCamelCase__:   List[Any]								=			"README.md"


def  snake_case_     (					_lowerCAmelCase  :						Optional[Any]   ,      _lowerCAmelCase  :						List[Any]   ,      _lowerCAmelCase  :						int  )      ->   Optional[int]:
							with open(_lowerCAmelCase   ,      '''r'''   ,      encoding='''utf-8'''   ,      newline='''\n'''  ) as f:
														UpperCAmelCase :       Optional[int] 							=		f.read()
							UpperCAmelCase							,		UpperCAmelCase :       List[Any] 							=		REPLACE_PATTERNS[pattern]
							UpperCAmelCase :       List[Any] 							=		replace.replace('''VERSION'''   ,      _lowerCAmelCase  )
							UpperCAmelCase :       Optional[Any] 							=		re_pattern.sub(_lowerCAmelCase   ,      _lowerCAmelCase  )
							with open(_lowerCAmelCase   ,      '''w'''   ,      encoding='''utf-8'''   ,      newline='''\n'''  ) as f:
														f.write(_lowerCAmelCase  )


def  snake_case_     (					_lowerCAmelCase  :						Any  )      ->   Optional[int]:
							for folder, directories, fnames in os.walk(_lowerCAmelCase  ):
														# Removing some of the folders with non-actively maintained examples from the walk
														if "research_projects" in directories:
																					directories.remove('''research_projects'''  )
														if "legacy" in directories:
																					directories.remove('''legacy'''  )
														for fname in fnames:
																					if fname.endswith('''.py'''  ):
																												update_version_in_file(os.path.join(_lowerCAmelCase   ,      _lowerCAmelCase  )   ,      _lowerCAmelCase   ,      pattern='''examples'''  )


def  snake_case_     (					_lowerCAmelCase  :						Any   ,      _lowerCAmelCase  :						str=False  )      ->   List[str]:
							for pattern, fname in REPLACE_FILES.items():
														update_version_in_file(_lowerCAmelCase   ,      _lowerCAmelCase   ,      _lowerCAmelCase  )
							if not patch:
														update_version_in_examples(_lowerCAmelCase  )


def  snake_case_     (					)      ->   Optional[Any]:
							UpperCAmelCase :       Optional[int] 							=		'''🤗 Transformers currently provides the following architectures'''
							UpperCAmelCase :       Optional[int] 							=		'''1. Want to contribute a new model?'''
							with open(_lowerCAmelCase   ,      '''r'''   ,      encoding='''utf-8'''   ,      newline='''\n'''  ) as f:
														UpperCAmelCase :       Optional[Any] 							=		f.readlines()

							# Find the start of the list.
							UpperCAmelCase :       List[Any] 							=		0
							while not lines[start_index].startswith(_start_prompt  ):
														start_index += 1
							start_index += 1

							UpperCAmelCase :       Optional[Any] 							=		start_index
							# Update the lines in the model list.
							while not lines[index].startswith(_end_prompt  ):
														if lines[index].startswith('''1.'''  ):
																					UpperCAmelCase :       Optional[int] 							=		lines[index].replace(
																					    '''https://huggingface.co/docs/diffusers/main/model_doc'''   ,      '''https://huggingface.co/docs/diffusers/model_doc'''   ,      )
														index += 1

							with open(_lowerCAmelCase   ,      '''w'''   ,      encoding='''utf-8'''   ,      newline='''\n'''  ) as f:
														f.writelines(_lowerCAmelCase  )


def  snake_case_     (					)      ->   Optional[Any]:
							with open(REPLACE_FILES['''init''']   ,      '''r'''  ) as f:
														UpperCAmelCase :       Union[str, Any] 							=		f.read()
							UpperCAmelCase :       int 							=		REPLACE_PATTERNS['''init'''][0].search(_lowerCAmelCase  ).groups()[0]
							return packaging.version.parse(_lowerCAmelCase  )


def  snake_case_     (					_lowerCAmelCase  :						List[str]=False  )      ->   Any:
							UpperCAmelCase :       Optional[Any] 							=		get_version()
							if patch and default_version.is_devrelease:
														raise ValueError('''Can\'t create a patch version from the dev branch, checkout a released version!'''  )
							if default_version.is_devrelease:
														UpperCAmelCase :       Optional[int] 							=		default_version.base_version
							elif patch:
														UpperCAmelCase :       Union[str, Any] 							=		f"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}"""
							else:
														UpperCAmelCase :       Union[str, Any] 							=		f"""{default_version.major}.{default_version.minor + 1}.0"""

							# Now let's ask nicely if that's the right one.
							UpperCAmelCase :       Dict 							=		input(f"""Which version are you releasing? [{default_version}]"""  )
							if len(_lowerCAmelCase  ) == 0:
														UpperCAmelCase :       Tuple 							=		default_version

							print(f"""Updating version to {version}."""  )
							global_version_update(_lowerCAmelCase   ,      patch=_lowerCAmelCase  )


def  snake_case_     (					)      ->   Any:
							UpperCAmelCase :       List[Any] 							=		get_version()
							UpperCAmelCase :       List[str] 							=		f"""{current_version.major}.{current_version.minor + 1}.0.dev0"""
							UpperCAmelCase :       List[Any] 							=		current_version.base_version

							# Check with the user we got that right.
							UpperCAmelCase :       Optional[int] 							=		input(f"""Which version are we developing now? [{dev_version}]"""  )
							if len(_lowerCAmelCase  ) == 0:
														UpperCAmelCase :       Dict 							=		dev_version

							print(f"""Updating version to {version}."""  )
							global_version_update(_lowerCAmelCase  )


#    print("Cleaning main README, don't forget to run `make fix-copies`.")
#    clean_main_ref_in_model_list()


if __name__ == "__main__":
						UpperCamelCase__:   Union[str, Any]								=			argparse.ArgumentParser()
						parser.add_argument("--post_release", action="store_true", help="Whether this is pre or post release.")
						parser.add_argument("--patch", action="store_true", help="Whether or not this is a patch release.")
						UpperCamelCase__:   Optional[Any]								=			parser.parse_args()
						if not args.post_release:
												pre_release_work(patch=args.patch)
						elif args.patch:
												print("Nothing to do after a patch :-)")
						else:
												post_release_work()





