


'''simple docstring'''


import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()



@skip_mps
class 	__lowerCAmelCase		(							__SCREAMING_SNAKE_CASE  , unittest.TestCase    ):


  '''simple docstring'''







  a_  					=							TextToVideoSDPipeline
  a_  					=							TEXT_TO_IMAGE_PARAMS
  a_  					=							TEXT_TO_IMAGE_BATCH_PARAMS
  # No `output_type`.
  a_  					=							frozenset(
      [
          """num_inference_steps""",
          """generator""",
          """latents""",
          """return_dict""",
          """callback""",
          """callback_steps""",
      ]    )






  def        _a							(							self :       Any ):

        '''simple docstring'''




        torch.manual_seed(0 )
        A_						:  List[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	,)
        A_						:  Tuple          =				DDIMScheduler(
            beta_start=0.00085	,beta_end=0.012	,beta_schedule="""scaled_linear"""	,clip_sample=_a	,set_alpha_to_one=_a	,)
        torch.manual_seed(0 )
        A_						:  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 )
        A_						:  Union[str, 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	,)
        A_						:  List[Any]          =				CLIPTextModel(_a )
        A_						:  str          =				CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

        A_						:  str          =				{
            """unet""": unet,
            """scheduler""": scheduler,
            """vae""": vae,
            """text_encoder""": text_encoder,
            """tokenizer""": tokenizer,
        }
        return components






  def        _a							(							self :       str	,_a :       List[Any]	,_a :       Union[str, Any]=0 ):

        '''simple docstring'''




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






  def        _a							(							self :       Optional[Any] ):

        '''simple docstring'''




        A_						:  Optional[int]          =				"""cpu"""  # ensure determinism for the device-dependent torch.Generator
        A_						:  str          =				self.get_dummy_components()
        A_						:  Optional[Any]          =				TextToVideoSDPipeline(**_a )
        A_						:  str          =				sd_pipe.to(_a )
        sd_pipe.set_progress_bar_config(disable=_a )

        A_						:  Optional[Any]          =				self.get_dummy_inputs(_a )
        A_						:  int          =				"""np"""
        A_						:  List[str]          =				sd_pipe(**_a ).frames
        A_						:  int          =				frames[0][-3:, -3:, -1]

        assert frames[0].shape == (64, 64, 3)
        A_						:  List[Any]          =				np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0] )

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






  def        _a							(							self :       Any ):

        '''simple docstring'''




        self._test_attention_slicing_forward_pass(test_mean_pixel_difference=_a	,expected_max_diff=3e-3 )






  @unittest.skipIf(
      torch_device != """cuda""" or not is_xformers_available()	,reason="""XFormers attention is only available with CUDA and `xformers` installed"""	,)
  def        _a							(							self :       Union[str, Any] ):

        '''simple docstring'''




        self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_a	,expected_max_diff=1e-2 )






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

        '''simple docstring'''




        pass






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

        '''simple docstring'''




        pass






  @unittest.skip(reason="""`num_images_per_prompt` argument is not supported for this pipeline.""" )
  def        _a							(							self :       Optional[Any] ):

        '''simple docstring'''




        pass






  def        _a							(							self :       Union[str, Any] ):

        '''simple docstring'''




        return super().test_progress_bar()







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


  '''simple docstring'''







  def        _a							(							self :       List[str] ):

        '''simple docstring'''




        A_						:  str          =				load_numpy(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy""" )

        A_						:  Optional[Any]          =				TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b""" )
        A_						:  Tuple          =				DPMSolverMultistepScheduler.from_config(pipe.scheduler.config )
        A_						:  List[Any]          =				pipe.to("""cuda""" )

        A_						:  Optional[Any]          =				"""Spiderman is surfing"""
        A_						:  Optional[int]          =				torch.Generator(device="""cpu""" ).manual_seed(0 )

        A_						:  List[str]          =				pipe(_a	,generator=_a	,num_inference_steps=25	,output_type="""pt""" ).frames
        A_						:  str          =				video_frames.cpu().numpy()

        assert np.abs(expected_video - video ).mean() < 5e-2






  def        _a							(							self :       int ):

        '''simple docstring'''




        A_						:  int          =				load_numpy(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy""" )

        A_						:  Optional[Any]          =				TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b""" )
        A_						:  Any          =				pipe.to("""cuda""" )

        A_						:  Any          =				"""Spiderman is surfing"""
        A_						:  Optional[Any]          =				torch.Generator(device="""cpu""" ).manual_seed(0 )

        A_						:  List[str]          =				pipe(_a	,generator=_a	,num_inference_steps=2	,output_type="""pt""" ).frames
        A_						:  List[Any]          =				video_frames.cpu().numpy()

        assert np.abs(expected_video - video ).mean() < 5e-2




'''simple docstring'''


from __future__ import annotations

import math




def      lowerCamelCase					(      lowerCamelCase  :      int):

      if num <= 0:
            A_						:  List[Any]          =				F'{num}: Invalid input, please enter a positive integer.'
            raise ValueError(lowerCamelCase)

      A_						:  str          =				[True] * (num + 1)
      A_						:  Tuple          =				[]
      A_						:  str          =				2
      A_						:  Any          =				int(math.sqrt(lowerCamelCase))

      while start <= end:
            # If start is a prime
            if sieve[start] is True:
                  prime.append(lowerCamelCase)

                  # Set multiples of start be False
                  for i in range(start * start							,						num + 1							,						lowerCamelCase):
                        if sieve[i] is True:
                              A_						:  Union[str, Any]          =				False

            start += 1

      for j in range(end + 1							,						num + 1):
            if sieve[j] is True:
                  prime.append(lowerCamelCase)

      return prime


if __name__ == "__main__":
     print(prime_sieve(int(input('Enter a positive integer: ').strip())))
