




import unittest

from transformers import MarkupLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MarkupLMForQuestionAnswering,
		    MarkupLMForSequenceClassification,
		    MarkupLMForTokenClassification,
		    MarkupLMModel,
		)

# TODO check dependencies
from transformers import MarkupLMFeatureExtractor, MarkupLMProcessor, MarkupLMTokenizer

class 	__lowerCAmelCase			:
							def __init__(		self		:Tuple	,   __magic_name__		:List[Any]	,   __magic_name__		:Any=13	,   __magic_name__		:Any=7	,   __magic_name__		:Optional[Any]=True	,   __magic_name__		:Optional[int]=True	,   __magic_name__		:Optional[Any]=True	,   __magic_name__		:str=True	,   __magic_name__		:List[str]=99	,   __magic_name__		:int=32	,   __magic_name__		:Tuple=5	,   __magic_name__		:List[Any]=4	,   __magic_name__		:Optional[Any]=37	,   __magic_name__		:str="gelu"	,   __magic_name__		:List[Any]=0.1	,   __magic_name__		:int=0.1	,   __magic_name__		:int=512	,   __magic_name__		:Any=16	,   __magic_name__		:List[Any]=2	,   __magic_name__		:Any=0.02	,   __magic_name__		:Any=3	,   __magic_name__		:str=None	,   __magic_name__		:List[str]=20	,   __magic_name__		:Union[str, Any]=30	,   __magic_name__		:int=2	,   __magic_name__		:Optional[Any]=2	,   __magic_name__		:int=10	,   ):







								'''simple docstring'''







								a		       =							parent
								a		       =							batch_size
								a		       =							seq_length
								a		       =							is_training
								a		       =							use_input_mask
								a		       =							use_token_type_ids
								a		       =							use_labels
								a		       =							vocab_size
								a		       =							hidden_size
								a		       =							num_hidden_layers
								a		       =							num_attention_heads
								a		       =							intermediate_size
								a		       =							hidden_act
								a		       =							hidden_dropout_prob
								a		       =							attention_probs_dropout_prob
								a		       =							max_position_embeddings
								a		       =							type_vocab_size
								a		       =							type_sequence_label_size
								a		       =							initializer_range
								a		       =							num_labels
								a		       =							scope
								a		       =							max_xpath_tag_unit_embeddings
								a		       =							max_xpath_subs_unit_embeddings
								a		       =							tag_pad_id
								a		       =							subs_pad_id
								a		       =							max_depth
							def    lowerCamelCase__							(		self		:Union[str, Any]       ):







								'''simple docstring'''







								a		       =							ids_tensor([self.batch_size, self.seq_length]	,   self.vocab_size       )

								a		       =							ids_tensor(
								    [self.batch_size, self.seq_length, self.max_depth]	,   self.max_xpath_tag_unit_embeddings       )

								a		       =							ids_tensor(
								    [self.batch_size, self.seq_length, self.max_depth]	,   self.max_xpath_subs_unit_embeddings       )

								a		       =							None
								if self.use_input_mask:
									a		       =							ids_tensor([self.batch_size, self.seq_length]	,   vocab_size=2       )

								a		       =							None
								if self.use_token_type_ids:
									a		       =							ids_tensor([self.batch_size, self.seq_length]	,   self.type_vocab_size       )

								a		       =							None
								a		       =							None
								if self.use_labels:
									a		       =							ids_tensor([self.batch_size]	,   self.type_sequence_label_size       )
									a		       =							ids_tensor([self.batch_size, self.seq_length]	,   self.num_labels       )

								a		       =							self.get_config()

								return (
								    config,
								    input_ids,
								    xpath_tags_seq,
								    xpath_subs_seq,
								    token_type_ids,
								    input_mask,
								    sequence_labels,
								    token_labels,
								)
							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								return MarkupLMConfig(
								    vocab_size=self.vocab_size	,   hidden_size=self.hidden_size	,   num_hidden_layers=self.num_hidden_layers	,   num_attention_heads=self.num_attention_heads	,   intermediate_size=self.intermediate_size	,   hidden_act=self.hidden_act	,   hidden_dropout_prob=self.hidden_dropout_prob	,   attention_probs_dropout_prob=self.attention_probs_dropout_prob	,   max_position_embeddings=self.max_position_embeddings	,   type_vocab_size=self.type_vocab_size	,   initializer_range=self.initializer_range	,   max_xpath_tag_unit_embeddings=self.max_xpath_tag_unit_embeddings	,   max_xpath_subs_unit_embeddings=self.max_xpath_subs_unit_embeddings	,   tag_pad_id=self.tag_pad_id	,   subs_pad_id=self.subs_pad_id	,   max_depth=self.max_depth	,   )
							def    lowerCamelCase__							(		self		:List[str]	,   __magic_name__		:str	,   __magic_name__		:Optional[Any]	,   __magic_name__		:List[Any]	,   __magic_name__		:List[str]	,   __magic_name__		:List[Any]	,   __magic_name__		:Tuple	,   __magic_name__		:List[Any]	,   __magic_name__		:str	,   ):







								'''simple docstring'''







								a		       =							MarkupLMModel(config=__magic_name__       )
								model.to(__magic_name__       )
								model.eval()
								print("""Configs:"""	,   model.config.tag_pad_id	,   model.config.subs_pad_id       )
								a		       =							model(__magic_name__	,   attention_mask=__magic_name__	,   token_type_ids=__magic_name__       )
								a		       =							model(__magic_name__	,   token_type_ids=__magic_name__       )
								a		       =							model(__magic_name__       )
								self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, self.seq_length, self.hidden_size)       )
								self.parent.assertEqual(result.pooler_output.shape	,   (self.batch_size, self.hidden_size)       )
							def    lowerCamelCase__							(		self		:List[str]	,   __magic_name__		:str	,   __magic_name__		:Tuple	,   __magic_name__		:Optional[Any]	,   __magic_name__		:List[Any]	,   __magic_name__		:Dict	,   __magic_name__		:str	,   __magic_name__		:Tuple	,   __magic_name__		:Optional[Any]	,   ):







								'''simple docstring'''







								a		       =							self.num_labels
								a		       =							MarkupLMForSequenceClassification(__magic_name__       )
								model.to(__magic_name__       )
								model.eval()
								a		       =							model(
								    __magic_name__	,   xpath_tags_seq=__magic_name__	,   xpath_subs_seq=__magic_name__	,   attention_mask=__magic_name__	,   token_type_ids=__magic_name__	,   labels=__magic_name__	,   )
								self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_labels)       )
							def    lowerCamelCase__							(		self		:Optional[int]	,   __magic_name__		:List[Any]	,   __magic_name__		:Optional[Any]	,   __magic_name__		:int	,   __magic_name__		:int	,   __magic_name__		:Dict	,   __magic_name__		:int	,   __magic_name__		:str	,   __magic_name__		:Any	,   ):







								'''simple docstring'''







								a		       =							self.num_labels
								a		       =							MarkupLMForTokenClassification(config=__magic_name__       )
								model.to(__magic_name__       )
								model.eval()
								a		       =							model(
								    __magic_name__	,   xpath_tags_seq=__magic_name__	,   xpath_subs_seq=__magic_name__	,   attention_mask=__magic_name__	,   token_type_ids=__magic_name__	,   labels=__magic_name__	,   )
								self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.seq_length, self.num_labels)       )
							def    lowerCamelCase__							(		self		:str	,   __magic_name__		:str	,   __magic_name__		:int	,   __magic_name__		:int	,   __magic_name__		:str	,   __magic_name__		:Optional[int]	,   __magic_name__		:Dict	,   __magic_name__		:List[str]	,   __magic_name__		:Any	,   ):







								'''simple docstring'''







								a		       =							MarkupLMForQuestionAnswering(config=__magic_name__       )
								model.to(__magic_name__       )
								model.eval()
								a		       =							model(
								    __magic_name__	,   xpath_tags_seq=__magic_name__	,   xpath_subs_seq=__magic_name__	,   attention_mask=__magic_name__	,   token_type_ids=__magic_name__	,   start_positions=__magic_name__	,   end_positions=__magic_name__	,   )
								self.parent.assertEqual(result.start_logits.shape	,   (self.batch_size, self.seq_length)       )
								self.parent.assertEqual(result.end_logits.shape	,   (self.batch_size, self.seq_length)       )





							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								a		       =							self.prepare_config_and_inputs()
								(
								    (
								    a				
								)       ,				(
								    a				
								)       ,				(
								    a				
								)       ,				(
								    a				
								)       ,				(
								    a				
								)       ,				(
								    a				
								)       ,				(
								    a				
								)       ,				(
								    a				
								)       ,								
								)		       =							config_and_inputs
								a		       =							{
								    """input_ids""": input_ids,
								    """xpath_tags_seq""": xpath_tags_seq,
								    """xpath_subs_seq""": xpath_subs_seq,
								    """token_type_ids""": token_type_ids,
								    """attention_mask""": input_mask,
								}
								return config, inputs_dict







@require_torch
class 	__lowerCAmelCase			(			__magic_name__   , __magic_name__   , unittest.TestCase				):
							UpperCamelCase__        =						(
							    (
							        MarkupLMModel,
							        MarkupLMForSequenceClassification,
							        MarkupLMForTokenClassification,
							        MarkupLMForQuestionAnswering,
							    )
							    if is_torch_available()
							    else None
							)
							UpperCamelCase__        =						(
							    {
							        '''feature-extraction''': MarkupLMModel,
							        '''question-answering''': MarkupLMForQuestionAnswering,
							        '''text-classification''': MarkupLMForSequenceClassification,
							        '''token-classification''': MarkupLMForTokenClassification,
							        '''zero-shot''': MarkupLMForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							def    lowerCamelCase__							(		self		:int	,   __magic_name__		:List[Any]	,   __magic_name__		:List[str]	,   __magic_name__		:Any	,   __magic_name__		:Union[str, Any]	,   __magic_name__		:Dict       ):







								'''simple docstring'''







								return True
							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								a		       =							MarkupLMModelTester(self       )
								a		       =							ConfigTester(self	,   config_class=__magic_name__	,   hidden_size=37       )
							def    lowerCamelCase__							(		self		:Tuple       ):







								'''simple docstring'''







								self.config_tester.run_common_tests()
							def    lowerCamelCase__							(		self		:Tuple       ):







								'''simple docstring'''







								a		       =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__magic_name__       )
							def    lowerCamelCase__							(		self		:Tuple       ):







								'''simple docstring'''







								a		       =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*__magic_name__       )
							def    lowerCamelCase__							(		self		:int       ):







								'''simple docstring'''







								a		       =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*__magic_name__       )





							def    lowerCamelCase__							(		self		:Union[str, Any]       ):







								'''simple docstring'''







								a		       =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*__magic_name__       )







def 	__A	(			)   -> Optional[Any]:
	a		       =							"""
    <!DOCTYPE html>
    <html>
    <head>
    <title>Page Title</title>
    </head>
    <body>

    <h1>This is a Heading</h1>
    <p>This is a paragraph.</p>

    </body>
    </html>
    """

	return html_string



@require_torch
class 	__lowerCAmelCase			(			unittest.TestCase				):
							@cached_property
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								a		       =							MarkupLMFeatureExtractor()
								a		       =							MarkupLMTokenizer.from_pretrained("""microsoft/markuplm-base"""       )

								return MarkupLMProcessor(__magic_name__	,   __magic_name__       )





							@slow
							def    lowerCamelCase__							(		self		:Tuple       ):







								'''simple docstring'''







								a		       =							MarkupLMModel.from_pretrained("""microsoft/markuplm-base"""       ).to(__magic_name__       )

								a		       =							self.default_processor

								a		       =							processor(prepare_html_string()	,   return_tensors="""pt"""       )
								a		       =							inputs.to(__magic_name__       )

								# forward pass
								with torch.no_grad():
									a		       =							model(**__magic_name__       )

								# verify the last hidden states
								a		       =							torch.Size([1, 14, 768]       )
								self.assertEqual(outputs.last_hidden_state.shape	,   __magic_name__       )

								a		       =							torch.tensor(
								    [[0.0675, -0.0052, 0.5001], [-0.2281, 0.0802, 0.2192], [-0.0583, -0.3311, 0.1185]]       ).to(__magic_name__       )

								self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]	,   __magic_name__	,   atol=1E-4       )       )







import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
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 PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class 	__lowerCAmelCase			(			__magic_name__   , __magic_name__   , unittest.TestCase				):
							UpperCamelCase__        =						StableDiffusionParadigmsPipeline
							UpperCamelCase__        =						TEXT_TO_IMAGE_PARAMS
							UpperCamelCase__        =						TEXT_TO_IMAGE_BATCH_PARAMS
							UpperCamelCase__        =						TEXT_TO_IMAGE_IMAGE_PARAMS
							UpperCamelCase__        =						TEXT_TO_IMAGE_IMAGE_PARAMS
							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								torch.manual_seed(0       )
								a		       =							UNetaDConditionModel(
								    block_out_channels=(32, 64)	,   layers_per_block=2	,   sample_size=32	,   in_channels=4	,   out_channels=4	,   down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")	,   up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")	,   cross_attention_dim=32	,   attention_head_dim=(2, 4)	,   use_linear_projection=__magic_name__	,   )
								a		       =							DDIMParallelScheduler(
								    beta_start=0.00085	,   beta_end=0.012	,   beta_schedule="""scaled_linear"""	,   clip_sample=__magic_name__	,   set_alpha_to_one=__magic_name__	,   )
								torch.manual_seed(0       )
								a		       =							AutoencoderKL(
								    block_out_channels=[32, 64]	,   in_channels=3	,   out_channels=3	,   down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]	,   up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]	,   latent_channels=4	,   sample_size=128	,   )
								torch.manual_seed(0       )
								a		       =							CLIPTextConfig(
								    bos_token_id=0	,   eos_token_id=2	,   hidden_size=32	,   intermediate_size=37	,   layer_norm_eps=1E-0_5	,   num_attention_heads=4	,   num_hidden_layers=5	,   pad_token_id=1	,   vocab_size=1000	,   hidden_act="""gelu"""	,   projection_dim=512	,   )
								a		       =							CLIPTextModel(__magic_name__       )
								a		       =							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

								a		       =							{
								    """unet""": unet,
								    """scheduler""": scheduler,
								    """vae""": vae,
								    """text_encoder""": text_encoder,
								    """tokenizer""": tokenizer,
								    """safety_checker""": None,
								    """feature_extractor""": None,
								}
								return components
							def    lowerCamelCase__							(		self		:Any	,   __magic_name__		:List[Any]	,   __magic_name__		:Tuple=0       ):







								'''simple docstring'''







								if str(__magic_name__       ).startswith("""mps"""       ):
									a		       =							torch.manual_seed(__magic_name__       )
								else:
									a		       =							torch.Generator(device=__magic_name__       ).manual_seed(__magic_name__       )
								a		       =							{
								    """prompt""": """a photograph of an astronaut riding a horse""",
								    """generator""": generator,
								    """num_inference_steps""": 10,
								    """guidance_scale""": 6.0,
								    """output_type""": """numpy""",
								    """parallel""": 3,
								    """debug""": True,
								}
								return inputs
							def    lowerCamelCase__							(		self		:Dict       ):







								'''simple docstring'''







								a		       =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								a		       =							StableDiffusionParadigmsPipeline(**__magic_name__       )
								a		       =							sd_pipe.to(__magic_name__       )
								sd_pipe.set_progress_bar_config(disable=__magic_name__       )

								a		       =							self.get_dummy_inputs(__magic_name__       )
								a		       =							sd_pipe(**__magic_name__       ).images
								a		       =							image[0, -3:, -3:, -1]
								assert image.shape == (1, 64, 64, 3)

								a		       =							np.array([0.4773, 0.5417, 0.4723, 0.4925, 0.5631, 0.4752, 0.5240, 0.4935, 0.5023]       )

								assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2
							def    lowerCamelCase__							(		self		:Any       ):







								'''simple docstring'''







								a		       =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								torch.manual_seed(0       )
								a		       =							DDPMParallelScheduler()
								torch.manual_seed(0       )
								a		       =							StableDiffusionParadigmsPipeline(**__magic_name__       )
								a		       =							sd_pipe.to(__magic_name__       )
								sd_pipe.set_progress_bar_config(disable=__magic_name__       )

								a		       =							self.get_dummy_inputs(__magic_name__       )
								a		       =							sd_pipe(**__magic_name__       ).images
								a		       =							image[0, -3:, -3:, -1]
								assert image.shape == (1, 64, 64, 3)

								a		       =							np.array([0.3573, 0.4420, 0.4960, 0.4799, 0.3796, 0.3879, 0.4819, 0.4365, 0.4468]       )

								assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								super().test_inference_batch_consistent(batch_sizes=[1, 2]       )
							def    lowerCamelCase__							(		self		:str       ):







								'''simple docstring'''







								super().test_inference_batch_single_identical(batch_size=2	,   expected_max_diff=3E-3       )





							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								a		       =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								a		       =							StableDiffusionParadigmsPipeline(**__magic_name__       )
								a		       =							sd_pipe.to(__magic_name__       )
								sd_pipe.set_progress_bar_config(disable=__magic_name__       )

								a		       =							self.get_dummy_inputs(__magic_name__       )
								a		       =							"""french fries"""
								a		       =							sd_pipe(**__magic_name__	,   negative_prompt=__magic_name__       )
								a		       =							output.images
								a		       =							image[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)

								a		       =							np.array([0.4771, 0.5420, 0.4683, 0.4918, 0.5636, 0.4725, 0.5230, 0.4923, 0.5015]       )

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







@slow
@require_torch_gpu
class 	__lowerCAmelCase			(			unittest.TestCase				):
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()
							def    lowerCamelCase__							(		self		:str	,   __magic_name__		:Union[str, Any]=0       ):







								'''simple docstring'''







								a		       =							torch.Generator(device=__magic_name__       ).manual_seed(__magic_name__       )
								a		       =							{
								    """prompt""": """a photograph of an astronaut riding a horse""",
								    """generator""": generator,
								    """num_inference_steps""": 10,
								    """guidance_scale""": 7.5,
								    """output_type""": """numpy""",
								    """parallel""": 3,
								    """debug""": True,
								}
								return inputs





							def    lowerCamelCase__							(		self		:Dict       ):







								'''simple docstring'''







								a		       =							"""stabilityai/stable-diffusion-2-base"""
								a		       =							DDIMParallelScheduler.from_pretrained(__magic_name__	,   subfolder="""scheduler"""       )
								a		       =							StableDiffusionParadigmsPipeline.from_pretrained(__magic_name__	,   scheduler=__magic_name__	,   safety_checker=__magic_name__       )
								pipe.to(__magic_name__       )
								pipe.set_progress_bar_config(disable=__magic_name__       )
								pipe.enable_attention_slicing()

								a		       =							self.get_inputs()
								a		       =							pipe(**__magic_name__       ).images
								a		       =							image[0, -3:, -3:, -1].flatten()

								assert image.shape == (1, 512, 512, 3)

								a		       =							np.array([0.9622, 0.9602, 0.9748, 0.9591, 0.9630, 0.9691, 0.9661, 0.9631, 0.9741]       )

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

