


"""simple docstring"""



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


UpperCAmelCase      		=			'''CompVis/stable-diffusion-v1-1'''
UpperCAmelCase      		=			'''CompVis/stable-diffusion-v1-2'''
UpperCAmelCase      		=			'''CompVis/stable-diffusion-v1-3'''
UpperCAmelCase      		=			'''CompVis/stable-diffusion-v1-4'''
class 					__magic_name__		(			__UpperCAmelCase     ):






       def __init__(   self  :    int  ,     snake_case__  :    AutoencoderKL  ,     snake_case__  :    CLIPTextModel  ,     snake_case__  :    CLIPTokenizer  ,     snake_case__  :    UNetaDConditionModel  ,     snake_case__  :    Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]  ,     snake_case__  :    StableDiffusionSafetyChecker  ,     snake_case__  :    CLIPImageProcessor  ,     snake_case__  :    bool = True  ,     ):

              '''simple docstring'''






              super()._init_()

              lowercase		:List[str]       							=				StableDiffusionPipeline.from_pretrained(snake_case__				)
              lowercase		:str       							=				StableDiffusionPipeline.from_pretrained(snake_case__				)
              lowercase		:str       							=				StableDiffusionPipeline.from_pretrained(snake_case__				)
              lowercase		:Optional[Any]       							=				StableDiffusionPipeline(
                  vae=snake_case__  ,     text_encoder=snake_case__  ,     tokenizer=snake_case__  ,     unet=snake_case__  ,     scheduler=snake_case__  ,     safety_checker=snake_case__  ,     feature_extractor=snake_case__  ,     requires_safety_checker=snake_case__  ,     )

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






       @property
       def  __snake_case						(   self  :    str				):

              '''simple docstring'''






              return {k: getattr(self  ,     snake_case__				) for k in self.config.keys() if not k.startswith('''_'''				)}






       def  __snake_case						(   self  :    int  ,     snake_case__  :    Optional[Union[str, int]] = "auto"				):

              '''simple docstring'''






              if slice_size == "auto":
                     # half the attention head size is usually a good trade-off between
                     # speed and memory
                     lowercase		:Dict       							=				self.unet.config.attention_head_dim // 2
              self.unet.set_attention_slice(snake_case__				)






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              self.enable_attention_slicing(snake_case__				)






       @torch.no_grad()
       def  __snake_case						(   self  :    int  ,     snake_case__  :    Union[str, List[str]]  ,     snake_case__  :    int = 5_1_2  ,     snake_case__  :    int = 5_1_2  ,     snake_case__  :    int = 5_0  ,     snake_case__  :    float = 7.5  ,     snake_case__  :    Optional[Union[str, List[str]]] = None  ,     snake_case__  :    Optional[int] = 1  ,     snake_case__  :    float = 0.0  ,     snake_case__  :    Optional[torch.Generator] = None  ,     snake_case__  :    Optional[torch.FloatTensor] = None  ,     snake_case__  :    Optional[str] = "pil"  ,     snake_case__  :    bool = True  ,     snake_case__  :    Optional[Callable[[int, int, torch.FloatTensor], None]] = None  ,     snake_case__  :    int = 1  ,     **snake_case__  :    Any  ,     ):

              '''simple docstring'''






              return self.pipea(
                  prompt=snake_case__  ,     height=snake_case__  ,     width=snake_case__  ,     num_inference_steps=snake_case__  ,     guidance_scale=snake_case__  ,     negative_prompt=snake_case__  ,     num_images_per_prompt=snake_case__  ,     eta=snake_case__  ,     generator=snake_case__  ,     latents=snake_case__  ,     output_type=snake_case__  ,     return_dict=snake_case__  ,     callback=snake_case__  ,     callback_steps=snake_case__  ,     **snake_case__  ,     )






       @torch.no_grad()
       def  __snake_case						(   self  :    Optional[Any]  ,     snake_case__  :    Union[str, List[str]]  ,     snake_case__  :    int = 5_1_2  ,     snake_case__  :    int = 5_1_2  ,     snake_case__  :    int = 5_0  ,     snake_case__  :    float = 7.5  ,     snake_case__  :    Optional[Union[str, List[str]]] = None  ,     snake_case__  :    Optional[int] = 1  ,     snake_case__  :    float = 0.0  ,     snake_case__  :    Optional[torch.Generator] = None  ,     snake_case__  :    Optional[torch.FloatTensor] = None  ,     snake_case__  :    Optional[str] = "pil"  ,     snake_case__  :    bool = True  ,     snake_case__  :    Optional[Callable[[int, int, torch.FloatTensor], None]] = None  ,     snake_case__  :    int = 1  ,     **snake_case__  :    Dict  ,     ):

              '''simple docstring'''






              return self.pipea(
                  prompt=snake_case__  ,     height=snake_case__  ,     width=snake_case__  ,     num_inference_steps=snake_case__  ,     guidance_scale=snake_case__  ,     negative_prompt=snake_case__  ,     num_images_per_prompt=snake_case__  ,     eta=snake_case__  ,     generator=snake_case__  ,     latents=snake_case__  ,     output_type=snake_case__  ,     return_dict=snake_case__  ,     callback=snake_case__  ,     callback_steps=snake_case__  ,     **snake_case__  ,     )






       @torch.no_grad()
       def  __snake_case						(   self  :    int  ,     snake_case__  :    Union[str, List[str]]  ,     snake_case__  :    int = 5_1_2  ,     snake_case__  :    int = 5_1_2  ,     snake_case__  :    int = 5_0  ,     snake_case__  :    float = 7.5  ,     snake_case__  :    Optional[Union[str, List[str]]] = None  ,     snake_case__  :    Optional[int] = 1  ,     snake_case__  :    float = 0.0  ,     snake_case__  :    Optional[torch.Generator] = None  ,     snake_case__  :    Optional[torch.FloatTensor] = None  ,     snake_case__  :    Optional[str] = "pil"  ,     snake_case__  :    bool = True  ,     snake_case__  :    Optional[Callable[[int, int, torch.FloatTensor], None]] = None  ,     snake_case__  :    int = 1  ,     **snake_case__  :    Optional[int]  ,     ):

              '''simple docstring'''






              return self.pipea(
                  prompt=snake_case__  ,     height=snake_case__  ,     width=snake_case__  ,     num_inference_steps=snake_case__  ,     guidance_scale=snake_case__  ,     negative_prompt=snake_case__  ,     num_images_per_prompt=snake_case__  ,     eta=snake_case__  ,     generator=snake_case__  ,     latents=snake_case__  ,     output_type=snake_case__  ,     return_dict=snake_case__  ,     callback=snake_case__  ,     callback_steps=snake_case__  ,     **snake_case__  ,     )






       @torch.no_grad()
       def  __snake_case						(   self  :    str  ,     snake_case__  :    Union[str, List[str]]  ,     snake_case__  :    int = 5_1_2  ,     snake_case__  :    int = 5_1_2  ,     snake_case__  :    int = 5_0  ,     snake_case__  :    float = 7.5  ,     snake_case__  :    Optional[Union[str, List[str]]] = None  ,     snake_case__  :    Optional[int] = 1  ,     snake_case__  :    float = 0.0  ,     snake_case__  :    Optional[torch.Generator] = None  ,     snake_case__  :    Optional[torch.FloatTensor] = None  ,     snake_case__  :    Optional[str] = "pil"  ,     snake_case__  :    bool = True  ,     snake_case__  :    Optional[Callable[[int, int, torch.FloatTensor], None]] = None  ,     snake_case__  :    int = 1  ,     **snake_case__  :    Tuple  ,     ):

              '''simple docstring'''






              return self.pipea(
                  prompt=snake_case__  ,     height=snake_case__  ,     width=snake_case__  ,     num_inference_steps=snake_case__  ,     guidance_scale=snake_case__  ,     negative_prompt=snake_case__  ,     num_images_per_prompt=snake_case__  ,     eta=snake_case__  ,     generator=snake_case__  ,     latents=snake_case__  ,     output_type=snake_case__  ,     return_dict=snake_case__  ,     callback=snake_case__  ,     callback_steps=snake_case__  ,     **snake_case__  ,     )







       @torch.no_grad()
       def  __snake_case						(   self  :    Union[str, Any]  ,     snake_case__  :    Union[str, List[str]]  ,     snake_case__  :    int = 5_1_2  ,     snake_case__  :    int = 5_1_2  ,     snake_case__  :    int = 5_0  ,     snake_case__  :    float = 7.5  ,     snake_case__  :    Optional[Union[str, List[str]]] = None  ,     snake_case__  :    Optional[int] = 1  ,     snake_case__  :    float = 0.0  ,     snake_case__  :    Optional[torch.Generator] = None  ,     snake_case__  :    Optional[torch.FloatTensor] = None  ,     snake_case__  :    Optional[str] = "pil"  ,     snake_case__  :    bool = True  ,     snake_case__  :    Optional[Callable[[int, int, torch.FloatTensor], None]] = None  ,     snake_case__  :    int = 1  ,     **snake_case__  :    Tuple  ,     ):

              '''simple docstring'''






              lowercase		:Any       							=				'''cuda''' if torch.cuda.is_available() else '''cpu'''
              self.to(snake_case__				)

              # 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		:Any       							=				self.textaimg_sda_a(
                  prompt=snake_case__  ,     height=snake_case__  ,     width=snake_case__  ,     num_inference_steps=snake_case__  ,     guidance_scale=snake_case__  ,     negative_prompt=snake_case__  ,     num_images_per_prompt=snake_case__  ,     eta=snake_case__  ,     generator=snake_case__  ,     latents=snake_case__  ,     output_type=snake_case__  ,     return_dict=snake_case__  ,     callback=snake_case__  ,     callback_steps=snake_case__  ,     **snake_case__  ,     )

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

              # Get first result from Stable Diffusion Checkpoint v1.3
              lowercase		:List[str]       							=				self.textaimg_sda_a(
                  prompt=snake_case__  ,     height=snake_case__  ,     width=snake_case__  ,     num_inference_steps=snake_case__  ,     guidance_scale=snake_case__  ,     negative_prompt=snake_case__  ,     num_images_per_prompt=snake_case__  ,     eta=snake_case__  ,     generator=snake_case__  ,     latents=snake_case__  ,     output_type=snake_case__  ,     return_dict=snake_case__  ,     callback=snake_case__  ,     callback_steps=snake_case__  ,     **snake_case__  ,     )

              # Get first result from Stable Diffusion Checkpoint v1.4
              lowercase		:Optional[int]       							=				self.textaimg_sda_a(
                  prompt=snake_case__  ,     height=snake_case__  ,     width=snake_case__  ,     num_inference_steps=snake_case__  ,     guidance_scale=snake_case__  ,     negative_prompt=snake_case__  ,     num_images_per_prompt=snake_case__  ,     eta=snake_case__  ,     generator=snake_case__  ,     latents=snake_case__  ,     output_type=snake_case__  ,     return_dict=snake_case__  ,     callback=snake_case__  ,     callback_steps=snake_case__  ,     **snake_case__  ,     )

              # 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]]				)





"""simple docstring"""



import unittest

import numpy as np






def       lowerCamelCase					(a_						:np.ndarray				,				a_						:np.ndarray				,				a_						:np.ndarray				,				a_						:np.ndarray | None = None				,				)     ->							np.ndarray:
       lowercase		:str       							=				np.shape(a_)
       lowercase		:Dict       							=				np.shape(a_)
       lowercase		:Optional[int]       							=				np.shape(a_)

       if shape_a[0] != shape_b[0]:
              lowercase		:List[str]       							=				(
                  '''Expected the same number of rows for A and B. '''
                  F"""Instead found A of size {shape_a} and B of size {shape_b}"""
              )
              raise ValueError(a_)

       if shape_b[1] != shape_c[1]:
              lowercase		:List[str]       							=				(
                  '''Expected the same number of columns for B and C. '''
                  F"""Instead found B of size {shape_b} and C of size {shape_c}"""
              )
              raise ValueError(a_)

       lowercase		:Optional[Any]       							=				pseudo_inv
       if a_inv is None:
              try:
                     lowercase		:int       							=				np.linalg.inv(a_)
              except np.linalg.LinAlgError:
                     raise ValueError(
                         '''Input matrix A is not invertible. Cannot compute Schur complement.''')

       return mat_c - mat_b.T @ a_inv @ mat_b
class 					__magic_name__		(			unittest.TestCase     ):






       def  __snake_case						(   self  :    int				):

              '''simple docstring'''






              lowercase		:Dict       							=				np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]				)
              lowercase		:List[str]       							=				np.array([[0, 3], [3, 0], [2, 3]]				)
              lowercase		:List[str]       							=				np.array([[2, 1], [6, 3]]				)

              lowercase		:Any       							=				schur_complement(snake_case__  ,     snake_case__  ,     snake_case__				)

              lowercase		:int       							=				np.block([[a, b], [b.T, c]]				)

              lowercase		:Tuple       							=				np.linalg.det(snake_case__				)
              lowercase		:Any       							=				np.linalg.det(snake_case__				)
              lowercase		:List[Any]       							=				np.linalg.det(snake_case__				)

              self.assertAlmostEqual(snake_case__  ,     det_a * det_s				)






       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:Union[str, Any]       							=				np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]				)
              lowercase		:Union[str, Any]       							=				np.array([[0, 3], [3, 0], [2, 3]]				)
              lowercase		:List[str]       							=				np.array([[2, 1], [6, 3]]				)

              with self.assertRaises(snake_case__				):
                     schur_complement(snake_case__  ,     snake_case__  ,     snake_case__				)







       def  __snake_case						(   self  :    List[Any]				):

              '''simple docstring'''






              lowercase		:List[str]       							=				np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]				)
              lowercase		:int       							=				np.array([[0, 3], [3, 0], [2, 3]]				)
              lowercase		:List[Any]       							=				np.array([[2, 1, 3], [6, 3, 5]]				)

              with self.assertRaises(snake_case__				):
                     schur_complement(snake_case__  ,     snake_case__  ,     snake_case__				)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 unittest.main()

