

'''simple docstring'''



from logging import getLogger
from typing import Any, Callable, List, Optional, Union

import numpy as np
import PIL
import torch

from ...schedulers import DDPMScheduler
from ..onnx_utils import ORT_TO_NP_TYPE, OnnxRuntimeModel
from ..pipeline_utils import ImagePipelineOutput
from . import StableDiffusionUpscalePipeline


SCREAMING_SNAKE_CASE_    =   getLogger(__name__)


SCREAMING_SNAKE_CASE_    =   4
SCREAMING_SNAKE_CASE_    =   7

SCREAMING_SNAKE_CASE_    =   {
    "float16": torch.floataa,
    "float32": torch.floataa,
}

def   lowerCamelCase__       (      a__):



    """simple docstring"""







    if isinstance(UpperCamelCase__			,      torch.Tensor):
        return image
    elif isinstance(UpperCamelCase__			,      PIL.Image.Image):
        _snake_case : Dict												=		[image]

    if isinstance(image[0]			,      PIL.Image.Image):
        _snake_case : List[Any]												=		image[0].size
        _snake_case : Optional[Any]												=		(x - x % 6_4 for x in (w, h))  # resize to integer multiple of 32

        _snake_case : str												=		[np.array(i.resize((w, h)))[None, :] for i in image]
        _snake_case : Union[str, Any]												=		np.concatenate(UpperCamelCase__			,      axis=0)
        _snake_case : Dict												=		np.array(UpperCamelCase__).astype(np.floataa) / 2_5_5.0
        _snake_case : Any												=		image.transpose(0			,      3			,      1			,      2)
        _snake_case : Tuple												=		2.0 * image - 1.0
        _snake_case : List[str]												=		torch.from_numpy(UpperCamelCase__)
    elif isinstance(image[0]			,      torch.Tensor):
        _snake_case : Optional[Any]												=		torch.cat(UpperCamelCase__			,      dim=0)

    return image




class 			SCREAMING_SNAKE_CASE					(							lowercase_					):






      '''simple docstring'''






      def __init__(					self :		List[Any]     ,					snake_case :		Union[str, Any]     ,					snake_case :		List[Any]     ,					snake_case :		List[str]     ,					snake_case :		Tuple     ,					snake_case :		List[Any]     ,					snake_case :		Optional[Any]     ,					snake_case :		Tuple = 350     ,					):



          """simple docstring"""





          super().__init__(
              vae=__lowerCamelCase     ,					text_encoder=__lowerCamelCase     ,					tokenizer=__lowerCamelCase     ,					unet=__lowerCamelCase     ,					low_res_scheduler=__lowerCamelCase     ,					scheduler=__lowerCamelCase     ,					safety_checker=__lowerCamelCase     ,					feature_extractor=__lowerCamelCase     ,					watermarker=__lowerCamelCase     ,					max_noise_level=__lowerCamelCase     ,					)




      def __call__(					self :		Any     ,					snake_case :		Dict     ,					snake_case :		List[Any]     ,					snake_case :		Optional[Any] = 75     ,					snake_case :		Any = 9.0     ,					snake_case :		List[Any] = 20     ,					snake_case :		int = None     ,					snake_case :		Union[str, Any] = 1     ,					snake_case :		str = 0.0     ,					snake_case :		Union[str, Any] = None     ,					snake_case :		Optional[Any] = None     ,					snake_case :		List[Any] = None     ,					snake_case :		Optional[int] = None     ,					snake_case :		Optional[int] = "pil"     ,					snake_case :		Tuple = True     ,					snake_case :		Union[str, Any] = None     ,					snake_case :		Optional[int] = 1     ,					):



          """simple docstring"""





          self.check_inputs(__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase   )

          # 2. Define call parameters
          if prompt is not None and isinstance(__lowerCamelCase     ,					__lowerCamelCase   ):
              _snake_case : Optional[Any]												=		1
          elif prompt is not None and isinstance(__lowerCamelCase     ,					__lowerCamelCase   ):
              _snake_case : Tuple												=		len(__lowerCamelCase   )
          else:
              _snake_case : Optional[Any]												=		prompt_embeds.shape[0]

          _snake_case : Optional[int]												=		self._execution_device
          # 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.
          _snake_case : Optional[Any]												=		guidance_scale > 1.0

          # 3. Encode input prompt
          _snake_case : Tuple												=		self._encode_prompt(
              __lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					prompt_embeds=__lowerCamelCase     ,					negative_prompt_embeds=__lowerCamelCase     ,					)

          _snake_case : List[str]												=		ORT_TO_PT_TYPE[str(text_embeddings.dtype   )]

          # 4. Preprocess image
          _snake_case : int												=		preprocess(__lowerCamelCase   )
          _snake_case : Tuple												=		image.cpu()

          # 5. set timesteps
          self.scheduler.set_timesteps(__lowerCamelCase     ,					device=__lowerCamelCase   )
          _snake_case : str												=		self.scheduler.timesteps

          # 5. Add noise to image
          _snake_case : int												=		torch.tensor([noise_level]     ,					dtype=torch.long     ,					device=__lowerCamelCase   )
          _snake_case : List[str]												=		torch.randn(image.shape     ,					generator=__lowerCamelCase     ,					device=__lowerCamelCase     ,					dtype=__lowerCamelCase   )
          _snake_case : List[str]												=		self.low_res_scheduler.add_noise(__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase   )

          _snake_case : Union[str, Any]												=		2 if do_classifier_free_guidance else 1
          _snake_case : Optional[Any]												=		np.concatenate([image] * batch_multiplier * num_images_per_prompt   )
          _snake_case : Tuple												=		np.concatenate([noise_level] * image.shape[0]   )

          # 6. Prepare latent variables
          _snake_case : Any												=		image.shape[2:]
          _snake_case : Dict												=		self.prepare_latents(
              batch_size * num_images_per_prompt     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					)

          # 7. Check that sizes of image and latents match
          _snake_case : List[str]												=		image.shape[1]
          if NUM_LATENT_CHANNELS + num_channels_image != NUM_UNET_INPUT_CHANNELS:
              raise ValueError(
                  'Incorrect configuration settings! The config of `pipeline.unet` expects'
                  F""" {NUM_UNET_INPUT_CHANNELS} but received `num_channels_latents`: {NUM_LATENT_CHANNELS} +"""
                  F""" `num_channels_image`: {num_channels_image} """
                  F""" = {NUM_LATENT_CHANNELS+num_channels_image}. Please verify the config of"""
                  ' `pipeline.unet` or your `image` input.'   )

          # 8. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
          _snake_case : Any												=		self.prepare_extra_step_kwargs(__lowerCamelCase     ,					__lowerCamelCase   )

          _snake_case : List[str]												=		next(
              (input.type for input in self.unet.model.get_inputs() if input.name == 'timestep')     ,					'tensor(float)'   )
          _snake_case : int												=		ORT_TO_NP_TYPE[timestep_dtype]

          # 9. Denoising loop
          _snake_case : str												=		len(__lowerCamelCase   ) - num_inference_steps * self.scheduler.order
          with self.progress_bar(total=__lowerCamelCase   ) as progress_bar:
              for i, t in enumerate(__lowerCamelCase   ):
                  # expand the latents if we are doing classifier free guidance
                  _snake_case : Dict												=		np.concatenate([latents] * 2   ) if do_classifier_free_guidance else latents

                  # concat latents, mask, masked_image_latents in the channel dimension
                  _snake_case : Optional[int]												=		self.scheduler.scale_model_input(__lowerCamelCase     ,					__lowerCamelCase   )
                  _snake_case : Optional[int]												=		np.concatenate([latent_model_input, image]     ,					axis=1   )

                  # timestep to tensor
                  _snake_case : Optional[int]												=		np.array([t]     ,					dtype=__lowerCamelCase   )

                  # predict the noise residual
                  _snake_case : str												=		self.unet(
                      sample=__lowerCamelCase     ,					timestep=__lowerCamelCase     ,					encoder_hidden_states=__lowerCamelCase     ,					class_labels=noise_level.astype(np.intaa   )     ,					)[0]

                  # perform guidance
                  if do_classifier_free_guidance:
                      _snake_case : Optional[int]												=		np.split(__lowerCamelCase     ,					2   )
                  _snake_case : List[Any]												=		noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

                  # compute the previous noisy sample x_t -> x_t-1
                  _snake_case : Dict												=		self.scheduler.step(
                      torch.from_numpy(__lowerCamelCase   )     ,					__lowerCamelCase     ,					__lowerCamelCase     ,					**__lowerCamelCase   ).prev_sample

                  # call the callback, if provided
                  if i == len(__lowerCamelCase   ) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
                      progress_bar.update()
                      if callback is not None and i % callback_steps == 0:
                          callback(__lowerCamelCase     ,					__lowerCamelCase     ,					__lowerCamelCase   )

        # 10. Post-processing
          _snake_case : List[Any]												=		self.decode_latents(latents.float()   )

          # 11. Convert to PIL
          if output_type == "pil":
              _snake_case : List[str]												=		self.numpy_to_pil(__lowerCamelCase   )

          if not return_dict:
              return (image,)

          return ImagePipelineOutput(images=__lowerCamelCase   )




      def 	__UpperCAmelCase			(					self :		Dict     ,					snake_case :		List[str]   ):



          """simple docstring"""





          _snake_case : Tuple												=		1 / 0.0_8333 * latents
          _snake_case : List[Any]												=		self.vae(latent_sample=__lowerCamelCase   )[0]
          _snake_case : Any												=		np.clip(image / 2 + 0.5     ,					0     ,					1   )
          _snake_case : Any												=		image.transpose((0, 2, 3, 1)   )
          return image




      def 	__UpperCAmelCase			(					self :		Any     ,					snake_case :		Dict     ,					snake_case :		Dict     ,					snake_case :		Optional[Any]     ,					snake_case :		Union[str, Any]     ,					snake_case :		List[str]     ,					snake_case :		Tuple = None     ,					snake_case :		int = None     ,					):



          """simple docstring"""





          if prompt is not None and isinstance(__lowerCamelCase     ,					__lowerCamelCase   ):
              _snake_case : Optional[Any]												=		1
          elif prompt is not None and isinstance(__lowerCamelCase     ,					__lowerCamelCase   ):
              _snake_case : Dict												=		len(__lowerCamelCase   )
          else:
              _snake_case : Union[str, Any]												=		prompt_embeds.shape[0]

          if prompt_embeds is None:
              _snake_case : List[str]												=		self.tokenizer(
                  __lowerCamelCase     ,					padding='max_length'     ,					max_length=self.tokenizer.model_max_length     ,					truncation=__lowerCamelCase     ,					return_tensors='pt'     ,					)
              _snake_case : Dict												=		text_inputs.input_ids
              _snake_case : Any												=		self.tokenizer(__lowerCamelCase     ,					padding='longest'     ,					return_tensors='pt'   ).input_ids

              if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
                  __lowerCamelCase     ,					__lowerCamelCase   ):
                  _snake_case : Union[str, Any]												=		self.tokenizer.batch_decode(
                      untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]   )
                  logger.warning(
                      'The following part of your input was truncated because CLIP can only handle sequences up to'
                      F""" {self.tokenizer.model_max_length} tokens: {removed_text}"""   )

              # no positional arguments to text_encoder
              _snake_case : int												=		self.text_encoder(
                  input_ids=text_input_ids.int().to(__lowerCamelCase   )     ,					)
              _snake_case : List[Any]												=		prompt_embeds[0]

          _snake_case : Dict												=		prompt_embeds.shape
          # duplicate text embeddings for each generation per prompt, using mps friendly method
          _snake_case : Optional[Any]												=		prompt_embeds.repeat(1     ,					__lowerCamelCase   )
          _snake_case : Optional[Any]												=		prompt_embeds.reshape(bs_embed * num_images_per_prompt     ,					__lowerCamelCase     ,					-1   )

          # get unconditional embeddings for classifier free guidance
          if do_classifier_free_guidance and negative_prompt_embeds is None:
              _snake_case : List[str]
              if negative_prompt is None:
                  _snake_case : int												=		[""] * batch_size
              elif type(__lowerCamelCase   ) is not type(__lowerCamelCase   ):
                  raise TypeError(
                      F"""`negative_prompt` should be the same type to `prompt`, but got {type(__lowerCamelCase   )} !="""
                      F""" {type(__lowerCamelCase   )}."""   )
              elif isinstance(__lowerCamelCase     ,					__lowerCamelCase   ):
                  _snake_case : Union[str, Any]												=		[negative_prompt]
              elif batch_size != len(__lowerCamelCase   ):
                  raise ValueError(
                      F"""`negative_prompt`: {negative_prompt} has batch size {len(__lowerCamelCase   )}, but `prompt`:"""
                      F""" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"""
                      ' the batch size of `prompt`.'   )
              else:
                  _snake_case : List[str]												=		negative_prompt

              _snake_case : str												=		text_input_ids.shape[-1]
              _snake_case : List[Any]												=		self.tokenizer(
                  __lowerCamelCase     ,					padding='max_length'     ,					max_length=__lowerCamelCase     ,					truncation=__lowerCamelCase     ,					return_tensors='pt'     ,					)

              # if hasattr(uncond_input, "attention_mask"):
              #     attention_mask = uncond_input.attention_mask.to(device)
              # else:
              #     attention_mask = None

              _snake_case : int												=		self.text_encoder(
                  input_ids=uncond_input.input_ids.int().to(__lowerCamelCase   )     ,					)
              _snake_case : Any												=		uncond_embeddings[0]

          if do_classifier_free_guidance:
              _snake_case : List[Any]												=		uncond_embeddings.shape[1]
              # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
              _snake_case : Tuple												=		uncond_embeddings.repeat(1     ,					__lowerCamelCase   )
              _snake_case : List[Any]												=		uncond_embeddings.reshape(batch_size * num_images_per_prompt     ,					__lowerCamelCase     ,					-1   )

              # 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
              _snake_case : Union[str, Any]												=		np.concatenate([uncond_embeddings, prompt_embeds]   )

          return prompt_embeds






'''simple docstring'''



import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE_    =   logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_    =   {}

class 			SCREAMING_SNAKE_CASE					(							lowercase_					):






      '''simple docstring'''






      SCREAMING_SNAKE_CASE__ :				Optional[Any]    =				'''fsmt_decoder'''




      def __init__(					self :		Any     ,					snake_case :		int=0     ,					snake_case :		Dict=0   ):



          """simple docstring"""





          super().__init__()
          _snake_case : int												=		vocab_size
          _snake_case : Dict												=		bos_token_id



class 			SCREAMING_SNAKE_CASE					(							lowercase_					):






      '''simple docstring'''






      SCREAMING_SNAKE_CASE__ :				Union[str, Any]    =				'''fsmt'''
      SCREAMING_SNAKE_CASE__ :				Union[str, Any]    =				{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}




      def __init__(					self :		Optional[int]     ,					snake_case :		Tuple=["en", "de"]     ,					snake_case :		Optional[int]=42024     ,					snake_case :		List[str]=42024     ,					snake_case :		Union[str, Any]="relu"     ,					snake_case :		Optional[Any]=1024     ,					snake_case :		Union[str, Any]=200     ,					snake_case :		int=1024     ,					snake_case :		str=4096     ,					snake_case :		Dict=12     ,					snake_case :		str=16     ,					snake_case :		List[str]=0.0     ,					snake_case :		List[Any]=4096     ,					snake_case :		str=12     ,					snake_case :		str=16     ,					snake_case :		Optional[int]=0.0     ,					snake_case :		Optional[int]=0.0     ,					snake_case :		str=0.1     ,					snake_case :		Tuple=0.0     ,					snake_case :		Optional[int]=0.02     ,					snake_case :		List[str]=2     ,					snake_case :		int=True     ,					snake_case :		Any=True     ,					snake_case :		str=False     ,					snake_case :		Union[str, Any]=5     ,					snake_case :		Dict=1.0     ,					snake_case :		Union[str, Any]=False     ,					snake_case :		Optional[Any]=True     ,					snake_case :		Optional[int]=1     ,					snake_case :		int=0     ,					snake_case :		Optional[int]=2     ,					snake_case :		Optional[Any]=2     ,					**snake_case :		Any     ,					):



          """simple docstring"""





          _snake_case : int												=		langs
          _snake_case : str												=		src_vocab_size
          _snake_case : List[Any]												=		tgt_vocab_size
          _snake_case : Optional[int]												=		d_model  # encoder_embed_dim and decoder_embed_dim

          _snake_case : Optional[Any]												=		encoder_ffn_dim
          _snake_case : Dict												=		encoder_layers
          _snake_case : List[Any]												=		encoder_attention_heads
          _snake_case : Any												=		encoder_layerdrop
          _snake_case : List[str]												=		decoder_layerdrop
          _snake_case : str												=		decoder_ffn_dim
          _snake_case : Union[str, Any]												=		decoder_layers
          _snake_case : Tuple												=		decoder_attention_heads
          _snake_case : str												=		max_position_embeddings
          _snake_case : Dict												=		init_std  # Normal(0, this parameter)
          _snake_case : List[str]												=		activation_function

          _snake_case : Any												=		DecoderConfig(vocab_size=snake_case     ,					bos_token_id=snake_case   )
          if "decoder" in common_kwargs:
              del common_kwargs["decoder"]

          _snake_case : str												=		scale_embedding  # scale factor will be sqrt(d_model) if True

          # 3 Types of Dropout
          _snake_case : int												=		attention_dropout
          _snake_case : List[Any]												=		activation_dropout
          _snake_case : Optional[int]												=		dropout

          _snake_case : Union[str, Any]												=		use_cache
          super().__init__(
              pad_token_id=snake_case     ,					bos_token_id=snake_case     ,					eos_token_id=snake_case     ,					decoder_start_token_id=snake_case     ,					is_encoder_decoder=snake_case     ,					tie_word_embeddings=snake_case     ,					forced_eos_token_id=snake_case     ,					max_length=snake_case     ,					num_beams=snake_case     ,					length_penalty=snake_case     ,					early_stopping=snake_case     ,					**snake_case     ,					)




      def 	__UpperCAmelCase			(					self :		Optional[int]   ):



          """simple docstring"""





          _snake_case : Any												=		copy.deepcopy(self.__dict__   )
          _snake_case : str												=		self.decoder.to_dict()
          _snake_case : Dict												=		self.__class__.model_type
          return output



