def    UpperCAmelCase__(						lowerCamelCase_							,	lowerCamelCase_ = 1000  ):



			"""simple docstring"""





			if (not isinstance(lowerCamelCase_							,	lowerCamelCase_  )) or (digit_position <= 0):
						raise ValueError("Digit position must be a positive integer"  )
			elif (not isinstance(lowerCamelCase_							,	lowerCamelCase_  )) or (precision < 0):
						raise ValueError("Precision must be a nonnegative integer"  )

			# compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
			# accurate
			_snake_case              =      (
			    4 * _subsum(lowerCamelCase_							,	1							,	lowerCamelCase_  )
			    - 2 * _subsum(lowerCamelCase_							,	4							,	lowerCamelCase_  )
			    - _subsum(lowerCamelCase_							,	5							,	lowerCamelCase_  )
			    - _subsum(lowerCamelCase_							,	6							,	lowerCamelCase_  )
			)

			# return the first hex digit of the fractional part of the result
			return hex(int((sum_result % 1) * 16  )  )[2:]






def    UpperCAmelCase__(						lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_  ):



			"""simple docstring"""





			_snake_case              =      0.0
			for sum_index in range(digit_pos_to_extract + precision  ):
						_snake_case              =      8 * sum_index + denominator_addend
						if sum_index < digit_pos_to_extract:
									# if the exponential term is an integer and we mod it by the denominator
									# before dividing, only the integer part of the sum will change;
									# the fractional part will not
									_snake_case              =      pow(
									    16							,	digit_pos_to_extract - 1 - sum_index							,	lowerCamelCase_  )
						else:
									_snake_case              =      pow(16							,	digit_pos_to_extract - 1 - sum_index  )
						total += exponential_term / denominator
			return total


if __name__ == "__main__":
			import doctest

			doctest.testmod()







from typing import Optional

import torch
from PIL import Image
from tqdm.auto import tqdm
from transformers import CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, DiffusionPipeline, UNetaDConditionModel
from diffusers.image_processor import VaeImageProcessor
from diffusers.utils import (
    deprecate,
)

class 	_SCREAMING_SNAKE_CASE							(     _lowercase							):






		"""simple docstring"""







		def __init__(			self    :				int  ,					__SCREAMING_SNAKE_CASE    :				AutoencoderKL  ,					__SCREAMING_SNAKE_CASE    :				CLIPTextModel  ,					__SCREAMING_SNAKE_CASE    :				CLIPTokenizer  ,					__SCREAMING_SNAKE_CASE    :				UNetaDConditionModel  ,					__SCREAMING_SNAKE_CASE    :				DDIMScheduler  ,					__SCREAMING_SNAKE_CASE    :				float = 0.9_3  ,					__SCREAMING_SNAKE_CASE    :				bool = True  ,					):






					"""simple docstring"""
					_snake_case              =      mixing_coeff
					_snake_case              =      leapfrog_steps

					super().__init__()
					self.register_modules(
					    vae=__SCREAMING_SNAKE_CASE  ,					text_encoder=__SCREAMING_SNAKE_CASE  ,					tokenizer=__SCREAMING_SNAKE_CASE  ,					unet=__SCREAMING_SNAKE_CASE  ,					scheduler=__SCREAMING_SNAKE_CASE  ,					)

					_snake_case              =      2 ** (len(self.vae.config.block_out_channels   ) - 1)
					_snake_case              =      VaeImageProcessor(vae_scale_factor=self.vae_scale_factor   )



		def 				_a				(			self    :				Tuple  ,					__SCREAMING_SNAKE_CASE    :				str  ,					__SCREAMING_SNAKE_CASE    :				Optional[str] = None  ,					__SCREAMING_SNAKE_CASE    :				bool = False   ):






					"""simple docstring"""
					_snake_case              =      self.tokenizer(
					    __SCREAMING_SNAKE_CASE  ,					padding="max_length"  ,					max_length=self.tokenizer.model_max_length  ,					truncation=__SCREAMING_SNAKE_CASE  ,					return_tensors="pt"  ,					)

					_snake_case              =      self.text_encoder(text_inputs.input_ids.to(self.device   )   ).last_hidden_state

					_snake_case              =      prompt_embeds.to(dtype=self.text_encoder.dtype  ,					device=self.device   )

					if do_classifier_free_guidance:
								_snake_case              =      "" if negative_prompt is None else negative_prompt

								_snake_case              =      self.tokenizer(
								    __SCREAMING_SNAKE_CASE  ,					padding="max_length"  ,					max_length=self.tokenizer.model_max_length  ,					truncation=__SCREAMING_SNAKE_CASE  ,					return_tensors="pt"  ,					)

								_snake_case              =      self.text_encoder(uncond_input.input_ids.to(self.device   )   ).last_hidden_state

								_snake_case              =      torch.cat([negative_prompt_embeds, prompt_embeds]   )

					return prompt_embeds



		def 				_a				(			self    :				Optional[Any]  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor   ):






					"""simple docstring"""
					_snake_case              =      self.mixing_coeff * x + (1 - self.mixing_coeff) * y
					_snake_case              =      self.mixing_coeff * y + (1 - self.mixing_coeff) * x

					return [x, y]



		def 				_a				(			self    :				Union[str, Any]  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor   ):






					"""simple docstring"""
					_snake_case              =      (y - (1 - self.mixing_coeff) * x) / self.mixing_coeff
					_snake_case              =      (x - (1 - self.mixing_coeff) * y) / self.mixing_coeff

					return [x, y]



		def 				_a				(			self    :				Tuple  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor   ):






					"""simple docstring"""
					# as self.alphas_cumprod is always in cpu
					_snake_case              =      int(__SCREAMING_SNAKE_CASE   )

					_snake_case              =      self.scheduler.alphas_cumprod[t] if t >= 0 else self.scheduler.final_alpha_cumprod

					return alpha_prod, 1 - alpha_prod



		def 				_a				(			self    :				List[Any]  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					):






					"""simple docstring"""
					_snake_case              =      timestep - self.scheduler.config.num_train_timesteps / self.scheduler.num_inference_steps

					_snake_case       , _snake_case              =      self._get_alpha_and_beta(__SCREAMING_SNAKE_CASE   )
					_snake_case       , _snake_case              =      self._get_alpha_and_beta(__SCREAMING_SNAKE_CASE   )

					_snake_case              =      (alpha_prod_t_prev / alpha_prod_t) ** 0.5
					_snake_case              =      -a_t * (beta_prod_t**0.5) + beta_prod_t_prev**0.5

					_snake_case              =      (base - b_t * model_output) / a_t

					return model_input, next_model_input.to(base.dtype   )



		def 				_a				(			self    :				int  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					):






					"""simple docstring"""
					_snake_case              =      timestep - self.scheduler.config.num_train_timesteps / self.scheduler.num_inference_steps

					_snake_case       , _snake_case              =      self._get_alpha_and_beta(__SCREAMING_SNAKE_CASE   )
					_snake_case       , _snake_case              =      self._get_alpha_and_beta(__SCREAMING_SNAKE_CASE   )

					_snake_case              =      (alpha_prod_t_prev / alpha_prod_t) ** 0.5
					_snake_case              =      -a_t * (beta_prod_t**0.5) + beta_prod_t_prev**0.5
					_snake_case              =      a_t * base + b_t * model_output

					return model_input, next_model_input.to(base.dtype   )



		@torch.no_grad()
		def 				_a				(			self    :				List[str]  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor   ):






					"""simple docstring"""
					_snake_case              =      1 / self.vae.config.scaling_factor * latents
					_snake_case              =      self.vae.decode(__SCREAMING_SNAKE_CASE   ).sample
					_snake_case              =      (image / 2 + 0.5).clamp(0  ,					1   )
					return image



		@torch.no_grad()
		def 				_a				(			self    :				List[str]  ,					__SCREAMING_SNAKE_CASE    :				Image.Image  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					__SCREAMING_SNAKE_CASE    :				torch.Tensor  ,					__SCREAMING_SNAKE_CASE    :				float  ,					__SCREAMING_SNAKE_CASE    :				Optional[torch.Generator] = None  ,					):






					"""simple docstring"""
					_snake_case              =      guidance_scale > 1.0

					_snake_case              =      image.to(device=self.device  ,					dtype=text_embeds.dtype   )
					_snake_case              =      self.vae.encode(__SCREAMING_SNAKE_CASE   ).latent_dist.sample(__SCREAMING_SNAKE_CASE   )

					_snake_case              =      self.vae.config.scaling_factor * latent

					_snake_case              =      [latent.clone(), latent.clone()]

					for i, t in tqdm(enumerate(__SCREAMING_SNAKE_CASE   )  ,					total=len(__SCREAMING_SNAKE_CASE   )   ):
								_snake_case              =      self.noise_mixing_layer(x=coupled_latents[0]  ,					y=coupled_latents[1]   )

								# j - model_input index, k - base index
								for j in range(2   ):
											_snake_case              =      j ^ 1

											if self.leapfrog_steps:
														if i % 2 == 0:
																	_snake_case       , _snake_case              =      j, k

											_snake_case              =      coupled_latents[j]
											_snake_case              =      coupled_latents[k]

											_snake_case              =      torch.cat([model_input] * 2   ) if do_classifier_free_guidance else model_input

											_snake_case              =      self.unet(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE  ,					encoder_hidden_states=__SCREAMING_SNAKE_CASE   ).sample

											if do_classifier_free_guidance:
														_snake_case       , _snake_case              =      noise_pred.chunk(2   )
														_snake_case              =      noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

											_snake_case       , _snake_case              =      self.noise_step(
											    base=__SCREAMING_SNAKE_CASE  ,					model_input=__SCREAMING_SNAKE_CASE  ,					model_output=__SCREAMING_SNAKE_CASE  ,					timestep=__SCREAMING_SNAKE_CASE  ,					)

											_snake_case              =      model_input

					return coupled_latents







		@torch.no_grad()
		def __call__(			self    :				Optional[Any]  ,					__SCREAMING_SNAKE_CASE    :				str  ,					__SCREAMING_SNAKE_CASE    :				str  ,					__SCREAMING_SNAKE_CASE    :				Image.Image  ,					__SCREAMING_SNAKE_CASE    :				float = 3.0  ,					__SCREAMING_SNAKE_CASE    :				int = 50  ,					__SCREAMING_SNAKE_CASE    :				float = 0.8  ,					__SCREAMING_SNAKE_CASE    :				Optional[str] = None  ,					__SCREAMING_SNAKE_CASE    :				Optional[torch.Generator] = None  ,					__SCREAMING_SNAKE_CASE    :				Optional[str] = "pil"  ,					):






					"""simple docstring"""
					_snake_case              =      guidance_scale > 1.0

					_snake_case              =      self.image_processor.preprocess(__SCREAMING_SNAKE_CASE   )

					_snake_case              =      self._encode_prompt(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE   )
					_snake_case              =      self._encode_prompt(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE   )

					self.scheduler.set_timesteps(__SCREAMING_SNAKE_CASE  ,					self.device   )

					_snake_case              =      num_inference_steps - int(num_inference_steps * strength   )
					_snake_case              =      self.scheduler.timesteps[t_limit:]
					_snake_case              =      fwd_timesteps.flip(0   )

					_snake_case              =      self.prepare_latents(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE   )

					for i, t in tqdm(enumerate(__SCREAMING_SNAKE_CASE   )  ,					total=len(__SCREAMING_SNAKE_CASE   )   ):
								# j - model_input index, k - base index
								for k in range(2   ):
											_snake_case              =      k ^ 1

											if self.leapfrog_steps:
														if i % 2 == 1:
																	_snake_case       , _snake_case              =      j, k

											_snake_case              =      coupled_latents[j]
											_snake_case              =      coupled_latents[k]

											_snake_case              =      torch.cat([model_input] * 2   ) if do_classifier_free_guidance else model_input

											_snake_case              =      self.unet(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE  ,					encoder_hidden_states=__SCREAMING_SNAKE_CASE   ).sample

											if do_classifier_free_guidance:
														_snake_case       , _snake_case              =      noise_pred.chunk(2   )
														_snake_case              =      noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

											_snake_case       , _snake_case              =      self.denoise_step(
											    base=__SCREAMING_SNAKE_CASE  ,					model_input=__SCREAMING_SNAKE_CASE  ,					model_output=__SCREAMING_SNAKE_CASE  ,					timestep=__SCREAMING_SNAKE_CASE  ,					)

											_snake_case              =      model_input

								_snake_case              =      self.denoise_mixing_layer(x=coupled_latents[0]  ,					y=coupled_latents[1]   )

					# either one is fine
					_snake_case              =      coupled_latents[0]

					if output_type not in ["latent", "pt", "np", "pil"]:
								_snake_case              =      (
								    F'the output_type {output_type} is outdated. Please make sure to set it to one of these instead: '
								    "`pil`, `np`, `pt`, `latent`"
								)
								deprecate("Unsupported output_type"  ,					"1.0.0"  ,					__SCREAMING_SNAKE_CASE  ,					standard_warn=__SCREAMING_SNAKE_CASE   )
								_snake_case              =      "np"

					if output_type == "latent":
								_snake_case              =      final_latent
					else:
								_snake_case              =      self.decode_latents(__SCREAMING_SNAKE_CASE   )
								_snake_case              =      self.image_processor.postprocess(__SCREAMING_SNAKE_CASE  ,					output_type=__SCREAMING_SNAKE_CASE   )

					return image

