

import warnings
from typing import List

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import is_flax_available, is_tf_available, is_torch_available





class A__    ( A ):



 """simple docstring"""







 _lowercase     :					Dict      =						['''image_processor''', '''tokenizer''']
 _lowercase     :					str      =						'''OwlViTImageProcessor'''
 _lowercase     :					List[Any]      =						('''CLIPTokenizer''', '''CLIPTokenizerFast''')

 def __init__(		self :	Optional[Any]     ,						A_ :	Optional[int]=None     ,						A_ :	List[Any]=None     ,						**A_ :	Union[str, Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[str]        =    None
      if "feature_extractor" in kwargs:
           warnings.warn(
               "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
               " instead."     ,						A_     ,						)
           _lowerCAmelCase   :					List[Any]        =    kwargs.pop("feature_extractor"       )

      _lowerCAmelCase   :					Dict        =    image_processor if image_processor is not None else feature_extractor
      if image_processor is None:
           raise ValueError("You need to specify an `image_processor`."       )
      if tokenizer is None:
           raise ValueError("You need to specify a `tokenizer`."       )

      super().__init__(A_     ,						A_       )

 def __call__(		self :	Dict     ,						A_ :	Optional[int]=None     ,						A_ :	Tuple=None     ,						A_ :	Tuple=None     ,						A_ :	int="max_length"     ,						A_ :	Any="np"     ,						**A_ :	Union[str, Any]       ):






      '''simple docstring'''




      if text is None and query_images is None and images is None:
           raise ValueError(
               "You have to specify at least one text or query image or image. All three cannot be none."       )

      if text is not None:
           if isinstance(A_     ,						A_       ) or (isinstance(A_     ,						A_       ) and not isinstance(text[0]     ,						A_       )):
                _lowerCAmelCase   :					Dict        =    [self.tokenizer(A_     ,						padding=A_     ,						return_tensors=A_     ,						**A_       )]

           elif isinstance(A_     ,						A_       ) and isinstance(text[0]     ,						A_       ):
                _lowerCAmelCase   :					List[Any]        =    []

                # Maximum number of queries across batch
                _lowerCAmelCase   :					Optional[int]        =    max([len(A_       ) for t in text]       )

                # Pad all batch samples to max number of text queries
                for t in text:
                     if len(A_       ) != max_num_queries:
                          _lowerCAmelCase   :					str        =    t + [" "] * (max_num_queries - len(A_       ))

                     _lowerCAmelCase   :					str        =    self.tokenizer(A_     ,						padding=A_     ,						return_tensors=A_     ,						**A_       )
                     encodings.append(A_       )
           else:
                raise TypeError("Input text should be a string, a list of strings or a nested list of strings"       )

           if return_tensors == "np":
                _lowerCAmelCase   :					List[Any]        =    np.concatenate([encoding["input_ids"] for encoding in encodings]     ,						axis=0       )
                _lowerCAmelCase   :					Any        =    np.concatenate([encoding["attention_mask"] for encoding in encodings]     ,						axis=0       )

           elif return_tensors == "jax" and is_flax_available():
                import jax.numpy as jnp

                _lowerCAmelCase   :					str        =    jnp.concatenate([encoding["input_ids"] for encoding in encodings]     ,						axis=0       )
                _lowerCAmelCase   :					Tuple        =    jnp.concatenate([encoding["attention_mask"] for encoding in encodings]     ,						axis=0       )

           elif return_tensors == "pt" and is_torch_available():
                import torch

                _lowerCAmelCase   :					Optional[Any]        =    torch.cat([encoding["input_ids"] for encoding in encodings]     ,						dim=0       )
                _lowerCAmelCase   :					Union[str, Any]        =    torch.cat([encoding["attention_mask"] for encoding in encodings]     ,						dim=0       )

           elif return_tensors == "tf" and is_tf_available():
                import tensorflow as tf

                _lowerCAmelCase   :					Optional[Any]        =    tf.stack([encoding["input_ids"] for encoding in encodings]     ,						axis=0       )
                _lowerCAmelCase   :					Optional[Any]        =    tf.stack([encoding["attention_mask"] for encoding in encodings]     ,						axis=0       )

           else:
                raise ValueError("Target return tensor type could not be returned"       )

           _lowerCAmelCase   :					Optional[int]        =    BatchEncoding()
           _lowerCAmelCase   :					Optional[Any]        =    input_ids
           _lowerCAmelCase   :					Optional[int]        =    attention_mask

      if query_images is not None:
           _lowerCAmelCase   :					int        =    BatchEncoding()
           _lowerCAmelCase   :					Any        =    self.image_processor(
               A_     ,						return_tensors=A_     ,						**A_       ).pixel_values
           _lowerCAmelCase   :					Any        =    query_pixel_values

      if images is not None:
           _lowerCAmelCase   :					str        =    self.image_processor(A_     ,						return_tensors=A_     ,						**A_       )

      if text is not None and images is not None:
           _lowerCAmelCase   :					Union[str, Any]        =    image_features.pixel_values
           return encoding
      elif query_images is not None and images is not None:
           _lowerCAmelCase   :					Optional[int]        =    image_features.pixel_values
           return encoding
      elif text is not None or query_images is not None:
           return encoding
      else:
           return BatchEncoding(data=dict(**A_       )     ,						tensor_type=A_       )

 def    __magic_name__       (		self :	Dict     ,						*A_ :	int     ,						**A_ :	Union[str, Any]       ):






      '''simple docstring'''




      return self.image_processor.post_process(*A_     ,						**A_       )

 def    __magic_name__       (		self :	List[str]     ,						*A_ :	Tuple     ,						**A_ :	Optional[int]       ):






      '''simple docstring'''




      return self.image_processor.post_process_object_detection(*A_     ,						**A_       )

 def    __magic_name__       (		self :	List[Any]     ,						*A_ :	int     ,						**A_ :	Dict       ):






      '''simple docstring'''




      return self.image_processor.post_process_image_guided_detection(*A_     ,						**A_       )

 def    __magic_name__       (		self :	Optional[Any]     ,						*A_ :	str     ,						**A_ :	Any       ):






      '''simple docstring'''




      return self.tokenizer.batch_decode(*A_     ,						**A_       )

 def    __magic_name__       (		self :	Optional[Any]     ,						*A_ :	int     ,						**A_ :	List[str]       ):






      '''simple docstring'''




      return self.tokenizer.decode(*A_     ,						**A_       )

 @property
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      warnings.warn(
          "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."     ,						A_     ,						)
      return self.image_processor_class


 @property
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      warnings.warn(
          "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."     ,						A_     ,						)
      return self.image_processor









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






