'''simple docstring'''

import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.utils import (
    PIL_INTERPOLATION,
    randn_tensor,
)
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     ):
 if isinstance(UpperCAmelCase		,     torch.Tensor     ):
  return image
 elif isinstance(UpperCAmelCase		,     PIL.Image.Image     ):
  lowercase__				:    List[str]  =					[image]

 if isinstance(image[0]		,     PIL.Image.Image     ):
  lowercase__				:    List[str]  =					[np.array(i.resize((w, h)		,     resample=PIL_INTERPOLATION['''lanczos''']     )     )[None, :] for i in image]
  lowercase__				:    Any  =					np.concatenate(UpperCAmelCase		,     axis=0     )
  lowercase__				:    Optional[Any]  =					np.array(UpperCAmelCase     ).astype(np.floataa     ) / 2_5_5.0
  lowercase__				:    Dict  =					image.transpose(0		,     3		,     1		,     2     )
  lowercase__				:    Union[str, Any]  =					2.0 * image - 1.0
  lowercase__				:    List[str]  =					torch.from_numpy(UpperCAmelCase     )
 elif isinstance(image[0]		,     torch.Tensor     ):
  lowercase__				:    Dict  =					torch.cat(UpperCAmelCase		,     dim=0     )
 return image
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase=0.9_9_9_5     ):
 if not isinstance(UpperCAmelCase		,     np.ndarray     ):
  lowercase__				:    Union[str, Any]  =					True
  lowercase__				:    List[str]  =					va.device
  lowercase__				:    List[str]  =					va.cpu().numpy()
  lowercase__				:    Dict  =					va.cpu().numpy()

 lowercase__				:    int  =					np.sum(va * va / (np.linalg.norm(UpperCAmelCase     ) * np.linalg.norm(UpperCAmelCase     ))     )
 if np.abs(UpperCAmelCase     ) > DOT_THRESHOLD:
  lowercase__				:    List[Any]  =					(1 - t) * va + t * va
 else:
  lowercase__				:    Optional[int]  =					np.arccos(UpperCAmelCase     )
  lowercase__				:    Tuple  =					np.sin(UpperCAmelCase     )
  lowercase__				:    Optional[int]  =					theta_a * t
  lowercase__				:    Dict  =					np.sin(UpperCAmelCase     )
  lowercase__				:    List[Any]  =					np.sin(theta_a - theta_t     ) / sin_theta_a
  lowercase__				:    Optional[int]  =					sin_theta_t / sin_theta_a
  lowercase__				:    List[str]  =					sa * va + sa * va

 if inputs_are_torch:
  lowercase__				:    List[Any]  =					torch.from_numpy(UpperCAmelCase     ).to(UpperCAmelCase     )

 return va
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase     ):
 lowercase__				:    int  =					F.normalize(UpperCAmelCase		,     dim=-1     )
 lowercase__				:    Dict  =					F.normalize(UpperCAmelCase		,     dim=-1     )
 return (x - y).norm(dim=-1     ).div(2     ).arcsin().pow(2     ).mul(2     )
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase     ):
 for param in model.parameters():
  lowercase__				:    Dict  =					value





class 			UpperCAmelCase  (						a__					):





       '''simple docstring'''



       def __init__(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase=None	,   __lowerCAmelCase=None	,   __lowerCAmelCase=None	,   )  ->  Optional[int]:
        super().__init__()
        self.register_modules(
            vae=__lowerCAmelCase	,   text_encoder=__lowerCAmelCase	,   clip_model=__lowerCAmelCase	,   tokenizer=__lowerCAmelCase	,   unet=__lowerCAmelCase	,   scheduler=__lowerCAmelCase	,   feature_extractor=__lowerCAmelCase	,   coca_model=__lowerCAmelCase	,   coca_tokenizer=__lowerCAmelCase	,   coca_transform=__lowerCAmelCase	,   )
        lowercase__				:    int  =					(
            feature_extractor.size
            if isinstance(feature_extractor.size	,   __lowerCAmelCase )
            else feature_extractor.size['''shortest_edge''']
        )
        lowercase__				:    int  =					transforms.Normalize(mean=feature_extractor.image_mean	,   std=feature_extractor.image_std )
        set_requires_grad(self.text_encoder	,   __lowerCAmelCase )
        set_requires_grad(self.clip_model	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase = "auto" )  ->  Tuple:
        if slice_size == "auto":
         # half the attention head size is usually a good trade-off between
         # speed and memory
         lowercase__				:    Optional[int]  =					self.unet.config.attention_head_dim // 2
        self.unet.set_attention_slice(__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  List[Any]:
        self.enable_attention_slicing(__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Optional[int]:
        set_requires_grad(self.vae	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  List[Any]:
        set_requires_grad(self.vae	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Any:
        set_requires_grad(self.unet	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Union[str, Any]:
        set_requires_grad(self.unet	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  List[Any]:
        # get the original timestep using init_timestep
        lowercase__				:    List[Any]  =					min(int(num_inference_steps * strength )	,   __lowerCAmelCase )

        lowercase__				:    Tuple  =					max(num_inference_steps - init_timestep	,   0 )
        lowercase__				:    List[str]  =					self.scheduler.timesteps[t_start:]

        return timesteps, num_inference_steps - t_start

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase=None )  ->  Tuple:
        if not isinstance(__lowerCAmelCase	,   torch.Tensor ):
         raise ValueError(F"""`image` has to be of type `torch.Tensor` but is {type(__lowerCAmelCase )}""" )

        lowercase__				:    Optional[int]  =					image.to(device=__lowerCAmelCase	,   dtype=__lowerCAmelCase )

        if isinstance(__lowerCAmelCase	,   __lowerCAmelCase ):
         lowercase__				:    List[str]  =					[
             self.vae.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(__lowerCAmelCase )
         ]
         lowercase__				:    List[Any]  =					torch.cat(__lowerCAmelCase	,   dim=0 )
        else:
         lowercase__				:    Tuple  =					self.vae.encode(__lowerCAmelCase ).latent_dist.sample(__lowerCAmelCase )

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
        lowercase__				:    Dict  =					0.1_8_2_1_5 * init_latents
        lowercase__				:    List[str]  =					init_latents.repeat_interleave(__lowerCAmelCase	,   dim=0 )

        lowercase__				:    List[str]  =					randn_tensor(init_latents.shape	,   generator=__lowerCAmelCase	,   device=__lowerCAmelCase	,   dtype=__lowerCAmelCase )

        # get latents
        lowercase__				:    Any  =					self.scheduler.add_noise(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )
        lowercase__				:    Union[str, Any]  =					init_latents

        return latents

       def _lowerCAmelCase(						self	,   __lowerCAmelCase )  ->  List[str]:
        lowercase__				:    Optional[Any]  =					self.coca_transform(__lowerCAmelCase ).unsqueeze(0 )
        with torch.no_grad(), torch.cuda.amp.autocast():
         lowercase__				:    Any  =					self.coca_model.generate(transformed_image.to(device=self.device	,   dtype=self.coca_model.dtype ) )
        lowercase__				:    str  =					self.coca_tokenizer.decode(generated[0].cpu().numpy() )
        return generated.split('''<end_of_text>''' )[0].replace('''<start_of_text>'''	,   '''''' ).rstrip(''' .,''' )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  Any:
        lowercase__				:    str  =					self.feature_extractor.preprocess(__lowerCAmelCase )
        lowercase__				:    Optional[Any]  =					torch.from_numpy(clip_image_input['''pixel_values'''][0] ).unsqueeze(0 ).to(self.device ).half()
        lowercase__				:    List[str]  =					self.clip_model.get_image_features(__lowerCAmelCase )
        lowercase__				:    str  =					image_embeddings_clip / image_embeddings_clip.norm(p=2	,   dim=-1	,   keepdim=__lowerCAmelCase )
        lowercase__				:    Dict  =					image_embeddings_clip.repeat_interleave(__lowerCAmelCase	,   dim=0 )
        return image_embeddings_clip

       @torch.enable_grad()
       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   )  ->  List[str]:
        lowercase__				:    int  =					latents.detach().requires_grad_()

        lowercase__				:    int  =					self.scheduler.scale_model_input(__lowerCAmelCase	,   __lowerCAmelCase )

        # predict the noise residual
        lowercase__				:    str  =					self.unet(__lowerCAmelCase	,   __lowerCAmelCase	,   encoder_hidden_states=__lowerCAmelCase ).sample

        if isinstance(self.scheduler	,   (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler) ):
         lowercase__				:    Union[str, Any]  =					self.scheduler.alphas_cumprod[timestep]
         lowercase__				:    Dict  =					1 - alpha_prod_t
         # compute predicted original sample from predicted noise also called
         # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
         lowercase__				:    str  =					(latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

         lowercase__				:    Optional[Any]  =					torch.sqrt(__lowerCAmelCase )
         lowercase__				:    str  =					pred_original_sample * (fac) + latents * (1 - fac)
        elif isinstance(self.scheduler	,   __lowerCAmelCase ):
         lowercase__				:    List[Any]  =					self.scheduler.sigmas[index]
         lowercase__				:    Union[str, Any]  =					latents - sigma * noise_pred
        else:
         raise ValueError(F"""scheduler type {type(self.scheduler )} not supported""" )

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
        lowercase__				:    Optional[Any]  =					1 / 0.1_8_2_1_5 * sample
        lowercase__				:    List[str]  =					self.vae.decode(__lowerCAmelCase ).sample
        lowercase__				:    Dict  =					(image / 2 + 0.5).clamp(0	,   1 )

        lowercase__				:    Optional[Any]  =					transforms.Resize(self.feature_extractor_size )(__lowerCAmelCase )
        lowercase__				:    Optional[Any]  =					self.normalize(__lowerCAmelCase ).to(latents.dtype )

        lowercase__				:    int  =					self.clip_model.get_image_features(__lowerCAmelCase )
        lowercase__				:    Dict  =					image_embeddings_clip / image_embeddings_clip.norm(p=2	,   dim=-1	,   keepdim=__lowerCAmelCase )

        lowercase__				:    Union[str, Any]  =					spherical_dist_loss(__lowerCAmelCase	,   __lowerCAmelCase ).mean() * clip_guidance_scale

        lowercase__				:    str  =					-torch.autograd.grad(__lowerCAmelCase	,   __lowerCAmelCase )[0]

        if isinstance(self.scheduler	,   __lowerCAmelCase ):
         lowercase__				:    Dict  =					latents.detach() + grads * (sigma**2)
         lowercase__				:    Dict  =					noise_pred_original
        else:
         lowercase__				:    Optional[Any]  =					noise_pred_original - torch.sqrt(__lowerCAmelCase ) * grads
        return noise_pred, latents


       @torch.no_grad()
       def __call__(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase = None	,   __lowerCAmelCase = None	,   __lowerCAmelCase = 512	,   __lowerCAmelCase = 512	,   __lowerCAmelCase = 0.6	,   __lowerCAmelCase = 50	,   __lowerCAmelCase = 7.5	,   __lowerCAmelCase = 1	,   __lowerCAmelCase = 0.0	,   __lowerCAmelCase = 100	,   __lowerCAmelCase = None	,   __lowerCAmelCase = "pil"	,   __lowerCAmelCase = True	,   __lowerCAmelCase = 0.8	,   __lowerCAmelCase = 0.1	,   __lowerCAmelCase = 0.1	,   )  ->  Any:
        if isinstance(__lowerCAmelCase	,   __lowerCAmelCase ) and len(__lowerCAmelCase ) != batch_size:
         raise ValueError(F"""You have passed {batch_size} batch_size, but only {len(__lowerCAmelCase )} generators.""" )

        if height % 8 != 0 or width % 8 != 0:
         raise ValueError(F"""`height` and `width` have to be divisible by 8 but are {height} and {width}.""" )

        if isinstance(__lowerCAmelCase	,   torch.Generator ) and batch_size > 1:
         lowercase__				:    List[Any]  =					[generator] + [None] * (batch_size - 1)

        lowercase__				:    Any  =					[
            ('''model''', self.coca_model is None),
            ('''tokenizer''', self.coca_tokenizer is None),
            ('''transform''', self.coca_transform is None),
        ]
        lowercase__				:    Dict  =					[x[0] for x in coca_is_none if x[1]]
        lowercase__				:    Optional[Any]  =					''', '''.join(__lowerCAmelCase )
        # generate prompts with coca model if prompt is None
        if content_prompt is None:
         if len(__lowerCAmelCase ):
          raise ValueError(
              F"""Content prompt is None and CoCa [{coca_is_none_str}] is None."""
              F"""Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.""" )
         lowercase__				:    Optional[int]  =					self.get_image_description(__lowerCAmelCase )
        if style_prompt is None:
         if len(__lowerCAmelCase ):
          raise ValueError(
              F"""Style prompt is None and CoCa [{coca_is_none_str}] is None."""
              F""" Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.""" )
         lowercase__				:    Optional[int]  =					self.get_image_description(__lowerCAmelCase )

        # get prompt text embeddings for content and style
        lowercase__				:    Union[str, Any]  =					self.tokenizer(
            __lowerCAmelCase	,   padding='''max_length'''	,   max_length=self.tokenizer.model_max_length	,   truncation=__lowerCAmelCase	,   return_tensors='''pt'''	,   )
        lowercase__				:    List[Any]  =					self.text_encoder(content_text_input.input_ids.to(self.device ) )[0]

        lowercase__				:    int  =					self.tokenizer(
            __lowerCAmelCase	,   padding='''max_length'''	,   max_length=self.tokenizer.model_max_length	,   truncation=__lowerCAmelCase	,   return_tensors='''pt'''	,   )
        lowercase__				:    Union[str, Any]  =					self.text_encoder(style_text_input.input_ids.to(self.device ) )[0]

        lowercase__				:    Dict  =					slerp(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )

        # duplicate text embeddings for each generation per prompt
        lowercase__				:    int  =					text_embeddings.repeat_interleave(__lowerCAmelCase	,   dim=0 )

        # set timesteps
        lowercase__				:    List[Any]  =					'''offset''' in set(inspect.signature(self.scheduler.set_timesteps ).parameters.keys() )
        lowercase__				:    List[Any]  =					{}
        if accepts_offset:
         lowercase__				:    str  =					1

        self.scheduler.set_timesteps(__lowerCAmelCase	,   **__lowerCAmelCase )
        # Some schedulers like PNDM have timesteps as arrays
        # It's more optimized to move all timesteps to correct device beforehand
        self.scheduler.timesteps.to(self.device )

        lowercase__ ,							lowercase__				:    int  =					self.get_timesteps(__lowerCAmelCase	,   __lowerCAmelCase	,   self.device )
        lowercase__				:    int  =					timesteps[:1].repeat(__lowerCAmelCase )

        # Preprocess image
        lowercase__				:    Union[str, Any]  =					preprocess(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )
        lowercase__				:    List[str]  =					self.prepare_latents(
            __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   text_embeddings.dtype	,   self.device	,   __lowerCAmelCase )

        lowercase__				:    Optional[int]  =					preprocess(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )
        lowercase__				:    Dict  =					self.prepare_latents(
            __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   text_embeddings.dtype	,   self.device	,   __lowerCAmelCase )

        lowercase__				:    Tuple  =					slerp(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )

        if clip_guidance_scale > 0:
         lowercase__				:    List[Any]  =					self.get_clip_image_embeddings(__lowerCAmelCase	,   __lowerCAmelCase )
         lowercase__				:    List[Any]  =					self.get_clip_image_embeddings(__lowerCAmelCase	,   __lowerCAmelCase )
         lowercase__				:    Union[str, Any]  =					slerp(
             __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )

        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
        # corresponds to doing no classifier free guidance.
        lowercase__				:    Any  =					guidance_scale > 1.0
        # get unconditional embeddings for classifier free guidance
        if do_classifier_free_guidance:
         lowercase__				:    Optional[int]  =					content_text_input.input_ids.shape[-1]
         lowercase__				:    Dict  =					self.tokenizer(['''''']	,   padding='''max_length'''	,   max_length=__lowerCAmelCase	,   return_tensors='''pt''' )
         lowercase__				:    Any  =					self.text_encoder(uncond_input.input_ids.to(self.device ) )[0]
         # duplicate unconditional embeddings for each generation per prompt
         lowercase__				:    Tuple  =					uncond_embeddings.repeat_interleave(__lowerCAmelCase	,   dim=0 )

         # For classifier free guidance, we need to do two forward passes.
         # Here we concatenate the unconditional and text embeddings into a single batch
         # to avoid doing two forward passes
         lowercase__				:    Union[str, Any]  =					torch.cat([uncond_embeddings, text_embeddings] )

        # get the initial random noise unless the user supplied it

        # Unlike in other pipelines, latents need to be generated in the target device
        # for 1-to-1 results reproducibility with the CompVis implementation.
        # However this currently doesn't work in `mps`.
        lowercase__				:    Any  =					(batch_size, self.unet.config.in_channels, height // 8, width // 8)
        lowercase__				:    Tuple  =					text_embeddings.dtype
        if latents is None:
         if self.device.type == "mps":
          # randn does not work reproducibly on mps
          lowercase__				:    Union[str, Any]  =					torch.randn(__lowerCAmelCase	,   generator=__lowerCAmelCase	,   device='''cpu'''	,   dtype=__lowerCAmelCase ).to(
              self.device )
         else:
          lowercase__				:    int  =					torch.randn(__lowerCAmelCase	,   generator=__lowerCAmelCase	,   device=self.device	,   dtype=__lowerCAmelCase )
        else:
         if latents.shape != latents_shape:
          raise ValueError(F"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}""" )
         lowercase__				:    Optional[int]  =					latents.to(self.device )

        # scale the initial noise by the standard deviation required by the scheduler
        lowercase__				:    List[Any]  =					latents * self.scheduler.init_noise_sigma

        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
        # and should be between [0, 1]
        lowercase__				:    Tuple  =					'''eta''' in set(inspect.signature(self.scheduler.step ).parameters.keys() )
        lowercase__				:    List[str]  =					{}
        if accepts_eta:
         lowercase__				:    Any  =					eta

        # check if the scheduler accepts generator
        lowercase__				:    Dict  =					'''generator''' in set(inspect.signature(self.scheduler.step ).parameters.keys() )
        if accepts_generator:
         lowercase__				:    Any  =					generator

        with self.progress_bar(total=__lowerCAmelCase ):
         for i, t in enumerate(__lowerCAmelCase ):
          # expand the latents if we are doing classifier free guidance
          lowercase__				:    Dict  =					torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents
          lowercase__				:    Optional[int]  =					self.scheduler.scale_model_input(__lowerCAmelCase	,   __lowerCAmelCase )

          # predict the noise residual
          lowercase__				:    Optional[Any]  =					self.unet(__lowerCAmelCase	,   __lowerCAmelCase	,   encoder_hidden_states=__lowerCAmelCase ).sample

          # perform classifier free guidance
          if do_classifier_free_guidance:
           lowercase__ ,							lowercase__				:    List[str]  =					noise_pred.chunk(2 )
           lowercase__				:    List[str]  =					noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

          # perform clip guidance
          if clip_guidance_scale > 0:
           lowercase__				:    Union[str, Any]  =					(
               text_embeddings.chunk(2 )[1] if do_classifier_free_guidance else text_embeddings
           )
           lowercase__ ,							lowercase__				:    Any  =					self.cond_fn(
               __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   )

          # compute the previous noisy sample x_t -> x_t-1
          lowercase__				:    Optional[int]  =					self.scheduler.step(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   **__lowerCAmelCase ).prev_sample

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
        lowercase__				:    Dict  =					1 / 0.1_8_2_1_5 * latents
        lowercase__				:    Any  =					self.vae.decode(__lowerCAmelCase ).sample

        lowercase__				:    List[Any]  =					(image / 2 + 0.5).clamp(0	,   1 )
        lowercase__				:    Optional[Any]  =					image.cpu().permute(0	,   2	,   3	,   1 ).numpy()

        if output_type == "pil":
         lowercase__				:    int  =					self.numpy_to_pil(__lowerCAmelCase )

        if not return_dict:
         return (image, None)

        return StableDiffusionPipelineOutput(images=__lowerCAmelCase	,   nsfw_content_detected=__lowerCAmelCase )


'''simple docstring'''

def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    List[str]  =					0
 while num > 0:
  digit_sum += num % 10
  num //= 10
 return digit_sum
def 			__UpperCamelCase       (   UpperCAmelCase = 100     ):
 lowercase__				:    Dict  =					1
 lowercase__				:    Optional[int]  =					2

 for i in range(2		,     max_n + 1     ):
  lowercase__				:    List[str]  =					pre_numerator
  lowercase__				:    Optional[Any]  =					2 * i // 3 if i % 3 == 0 else 1
  lowercase__				:    Union[str, Any]  =					cur_numerator
  lowercase__				:    int  =					e_cont * pre_numerator + temp

 return sum_digits(UpperCAmelCase     )


if __name__ == "__main__":
  print(F'{solution() = }')

