


'''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 					UpperCAmelCase__	(		__lowerCAmelCase							,       unittest.TestCase ):
					a      :     Any        =							DiTPipeline
					a      :     Union[str, Any]        =							CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
					a      :     Dict        =							PipelineTesterMixin.required_optional_params - {
					    """latents""",
					    """num_images_per_prompt""",
					    """callback""",
					    """callback_steps""",
					}
					a      :     int        =							CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
					a      :     Optional[Any]        =							False



					def        UpperCAmelCase_ (    self     )     ->			List[str]:
						torch.manual_seed(0     )
						__lowerCAmelCase												=  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=_UpperCamelCase			,				activation_fn="gelu-approximate"			,				num_embeds_ada_norm=1000			,				norm_type="ada_norm_zero"			,				norm_elementwise_affine=_UpperCamelCase			,				)
						__lowerCAmelCase												=  AutoencoderKL()
						__lowerCAmelCase												=  DDIMScheduler()
						__lowerCAmelCase												=  {"""transformer""": transformer.eval(), """vae""": vae.eval(), """scheduler""": scheduler}
						return components



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase=0     )     ->			Optional[Any]:


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



					def        UpperCAmelCase_ (    self     )     ->			Dict:
						__lowerCAmelCase												=  """cpu"""

						__lowerCAmelCase												=  self.get_dummy_components()
						__lowerCAmelCase												=  self.pipeline_class(**_UpperCamelCase     )
						pipe.to(_UpperCamelCase     )
						pipe.set_progress_bar_config(disable=_UpperCamelCase     )

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

						self.assertEqual(image.shape			,				(1, 16, 16, 3)     )
						__lowerCAmelCase												=  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]     )
						__lowerCAmelCase												=  np.abs(image_slice.flatten() - expected_slice     ).max()
						self.assertLessEqual(_UpperCamelCase			,				1E-3     )



					def        UpperCAmelCase_ (    self     )     ->			Tuple:
						self._test_inference_batch_single_identical(relax_max_difference=_UpperCamelCase			,				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     )     ->			Optional[int]:
						self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3     )






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



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



					def        UpperCAmelCase_ (    self     )     ->			List[str]:
						__lowerCAmelCase												=  torch.manual_seed(0     )

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

						__lowerCAmelCase												=  ["""vase""", """umbrella""", """white shark""", """white wolf"""]
						__lowerCAmelCase												=  pipe.get_label_ids(_UpperCamelCase     )

						__lowerCAmelCase												=  pipe(_UpperCamelCase			,				generator=_UpperCamelCase			,				num_inference_steps=40			,				output_type="np"     ).images

						for word, image in zip(_UpperCamelCase			,				_UpperCamelCase     ):
							__lowerCAmelCase												=  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     )     ->			Union[str, Any]:
						__lowerCAmelCase												=  DiTPipeline.from_pretrained("facebook/DiT-XL-2-512"     )
						__lowerCAmelCase												=  DPMSolverMultistepScheduler.from_config(pipe.scheduler.config     )
						pipe.to("cuda"     )

						__lowerCAmelCase												=  ["""vase""", """umbrella"""]
						__lowerCAmelCase												=  pipe.get_label_ids(_UpperCamelCase     )

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

						for word, image in zip(_UpperCamelCase			,				_UpperCamelCase     ):
							__lowerCAmelCase												=  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'''



import re



def   __lowerCAmelCase					(							lowerCamelCase   :						str					):






	'''simple docstring'''




	__lowerCAmelCase												=  re.compile(
	    r"^(?:0|94|\+94|0{2}94)" r"7(0|1|2|4|5|6|7|8)" r"(-| |)" r"\d{7}$"					)

	return bool(re.search(lowerCamelCase				,		lowerCamelCase					)					)


if __name__ == "__main__":
	lowerCAmelCase	:		Optional[Any]				=   '''0094702343221'''

	print(is_sri_lankan_phone_number(phone))