

from typing import Optional

import numpy as np
import torch
from torch import nn
from transformers import GPTaConfig, GPTaLMHeadModel
from transformers.modeling_utils import ModuleUtilsMixin

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin


class 			A						(							A__   ,							A__   ,							A__			):







    """simple docstring"""





    lowerCamelCase		     =							[r"h\.\d+\.attn\.bias", r"h\.\d+\.attn\.masked_bias"]


    @register_to_config
    def __init__(				self			:	Dict,lowercase_			:	List[str],lowercase_			:	Optional[Any],lowercase_			:	int = None,lowercase_			:	Tuple = 5_0_2_5_7,lowercase_			:	List[Any] = 1_0_2_4,lowercase_			:	Dict = 7_6_8,lowercase_			:	Optional[Any] = 1_2,lowercase_			:	Any = 1_2,lowercase_			:	List[Any] = None,lowercase_			:	List[str] = "gelu_new",lowercase_			:	Union[str, Any] = 0.1,lowercase_			:	Optional[Any] = 0.1,lowercase_			:	List[Any] = 0.1,lowercase_			:	Optional[Any] = 1E-5,lowercase_			:	List[str] = 0.02,lowercase_			:	int = True,lowercase_			:	Dict = True,lowercase_			:	str = False,lowercase_			:	Union[str, Any] = False,)->   Optional[Any]:





        '''simple docstring'''







        super().__init__()

        A__   				=       prefix_length

        if prefix_inner_dim != n_embd and prefix_hidden_dim is None:
            raise ValueError(
                F'`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and'
                F' `n_embd`: {n_embd} are not equal.'		)

        A__   				=       prefix_inner_dim
        A__   				=       prefix_hidden_dim

        A__   				=       (
            nn.Linear(self.prefix_inner_dim,self.prefix_hidden_dim		)
            if self.prefix_hidden_dim is not None
            else nn.Identity()
        )
        A__   				=       (
            nn.Linear(self.prefix_hidden_dim,__A		) if self.prefix_hidden_dim is not None else nn.Identity()
        )

        A__   				=       GPTaConfig(
            vocab_size=__A,n_positions=__A,n_embd=__A,n_layer=__A,n_head=__A,n_inner=__A,activation_function=__A,resid_pdrop=__A,embd_pdrop=__A,attn_pdrop=__A,layer_norm_epsilon=__A,initializer_range=__A,scale_attn_weights=__A,use_cache=__A,scale_attn_by_inverse_layer_idx=__A,reorder_and_upcast_attn=__A,)
        A__   				=       GPTaLMHeadModel(__A		)


    def 						snake_case__					(				self			:	Optional[int],lowercase_			:	int,lowercase_			:	List[str],lowercase_			:	Optional[Any] = None,lowercase_			:	str = None,)->   List[str]:





        '''simple docstring'''







        A__   				=       self.transformer.transformer.wte(__A		)
        A__   				=       self.encode_prefix(__A		)
        A__   				=       self.decode_prefix(__A		)
        A__   				=       torch.cat((prefix_embeds, embedding_text),dim=1		)

        if labels is not None:
            A__   				=       self.get_dummy_token(input_ids.shape[0],input_ids.device		)
            A__   				=       torch.cat((dummy_token, input_ids),dim=1		)
        A__   				=       self.transformer(inputs_embeds=__A,labels=__A,attention_mask=__A		)
        if self.prefix_hidden_dim is not None:
            return out, hidden
        else:
            return out


    def 						snake_case__					(				self			:	Dict,lowercase_			:	Tuple,lowercase_			:	Tuple		)->   torch.Tensor:





        '''simple docstring'''







        return torch.zeros(__A,self.prefix_length,dtype=torch.intaa,device=__A		)


    def 						snake_case__					(				self			:	List[Any],lowercase_			:	Tuple		)->   Optional[int]:





        '''simple docstring'''







        return self.encode_prefix(__A		)


    @torch.no_grad()
    def 						snake_case__					(				self			:	Tuple,lowercase_			:	Dict,lowercase_			:	Union[str, Any],lowercase_			:	List[Any]		)->   Optional[int]:





        '''simple docstring'''







        A__   				=       torch.split(__A,1,dim=0		)
        A__   				=       []
        A__   				=       []
        for feature in features:
            A__   				=       self.decode_prefix(feature.to(__A		)		)  # back to the clip feature
            # Only support beam search for now
            A__   				=       self.generate_beam(
                input_embeds=__A,device=__A,eos_token_id=__A		)
            generated_tokens.append(output_tokens[0]		)
            generated_seq_lengths.append(seq_lengths[0]		)
        A__   				=       torch.stack(__A		)
        A__   				=       torch.stack(__A		)
        return generated_tokens, generated_seq_lengths


    @torch.no_grad()
    def 						snake_case__					(				self			:	List[Any],lowercase_			:	Optional[Any]=None,lowercase_			:	Union[str, Any]=None,lowercase_			:	Any=None,lowercase_			:	Dict = 5,lowercase_			:	List[Any] = 6_7,lowercase_			:	Optional[Any] = 1.0,lowercase_			:	Dict = None,)->   Union[str, Any]:





        '''simple docstring'''







        A__   				=       eos_token_id
        A__   				=       None
        A__   				=       None
        A__   				=       torch.ones(__A,device=__A,dtype=torch.int		)
        A__   				=       torch.zeros(__A,device=__A,dtype=torch.bool		)

        if input_embeds is not None:
            A__   				=       input_embeds
        else:
            A__   				=       self.transformer.transformer.wte(__A		)

        for i in range(__A		):
            A__   				=       self.transformer(inputs_embeds=__A		)
            A__   				=       outputs.logits
            A__   				=       logits[:, -1, :] / (temperature if temperature > 0 else 1.0)
            A__   				=       logits.softmax(-1		).log()

            if scores is None:
                A__   				=       logits.topk(__A,-1		)
                A__   				=       generated.expand(__A,*generated.shape[1:]		)
                A__   				=       next_tokens.permute(1,0		), scores.squeeze(0		)
                if tokens is None:
                    A__   				=       next_tokens
                else:
                    A__   				=       tokens.expand(__A,*tokens.shape[1:]		)
                    A__   				=       torch.cat((tokens, next_tokens),dim=1		)
            else:
                A__   				=       -float(np.inf		)
                A__   				=       0
                A__   				=       scores[:, None] + logits
                seq_lengths[~is_stopped] += 1
                A__   				=       scores_sum / seq_lengths[:, None]
                A__   				=       scores_sum_average.view(-1		).topk(__A,-1		)
                A__   				=       next_tokens // scores_sum.shape[1]
                A__   				=       seq_lengths[next_tokens_source]
                A__   				=       next_tokens % scores_sum.shape[1]
                A__   				=       next_tokens.unsqueeze(1		)
                A__   				=       tokens[next_tokens_source]
                A__   				=       torch.cat((tokens, next_tokens),dim=1		)
                A__   				=       generated[next_tokens_source]
                A__   				=       scores_sum_average * seq_lengths
                A__   				=       is_stopped[next_tokens_source]

            A__   				=       self.transformer.transformer.wte(next_tokens.squeeze()		).view(generated.shape[0],1,-1		)
            A__   				=       torch.cat((generated, next_token_embed),dim=1		)
            A__   				=       is_stopped + next_tokens.eq(__A		).squeeze()
            if is_stopped.all():
                break

        A__   				=       scores / seq_lengths
        A__   				=       scores.argsort(descending=__A		)
        # tokens tensors are already padded to max_seq_length
        A__   				=       [tokens[i] for i in order]
        A__   				=       torch.stack(__A,dim=0		)
        A__   				=       torch.tensor([seq_lengths[i] for i in order],dtype=seq_lengths.dtype		)
        return output_texts, seq_lengths




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

