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							(			__lowerCAmelCase       ,			unittest.TestCase       ):







 """simple docstring"""






 lowerCamelCase	:List[Any]    			=		TextToVideoSDPipeline
 lowerCamelCase	:Any    			=		TEXT_TO_IMAGE_PARAMS
 lowerCamelCase	:Optional[Any]    			=		TEXT_TO_IMAGE_BATCH_PARAMS
 # No `output_type`.
 lowerCamelCase	:Optional[int]    			=		frozenset(
     [
         '''num_inference_steps''',
         '''generator''',
         '''latents''',
         '''return_dict''',
         '''callback''',
         '''callback_steps''',
     ]       )



 def      UpperCAmelCase							(					self							)  ->					Dict:
        torch.manual_seed(0							)
        _A        =  UNetaDConditionModel(
            block_out_channels=(32, 64, 64, 64)		,				layers_per_block=2		,				sample_size=32		,				in_channels=4		,				out_channels=4		,				down_block_types=("""CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """DownBlock3D""")		,				up_block_types=("""UpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""")		,				cross_attention_dim=32		,				attention_head_dim=4		,				)
        _A        =  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							)
        _A        =  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		,				sample_size=1_28		,				)
        torch.manual_seed(0							)
        _A        =  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		,				hidden_act="""gelu"""		,				projection_dim=5_12		,				)
        _A        =  CLIPTextModel(lowerCAmelCase_							)
        _A        =  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

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



 def      UpperCAmelCase							(					self		,				lowerCAmelCase_		,				lowerCAmelCase_=0							)  ->					str:
        if str(lowerCAmelCase_							).startswith("""mps"""							):
               _A        =  torch.manual_seed(lowerCAmelCase_							)
        else:
               _A        =  torch.Generator(device=lowerCAmelCase_							).manual_seed(lowerCAmelCase_							)
        _A        =  {
            """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      UpperCAmelCase							(					self							)  ->					List[Any]:
        _A        =  """cpu"""  # ensure determinism for the device-dependent torch.Generator
        _A        =  self.get_dummy_components()
        _A        =  TextToVideoSDPipeline(**lowerCAmelCase_							)
        _A        =  sd_pipe.to(lowerCAmelCase_							)
        sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_							)

        _A        =  self.get_dummy_inputs(lowerCAmelCase_							)
        _A        =  """np"""
        _A        =  sd_pipe(**lowerCAmelCase_							).frames
        _A        =  frames[0][-3:, -3:, -1]

        assert frames[0].shape == (64, 64, 3)
        _A        =  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      UpperCAmelCase							(					self							)  ->					int:
        self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCAmelCase_		,				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      UpperCAmelCase							(					self							)  ->					List[Any]:
        self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCAmelCase_		,				expected_max_diff=1E-2							)



 @unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""							)
 def      UpperCAmelCase							(					self							)  ->					Union[str, Any]:
        pass



 @unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""							)
 def      UpperCAmelCase							(					self							)  ->					List[Any]:
        pass



 @unittest.skip(reason="""`num_images_per_prompt` argument is not supported for this pipeline."""							)
 def      UpperCAmelCase							(					self							)  ->					List[Any]:
        pass



 def      UpperCAmelCase							(					self							)  ->					Optional[int]:
        return super().test_progress_bar()



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







 """simple docstring"""






 def      UpperCAmelCase							(					self							)  ->					List[Any]:
        _A        =  load_numpy(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"""							)

        _A        =  TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b"""							)
        _A        =  DPMSolverMultistepScheduler.from_config(pipe.scheduler.config							)
        _A        =  pipe.to("""cuda"""							)

        _A        =  """Spiderman is surfing"""
        _A        =  torch.Generator(device="""cpu"""							).manual_seed(0							)

        _A        =  pipe(lowerCAmelCase_		,				generator=lowerCAmelCase_		,				num_inference_steps=25		,				output_type="""pt"""							).frames
        _A        =  video_frames.cpu().numpy()

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



 def      UpperCAmelCase							(					self							)  ->					int:
        _A        =  load_numpy(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"""							)

        _A        =  TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b"""							)
        _A        =  pipe.to("""cuda"""							)

        _A        =  """Spiderman is surfing"""
        _A        =  torch.Generator(device="""cpu"""							).manual_seed(0							)

        _A        =  pipe(lowerCAmelCase_		,				generator=lowerCAmelCase_		,				num_inference_steps=2		,				output_type="""pt"""							).frames
        _A        =  video_frames.cpu().numpy()

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





import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE										=						logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE										=						{
    'BridgeTower/bridgetower-base': 'https://huggingface.co/BridgeTower/bridgetower-base/blob/main/config.json',
    'BridgeTower/bridgetower-base-itm-mlm': (
        'https://huggingface.co/BridgeTower/bridgetower-base-itm-mlm/blob/main/config.json'
    ),
}



class 				a							(			__lowerCAmelCase       ):







 """simple docstring"""






 lowerCamelCase	:Optional[Any]    			=		'''bridgetower_vision_model'''



 def __init__(					self		,				lowerCAmelCase_=7_68		,				lowerCAmelCase_=12		,				lowerCAmelCase_=3		,				lowerCAmelCase_=16		,				lowerCAmelCase_=2_88		,				lowerCAmelCase_=1		,				lowerCAmelCase_=1E-05		,				lowerCAmelCase_=False		,				lowerCAmelCase_=True		,				lowerCAmelCase_=False		,				**lowerCAmelCase_		,				)  ->					Any:
        super().__init__(**lowerCAmelCase_							)
        _A        =  hidden_size
        _A        =  num_hidden_layers
        _A        =  num_channels
        _A        =  patch_size
        _A        =  image_size
        _A        =  initializer_factor
        _A        =  layer_norm_eps
        _A        =  stop_gradient
        _A        =  share_layernorm
        _A        =  remove_last_layer



 @classmethod
 def      UpperCAmelCase							(					cls		,				lowerCAmelCase_		,				**lowerCAmelCase_							)  ->					"PretrainedConfig":
        _A   ,  _A        =  cls.get_config_dict(lowerCAmelCase_		,				**lowerCAmelCase_							)

        if config_dict.get("""model_type"""							) == "bridgetower":
               _A        =  config_dict["""text_config"""]

        if "model_type" in config_dict and hasattr(cls		,				"""model_type"""							) and config_dict["model_type"] != cls.model_type:
               logger.warning(
                   F'''You are using a model of type {config_dict['model_type']} to instantiate a model of type '''
                   F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''							)

        return cls.from_dict(lowerCAmelCase_		,				**lowerCAmelCase_							)



class 				a							(			__lowerCAmelCase       ):







 """simple docstring"""






 lowerCamelCase	:Union[str, Any]    			=		'''bridgetower_text_model'''



 def __init__(					self		,				lowerCAmelCase_=5_02_65		,				lowerCAmelCase_=7_68		,				lowerCAmelCase_=12		,				lowerCAmelCase_=12		,				lowerCAmelCase_=1		,				lowerCAmelCase_=30_72		,				lowerCAmelCase_="gelu"		,				lowerCAmelCase_=0.1		,				lowerCAmelCase_=0.1		,				lowerCAmelCase_=5_14		,				lowerCAmelCase_=1		,				lowerCAmelCase_=1E-05		,				lowerCAmelCase_=1		,				lowerCAmelCase_=0		,				lowerCAmelCase_=2		,				lowerCAmelCase_="absolute"		,				lowerCAmelCase_=True		,				**lowerCAmelCase_		,				)  ->					Optional[Any]:
        super().__init__(**lowerCAmelCase_							)

        _A        =  vocab_size
        _A        =  hidden_size
        _A        =  num_hidden_layers
        _A        =  num_attention_heads
        _A        =  hidden_act
        _A        =  initializer_factor
        _A        =  intermediate_size
        _A        =  hidden_dropout_prob
        _A        =  attention_probs_dropout_prob
        _A        =  max_position_embeddings
        _A        =  type_vocab_size
        _A        =  layer_norm_eps
        _A        =  position_embedding_type
        _A        =  use_cache
        _A        =  pad_token_id
        _A        =  bos_token_id
        _A        =  eos_token_id



 @classmethod
 def      UpperCAmelCase							(					cls		,				lowerCAmelCase_		,				**lowerCAmelCase_							)  ->					"PretrainedConfig":
        _A   ,  _A        =  cls.get_config_dict(lowerCAmelCase_		,				**lowerCAmelCase_							)

        if config_dict.get("""model_type"""							) == "bridgetower":
               _A        =  config_dict["""text_config"""]

        if "model_type" in config_dict and hasattr(cls		,				"""model_type"""							) and config_dict["model_type"] != cls.model_type:
               logger.warning(
                   F'''You are using a model of type {config_dict['model_type']} to instantiate a model of type '''
                   F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''							)

        return cls.from_dict(lowerCAmelCase_		,				**lowerCAmelCase_							)



class 				a							(			__lowerCAmelCase       ):







 """simple docstring"""






 lowerCamelCase	:Optional[int]    			=		'''bridgetower'''



 def __init__(					self		,				lowerCAmelCase_=True		,				lowerCAmelCase_="gelu"		,				lowerCAmelCase_=7_68		,				lowerCAmelCase_=1		,				lowerCAmelCase_=1E-05		,				lowerCAmelCase_=False		,				lowerCAmelCase_="add"		,				lowerCAmelCase_=12		,				lowerCAmelCase_=6		,				lowerCAmelCase_=False		,				lowerCAmelCase_=False		,				lowerCAmelCase_=None		,				lowerCAmelCase_=None		,				**lowerCAmelCase_		,				)  ->					int:
        # TODO: remove this once the Hub files are updated.
        _A        =  kwargs.pop("""text_config_dict"""		,				lowerCAmelCase_							)
        _A        =  kwargs.pop("""vision_config_dict"""		,				lowerCAmelCase_							)

        super().__init__(**lowerCAmelCase_							)
        _A        =  share_cross_modal_transformer_layers
        _A        =  hidden_act
        _A        =  hidden_size
        _A        =  initializer_factor
        _A        =  layer_norm_eps
        _A        =  share_link_tower_layers
        _A        =  link_tower_type
        _A        =  num_attention_heads
        _A        =  num_hidden_layers
        _A        =  tie_word_embeddings
        _A        =  init_layernorm_from_vision_encoder

        if text_config is None:
               _A        =  {}
               logger.info("""`text_config` is `None`. Initializing the `BridgeTowerTextConfig` with default values."""							)

        if vision_config is None:
               _A        =  {}
               logger.info("""`vision_config` is `None`. Initializing the `BridgeTowerVisionConfig` with default values."""							)

        _A        =  BridgeTowerTextConfig(**lowerCAmelCase_							)
        _A        =  BridgeTowerVisionConfig(**lowerCAmelCase_							)



 @classmethod
 def      UpperCAmelCase							(					cls		,				lowerCAmelCase_		,				lowerCAmelCase_		,				**lowerCAmelCase_							)  ->					Any:
        return cls(text_config=text_config.to_dict()		,				vision_config=vision_config.to_dict()		,				**lowerCAmelCase_							)



 def      UpperCAmelCase							(					self							)  ->					Union[str, Any]:
        _A        =  copy.deepcopy(self.__dict__							)
        _A        =  self.text_config.to_dict()
        _A        =  self.vision_config.to_dict()
        _A        =  self.__class__.model_type
        return output




