





import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, XLMRobertaTokenizer

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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


enable_full_determinism()






class        _a(    __A	,   __A	,   __A	,   unittest.TestCase    ):
		lowerCamelCase__     :int   				=		AltDiffusionPipeline
		lowerCamelCase__     :List[Any]   				=		TEXT_TO_IMAGE_PARAMS
		lowerCamelCase__     :Optional[int]   				=		TEXT_TO_IMAGE_BATCH_PARAMS
		lowerCamelCase__     :Any   				=		TEXT_TO_IMAGE_IMAGE_PARAMS
		lowerCamelCase__     :Optional[Any]   				=		TEXT_TO_IMAGE_IMAGE_PARAMS







		def        lowercase       (    self				)      ->      List[str]:


							'''simple docstring'''

							torch.manual_seed(0				)
							_snake_case       :					int				       =   UNetaDConditionModel(
							    block_out_channels=(3_2, 6_4) ,						layers_per_block=2 ,						sample_size=3_2 ,						in_channels=4 ,						out_channels=4 ,						down_block_types=("DownBlock2D", "CrossAttnDownBlock2D") ,						up_block_types=("CrossAttnUpBlock2D", "UpBlock2D") ,						cross_attention_dim=3_2 ,						)
							_snake_case       :					Dict				       =   DDIMScheduler(
							    beta_start=0.0_00_85 ,						beta_end=0.0_12 ,						beta_schedule="scaled_linear" ,						clip_sample=__snake_case ,						set_alpha_to_one=__snake_case ,						)
							torch.manual_seed(0				)
							_snake_case       :					Any				       =   AutoencoderKL(
							    block_out_channels=[3_2, 6_4] ,						in_channels=3 ,						out_channels=3 ,						down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"] ,						up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"] ,						latent_channels=4 ,						)

							# TODO: address the non-deterministic text encoder (fails for save-load tests)
							# torch.manual_seed(0)
							# text_encoder_config = RobertaSeriesConfig(
							#     hidden_size=32,
							#     project_dim=32,
							#     intermediate_size=37,
							#     layer_norm_eps=1e-05,
							#     num_attention_heads=4,
							#     num_hidden_layers=5,
							#     vocab_size=5002,
							# )
							# text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

							torch.manual_seed(0				)
							_snake_case       :					str				       =   CLIPTextConfig(
							    bos_token_id=0 ,						eos_token_id=2 ,						hidden_size=3_2 ,						projection_dim=3_2 ,						intermediate_size=3_7 ,						layer_norm_eps=1E-05 ,						num_attention_heads=4 ,						num_hidden_layers=5 ,						pad_token_id=1 ,						vocab_size=5_0_0_2 ,						)
							_snake_case       :					int				       =   CLIPTextModel(__snake_case				)

							_snake_case       :					Tuple				       =   XLMRobertaTokenizer.from_pretrained("hf-internal-testing/tiny-xlm-roberta"				)
							_snake_case       :					Optional[int]				       =   7_7

							_snake_case       :					str				       =   {
							    "unet": unet,
							    "scheduler": scheduler,
							    "vae": vae,
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							    "safety_checker": None,
							    "feature_extractor": None,
							}
							return components







		def        lowercase       (    self ,						__snake_case ,						__snake_case=0				)      ->      Any:


							'''simple docstring'''

							if str(__snake_case				).startswith("mps"				):
												_snake_case       :					Optional[int]				       =   torch.manual_seed(__snake_case				)
							else:
												_snake_case       :					Dict				       =   torch.Generator(device=__snake_case				).manual_seed(__snake_case				)
							_snake_case       :					Dict				       =   {
							    "prompt": "A painting of a squirrel eating a burger",
							    "generator": generator,
							    "num_inference_steps": 2,
							    "guidance_scale": 6.0,
							    "output_type": "numpy",
							}
							return inputs







		def        lowercase       (    self				)      ->      Optional[int]:


							'''simple docstring'''

							super().test_attention_slicing_forward_pass(expected_max_diff=3E-3				)







		def        lowercase       (    self				)      ->      Tuple:


							'''simple docstring'''

							super().test_inference_batch_single_identical(expected_max_diff=3E-3				)







		def        lowercase       (    self				)      ->      Optional[int]:


							'''simple docstring'''

							_snake_case       :					int				       =   "cpu"  # ensure determinism for the device-dependent torch.Generator

							_snake_case       :					Tuple				       =   self.get_dummy_components()
							torch.manual_seed(0				)
							_snake_case       :					Any				       =   RobertaSeriesConfig(
							    hidden_size=3_2 ,						project_dim=3_2 ,						intermediate_size=3_7 ,						layer_norm_eps=1E-05 ,						num_attention_heads=4 ,						num_hidden_layers=5 ,						vocab_size=5_0_0_2 ,						)
							# TODO: remove after fixing the non-deterministic text encoder
							_snake_case       :					List[Any]				       =   RobertaSeriesModelWithTransformation(__snake_case				)
							_snake_case       :					Tuple				       =   text_encoder

							_snake_case       :					Tuple				       =   AltDiffusionPipeline(**__snake_case				)
							_snake_case       :					Optional[Any]				       =   alt_pipe.to(__snake_case				)
							alt_pipe.set_progress_bar_config(disable=__snake_case				)

							_snake_case       :					Any				       =   self.get_dummy_inputs(__snake_case				)
							_snake_case       :					int				       =   "A photo of an astronaut"
							_snake_case       :					Union[str, Any]				       =   alt_pipe(**__snake_case				)
							_snake_case       :					str				       =   output.images
							_snake_case       :					Optional[int]				       =   image[0, -3:, -3:, -1]

							assert image.shape == (1, 6_4, 6_4, 3)
							_snake_case       :					List[Any]				       =   np.array(
							    [0.5_74_81_62, 0.60_44_71_45, 0.48_82_12_17, 0.50_10_06_36, 0.5_43_11_85, 0.45_76_36_83, 0.49_65_76_96, 0.48_13_27_33, 0.47_57_30_93]				)

							assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2







		def        lowercase       (    self				)      ->      int:


							'''simple docstring'''

							_snake_case       :					Tuple				       =   "cpu"  # ensure determinism for the device-dependent torch.Generator

							_snake_case       :					Union[str, Any]				       =   self.get_dummy_components()
							_snake_case       :					List[Any]				       =   PNDMScheduler(skip_prk_steps=__snake_case				)
							torch.manual_seed(0				)
							_snake_case       :					List[str]				       =   RobertaSeriesConfig(
							    hidden_size=3_2 ,						project_dim=3_2 ,						intermediate_size=3_7 ,						layer_norm_eps=1E-05 ,						num_attention_heads=4 ,						num_hidden_layers=5 ,						vocab_size=5_0_0_2 ,						)
							# TODO: remove after fixing the non-deterministic text encoder
							_snake_case       :					List[Any]				       =   RobertaSeriesModelWithTransformation(__snake_case				)
							_snake_case       :					Any				       =   text_encoder
							_snake_case       :					int				       =   AltDiffusionPipeline(**__snake_case				)
							_snake_case       :					Tuple				       =   alt_pipe.to(__snake_case				)
							alt_pipe.set_progress_bar_config(disable=__snake_case				)

							_snake_case       :					List[str]				       =   self.get_dummy_inputs(__snake_case				)
							_snake_case       :					Optional[int]				       =   alt_pipe(**__snake_case				)
							_snake_case       :					Optional[Any]				       =   output.images
							_snake_case       :					Any				       =   image[0, -3:, -3:, -1]

							assert image.shape == (1, 6_4, 6_4, 3)
							_snake_case       :					List[str]				       =   np.array(
							    [0.51_60_50_93, 0.5_70_72_41, 0.47_36_55_07, 0.50_57_88_86, 0.5_63_38_77, 0.4_64_25_03, 0.5_18_20_81, 0.48_76_34_84, 0.49_08_42_37]				)

							assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2






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







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


							'''simple docstring'''

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







		def        lowercase       (    self				)      ->      List[str]:


							'''simple docstring'''

							_snake_case       :					Optional[int]				       =   AltDiffusionPipeline.from_pretrained("BAAI/AltDiffusion" ,						safety_checker=__snake_case				)
							_snake_case       :					Dict				       =   alt_pipe.to(__snake_case				)
							alt_pipe.set_progress_bar_config(disable=__snake_case				)

							_snake_case       :					str				       =   "A painting of a squirrel eating a burger"
							_snake_case       :					Any				       =   torch.manual_seed(0				)
							_snake_case       :					str				       =   alt_pipe([prompt] ,						generator=__snake_case ,						guidance_scale=6.0 ,						num_inference_steps=2_0 ,						output_type="np"				)

							_snake_case       :					Optional[Any]				       =   output.images

							_snake_case       :					Tuple				       =   image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_1_2, 5_1_2, 3)
							_snake_case       :					Dict				       =   np.array([0.10_10, 0.08_00, 0.07_94, 0.08_85, 0.08_43, 0.07_62, 0.07_69, 0.07_29, 0.05_86]				)

							assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2







		def        lowercase       (    self				)      ->      Optional[int]:


							'''simple docstring'''

							_snake_case       :					Any				       =   DDIMScheduler.from_pretrained("BAAI/AltDiffusion" ,						subfolder="scheduler"				)

							_snake_case       :					int				       =   AltDiffusionPipeline.from_pretrained("BAAI/AltDiffusion" ,						scheduler=__snake_case ,						safety_checker=__snake_case				)
							_snake_case       :					Union[str, Any]				       =   alt_pipe.to(__snake_case				)
							alt_pipe.set_progress_bar_config(disable=__snake_case				)

							_snake_case       :					Tuple				       =   "A painting of a squirrel eating a burger"
							_snake_case       :					Union[str, Any]				       =   torch.manual_seed(0				)

							_snake_case       :					List[str]				       =   alt_pipe([prompt] ,						generator=__snake_case ,						num_inference_steps=2 ,						output_type="numpy"				)
							_snake_case       :					int				       =   output.images

							_snake_case       :					List[Any]				       =   image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_1_2, 5_1_2, 3)
							_snake_case       :					Optional[int]				       =   np.array([0.40_19, 0.40_52, 0.38_10, 0.41_19, 0.39_16, 0.39_82, 0.46_51, 0.41_95, 0.53_23]				)

							assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2






import re







def    A				(							UpperCAmelCase				):
					_snake_case       :					Any				       =   re.compile(R"^(\+91[\-\s]?)?[0]?(91)?[789]\d{9}$"				)
					if match := re.search(UpperCAmelCase  ,  UpperCAmelCase				):
										return match.string == phone
					return False


if __name__ == "__main__":
							print(indian_phone_validator('+918827897895'))