



'''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 						a_		(     snake_case    ,   unittest.TestCase    ):
							UpperCAmelCase			:		Optional[int]        =				TextToVideoSDPipeline
							UpperCAmelCase			:		Any        =				TEXT_TO_IMAGE_PARAMS
							UpperCAmelCase			:		int        =				TEXT_TO_IMAGE_BATCH_PARAMS
							# No `output_type`.
							UpperCAmelCase			:		List[str]        =				frozenset(
							    [
							        """num_inference_steps""",
							        """generator""",
							        """latents""",
							        """return_dict""",
							        """callback""",
							        """callback_steps""",
							    ]    )


							def    UpperCamelCase     (				self   :						Tuple			)			->					Tuple:
										torch.manual_seed(0			)
										snake_case:    Optional[Any]      							=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      ,						)
										snake_case:    str      							=DDIMScheduler(
										    beta_start=0.0_0_0_8_5      ,						beta_end=0.0_1_2      ,						beta_schedule='scaled_linear'      ,						clip_sample=a_      ,						set_alpha_to_one=a_      ,						)
										torch.manual_seed(0			)
										snake_case:    Tuple      							=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			)
										snake_case:    int      							=CLIPTextConfig(
										    bos_token_id=0      ,						eos_token_id=2      ,						hidden_size=3_2      ,						intermediate_size=3_7      ,						layer_norm_eps=1E-0_5      ,						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      ,						)
										snake_case:    Any      							=CLIPTextModel(a_			)
										snake_case:    Optional[int]      							=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)

										snake_case:    Optional[Any]      							={
										    'unet': unet,
										    'scheduler': scheduler,
										    'vae': vae,
										    'text_encoder': text_encoder,
										    'tokenizer': tokenizer,
										}
										return components


							def    UpperCamelCase     (				self   :						Union[str, Any]      ,						a_   :						Optional[int]      ,						a_   :						List[Any]=0			)			->					List[Any]:
										if str(a_			).startswith('mps'			):
													snake_case:    Union[str, Any]      							=torch.manual_seed(a_			)
										else:
													snake_case:    Optional[Any]      							=torch.Generator(device=a_			).manual_seed(a_			)
										snake_case:    int      							={
										    '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    UpperCamelCase     (				self   :						List[Any]			)			->					int:
										snake_case:    Tuple      							='cpu'  # ensure determinism for the device-dependent torch.Generator
										snake_case:    List[Any]      							=self.get_dummy_components()
										snake_case:    int      							=TextToVideoSDPipeline(**a_			)
										snake_case:    Any      							=sd_pipe.to(a_			)
										sd_pipe.set_progress_bar_config(disable=a_			)

										snake_case:    Any      							=self.get_dummy_inputs(a_			)
										snake_case:    int      							='np'
										snake_case:    List[Any]      							=sd_pipe(**a_			).frames
										snake_case:    Optional[int]      							=frames[0][-3:, -3:, -1]

										assert frames[0].shape == (6_4, 6_4, 3)
										snake_case:    List[Any]      							=np.array([1_5_8.0, 1_6_0.0, 1_5_3.0, 1_2_5.0, 1_0_0.0, 1_2_1.0, 1_1_1.0, 9_3.0, 1_1_3.0]			)

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


							def    UpperCamelCase     (				self   :						Any			)			->					Dict:
										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    UpperCamelCase     (				self   :						Any			)			->					Tuple:
										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    UpperCamelCase     (				self   :						Optional[Any]			)			->					Optional[int]:
										pass


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


							@unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'			)
							def    UpperCamelCase     (				self   :						str			)			->					str:
										pass




							def    UpperCamelCase     (				self   :						str			)			->					Dict:
										return super().test_progress_bar()






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


							def    UpperCamelCase     (				self   :						Union[str, Any]			)			->					int:
										snake_case:    List[Any]      							=load_numpy(
										    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'			)

										snake_case:    Optional[Any]      							=TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'			)
										snake_case:    Dict      							=DPMSolverMultistepScheduler.from_config(pipe.scheduler.config			)
										snake_case:    Optional[int]      							=pipe.to('cuda'			)

										snake_case:    List[str]      							='Spiderman is surfing'
										snake_case:    Optional[int]      							=torch.Generator(device='cpu'			).manual_seed(0			)

										snake_case:    Tuple      							=pipe(a_      ,						generator=a_      ,						num_inference_steps=2_5      ,						output_type='pt'			).frames
										snake_case:    Tuple      							=video_frames.cpu().numpy()

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




							def    UpperCamelCase     (				self   :						Optional[int]			)			->					List[Any]:
										snake_case:    Optional[Any]      							=load_numpy(
										    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'			)

										snake_case:    List[Any]      							=TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'			)
										snake_case:    str      							=pipe.to('cuda'			)

										snake_case:    Dict      							='Spiderman is surfing'
										snake_case:    Any      							=torch.Generator(device='cpu'			).manual_seed(0			)

										snake_case:    List[str]      							=pipe(a_      ,						generator=a_      ,						num_inference_steps=2      ,						output_type='pt'			).frames
										snake_case:    Optional[int]      							=video_frames.cpu().numpy()

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









'''simple docstring'''

from __future__ import annotations







def a_     (    __UpperCAmelCase					)				->					list[int]:





			"""simple docstring"""







			snake_case:    Tuple      							=[True] * limit
			snake_case:    Optional[int]      							=False
			snake_case:    Union[str, Any]      							=False
			snake_case:    List[Any]      							=True

			for i in range(3				,							int(limit**0.5 + 1					)				,							2					):
						snake_case:    str      							=i * 2
						while index < limit:
									snake_case:    List[Any]      							=False
									snake_case:    List[str]      							=index + i

			snake_case:    Union[str, Any]      							=[2]

			for i in range(3				,							__UpperCAmelCase				,							2					):
						if is_prime[i]:
									primes.append(__UpperCAmelCase					)

			return primes







def a_     (    __UpperCAmelCase = 1_00_00_00					)				->					int:





			"""simple docstring"""







			snake_case:    str      							=prime_sieve(__UpperCAmelCase					)
			snake_case:    str      							=0
			snake_case:    str      							=0

			for i in range(len(__UpperCAmelCase					)					):
						for j in range(i + length				,							len(__UpperCAmelCase					)					):
									snake_case:    Tuple      							=sum(primes[i:j]					)
									if sol >= ceiling:
												break

									if sol in primes:
												snake_case:    List[str]      							=j - i
												snake_case:    Optional[int]      							=sol

			return largest


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




