






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


UpperCamelCase__						:      int								=					getLogger(__name__)


UpperCamelCase__						:      List[str]								=					4
UpperCamelCase__						:      Dict								=					7

UpperCamelCase__						:      Dict								=					{
    """float16""": torch.floataa,
    """float32""": torch.floataa,
}





def   SCREAMING_SNAKE_CASE__						(   snake_case_  )   ->  int:


	"""simple docstring"""



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

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

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

	return image







class 				lowerCamelCase_     (	a_     ):
							def __init__(						self		:					Dict							,__lowerCamelCase		:					List[str]							,__lowerCamelCase		:					List[Any]							,__lowerCamelCase		:					Optional[Any]							,__lowerCamelCase		:					List[str]							,__lowerCamelCase		:					str							,__lowerCamelCase		:					Optional[Any]							,__lowerCamelCase		:					Tuple = 3_50							,):





								'''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		:					str							,__lowerCamelCase		:					Tuple							,__lowerCamelCase		:					Union[str, Any]							,__lowerCamelCase		:					Union[str, Any] = 75							,__lowerCamelCase		:					str = 9.0							,__lowerCamelCase		:					int = 20							,__lowerCamelCase		:					Optional[Any] = None							,__lowerCamelCase		:					Tuple = 1							,__lowerCamelCase		:					int = 0.0							,__lowerCamelCase		:					List[str] = None							,__lowerCamelCase		:					str = None							,__lowerCamelCase		:					Union[str, Any] = None							,__lowerCamelCase		:					Tuple = None							,__lowerCamelCase		:					Tuple = "pil"							,__lowerCamelCase		:					Dict = True							,__lowerCamelCase		:					Optional[Any] = None							,__lowerCamelCase		:					Optional[Any] = 1							,):





								'''simple docstring'''



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

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

								a		=			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.
								a		=			guidance_scale > 1.0

								# 3. Encode input prompt
								a		=			self._encode_prompt(
								    __lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase							,prompt_embeds=__lowerCamelCase							,negative_prompt_embeds=__lowerCamelCase							,)

								a		=			ORT_TO_PT_TYPE[str(text_embeddings.dtype					)]

								# 4. Preprocess image
								a		=			preprocess(__lowerCamelCase					)
								a		=			image.cpu()

								# 5. set timesteps
								self.scheduler.set_timesteps(__lowerCamelCase							,device=__lowerCamelCase					)
								a		=			self.scheduler.timesteps

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

								a		=			2 if do_classifier_free_guidance else 1
								a		=			np.concatenate([image] * batch_multiplier * num_images_per_prompt					)
								a		=			np.concatenate([noise_level] * image.shape[0]					)

								# 6. Prepare latent variables
								a		=			image.shape[2:]
								a		=			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
								a		=			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
								a		=			self.prepare_extra_step_kwargs(__lowerCamelCase							,__lowerCamelCase					)

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

								# 9. Denoising loop
								a		=			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
										a		=			np.concatenate([latents] * 2					) if do_classifier_free_guidance else latents

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

										# timestep to tensor
										a		=			np.array([t]							,dtype=__lowerCamelCase					)

										# predict the noise residual
										a		=			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:
											a		=			np.split(__lowerCamelCase							,2					)
										a		=			noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

										# compute the previous noisy sample x_t -> x_t-1
										a		=			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
								a		=			self.decode_latents(latents.float()					)

								# 11. Convert to PIL
								if output_type == "pil":
									a		=			self.numpy_to_pil(__lowerCamelCase					)

								if not return_dict:
									return (image,)

								return ImagePipelineOutput(images=__lowerCamelCase					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]							,__lowerCamelCase		:					Union[str, Any]					):





								'''simple docstring'''



								a		=			1 / 0.08_333 * latents
								a		=			self.vae(latent_sample=__lowerCamelCase					)[0]
								a		=			np.clip(image / 2 + 0.5							,0							,1					)
								a		=			image.transpose((0, 2, 3, 1)					)
								return image




							def  SCREAMING_SNAKE_CASE_ (						self		:					Tuple							,__lowerCamelCase		:					Any							,__lowerCamelCase		:					Optional[Any]							,__lowerCamelCase		:					List[Any]							,__lowerCamelCase		:					Any							,__lowerCamelCase		:					str							,__lowerCamelCase		:					List[Any] = None							,__lowerCamelCase		:					Optional[Any] = None							,):





								'''simple docstring'''



								if prompt is not None and isinstance(__lowerCamelCase							,__lowerCamelCase					):
									a		=			1
								elif prompt is not None and isinstance(__lowerCamelCase							,__lowerCamelCase					):
									a		=			len(__lowerCamelCase					)
								else:
									a		=			prompt_embeds.shape[0]

								if prompt_embeds is None:
									a		=			self.tokenizer(
									    __lowerCamelCase							,padding='''max_length'''							,max_length=self.tokenizer.model_max_length							,truncation=__lowerCamelCase							,return_tensors='''pt'''							,)
									a		=			text_inputs.input_ids
									a		=			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					):
										a		=			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
									a		=			self.text_encoder(
									    input_ids=text_input_ids.int().to(__lowerCamelCase					)							,)
									a		=			prompt_embeds[0]

								a		=			prompt_embeds.shape
								# duplicate text embeddings for each generation per prompt, using mps friendly method
								a		=			prompt_embeds.repeat(1							,__lowerCamelCase					)
								a		=			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:
									a		=			42
									if negative_prompt is None:
										a		=			[""] * 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					):
										a		=			[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:
										a		=			negative_prompt

									a		=			text_input_ids.shape[-1]
									a		=			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

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

								if do_classifier_free_guidance:
									a		=			uncond_embeddings.shape[1]
									# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
									a		=			uncond_embeddings.repeat(1							,__lowerCamelCase					)
									a		=			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
									a		=			np.concatenate([uncond_embeddings, prompt_embeds]					)

								return prompt_embeds













import sys
from dataclasses import dataclass
from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union

import pandas as pd
import pyarrow as pa

import datasets
import datasets.config
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


if TYPE_CHECKING:
				import sqlitea

				import sqlalchemy


UpperCamelCase__						:      Tuple								=					datasets.utils.logging.get_logger(__name__)







@dataclass
class 				lowerCamelCase_     (	datasets.BuilderConfig     ):
							SCREAMING_SNAKE_CASE_						     =			None
							SCREAMING_SNAKE_CASE_						     =			None
							SCREAMING_SNAKE_CASE_						     =			None
							SCREAMING_SNAKE_CASE_						     =			True
							SCREAMING_SNAKE_CASE_						     =			None
							SCREAMING_SNAKE_CASE_						     =			None
							SCREAMING_SNAKE_CASE_						     =			None
							SCREAMING_SNAKE_CASE_						     =			1_00_00
							SCREAMING_SNAKE_CASE_						     =			None
							def  SCREAMING_SNAKE_CASE_ (						self		:					Optional[Any]					):





								'''simple docstring'''



								if self.sql is None:
									raise ValueError('''sql must be specified'''					)
								if self.con is None:
									raise ValueError('''con must be specified'''					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					Any							,__lowerCamelCase		:					dict							,__lowerCamelCase		:					Optional[datasets.Features] = None							,):





								'''simple docstring'''



								a		=			config_kwargs.copy()
								# We need to stringify the Selectable object to make its hash deterministic

								# The process of stringifying is explained here: http://docs.sqlalchemy.org/en/latest/faq/sqlexpressions.html
								a		=			config_kwargs['''sql''']
								if not isinstance(__lowerCamelCase							,__lowerCamelCase					):
									if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
										import sqlalchemy

										if isinstance(__lowerCamelCase							,sqlalchemy.sql.Selectable					):
											a		=			sqlalchemy.create_engine(config_kwargs['''con'''].split('''://'''					)[0] + '''://'''					)
											a		=			str(sql.compile(dialect=engine.dialect					)					)
											a		=			sql_str
										else:
											raise TypeError(
											    F"""Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(__lowerCamelCase					)}: {sql}"""					)
									else:
										raise TypeError(
										    F"""Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(__lowerCamelCase					)}: {sql}"""					)
								a		=			config_kwargs['''con''']
								if not isinstance(__lowerCamelCase							,__lowerCamelCase					):
									a		=			id(__lowerCamelCase					)
									logger.info(
									    F"""SQL connection 'con' of type {type(__lowerCamelCase					)} couldn't be hashed properly. To enable hashing, specify 'con' as URI string instead."""					)

								return super().create_config_id(__lowerCamelCase							,custom_features=__lowerCamelCase					)




							@property
							def  SCREAMING_SNAKE_CASE_ (						self		:					Dict					):





								'''simple docstring'''



								a		=			{
								    '''index_col''': self.index_col,
								    '''columns''': self.columns,
								    '''params''': self.params,
								    '''coerce_float''': self.coerce_float,
								    '''parse_dates''': self.parse_dates,
								}
								return pd_read_sql_kwargs







class 				lowerCamelCase_     (	datasets.ArrowBasedBuilder     ):
							SCREAMING_SNAKE_CASE_						     =			SqlConfig
							def  SCREAMING_SNAKE_CASE_ (						self		:					Optional[Any]					):





								'''simple docstring'''



								return datasets.DatasetInfo(features=self.config.features					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]							,__lowerCamelCase		:					int					):





								'''simple docstring'''



								return [datasets.SplitGenerator(name=datasets.Split.TRAIN							,gen_kwargs={}					)]
							def  SCREAMING_SNAKE_CASE_ (						self		:					Tuple							,__lowerCamelCase		:					pa.Table					):





								'''simple docstring'''



								if self.config.features is not None:
									a		=			self.config.features.arrow_schema
									if all(not require_storage_cast(__lowerCamelCase					) for feature in self.config.features.values()					):
										# cheaper cast
										a		=			pa.Table.from_arrays([pa_table[field.name] for field in schema]							,schema=__lowerCamelCase					)
									else:
										# more expensive cast; allows str <-> int/float or str to Audio for example
										a		=			table_cast(__lowerCamelCase							,__lowerCamelCase					)
								return pa_table




							def  SCREAMING_SNAKE_CASE_ (						self		:					str					):





								'''simple docstring'''



								a		=			self.config.chunksize
								a		=			pd.read_sql(
								    self.config.sql							,self.config.con							,chunksize=__lowerCamelCase							,**self.config.pd_read_sql_kwargs					)
								a		=			[sql_reader] if chunksize is None else sql_reader
								for chunk_idx, df in enumerate(__lowerCamelCase					):
									a		=			pa.Table.from_pandas(__lowerCamelCase					)
									yield chunk_idx, self._cast_table(__lowerCamelCase					)





