





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







class 	__lowerCAmelCase      (       _UpperCamelCase		,_UpperCamelCase		,unittest.TestCase	):
   _UpperCamelCase			:    Tuple  		=					StableDiffusionSAGPipeline
   _UpperCamelCase			:    Tuple  		=					TEXT_TO_IMAGE_PARAMS
   _UpperCamelCase			:    Tuple  		=					TEXT_TO_IMAGE_BATCH_PARAMS
   _UpperCamelCase			:    str  		=					TEXT_TO_IMAGE_IMAGE_PARAMS
   _UpperCamelCase			:    Optional[int]  		=					TEXT_TO_IMAGE_IMAGE_PARAMS
   _UpperCamelCase			:    Any  		=					False





   def 						_snake_case			(			self   )					->	str:
      """simple docstring"""





      torch.manual_seed(0   )
      a__						:    Tuple   		=	UNetaDConditionModel(
          block_out_channels=(32, 64)       ,      layers_per_block=2       ,      sample_size=32       ,      in_channels=4       ,      out_channels=4       ,      down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")       ,      up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")       ,      cross_attention_dim=32       ,      )
      a__						:    List[Any]   		=	DDIMScheduler(
          beta_start=0.00_085       ,      beta_end=0.012       ,      beta_schedule="scaled_linear"       ,      clip_sample=snake_case       ,      set_alpha_to_one=snake_case       ,      )
      torch.manual_seed(0   )
      a__						:    Optional[int]   		=	AutoencoderKL(
          block_out_channels=[32, 64]       ,      in_channels=3       ,      out_channels=3       ,      down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]       ,      up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]       ,      latent_channels=4       ,      )
      torch.manual_seed(0   )
      a__						:    Any   		=	CLIPTextConfig(
          bos_token_id=0       ,      eos_token_id=2       ,      hidden_size=32       ,      intermediate_size=37       ,      layer_norm_eps=1E-05       ,      num_attention_heads=4       ,      num_hidden_layers=5       ,      pad_token_id=1       ,      vocab_size=1_000       ,      )
      a__						:    Dict   		=	CLIPTextModel(snake_case   )
      a__						:    Any   		=	CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"   )

      a__						:    Tuple   		=	{
          "unet": unet,
          "scheduler": scheduler,
          "vae": vae,
          "text_encoder": text_encoder,
          "tokenizer": tokenizer,
          "safety_checker": None,
          "feature_extractor": None,
      }
      return components





   def 						_snake_case			(			self       ,      snake_case       ,      snake_case=0   )					->	str:
      """simple docstring"""





      if str(snake_case   ).startswith("mps"   ):
         a__						:    Tuple   		=	torch.manual_seed(snake_case   )
      else:
         a__						:    List[Any]   		=	torch.Generator(device=snake_case   ).manual_seed(snake_case   )
      a__						:    Optional[Any]   		=	{
          "prompt": ".",
          "generator": generator,
          "num_inference_steps": 2,
          "guidance_scale": 1.0,
          "sag_scale": 1.0,
          "output_type": "numpy",
      }
      return inputs





   def 						_snake_case			(			self   )					->	str:
      """simple docstring"""





      super().test_inference_batch_single_identical(expected_max_diff=3E-3   )







@slow
@require_torch_gpu
class 	__lowerCAmelCase      (       unittest.TestCase	):





   def 						_snake_case			(			self   )					->	Optional[Any]:
      """simple docstring"""





      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()





   def 						_snake_case			(			self   )					->	List[str]:
      """simple docstring"""





      a__						:    Union[str, Any]   		=	StableDiffusionSAGPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"   )
      a__						:    Dict   		=	sag_pipe.to(snake_case   )
      sag_pipe.set_progress_bar_config(disable=snake_case   )

      a__						:    Dict   		=	"."
      a__						:    List[Any]   		=	torch.manual_seed(0   )
      a__						:    Optional[Any]   		=	sag_pipe(
          [prompt]       ,      generator=snake_case       ,      guidance_scale=7.5       ,      sag_scale=1.0       ,      num_inference_steps=20       ,      output_type="np"   )

      a__						:    List[Any]   		=	output.images

      a__						:    Optional[Any]   		=	image[0, -3:, -3:, -1]

      assert image.shape == (1, 512, 512, 3)
      a__						:    Any   		=	np.array([0.1_568, 0.1_738, 0.1_695, 0.1_693, 0.1_507, 0.1_705, 0.1_547, 0.1_751, 0.1_949]   )

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





   def 						_snake_case			(			self   )					->	Optional[int]:
      """simple docstring"""





      a__						:    Optional[int]   		=	StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"   )
      a__						:    Tuple   		=	sag_pipe.to(snake_case   )
      sag_pipe.set_progress_bar_config(disable=snake_case   )

      a__						:    List[str]   		=	"."
      a__						:    Tuple   		=	torch.manual_seed(0   )
      a__						:    int   		=	sag_pipe(
          [prompt]       ,      generator=snake_case       ,      guidance_scale=7.5       ,      sag_scale=1.0       ,      num_inference_steps=20       ,      output_type="np"   )

      a__						:    List[str]   		=	output.images

      a__						:    int   		=	image[0, -3:, -3:, -1]

      assert image.shape == (1, 512, 512, 3)
      a__						:    List[str]   		=	np.array([0.3_459, 0.2_876, 0.2_537, 0.3_002, 0.2_671, 0.2_160, 0.3_026, 0.2_262, 0.2_371]   )

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





   def 						_snake_case			(			self   )					->	List[Any]:
      """simple docstring"""





      a__						:    Optional[Any]   		=	StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"   )
      a__						:    List[Any]   		=	sag_pipe.to(snake_case   )
      sag_pipe.set_progress_bar_config(disable=snake_case   )

      a__						:    str   		=	"."
      a__						:    Optional[Any]   		=	torch.manual_seed(0   )
      a__						:    List[str]   		=	sag_pipe(
          [prompt]       ,      width=768       ,      height=512       ,      generator=snake_case       ,      guidance_scale=7.5       ,      sag_scale=1.0       ,      num_inference_steps=20       ,      output_type="np"       ,      )

      a__						:    List[str]   		=	output.images

      assert image.shape == (1, 512, 768, 3)







import os
import unittest

from transformers.models.transfo_xl.tokenization_transfo_xl import VOCAB_FILES_NAMES, TransfoXLTokenizer

from ...test_tokenization_common import TokenizerTesterMixin

class 						__lowerCAmelCase      (      __magic_name__ ,			unittest.TestCase					):
							UpperCamelCase__   	=    TransfoXLTokenizer
							UpperCamelCase__   	=    False
							UpperCamelCase__   	=    False
							def  lowerCamelCase__				(		self		:Optional[Any]							):







								'''simple docstring'''







								super().setUp()

								a									=				[
								    """<unk>""",
								    """[CLS]""",
								    """[SEP]""",
								    """want""",
								    """unwanted""",
								    """wa""",
								    """un""",
								    """running""",
								    """,""",
								    """low""",
								    """l""",
								]
								a									=				os.path.join(self.tmpdirname						, VOCAB_FILES_NAMES["""vocab_file"""]							)
								with open(self.vocab_file						, """w"""						, encoding="""utf-8"""							) as vocab_writer:
									vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]							)							)
							def  lowerCamelCase__				(		self		:List[Any]						, **__magic_name__		:Optional[int]							):







								'''simple docstring'''







								a									=				True
								return TransfoXLTokenizer.from_pretrained(self.tmpdirname						, **__magic_name__							)
							def  lowerCamelCase__				(		self		:Union[str, Any]						, __magic_name__		:int							):







								'''simple docstring'''







								a									=				"""<unk> UNwanted , running"""
								a									=				"""<unk> unwanted, running"""
								return input_text, output_text
							def  lowerCamelCase__				(		self		:str							):







								'''simple docstring'''







								a									=				TransfoXLTokenizer(vocab_file=self.vocab_file						, lower_case=__magic_name__							)

								a									=				tokenizer.tokenize("""<unk> UNwanted , running"""							)
								self.assertListEqual(__magic_name__						, ["""<unk>""", """unwanted""", """,""", """running"""]							)

								self.assertListEqual(tokenizer.convert_tokens_to_ids(__magic_name__							)						, [0, 4, 8, 7]							)
							def  lowerCamelCase__				(		self		:int							):







								'''simple docstring'''







								a									=				TransfoXLTokenizer(lower_case=__magic_name__							)

								self.assertListEqual(
								    tokenizer.tokenize(""" \tHeLLo ! how  \n Are yoU ?  """							)						, ["""hello""", """!""", """how""", """are""", """you""", """?"""]							)
							def  lowerCamelCase__				(		self		:str							):







								'''simple docstring'''







								a									=				TransfoXLTokenizer(lower_case=__magic_name__							)

								self.assertListEqual(
								    tokenizer.tokenize(""" \tHeLLo ! how  \n Are yoU ?  """							)						, ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""]							)
							def  lowerCamelCase__				(		self		:Optional[int]							):







								'''simple docstring'''







								a									=				TransfoXLTokenizer(lower_case=__magic_name__							)
								a									=				"""Hello (bracket) and side-scrolled [and] Henry's $5,000 with 3.34 m. What's up!?"""
								a									=				[
								    """Hello""",
								    """(""",
								    """bracket""",
								    """)""",
								    """and""",
								    """side""",
								    """@-@""",
								    """scrolled""",
								    """[""",
								    """and""",
								    """]""",
								    """Henry""",
								    """'s""",
								    """$""",
								    """5""",
								    """@,@""",
								    """000""",
								    """with""",
								    """3""",
								    """@.@""",
								    """34""",
								    """m""",
								    """.""",
								    """What""",
								    """'s""",
								    """up""",
								    """!""",
								    """?""",
								]

								self.assertListEqual(tokenizer.tokenize(__magic_name__							)						, __magic_name__							)

								self.assertEqual(tokenizer.convert_tokens_to_string(__magic_name__							)						, __magic_name__							)





							def  lowerCamelCase__				(		self		:List[Any]							):







								'''simple docstring'''







								a									=				self.get_tokenizer()
								a									=				len(__magic_name__							)

								tokenizer.add_tokens(["""new1""", """new2"""]							)
								tokenizer.move_added_token("""new1"""						, 1							)

								# Check that moved token is not copied (duplicate)
								self.assertEqual(len(__magic_name__							)						, original_len + 2							)
								# Check that token is moved to specified id
								self.assertEqual(tokenizer.encode("""new1"""							)						, [1]							)
								self.assertEqual(tokenizer.decode([1]							)						, """new1"""							)

