
'''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,
)


__lowercase							:   Any					=     logging.get_logger(__name__)  # pylint: disable=invalid-name

__lowercase							:   str					=     '''
    Examples:
        ```py
        >>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline
        >>> import torch

        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior")
        >>> pipe_prior.to("cuda")
        >>> prompt = "red cat, 4k photo"
        >>> out = pipe_prior(prompt)
        >>> image_emb = out.image_embeds
        >>> zero_image_emb = out.negative_image_embeds
        >>> pipe = KandinskyV22Pipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder")
        >>> pipe.to("cuda")
        >>> image = pipe(
        ...     image_embeds=image_emb,
        ...     negative_image_embeds=zero_image_emb,
        ...     height=768,
        ...     width=768,
        ...     num_inference_steps=50,
        ... ).images
        >>> image[0].save("cat.png")
        ```
'''




def lowercase_	(   _lowercase			,       _lowercase			,       _lowercase=8				)     ->							Optional[Any]:
					'''simple docstring'''

					lowerCamelCase_					:      Tuple     =		height // scale_factor**2
					if height % scale_factor**2 != 0:
										new_height += 1
					lowerCamelCase_					:      Tuple     =		width // scale_factor**2
					if width % scale_factor**2 != 0:
										new_width += 1
					return new_height * scale_factor, new_width * scale_factor






class 	__lowercase				(  _lowercase    ):

			def __init__(self			,   A			,   A			,   A			,   ):
								super().__init__()

								self.register_modules(
								    unet=A			,   scheduler=A			,   movq=A			,   )
								lowerCamelCase_					:      List[Any]     =		2 ** (len(self.movq.config.block_out_channels      ) - 1)

			def        UpperCAmelCase__ (self			,   A			,   A			,   A			,   A			,   A			,   A      ):
								if latents is None:
													lowerCamelCase_					:      List[str]     =		randn_tensor(A			,   generator=A			,   device=A			,   dtype=A      )
								else:
													if latents.shape != shape:
																		raise ValueError(F"""Unexpected latents shape, got {latents.shape}, expected {shape}"""      )
													lowerCamelCase_					:      int     =		latents.to(A      )

								lowerCamelCase_					:      Dict     =		latents * scheduler.init_noise_sigma
								return latents

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

								lowerCamelCase_					:      int     =		torch.device(F"""cuda:{gpu_id}"""      )

								lowerCamelCase_					:      Union[str, Any]     =		[
								    self.unet,
								    self.movq,
								]
								for cpu_offloaded_model in models:
													if cpu_offloaded_model is not None:
																		cpu_offload(A			,   A      )

			def        UpperCAmelCase__ (self			,   A=0      ):
								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.'''      )

								lowerCamelCase_					:      int     =		torch.device(F"""cuda:{gpu_id}"""      )

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

								lowerCamelCase_					:      int     =		None
								for cpu_offloaded_model in [self.unet, self.movq]:
													lowerCamelCase_,      lowerCamelCase_					:      Any     =		cpu_offload_with_hook(A			,   A			,   prev_module_hook=A      )

								# We'll offload the last model manually.
								lowerCamelCase_					:      Optional[int]     =		hook

			@property
			# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
			def        UpperCAmelCase__ (self      ):
								if not hasattr(self.unet			,   '''_hf_hook'''      ):
													return self.device
								for module in self.unet.modules():
													if (
													    hasattr(A			,   '''_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(A      )
			def __call__(self			,   A			,   A			,   A = 5_1_2			,   A = 5_1_2			,   A = 1_0_0			,   A = 4.0			,   A = 1			,   A = None			,   A = None			,   A = "pil"			,   A = True			,   ):
								lowerCamelCase_					:      Any     =		self._execution_device

								lowerCamelCase_					:      Any     =		guidance_scale > 1.0

								if isinstance(A			,   A      ):
													lowerCamelCase_					:      Optional[int]     =		torch.cat(A			,   dim=0      )
								lowerCamelCase_					:      Any     =		image_embeds.shape[0] * num_images_per_prompt
								if isinstance(A			,   A      ):
													lowerCamelCase_					:      int     =		torch.cat(A			,   dim=0      )

								if do_classifier_free_guidance:
													lowerCamelCase_					:      Union[str, Any]     =		image_embeds.repeat_interleave(A			,   dim=0      )
													lowerCamelCase_					:      str     =		negative_image_embeds.repeat_interleave(A			,   dim=0      )

								lowerCamelCase_					:      Dict     =		torch.cat([negative_image_embeds, image_embeds]			,   dim=0      ).to(dtype=self.unet.dtype			,   device=A      )

								self.scheduler.set_timesteps(A			,   device=A      )
								lowerCamelCase_					:      Optional[Any]     =		self.scheduler.timesteps

								lowerCamelCase_					:      List[str]     =		self.unet.config.in_channels

								lowerCamelCase_,      lowerCamelCase_					:      Optional[int]     =		downscale_height_and_width(A			,   A			,   self.movq_scale_factor      )

								# create initial latent
								lowerCamelCase_					:      Union[str, Any]     =		self.prepare_latents(
								    (batch_size, num_channels_latents, height, width)			,   image_embeds.dtype			,   A			,   A			,   A			,   self.scheduler			,   )

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

													lowerCamelCase_					:      List[str]     =		{'''image_embeds''': image_embeds}
													lowerCamelCase_					:      List[str]     =		self.unet(
													    sample=A			,   timestep=A			,   encoder_hidden_states=A			,   added_cond_kwargs=A			,   return_dict=A			,   )[0]

													if do_classifier_free_guidance:
																		lowerCamelCase_,      lowerCamelCase_					:      int     =		noise_pred.split(latents.shape[1]			,   dim=1      )
																		lowerCamelCase_,      lowerCamelCase_					:      Optional[Any]     =		noise_pred.chunk(2      )
																		lowerCamelCase_,      lowerCamelCase_					:      Tuple     =		variance_pred.chunk(2      )
																		lowerCamelCase_					:      int     =		noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																		lowerCamelCase_					:      Optional[int]     =		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"]
													):
																		lowerCamelCase_,      lowerCamelCase_					:      Dict     =		noise_pred.split(latents.shape[1]			,   dim=1      )

													# compute the previous noisy sample x_t -> x_t-1
													lowerCamelCase_					:      Dict     =		self.scheduler.step(
													    A			,   A			,   A			,   generator=A			,   )[0]
								# post-processing
								lowerCamelCase_					:      Any     =		self.movq.decode(A			,   force_not_quantize=A      )['''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"]:
													lowerCamelCase_					:      str     =		image * 0.5 + 0.5
													lowerCamelCase_					:      Optional[int]     =		image.clamp(0			,   1      )
													lowerCamelCase_					:      List[Any]     =		image.cpu().permute(0			,   2			,   3			,   1      ).float().numpy()

								if output_type == "pil":
													lowerCamelCase_					:      Tuple     =		self.numpy_to_pil(A      )

								if not return_dict:
													return (image,)

								return ImagePipelineOutput(images=A      )




'''simple docstring'''


def lowercase_	(   _lowercase = 1_000				)     ->							int:
					'''simple docstring'''

					lowerCamelCase_					:      Dict     =		2**power
					lowerCamelCase_					:      Union[str, Any]     =		str(_lowercase				)
					lowerCamelCase_					:      Union[str, Any]     =		list(_lowercase				)
					lowerCamelCase_					:      Dict     =		0

					for i in list_num:
										sum_of_num += int(_lowercase				)

					return sum_of_num


if __name__ == "__main__":
					__lowercase							:   Optional[Any]					=     int(input('''Enter the power of 2: ''').strip())
					print('''2 ^ ''', power, ''' = ''', 2**power)
					__lowercase							:   Tuple					=     solution(power)
					print('''Sum of the digits is: ''', result)


