


from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers.models.layoutlm.modeling_tf_layoutlm import (
       TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFLayoutLMForMaskedLM,
       TFLayoutLMForQuestionAnswering,
       TFLayoutLMForSequenceClassification,
       TFLayoutLMForTokenClassification,
       TFLayoutLMModel,
   )


class      __lowerCAmelCase  :






  """simple docstring"""





  def __init__(  self							:							Optional[Any]     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							int=1_3     ,					_lowerCAmelCase							:							List[Any]=7     ,					_lowerCAmelCase							:							Optional[Any]=True     ,					_lowerCAmelCase							:							Tuple=True     ,					_lowerCAmelCase							:							str=True     ,					_lowerCAmelCase							:							Dict=True     ,					_lowerCAmelCase							:							Tuple=9_9     ,					_lowerCAmelCase							:							List[str]=3_2     ,					_lowerCAmelCase							:							Dict=2     ,					_lowerCAmelCase							:							Optional[Any]=4     ,					_lowerCAmelCase							:							List[Any]=3_7     ,					_lowerCAmelCase							:							List[Any]="gelu"     ,					_lowerCAmelCase							:							Optional[Any]=0.1     ,					_lowerCAmelCase							:							Union[str, Any]=0.1     ,					_lowerCAmelCase							:							Dict=5_1_2     ,					_lowerCAmelCase							:							Any=1_6     ,					_lowerCAmelCase							:							Optional[Any]=2     ,					_lowerCAmelCase							:							Dict=0.02     ,					_lowerCAmelCase							:							Optional[Any]=3     ,					_lowerCAmelCase							:							Union[str, Any]=4     ,					_lowerCAmelCase							:							Dict=None     ,					_lowerCAmelCase							:							List[Any]=1_0_0_0     ,					) ->			Tuple:




     """simple docstring"""
     snake_case_            =       parent
     snake_case_            =       batch_size
     snake_case_            =       seq_length
     snake_case_            =       is_training
     snake_case_            =       use_input_mask
     snake_case_            =       use_token_type_ids
     snake_case_            =       use_labels
     snake_case_            =       vocab_size
     snake_case_            =       hidden_size
     snake_case_            =       num_hidden_layers
     snake_case_            =       num_attention_heads
     snake_case_            =       intermediate_size
     snake_case_            =       hidden_act
     snake_case_            =       hidden_dropout_prob
     snake_case_            =       attention_probs_dropout_prob
     snake_case_            =       max_position_embeddings
     snake_case_            =       type_vocab_size
     snake_case_            =       type_sequence_label_size
     snake_case_            =       initializer_range
     snake_case_            =       num_labels
     snake_case_            =       num_choices
     snake_case_            =       scope
     snake_case_            =       range_bbox



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




     """simple docstring"""
     snake_case_            =       ids_tensor([self.batch_size, self.seq_length]     ,					self.vocab_size	)

     # convert bbox to numpy since TF does not support item assignment
     snake_case_            =       ids_tensor([self.batch_size, self.seq_length, 4]     ,					self.range_bbox	).numpy()
     # 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]:
              snake_case_            =       bbox[i, j, 3]
              snake_case_            =       bbox[i, j, 1]
              snake_case_            =       t
           if bbox[i, j, 2] < bbox[i, j, 0]:
              snake_case_            =       bbox[i, j, 2]
              snake_case_            =       bbox[i, j, 0]
              snake_case_            =       t
     snake_case_            =       tf.convert_to_tensor(_lowerCAmelCase	)

     snake_case_            =       None
     if self.use_input_mask:
        snake_case_            =       random_attention_mask([self.batch_size, self.seq_length]	)

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

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

     snake_case_            =       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     ,					)

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



  def        lowerCAmelCase__	(  self							:							Optional[Any]     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							Union[str, Any]     ,					_lowerCAmelCase							:							List[Any]     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							int     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							int	) ->			Union[str, Any]:




     """simple docstring"""
     snake_case_            =       TFLayoutLMModel(config=_lowerCAmelCase	)

     snake_case_            =       model(_lowerCAmelCase     ,					_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					token_type_ids=_lowerCAmelCase	)
     snake_case_            =       model(_lowerCAmelCase     ,					_lowerCAmelCase     ,					token_type_ids=_lowerCAmelCase	)
     snake_case_            =       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        lowerCAmelCase__	(  self							:							Optional[Any]     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							Dict     ,					_lowerCAmelCase							:							Tuple     ,					_lowerCAmelCase							:							Dict     ,					_lowerCAmelCase							:							Union[str, Any]     ,					_lowerCAmelCase							:							List[str]     ,					_lowerCAmelCase							:							Tuple     ,					_lowerCAmelCase							:							Any	) ->			str:




     """simple docstring"""
     snake_case_            =       TFLayoutLMForMaskedLM(config=_lowerCAmelCase	)

     snake_case_            =       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        lowerCAmelCase__	(  self							:							Dict     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							Dict     ,					_lowerCAmelCase							:							int     ,					_lowerCAmelCase							:							Union[str, Any]     ,					_lowerCAmelCase							:							int     ,					_lowerCAmelCase							:							List[Any]     ,					_lowerCAmelCase							:							Optional[Any]     ,					_lowerCAmelCase							:							List[str]	) ->			Optional[Any]:




     """simple docstring"""
     snake_case_            =       self.num_labels
     snake_case_            =       TFLayoutLMForSequenceClassification(config=_lowerCAmelCase	)

     snake_case_            =       model(_lowerCAmelCase     ,					_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					token_type_ids=_lowerCAmelCase	)
     self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.num_labels)	)



  def        lowerCAmelCase__	(  self							:							str     ,					_lowerCAmelCase							:							Dict     ,					_lowerCAmelCase							:							Dict     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							str     ,					_lowerCAmelCase							:							str     ,					_lowerCAmelCase							:							str     ,					_lowerCAmelCase							:							List[Any]     ,					_lowerCAmelCase							:							List[str]	) ->			Optional[int]:




     """simple docstring"""
     snake_case_            =       self.num_labels
     snake_case_            =       TFLayoutLMForTokenClassification(config=_lowerCAmelCase	)

     snake_case_            =       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        lowerCAmelCase__	(  self							:							List[Any]     ,					_lowerCAmelCase							:							List[str]     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							Tuple     ,					_lowerCAmelCase							:							int     ,					_lowerCAmelCase							:							Union[str, Any]     ,					_lowerCAmelCase							:							Union[str, Any]     ,					_lowerCAmelCase							:							List[Any]	) ->			List[Any]:




     """simple docstring"""
     snake_case_            =       TFLayoutLMForQuestionAnswering(config=_lowerCAmelCase	)

     snake_case_            =       model(_lowerCAmelCase     ,					_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					token_type_ids=_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        lowerCAmelCase__	(  self							:							Union[str, Any]	) ->			Tuple:




     """simple docstring"""
     snake_case_            =       self.prepare_config_and_inputs()
     (
         (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     
     )            =       config_and_inputs
     snake_case_            =       {
         "input_ids": input_ids,
         "bbox": bbox,
         "token_type_ids": token_type_ids,
         "attention_mask": input_mask,
     }
     return config, inputs_dict






@require_tf
class      __lowerCAmelCase  (			a			,	a			,	unittest.TestCase       ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		     =							(
      (
          TFLayoutLMModel,
          TFLayoutLMForMaskedLM,
          TFLayoutLMForTokenClassification,
          TFLayoutLMForSequenceClassification,
          TFLayoutLMForQuestionAnswering,
      )
      if is_tf_available()
      else ()
  )
  _SCREAMING_SNAKE_CASE		     =							(
      {
          'feature-extraction': TFLayoutLMModel,
          'fill-mask': TFLayoutLMForMaskedLM,
          'text-classification': TFLayoutLMForSequenceClassification,
          'token-classification': TFLayoutLMForTokenClassification,
          'zero-shot': TFLayoutLMForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  _SCREAMING_SNAKE_CASE		     =							False
  _SCREAMING_SNAKE_CASE		     =							True
  _SCREAMING_SNAKE_CASE		     =							10



  def        lowerCAmelCase__	(  self							:							List[str]	) ->			Optional[Any]:




     """simple docstring"""
     snake_case_            =       TFLayoutLMModelTester(self	)
     snake_case_            =       ConfigTester(self     ,					config_class=_lowerCAmelCase     ,					hidden_size=3_7	)



  def        lowerCAmelCase__	(  self							:							List[Any]	) ->			Any:




     """simple docstring"""
     self.config_tester.run_common_tests()



  def        lowerCAmelCase__	(  self							:							Dict	) ->			Optional[int]:




     """simple docstring"""
     snake_case_            =       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowerCAmelCase	)



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




     """simple docstring"""
     snake_case_            =       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_lm(*_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							Optional[int]	) ->			List[Any]:




     """simple docstring"""
     snake_case_            =       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_sequence_classification(*_lowerCAmelCase	)



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




     """simple docstring"""
     snake_case_            =       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							str	) ->			str:




     """simple docstring"""
     snake_case_            =       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*_lowerCAmelCase	)



  @slow
  def        lowerCAmelCase__	(  self							:							str	) ->			List[Any]:




     """simple docstring"""
     for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        snake_case_            =       TFLayoutLMModel.from_pretrained(_lowerCAmelCase	)
        self.assertIsNotNone(_lowerCAmelCase	)



  @unittest.skip("Onnx compliancy broke with TF 2.10"	)
  def        lowerCAmelCase__	(  self							:							Dict	) ->			str:




     """simple docstring"""
     pass






def       _lowerCAmelCase    (				)->Any:
   '''simple docstring'''






   snake_case_            =       tf.convert_to_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]]				)  # noqa: E231
   snake_case_            =       tf.convert_to_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],]				)  # noqa: E231
   snake_case_            =       tf.convert_to_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]]]				)  # noqa: E231
   snake_case_            =       tf.convert_to_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]]				)  # noqa: E231
   # these are sequence labels (i.e. at the token level)
   snake_case_            =       tf.convert_to_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]]				)  # noqa: E231
   # fmt: on

   return input_ids, attention_mask, bbox, token_type_ids, labels



@require_tf
class      __lowerCAmelCase  (			unittest.TestCase       ):






  """simple docstring"""





  @slow
  def        lowerCAmelCase__	(  self							:							List[str]	) ->			List[Any]:




     """simple docstring"""
     snake_case_            =       TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"	)

     snake_case_     ,     snake_case_     ,     snake_case_     ,     snake_case_     ,     snake_case_            =       prepare_layoutlm_batch_inputs()

     # forward pass
     snake_case_            =       model(input_ids=_lowerCAmelCase     ,					bbox=_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					token_type_ids=_lowerCAmelCase	)

     # test the sequence output on [0, :3, :3]
     snake_case_            =       tf.convert_to_tensor(
         [[0.1_785, -0.1_947, -0.0_425], [-0.3_254, -0.2_807, 0.2_553], [-0.5_391, -0.3_322, 0.3_364]]     ,					)

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

     # test the pooled output on [1, :3]
     snake_case_            =       tf.convert_to_tensor([-0.6_580, -0.0_214, 0.8_552]	)

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



  @slow
  def        lowerCAmelCase__	(  self							:							Tuple	) ->			Union[str, Any]:




     """simple docstring"""
     # initialize model with randomly initialized sequence classification head
     snake_case_            =       TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"     ,					num_labels=2	)

     snake_case_     ,     snake_case_     ,     snake_case_     ,     snake_case_     ,     snake_case_            =       prepare_layoutlm_batch_inputs()

     # forward pass
     snake_case_            =       model(
         input_ids=_lowerCAmelCase     ,					bbox=_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					token_type_ids=_lowerCAmelCase     ,					labels=tf.convert_to_tensor([1, 1]	)     ,					)

     # test whether we get a loss as a scalar
     snake_case_            =       outputs.loss
     snake_case_            =       (2,)
     self.assertEqual(loss.shape     ,					_lowerCAmelCase	)

     # test the shape of the logits
     snake_case_            =       outputs.logits
     snake_case_            =       (2, 2)
     self.assertEqual(logits.shape     ,					_lowerCAmelCase	)



  @slow
  def        lowerCAmelCase__	(  self							:							List[Any]	) ->			List[Any]:




     """simple docstring"""
     # initialize model with randomly initialized token classification head
     snake_case_            =       TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"     ,					num_labels=1_3	)

     snake_case_     ,     snake_case_     ,     snake_case_     ,     snake_case_     ,     snake_case_            =       prepare_layoutlm_batch_inputs()

     # forward pass
     snake_case_            =       model(
         input_ids=_lowerCAmelCase     ,					bbox=_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					token_type_ids=_lowerCAmelCase     ,					labels=_lowerCAmelCase	)

     # test the shape of the logits
     snake_case_            =       outputs.logits
     snake_case_            =       tf.convert_to_tensor((2, 2_5, 1_3)	)
     self.assertEqual(logits.shape     ,					_lowerCAmelCase	)



  @slow
  def        lowerCAmelCase__	(  self							:							str	) ->			List[Any]:




     """simple docstring"""
     # initialize model with randomly initialized token classification head
     snake_case_            =       TFLayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"	)

     snake_case_     ,     snake_case_     ,     snake_case_     ,     snake_case_     ,     snake_case_            =       prepare_layoutlm_batch_inputs()

     # forward pass
     snake_case_            =       model(input_ids=_lowerCAmelCase     ,					bbox=_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					token_type_ids=_lowerCAmelCase	)

     # test the shape of the logits
     snake_case_            =       tf.convert_to_tensor((2, 2_5)	)
     self.assertEqual(outputs.start_logits.shape     ,					_lowerCAmelCase	)
     self.assertEqual(outputs.end_logits.shape     ,					_lowerCAmelCase	)








def       _lowerCAmelCase    (				lowerCAmelCase_				:int		,    lowerCAmelCase_				:int				)->str:
   '''simple docstring'''






   if not isinstance(lowerCAmelCase_		,    lowerCAmelCase_				):
      raise ValueError("iterations must be defined as integers"				)
   if not isinstance(lowerCAmelCase_		,    lowerCAmelCase_				) or not number >= 1:
      raise ValueError(
          "starting number must be\n                         and integer and be more than 0"				)
   if not iterations >= 1:
      raise ValueError("Iterations must be done more than 0 times to play FizzBuzz"				)

   snake_case_            =       ""
   while number <= iterations:
      if number % 3 == 0:
         out += "Fizz"
      if number % 5 == 0:
         out += "Buzz"
      if 0 not in (number % 3, number % 5):
         out += str(lowerCAmelCase_				)

      # print(out)
      number += 1
      out += " "
   return out


if __name__ == "__main__":
   import doctest

   doctest.testmod()




