


"""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 snake_case      (  _UpperCamelCase     ,				unittest.TestCase):
		__UpperCamelCase           =			DiTPipeline
		__UpperCamelCase           =			CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
		__UpperCamelCase           =			PipelineTesterMixin.required_optional_params - {
		    'latents',
		    'num_images_per_prompt',
		    'callback',
		    'callback_steps',
		}
		__UpperCamelCase           =			CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
		__UpperCamelCase           =			False







		def  a_ (					self      :       Tuple		)       ->						Union[str, Any]:





						'''simple docstring'''







						torch.manual_seed(0		)
						_A					  =			TransformeraDModel(
						    sample_size=16    ,   num_layers=2    ,   patch_size=4    ,   attention_head_dim=8    ,   num_attention_heads=2    ,   in_channels=4    ,   out_channels=8    ,   attention_bias=a__    ,   activation_fn="gelu-approximate"    ,   num_embeds_ada_norm=10_00    ,   norm_type="ada_norm_zero"    ,   norm_elementwise_affine=a__    ,   )
						_A					  =			AutoencoderKL()
						_A					  =			DDIMScheduler()
						_A					  =			{"transformer": transformer.eval(), "vae": vae.eval(), "scheduler": scheduler}
						return components







		def  a_ (					self      :       Optional[Any]    ,   a__      :       Any    ,   a__      :       Dict=0		)       ->						Optional[Any]:





						'''simple docstring'''







						if str(a__		).startswith("mps"		):
										_A					  =			torch.manual_seed(a__		)
						else:
										_A					  =			torch.Generator(device=a__		).manual_seed(a__		)
						_A					  =			{
						    "class_labels": [1],
						    "generator": generator,
						    "num_inference_steps": 2,
						    "output_type": "numpy",
						}
						return inputs







		def  a_ (					self      :       List[Any]		)       ->						List[Any]:





						'''simple docstring'''







						_A					  =			"cpu"

						_A					  =			self.get_dummy_components()
						_A					  =			self.pipeline_class(**a__		)
						pipe.to(a__		)
						pipe.set_progress_bar_config(disable=a__		)

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

						self.assertEqual(image.shape    ,   (1, 16, 16, 3)		)
						_A					  =			np.array([0.2_9_4_6, 0.6_6_0_1, 0.4_3_2_9, 0.3_2_9_6, 0.4_1_4_4, 0.5_3_1_9, 0.7_2_7_3, 0.5_0_1_3, 0.4_4_5_7]		)
						_A					  =			np.abs(image_slice.flatten() - expected_slice		).max()
						self.assertLessEqual(a__    ,   1E-3		)







		def  a_ (					self      :       str		)       ->						int:





						'''simple docstring'''







						self._test_inference_batch_single_identical(relax_max_difference=a__    ,   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  a_ (					self      :       str		)       ->						Optional[int]:





						'''simple docstring'''







						self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3		)





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







		def  a_ (					self      :       Optional[Any]		)       ->						Any:





						'''simple docstring'''







						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()







		def  a_ (					self      :       Any		)       ->						Any:





						'''simple docstring'''







						_A					  =			torch.manual_seed(0		)

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

						_A					  =			["vase", "umbrella", "white shark", "white wolf"]
						_A					  =			pipe.get_label_ids(a__		)

						_A					  =			pipe(a__    ,   generator=a__    ,   num_inference_steps=40    ,   output_type="np"		).images

						for word, image in zip(a__    ,   a__		):
										_A					  =			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  a_ (					self      :       str		)       ->						str:





						'''simple docstring'''







						_A					  =			DiTPipeline.from_pretrained("facebook/DiT-XL-2-512"		)
						_A					  =			DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
						pipe.to("cuda"		)

						_A					  =			["vase", "umbrella"]
						_A					  =			pipe.get_label_ids(a__		)

						_A					  =			torch.manual_seed(0		)
						_A					  =			pipe(a__    ,   generator=a__    ,   num_inference_steps=25    ,   output_type="np"		).images

						for word, image in zip(a__    ,   a__		):
										_A					  =			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"""


def      a__ (				__lowercase     ,			__lowercase   )	->	int:
				while a != 0:
								_A  ,		_A					  =			b % a, a
				return b






def      a__ (				__lowercase     ,			__lowercase   )	->	int:
				if gcd(__lowercase     ,			__lowercase   ) != 1:
								_A					  =			f"""mod inverse of {a!r} and {m!r} does not exist"""
								raise ValueError(__lowercase   )
				_A  ,		_A  ,		_A					  =			1, 0, a
				_A  ,		_A  ,		_A					  =			0, 1, m
				while va != 0:
								_A					  =			ua // va
								_A  ,		_A  ,		_A  ,		_A  ,		_A  ,		_A					  =			(ua - q * va), (ua - q * va), (ua - q * va), va, va, va
				return ua % m