



"""simple docstring"""


import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()







class       A_			(     SCREAMING_SNAKE_CASE_	,   SCREAMING_SNAKE_CASE_	,   SCREAMING_SNAKE_CASE_	,   unittest.TestCase				):



						"""simple docstring"""
						__UpperCamelCase						=							StableUnCLIPPipeline
						__UpperCamelCase						=							TEXT_TO_IMAGE_PARAMS
						__UpperCamelCase						=							TEXT_TO_IMAGE_BATCH_PARAMS
						__UpperCamelCase						=							TEXT_TO_IMAGE_IMAGE_PARAMS
						__UpperCamelCase						=							TEXT_TO_IMAGE_IMAGE_PARAMS

						# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
						__UpperCamelCase						=							False






						def 	UpperCAmelCase__     (					self :List[Any]					)				->			Any:
												UpperCAmelCase             = 32
												UpperCAmelCase             = embedder_hidden_size

												# prior components

												torch.manual_seed(0					)
												UpperCAmelCase             = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'					)

												torch.manual_seed(0					)
												UpperCAmelCase             = CLIPTextModelWithProjection(
												    CLIPTextConfig(
												        bos_token_id=0   ,  eos_token_id=2   ,  hidden_size=lowercase_   ,  projection_dim=lowercase_   ,  intermediate_size=37   ,  layer_norm_eps=1E-05   ,  num_attention_heads=4   ,  num_hidden_layers=5   ,  pad_token_id=1   ,  vocab_size=10_00   ,  )					)

												torch.manual_seed(0					)
												UpperCAmelCase             = PriorTransformer(
												    num_attention_heads=2   ,  attention_head_dim=12   ,  embedding_dim=lowercase_   ,  num_layers=1   ,  )

												torch.manual_seed(0					)
												UpperCAmelCase             = DDPMScheduler(
												    variance_type='fixed_small_log'   ,  prediction_type='sample'   ,  num_train_timesteps=10_00   ,  clip_sample=lowercase_   ,  clip_sample_range=5.0   ,  beta_schedule='squaredcos_cap_v2'   ,  )

												# regular denoising components

												torch.manual_seed(0					)
												UpperCAmelCase             = StableUnCLIPImageNormalizer(embedding_dim=lowercase_					)
												UpperCAmelCase             = DDPMScheduler(beta_schedule='squaredcos_cap_v2'					)

												torch.manual_seed(0					)
												UpperCAmelCase             = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'					)

												torch.manual_seed(0					)
												UpperCAmelCase             = CLIPTextModel(
												    CLIPTextConfig(
												        bos_token_id=0   ,  eos_token_id=2   ,  hidden_size=lowercase_   ,  projection_dim=32   ,  intermediate_size=37   ,  layer_norm_eps=1E-05   ,  num_attention_heads=4   ,  num_hidden_layers=5   ,  pad_token_id=1   ,  vocab_size=10_00   ,  )					)

												torch.manual_seed(0					)
												UpperCAmelCase             = UNetaDConditionModel(
												    sample_size=32   ,  in_channels=4   ,  out_channels=4   ,  down_block_types=('CrossAttnDownBlock2D', 'DownBlock2D')   ,  up_block_types=('UpBlock2D', 'CrossAttnUpBlock2D')   ,  block_out_channels=(32, 64)   ,  attention_head_dim=(2, 4)   ,  class_embed_type='projection'   ,  projection_class_embeddings_input_dim=embedder_projection_dim * 2   ,  cross_attention_dim=lowercase_   ,  layers_per_block=1   ,  upcast_attention=lowercase_   ,  use_linear_projection=lowercase_   ,  )

												torch.manual_seed(0					)
												UpperCAmelCase             = DDIMScheduler(
												    beta_schedule='scaled_linear'   ,  beta_start=0.0_0085   ,  beta_end=0.012   ,  prediction_type='v_prediction'   ,  set_alpha_to_one=lowercase_   ,  steps_offset=1   ,  )

												torch.manual_seed(0					)
												UpperCAmelCase             = AutoencoderKL()

												UpperCAmelCase             = {
												    # prior components
												    'prior_tokenizer': prior_tokenizer,
												    'prior_text_encoder': prior_text_encoder,
												    'prior': prior,
												    'prior_scheduler': prior_scheduler,
												    # image noising components
												    'image_normalizer': image_normalizer,
												    'image_noising_scheduler': image_noising_scheduler,
												    # regular denoising components
												    'tokenizer': tokenizer,
												    'text_encoder': text_encoder,
												    'unet': unet,
												    'scheduler': scheduler,
												    'vae': vae,
												}

												return components






						def 	UpperCAmelCase__     (					self :Union[str, Any]   ,  lowercase_ :str   ,  lowercase_ :Dict=0					)				->			List[str]:
												if str(lowercase_					).startswith('mps'					):
																		UpperCAmelCase             = torch.manual_seed(lowercase_					)
												else:
																		UpperCAmelCase             = torch.Generator(device=lowercase_					).manual_seed(lowercase_					)
												UpperCAmelCase             = {
												    'prompt': 'A painting of a squirrel eating a burger',
												    'generator': generator,
												    'num_inference_steps': 2,
												    'prior_num_inference_steps': 2,
												    'output_type': 'numpy',
												}
												return inputs






						def 	UpperCAmelCase__     (					self :Optional[Any]					)				->			int:
												UpperCAmelCase             = torch_device == 'cpu'

												self._test_attention_slicing_forward_pass(test_max_difference=lowercase_					)






						def 	UpperCAmelCase__     (					self :Union[str, Any]					)				->			int:
												UpperCAmelCase             = torch_device in ['cpu', 'mps']

												self._test_inference_batch_single_identical(test_max_difference=lowercase_					)







@slow
@require_torch_gpu
class       A_			(     unittest.TestCase				):



						"""simple docstring"""






						def 	UpperCAmelCase__     (					self :Any					)				->			Optional[Any]:
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()






						def 	UpperCAmelCase__     (					self :Tuple					)				->			Union[str, Any]:
												UpperCAmelCase             = load_numpy(
												    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'					)

												UpperCAmelCase             = StableUnCLIPPipeline.from_pretrained('fusing/stable-unclip-2-1-l'   ,  torch_dtype=torch.floataa					)
												pipe.to(lowercase_					)
												pipe.set_progress_bar_config(disable=lowercase_					)
												# stable unclip will oom when integration tests are run on a V100,
												# so turn on memory savings
												pipe.enable_attention_slicing()
												pipe.enable_sequential_cpu_offload()

												UpperCAmelCase             = torch.Generator(device='cpu'					).manual_seed(0					)
												UpperCAmelCase             = pipe('anime turle'   ,  generator=lowercase_   ,  output_type='np'					)

												UpperCAmelCase             = output.images[0]

												assert image.shape == (7_68, 7_68, 3)

												assert_mean_pixel_difference(lowercase_   ,  lowercase_					)






						def 	UpperCAmelCase__     (					self :Tuple					)				->			Tuple:
												torch.cuda.empty_cache()
												torch.cuda.reset_max_memory_allocated()
												torch.cuda.reset_peak_memory_stats()

												UpperCAmelCase             = StableUnCLIPPipeline.from_pretrained('fusing/stable-unclip-2-1-l'   ,  torch_dtype=torch.floataa					)
												UpperCAmelCase             = pipe.to(lowercase_					)
												pipe.set_progress_bar_config(disable=lowercase_					)
												pipe.enable_attention_slicing()
												pipe.enable_sequential_cpu_offload()

												UpperCAmelCase             = pipe(
												    'anime turtle'   ,  prior_num_inference_steps=2   ,  num_inference_steps=2   ,  output_type='np'   ,  )

												UpperCAmelCase             = torch.cuda.max_memory_allocated()
												# make sure that less than 7 GB is allocated
												assert mem_bytes < 7 * 10**9









"""simple docstring"""







from __future__ import annotations

from functools import lru_cache
from math import ceil

lowerCAmelCase__      				=   100

lowerCAmelCase__      				=   set(range(3, NUM_PRIMES, 2))
primes.add(2)
lowerCAmelCase__      				=   42

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
     if prime not in primes:
          continue
     primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))
@lru_cache(maxsize=1_0_0				)
def 					a__			(				SCREAMING_SNAKE_CASE    :    int				):


  '''simple docstring'''







  if number_to_partition < 0:
    return set()
  elif number_to_partition == 0:
    return {1}

  lowerCAmelCase     :     set[int]								=							set()
  lowerCAmelCase     :     int
  lowerCAmelCase     :     int

  for prime in primes:
    if prime > number_to_partition:
      continue
    for sub in partition(number_to_partition - prime				):
      ret.add(sub * prime				)

  return ret
def 					a__			(				SCREAMING_SNAKE_CASE    :    int = 5_0_0_0				):


  '''simple docstring'''







  for number_to_partition in range(1				,      SCREAMING_SNAKE_CASE				):
    if len(partition(SCREAMING_SNAKE_CASE				)				) > number_unique_partitions:
      return number_to_partition
  return None


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





