





"""simple docstring"""
from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    get_resize_output_image_size,
    normalize,
    pad,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging
from ...utils.import_utils import is_vision_available


_snake_case	:						Union[str, Any]					=					logging.get_logger(__name__)


if is_vision_available():
		import PIL






class    _UpperCAmelCase  (      lowerCamelCase__					):
					UpperCamelCase						=				['pixel_values']


					def __init__(   self     :Tuple	,			__UpperCamelCase     :Union[str, Any] = True	,			__UpperCamelCase     :Optional[int] = None	,			__UpperCamelCase     :List[Any] = PILImageResampling.BILINEAR	,			__UpperCamelCase     :str = True	,			__UpperCamelCase     :List[str] = False	,			__UpperCamelCase     :str = True	,			__UpperCamelCase     :str = True	,			__UpperCamelCase     :Any = 1 / 2_55	,			__UpperCamelCase     :int = True	,			__UpperCamelCase     :List[Any] = None	,			__UpperCamelCase     :Union[str, Any] = None	,			**__UpperCamelCase     :Optional[Any]	,			):
												super().__init__(**lowercase_						)

												A						=    size if size is not None else {"height": 25_60, "width": 19_20}
												if isinstance(lowercase_	,			(tuple, list)						):
																			# The previous feature extractor size parameter was in (width, height) format
																			A						=    size[::-1]
												A						=    get_size_dict(lowercase_						)

												A						=    do_resize
												A						=    size
												A						=    resample
												A						=    do_thumbnail
												A						=    do_align_long_axis
												A						=    do_pad
												A						=    do_rescale
												A						=    rescale_factor
												A						=    do_normalize
												A						=    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
												A						=    image_std if image_std is not None else IMAGENET_STANDARD_STD


					def       lowerCamelCase			(   self     :Any	,			__UpperCamelCase     :Optional[int]	,			__UpperCamelCase     :str	,			__UpperCamelCase     :Union[str, Any] = None						):
												A,      A						=    get_image_size(lowercase_						)
												A,      A						=    size["height"], size["width"]

												if (output_width < output_height and input_width > input_height) or (
												    output_width > output_height and input_width < input_height
												):
																			A						=    np.rotaa(lowercase_	,			3						)

												if data_format is not None:
																			A						=    to_channel_dimension_format(lowercase_	,			lowercase_						)

												return image


					def       lowerCamelCase			(   self     :Any	,			__UpperCamelCase     :Tuple	,			__UpperCamelCase     :Optional[Any]	,			__UpperCamelCase     :List[str] = False	,			__UpperCamelCase     :Union[str, Any] = None	,			):
												A,      A						=    size["height"], size["width"]
												A,      A						=    get_image_size(lowercase_						)

												A						=    output_width - input_width
												A						=    output_height - input_height

												if random_padding:
																			A						=    np.random.randint(low=0	,			high=delta_height + 1						)
																			A						=    np.random.randint(low=0	,			high=delta_width + 1						)
												else:
																			A						=    delta_height // 2
																			A						=    delta_width // 2

												A						=    delta_height - pad_top
												A						=    delta_width - pad_left

												A						=    ((pad_top, pad_bottom), (pad_left, pad_right))
												return pad(lowercase_	,			lowercase_	,			data_format=lowercase_						)


					def       lowerCamelCase			(   self     :Dict	,			*__UpperCamelCase     :int	,			**__UpperCamelCase     :Optional[Any]						):
												logger.info("pad is deprecated and will be removed in version 4.27. Please use pad_image instead."						)
												return self.pad_image(*lowercase_	,			**lowercase_						)


					def       lowerCamelCase			(   self     :Optional[int]	,			__UpperCamelCase     :int	,			__UpperCamelCase     :Any	,			__UpperCamelCase     :Optional[Any] = PILImageResampling.BICUBIC	,			__UpperCamelCase     :Dict = None	,			**__UpperCamelCase     :Union[str, Any]	,			):
												A,      A						=    get_image_size(lowercase_						)
												A,      A						=    size["height"], size["width"]

												# We always resize to the smallest of either the input or output size.
												A						=    min(lowercase_	,			lowercase_						)
												A						=    min(lowercase_	,			lowercase_						)

												if height == input_height and width == input_width:
																			return image

												if input_height > input_width:
																			A						=    int(input_width * height / input_height						)
												elif input_width > input_height:
																			A						=    int(input_height * width / input_width						)

												return resize(
												    lowercase_	,			size=(height, width)	,			resample=lowercase_	,			reducing_gap=2.0	,			data_format=lowercase_	,			**lowercase_						)


					def       lowerCamelCase			(   self     :Optional[Any]	,			__UpperCamelCase     :Optional[Any]	,			__UpperCamelCase     :Optional[int]	,			__UpperCamelCase     :Optional[Any] = PILImageResampling.BICUBIC	,			__UpperCamelCase     :Optional[Any] = None	,			**__UpperCamelCase     :Any	,			):
												A						=    get_size_dict(lowercase_						)
												A						=    min(size["height"]	,			size["width"]						)
												A						=    get_resize_output_image_size(lowercase_	,			size=lowercase_	,			default_to_square=lowercase_						)
												A						=    resize(lowercase_	,			size=lowercase_	,			resample=lowercase_	,			data_format=lowercase_	,			**lowercase_						)
												return resized_image


					def       lowerCamelCase			(   self     :Dict	,			__UpperCamelCase     :Optional[int]	,			__UpperCamelCase     :Union[str, Any]	,			__UpperCamelCase     :Union[str, Any] = None	,			**__UpperCamelCase     :Optional[Any]	,			):
												return rescale(lowercase_	,			scale=lowercase_	,			data_format=lowercase_	,			**lowercase_						)


					def       lowerCamelCase			(   self     :Any	,			__UpperCamelCase     :List[str]	,			__UpperCamelCase     :List[Any]	,			__UpperCamelCase     :Dict	,			__UpperCamelCase     :str = None	,			**__UpperCamelCase     :Dict	,			):
												return normalize(lowercase_	,			mean=lowercase_	,			std=lowercase_	,			data_format=lowercase_	,			**lowercase_						)


					def       lowerCamelCase			(   self     :str	,			__UpperCamelCase     :int	,			__UpperCamelCase     :Optional[int] = None	,			__UpperCamelCase     :List[Any] = None	,			__UpperCamelCase     :Optional[Any] = None	,			__UpperCamelCase     :List[Any] = None	,			__UpperCamelCase     :Any = None	,			__UpperCamelCase     :List[str] = None	,			__UpperCamelCase     :int = False	,			__UpperCamelCase     :Optional[int] = None	,			__UpperCamelCase     :List[str] = None	,			__UpperCamelCase     :str = None	,			__UpperCamelCase     :Tuple = None	,			__UpperCamelCase     :List[str] = None	,			__UpperCamelCase     :Optional[int] = None	,			__UpperCamelCase     :Optional[Any] = ChannelDimension.FIRST	,			**__UpperCamelCase     :str	,			):
												A						=    do_resize if do_resize is not None else self.do_resize
												A						=    size if size is not None else self.size
												if isinstance(lowercase_	,			(tuple, list)						):
																			# Previous feature extractor had size in (width, height) format
																			A						=    size[::-1]
												A						=    get_size_dict(lowercase_						)
												A						=    resample if resample is not None else self.resample
												A						=    do_thumbnail if do_thumbnail is not None else self.do_thumbnail
												A						=    do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
												A						=    do_pad if do_pad is not None else self.do_pad
												A						=    do_rescale if do_rescale is not None else self.do_rescale
												A						=    rescale_factor if rescale_factor is not None else self.rescale_factor
												A						=    do_normalize if do_normalize is not None else self.do_normalize
												A						=    image_mean if image_mean is not None else self.image_mean
												A						=    image_std if image_std is not None else self.image_std

												A						=    make_list_of_images(lowercase_						)

												if not valid_images(lowercase_						):
																			raise ValueError(
																			    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
																			    "torch.Tensor, tf.Tensor or jax.ndarray."						)

												if do_resize and size is None:
																			raise ValueError("Size must be specified if do_resize is True."						)

												if do_rescale and rescale_factor is None:
																			raise ValueError("Rescale factor must be specified if do_rescale is True."						)

												if do_pad and size is None:
																			raise ValueError("Size must be specified if do_pad is True."						)

												if do_normalize and (image_mean is None or image_std is None):
																			raise ValueError("Image mean and std must be specified if do_normalize is True."						)

												# All transformations expect numpy arrays.
												A						=    [to_numpy_array(lowercase_						) for image in images]

												if do_align_long_axis:
																			A						=    [self.align_long_axis(lowercase_	,			size=lowercase_						) for image in images]

												if do_resize:
																			A						=    [self.resize(image=lowercase_	,			size=lowercase_	,			resample=lowercase_						) for image in images]

												if do_thumbnail:
																			A						=    [self.thumbnail(image=lowercase_	,			size=lowercase_						) for image in images]

												if do_pad:
																			A						=    [self.pad_image(image=lowercase_	,			size=lowercase_	,			random_padding=lowercase_						) for image in images]

												if do_rescale:
																			A						=    [self.rescale(image=lowercase_	,			scale=lowercase_						) for image in images]

												if do_normalize:
																			A						=    [self.normalize(image=lowercase_	,			mean=lowercase_	,			std=lowercase_						) for image in images]

												A						=    [to_channel_dimension_format(lowercase_	,			lowercase_						) for image in images]

												A						=    {"pixel_values": images}
												return BatchFeature(data=lowercase_	,			tensor_type=lowercase_						)





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 		__magic_name__     :

   '''simple docstring'''




   def __init__(							self,       lowercase_,       lowercase_=13,       lowercase_=7,       lowercase_=True,       lowercase_=True,       lowercase_=True,       lowercase_=True,       lowercase_=99,       lowercase_=32,       lowercase_=5,       lowercase_=4,       lowercase_=37,       lowercase_="gelu",       lowercase_=0.1,       lowercase_=0.1,       lowercase_=512,       lowercase_=16,       lowercase_=2,       lowercase_=0.02,       lowercase_=3,       lowercase_=None,       lowercase_=20,       lowercase_=30,       lowercase_=2,       lowercase_=2,       lowercase_=10,       )				->       Dict:






     """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 					_UpperCAmelCase					(							self			)				->       Optional[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 					_UpperCAmelCase					(							self			)				->       List[str]:






     """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 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       )				->       Tuple:






     """simple docstring"""






     a__    =MarkupLMModel(config=lowercase_			)
     model.to(lowercase_			)
     model.eval()
     print('''Configs:''',       model.config.tag_pad_id,       model.config.subs_pad_id			)
     a__    =model(lowercase_,       attention_mask=lowercase_,       token_type_ids=lowercase_			)
     a__    =model(lowercase_,       token_type_ids=lowercase_			)
     a__    =model(lowercase_			)
     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 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       )				->       Tuple:






     """simple docstring"""






     a__    =self.num_labels
     a__    =MarkupLMForSequenceClassification(lowercase_			)
     model.to(lowercase_			)
     model.eval()
     a__    =model(
         lowercase_,       xpath_tags_seq=lowercase_,       xpath_subs_seq=lowercase_,       attention_mask=lowercase_,       token_type_ids=lowercase_,       labels=lowercase_,       )
     self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.num_labels)			)



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






     """simple docstring"""






     a__    =self.num_labels
     a__    =MarkupLMForTokenClassification(config=lowercase_			)
     model.to(lowercase_			)
     model.eval()
     a__    =model(
         lowercase_,       xpath_tags_seq=lowercase_,       xpath_subs_seq=lowercase_,       attention_mask=lowercase_,       token_type_ids=lowercase_,       labels=lowercase_,       )
     self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.seq_length, self.num_labels)			)



   def 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       )				->       Any:






     """simple docstring"""






     a__    =MarkupLMForQuestionAnswering(config=lowercase_			)
     model.to(lowercase_			)
     model.eval()
     a__    =model(
         lowercase_,       xpath_tags_seq=lowercase_,       xpath_subs_seq=lowercase_,       attention_mask=lowercase_,       token_type_ids=lowercase_,       start_positions=lowercase_,       end_positions=lowercase_,       )
     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 					_UpperCAmelCase					(							self			)				->       Union[str, 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 		__magic_name__     (				lowerCamelCase__						,			lowerCamelCase__						,			unittest.TestCase				):

   '''simple docstring'''




   lowerCamelCase__					:      Tuple        =  (
       (
           MarkupLMModel,
           MarkupLMForSequenceClassification,
           MarkupLMForTokenClassification,
           MarkupLMForQuestionAnswering,
       )
       if is_torch_available()
       else None
   )
   lowerCamelCase__					:      Union[str, Any]        =  (
       {
           'feature-extraction': MarkupLMModel,
           'question-answering': MarkupLMForQuestionAnswering,
           'text-classification': MarkupLMForSequenceClassification,
           'token-classification': MarkupLMForTokenClassification,
           'zero-shot': MarkupLMForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )



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






     """simple docstring"""






     return True



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






     """simple docstring"""






     a__    =MarkupLMModelTester(self			)
     a__    =ConfigTester(self,       config_class=lowercase_,       hidden_size=37			)



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






     """simple docstring"""






     self.config_tester.run_common_tests()



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






     """simple docstring"""






     a__    =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_			)



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






     """simple docstring"""






     a__    =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_sequence_classification(*lowercase_			)



   def 					_UpperCAmelCase					(							self			)				->       Tuple:






     """simple docstring"""






     a__    =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*lowercase_			)



   def 					_UpperCAmelCase					(							self			)				->       int:






     """simple docstring"""






     a__    =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*lowercase_			)





def      UpperCAmelCase__							(     ):





  '''simple docstring'''







  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 		__magic_name__     (				unittest.TestCase				):

   '''simple docstring'''




   @cached_property
   def 					_UpperCAmelCase					(							self			)				->       List[str]:






     """simple docstring"""






     a__    =MarkupLMFeatureExtractor()
     a__    =MarkupLMTokenizer.from_pretrained('''microsoft/markuplm-base'''			)

     return MarkupLMProcessor(lowercase_,       lowercase_			)



   @slow
   def 					_UpperCAmelCase					(							self			)				->       Optional[Any]:






     """simple docstring"""






     a__    =MarkupLMModel.from_pretrained('''microsoft/markuplm-base'''			).to(lowercase_			)

     a__    =self.default_processor

     a__    =processor(prepare_html_string(),       return_tensors='''pt'''			)
     a__    =inputs.to(lowercase_			)

     # forward pass
     with torch.no_grad():
       a__    =model(**lowercase_			)

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

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

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