
'''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		(   a__    ,   unittest.TestCase):
					_lowerCAmelCase			     =	DiTPipeline
					_lowerCAmelCase			     =	CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
					_lowerCAmelCase			     =	PipelineTesterMixin.required_optional_params - {
					    '''latents''',
					    '''num_images_per_prompt''',
					    '''callback''',
					    '''callback_steps''',
					}
					_lowerCAmelCase			     =	CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
					_lowerCAmelCase			     =	False
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									torch.manual_seed(0      )
									lowerCamelCase					:			Any									= 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=1000,    norm_type='ada_norm_zero',    norm_elementwise_affine=A,    )
									lowerCamelCase					:			List[Any]									= AutoencoderKL()
									lowerCamelCase					:			Tuple									= DDIMScheduler()
									lowerCamelCase					:			List[str]									= {'transformer': transformer.eval(), 'vae': vae.eval(), 'scheduler': scheduler}
									return components
					def     UpperCAmelCase_							(     self,    A,    A=0      ):

									"""simple docstring"""


									if str(A      ).startswith('mps'      ):
													lowerCamelCase					:			Optional[Any]									= torch.manual_seed(A      )
									else:
													lowerCamelCase					:			Union[str, Any]									= torch.Generator(device=A      ).manual_seed(A      )
									lowerCamelCase					:			Tuple									= {
									    'class_labels': [1],
									    'generator': generator,
									    'num_inference_steps': 2,
									    'output_type': 'numpy',
									}
									return inputs
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			int									= 'cpu'

									lowerCamelCase					:			int									= self.get_dummy_components()
									lowerCamelCase					:			Optional[Any]									= self.pipeline_class(**A      )
									pipe.to(A      )
									pipe.set_progress_bar_config(disable=A      )

									lowerCamelCase					:			str									= self.get_dummy_inputs(A      )
									lowerCamelCase					:			str									= pipe(**A      ).images
									lowerCamelCase					:			List[str]									= image[0, -3:, -3:, -1]

									self.assertEqual(image.shape,    (1, 16, 16, 3)      )
									lowerCamelCase					:			str									= np.array([0.2946, 0.6601, 0.4329, 0.3296, 0.4144, 0.5319, 0.7273, 0.5013, 0.4457]      )
									lowerCamelCase					:			Tuple									= np.abs(image_slice.flatten() - expected_slice      ).max()
									self.assertLessEqual(A,    1e-3      )
					def     UpperCAmelCase_							(     self      ):

									"""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     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3      )





@require_torch_gpu
@slow
class     __snake_case		(   unittest.TestCase):
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


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

									"""simple docstring"""


									lowerCamelCase					:			Any									= torch.manual_seed(0      )

									lowerCamelCase					:			List[Any]									= DiTPipeline.from_pretrained('facebook/DiT-XL-2-256'      )
									pipe.to('cuda'      )

									lowerCamelCase					:			int									= ['vase', 'umbrella', 'white shark', 'white wolf']
									lowerCamelCase					:			Tuple									= pipe.get_label_ids(A      )

									lowerCamelCase					:			List[Any]									= pipe(A,    generator=A,    num_inference_steps=40,    output_type='np'      ).images

									for word, image in zip(A,    A      ):
													lowerCamelCase					:			Tuple									= 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     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			List[Any]									= DiTPipeline.from_pretrained('facebook/DiT-XL-2-512'      )
									lowerCamelCase					:			int									= DPMSolverMultistepScheduler.from_config(pipe.scheduler.config      )
									pipe.to('cuda'      )

									lowerCamelCase					:			Any									= ['vase', 'umbrella']
									lowerCamelCase					:			Any									= pipe.get_label_ids(A      )

									lowerCamelCase					:			Optional[Any]									= torch.manual_seed(0      )
									lowerCamelCase					:			Union[str, Any]									= pipe(A,    generator=A,    num_inference_steps=25,    output_type='np'      ).images

									for word, image in zip(A,    A      ):
													lowerCamelCase					:			Any									= 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 __future__ import annotations





def    UpperCAmelCase							(  UpperCAmelCase__							:							int):
				lowerCamelCase					:			List[Any]									= str(UpperCAmelCase__)
				return len(UpperCAmelCase__) == 9 and set(UpperCAmelCase__) == set('123456789')





def    UpperCAmelCase							(  ):
				for base_num in range(99_99       ,							49_99       ,							-1):
								lowerCamelCase					:			Tuple									= 10_00_02 * base_num
								if is_9_pandigital(UpperCAmelCase__):
												return candidate

				for base_num in range(3_33       ,							99       ,							-1):
								lowerCamelCase					:			List[Any]									= 1_00_20_03 * base_num
								if is_9_pandigital(UpperCAmelCase__):
												return candidate

				return None


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