
"""simple docstring"""





import gc
import unittest

import numpy as np
import torch

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, DPMSolverMultistepScheduler, TransformeraDModel
from diffusers.utils import is_xformers_available, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS,
    CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
class 						SCREAMING_SNAKE_CASE_ (						__a     ,				unittest.TestCase ):




		"""simple docstring"""





		__lowercase							:  str						   =		DiTPipeline
		__lowercase							:  List[str]						   =		CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
		__lowercase							:  Union[str, Any]						   =		PipelineTesterMixin.required_optional_params - {
		    '''latents''',
		    '''num_images_per_prompt''',
		    '''callback''',
		    '''callback_steps''',
		}
		__lowercase							:  Optional[Any]						   =		CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
		__lowercase							:  Union[str, Any]						   =		False




		def 	snake_case_     (     self):
				torch.manual_seed(0)
				__SCREAMING_SNAKE_CASE            = TransformeraDModel(
				    sample_size=1_6							,  num_layers=2							,  patch_size=4							,  attention_head_dim=8							,  num_attention_heads=2							,  in_channels=4							,  out_channels=8							,  attention_bias=lowerCAmelCase__							,  activation_fn="""gelu-approximate"""							,  num_embeds_ada_norm=1_0_0_0							,  norm_type="""ada_norm_zero"""							,  norm_elementwise_affine=lowerCAmelCase__							,  )
				__SCREAMING_SNAKE_CASE            = AutoencoderKL()
				__SCREAMING_SNAKE_CASE            = DDIMScheduler()
				__SCREAMING_SNAKE_CASE            = {"""transformer""": transformer.eval(), """vae""": vae.eval(), """scheduler""": scheduler}
				return components




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__=0):
				if str(lowerCAmelCase__).startswith("""mps"""):
						__SCREAMING_SNAKE_CASE            = torch.manual_seed(lowerCAmelCase__)
				else:
						__SCREAMING_SNAKE_CASE            = torch.Generator(device=lowerCAmelCase__).manual_seed(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = {
				    """class_labels""": [1],
				    """generator""": generator,
				    """num_inference_steps""": 2,
				    """output_type""": """numpy""",
				}
				return inputs




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = """cpu"""

				__SCREAMING_SNAKE_CASE            = self.get_dummy_components()
				__SCREAMING_SNAKE_CASE            = self.pipeline_class(**lowerCAmelCase__)
				pipe.to(lowerCAmelCase__)
				pipe.set_progress_bar_config(disable=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = self.get_dummy_inputs(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = pipe(**lowerCAmelCase__).images
				__SCREAMING_SNAKE_CASE            = image[0, -3:, -3:, -1]

				self.assertEqual(image.shape							,  (1, 1_6, 1_6, 3))
				__SCREAMING_SNAKE_CASE            = np.array([0.29_46, 0.66_01, 0.43_29, 0.32_96, 0.41_44, 0.53_19, 0.72_73, 0.50_13, 0.44_57])
				__SCREAMING_SNAKE_CASE            = np.abs(image_slice.flatten() - expected_slice).max()
				self.assertLessEqual(lowerCAmelCase__							,  1E-3)




		def 	snake_case_     (     self):
				self._test_inference_batch_single_identical(relax_max_difference=lowerCAmelCase__							,  expected_max_diff=1E-3)




		@unittest.skipIf(
		    torch_device != """cuda""" or not is_xformers_available()							,  reason="""XFormers attention is only available with CUDA and `xformers` installed"""							,  )
		def 	snake_case_     (     self):
				self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3)



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




		"""simple docstring"""





		def 	snake_case_     (     self):
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = torch.manual_seed(0)

				__SCREAMING_SNAKE_CASE            = DiTPipeline.from_pretrained("""facebook/DiT-XL-2-256""")
				pipe.to("""cuda""")

				__SCREAMING_SNAKE_CASE            = ["""vase""", """umbrella""", """white shark""", """white wolf"""]
				__SCREAMING_SNAKE_CASE            = pipe.get_label_ids(lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = pipe(lowerCAmelCase__							,  generator=lowerCAmelCase__							,  num_inference_steps=4_0							,  output_type="""np""").images

				for word, image in zip(lowerCAmelCase__							,  lowerCAmelCase__):
						__SCREAMING_SNAKE_CASE            = load_numpy(
						    f"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/dit/{word}.npy")
						assert np.abs((expected_image - image).max()) < 1E-2




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = DiTPipeline.from_pretrained("""facebook/DiT-XL-2-512""")
				__SCREAMING_SNAKE_CASE            = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
				pipe.to("""cuda""")

				__SCREAMING_SNAKE_CASE            = ["""vase""", """umbrella"""]
				__SCREAMING_SNAKE_CASE            = pipe.get_label_ids(lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = torch.manual_seed(0)
				__SCREAMING_SNAKE_CASE            = pipe(lowerCAmelCase__							,  generator=lowerCAmelCase__							,  num_inference_steps=2_5							,  output_type="""np""").images

				for word, image in zip(lowerCAmelCase__							,  lowerCAmelCase__):
						__SCREAMING_SNAKE_CASE            = load_numpy(
						    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
						    f"/dit/{word}_512.npy")

						assert np.abs((expected_image - image).max()) < 1E-1






"""simple docstring"""





from math import isqrt, loga



def 						_lowerCAmelCase				(				UpperCamelCase_				):
		__SCREAMING_SNAKE_CASE            = [True] * max_number
		for i in range(2  ,				isqrt(max_number - 1				) + 1				):
				if is_prime[i]:
						for j in range(i**2  ,				UpperCamelCase_  ,				UpperCamelCase_				):
								__SCREAMING_SNAKE_CASE            = False

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



def 						_lowerCAmelCase				(				UpperCamelCase_ = 80_0800  ,				UpperCamelCase_ = 80_0800				):
		__SCREAMING_SNAKE_CASE            = degree * loga(UpperCamelCase_				)
		__SCREAMING_SNAKE_CASE            = int(UpperCamelCase_				)
		__SCREAMING_SNAKE_CASE            = calculate_prime_numbers(UpperCamelCase_				)

		__SCREAMING_SNAKE_CASE            = 0
		__SCREAMING_SNAKE_CASE            = 0
		__SCREAMING_SNAKE_CASE            = len(UpperCamelCase_				) - 1
		while left < right:
				while (
				    prime_numbers[right] * loga(prime_numbers[left]				)
				    + prime_numbers[left] * loga(prime_numbers[right]				)
				    > upper_bound
				):
						right -= 1
				hybrid_integers_count += right - left
				left += 1

		return hybrid_integers_count


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




