





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







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__							:List[str]	     =					VideoToVideoSDPipeline
  SCREAMING_SNAKE_CASE__							:int	     =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({"video"}   ) - {"image", "width", "height"}
  SCREAMING_SNAKE_CASE__							:Dict	     =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"video"}   ) - {"image"}
  SCREAMING_SNAKE_CASE__							:Any	     =					PipelineTesterMixin.required_optional_params - {"latents"}
  SCREAMING_SNAKE_CASE__							:Any	     =					False

  # No `output_type`.
  SCREAMING_SNAKE_CASE__							:Any	     =					frozenset(
      [
          "num_inference_steps",
          "generator",
          "latents",
          "return_dict",
          "callback",
          "callback_steps",
      ]   )

  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[int]	)		->				Optional[int]:
        torch.manual_seed(0	)
        _UpperCamelCase      :	List[str]						=       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					,   )
        _UpperCamelCase      :	str						=       DDIMScheduler(
            beta_start=0.0_00_85					,   beta_end=0.0_12					,   beta_schedule="scaled_linear"					,   clip_sample=__a					,   set_alpha_to_one=__a					,   )
        torch.manual_seed(0	)
        _UpperCamelCase      :	int						=       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	)
        _UpperCamelCase      :	Union[str, 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=1000					,   hidden_act="gelu"					,   projection_dim=512					,   )
        _UpperCamelCase      :	Any						=       CLIPTextModel(__a	)
        _UpperCamelCase      :	int						=       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

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

  def    __SCREAMING_SNAKE_CASE				(		self   :       Any					,   __a   :       Optional[int]					,   __a   :       List[Any]=0	)		->				int:
        # 3 frames
        _UpperCamelCase      :	Union[str, Any]						=       floats_tensor((1, 3, 3, 32, 32)					,   rng=random.Random(__a	)	).to(__a	)

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

        _UpperCamelCase      :	Tuple						=       self.get_dummy_inputs(__a	)
        _UpperCamelCase      :	str						=       "np"
        _UpperCamelCase      :	Optional[Any]						=       sd_pipe(**__a	).frames
        _UpperCamelCase      :	List[Any]						=       frames[0][-3:, -3:, -1]

        assert frames[0].shape == (32, 32, 3)
        _UpperCamelCase      :	Optional[Any]						=       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    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				Optional[Any]:
        self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__a					,   expected_max_diff=5e-3	)

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

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

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


  def    __SCREAMING_SNAKE_CASE				(		self   :       str	)		->				List[Any]:
        return super().test_progress_bar()





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







  '''simple docstring'''


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

        # 10 frames
        _UpperCamelCase      :	Tuple						=       torch.Generator(device="cpu"	).manual_seed(0	)
        _UpperCamelCase      :	Optional[int]						=       torch.randn((1, 10, 3, 1024, 576)					,   generator=__a	)
        _UpperCamelCase      :	Dict						=       video.to("cuda"	)

        _UpperCamelCase      :	int						=       "Spiderman is surfing"

        _UpperCamelCase      :	List[Any]						=       pipe(__a					,   video=__a					,   generator=__a					,   num_inference_steps=3					,   output_type="pt"	).frames

        _UpperCamelCase      :	List[Any]						=       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







"""simple docstring"""


from collections import defaultdict
from math import ceil, sqrt




def 					lowercase__    (					lowercase_ = 1_000_000		,lowercase_ = 10			)					->		int:




      """simple docstring"""

      _UpperCamelCase      :	defaultdict						=       defaultdict(lowercase_			)

      for outer_width in range(3		,(t_limit // 4) + 2			):
            if outer_width * outer_width > t_limit:
                  _UpperCamelCase      :	Any						=       max(
                      ceil(sqrt(outer_width * outer_width - t_limit			)			)		,1			)
            else:
                  _UpperCamelCase      :	str						=       1

            hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

            for hole_width in range(lowercase_		,outer_width - 1		,2			):
                  count[outer_width * outer_width - hole_width * hole_width] += 1

      return sum(1 for n in count.values() if 1 <= n <= 10			)


if __name__ == "__main__":
  print(f"""{solution() = }""")
