
'''simple docstring'''

import unittest

from transformers import SpeechaTextaConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers.models.speech_to_text_a.modeling_speech_to_text_a import (
							    SpeechaTextaDecoder,
							    SpeechaTextaForCausalLM,
							)






@require_torch
class 				A       :





	def __init__(   self     :    Union[str, Any] ,							__magic_name__     :    str ,							__magic_name__     :    Tuple=99 ,							__magic_name__     :    List[Any]=13 ,							__magic_name__     :    Dict=16 ,							__magic_name__     :    Dict=7 ,							__magic_name__     :    Tuple=True ,							__magic_name__     :    Optional[Any]=True ,							__magic_name__     :    List[Any]=True ,							__magic_name__     :    str=False ,							__magic_name__     :    Tuple=True ,							__magic_name__     :    Optional[int]=2 ,							__magic_name__     :    Optional[Any]=32 ,							__magic_name__     :    Dict=4 ,							__magic_name__     :    List[str]=4 ,							__magic_name__     :    str=30 ,							__magic_name__     :    Optional[Any]=0 ,							__magic_name__     :    Dict=1 ,							__magic_name__     :    Optional[Any]=2 ,							__magic_name__     :    List[str]=None ,							):


				"""simple docstring"""

				lowerCAmelCase__									=							parent
				lowerCAmelCase__									=							batch_size
				lowerCAmelCase__									=							decoder_seq_length
				# For common tests
				lowerCAmelCase__									=							self.decoder_seq_length
				lowerCAmelCase__									=							is_training
				lowerCAmelCase__									=							use_attention_mask
				lowerCAmelCase__									=							use_labels

				lowerCAmelCase__									=							vocab_size
				lowerCAmelCase__									=							d_model
				lowerCAmelCase__									=							d_model
				lowerCAmelCase__									=							decoder_layers
				lowerCAmelCase__									=							decoder_layers
				lowerCAmelCase__									=							decoder_ffn_dim
				lowerCAmelCase__									=							decoder_attention_heads
				lowerCAmelCase__									=							decoder_attention_heads
				lowerCAmelCase__									=							eos_token_id
				lowerCAmelCase__									=							bos_token_id
				lowerCAmelCase__									=							pad_token_id
				lowerCAmelCase__									=							decoder_start_token_id
				lowerCAmelCase__									=							use_cache
				lowerCAmelCase__									=							max_position_embeddings

				lowerCAmelCase__									=							None
				lowerCAmelCase__									=							decoder_seq_length
				lowerCAmelCase__									=							2
				lowerCAmelCase__									=							1





	def 							__SCREAMING_SNAKE_CASE					(   self     :    Union[str, Any]							):


				"""simple docstring"""

				lowerCAmelCase__									=							ids_tensor([self.batch_size, self.decoder_seq_length] ,							self.vocab_size							)

				lowerCAmelCase__									=							None
				if self.use_attention_mask:
							lowerCAmelCase__									=							ids_tensor([self.batch_size, self.decoder_seq_length] ,							vocab_size=2							)

				lowerCAmelCase__									=							None
				if self.use_labels:
							lowerCAmelCase__									=							ids_tensor([self.batch_size, self.decoder_seq_length] ,							self.vocab_size							)

				lowerCAmelCase__									=							SpeechaTextaConfig(
				    vocab_size=self.vocab_size ,							d_model=self.d_model ,							decoder_layers=self.decoder_layers ,							decoder_ffn_dim=self.decoder_ffn_dim ,							decoder_attention_heads=self.decoder_attention_heads ,							eos_token_id=self.eos_token_id ,							bos_token_id=self.bos_token_id ,							use_cache=self.use_cache ,							pad_token_id=self.pad_token_id ,							decoder_start_token_id=self.decoder_start_token_id ,							max_position_embeddings=self.max_position_embeddings ,							)

				return (
				    config,
				    input_ids,
				    attention_mask,
				    lm_labels,
				)





	def 							__SCREAMING_SNAKE_CASE					(   self     :    int ,							__magic_name__     :    Any ,							__magic_name__     :    Any ,							__magic_name__     :    Optional[int] ,							__magic_name__     :    Optional[int] ,							):


				"""simple docstring"""

				lowerCAmelCase__									=							True
				lowerCAmelCase__									=							SpeechaTextaDecoder(config=__magic_name__							).to(__magic_name__							).eval()
				lowerCAmelCase__									=							input_ids[:2]

				input_ids[input_ids == 0] += 1
				# first forward pass
				lowerCAmelCase__									=							model(__magic_name__ ,							use_cache=__magic_name__							)
				lowerCAmelCase__									=							model(__magic_name__							)
				lowerCAmelCase__									=							model(__magic_name__ ,							use_cache=__magic_name__							)

				self.parent.assertTrue(len(__magic_name__							) == len(__magic_name__							)							)
				self.parent.assertTrue(len(__magic_name__							) == len(__magic_name__							) + 1							)

				lowerCAmelCase__									=							outputs["past_key_values"]

				# create hypothetical next token and extent to next_input_ids
				lowerCAmelCase__									=							ids_tensor((2, 1) ,							config.vocab_size - 1							) + 1

				# append to next input_ids and
				lowerCAmelCase__									=							torch.cat([input_ids, next_tokens] ,							dim=-1							)

				print(__magic_name__							)

				lowerCAmelCase__									=							model(__magic_name__							)["last_hidden_state"]
				lowerCAmelCase__									=							model(__magic_name__ ,							past_key_values=__magic_name__							)["last_hidden_state"]

				# select random slice
				lowerCAmelCase__									=							ids_tensor((1,) ,							output_from_past.shape[-1]							).item()
				lowerCAmelCase__									=							output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
				lowerCAmelCase__									=							output_from_past[:, 0, random_slice_idx].detach()

				# test that outputs are equal for slice
				assert torch.allclose(__magic_name__ ,							__magic_name__ ,							atol=1E-3							)







	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[Any]							):


				"""simple docstring"""

				lowerCAmelCase__									=							self.prepare_config_and_inputs()
				(
				    lowerCAmelCase__						
				)									=							config_and_inputs

				lowerCAmelCase__									=							{
				    "input_ids": input_ids,
				    "attention_mask": attention_mask,
				}
				return config, inputs_dict






@require_torch
class 				A       (		SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__					, unittest.TestCase      ):
	snake_case__ :Dict				       =       (SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
	snake_case__ :Optional[int]				       =       (SpeechaTextaForCausalLM,) if is_torch_available() else ()
	snake_case__ :Union[str, Any]				       =       {'text-generation': SpeechaTextaForCausalLM} if is_torch_available() else {}
	snake_case__ :int				       =       True
	snake_case__ :Optional[Any]				       =       False





	def 							__SCREAMING_SNAKE_CASE					(   self     :    str ,							):


				"""simple docstring"""

				lowerCAmelCase__									=							SpeechaTextaStandaloneDecoderModelTester(self ,							is_training=__magic_name__							)
				lowerCAmelCase__									=							ConfigTester(self ,							config_class=__magic_name__							)





	def 							__SCREAMING_SNAKE_CASE					(   self     :    List[str]							):


				"""simple docstring"""

				pass





	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[Any]							):


				"""simple docstring"""

				pass





	def 							__SCREAMING_SNAKE_CASE					(   self     :    Union[str, Any]							):


				"""simple docstring"""

				pass





	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[Any]							):


				"""simple docstring"""

				self.config_tester.run_common_tests()





	def 							__SCREAMING_SNAKE_CASE					(   self     :    Dict							):


				"""simple docstring"""

				lowerCAmelCase__									=							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_decoder_model_past(*__magic_name__							)







	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[int]							):


				"""simple docstring"""

				return







'''simple docstring'''

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

import PIL.Image
import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionImgaImgPipeline,
    StableDiffusionInpaintPipelineLegacy,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.configuration_utils import FrozenDict
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.utils import deprecate, logging


UpperCAmelCase__				:	Tuple					=						logging.get_logger(__name__)  # pylint: disable=invalid-name






class 				A       (		SCREAMING_SNAKE_CASE__      ):
	snake_case__ :Dict				       =       ['safety_checker', 'feature_extractor']





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


				"""simple docstring"""

				super().__init__()
				if hasattr(scheduler.config ,							"steps_offset"							) and scheduler.config.steps_offset != 1:
							lowerCAmelCase__									=							(
							    f"""The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"""
							    f""" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure """
							    "to update the config accordingly as leaving `steps_offset` might led to incorrect results"
							    " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
							    " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
							    " file"
							)
							deprecate("steps_offset!=1" ,							"1.0.0" ,							__magic_name__ ,							standard_warn=__magic_name__							)
							lowerCAmelCase__									=							dict(scheduler.config							)
							lowerCAmelCase__									=							1
							lowerCAmelCase__									=							FrozenDict(__magic_name__							)

				self.register_modules(
				    vae=__magic_name__ ,							text_encoder=__magic_name__ ,							tokenizer=__magic_name__ ,							unet=__magic_name__ ,							scheduler=__magic_name__ ,							safety_checker=__magic_name__ ,							feature_extractor=__magic_name__ ,							)
				self.register_to_config(requires_safety_checker=__magic_name__							)





	@property
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Union[str, Any]							):


				"""simple docstring"""

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





	def 							__SCREAMING_SNAKE_CASE					(   self     :    int ,							__magic_name__     :    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
							lowerCAmelCase__									=							self.unet.config.attention_head_dim // 2
				self.unet.set_attention_slice(__magic_name__							)





	def 							__SCREAMING_SNAKE_CASE					(   self     :    Union[str, Any]							):


				"""simple docstring"""

				self.enable_attention_slicing(__magic_name__							)





	@torch.no_grad()
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[Any] ,							__magic_name__     :    Union[str, List[str]] ,							__magic_name__     :    Union[torch.FloatTensor, PIL.Image.Image] ,							__magic_name__     :    Union[torch.FloatTensor, PIL.Image.Image] ,							__magic_name__     :    float = 0.8 ,							__magic_name__     :    Optional[int] = 50 ,							__magic_name__     :    Optional[float] = 7.5 ,							__magic_name__     :    Optional[Union[str, List[str]]] = None ,							__magic_name__     :    Optional[int] = 1 ,							__magic_name__     :    Optional[float] = 0.0 ,							__magic_name__     :    Optional[torch.Generator] = None ,							__magic_name__     :    Optional[str] = "pil" ,							__magic_name__     :    bool = True ,							__magic_name__     :    Optional[Callable[[int, int, torch.FloatTensor], None]] = None ,							__magic_name__     :    int = 1 ,							):


				"""simple docstring"""

				return StableDiffusionInpaintPipelineLegacy(**self.components							)(
				    prompt=__magic_name__ ,							image=__magic_name__ ,							mask_image=__magic_name__ ,							strength=__magic_name__ ,							num_inference_steps=__magic_name__ ,							guidance_scale=__magic_name__ ,							negative_prompt=__magic_name__ ,							num_images_per_prompt=__magic_name__ ,							eta=__magic_name__ ,							generator=__magic_name__ ,							output_type=__magic_name__ ,							return_dict=__magic_name__ ,							callback=__magic_name__ ,							)





	@torch.no_grad()
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[Any] ,							__magic_name__     :    Union[str, List[str]] ,							__magic_name__     :    Union[torch.FloatTensor, PIL.Image.Image] ,							__magic_name__     :    float = 0.8 ,							__magic_name__     :    Optional[int] = 50 ,							__magic_name__     :    Optional[float] = 7.5 ,							__magic_name__     :    Optional[Union[str, List[str]]] = None ,							__magic_name__     :    Optional[int] = 1 ,							__magic_name__     :    Optional[float] = 0.0 ,							__magic_name__     :    Optional[torch.Generator] = None ,							__magic_name__     :    Optional[str] = "pil" ,							__magic_name__     :    bool = True ,							__magic_name__     :    Optional[Callable[[int, int, torch.FloatTensor], None]] = None ,							__magic_name__     :    int = 1 ,							**__magic_name__     :    List[str] ,							):


				"""simple docstring"""

				return StableDiffusionImgaImgPipeline(**self.components							)(
				    prompt=__magic_name__ ,							image=__magic_name__ ,							strength=__magic_name__ ,							num_inference_steps=__magic_name__ ,							guidance_scale=__magic_name__ ,							negative_prompt=__magic_name__ ,							num_images_per_prompt=__magic_name__ ,							eta=__magic_name__ ,							generator=__magic_name__ ,							output_type=__magic_name__ ,							return_dict=__magic_name__ ,							callback=__magic_name__ ,							callback_steps=__magic_name__ ,							)







	@torch.no_grad()
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Tuple ,							__magic_name__     :    Union[str, List[str]] ,							__magic_name__     :    int = 512 ,							__magic_name__     :    int = 512 ,							__magic_name__     :    int = 50 ,							__magic_name__     :    float = 7.5 ,							__magic_name__     :    Optional[Union[str, List[str]]] = None ,							__magic_name__     :    Optional[int] = 1 ,							__magic_name__     :    float = 0.0 ,							__magic_name__     :    Optional[torch.Generator] = None ,							__magic_name__     :    Optional[torch.FloatTensor] = None ,							__magic_name__     :    Optional[str] = "pil" ,							__magic_name__     :    bool = True ,							__magic_name__     :    Optional[Callable[[int, int, torch.FloatTensor], None]] = None ,							__magic_name__     :    int = 1 ,							):


				"""simple docstring"""

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





