






import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import MaMaaaTokenizer, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)
from transformers.utils import is_sentencepiece_available


if is_sentencepiece_available():
       from transformers.models.mam_aaa.tokenization_mam_aaa import VOCAB_FILES_NAMES, save_json

from ...test_tokenization_common import TokenizerTesterMixin


if is_sentencepiece_available():
       UpperCamelCase    							=      get_tests_dir('fixtures/test_sentencepiece.model')


if is_torch_available():
       from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

UpperCamelCase    							=      12_8022
UpperCamelCase    							=      12_8028







@require_sentencepiece
class 		_A						( UpperCAmelCase_	,				unittest.TestCase ):
  lowercase_						:			Dict						=					MaMaaaTokenizer
  lowercase_						:			Tuple						=					False
  lowercase_						:			Optional[Any]						=					False
  lowercase_						:			Tuple						=					True

  def    a					(    self						:	List[Any]			):
     """simple docstring"""

     super().setUp()

     __UpperCamelCase	:			str					=					["""</s>""", """<unk>""", """▁This""", """▁is""", """▁a""", """▁t""", """est""", """\u0120""", """<pad>"""]
     __UpperCamelCase	:			Optional[Any]					=					dict(zip(lowerCamelCase__   ,				range(len(lowerCamelCase__			)			)			)			)
     __UpperCamelCase	:			List[str]					=					Path(self.tmpdirname			)
     save_json(lowerCamelCase__   ,				save_dir / VOCAB_FILES_NAMES["""vocab_file"""]			)
     if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
        copyfile(lowerCamelCase__   ,				save_dir / VOCAB_FILES_NAMES["""spm_file"""]			)

     __UpperCamelCase	:			Any					=					MaMaaaTokenizer.from_pretrained(self.tmpdirname			)
     tokenizer.save_pretrained(self.tmpdirname			)

  def    a					(    self						:	Tuple   ,				**lowerCamelCase__						:	Tuple			):
     """simple docstring"""

     return MaMaaaTokenizer.from_pretrained(self.tmpdirname   ,				**lowerCamelCase__			)

  def    a					(    self						:	Any   ,				lowerCamelCase__						:	List[str]			):
     """simple docstring"""

     return (
         "This is a test",
         "This is a test",
     )

  def    a					(    self						:	Union[str, Any]			):
     """simple docstring"""

     __UpperCamelCase	:			Union[str, Any]					=					"""</s>"""
     __UpperCamelCase	:			Tuple					=					0

     self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase__			)   ,				lowerCamelCase__			)
     self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase__			)   ,				lowerCamelCase__			)

  def    a					(    self						:	Optional[int]			):
     """simple docstring"""

     __UpperCamelCase	:			str					=					self.get_tokenizer()
     __UpperCamelCase	:			Optional[int]					=					list(tokenizer.get_vocab().keys()			)

     self.assertEqual(vocab_keys[0]   ,				"""</s>"""			)
     self.assertEqual(vocab_keys[1]   ,				"""<unk>"""			)
     self.assertEqual(vocab_keys[-1]   ,				"""<s>"""			)
     self.assertEqual(len(lowerCamelCase__			)   ,				tokenizer.vocab_size + len(tokenizer.get_added_vocab()			)			)

  @unittest.skip("""Skip this test while all models are still to be uploaded."""			)
  def    a					(    self						:	str			):
     """simple docstring"""

     pass

  def    a					(    self						:	Tuple			):
     """simple docstring"""

     __UpperCamelCase	:			List[Any]					=					self.get_tokenizer()

     __UpperCamelCase	:			Any					=					tokenizer.tokenize("""This is a test"""			)
     self.assertListEqual(lowerCamelCase__   ,				["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]			)

     self.assertListEqual(
         tokenizer.convert_tokens_to_ids(lowerCamelCase__			)   ,				[2, 3, 4, 5, 6]   ,				)

     __UpperCamelCase	:			str					=					tokenizer.convert_ids_to_tokens([2, 3, 4, 5, 6]			)
     self.assertListEqual(lowerCamelCase__   ,				["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]			)

     __UpperCamelCase	:			Union[str, Any]					=					tokenizer.convert_tokens_to_string(lowerCamelCase__			)
     self.assertEqual(lowerCamelCase__   ,				"""This is a test"""			)

  @slow
  def    a					(    self						:	int			):
     """simple docstring"""

     __UpperCamelCase	:			Dict					=					{"""input_ids""": [[12_80_22, 11_01_08, 3_97, 11, 3_82_72, 22_47, 12_48_11, 2_85, 1_81_05, 15_86, 2_07, 7, 3_95_34, 44_28, 3_97, 10_19, 1_81_05, 15_86, 2_07, 7, 4_13_37, 1_67_86, 2_41, 7, 2_02_14, 17, 12_56_90, 1_03_98, 7, 4_43_78, 5_80_69, 6_83_42, 77_98, 73_43, 11, 2_99, 3_33_10, 4, 1_58, 3_73_50, 9_40_77, 45_69, 2_99, 3_33_10, 90, 4, 5_28_40, 2_90, 4, 3_12_70, 1_12, 2_99, 6_82, 4, 5_28_40, 3_99_53, 1_40_79, 1_93, 5_25_19, 9_08_94, 1_78_94, 12_06_97, 11, 4_04_45, 5_51, 17, 10_19, 5_25_19, 9_08_94, 1_77_56, 9_63, 11, 4_04_45, 4_80, 17, 97_92, 11_20, 51_73, 13_93, 62_40, 1_67_86, 2_41, 12_09_96, 28, 12_45, 13_93, 11_82_40, 1_11_23, 10_19, 9_36_12, 26_91, 1_06_18, 9_80_58, 12_04_09, 19_28, 2_79, 4, 4_06_83, 3_67, 1_78, 2_07, 10_19, 1_03, 10_31_21, 5_06, 6_52_96, 5, 2], [12_80_22, 2_12_17, 3_67, 1_17, 12_54_50, 1_28, 7_19, 7, 73_08, 40, 9_36_12, 1_26_69, 11_16, 1_67_04, 71, 1_77_85, 36_99, 1_55_92, 35, 1_44, 95_84, 2_41, 1_19_43, 7_13, 9_50, 7_99, 22_47, 8_84_27, 1_50, 1_49, 11_88_13, 12_07_06, 10_19, 10_69_06, 8_15_18, 28, 12_24, 2_27_99, 3_97, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [12_80_22, 16_58, 12_33_11, 51_55, 55_78, 47_22, 2_79, 1_49_47, 23_66, 11_20, 11_97, 14, 13_48, 92_32, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
     # fmt: on

     self.tokenizer_integration_test_util(
         expected_encoding=lowerCamelCase__   ,				model_name="""facebook/m2m100_418M"""   ,				revision="""c168bae485c864188cf9aa0e4108b0b6934dc91e"""   ,				)







@require_torch
@require_sentencepiece
@require_tokenizers
class 		_A						( unittest.TestCase ):
  lowercase_						:			Any						=					'''facebook/m2m100_418M'''
  lowercase_						:			List[Any]						=					[
      '''In my opinion, there are two levels of response from the French government.''',
      '''NSA Affair Emphasizes Complete Lack of Debate on Intelligence''',
  ]
  lowercase_						:			Optional[int]						=					[
      '''Selon moi, il y a deux niveaux de réponse de la part du gouvernement français.''',
      '''L\'affaire NSA souligne l\'absence totale de débat sur le renseignement''',
  ]

  # fmt: off
  lowercase_						:			int						=					[EN_CODE, 593, 1_949, 115_781, 4, 71_586, 4_234, 60_633, 126_233, 432, 123_808, 15_592, 1_197, 117_132, 120_618, 5, 2]

  @classmethod
  def    a					(    cls						:	List[str]			):
     """simple docstring"""

     __UpperCamelCase	:			MaMaaaTokenizer					=					MaMaaaTokenizer.from_pretrained(
         cls.checkpoint_name   ,				src_lang="""en"""   ,				tgt_lang="""fr"""			)
     __UpperCamelCase	:			Tuple					=					1
     return cls

  def    a					(    self						:	Optional[int]			):
     """simple docstring"""

     self.assertEqual(self.tokenizer.get_lang_id("""ar"""			)   ,				12_80_06			)
     self.assertEqual(self.tokenizer.get_lang_id("""en"""			)   ,				12_80_22			)
     self.assertEqual(self.tokenizer.get_lang_id("""ro"""			)   ,				12_80_76			)
     self.assertEqual(self.tokenizer.get_lang_id("""mr"""			)   ,				12_80_63			)

  def    a					(    self						:	Optional[Any]			):
     """simple docstring"""

     __UpperCamelCase	:			int					=					self.tokenizer.get_vocab()
     self.assertEqual(len(lowerCamelCase__			)   ,				self.tokenizer.vocab_size			)
     self.assertEqual(vocab["""<unk>"""]   ,				3			)
     self.assertIn(self.tokenizer.get_lang_token("""en"""			)   ,				lowerCamelCase__			)

  def    a					(    self						:	Optional[int]			):
     """simple docstring"""

     __UpperCamelCase	:			Union[str, Any]					=					"""en"""
     __UpperCamelCase	:			Optional[Any]					=					self.tokenizer.batch_encode_plus(self.src_text			).input_ids[0]
     self.assertListEqual(self.expected_src_tokens   ,				lowerCamelCase__			)

  def    a					(    self						:	Tuple			):
     """simple docstring"""

     self.assertIn(lowerCamelCase__   ,				self.tokenizer.all_special_ids			)
     # fmt: off
     __UpperCamelCase	:			Optional[Any]					=					[FR_CODE, 53_64, 82, 86_42, 4, 2_94, 47, 8, 1_40_28, 1_36, 32_86, 97_06, 6, 9_07_97, 6, 14_40_12, 1_62, 8_81_28, 3_00_61, 5, 2]
     # fmt: on
     __UpperCamelCase	:			Union[str, Any]					=					self.tokenizer.decode(lowerCamelCase__   ,				skip_special_tokens=lowerCamelCase__			)
     __UpperCamelCase	:			List[str]					=					self.tokenizer.decode(generated_ids[1:]   ,				skip_special_tokens=lowerCamelCase__			)
     self.assertEqual(lowerCamelCase__   ,				lowerCamelCase__			)
     self.assertNotIn(self.tokenizer.eos_token   ,				lowerCamelCase__			)

  def    a					(    self						:	str			):
     """simple docstring"""

     __UpperCamelCase	:			List[str]					=					tempfile.mkdtemp()
     __UpperCamelCase	:			Dict					=					self.tokenizer.lang_token_to_id
     self.tokenizer.save_pretrained(lowerCamelCase__			)
     __UpperCamelCase	:			Optional[int]					=					MaMaaaTokenizer.from_pretrained(lowerCamelCase__			)
     self.assertDictEqual(new_tok.lang_token_to_id   ,				lowerCamelCase__			)

  @require_torch
  def    a					(    self						:	Tuple			):
     """simple docstring"""

     __UpperCamelCase	:			Tuple					=					"""en"""
     __UpperCamelCase	:			Union[str, Any]					=					"""fr"""

     __UpperCamelCase	:			List[str]					=					self.tokenizer(self.src_text   ,				text_target=self.tgt_text   ,				padding=lowerCamelCase__   ,				return_tensors="""pt"""			)

     __UpperCamelCase	:			Union[str, Any]					=					shift_tokens_right(
         batch["""labels"""]   ,				self.tokenizer.pad_token_id   ,				self.tokenizer.eos_token_id			)

     for k in batch:
        __UpperCamelCase	:			List[str]					=					batch[k].tolist()
     # batch = {k: v.tolist() for k,v in batch.items()}
     # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
     # batch.decoder_inputs_ids[0][0] ==
     assert batch.input_ids[1][0] == EN_CODE
     assert batch.input_ids[1][-1] == 2
     assert batch.labels[1][0] == FR_CODE
     assert batch.labels[1][-1] == 2
     assert batch.decoder_input_ids[1][:2] == [2, FR_CODE]

  @require_torch
  def    a					(    self						:	Union[str, Any]			):
     """simple docstring"""

     __UpperCamelCase	:			List[str]					=					"""mr"""
     self.assertListEqual(self.tokenizer.prefix_tokens   ,				[self.tokenizer.get_lang_id("""mr"""			)]			)
     self.assertListEqual(self.tokenizer.suffix_tokens   ,				[self.tokenizer.eos_token_id]			)

     __UpperCamelCase	:			Tuple					=					"""zh"""
     self.assertListEqual(self.tokenizer.prefix_tokens   ,				[self.tokenizer.get_lang_id("""zh"""			)]			)
     self.assertListEqual(self.tokenizer.suffix_tokens   ,				[self.tokenizer.eos_token_id]			)

  @require_torch
  def    a					(    self						:	Dict			):
     """simple docstring"""

     __UpperCamelCase	:			List[Any]					=					"""mr"""
     self.tokenizer._switch_to_target_mode()
     self.assertListEqual(self.tokenizer.prefix_tokens   ,				[self.tokenizer.get_lang_id("""mr"""			)]			)
     self.assertListEqual(self.tokenizer.suffix_tokens   ,				[self.tokenizer.eos_token_id]			)
     self.tokenizer._switch_to_input_mode()
     self.assertListEqual(self.tokenizer.prefix_tokens   ,				[self.tokenizer.get_lang_id(self.tokenizer.src_lang			)]			)

     __UpperCamelCase	:			int					=					"""zh"""
     self.tokenizer._switch_to_target_mode()
     self.assertListEqual(self.tokenizer.prefix_tokens   ,				[self.tokenizer.get_lang_id("""zh"""			)]			)
     self.assertListEqual(self.tokenizer.suffix_tokens   ,				[self.tokenizer.eos_token_id]			)
     self.tokenizer._switch_to_input_mode()
     self.assertListEqual(self.tokenizer.prefix_tokens   ,				[self.tokenizer.get_lang_id(self.tokenizer.src_lang			)]			)

  @require_torch
  def    a					(    self						:	List[Any]			):
     """simple docstring"""

     __UpperCamelCase	:			str					=					self.tokenizer._build_translation_inputs("""A test"""   ,				return_tensors="""pt"""   ,				src_lang="""en"""   ,				tgt_lang="""ar"""			)

     self.assertEqual(
         nested_simplify(lowerCamelCase__			)   ,				{
             # en_XX, A, test, EOS
             """input_ids""": [[12_80_22, 58, 41_83, 2]],
             """attention_mask""": [[1, 1, 1, 1]],
             # ar_AR
             """forced_bos_token_id""": 12_80_06,
         }   ,				)











import gc
import unittest

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

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

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


enable_full_determinism()







class 		_A						( UpperCAmelCase_	,				unittest.TestCase ):
  lowercase_						:			Union[str, Any]						=					LDMTextToImagePipeline
  lowercase_						:			Tuple						=					TEXT_TO_IMAGE_PARAMS - {
      '''negative_prompt''',
      '''negative_prompt_embeds''',
      '''cross_attention_kwargs''',
      '''prompt_embeds''',
  }
  lowercase_						:			Optional[Any]						=					PipelineTesterMixin.required_optional_params - {
      '''num_images_per_prompt''',
      '''callback''',
      '''callback_steps''',
  }
  lowercase_						:			Dict						=					TEXT_TO_IMAGE_BATCH_PARAMS
  lowercase_						:			Tuple						=					False

  def    a					(    self						:	Optional[Any]			):
     """simple docstring"""

     torch.manual_seed(0			)
     __UpperCamelCase	:			Any					=					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   ,				)
     __UpperCamelCase	:			Union[str, Any]					=					DDIMScheduler(
         beta_start=0.0_0085   ,				beta_end=0.012   ,				beta_schedule="""scaled_linear"""   ,				clip_sample=lowerCamelCase__   ,				set_alpha_to_one=lowerCamelCase__   ,				)
     torch.manual_seed(0			)
     __UpperCamelCase	:			Any					=					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			)
     __UpperCamelCase	:			Union[str, 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=10_00   ,				)
     __UpperCamelCase	:			List[str]					=					CLIPTextModel(lowerCamelCase__			)
     __UpperCamelCase	:			List[str]					=					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)

     __UpperCamelCase	:			Any					=					{
         """unet""": unet,
         """scheduler""": scheduler,
         """vqvae""": vae,
         """bert""": text_encoder,
         """tokenizer""": tokenizer,
     }
     return components

  def    a					(    self						:	Tuple   ,				lowerCamelCase__						:	str   ,				lowerCamelCase__						:	List[str]=0			):
     """simple docstring"""

     if str(lowerCamelCase__			).startswith("""mps"""			):
        __UpperCamelCase	:			str					=					torch.manual_seed(lowerCamelCase__			)
     else:
        __UpperCamelCase	:			Optional[Any]					=					torch.Generator(device=lowerCamelCase__			).manual_seed(lowerCamelCase__			)
     __UpperCamelCase	:			Tuple					=					{
         """prompt""": """A painting of a squirrel eating a burger""",
         """generator""": generator,
         """num_inference_steps""": 2,
         """guidance_scale""": 6.0,
         """output_type""": """numpy""",
     }
     return inputs

  def    a					(    self						:	Tuple			):
     """simple docstring"""

     __UpperCamelCase	:			Dict					=					"""cpu"""  # ensure determinism for the device-dependent torch.Generator

     __UpperCamelCase	:			List[str]					=					self.get_dummy_components()
     __UpperCamelCase	:			Optional[int]					=					LDMTextToImagePipeline(**lowerCamelCase__			)
     pipe.to(lowerCamelCase__			)
     pipe.set_progress_bar_config(disable=lowerCamelCase__			)

     __UpperCamelCase	:			List[Any]					=					self.get_dummy_inputs(lowerCamelCase__			)
     __UpperCamelCase	:			List[Any]					=					pipe(**lowerCamelCase__			).images
     __UpperCamelCase	:			Tuple					=					image[0, -3:, -3:, -1]

     assert image.shape == (1, 16, 16, 3)
     __UpperCamelCase	:			int					=					np.array([0.6101, 0.6156, 0.5622, 0.4895, 0.6661, 0.3804, 0.5748, 0.6136, 0.5014]			)

     assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-3







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

  def    a					(    self						:	Any			):
     """simple docstring"""

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

  def    a					(    self						:	Dict   ,				lowerCamelCase__						:	List[Any]   ,				lowerCamelCase__						:	Tuple=torch.floataa   ,				lowerCamelCase__						:	List[Any]=0			):
     """simple docstring"""

     __UpperCamelCase	:			Union[str, Any]					=					torch.manual_seed(lowerCamelCase__			)
     __UpperCamelCase	:			Tuple					=					np.random.RandomState(lowerCamelCase__			).standard_normal((1, 4, 32, 32)			)
     __UpperCamelCase	:			Any					=					torch.from_numpy(lowerCamelCase__			).to(device=lowerCamelCase__   ,				dtype=lowerCamelCase__			)
     __UpperCamelCase	:			Optional[int]					=					{
         """prompt""": """A painting of a squirrel eating a burger""",
         """latents""": latents,
         """generator""": generator,
         """num_inference_steps""": 3,
         """guidance_scale""": 6.0,
         """output_type""": """numpy""",
     }
     return inputs

  def    a					(    self						:	Optional[int]			):
     """simple docstring"""

     __UpperCamelCase	:			Any					=					LDMTextToImagePipeline.from_pretrained("""CompVis/ldm-text2im-large-256"""			).to(lowerCamelCase__			)
     pipe.set_progress_bar_config(disable=lowerCamelCase__			)

     __UpperCamelCase	:			Any					=					self.get_inputs(lowerCamelCase__			)
     __UpperCamelCase	:			Tuple					=					pipe(**lowerCamelCase__			).images
     __UpperCamelCase	:			Optional[int]					=					image[0, -3:, -3:, -1].flatten()

     assert image.shape == (1, 2_56, 2_56, 3)
     __UpperCamelCase	:			Optional[Any]					=					np.array([0.5_1825, 0.5_2850, 0.5_2543, 0.5_4258, 0.5_2304, 0.5_2569, 0.5_4363, 0.5_5276, 0.5_6878]			)
     __UpperCamelCase	:			Union[str, Any]					=					np.abs(expected_slice - image_slice			).max()
     assert max_diff < 1e-3







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

  def    a					(    self						:	Optional[Any]			):
     """simple docstring"""

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

  def    a					(    self						:	Tuple   ,				lowerCamelCase__						:	str   ,				lowerCamelCase__						:	Union[str, Any]=torch.floataa   ,				lowerCamelCase__						:	Tuple=0			):
     """simple docstring"""

     __UpperCamelCase	:			Union[str, Any]					=					torch.manual_seed(lowerCamelCase__			)
     __UpperCamelCase	:			Optional[Any]					=					np.random.RandomState(lowerCamelCase__			).standard_normal((1, 4, 32, 32)			)
     __UpperCamelCase	:			List[Any]					=					torch.from_numpy(lowerCamelCase__			).to(device=lowerCamelCase__   ,				dtype=lowerCamelCase__			)
     __UpperCamelCase	:			Union[str, Any]					=					{
         """prompt""": """A painting of a squirrel eating a burger""",
         """latents""": latents,
         """generator""": generator,
         """num_inference_steps""": 50,
         """guidance_scale""": 6.0,
         """output_type""": """numpy""",
     }
     return inputs

  def    a					(    self						:	Tuple			):
     """simple docstring"""

     __UpperCamelCase	:			Tuple					=					LDMTextToImagePipeline.from_pretrained("""CompVis/ldm-text2im-large-256"""			).to(lowerCamelCase__			)
     pipe.set_progress_bar_config(disable=lowerCamelCase__			)

     __UpperCamelCase	:			Dict					=					self.get_inputs(lowerCamelCase__			)
     __UpperCamelCase	:			List[Any]					=					pipe(**lowerCamelCase__			).images[0]

     __UpperCamelCase	:			Optional[Any]					=					load_numpy(
         """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy"""			)
     __UpperCamelCase	:			int					=					np.abs(expected_image - image			).max()
     assert max_diff < 1e-3



