

import json
import os
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
  import torch

if is_vision_available():
  from PIL import Image

  from transformers import ImageGPTImageProcessor





class A__    ( unittest.TestCase ):



 """simple docstring"""







 def __init__(		self :	Tuple     ,						A_ :	int     ,						A_ :	Optional[int]=7     ,						A_ :	Union[str, Any]=3     ,						A_ :	Optional[Any]=1_8     ,						A_ :	Union[str, Any]=3_0     ,						A_ :	Dict=4_0_0     ,						A_ :	Optional[Any]=True     ,						A_ :	int=None     ,						A_ :	List[Any]=True     ,						):






      '''simple docstring'''




      _lowerCAmelCase   :					int        =    size if size is not None else {"height": 1_8, "width": 1_8}
      _lowerCAmelCase   :					str        =    parent
      _lowerCAmelCase   :					Optional[Any]        =    batch_size
      _lowerCAmelCase   :					Tuple        =    num_channels
      _lowerCAmelCase   :					Optional[int]        =    image_size
      _lowerCAmelCase   :					Optional[Any]        =    min_resolution
      _lowerCAmelCase   :					Optional[Any]        =    max_resolution
      _lowerCAmelCase   :					Tuple        =    do_resize
      _lowerCAmelCase   :					Dict        =    size
      _lowerCAmelCase   :					Union[str, Any]        =    do_normalize


 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      return {
          # here we create 2 clusters for the sake of simplicity
          "clusters": np.asarray(
              [
                  [0.8866443634033203, 0.6618829369544983, 0.3891746401786804],
                  [-0.6042559146881104, -0.02295008860528469, 0.5423797369003296],
              ]       ),
          "do_resize": self.do_resize,
          "size": self.size,
          "do_normalize": self.do_normalize,
      }





@require_torch
@require_vision
class A__    ( A  ,		unittest.TestCase ):



 """simple docstring"""







 _lowercase     :					Tuple      =						ImageGPTImageProcessor if is_vision_available() else None

 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    ImageGPTImageProcessingTester(self       )

 @property
 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      return self.image_processor_tester.prepare_image_processor_dict()

 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Any        =    self.image_processing_class(**self.image_processor_dict       )
      self.assertTrue(hasattr(A_     ,						"clusters"       )       )
      self.assertTrue(hasattr(A_     ,						"do_resize"       )       )
      self.assertTrue(hasattr(A_     ,						"size"       )       )
      self.assertTrue(hasattr(A_     ,						"do_normalize"       )       )

 def    __magic_name__       (		self :	Optional[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    self.image_processing_class.from_dict(self.image_processor_dict       )
      self.assertEqual(image_processor.size     ,						{"height": 1_8, "width": 1_8}       )

      _lowerCAmelCase   :					Any        =    self.image_processing_class.from_dict(self.image_processor_dict     ,						size=4_2       )
      self.assertEqual(image_processor.size     ,						{"height": 4_2, "width": 4_2}       )

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






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[Any]        =    self.image_processing_class(**self.image_processor_dict       )
      _lowerCAmelCase   :					Tuple        =    json.loads(image_processor.to_json_string()       )
      for key, value in self.image_processor_dict.items():
           if key == "clusters":
                self.assertTrue(np.array_equal(A_     ,						obj[key]       )       )
           else:
                self.assertEqual(obj[key]     ,						A_       )

 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Tuple        =    self.image_processing_class(**self.image_processor_dict       )

      with tempfile.TemporaryDirectory() as tmpdirname:
           _lowerCAmelCase   :					Optional[Any]        =    os.path.join(A_     ,						"image_processor.json"       )
           image_processor_first.to_json_file(A_       )
           _lowerCAmelCase   :					Optional[Any]        =    self.image_processing_class.from_json_file(A_       ).to_dict()

      _lowerCAmelCase   :					str        =    image_processor_first.to_dict()
      for key, value in image_processor_first.items():
           if key == "clusters":
                self.assertTrue(np.array_equal(A_     ,						image_processor_second[key]       )       )
           else:
                self.assertEqual(image_processor_first[key]     ,						A_       )

 def    __magic_name__       (		self :	List[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[Any]        =    self.image_processing_class(**self.image_processor_dict       )

      with tempfile.TemporaryDirectory() as tmpdirname:
           image_processor_first.save_pretrained(A_       )
           _lowerCAmelCase   :					Tuple        =    self.image_processing_class.from_pretrained(A_       ).to_dict()

      _lowerCAmelCase   :					str        =    image_processor_first.to_dict()
      for key, value in image_processor_first.items():
           if key == "clusters":
                self.assertTrue(np.array_equal(A_     ,						image_processor_second[key]       )       )
           else:
                self.assertEqual(image_processor_first[key]     ,						A_       )


 @unittest.skip("ImageGPT requires clusters at initialization"       )
 def    __magic_name__       (		self :	Optional[Any]       ):






      '''simple docstring'''




      pass







def 	_snake_case		(    )       ->      Tuple:

     """simple docstring"""







     _lowerCAmelCase   :					Optional[Any]        =    load_dataset("hf-internal-testing/fixtures_image_utils"		,							split="test"				)

     _lowerCAmelCase   :					Union[str, Any]        =    Image.open(dataset[4]["file"]				)
     _lowerCAmelCase   :					Optional[Any]        =    Image.open(dataset[5]["file"]				)

     _lowerCAmelCase   :					str        =    [imagea, imagea]

     return images





@require_vision
@require_torch
class A__    ( unittest.TestCase ):



 """simple docstring"""







 @slow
 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      _lowerCAmelCase   :					int        =    ImageGPTImageProcessor.from_pretrained("openai/imagegpt-small"       )

      _lowerCAmelCase   :					str        =    prepare_images()

      # test non-batched
      _lowerCAmelCase   :					int        =    image_processing(images[0]     ,						return_tensors="pt"       )

      self.assertIsInstance(encoding.input_ids     ,						torch.LongTensor       )
      self.assertEqual(encoding.input_ids.shape     ,						(1, 1_0_2_4)       )

      _lowerCAmelCase   :					Optional[Any]        =    [3_0_6, 1_9_1, 1_9_1]
      self.assertEqual(encoding.input_ids[0, :3].tolist()     ,						A_       )

      # test batched
      _lowerCAmelCase   :					str        =    image_processing(A_     ,						return_tensors="pt"       )

      self.assertIsInstance(encoding.input_ids     ,						torch.LongTensor       )
      self.assertEqual(encoding.input_ids.shape     ,						(2, 1_0_2_4)       )

      _lowerCAmelCase   :					Any        =    [3_0_3, 1_3, 1_3]
      self.assertEqual(encoding.input_ids[1, -3:].tolist()     ,						A_       )









import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

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


enable_full_determinism()





@skip_mps
class A__    ( A  ,		unittest.TestCase ):



 """simple docstring"""







 _lowercase     :					str      =						TextToVideoSDPipeline
 _lowercase     :					str      =						TEXT_TO_IMAGE_PARAMS
 _lowercase     :					Dict      =						TEXT_TO_IMAGE_BATCH_PARAMS
 # No `output_type`.
 _lowercase     :					Union[str, Any]      =						frozenset(
     [
         '''num_inference_steps''',
         '''generator''',
         '''latents''',
         '''return_dict''',
         '''callback''',
         '''callback_steps''',
     ] )

 def    __magic_name__       (		self :	Any       ):






      '''simple docstring'''




      torch.manual_seed(0       )
      _lowerCAmelCase   :					Union[str, Any]        =    UNetaDConditionModel(
          block_out_channels=(3_2, 6_4, 6_4, 6_4)     ,						layers_per_block=2     ,						sample_size=3_2     ,						in_channels=4     ,						out_channels=4     ,						down_block_types=("CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "DownBlock3D")     ,						up_block_types=("UpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D")     ,						cross_attention_dim=3_2     ,						attention_head_dim=4     ,						)
      _lowerCAmelCase   :					Any        =    DDIMScheduler(
          beta_start=0.00085     ,						beta_end=0.012     ,						beta_schedule="scaled_linear"     ,						clip_sample=A_     ,						set_alpha_to_one=A_     ,						)
      torch.manual_seed(0       )
      _lowerCAmelCase   :					Dict        =    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     ,						sample_size=1_2_8     ,						)
      torch.manual_seed(0       )
      _lowerCAmelCase   :					Union[str, Any]        =    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     ,						hidden_act="gelu"     ,						projection_dim=5_1_2     ,						)
      _lowerCAmelCase   :					Any        =    CLIPTextModel(A_       )
      _lowerCAmelCase   :					Union[str, Any]        =    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

      _lowerCAmelCase   :					Dict        =    {
          "unet": unet,
          "scheduler": scheduler,
          "vae": vae,
          "text_encoder": text_encoder,
          "tokenizer": tokenizer,
      }
      return components

 def    __magic_name__       (		self :	str     ,						A_ :	Union[str, Any]     ,						A_ :	List[str]=0       ):






      '''simple docstring'''




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

 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Tuple        =    "cpu"  # ensure determinism for the device-dependent torch.Generator
      _lowerCAmelCase   :					Dict        =    self.get_dummy_components()
      _lowerCAmelCase   :					int        =    TextToVideoSDPipeline(**A_       )
      _lowerCAmelCase   :					Dict        =    sd_pipe.to(A_       )
      sd_pipe.set_progress_bar_config(disable=A_       )

      _lowerCAmelCase   :					Optional[Any]        =    self.get_dummy_inputs(A_       )
      _lowerCAmelCase   :					Any        =    "np"
      _lowerCAmelCase   :					List[str]        =    sd_pipe(**A_       ).frames
      _lowerCAmelCase   :					Optional[int]        =    frames[0][-3:, -3:, -1]

      assert frames[0].shape == (6_4, 6_4, 3)
      _lowerCAmelCase   :					str        =    np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0]       )

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

 def    __magic_name__       (		self :	List[Any]       ):






      '''simple docstring'''




      self._test_attention_slicing_forward_pass(test_mean_pixel_difference=A_     ,						expected_max_diff=3E-3       )

 @unittest.skipIf(
     torch_device != "cuda" or not is_xformers_available()     ,						reason="XFormers attention is only available with CUDA and `xformers` installed"     ,						)
 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=A_     ,						expected_max_diff=1E-2       )

 @unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."       )
 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      pass

 @unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."       )
 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      pass

 @unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."       )
 def    __magic_name__       (		self :	str       ):






      '''simple docstring'''




      pass


 def    __magic_name__       (		self :	Optional[Any]       ):






      '''simple docstring'''




      return super().test_progress_bar()





@slow
@skip_mps
class A__    ( unittest.TestCase ):



 """simple docstring"""







 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[Any]        =    load_numpy(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"       )

      _lowerCAmelCase   :					Dict        =    TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"       )
      _lowerCAmelCase   :					Optional[Any]        =    DPMSolverMultistepScheduler.from_config(pipe.scheduler.config       )
      _lowerCAmelCase   :					Optional[Any]        =    pipe.to("cuda"       )

      _lowerCAmelCase   :					Union[str, Any]        =    "Spiderman is surfing"
      _lowerCAmelCase   :					Any        =    torch.Generator(device="cpu"       ).manual_seed(0       )

      _lowerCAmelCase   :					Union[str, Any]        =    pipe(A_     ,						generator=A_     ,						num_inference_steps=2_5     ,						output_type="pt"       ).frames
      _lowerCAmelCase   :					Optional[Any]        =    video_frames.cpu().numpy()

      assert np.abs(expected_video - video       ).mean() < 5E-2


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






      '''simple docstring'''




      _lowerCAmelCase   :					Dict        =    load_numpy(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"       )

      _lowerCAmelCase   :					Optional[Any]        =    TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"       )
      _lowerCAmelCase   :					Optional[int]        =    pipe.to("cuda"       )

      _lowerCAmelCase   :					List[Any]        =    "Spiderman is surfing"
      _lowerCAmelCase   :					List[str]        =    torch.Generator(device="cpu"       ).manual_seed(0       )

      _lowerCAmelCase   :					List[Any]        =    pipe(A_     ,						generator=A_     ,						num_inference_steps=2     ,						output_type="pt"       ).frames
      _lowerCAmelCase   :					str        =    video_frames.cpu().numpy()

      assert np.abs(expected_video - video       ).mean() < 5E-2






