





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        __SCREAMING_SNAKE_CASE					(     _a   ,		_a   ,		_a   ,		unittest.TestCase       ):
							snake_case     :      Any						     =       StableUnCLIPPipeline
							snake_case     :      Union[str, Any]						     =       TEXT_TO_IMAGE_PARAMS
							snake_case     :      Dict						     =       TEXT_TO_IMAGE_BATCH_PARAMS
							snake_case     :      str						     =       TEXT_TO_IMAGE_IMAGE_PARAMS
							snake_case     :      List[str]						     =       TEXT_TO_IMAGE_IMAGE_PARAMS

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






							def 				_lowerCamelCase		(						self  ):
														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=__lowerCAmelCase  , projection_dim=__lowerCAmelCase  , intermediate_size=37  , layer_norm_eps=1E-05  , num_attention_heads=4  , num_hidden_layers=5  , pad_token_id=1  , vocab_size=1000  , )  )

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

														torch.manual_seed(0  )
														UpperCamelCase__				     =			DDPMScheduler(
														    variance_type="""fixed_small_log"""  , prediction_type="""sample"""  , num_train_timesteps=1000  , clip_sample=__lowerCAmelCase  , clip_sample_range=5.0  , beta_schedule="""squaredcos_cap_v2"""  , )

														# regular denoising components

														torch.manual_seed(0  )
														UpperCamelCase__				     =			StableUnCLIPImageNormalizer(embedding_dim=__lowerCAmelCase  )
														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=__lowerCAmelCase  , 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=1000  , )  )

														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=__lowerCAmelCase  , layers_per_block=1  , upcast_attention=__lowerCAmelCase  , use_linear_projection=__lowerCAmelCase  , )

														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=__lowerCAmelCase  , 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 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase=0  ):
														if str(__lowerCAmelCase  ).startswith("""mps"""  ):
																					UpperCamelCase__				     =			torch.manual_seed(__lowerCAmelCase  )
														else:
																					UpperCamelCase__				     =			torch.Generator(device=__lowerCAmelCase  ).manual_seed(__lowerCAmelCase  )
														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 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			torch_device == """cpu"""

														self._test_attention_slicing_forward_pass(test_max_difference=__lowerCAmelCase  )







							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			torch_device in ["""cpu""", """mps"""]

														self._test_inference_batch_single_identical(test_max_difference=__lowerCAmelCase  )






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






							def 				_lowerCamelCase		(						self  ):
														# clean up the VRAM after each test
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()






							def 				_lowerCamelCase		(						self  ):
														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(__lowerCAmelCase  )
														pipe.set_progress_bar_config(disable=__lowerCAmelCase  )
														# 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=__lowerCAmelCase  , output_type="""np"""  )

														UpperCamelCase__				     =			output.images[0]

														assert image.shape == (768, 768, 3)

														assert_mean_pixel_difference(__lowerCAmelCase  , __lowerCAmelCase  )







							def 				_lowerCamelCase		(						self  ):
														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(__lowerCAmelCase  )
														pipe.set_progress_bar_config(disable=__lowerCAmelCase  )
														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











from math import ceil, sqrt





def     _UpperCamelCase     (a__   :int = 100_0000       ):






							"""simple docstring"""





							UpperCamelCase__				     =			0

							for outer_width in range(3   ,			(limit // 4) + 2       ):
														if outer_width**2 > limit:
																					UpperCamelCase__				     =			max(ceil(sqrt(outer_width**2 - limit       )       )   ,			1       )
														else:
																					UpperCamelCase__				     =			1
														if (outer_width - hole_width_lower_bound) % 2:
																					hole_width_lower_bound += 1

														answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1

							return answer


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




