


"""simple docstring"""


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


     """simple docstring"""
     snake_case__						:       str				    =VideoToVideoSDPipeline
     snake_case__						:       int				    =TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'''video'''}) - {'''image''', '''width''', '''height'''}
     snake_case__						:       Tuple				    =TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''video'''}) - {'''image'''}
     snake_case__						:       Optional[Any]				    =PipelineTesterMixin.required_optional_params - {'''latents'''}
     snake_case__						:       Union[str, Any]				    =False

     # No `output_type`.
     snake_case__						:       Optional[int]				    =frozenset(
         [
             '''num_inference_steps''',
             '''generator''',
             '''latents''',
             '''return_dict''',
             '''callback''',
             '''callback_steps''',
         ])

     def 		a__    (						self:    Optional[int]						)->     Union[str, Any]:
           torch.manual_seed(0						)
           lowerCamelCase       :       Optional[Any]   =						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  ,		)
           lowerCamelCase       :       Any   =						DDIMScheduler(
               beta_start=0.0_00_85  ,		beta_end=0.0_12  ,		beta_schedule="""scaled_linear"""  ,		clip_sample=lowerCAmelCase__  ,		set_alpha_to_one=lowerCAmelCase__  ,		)
           torch.manual_seed(0						)
           lowerCamelCase       :       List[str]   =						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=128  ,		)
           torch.manual_seed(0						)
           lowerCamelCase       :       Any   =						CLIPTextConfig(
               bos_token_id=0  ,		eos_token_id=2  ,		hidden_size=32  ,		intermediate_size=37  ,		layer_norm_eps=1e-0_5  ,		num_attention_heads=4  ,		num_hidden_layers=5  ,		pad_token_id=1  ,		vocab_size=1_000  ,		hidden_act="""gelu"""  ,		projection_dim=512  ,		)
           lowerCamelCase       :       List[str]   =						CLIPTextModel(lowerCAmelCase__						)
           lowerCamelCase       :       Union[str, Any]   =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)

           lowerCamelCase       :       int   =						{
               'unet': unet,
               'scheduler': scheduler,
               'vae': vae,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
           }
           return components

     def 		a__    (						self:    Any  ,		__a:    Optional[int]  ,		__a:    int=0						)->     str:
           lowerCamelCase       :       int   =						floats_tensor((1, 3, 3, 32, 32)  ,		rng=random.Random(lowerCAmelCase__						)						).to(lowerCAmelCase__						)

           if str(lowerCAmelCase__						).startswith("""mps"""						):
                 lowerCamelCase       :       int   =						torch.manual_seed(lowerCAmelCase__						)
           else:
                 lowerCamelCase       :       Any   =						torch.Generator(device=lowerCAmelCase__						).manual_seed(lowerCAmelCase__						)
           lowerCamelCase       :       str   =						{
               '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 		a__    (						self:    Dict						)->     List[str]:
           lowerCamelCase       :       Optional[int]   =						'cpu'  # ensure determinism for the device-dependent torch.Generator
           lowerCamelCase       :       Tuple   =						self.get_dummy_components()
           lowerCamelCase       :       Dict   =						VideoToVideoSDPipeline(**lowerCAmelCase__						)
           lowerCamelCase       :       Dict   =						sd_pipe.to(lowerCAmelCase__						)
           sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__						)

           lowerCamelCase       :       Optional[Any]   =						self.get_dummy_inputs(lowerCAmelCase__						)
           lowerCamelCase       :       str   =						'np'
           lowerCamelCase       :       Any   =						sd_pipe(**lowerCAmelCase__						).frames
           lowerCamelCase       :       Optional[int]   =						frames[0][-3:, -3:, -1]

           assert frames[0].shape == (32, 32, 3)
           lowerCamelCase       :       str   =						np.array([106, 117, 113, 174, 137, 112, 148, 151, 131]						)

           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 		a__    (						self:    int						)->     Optional[int]:
           self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCAmelCase__  ,		expected_max_diff=5e-3						)

     @unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""						)
     def 		a__    (						self:    str						)->     Tuple:
           pass

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

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







     def 		a__    (						self:    Optional[int]						)->     Union[str, Any]:
           return super().test_progress_bar()


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


     """simple docstring"""

     def 		a__    (						self:    int						)->     int:
           lowerCamelCase       :       List[str]   =						VideoToVideoSDPipeline.from_pretrained("""cerspense/zeroscope_v2_XL"""  ,		torch_dtype=torch.floataa						)
           pipe.enable_model_cpu_offload()

           # 10 frames
           lowerCamelCase       :       Optional[Any]   =						torch.Generator(device="""cpu"""						).manual_seed(0						)
           lowerCamelCase       :       List[str]   =						torch.randn((1, 10, 3, 1_024, 576)  ,		generator=lowerCAmelCase__						)
           lowerCamelCase       :       Dict   =						video.to("""cuda"""						)

           lowerCamelCase       :       List[Any]   =						'Spiderman is surfing'

           lowerCamelCase       :       Optional[Any]   =						pipe(lowerCAmelCase__  ,		video=lowerCAmelCase__  ,		generator=lowerCAmelCase__  ,		num_inference_steps=3  ,		output_type="""pt"""						).frames

           lowerCamelCase       :       str   =						np.array([-1.0_45_89_84, -1.1_27_92_97, -0.9_66_30_86, -0.91_50_39_06, -0.75_09_76_56]						)
           assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array						).sum() < 1e-2








import webbrowser
from sys import argv
from urllib.parse import parse_qs, quote

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

if __name__ == "__main__":
				lowerCAmelCase__			:      Optional[int]								='%20'.join(argv[1:]) if len(argv) > 1 else quote(str(input('Search: ')))

				print('Googling.....')

				lowerCAmelCase__			:      Optional[int]								=F"""https://www.google.com/search?q={query}&num=100"""

				lowerCAmelCase__			:      Union[str, Any]								=requests.get(
				    url,
				    headers={'User-Agent': str(UserAgent().random)},
				)

				try:
								lowerCAmelCase__			:      str								=(
								    BeautifulSoup(res.text, 'html.parser')
								    .find('div', attrs={'class': 'yuRUbf'})
								    .find('a')
								    .get('href')
								)

				except AttributeError:
								lowerCAmelCase__			:      Optional[Any]								=parse_qs(
								    BeautifulSoup(res.text, 'html.parser')
								    .find('div', attrs={'class': 'kCrYT'})
								    .find('a')
								    .get('href')
								)['url'][0]

				webbrowser.open(link)





