






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






      '''simple docstring'''

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

      # No `output_type`.
      __UpperCamelCase							=						frozenset(
          [
              "num_inference_steps",
              "generator",
              "latents",
              "return_dict",
              "callback",
              "callback_steps",
          ]				)
      def _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


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

          SCREAMING_SNAKE_CASE_   :						List[str]							=	{
              '''unet''': unet,
              '''scheduler''': scheduler,
              '''vae''': vae,
              '''text_encoder''': text_encoder,
              '''tokenizer''': tokenizer,
          }
          return components
      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple		,			lowercase_  :						int		,			lowercase_  :						Optional[int]=0):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[Any]							=	floats_tensor((1, 3, 3, 32, 32)		,			rng=random.Random(lowercase_)).to(lowercase_)

          if str(lowercase_).startswith('''mps'''):
              SCREAMING_SNAKE_CASE_   :						List[Any]							=	torch.manual_seed(lowercase_)
          else:
              SCREAMING_SNAKE_CASE_   :						Any							=	torch.Generator(device=lowercase_).manual_seed(lowercase_)
          SCREAMING_SNAKE_CASE_   :						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  :						Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[str]							=	'''cpu'''  # ensure determinism for the device-dependent torch.Generator
          SCREAMING_SNAKE_CASE_   :						List[str]							=	self.get_dummy_components()
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	VideoToVideoSDPipeline(**lowercase_)
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	sd_pipe.to(lowercase_)
          sd_pipe.set_progress_bar_config(disable=lowercase_)

          SCREAMING_SNAKE_CASE_   :						List[Any]							=	self.get_dummy_inputs(lowercase_)
          SCREAMING_SNAKE_CASE_   :						int							=	'''np'''
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	sd_pipe(**lowercase_).frames
          SCREAMING_SNAKE_CASE_   :						Dict							=	frames[0][-3:, -3:, -1]

          assert frames[0].shape == (32, 32, 3)
          SCREAMING_SNAKE_CASE_   :						Union[str, 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  :						str):




          '''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 _SCREAMING_SNAKE_CASE				(		self  :						Optional[int]):




          '''simple docstring'''


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




          '''simple docstring'''


          pass
      @unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.''')
      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple):




          '''simple docstring'''


          pass



      def _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


          return super().test_progress_bar()




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






      '''simple docstring'''

      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple):




          '''simple docstring'''


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

          # 10 frames
          SCREAMING_SNAKE_CASE_   :						Any							=	torch.Generator(device='''cpu''').manual_seed(0)
          SCREAMING_SNAKE_CASE_   :						Tuple							=	torch.randn((1, 10, 3, 1024, 576)		,			generator=lowercase_)
          SCREAMING_SNAKE_CASE_   :						List[str]							=	video.to('''cuda''')

          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	'''Spiderman is surfing'''

          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	pipe(lowercase_		,			video=lowercase_		,			generator=lowercase_		,			num_inference_steps=3		,			output_type='''pt''').frames

          SCREAMING_SNAKE_CASE_   :						Dict							=	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 math import isqrt



def       _A    (__a							)				-> list[int]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	[True] * max_number
    for i in range(2					,       isqrt(max_number - 1							) + 1							):
        if is_prime[i]:
            for j in range(i**2					,       __a					,       __a							):
                SCREAMING_SNAKE_CASE_   :						Tuple							=	False

    return [i for i in range(2					,       __a							) if is_prime[i]]



def       _A    (__a = 10**8							)				-> int:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						Any							=	calculate_prime_numbers(max_number // 2							)

    SCREAMING_SNAKE_CASE_   :						List[str]							=	0
    SCREAMING_SNAKE_CASE_   :						Any							=	0
    SCREAMING_SNAKE_CASE_   :						List[str]							=	len(__a							) - 1
    while left <= right:
        while prime_numbers[left] * prime_numbers[right] >= max_number:
            right -= 1
        semiprimes_count += right - left + 1
        left += 1

    return semiprimes_count


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


