


'''simple docstring'''





import unittest

from transformers import LayoutLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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 (
        LayoutLMForMaskedLM,
        LayoutLMForQuestionAnswering,
        LayoutLMForSequenceClassification,
        LayoutLMForTokenClassification,
        LayoutLMModel,
    )




class 							UpperCAmelCase :


 def __init__(			self       :  Optional[int] ,					__lowerCamelCase       :  Optional[Any] ,					__lowerCamelCase       :  List[str]=1_3 ,					__lowerCamelCase       :  str=7 ,					__lowerCamelCase       :  Union[str, Any]=True ,					__lowerCamelCase       :  Any=True ,					__lowerCamelCase       :  Union[str, Any]=True ,					__lowerCamelCase       :  Union[str, Any]=True ,					__lowerCamelCase       :  str=9_9 ,					__lowerCamelCase       :  int=3_2 ,					__lowerCamelCase       :  Union[str, Any]=5 ,					__lowerCamelCase       :  Dict=4 ,					__lowerCamelCase       :  List[Any]=3_7 ,					__lowerCamelCase       :  Any="gelu" ,					__lowerCamelCase       :  int=0.1 ,					__lowerCamelCase       :  int=0.1 ,					__lowerCamelCase       :  Optional[int]=5_1_2 ,					__lowerCamelCase       :  Union[str, Any]=1_6 ,					__lowerCamelCase       :  Tuple=2 ,					__lowerCamelCase       :  str=0.02 ,					__lowerCamelCase       :  int=3 ,					__lowerCamelCase       :  List[Any]=4 ,					__lowerCamelCase       :  Tuple=None ,					__lowerCamelCase       :  Any=1_0_0_0 ,					):
    UpperCAmelCase__  :Union[str, Any]            =			parent
    UpperCAmelCase__  :Any            =			batch_size
    UpperCAmelCase__  :List[str]            =			seq_length
    UpperCAmelCase__  :str            =			is_training
    UpperCAmelCase__  :Union[str, Any]            =			use_input_mask
    UpperCAmelCase__  :List[str]            =			use_token_type_ids
    UpperCAmelCase__  :Tuple            =			use_labels
    UpperCAmelCase__  :List[Any]            =			vocab_size
    UpperCAmelCase__  :int            =			hidden_size
    UpperCAmelCase__  :Any            =			num_hidden_layers
    UpperCAmelCase__  :Any            =			num_attention_heads
    UpperCAmelCase__  :str            =			intermediate_size
    UpperCAmelCase__  :Optional[Any]            =			hidden_act
    UpperCAmelCase__  :Optional[int]            =			hidden_dropout_prob
    UpperCAmelCase__  :Any            =			attention_probs_dropout_prob
    UpperCAmelCase__  :List[str]            =			max_position_embeddings
    UpperCAmelCase__  :str            =			type_vocab_size
    UpperCAmelCase__  :List[str]            =			type_sequence_label_size
    UpperCAmelCase__  :Optional[Any]            =			initializer_range
    UpperCAmelCase__  :Any            =			num_labels
    UpperCAmelCase__  :Any            =			num_choices
    UpperCAmelCase__  :List[Any]            =			scope
    UpperCAmelCase__  :Union[str, Any]            =			range_bbox


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Union[str, Any]   ):
    UpperCAmelCase__  :int            =			ids_tensor([self.batch_size, self.seq_length] ,					self.vocab_size   )

    UpperCAmelCase__  :Tuple            =			ids_tensor([self.batch_size, self.seq_length, 4] ,					self.range_bbox   )
    # Ensure that bbox is legal
    for i in range(bbox.shape[0]   ):
       for j in range(bbox.shape[1]   ):
          if bbox[i, j, 3] < bbox[i, j, 1]:
             UpperCAmelCase__  :Union[str, Any]            =			bbox[i, j, 3]
             UpperCAmelCase__  :str            =			bbox[i, j, 1]
             UpperCAmelCase__  :Any            =			t
          if bbox[i, j, 2] < bbox[i, j, 0]:
             UpperCAmelCase__  :Optional[Any]            =			bbox[i, j, 2]
             UpperCAmelCase__  :List[str]            =			bbox[i, j, 0]
             UpperCAmelCase__  :Optional[int]            =			t

    UpperCAmelCase__  :List[Any]            =			None
    if self.use_input_mask:
       UpperCAmelCase__  :int            =			ids_tensor([self.batch_size, self.seq_length] ,					vocab_size=2   )

    UpperCAmelCase__  :Optional[int]            =			None
    if self.use_token_type_ids:
       UpperCAmelCase__  :Any            =			ids_tensor([self.batch_size, self.seq_length] ,					self.type_vocab_size   )

    UpperCAmelCase__  :str            =			None
    UpperCAmelCase__  :Optional[int]            =			None
    UpperCAmelCase__  :List[Any]            =			None
    if self.use_labels:
       UpperCAmelCase__  :int            =			ids_tensor([self.batch_size] ,					self.type_sequence_label_size   )
       UpperCAmelCase__  :List[Any]            =			ids_tensor([self.batch_size, self.seq_length] ,					self.num_labels   )
       UpperCAmelCase__  :List[str]            =			ids_tensor([self.batch_size] ,					self.num_choices   )

    UpperCAmelCase__  :List[str]            =			self.get_config()

    return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Dict   ):
    return LayoutLMConfig(
        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 ,					)


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Optional[int] ,					__lowerCamelCase       :  str ,					__lowerCamelCase       :  Dict ,					__lowerCamelCase       :  int ,					__lowerCamelCase       :  List[Any] ,					__lowerCamelCase       :  Optional[int] ,					__lowerCamelCase       :  List[Any] ,					__lowerCamelCase       :  Optional[int] ,					__lowerCamelCase       :  Optional[int]   ):
    UpperCAmelCase__  :str            =			LayoutLMModel(config=lowerCamelCase__   )
    model.to(lowerCamelCase__   )
    model.eval()
    UpperCAmelCase__  :List[Any]            =			model(lowerCamelCase__ ,					lowerCamelCase__ ,					attention_mask=lowerCamelCase__ ,					token_type_ids=lowerCamelCase__   )
    UpperCAmelCase__  :Dict            =			model(lowerCamelCase__ ,					lowerCamelCase__ ,					token_type_ids=lowerCamelCase__   )
    UpperCAmelCase__  :List[str]            =			model(lowerCamelCase__ ,					lowerCamelCase__   )
    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 					__SCREAMING_SNAKE_CASE				(			self       :  List[str] ,					__lowerCamelCase       :  Dict ,					__lowerCamelCase       :  Union[str, Any] ,					__lowerCamelCase       :  Any ,					__lowerCamelCase       :  Union[str, Any] ,					__lowerCamelCase       :  Union[str, Any] ,					__lowerCamelCase       :  Union[str, Any] ,					__lowerCamelCase       :  List[Any] ,					__lowerCamelCase       :  str   ):
    UpperCAmelCase__  :Optional[Any]            =			LayoutLMForMaskedLM(config=lowerCamelCase__   )
    model.to(lowerCamelCase__   )
    model.eval()
    UpperCAmelCase__  :Tuple            =			model(lowerCamelCase__ ,					lowerCamelCase__ ,					attention_mask=lowerCamelCase__ ,					token_type_ids=lowerCamelCase__ ,					labels=lowerCamelCase__   )
    self.parent.assertEqual(result.logits.shape ,					(self.batch_size, self.seq_length, self.vocab_size)   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  List[str] ,					__lowerCamelCase       :  int ,					__lowerCamelCase       :  Dict ,					__lowerCamelCase       :  int ,					__lowerCamelCase       :  Optional[Any] ,					__lowerCamelCase       :  str ,					__lowerCamelCase       :  Tuple ,					__lowerCamelCase       :  List[str] ,					__lowerCamelCase       :  Tuple   ):
    UpperCAmelCase__  :str            =			self.num_labels
    UpperCAmelCase__  :Optional[int]            =			LayoutLMForSequenceClassification(lowerCamelCase__   )
    model.to(lowerCamelCase__   )
    model.eval()
    UpperCAmelCase__  :Optional[Any]            =			model(
        lowerCamelCase__ ,					lowerCamelCase__ ,					attention_mask=lowerCamelCase__ ,					token_type_ids=lowerCamelCase__ ,					labels=lowerCamelCase__   )
    self.parent.assertEqual(result.logits.shape ,					(self.batch_size, self.num_labels)   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  int ,					__lowerCamelCase       :  Union[str, Any] ,					__lowerCamelCase       :  int ,					__lowerCamelCase       :  int ,					__lowerCamelCase       :  Union[str, Any] ,					__lowerCamelCase       :  Union[str, Any] ,					__lowerCamelCase       :  Optional[Any] ,					__lowerCamelCase       :  Union[str, Any] ,					__lowerCamelCase       :  Tuple   ):
    UpperCAmelCase__  :List[str]            =			self.num_labels
    UpperCAmelCase__  :Dict            =			LayoutLMForTokenClassification(config=lowerCamelCase__   )
    model.to(lowerCamelCase__   )
    model.eval()
    UpperCAmelCase__  :int            =			model(lowerCamelCase__ ,					lowerCamelCase__ ,					attention_mask=lowerCamelCase__ ,					token_type_ids=lowerCamelCase__ ,					labels=lowerCamelCase__   )
    self.parent.assertEqual(result.logits.shape ,					(self.batch_size, self.seq_length, self.num_labels)   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  List[Any] ,					__lowerCamelCase       :  Optional[Any] ,					__lowerCamelCase       :  Optional[int] ,					__lowerCamelCase       :  List[str] ,					__lowerCamelCase       :  Any ,					__lowerCamelCase       :  Tuple ,					__lowerCamelCase       :  List[str] ,					__lowerCamelCase       :  int ,					__lowerCamelCase       :  List[Any]   ):
    UpperCAmelCase__  :str            =			LayoutLMForQuestionAnswering(config=lowerCamelCase__   )
    model.to(lowerCamelCase__   )
    model.eval()
    UpperCAmelCase__  :List[str]            =			model(
        lowerCamelCase__ ,					bbox=lowerCamelCase__ ,					attention_mask=lowerCamelCase__ ,					token_type_ids=lowerCamelCase__ ,					start_positions=lowerCamelCase__ ,					end_positions=lowerCamelCase__ ,					)
    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 					__SCREAMING_SNAKE_CASE				(			self       :  Optional[int]   ):
    UpperCAmelCase__  :Any            =			self.prepare_config_and_inputs()
    (
        (
        UpperCAmelCase__						
    )      ,	(
        UpperCAmelCase__						
    )      ,	(
        UpperCAmelCase__						
    )      ,	(
        UpperCAmelCase__						
    )      ,	(
        UpperCAmelCase__						
    )      ,	(
        UpperCAmelCase__						
    )      ,	(
        UpperCAmelCase__						
    )      ,	(
        UpperCAmelCase__						
    )      ,							
    )  :Any            =			config_and_inputs
    UpperCAmelCase__  :int            =			{
        '''input_ids''': input_ids,
        '''bbox''': bbox,
        '''token_type_ids''': token_type_ids,
        '''attention_mask''': input_mask,
    }
    return config, inputs_dict




@require_torch
class 							UpperCAmelCase ( __UpperCAmelCase	,   __UpperCAmelCase	,   unittest.TestCase	):
 UpperCAmelCase				=				(
     (
         LayoutLMModel,
         LayoutLMForMaskedLM,
         LayoutLMForSequenceClassification,
         LayoutLMForTokenClassification,
         LayoutLMForQuestionAnswering,
     )
     if is_torch_available()
     else None
 )
 UpperCAmelCase				=				(
     {
         """document-question-answering""": LayoutLMForQuestionAnswering,
         """feature-extraction""": LayoutLMModel,
         """fill-mask""": LayoutLMForMaskedLM,
         """text-classification""": LayoutLMForSequenceClassification,
         """token-classification""": LayoutLMForTokenClassification,
         """zero-shot""": LayoutLMForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 UpperCAmelCase				=				True


 def 					__SCREAMING_SNAKE_CASE				(			self       :  List[str]   ):
    UpperCAmelCase__  :Union[str, Any]            =			LayoutLMModelTester(self   )
    UpperCAmelCase__  :List[Any]            =			ConfigTester(self ,					config_class=lowerCamelCase__ ,					hidden_size=3_7   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Optional[int]   ):
    self.config_tester.run_common_tests()


 def 					__SCREAMING_SNAKE_CASE				(			self       :  int   ):
    UpperCAmelCase__  :int            =			self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*lowerCamelCase__   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  str   ):
    UpperCAmelCase__  :Optional[int]            =			self.model_tester.prepare_config_and_inputs()
    for type in ["absolute", "relative_key", "relative_key_query"]:
       UpperCAmelCase__  :Any            =			type
       self.model_tester.create_and_check_model(*lowerCamelCase__   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  List[Any]   ):
    UpperCAmelCase__  :Any            =			self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase__   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  int   ):
    UpperCAmelCase__  :List[Any]            =			self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase__   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Union[str, Any]   ):
    UpperCAmelCase__  :Any            =			self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_token_classification(*lowerCamelCase__   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Union[str, Any]   ):
    UpperCAmelCase__  :Any            =			self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_question_answering(*lowerCamelCase__   )





 @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''   )
 def 					__SCREAMING_SNAKE_CASE				(			self       :  List[str]   ):
    pass


def 					a__    (				):
   # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
   # fmt: off
   UpperCAmelCase__  :List[str]            =			torch.tensor([[101,1_019,1_014,1_016,1_037,12_849,4_747,1_004,14_246,2_278,5_439,4_524,5_002,2_930,2_193,2_930,4_341,3_208,1_005,1_055,2_171,2_848,11_300,3_531,102],[101,4_070,4_034,7_020,1_024,3_058,1_015,1_013,2_861,1_013,6_070,19_274,2_772,6_205,27_814,16_147,16_147,4_343,2_047,10_283,10_969,14_389,1_012,2_338,102]],      device=lowercase__	)  # noqa: E231
   UpperCAmelCase__  :str            =			torch.tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],],      device=lowercase__	)  # noqa: E231
   UpperCAmelCase__  :Optional[int]            =			torch.tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1_000,1_000,1_000,1_000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1_000,1_000,1_000,1_000]]],      device=lowercase__	)  # noqa: E231
   UpperCAmelCase__  :Dict            =			torch.tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]],      device=lowercase__	)  # noqa: E231
   # these are sequence labels (i.e. at the token level)
   UpperCAmelCase__  :int            =			torch.tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]],      device=lowercase__	)  # noqa: E231
   # fmt: on

   return input_ids, attention_mask, bbox, token_type_ids, labels




@require_torch
class 							UpperCAmelCase ( unittest.TestCase	):


 @slow
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Dict   ):
    UpperCAmelCase__  :Union[str, Any]            =			LayoutLMModel.from_pretrained('''microsoft/layoutlm-base-uncased'''   ).to(lowerCamelCase__   )

    UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__  :int            =			prepare_layoutlm_batch_inputs()

    # forward pass
    UpperCAmelCase__  :Dict            =			model(input_ids=lowerCamelCase__ ,					bbox=lowerCamelCase__ ,					attention_mask=lowerCamelCase__ ,					token_type_ids=lowerCamelCase__   )

    # test the sequence output on [0, :3, :3]
    UpperCAmelCase__  :Tuple            =			torch.tensor(
        [[0.17_85, -0.19_47, -0.04_25], [-0.32_54, -0.28_07, 0.25_53], [-0.53_91, -0.33_22, 0.33_64]] ,					device=lowerCamelCase__ ,					)

    self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3] ,					lowerCamelCase__ ,					atol=1e-3   )   )

    # test the pooled output on [1, :3]
    UpperCAmelCase__  :Any            =			torch.tensor([-0.65_80, -0.02_14, 0.85_52] ,					device=lowerCamelCase__   )

    self.assertTrue(torch.allclose(outputs.pooler_output[1, :3] ,					lowerCamelCase__ ,					atol=1e-3   )   )


 @slow
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Optional[int]   ):
    UpperCAmelCase__  :str            =			LayoutLMForSequenceClassification.from_pretrained('''microsoft/layoutlm-base-uncased''' ,					num_labels=2   ).to(
        lowerCamelCase__   )

    UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__  :Optional[Any]            =			prepare_layoutlm_batch_inputs()

    # forward pass
    UpperCAmelCase__  :Tuple            =			model(
        input_ids=lowerCamelCase__ ,					bbox=lowerCamelCase__ ,					attention_mask=lowerCamelCase__ ,					token_type_ids=lowerCamelCase__ ,					labels=torch.tensor([1, 1] ,					device=lowerCamelCase__   ) ,					)

    # test whether we get a loss as a scalar
    UpperCAmelCase__  :Dict            =			outputs.loss
    UpperCAmelCase__  :Any            =			torch.Size([]   )
    self.assertEqual(loss.shape ,					lowerCamelCase__   )

    # test the shape of the logits
    UpperCAmelCase__  :Any            =			outputs.logits
    UpperCAmelCase__  :Union[str, Any]            =			torch.Size((2, 2)   )
    self.assertEqual(logits.shape ,					lowerCamelCase__   )


 @slow
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Union[str, Any]   ):
    UpperCAmelCase__  :int            =			LayoutLMForTokenClassification.from_pretrained('''microsoft/layoutlm-base-uncased''' ,					num_labels=1_3   ).to(
        lowerCamelCase__   )

    UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__  :Union[str, Any]            =			prepare_layoutlm_batch_inputs()

    # forward pass
    UpperCAmelCase__  :List[str]            =			model(
        input_ids=lowerCamelCase__ ,					bbox=lowerCamelCase__ ,					attention_mask=lowerCamelCase__ ,					token_type_ids=lowerCamelCase__ ,					labels=lowerCamelCase__   )

    # test the loss calculation to be around 2.65
    # expected_loss = torch.tensor(2.65, device=torch_device)

    # The loss is currently somewhat random and can vary between 0.1-0.3 atol.
    # self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

    # test the shape of the logits
    UpperCAmelCase__  :Optional[int]            =			outputs.logits
    UpperCAmelCase__  :Dict            =			torch.Size((2, 2_5, 1_3)   )
    self.assertEqual(logits.shape ,					lowerCamelCase__   )





 @slow
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Optional[Any]   ):
    UpperCAmelCase__  :List[str]            =			LayoutLMForQuestionAnswering.from_pretrained('''microsoft/layoutlm-base-uncased'''   ).to(lowerCamelCase__   )

    UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__      ,	UpperCAmelCase__  :Optional[Any]            =			prepare_layoutlm_batch_inputs()

    # forward pass
    UpperCAmelCase__  :Any            =			model(input_ids=lowerCamelCase__ ,					bbox=lowerCamelCase__ ,					attention_mask=lowerCamelCase__ ,					token_type_ids=lowerCamelCase__   )

    # test the shape of the logits
    UpperCAmelCase__  :List[Any]            =			torch.Size((2, 2_5)   )
    self.assertEqual(outputs.start_logits.shape ,					lowerCamelCase__   )
    self.assertEqual(outputs.end_logits.shape ,					lowerCamelCase__   )





'''simple docstring'''





from scipy.constants import g


def 					a__    (				UpperCamelCase_	:			float,      UpperCamelCase_	:			float	):
   if mass < 0:
      # handling of negative values of mass
      raise ValueError('''The mass of a body cannot be negative'''	)
   if height < 0:
      # handling of negative values of height
      raise ValueError('''The height above the ground cannot be negative'''	)
   return mass * g * height


if __name__ == "__main__":
    from doctest import testmod

    testmod(name='''potential_energy''')



