

import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
lowercase_			=  logging.get_logger(__name__)
def 						_snake_case(   SCREAMING_SNAKE_CASE__      :     Tuple				)							->				Union[str, Any]:





    '''simple docstring'''






    A__   				=       SwinConfig(
        embed_dim=192   ,      depths=(2, 2, 18, 2)   ,      num_heads=(6, 12, 24, 48)   ,      window_size=12   ,      out_features=['stage2', 'stage3', 'stage4']   ,      )

    A__   				=       DetaConfig(
        backbone_config=SCREAMING_SNAKE_CASE__   ,      num_queries=900   ,      encoder_ffn_dim=2048   ,      decoder_ffn_dim=2048   ,      num_feature_levels=5   ,      assign_first_stage=SCREAMING_SNAKE_CASE__   ,      with_box_refine=SCREAMING_SNAKE_CASE__   ,      two_stage=SCREAMING_SNAKE_CASE__   ,      )

    # set labels
    A__   				=       'huggingface/label-files'
    if "o365" in model_name:
        A__   				=       366
        A__   				=       'object365-id2label.json'
    else:
        A__   				=       91
        A__   				=       'coco-detection-id2label.json'

    A__   				=       num_labels
    A__   				=       json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE__   ,      SCREAMING_SNAKE_CASE__   ,      repo_type='dataset'				)				)   ,      'r'				)				)
    A__   				=       {int(SCREAMING_SNAKE_CASE__				): v for k, v in idalabel.items()}
    A__   				=       idalabel
    A__   				=       {v: k for k, v in idalabel.items()}

    return config
def 						_snake_case(   SCREAMING_SNAKE_CASE__      :     str				)							->				int:





    '''simple docstring'''






    A__   				=       []

    # stem
    # fmt: off
    rename_keys.append(('backbone.0.body.patch_embed.proj.weight', 'model.backbone.model.embeddings.patch_embeddings.projection.weight')				)
    rename_keys.append(('backbone.0.body.patch_embed.proj.bias', 'model.backbone.model.embeddings.patch_embeddings.projection.bias')				)
    rename_keys.append(('backbone.0.body.patch_embed.norm.weight', 'model.backbone.model.embeddings.norm.weight')				)
    rename_keys.append(('backbone.0.body.patch_embed.norm.bias', 'model.backbone.model.embeddings.norm.bias')				)
    # stages
    for i in range(len(config.backbone_config.depths				)				):
        for j in range(config.backbone_config.depths[i]				):
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm1.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm1.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm2.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm2.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias')				)

        if i < 3:
            rename_keys.append((f'backbone.0.body.layers.{i}.downsample.reduction.weight', f'model.backbone.model.encoder.layers.{i}.downsample.reduction.weight')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.downsample.norm.weight', f'model.backbone.model.encoder.layers.{i}.downsample.norm.weight')				)
            rename_keys.append((f'backbone.0.body.layers.{i}.downsample.norm.bias', f'model.backbone.model.encoder.layers.{i}.downsample.norm.bias')				)

    rename_keys.append(('backbone.0.body.norm1.weight', 'model.backbone.model.hidden_states_norms.stage2.weight')				)
    rename_keys.append(('backbone.0.body.norm1.bias', 'model.backbone.model.hidden_states_norms.stage2.bias')				)
    rename_keys.append(('backbone.0.body.norm2.weight', 'model.backbone.model.hidden_states_norms.stage3.weight')				)
    rename_keys.append(('backbone.0.body.norm2.bias', 'model.backbone.model.hidden_states_norms.stage3.bias')				)
    rename_keys.append(('backbone.0.body.norm3.weight', 'model.backbone.model.hidden_states_norms.stage4.weight')				)
    rename_keys.append(('backbone.0.body.norm3.bias', 'model.backbone.model.hidden_states_norms.stage4.bias')				)

    # transformer encoder
    for i in range(config.encoder_layers				):
        rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight', f'model.encoder.layers.{i}.self_attn.sampling_offsets.weight')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias', f'model.encoder.layers.{i}.self_attn.sampling_offsets.bias')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.attention_weights.weight', f'model.encoder.layers.{i}.self_attn.attention_weights.weight')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.attention_weights.bias', f'model.encoder.layers.{i}.self_attn.attention_weights.bias')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.value_proj.weight', f'model.encoder.layers.{i}.self_attn.value_proj.weight')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.value_proj.bias', f'model.encoder.layers.{i}.self_attn.value_proj.bias')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.output_proj.weight', f'model.encoder.layers.{i}.self_attn.output_proj.weight')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.output_proj.bias', f'model.encoder.layers.{i}.self_attn.output_proj.bias')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.norm1.weight', f'model.encoder.layers.{i}.self_attn_layer_norm.weight')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.norm1.bias', f'model.encoder.layers.{i}.self_attn_layer_norm.bias')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.linear1.weight', f'model.encoder.layers.{i}.fc1.weight')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.linear1.bias', f'model.encoder.layers.{i}.fc1.bias')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.linear2.weight', f'model.encoder.layers.{i}.fc2.weight')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.linear2.bias', f'model.encoder.layers.{i}.fc2.bias')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.norm2.weight', f'model.encoder.layers.{i}.final_layer_norm.weight')				)
        rename_keys.append((f'transformer.encoder.layers.{i}.norm2.bias', f'model.encoder.layers.{i}.final_layer_norm.bias')				)

    # transformer decoder
    for i in range(config.decoder_layers				):
        rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight', f'model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias', f'model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.attention_weights.weight', f'model.decoder.layers.{i}.encoder_attn.attention_weights.weight')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.attention_weights.bias', f'model.decoder.layers.{i}.encoder_attn.attention_weights.bias')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.value_proj.weight', f'model.decoder.layers.{i}.encoder_attn.value_proj.weight')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.value_proj.bias', f'model.decoder.layers.{i}.encoder_attn.value_proj.bias')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.output_proj.weight', f'model.decoder.layers.{i}.encoder_attn.output_proj.weight')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.output_proj.bias', f'model.decoder.layers.{i}.encoder_attn.output_proj.bias')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.norm1.weight', f'model.decoder.layers.{i}.encoder_attn_layer_norm.weight')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.norm1.bias', f'model.decoder.layers.{i}.encoder_attn_layer_norm.bias')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.self_attn.out_proj.weight', f'model.decoder.layers.{i}.self_attn.out_proj.weight')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.self_attn.out_proj.bias', f'model.decoder.layers.{i}.self_attn.out_proj.bias')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.norm2.weight', f'model.decoder.layers.{i}.self_attn_layer_norm.weight')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.norm2.bias', f'model.decoder.layers.{i}.self_attn_layer_norm.bias')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.linear1.weight', f'model.decoder.layers.{i}.fc1.weight')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.linear1.bias', f'model.decoder.layers.{i}.fc1.bias')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.linear2.weight', f'model.decoder.layers.{i}.fc2.weight')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.linear2.bias', f'model.decoder.layers.{i}.fc2.bias')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.norm3.weight', f'model.decoder.layers.{i}.final_layer_norm.weight')				)
        rename_keys.append((f'transformer.decoder.layers.{i}.norm3.bias', f'model.decoder.layers.{i}.final_layer_norm.bias')				)

    # fmt: on

    return rename_keys
def 						_snake_case(   SCREAMING_SNAKE_CASE__      :     Optional[int]   ,      SCREAMING_SNAKE_CASE__      :     Any   ,      SCREAMING_SNAKE_CASE__      :     str				)							->				Dict:





    '''simple docstring'''






    A__   				=       dct.pop(SCREAMING_SNAKE_CASE__				)
    A__   				=       val
def 						_snake_case(   SCREAMING_SNAKE_CASE__      :     List[Any]   ,      SCREAMING_SNAKE_CASE__      :     str				)							->				Optional[Any]:





    '''simple docstring'''






    A__   				=       [int(backbone_config.embed_dim * 2**i				) for i in range(len(backbone_config.depths				)				)]
    for i in range(len(backbone_config.depths				)				):
        A__   				=       num_features[i]
        for j in range(backbone_config.depths[i]				):
            # fmt: off
            # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
            A__   				=       state_dict.pop(f'backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight'				)
            A__   				=       state_dict.pop(f'backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias'				)
            # next, add query, keys and values (in that order) to the state dict
            A__   				=       in_proj_weight[:dim, :]
            A__   				=       in_proj_bias[: dim]
            A__   				=       in_proj_weight[
                dim : dim * 2, :
            ]
            A__   				=       in_proj_bias[
                dim : dim * 2
            ]
            A__   				=       in_proj_weight[
                -dim :, :
            ]
            A__   				=       in_proj_bias[-dim :]
            # fmt: on
def 						_snake_case(   SCREAMING_SNAKE_CASE__      :     Optional[Any]   ,      SCREAMING_SNAKE_CASE__      :     Any				)							->				Dict:





    '''simple docstring'''






    A__   				=       config.d_model
    for i in range(config.decoder_layers				):
        # read in weights + bias of input projection layer of self-attention
        A__   				=       state_dict.pop(f'transformer.decoder.layers.{i}.self_attn.in_proj_weight'				)
        A__   				=       state_dict.pop(f'transformer.decoder.layers.{i}.self_attn.in_proj_bias'				)
        # next, add query, keys and values (in that order) to the state dict
        A__   				=       in_proj_weight[:hidden_size, :]
        A__   				=       in_proj_bias[:hidden_size]
        A__   				=       in_proj_weight[
            hidden_size : hidden_size * 2, :
        ]
        A__   				=       in_proj_bias[hidden_size : hidden_size * 2]
        A__   				=       in_proj_weight[-hidden_size:, :]
        A__   				=       in_proj_bias[-hidden_size:]
def 						_snake_case(   )							->				Dict:





    '''simple docstring'''






    A__   				=       'http://images.cocodataset.org/val2017/000000039769.jpg'
    A__   				=       Image.open(requests.get(SCREAMING_SNAKE_CASE__   ,      stream=SCREAMING_SNAKE_CASE__				).raw				)

    return im
@torch.no_grad()
def 						_snake_case(   SCREAMING_SNAKE_CASE__      :     Optional[int]   ,      SCREAMING_SNAKE_CASE__      :     List[str]   ,      SCREAMING_SNAKE_CASE__      :     Tuple				)							->				List[str]:





    '''simple docstring'''






    A__   				=       get_deta_config(SCREAMING_SNAKE_CASE__				)

    # load original state dict
    if model_name == "deta-swin-large":
        A__   				=       hf_hub_download(repo_id='nielsr/deta-checkpoints'   ,      filename='adet_swin_ft.pth'				)
    elif model_name == "deta-swin-large-o365":
        A__   				=       hf_hub_download(repo_id='jozhang97/deta-swin-l-o365'   ,      filename='deta_swin_pt_o365.pth'				)
    else:
        raise ValueError(f'Model name {model_name} not supported'				)

    A__   				=       torch.load(SCREAMING_SNAKE_CASE__   ,      map_location='cpu'				)['model']

    # original state dict
    for name, param in state_dict.items():
        print(SCREAMING_SNAKE_CASE__   ,      param.shape				)

    # rename keys
    A__   				=       create_rename_keys(SCREAMING_SNAKE_CASE__				)
    for src, dest in rename_keys:
        rename_key(SCREAMING_SNAKE_CASE__   ,      SCREAMING_SNAKE_CASE__   ,      SCREAMING_SNAKE_CASE__				)
    read_in_swin_q_k_v(SCREAMING_SNAKE_CASE__   ,      config.backbone_config				)
    read_in_decoder_q_k_v(SCREAMING_SNAKE_CASE__   ,      SCREAMING_SNAKE_CASE__				)

    # fix some prefixes
    for key in state_dict.copy().keys():
        if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
            A__   				=       state_dict.pop(SCREAMING_SNAKE_CASE__				)
            A__   				=       val
        if "input_proj" in key:
            A__   				=       state_dict.pop(SCREAMING_SNAKE_CASE__				)
            A__   				=       val
        if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
            A__   				=       state_dict.pop(SCREAMING_SNAKE_CASE__				)
            A__   				=       val

    # finally, create HuggingFace model and load state dict
    A__   				=       DetaForObjectDetection(SCREAMING_SNAKE_CASE__				)
    model.load_state_dict(SCREAMING_SNAKE_CASE__				)
    model.eval()

    A__   				=       'cuda' if torch.cuda.is_available() else 'cpu'
    model.to(SCREAMING_SNAKE_CASE__				)

    # load image processor
    A__   				=       DetaImageProcessor(format='coco_detection'				)

    # verify our conversion on image
    A__   				=       prepare_img()
    A__   				=       processor(images=SCREAMING_SNAKE_CASE__   ,      return_tensors='pt'				)
    A__   				=       encoding['pixel_values']
    A__   				=       model(pixel_values.to(SCREAMING_SNAKE_CASE__				)				)

    # verify logits
    print('Logits:'   ,      outputs.logits[0, :3, :3]				)
    print('Boxes:'   ,      outputs.pred_boxes[0, :3, :3]				)
    if model_name == "deta-swin-large":
        A__   				=       torch.tensor(
            [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]]				)
        A__   				=       torch.tensor([[0.4987, 0.4969, 0.9999], [0.2549, 0.5498, 0.4805], [0.5498, 0.2757, 0.0569]]				)
    elif model_name == "deta-swin-large-o365":
        A__   				=       torch.tensor(
            [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]]				)
        A__   				=       torch.tensor([[0.2523, 0.5549, 0.4881], [0.7715, 0.4149, 0.4601], [0.5503, 0.2753, 0.0575]]				)
    assert torch.allclose(outputs.logits[0, :3, :3]   ,      expected_logits.to(SCREAMING_SNAKE_CASE__				)   ,      atol=1E-4				)
    assert torch.allclose(outputs.pred_boxes[0, :3, :3]   ,      expected_boxes.to(SCREAMING_SNAKE_CASE__				)   ,      atol=1E-4				)
    print('Everything ok!'				)

    if pytorch_dump_folder_path:
        # Save model and processor
        logger.info(f'Saving PyTorch model and processor to {pytorch_dump_folder_path}...'				)
        Path(SCREAMING_SNAKE_CASE__				).mkdir(exist_ok=SCREAMING_SNAKE_CASE__				)
        model.save_pretrained(SCREAMING_SNAKE_CASE__				)
        processor.save_pretrained(SCREAMING_SNAKE_CASE__				)

    # Push to hub
    if push_to_hub:
        print('Pushing model and processor to hub...'				)
        model.push_to_hub(f'jozhang97/{model_name}'				)
        processor.push_to_hub(f'jozhang97/{model_name}'				)


if __name__ == "__main__":
     lowercase_			=  argparse.ArgumentParser()

     parser.add_argument(
         "--model_name",
         type=str,
         default="deta-swin-large",
         choices=["deta-swin-large", "deta-swin-large-o365"],
         help="Name of the model you'd like to convert.",
     )
     parser.add_argument(
         "--pytorch_dump_folder_path",
         default=None,
         type=str,
         help="Path to the folder to output PyTorch model.",
     )
     parser.add_argument(
         "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
     )
     lowercase_			=  parser.parse_args()
     convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    UNetaDConditionModel,
    VideoToVideoSDPipeline,
)
from diffusers.utils import floats_tensor, is_xformers_available, skip_mps
from diffusers.utils.testing_utils import enable_full_determinism, slow, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


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







    """simple docstring"""





    lowerCamelCase		     =							VideoToVideoSDPipeline
    lowerCamelCase		     =							TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'video'}			) - {'image', 'width', 'height'}
    lowerCamelCase		     =							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'video'}			) - {'image'}
    lowerCamelCase		     =							PipelineTesterMixin.required_optional_params - {'latents'}
    lowerCamelCase		     =							False

    # No `output_type`.
    lowerCamelCase		     =							frozenset(
        [
            'num_inference_steps',
            'generator',
            'latents',
            'return_dict',
            'callback',
            'callback_steps',
        ]			)


    def 						snake_case__					(				self			:	Tuple		)->   Optional[int]:





        '''simple docstring'''







        torch.manual_seed(0		)
        A__   				=       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,)
        A__   				=       DDIMScheduler(
            beta_start=0.00_085,beta_end=0.012,beta_schedule='scaled_linear',clip_sample=lowercase_,set_alpha_to_one=lowercase_,)
        torch.manual_seed(0		)
        A__   				=       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		)
        A__   				=       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,)
        A__   				=       CLIPTextModel(lowercase_		)
        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 						snake_case__					(				self			:	Optional[Any],lowercase_			:	Optional[int],lowercase_			:	List[Any]=0		)->   Any:





        '''simple docstring'''







        A__   				=       floats_tensor((1, 3, 3, 3_2, 3_2),rng=random.Random(lowercase_		)		).to(lowercase_		)

        if str(lowercase_		).startswith('mps'		):
            A__   				=       torch.manual_seed(lowercase_		)
        else:
            A__   				=       torch.Generator(device=lowercase_		).manual_seed(lowercase_		)
        A__   				=       {
            'prompt': 'A painting of a squirrel eating a burger',
            'video': video,
            'generator': generator,
            'num_inference_steps': 2,
            'guidance_scale': 6.0,
            'output_type': 'pt',
        }
        return inputs


    def 						snake_case__					(				self			:	List[Any]		)->   List[Any]:





        '''simple docstring'''







        A__   				=       'cpu'  # ensure determinism for the device-dependent torch.Generator
        A__   				=       self.get_dummy_components()
        A__   				=       VideoToVideoSDPipeline(**lowercase_		)
        A__   				=       sd_pipe.to(lowercase_		)
        sd_pipe.set_progress_bar_config(disable=lowercase_		)

        A__   				=       self.get_dummy_inputs(lowercase_		)
        A__   				=       'np'
        A__   				=       sd_pipe(**lowercase_		).frames
        A__   				=       frames[0][-3:, -3:, -1]

        assert frames[0].shape == (3_2, 3_2, 3)
        A__   				=       np.array([1_0_6, 1_1_7, 1_1_3, 1_7_4, 1_3_7, 1_1_2, 1_4_8, 1_5_1, 1_3_1]		)

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


    @unittest.skipIf(
        torch_device != 'cuda' or not is_xformers_available(),reason='XFormers attention is only available with CUDA and `xformers` installed',)
    def 						snake_case__					(				self			:	Optional[Any]		)->   int:





        '''simple docstring'''







        self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowercase_,expected_max_diff=5E-3		)


    @unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'		)
    def 						snake_case__					(				self			:	Any		)->   Optional[int]:





        '''simple docstring'''







        pass


    @unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'		)
    def 						snake_case__					(				self			:	int		)->   int:





        '''simple docstring'''







        pass


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





        '''simple docstring'''







        pass


    def 						snake_case__					(				self			:	Optional[int]		)->   Optional[Any]:





        '''simple docstring'''







        return super().test_progress_bar()




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







    """simple docstring"""





    def 						snake_case__					(				self			:	List[str]		)->   Dict:





        '''simple docstring'''







        A__   				=       VideoToVideoSDPipeline.from_pretrained('cerspense/zeroscope_v2_XL',torch_dtype=torch.floataa		)
        pipe.enable_model_cpu_offload()

        # 10 frames
        A__   				=       torch.Generator(device='cpu'		).manual_seed(0		)
        A__   				=       torch.randn((1, 1_0, 3, 1_0_2_4, 5_7_6),generator=lowercase_		)
        A__   				=       video.to('cuda'		)

        A__   				=       'Spiderman is surfing'

        A__   				=       pipe(lowercase_,video=lowercase_,generator=lowercase_,num_inference_steps=3,output_type='pt'		).frames

        A__   				=       np.array([-1.0_458_984, -1.1_279_297, -0.9_663_086, -0.91_503_906, -0.75_097_656]		)
        assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array		).sum() < 1E-2

