"""simple docstring"""




import unittest

import numpy as np

from transformers import DistilBertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
			import jax.numpy as jnp

			from transformers.models.distilbert.modeling_flax_distilbert import (
			    FlaxDistilBertForMaskedLM,
			    FlaxDistilBertForMultipleChoice,
			    FlaxDistilBertForQuestionAnswering,
			    FlaxDistilBertForSequenceClassification,
			    FlaxDistilBertForTokenClassification,
			    FlaxDistilBertModel,
			)

class    a_   (  unittest.TestCase      ):




					def __init__(						self    :  Union[str, Any]	,    snake_case__    :  int	,    snake_case__    :  List[Any]=13	,    snake_case__    :  Optional[Any]=7	,    snake_case__    :  Any=True	,    snake_case__    :  str=True	,    snake_case__    :  Optional[Any]=True	,    snake_case__    :  Optional[Any]=True	,    snake_case__    :  Optional[Any]=99	,    snake_case__    :  int=32	,    snake_case__    :  Optional[int]=5	,    snake_case__    :  int=4	,    snake_case__    :  Optional[Any]=37	,    snake_case__    :  List[Any]="gelu"	,    snake_case__    :  int=0.1	,    snake_case__    :  Dict=0.1	,    snake_case__    :  List[Any]=512	,    snake_case__    :  str=16	,    snake_case__    :  List[str]=2	,    snake_case__    :  Tuple=0.02	,    snake_case__    :  List[Any]=4	,    ):
							lowerCAmelCase__   = parent
							lowerCAmelCase__   = batch_size
							lowerCAmelCase__   = seq_length
							lowerCAmelCase__   = is_training
							lowerCAmelCase__   = use_attention_mask
							lowerCAmelCase__   = use_token_type_ids
							lowerCAmelCase__   = use_labels
							lowerCAmelCase__   = vocab_size
							lowerCAmelCase__   = hidden_size
							lowerCAmelCase__   = num_hidden_layers
							lowerCAmelCase__   = num_attention_heads
							lowerCAmelCase__   = intermediate_size
							lowerCAmelCase__   = hidden_act
							lowerCAmelCase__   = hidden_dropout_prob
							lowerCAmelCase__   = attention_probs_dropout_prob
							lowerCAmelCase__   = max_position_embeddings
							lowerCAmelCase__   = type_vocab_size
							lowerCAmelCase__   = type_sequence_label_size
							lowerCAmelCase__   = initializer_range
							lowerCAmelCase__   = num_choices




					def     _SCREAMING_SNAKE_CASE    (						self    :  int  ):
							lowerCAmelCase__   = ids_tensor([self.batch_size, self.seq_length]	,    self.vocab_size  )

							lowerCAmelCase__   = None
							if self.use_attention_mask:
									lowerCAmelCase__   = random_attention_mask([self.batch_size, self.seq_length]  )

							lowerCAmelCase__   = DistilBertConfig(
							    vocab_size=self.vocab_size	,    dim=self.hidden_size	,    n_layers=self.num_hidden_layers	,    n_heads=self.num_attention_heads	,    hidden_dim=self.intermediate_size	,    hidden_act=self.hidden_act	,    dropout=self.hidden_dropout_prob	,    attention_dropout=self.attention_probs_dropout_prob	,    max_position_embeddings=self.max_position_embeddings	,    initializer_range=self.initializer_range	,    tie_weights_=snake_case__	,    )

							return config, input_ids, attention_mask




					def     _SCREAMING_SNAKE_CASE    (						self    :  Any  ):
							lowerCAmelCase__   = self.prepare_config_and_inputs()
							lowerCAmelCase__ ,       lowerCAmelCase__ ,       lowerCAmelCase__   = config_and_inputs
							lowerCAmelCase__   = {"""input_ids""": input_ids, """attention_mask""": attention_mask}
							return config, inputs_dict

@require_flax
class    a_   (  __UpperCamelCase			,		unittest.TestCase      ):
					UpperCamelCase_			:						str      =     (
					    (
					        FlaxDistilBertModel,
					        FlaxDistilBertForMaskedLM,
					        FlaxDistilBertForMultipleChoice,
					        FlaxDistilBertForQuestionAnswering,
					        FlaxDistilBertForSequenceClassification,
					        FlaxDistilBertForTokenClassification,
					        FlaxDistilBertForQuestionAnswering,
					    )
					    if is_flax_available()
					    else ()
					)




					def     _SCREAMING_SNAKE_CASE    (						self    :  List[str]  ):
							lowerCAmelCase__   = FlaxDistilBertModelTester(self  )




					@slow
					def     _SCREAMING_SNAKE_CASE    (						self    :  List[Any]  ):
							for model_class_name in self.all_model_classes:
									lowerCAmelCase__   = model_class_name.from_pretrained("""distilbert-base-uncased"""  )
									lowerCAmelCase__   = model(np.ones((1, 1)  )  )
									self.assertIsNotNone(snake_case__  )

@require_flax
class    a_   (  unittest.TestCase      ):




					@slow
					def     _SCREAMING_SNAKE_CASE    (						self    :  Optional[Any]  ):
							lowerCAmelCase__   = FlaxDistilBertModel.from_pretrained("""distilbert-base-uncased"""  )
							lowerCAmelCase__   = np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]  )
							lowerCAmelCase__   = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
							lowerCAmelCase__   = model(snake_case__	,    attention_mask=snake_case__  )[0]
							lowerCAmelCase__   = (1, 11, 768)
							self.assertEqual(output.shape	,    snake_case__  )
							lowerCAmelCase__   = np.array([[[-0.1639, 0.3299, 0.1648], [-0.1746, 0.3289, 0.1710], [-0.1884, 0.3357, 0.1810]]]  )

							self.assertTrue(jnp.allclose(output[:, 1:4, 1:4]	,    snake_case__	,    atol=1E-4  )  )





"""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


__lowerCAmelCase     :				Dict    				=    "CompVis/stable-diffusion-v1-1"
__lowerCAmelCase     :				int    				=    "CompVis/stable-diffusion-v1-2"
__lowerCAmelCase     :				int    				=    "CompVis/stable-diffusion-v1-3"
__lowerCAmelCase     :				Union[str, Any]    				=    "CompVis/stable-diffusion-v1-4"

class    a_   (  __UpperCamelCase      ):




					def __init__(						self    :  List[Any]	,    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	,    ):
							super()._init_()

							lowerCAmelCase__   = StableDiffusionPipeline.from_pretrained(snake_case__  )
							lowerCAmelCase__   = StableDiffusionPipeline.from_pretrained(snake_case__  )
							lowerCAmelCase__   = StableDiffusionPipeline.from_pretrained(snake_case__  )
							lowerCAmelCase__   = 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     _SCREAMING_SNAKE_CASE    (						self    :  Tuple  ):
							return {k: getattr(self	,    snake_case__  ) for k in self.config.keys() if not k.startswith("""_"""  )}




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




					def     _SCREAMING_SNAKE_CASE    (						self    :  int  ):
							self.enable_attention_slicing(snake_case__  )




					@torch.no_grad()
					def     _SCREAMING_SNAKE_CASE    (						self    :  int	,    snake_case__    :  Union[str, List[str]]	,    snake_case__    :  int = 512	,    snake_case__    :  int = 512	,    snake_case__    :  int = 50	,    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__    :  List[Any]	,    ):
							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     _SCREAMING_SNAKE_CASE    (						self    :  Tuple	,    snake_case__    :  Union[str, List[str]]	,    snake_case__    :  int = 512	,    snake_case__    :  int = 512	,    snake_case__    :  int = 50	,    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	,    ):
							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     _SCREAMING_SNAKE_CASE    (						self    :  Optional[int]	,    snake_case__    :  Union[str, List[str]]	,    snake_case__    :  int = 512	,    snake_case__    :  int = 512	,    snake_case__    :  int = 50	,    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[Any]	,    ):
							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     _SCREAMING_SNAKE_CASE    (						self    :  List[str]	,    snake_case__    :  Union[str, List[str]]	,    snake_case__    :  int = 512	,    snake_case__    :  int = 512	,    snake_case__    :  int = 50	,    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__    :  str	,    ):
							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     _SCREAMING_SNAKE_CASE    (						self    :  Union[str, Any]	,    snake_case__    :  Union[str, List[str]]	,    snake_case__    :  int = 512	,    snake_case__    :  int = 512	,    snake_case__    :  int = 50	,    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[Any]	,    ):
							lowerCAmelCase__   = """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
							lowerCAmelCase__   = 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
							lowerCAmelCase__   = 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
							lowerCAmelCase__   = 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
							lowerCAmelCase__   = 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]]  )




