




"""simple docstring"""





import colorsys
import io

import cva
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import numpy as np
import torch
from matplotlib.backends.backend_agg import FigureCanvasAgg

from utils import img_tensorize


_lowercase						   =     10_00

class    __lowercase							:


				'''simple docstring'''


				def __init__( self :  List[Any]   ,SCREAMING_SNAKE_CASE_ :  Tuple   ,SCREAMING_SNAKE_CASE_ :  List[str]=1.2   ,SCREAMING_SNAKE_CASE_ :  Any="g"   ,SCREAMING_SNAKE_CASE_ :  Optional[int]=0.5   ,SCREAMING_SNAKE_CASE_ :  Tuple="-"   ,SCREAMING_SNAKE_CASE_ :  int="test_out.jpg"   ,SCREAMING_SNAKE_CASE_ :  Dict=True   ,SCREAMING_SNAKE_CASE_ :  Tuple=False   ,SCREAMING_SNAKE_CASE_ :  str=None   ,SCREAMING_SNAKE_CASE_ :  Optional[int]=None   ,SCREAMING_SNAKE_CASE_ :  List[Any]=0.7   ,):
										if isinstance(SCREAMING_SNAKE_CASE_   ,torch.Tensor   ):
																snake_case__							:       Optional[Any]				      =       img.numpy().astype('''np.uint8'''   )
										if isinstance(SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ):
																snake_case__							:       Tuple				      =       img_tensorize(SCREAMING_SNAKE_CASE_   )
										assert isinstance(SCREAMING_SNAKE_CASE_   ,np.ndarray   )

										snake_case__      ,						snake_case__							:       Any				      =       img.shape[1], img.shape[0]
										snake_case__							:       Tuple				      =       mplfigure.Figure(frameon=SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Optional[int]				      =       fig.get_dpi()
										snake_case__							:       Optional[Any]				      =       (width * scale + 1E-2) / dpi
										snake_case__							:       Optional[int]				      =       (height * scale + 1E-2) / dpi
										fig.set_size_inches(SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Tuple				      =       fig.add_axes([0.0, 0.0, 1.0, 1.0]   )
										ax.axis('''off'''   )
										ax.set_xlim(0.0   ,SCREAMING_SNAKE_CASE_   )
										ax.set_ylim(SCREAMING_SNAKE_CASE_   )

										snake_case__							:       Dict				      =       saveas
										snake_case__							:       Dict				      =       rgb
										snake_case__							:       List[Any]				      =       pynb
										snake_case__							:       Dict				      =       img
										snake_case__							:       List[str]				      =       edgecolor
										snake_case__							:       List[Any]				      =       0.5
										snake_case__							:       Optional[Any]				      =       linestyle
										snake_case__							:       int				      =       int(np.sqrt(min(SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   )   ) * scale // 3   )
										snake_case__							:       List[Any]				      =       width
										snake_case__							:       Optional[int]				      =       height
										snake_case__							:       Optional[int]				      =       scale
										snake_case__							:       Optional[Any]				      =       fig
										snake_case__							:       Union[str, Any]				      =       ax
										snake_case__							:       Union[str, Any]				      =       pad
										snake_case__							:       Tuple				      =       idaobj
										snake_case__							:       str				      =       idaattr
										snake_case__							:       Optional[Any]				      =       FigureCanvasAgg(SCREAMING_SNAKE_CASE_   )

				def    _lowerCamelCase       ( self :  int   ,SCREAMING_SNAKE_CASE_ :  Any   ,SCREAMING_SNAKE_CASE_ :  Optional[Any]=None   ):
										if color is None:
																snake_case__							:       str				      =       self.edgecolor
										((snake_case__)      ,						(snake_case__)      ,						(snake_case__)      ,						(snake_case__))							:       Optional[int]				      =       box
										snake_case__							:       str				      =       xa - xa
										snake_case__							:       List[str]				      =       ya - ya
										self.ax.add_patch(
										    mpl.patches.Rectangle(
										        (xa, ya)   ,SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ,fill=SCREAMING_SNAKE_CASE_   ,edgecolor=SCREAMING_SNAKE_CASE_   ,linewidth=self.font_size // 3   ,alpha=self.alpha   ,linestyle=self.linestyle   ,)   )

				def    _lowerCamelCase       ( self :  Union[str, Any]   ,SCREAMING_SNAKE_CASE_ :  str   ,SCREAMING_SNAKE_CASE_ :  str=None   ,SCREAMING_SNAKE_CASE_ :  Optional[Any]=None   ,SCREAMING_SNAKE_CASE_ :  int=None   ,SCREAMING_SNAKE_CASE_ :  Optional[Any]=None   ):
										if len(boxes.shape   ) > 2:
																snake_case__							:       str				      =       boxes[0]
										if len(obj_ids.shape   ) > 1:
																snake_case__							:       Optional[int]				      =       obj_ids[0]
										if len(obj_scores.shape   ) > 1:
																snake_case__							:       Tuple				      =       obj_scores[0]
										if len(attr_ids.shape   ) > 1:
																snake_case__							:       Tuple				      =       attr_ids[0]
										if len(attr_scores.shape   ) > 1:
																snake_case__							:       Optional[int]				      =       attr_scores[0]
										if isinstance(SCREAMING_SNAKE_CASE_   ,torch.Tensor   ):
																snake_case__							:       List[Any]				      =       boxes.numpy()
										if isinstance(SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ):
																snake_case__							:       Optional[Any]				      =       np.array(SCREAMING_SNAKE_CASE_   )
										assert isinstance(SCREAMING_SNAKE_CASE_   ,np.ndarray   )
										snake_case__							:       Union[str, Any]				      =       np.prod(boxes[:, 2:] - boxes[:, :2]   ,axis=1   )
										snake_case__							:       int				      =       np.argsort(-areas   ).tolist()
										snake_case__							:       int				      =       boxes[sorted_idxs] if boxes is not None else None
										snake_case__							:       Optional[int]				      =       obj_ids[sorted_idxs] if obj_ids is not None else None
										snake_case__							:       int				      =       obj_scores[sorted_idxs] if obj_scores is not None else None
										snake_case__							:       str				      =       attr_ids[sorted_idxs] if attr_ids is not None else None
										snake_case__							:       Tuple				      =       attr_scores[sorted_idxs] if attr_scores is not None else None

										snake_case__							:       Dict				      =       [self._random_color(maximum=1   ) for _ in range(len(SCREAMING_SNAKE_CASE_   )   )]
										snake_case__							:       Optional[int]				      =       [assigned_colors[idx] for idx in sorted_idxs]
										if obj_ids is not None:
																snake_case__							:       List[Any]				      =       self._create_text_labels_attr(SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   )
																for i in range(len(SCREAMING_SNAKE_CASE_   )   ):
																						snake_case__							:       Tuple				      =       assigned_colors[i]
																						self.add_box(boxes[i]   ,SCREAMING_SNAKE_CASE_   )
																						self.draw_labels(labels[i]   ,boxes[i]   ,SCREAMING_SNAKE_CASE_   )

				def    _lowerCamelCase       ( self :  Union[str, Any]   ,SCREAMING_SNAKE_CASE_ :  Any   ,SCREAMING_SNAKE_CASE_ :  Any   ,SCREAMING_SNAKE_CASE_ :  List[str]   ):
										snake_case__      ,						snake_case__      ,						snake_case__      ,						snake_case__							:       Optional[int]				      =       box
										snake_case__							:       int				      =       (xa, ya)
										snake_case__							:       Optional[Any]				      =       (ya - ya) * (xa - xa)
										snake_case__							:       int				      =       _SMALL_OBJ * self.scale
										if instance_area < small or ya - ya < 4_0 * self.scale:
																if ya >= self.height - 5:
																						snake_case__							:       Union[str, Any]				      =       (xa, ya)
																else:
																						snake_case__							:       int				      =       (xa, ya)

										snake_case__							:       Optional[int]				      =       (ya - ya) / np.sqrt(self.height * self.width   )
										snake_case__							:       Tuple				      =       self._change_color_brightness(SCREAMING_SNAKE_CASE_   ,brightness_factor=0.7   )
										snake_case__							:       Tuple				      =       np.clip((height_ratio - 0.02) / 0.08 + 1   ,1.2   ,2   )
										font_size *= 0.75 * self.font_size

										self.draw_text(
										    text=SCREAMING_SNAKE_CASE_   ,position=SCREAMING_SNAKE_CASE_   ,color=SCREAMING_SNAKE_CASE_   ,)

				def    _lowerCamelCase       ( self :  str   ,SCREAMING_SNAKE_CASE_ :  Optional[int]   ,SCREAMING_SNAKE_CASE_ :  int   ,SCREAMING_SNAKE_CASE_ :  Tuple="g"   ,SCREAMING_SNAKE_CASE_ :  int="left"   ,):
										snake_case__							:       Any				      =       0
										snake_case__							:       Dict				      =       self.font_size
										snake_case__							:       Union[str, Any]				      =       np.maximum(list(mplc.to_rgb(SCREAMING_SNAKE_CASE_   )   )   ,0.2   )
										snake_case__							:       Union[str, Any]				      =       max(0.8   ,np.max(SCREAMING_SNAKE_CASE_   )   )
										snake_case__							:       List[str]				      =       {
										    '''facecolor''': '''black''',
										    '''alpha''': self.alpha,
										    '''pad''': self.pad,
										    '''edgecolor''': '''none''',
										}
										snake_case__      ,						snake_case__							:       Tuple				      =       position
										self.ax.text(
										    SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ,size=font_size * self.scale   ,family='''sans-serif'''   ,bbox=SCREAMING_SNAKE_CASE_   ,verticalalignment='''top'''   ,horizontalalignment=SCREAMING_SNAKE_CASE_   ,color=SCREAMING_SNAKE_CASE_   ,zorder=1_0   ,rotation=SCREAMING_SNAKE_CASE_   ,)

				def    _lowerCamelCase       ( self :  List[str]   ,SCREAMING_SNAKE_CASE_ :  Union[str, Any]=None   ):
										if saveas is None:
																snake_case__							:       Optional[int]				      =       self.saveas
										if saveas.lower().endswith('''.jpg'''   ) or saveas.lower().endswith('''.png'''   ):
																cva.imwrite(
																    SCREAMING_SNAKE_CASE_   ,self._get_buffer()[:, :, ::-1]   ,)
										else:
																self.fig.savefig(SCREAMING_SNAKE_CASE_   )

				def    _lowerCamelCase       ( self :  List[Any]   ,SCREAMING_SNAKE_CASE_ :  str   ,SCREAMING_SNAKE_CASE_ :  Optional[Any]   ,SCREAMING_SNAKE_CASE_ :  int   ,SCREAMING_SNAKE_CASE_ :  List[str]   ):
										snake_case__							:       Optional[Any]				      =       [self.idaobj[i] for i in classes]
										snake_case__							:       Union[str, Any]				      =       [self.idaattr[i] for i in attr_classes]
										snake_case__							:       Tuple				      =       [
										    F'''{label} {score:.2f} {attr} {attr_score:.2f}'''
										    for label, score, attr, attr_score in zip(SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   )
										]
										return labels

				def    _lowerCamelCase       ( self :  List[Any]   ,SCREAMING_SNAKE_CASE_ :  Any   ,SCREAMING_SNAKE_CASE_ :  Union[str, Any]   ):
										snake_case__							:       List[Any]				      =       [self.idaobj[i] for i in classes]
										if scores is not None:
																if labels is None:
																						snake_case__							:       Optional[int]				      =       ['''{:.0f}%'''.format(s * 1_0_0   ) for s in scores]
																else:
																						snake_case__							:       Any				      =       ['''{} {:.0f}%'''.format(SCREAMING_SNAKE_CASE_   ,s * 1_0_0   ) for li, s in zip(SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   )]
										return labels

				def    _lowerCamelCase       ( self :  str   ,SCREAMING_SNAKE_CASE_ :  Union[str, Any]=2_5_5   ):
										snake_case__							:       Any				      =       np.random.randint(0   ,len(_COLORS   )   )
										snake_case__							:       Dict				      =       _COLORS[idx] * maximum
										if not self.rgb:
																snake_case__							:       Union[str, Any]				      =       ret[::-1]
										return ret

				def    _lowerCamelCase       ( self :  int   ):
										if not self.pynb:
																snake_case__      ,						snake_case__							:       int				      =       self.canvas.print_to_buffer()
																if (width, height) != (self.width, self.height):
																						snake_case__							:       str				      =       cva.resize(self.img   ,(width, height)   )
																else:
																						snake_case__							:       str				      =       self.img
										else:
																snake_case__							:       Optional[int]				      =       io.BytesIO()  # works for cairo backend
																self.canvas.print_rgba(SCREAMING_SNAKE_CASE_   )
																snake_case__      ,						snake_case__							:       Dict				      =       self.width, self.height
																snake_case__							:       Dict				      =       buf.getvalue()
																snake_case__							:       Optional[Any]				      =       self.img

										snake_case__							:       Optional[Any]				      =       np.frombuffer(SCREAMING_SNAKE_CASE_   ,dtype='''uint8'''   )
										snake_case__							:       Dict				      =       buffer.reshape(SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ,4   )
										snake_case__      ,						snake_case__							:       int				      =       np.split(SCREAMING_SNAKE_CASE_   ,[3]   ,axis=2   )

										try:
																import numexpr as ne  # fuse them with numexpr

																snake_case__							:       Any				      =       ne.evaluate('''img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)'''   )
										except ImportError:
																snake_case__							:       List[str]				      =       alpha.astype('''float32'''   ) / 255.0
																snake_case__							:       Union[str, Any]				      =       img * (1 - alpha) + rgb * alpha

										return visualized_image.astype('''uint8'''   )





				def    _lowerCamelCase       ( self :  List[str]   ,SCREAMING_SNAKE_CASE_ :  Optional[int]   ,SCREAMING_SNAKE_CASE_ :  Optional[Any]   ):
										assert brightness_factor >= -1.0 and brightness_factor <= 1.0
										snake_case__							:       Optional[int]				      =       mplc.to_rgb(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       List[Any]				      =       colorsys.rgb_to_hls(*mplc.to_rgb(SCREAMING_SNAKE_CASE_   )   )
										snake_case__							:       Optional[int]				      =       polygon_color[1] + (brightness_factor * polygon_color[1])
										snake_case__							:       Dict				      =       0.0 if modified_lightness < 0.0 else modified_lightness
										snake_case__							:       List[Any]				      =       1.0 if modified_lightness > 1.0 else modified_lightness
										snake_case__							:       Optional[int]				      =       colorsys.hls_to_rgb(polygon_color[0]   ,SCREAMING_SNAKE_CASE_   ,polygon_color[2]   )
										return modified_color







_lowercase						   =     (
    np.array(
        [
            0.0_00,
            0.4_47,
            0.7_41,
            0.8_50,
            0.3_25,
            0.0_98,
            0.9_29,
            0.6_94,
            0.1_25,
            0.4_94,
            0.1_84,
            0.5_56,
            0.4_66,
            0.6_74,
            0.1_88,
            0.3_01,
            0.7_45,
            0.9_33,
            0.6_35,
            0.0_78,
            0.1_84,
            0.3_00,
            0.3_00,
            0.3_00,
            0.6_00,
            0.6_00,
            0.6_00,
            1.0_00,
            0.0_00,
            0.0_00,
            1.0_00,
            0.5_00,
            0.0_00,
            0.7_49,
            0.7_49,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            1.0_00,
            0.6_67,
            0.0_00,
            1.0_00,
            0.3_33,
            0.3_33,
            0.0_00,
            0.3_33,
            0.6_67,
            0.0_00,
            0.3_33,
            1.0_00,
            0.0_00,
            0.6_67,
            0.3_33,
            0.0_00,
            0.6_67,
            0.6_67,
            0.0_00,
            0.6_67,
            1.0_00,
            0.0_00,
            1.0_00,
            0.3_33,
            0.0_00,
            1.0_00,
            0.6_67,
            0.0_00,
            1.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.3_33,
            0.5_00,
            0.0_00,
            0.6_67,
            0.5_00,
            0.0_00,
            1.0_00,
            0.5_00,
            0.3_33,
            0.0_00,
            0.5_00,
            0.3_33,
            0.3_33,
            0.5_00,
            0.3_33,
            0.6_67,
            0.5_00,
            0.3_33,
            1.0_00,
            0.5_00,
            0.6_67,
            0.0_00,
            0.5_00,
            0.6_67,
            0.3_33,
            0.5_00,
            0.6_67,
            0.6_67,
            0.5_00,
            0.6_67,
            1.0_00,
            0.5_00,
            1.0_00,
            0.0_00,
            0.5_00,
            1.0_00,
            0.3_33,
            0.5_00,
            1.0_00,
            0.6_67,
            0.5_00,
            1.0_00,
            1.0_00,
            0.5_00,
            0.0_00,
            0.3_33,
            1.0_00,
            0.0_00,
            0.6_67,
            1.0_00,
            0.0_00,
            1.0_00,
            1.0_00,
            0.3_33,
            0.0_00,
            1.0_00,
            0.3_33,
            0.3_33,
            1.0_00,
            0.3_33,
            0.6_67,
            1.0_00,
            0.3_33,
            1.0_00,
            1.0_00,
            0.6_67,
            0.0_00,
            1.0_00,
            0.6_67,
            0.3_33,
            1.0_00,
            0.6_67,
            0.6_67,
            1.0_00,
            0.6_67,
            1.0_00,
            1.0_00,
            1.0_00,
            0.0_00,
            1.0_00,
            1.0_00,
            0.3_33,
            1.0_00,
            1.0_00,
            0.6_67,
            1.0_00,
            0.3_33,
            0.0_00,
            0.0_00,
            0.5_00,
            0.0_00,
            0.0_00,
            0.6_67,
            0.0_00,
            0.0_00,
            0.8_33,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            0.1_67,
            0.0_00,
            0.0_00,
            0.3_33,
            0.0_00,
            0.0_00,
            0.5_00,
            0.0_00,
            0.0_00,
            0.6_67,
            0.0_00,
            0.0_00,
            0.8_33,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            0.1_67,
            0.0_00,
            0.0_00,
            0.3_33,
            0.0_00,
            0.0_00,
            0.5_00,
            0.0_00,
            0.0_00,
            0.6_67,
            0.0_00,
            0.0_00,
            0.8_33,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            0.1_43,
            0.1_43,
            0.1_43,
            0.8_57,
            0.8_57,
            0.8_57,
            1.0_00,
            1.0_00,
            1.0_00,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)








"""simple docstring"""





import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()

class    __lowercase							(      unittest.TestCase						):


				'''simple docstring'''


				def    _lowerCamelCase       ( self :  Tuple   ):
										# clean up the VRAM after each test
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()

				@property
				def    _lowerCamelCase       ( self :  List[Any]   ):
										snake_case__							:       int				      =       1
										snake_case__							:       Any				      =       3
										snake_case__							:       Any				      =       (3_2, 3_2)

										snake_case__							:       int				      =       floats_tensor((batch_size, num_channels) + sizes   ,rng=random.Random(0   )   ).to(SCREAMING_SNAKE_CASE_   )
										return image

				@property
				def    _lowerCamelCase       ( self :  Optional[Any]   ):
										torch.manual_seed(0   )
										snake_case__							:       int				      =       UNetaDConditionModel(
										    block_out_channels=(3_2, 6_4)   ,layers_per_block=2   ,sample_size=3_2   ,in_channels=4   ,out_channels=4   ,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')   ,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')   ,cross_attention_dim=3_2   ,)
										return model

				@property
				def    _lowerCamelCase       ( self :  List[str]   ):
										torch.manual_seed(0   )
										snake_case__							:       int				      =       AutoencoderKL(
										    block_out_channels=[3_2, 6_4]   ,in_channels=3   ,out_channels=3   ,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']   ,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']   ,latent_channels=4   ,)
										return model

				@property
				def    _lowerCamelCase       ( self :  Optional[int]   ):
										torch.manual_seed(0   )
										snake_case__							:       str				      =       CLIPTextConfig(
										    bos_token_id=0   ,eos_token_id=2   ,hidden_size=3_2   ,intermediate_size=3_7   ,layer_norm_eps=1E-05   ,num_attention_heads=4   ,num_hidden_layers=5   ,pad_token_id=1   ,vocab_size=1_0_0_0   ,)
										return CLIPTextModel(SCREAMING_SNAKE_CASE_   )

				@property
				def    _lowerCamelCase       ( self :  Optional[int]   ):
										def extract(*SCREAMING_SNAKE_CASE_ :  Optional[int]   ,**SCREAMING_SNAKE_CASE_ :  Optional[Any]   ):

																class    __lowercase							:


																				'''simple docstring'''


																				def __init__( self :  Optional[int]   ):
																										snake_case__							:       List[str]				      =       torch.ones([0]   )





																				def    _lowerCamelCase       ( self :  Optional[int]   ,SCREAMING_SNAKE_CASE_ :  str   ):
																										self.pixel_values.to(SCREAMING_SNAKE_CASE_   )
																										return self







																return Out()

										return extract

				def    _lowerCamelCase       ( self :  Dict   ):
										snake_case__							:       Tuple				      =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
										snake_case__							:       Union[str, Any]				      =       self.dummy_cond_unet
										snake_case__							:       List[Any]				      =       DDIMScheduler(
										    beta_start=0.00085   ,beta_end=0.012   ,beta_schedule='''scaled_linear'''   ,clip_sample=SCREAMING_SNAKE_CASE_   ,set_alpha_to_one=SCREAMING_SNAKE_CASE_   ,)

										snake_case__							:       Union[str, Any]				      =       self.dummy_vae
										snake_case__							:       Union[str, Any]				      =       self.dummy_text_encoder
										snake_case__							:       Union[str, Any]				      =       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )

										# make sure here that pndm scheduler skips prk
										snake_case__							:       Union[str, Any]				      =       StableDiffusionPipeline(
										    unet=SCREAMING_SNAKE_CASE_   ,scheduler=SCREAMING_SNAKE_CASE_   ,vae=SCREAMING_SNAKE_CASE_   ,text_encoder=SCREAMING_SNAKE_CASE_   ,tokenizer=SCREAMING_SNAKE_CASE_   ,safety_checker=SCREAMING_SNAKE_CASE_   ,feature_extractor=self.dummy_extractor   ,)
										snake_case__							:       Any				      =       sd_pipe.to(SCREAMING_SNAKE_CASE_   )
										sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       Union[str, Any]				      =       '''A painting of a squirrel eating a burger'''

										snake_case__							:       int				      =       torch.Generator(device=SCREAMING_SNAKE_CASE_   ).manual_seed(0   )
										snake_case__							:       List[Any]				      =       sd_pipe([prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   )
										snake_case__							:       List[str]				      =       output.images

										snake_case__							:       Any				      =       torch.Generator(device=SCREAMING_SNAKE_CASE_   ).manual_seed(0   )
										snake_case__							:       Optional[Any]				      =       sd_pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   ,return_dict=SCREAMING_SNAKE_CASE_   ,)[0]

										snake_case__							:       str				      =       image[0, -3:, -3:, -1]
										snake_case__							:       str				      =       image_from_tuple[0, -3:, -3:, -1]

										assert image.shape == (1, 6_4, 6_4, 3)
										snake_case__							:       int				      =       np.array([0.5753, 0.6114, 0.5001, 0.5034, 0.5470, 0.4729, 0.4971, 0.4867, 0.4867]   )

										assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2
										assert np.abs(image_from_tuple_slice.flatten() - expected_slice   ).max() < 1E-2

				def    _lowerCamelCase       ( self :  Dict   ):
										snake_case__							:       str				      =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
										snake_case__							:       Optional[Any]				      =       self.dummy_cond_unet
										snake_case__							:       Optional[Any]				      =       PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Optional[Any]				      =       self.dummy_vae
										snake_case__							:       Any				      =       self.dummy_text_encoder
										snake_case__							:       str				      =       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )

										# make sure here that pndm scheduler skips prk
										snake_case__							:       Dict				      =       StableDiffusionPipeline(
										    unet=SCREAMING_SNAKE_CASE_   ,scheduler=SCREAMING_SNAKE_CASE_   ,vae=SCREAMING_SNAKE_CASE_   ,text_encoder=SCREAMING_SNAKE_CASE_   ,tokenizer=SCREAMING_SNAKE_CASE_   ,safety_checker=SCREAMING_SNAKE_CASE_   ,feature_extractor=self.dummy_extractor   ,)
										snake_case__							:       Any				      =       sd_pipe.to(SCREAMING_SNAKE_CASE_   )
										sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       Dict				      =       '''A painting of a squirrel eating a burger'''
										snake_case__							:       int				      =       torch.Generator(device=SCREAMING_SNAKE_CASE_   ).manual_seed(0   )
										snake_case__							:       Optional[int]				      =       sd_pipe([prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   )

										snake_case__							:       int				      =       output.images

										snake_case__							:       Dict				      =       torch.Generator(device=SCREAMING_SNAKE_CASE_   ).manual_seed(0   )
										snake_case__							:       Optional[int]				      =       sd_pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   ,return_dict=SCREAMING_SNAKE_CASE_   ,)[0]

										snake_case__							:       str				      =       image[0, -3:, -3:, -1]
										snake_case__							:       int				      =       image_from_tuple[0, -3:, -3:, -1]

										assert image.shape == (1, 6_4, 6_4, 3)
										snake_case__							:       Optional[int]				      =       np.array([0.5122, 0.5712, 0.4825, 0.5053, 0.5646, 0.4769, 0.5179, 0.4894, 0.4994]   )

										assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2
										assert np.abs(image_from_tuple_slice.flatten() - expected_slice   ).max() < 1E-2

				def    _lowerCamelCase       ( self :  List[str]   ):
										snake_case__							:       Optional[Any]				      =       StableDiffusionPipeline.from_pretrained(
										    '''hf-internal-testing/tiny-stable-diffusion-lms-pipe'''   ,safety_checker=SCREAMING_SNAKE_CASE_   )
										assert isinstance(SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   )
										assert isinstance(pipe.scheduler   ,SCREAMING_SNAKE_CASE_   )
										assert pipe.safety_checker is None

										snake_case__							:       Optional[Any]				      =       pipe('''example prompt'''   ,num_inference_steps=2   ).images[0]
										assert image is not None

										# check that there's no error when saving a pipeline with one of the models being None
										with tempfile.TemporaryDirectory() as tmpdirname:
																pipe.save_pretrained(SCREAMING_SNAKE_CASE_   )
																snake_case__							:       int				      =       StableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE_   )

										# sanity check that the pipeline still works
										assert pipe.safety_checker is None
										snake_case__							:       Optional[Any]				      =       pipe('''example prompt'''   ,num_inference_steps=2   ).images[0]
										assert image is not None





				@unittest.skipIf(torch_device != '''cuda'''   ,'''This test requires a GPU'''   )
				def    _lowerCamelCase       ( self :  List[Any]   ):
										snake_case__							:       Optional[Any]				      =       self.dummy_cond_unet
										snake_case__							:       int				      =       PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Dict				      =       self.dummy_vae
										snake_case__							:       Optional[Any]				      =       self.dummy_text_encoder
										snake_case__							:       Union[str, Any]				      =       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )

										# put models in fp16
										snake_case__							:       int				      =       unet.half()
										snake_case__							:       Any				      =       vae.half()
										snake_case__							:       int				      =       bert.half()

										# make sure here that pndm scheduler skips prk
										snake_case__							:       Union[str, Any]				      =       StableDiffusionPipeline(
										    unet=SCREAMING_SNAKE_CASE_   ,scheduler=SCREAMING_SNAKE_CASE_   ,vae=SCREAMING_SNAKE_CASE_   ,text_encoder=SCREAMING_SNAKE_CASE_   ,tokenizer=SCREAMING_SNAKE_CASE_   ,safety_checker=SCREAMING_SNAKE_CASE_   ,feature_extractor=self.dummy_extractor   ,)
										snake_case__							:       Tuple				      =       sd_pipe.to(SCREAMING_SNAKE_CASE_   )
										sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       List[Any]				      =       '''A painting of a squirrel eating a burger'''
										snake_case__							:       Optional[Any]				      =       sd_pipe([prompt]   ,num_inference_steps=2   ,output_type='''np'''   ).images

										assert image.shape == (1, 6_4, 6_4, 3)







@nightly
@require_torch_gpu
class    __lowercase							(      unittest.TestCase						):


				'''simple docstring'''


				def    _lowerCamelCase       ( self :  Any   ):
										# clean up the VRAM after each test
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()

				def    _lowerCamelCase       ( self :  Union[str, Any]   ):
										snake_case__							:       Optional[Any]				      =       '''cuda'''
										snake_case__							:       str				      =       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''   )
										snake_case__							:       Optional[int]				      =       pipe.to(SCREAMING_SNAKE_CASE_   )
										pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       Union[str, Any]				      =       '''a photo of a cat'''
										snake_case__							:       int				      =       {
										    '''editing_prompt''': ['''sunglasses'''],
										    '''reverse_editing_direction''': [False],
										    '''edit_warmup_steps''': 1_0,
										    '''edit_guidance_scale''': 6,
										    '''edit_threshold''': 0.95,
										    '''edit_momentum_scale''': 0.5,
										    '''edit_mom_beta''': 0.6,
										}

										snake_case__							:       Optional[Any]				      =       3
										snake_case__							:       Any				      =       7

										# no sega enabled
										snake_case__							:       str				      =       torch.Generator(SCREAMING_SNAKE_CASE_   )
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Optional[Any]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,)

										snake_case__							:       Tuple				      =       output.images
										snake_case__							:       Optional[Any]				      =       image[0, -3:, -3:, -1]
										snake_case__							:       Union[str, Any]				      =       [
										    0.34673113,
										    0.38492733,
										    0.37597352,
										    0.34086335,
										    0.35650748,
										    0.35579205,
										    0.3384763,
										    0.34340236,
										    0.3573271,
										]

										assert image.shape == (1, 5_1_2, 5_1_2, 3)

										assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2

										# with sega enabled
										# generator = torch.manual_seed(seed)
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Tuple				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,**SCREAMING_SNAKE_CASE_   ,)

										snake_case__							:       int				      =       output.images
										snake_case__							:       int				      =       image[0, -3:, -3:, -1]
										snake_case__							:       Union[str, Any]				      =       [
										    0.41887826,
										    0.37728766,
										    0.30138272,
										    0.41416335,
										    0.41664985,
										    0.36283392,
										    0.36191246,
										    0.43364465,
										    0.43001732,
										]

										assert image.shape == (1, 5_1_2, 5_1_2, 3)

										assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2

				def    _lowerCamelCase       ( self :  int   ):
										snake_case__							:       int				      =       '''cuda'''
										snake_case__							:       Optional[Any]				      =       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''   )
										snake_case__							:       Optional[int]				      =       pipe.to(SCREAMING_SNAKE_CASE_   )
										pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       int				      =       '''an image of a crowded boulevard, realistic, 4k'''
										snake_case__							:       Tuple				      =       {
										    '''editing_prompt''': '''crowd, crowded, people''',
										    '''reverse_editing_direction''': True,
										    '''edit_warmup_steps''': 1_0,
										    '''edit_guidance_scale''': 8.3,
										    '''edit_threshold''': 0.9,
										    '''edit_momentum_scale''': 0.5,
										    '''edit_mom_beta''': 0.6,
										}

										snake_case__							:       Optional[Any]				      =       9
										snake_case__							:       Union[str, Any]				      =       7

										# no sega enabled
										snake_case__							:       Any				      =       torch.Generator(SCREAMING_SNAKE_CASE_   )
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Optional[int]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,)

										snake_case__							:       int				      =       output.images
										snake_case__							:       Union[str, Any]				      =       image[0, -3:, -3:, -1]
										snake_case__							:       Union[str, Any]				      =       [
										    0.43497998,
										    0.91814065,
										    0.7540739,
										    0.55580205,
										    0.8467265,
										    0.5389691,
										    0.62574506,
										    0.58897763,
										    0.50926757,
										]

										assert image.shape == (1, 5_1_2, 5_1_2, 3)

										assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2

										# with sega enabled
										# generator = torch.manual_seed(seed)
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Union[str, Any]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,**SCREAMING_SNAKE_CASE_   ,)

										snake_case__							:       int				      =       output.images
										snake_case__							:       int				      =       image[0, -3:, -3:, -1]
										snake_case__							:       Any				      =       [
										    0.3089719,
										    0.30500144,
										    0.29016042,
										    0.30630964,
										    0.325687,
										    0.29419225,
										    0.2908091,
										    0.28723598,
										    0.27696294,
										]

										assert image.shape == (1, 5_1_2, 5_1_2, 3)

										assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2

				def    _lowerCamelCase       ( self :  Tuple   ):
										snake_case__							:       Optional[int]				      =       '''cuda'''
										snake_case__							:       Union[str, Any]				      =       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''   )
										snake_case__							:       Tuple				      =       pipe.to(SCREAMING_SNAKE_CASE_   )
										pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       List[str]				      =       '''a castle next to a river'''
										snake_case__							:       Dict				      =       {
										    '''editing_prompt''': ['''boat on a river, boat''', '''monet, impression, sunrise'''],
										    '''reverse_editing_direction''': False,
										    '''edit_warmup_steps''': [1_5, 1_8],
										    '''edit_guidance_scale''': 6,
										    '''edit_threshold''': [0.9, 0.8],
										    '''edit_momentum_scale''': 0.5,
										    '''edit_mom_beta''': 0.6,
										}

										snake_case__							:       Dict				      =       4_8
										snake_case__							:       int				      =       7

										# no sega enabled
										snake_case__							:       Optional[int]				      =       torch.Generator(SCREAMING_SNAKE_CASE_   )
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       List[str]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,)

										snake_case__							:       str				      =       output.images
										snake_case__							:       int				      =       image[0, -3:, -3:, -1]
										snake_case__							:       List[str]				      =       [
										    0.75163555,
										    0.76037145,
										    0.61785,
										    0.9189673,
										    0.8627701,
										    0.85189694,
										    0.8512813,
										    0.87012076,
										    0.8312857,
										]

										assert image.shape == (1, 5_1_2, 5_1_2, 3)

										assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2

										# with sega enabled
										# generator = torch.manual_seed(seed)
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       List[str]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,**SCREAMING_SNAKE_CASE_   ,)

										snake_case__							:       Union[str, Any]				      =       output.images
										snake_case__							:       Any				      =       image[0, -3:, -3:, -1]
										snake_case__							:       List[str]				      =       [
										    0.73553365,
										    0.7537271,
										    0.74341905,
										    0.66480356,
										    0.6472925,
										    0.63039416,
										    0.64812905,
										    0.6749717,
										    0.6517102,
										]

										assert image.shape == (1, 5_1_2, 5_1_2, 3)

										assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2





				def    _lowerCamelCase       ( self :  str   ):
										snake_case__							:       Any				      =       '''cuda'''
										snake_case__							:       Any				      =       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''   ,torch_dtype=torch.floataa   )
										snake_case__							:       Dict				      =       pipe.to(SCREAMING_SNAKE_CASE_   )
										pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_   )

										snake_case__							:       List[Any]				      =       '''a photo of a cat'''
										snake_case__							:       Dict				      =       {
										    '''editing_prompt''': ['''sunglasses'''],
										    '''reverse_editing_direction''': [False],
										    '''edit_warmup_steps''': 1_0,
										    '''edit_guidance_scale''': 6,
										    '''edit_threshold''': 0.95,
										    '''edit_momentum_scale''': 0.5,
										    '''edit_mom_beta''': 0.6,
										}

										snake_case__							:       Dict				      =       3
										snake_case__							:       Optional[int]				      =       7

										# no sega enabled
										snake_case__							:       Dict				      =       torch.Generator(SCREAMING_SNAKE_CASE_   )
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       List[str]				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,)

										snake_case__							:       int				      =       output.images
										snake_case__							:       int				      =       image[0, -3:, -3:, -1]
										snake_case__							:       List[str]				      =       [
										    0.34887695,
										    0.3876953,
										    0.375,
										    0.34423828,
										    0.3581543,
										    0.35717773,
										    0.3383789,
										    0.34570312,
										    0.359375,
										]

										assert image.shape == (1, 5_1_2, 5_1_2, 3)

										assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2

										# with sega enabled
										# generator = torch.manual_seed(seed)
										generator.manual_seed(SCREAMING_SNAKE_CASE_   )
										snake_case__							:       Tuple				      =       pipe(
										    [prompt]   ,generator=SCREAMING_SNAKE_CASE_   ,guidance_scale=SCREAMING_SNAKE_CASE_   ,num_inference_steps=5_0   ,output_type='''np'''   ,width=5_1_2   ,height=5_1_2   ,**SCREAMING_SNAKE_CASE_   ,)

										snake_case__							:       Union[str, Any]				      =       output.images
										snake_case__							:       Tuple				      =       image[0, -3:, -3:, -1]
										snake_case__							:       Tuple				      =       [
										    0.42285156,
										    0.36914062,
										    0.29077148,
										    0.42041016,
										    0.41918945,
										    0.35498047,
										    0.3618164,
										    0.4423828,
										    0.43115234,
										]

										assert image.shape == (1, 5_1_2, 5_1_2, 3)

										assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2


