





from typing import Any, Callable, Dict, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker


snake_case								=							"""CompVis/stable-diffusion-v1-1"""
snake_case								=							"""CompVis/stable-diffusion-v1-2"""
snake_case								=							"""CompVis/stable-diffusion-v1-3"""
snake_case								=							"""CompVis/stable-diffusion-v1-4"""





class 					A_					(   UpperCAmelCase						):







       """simple docstring"""





       def __init__(     self						:						Union[str, Any]    ,__A						:						AutoencoderKL    ,__A						:						CLIPTextModel    ,__A						:						CLIPTokenizer    ,__A						:						UNetaDConditionModel    ,__A						:						Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]    ,__A						:						StableDiffusionSafetyChecker    ,__A						:						CLIPImageProcessor    ,__A						:						bool = True    ,)    ->       Any:
         super()._init_()

         _lowercase						    =			StableDiffusionPipeline.from_pretrained(__A	)
         _lowercase						    =			StableDiffusionPipeline.from_pretrained(__A	)
         _lowercase						    =			StableDiffusionPipeline.from_pretrained(__A	)
         _lowercase						    =			StableDiffusionPipeline(
             vae=__A    ,text_encoder=__A    ,tokenizer=__A    ,unet=__A    ,scheduler=__A    ,safety_checker=__A    ,feature_extractor=__A    ,requires_safety_checker=__A    ,)

         self.register_modules(pipelinea=self.pipea    ,pipelinea=self.pipea    ,pipelinea=self.pipea    ,pipelinea=self.pipea	)







       @property
       def  __UpperCAmelCase			(     self						:						Dict	)    ->       Dict[str, Any]:
         return {k: getattr(self    ,__A	) for k in self.config.keys() if not k.startswith('_'	)}







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







       def  __UpperCAmelCase			(     self						:						Optional[Any]	)    ->       Optional[int]:
         self.enable_attention_slicing(__A	)







       @torch.no_grad()
       def  __UpperCAmelCase			(     self						:						int    ,__A						:						Union[str, List[str]]    ,__A						:						int = 512    ,__A						:						int = 512    ,__A						:						int = 50    ,__A						:						float = 7.5    ,__A						:						Optional[Union[str, List[str]]] = None    ,__A						:						Optional[int] = 1    ,__A						:						float = 0.0    ,__A						:						Optional[torch.Generator] = None    ,__A						:						Optional[torch.FloatTensor] = None    ,__A						:						Optional[str] = "pil"    ,__A						:						bool = True    ,__A						:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None    ,__A						:						int = 1    ,**__A						:						Dict    ,)    ->       Tuple:
         return self.pipea(
             prompt=__A    ,height=__A    ,width=__A    ,num_inference_steps=__A    ,guidance_scale=__A    ,negative_prompt=__A    ,num_images_per_prompt=__A    ,eta=__A    ,generator=__A    ,latents=__A    ,output_type=__A    ,return_dict=__A    ,callback=__A    ,callback_steps=__A    ,**__A    ,)







       @torch.no_grad()
       def  __UpperCAmelCase			(     self						:						int    ,__A						:						Union[str, List[str]]    ,__A						:						int = 512    ,__A						:						int = 512    ,__A						:						int = 50    ,__A						:						float = 7.5    ,__A						:						Optional[Union[str, List[str]]] = None    ,__A						:						Optional[int] = 1    ,__A						:						float = 0.0    ,__A						:						Optional[torch.Generator] = None    ,__A						:						Optional[torch.FloatTensor] = None    ,__A						:						Optional[str] = "pil"    ,__A						:						bool = True    ,__A						:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None    ,__A						:						int = 1    ,**__A						:						Union[str, Any]    ,)    ->       Tuple:
         return self.pipea(
             prompt=__A    ,height=__A    ,width=__A    ,num_inference_steps=__A    ,guidance_scale=__A    ,negative_prompt=__A    ,num_images_per_prompt=__A    ,eta=__A    ,generator=__A    ,latents=__A    ,output_type=__A    ,return_dict=__A    ,callback=__A    ,callback_steps=__A    ,**__A    ,)







       @torch.no_grad()
       def  __UpperCAmelCase			(     self						:						Optional[int]    ,__A						:						Union[str, List[str]]    ,__A						:						int = 512    ,__A						:						int = 512    ,__A						:						int = 50    ,__A						:						float = 7.5    ,__A						:						Optional[Union[str, List[str]]] = None    ,__A						:						Optional[int] = 1    ,__A						:						float = 0.0    ,__A						:						Optional[torch.Generator] = None    ,__A						:						Optional[torch.FloatTensor] = None    ,__A						:						Optional[str] = "pil"    ,__A						:						bool = True    ,__A						:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None    ,__A						:						int = 1    ,**__A						:						int    ,)    ->       str:
         return self.pipea(
             prompt=__A    ,height=__A    ,width=__A    ,num_inference_steps=__A    ,guidance_scale=__A    ,negative_prompt=__A    ,num_images_per_prompt=__A    ,eta=__A    ,generator=__A    ,latents=__A    ,output_type=__A    ,return_dict=__A    ,callback=__A    ,callback_steps=__A    ,**__A    ,)







       @torch.no_grad()
       def  __UpperCAmelCase			(     self						:						Any    ,__A						:						Union[str, List[str]]    ,__A						:						int = 512    ,__A						:						int = 512    ,__A						:						int = 50    ,__A						:						float = 7.5    ,__A						:						Optional[Union[str, List[str]]] = None    ,__A						:						Optional[int] = 1    ,__A						:						float = 0.0    ,__A						:						Optional[torch.Generator] = None    ,__A						:						Optional[torch.FloatTensor] = None    ,__A						:						Optional[str] = "pil"    ,__A						:						bool = True    ,__A						:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None    ,__A						:						int = 1    ,**__A						:						Union[str, Any]    ,)    ->       List[Any]:
         return self.pipea(
             prompt=__A    ,height=__A    ,width=__A    ,num_inference_steps=__A    ,guidance_scale=__A    ,negative_prompt=__A    ,num_images_per_prompt=__A    ,eta=__A    ,generator=__A    ,latents=__A    ,output_type=__A    ,return_dict=__A    ,callback=__A    ,callback_steps=__A    ,**__A    ,)







       @torch.no_grad()
       def  __UpperCAmelCase			(     self						:						List[str]    ,__A						:						Union[str, List[str]]    ,__A						:						int = 512    ,__A						:						int = 512    ,__A						:						int = 50    ,__A						:						float = 7.5    ,__A						:						Optional[Union[str, List[str]]] = None    ,__A						:						Optional[int] = 1    ,__A						:						float = 0.0    ,__A						:						Optional[torch.Generator] = None    ,__A						:						Optional[torch.FloatTensor] = None    ,__A						:						Optional[str] = "pil"    ,__A						:						bool = True    ,__A						:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None    ,__A						:						int = 1    ,**__A						:						Tuple    ,)    ->       Optional[Any]:
         _lowercase						    =			'cuda' if torch.cuda.is_available() else 'cpu'
         self.to(__A	)

         # Checks if the height and width are divisible by 8 or not
         if height % 8 != 0 or width % 8 != 0:
           raise ValueError(F"""`height` and `width` must be divisible by 8 but are {height} and {width}."""	)

         # Get first result from Stable Diffusion Checkpoint v1.1
         _lowercase						    =			self.textaimg_sda_a(
             prompt=__A    ,height=__A    ,width=__A    ,num_inference_steps=__A    ,guidance_scale=__A    ,negative_prompt=__A    ,num_images_per_prompt=__A    ,eta=__A    ,generator=__A    ,latents=__A    ,output_type=__A    ,return_dict=__A    ,callback=__A    ,callback_steps=__A    ,**__A    ,)

         # Get first result from Stable Diffusion Checkpoint v1.2
         _lowercase						    =			self.textaimg_sda_a(
             prompt=__A    ,height=__A    ,width=__A    ,num_inference_steps=__A    ,guidance_scale=__A    ,negative_prompt=__A    ,num_images_per_prompt=__A    ,eta=__A    ,generator=__A    ,latents=__A    ,output_type=__A    ,return_dict=__A    ,callback=__A    ,callback_steps=__A    ,**__A    ,)

         # Get first result from Stable Diffusion Checkpoint v1.3
         _lowercase						    =			self.textaimg_sda_a(
             prompt=__A    ,height=__A    ,width=__A    ,num_inference_steps=__A    ,guidance_scale=__A    ,negative_prompt=__A    ,num_images_per_prompt=__A    ,eta=__A    ,generator=__A    ,latents=__A    ,output_type=__A    ,return_dict=__A    ,callback=__A    ,callback_steps=__A    ,**__A    ,)

         # Get first result from Stable Diffusion Checkpoint v1.4
         _lowercase						    =			self.textaimg_sda_a(
             prompt=__A    ,height=__A    ,width=__A    ,num_inference_steps=__A    ,guidance_scale=__A    ,negative_prompt=__A    ,num_images_per_prompt=__A    ,eta=__A    ,generator=__A    ,latents=__A    ,output_type=__A    ,return_dict=__A    ,callback=__A    ,callback_steps=__A    ,**__A    ,)

         # Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
         return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]]	)
from __future__ import annotations




def    lowerCAmelCase_  (		lowercase:				str	,       lowercase:				list[str] | None = None	,       lowercase:				dict[str, float] | None = None	,       lowercase:				bool = False	,       )     ->					tuple[int, float, str]:







 '''simple docstring'''
 _UpperCamelCase:  Any    						=			cipher_alphabet or [chr(lowercase		) for i in range(97	,       123		)]

 # If the argument is None or the user provided an empty dictionary
 if not frequencies_dict:
  # Frequencies of letters in the english language (how much they show up)
  _UpperCamelCase:  Any    						=			{
      '''a''': 0.08497,
      '''b''': 0.01492,
      '''c''': 0.02202,
      '''d''': 0.04253,
      '''e''': 0.11162,
      '''f''': 0.02228,
      '''g''': 0.02015,
      '''h''': 0.06094,
      '''i''': 0.07546,
      '''j''': 0.00153,
      '''k''': 0.01292,
      '''l''': 0.04025,
      '''m''': 0.02406,
      '''n''': 0.06749,
      '''o''': 0.07507,
      '''p''': 0.01929,
      '''q''': 0.00095,
      '''r''': 0.07587,
      '''s''': 0.06327,
      '''t''': 0.09356,
      '''u''': 0.02758,
      '''v''': 0.00978,
      '''w''': 0.02560,
      '''x''': 0.00150,
      '''y''': 0.01994,
      '''z''': 0.00077,
  }
 else:
  # Custom frequencies dictionary
  _UpperCamelCase:  str    						=			frequencies_dict

 if not case_sensitive:
  _UpperCamelCase:  Union[str, Any]    						=			ciphertext.lower()

 # Chi squared statistic values
 _UpperCamelCase:  dict[int, tuple[float, str]]    						=			{}

 # cycle through all of the shifts
 for shift in range(len(lowercase		)		):
  _UpperCamelCase:  Tuple    						=			''''''

  # decrypt the message with the shift
  for letter in ciphertext:
   try:
    # Try to index the letter in the alphabet
    _UpperCamelCase:  Optional[int]    						=			(alphabet_letters.index(letter.lower()		) - shift) % len(
        lowercase		)
    decrypted_with_shift += (
        alphabet_letters[new_key].upper()
        if case_sensitive and letter.isupper()
        else alphabet_letters[new_key]
    )
   except ValueError:
    # Append the character if it isn't in the alphabet
    decrypted_with_shift += letter

  _UpperCamelCase:  Optional[int]    						=			0.0

  # Loop through each letter in the decoded message with the shift
  for letter in decrypted_with_shift:
   if case_sensitive:
    _UpperCamelCase:  Optional[int]    						=			letter.lower()
    if letter in frequencies:
     # Get the amount of times the letter occurs in the message
     _UpperCamelCase:  Any    						=			decrypted_with_shift.lower().count(lowercase		)

     # Get the excepcted amount of times the letter should appear based
     # on letter frequencies
     _UpperCamelCase:  int    						=			frequencies[letter] * occurrences

     # Complete the chi squared statistic formula
     _UpperCamelCase:  int    						=			((occurrences - expected) ** 2) / expected

     # Add the margin of error to the total chi squared statistic
     chi_squared_statistic += chi_letter_value
   else:
    if letter.lower() in frequencies:
     # Get the amount of times the letter occurs in the message
     _UpperCamelCase:  List[Any]    						=			decrypted_with_shift.count(lowercase		)

     # Get the excepcted amount of times the letter should appear based
     # on letter frequencies
     _UpperCamelCase:  Union[str, Any]    						=			frequencies[letter] * occurrences

     # Complete the chi squared statistic formula
     _UpperCamelCase:  List[str]    						=			((occurrences - expected) ** 2) / expected

     # Add the margin of error to the total chi squared statistic
     chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
  _UpperCamelCase:  List[Any]    						=			(
      chi_squared_statistic,
      decrypted_with_shift,
  )

 # Get the most likely cipher by finding the cipher with the smallest chi squared
 # statistic
 def chi_squared_statistic_values_sorting_key(lowercase:				int		) -> tuple[float, str]:
  return chi_squared_statistic_values[key]

 _UpperCamelCase:  int    						=			min(
     lowercase	,       key=lowercase	,       )

 # Get all the data from the most likely cipher (key, decoded message)
 (
     (
     _UpperCamelCase
 )						,				(
     _UpperCamelCase
 )						,				
 ):  str    						=			chi_squared_statistic_values[most_likely_cipher]

 # Return the data on the most likely shift
 return (
     most_likely_cipher,
     most_likely_cipher_chi_squared_value,
     decoded_most_likely_cipher,
 )