

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





    def __init__(				self						,       a						,       a=13						,       a=7						,       a=True						,       a=True						,       a=True						,       a=True						,       a=99						,       a=32						,       a=2						,       a=4						,       a=37						,       a="gelu"						,       a=0.1						,       a=0.1						,       a=512						,       a=16						,       a=2						,       a=0.02						,       a=3						,       a=4						,       a=None						,       a=1000						,       ):
         lowercase__   :       int				=	parent
         lowercase__   :       Optional[int]				=	batch_size
         lowercase__   :       Union[str, Any]				=	seq_length
         lowercase__   :       List[Any]				=	is_training
         lowercase__   :       Any				=	use_input_mask
         lowercase__   :       List[str]				=	use_token_type_ids
         lowercase__   :       Tuple				=	use_labels
         lowercase__   :       Dict				=	vocab_size
         lowercase__   :       Optional[int]				=	hidden_size
         lowercase__   :       Any				=	num_hidden_layers
         lowercase__   :       List[Any]				=	num_attention_heads
         lowercase__   :       Dict				=	intermediate_size
         lowercase__   :       int				=	hidden_act
         lowercase__   :       str				=	hidden_dropout_prob
         lowercase__   :       List[Any]				=	attention_probs_dropout_prob
         lowercase__   :       Optional[int]				=	max_position_embeddings
         lowercase__   :       Optional[int]				=	type_vocab_size
         lowercase__   :       Union[str, Any]				=	type_sequence_label_size
         lowercase__   :       Dict				=	initializer_range
         lowercase__   :       Any				=	num_labels
         lowercase__   :       List[Any]				=	num_choices
         lowercase__   :       Any				=	scope
         lowercase__   :       List[Any]				=	range_bbox





    def 				snake_case_    (				self):
         lowercase__   :       List[Any]				=	ids_tensor([self.batch_size, self.seq_length]						,       self.vocab_size)

         # convert bbox to numpy since TF does not support item assignment
         lowercase__   :       Optional[Any]				=	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]:
                        lowercase__   :       Union[str, Any]				=	bbox[i, j, 3]
                        lowercase__   :       Dict				=	bbox[i, j, 1]
                        lowercase__   :       Tuple				=	t
                   if bbox[i, j, 2] < bbox[i, j, 0]:
                        lowercase__   :       str				=	bbox[i, j, 2]
                        lowercase__   :       Dict				=	bbox[i, j, 0]
                        lowercase__   :       str				=	t
         lowercase__   :       Optional[Any]				=	tf.convert_to_tensor(a)

         lowercase__   :       str				=	None
         if self.use_input_mask:
              lowercase__   :       List[Any]				=	random_attention_mask([self.batch_size, self.seq_length])

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

         lowercase__   :       Tuple				=	None
         lowercase__   :       Tuple				=	None
         lowercase__   :       str				=	None
         if self.use_labels:
              lowercase__   :       Tuple				=	ids_tensor([self.batch_size]						,       self.type_sequence_label_size)
              lowercase__   :       int				=	ids_tensor([self.batch_size, self.seq_length]						,       self.num_labels)
              lowercase__   :       int				=	ids_tensor([self.batch_size]						,       self.num_choices)

         lowercase__   :       Dict				=	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 				snake_case_    (				self						,       a						,       a						,       a						,       a						,       a						,       a						,       a						,       a):
         lowercase__   :       int				=	TFLayoutLMModel(config=a)

         lowercase__   :       int				=	model(a						,       a						,       attention_mask=a						,       token_type_ids=a)
         lowercase__   :       Any				=	model(a						,       a						,       token_type_ids=a)
         lowercase__   :       List[Any]				=	model(a						,       a)
         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 				snake_case_    (				self						,       a						,       a						,       a						,       a						,       a						,       a						,       a						,       a):
         lowercase__   :       Union[str, Any]				=	TFLayoutLMForMaskedLM(config=a)

         lowercase__   :       Tuple				=	model(a						,       a						,       attention_mask=a						,       token_type_ids=a						,       labels=a)
         self.parent.assertEqual(result.logits.shape						,       (self.batch_size, self.seq_length, self.vocab_size))





    def 				snake_case_    (				self						,       a						,       a						,       a						,       a						,       a						,       a						,       a						,       a):
         lowercase__   :       List[str]				=	self.num_labels
         lowercase__   :       Optional[Any]				=	TFLayoutLMForSequenceClassification(config=a)

         lowercase__   :       int				=	model(a						,       a						,       attention_mask=a						,       token_type_ids=a)
         self.parent.assertEqual(result.logits.shape						,       (self.batch_size, self.num_labels))





    def 				snake_case_    (				self						,       a						,       a						,       a						,       a						,       a						,       a						,       a						,       a):
         lowercase__   :       Any				=	self.num_labels
         lowercase__   :       Dict				=	TFLayoutLMForTokenClassification(config=a)

         lowercase__   :       Dict				=	model(a						,       a						,       attention_mask=a						,       token_type_ids=a						,       labels=a)
         self.parent.assertEqual(result.logits.shape						,       (self.batch_size, self.seq_length, self.num_labels))





    def 				snake_case_    (				self						,       a						,       a						,       a						,       a						,       a						,       a						,       a						,       a):
         lowercase__   :       int				=	TFLayoutLMForQuestionAnswering(config=a)

         lowercase__   :       Union[str, Any]				=	model(a						,       a						,       attention_mask=a						,       token_type_ids=a)
         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 				snake_case_    (				self):
         lowercase__   :       int				=	self.prepare_config_and_inputs()
         (
             lowercase__			
         )   :       Any				=	config_and_inputs
         lowercase__   :       int				=	{
             'input_ids': input_ids,
             'bbox': bbox,
             'token_type_ids': token_type_ids,
             'attention_mask': input_mask,
         }
         return config, inputs_dict



@require_tf
class 				SCREAMING_SNAKE_CASE__ (__snake_case		,	__snake_case		,	unittest.TestCase					):
    __lowerCamelCase						:	Optional[int]														=					(
        (
            TFLayoutLMModel,
            TFLayoutLMForMaskedLM,
            TFLayoutLMForTokenClassification,
            TFLayoutLMForSequenceClassification,
            TFLayoutLMForQuestionAnswering,
        )
        if is_tf_available()
        else ()
    )
    __lowerCamelCase						:	List[Any]														=					(
        {
            """feature-extraction""": TFLayoutLMModel,
            """fill-mask""": TFLayoutLMForMaskedLM,
            """text-classification""": TFLayoutLMForSequenceClassification,
            """token-classification""": TFLayoutLMForTokenClassification,
            """zero-shot""": TFLayoutLMForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    __lowerCamelCase						:	int														=					False
    __lowerCamelCase						:	Tuple														=					True
    __lowerCamelCase						:	List[str]														=					10





    def 				snake_case_    (				self):
         lowercase__   :       Union[str, Any]				=	TFLayoutLMModelTester(self)
         lowercase__   :       List[Any]				=	ConfigTester(self						,       config_class=a						,       hidden_size=37)





    def 				snake_case_    (				self):
         self.config_tester.run_common_tests()





    def 				snake_case_    (				self):
         lowercase__   :       Any				=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*a)





    def 				snake_case_    (				self):
         lowercase__   :       Optional[Any]				=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*a)





    def 				snake_case_    (				self):
         lowercase__   :       List[Any]				=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*a)





    def 				snake_case_    (				self):
         lowercase__   :       int				=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*a)





    def 				snake_case_    (				self):
         lowercase__   :       str				=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*a)





    @slow
    def 				snake_case_    (				self):
         for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowercase__   :       Optional[Any]				=	TFLayoutLMModel.from_pretrained(a)
              self.assertIsNotNone(a)





    @unittest.skip('Onnx compliancy broke with TF 2.10')
    def 				snake_case_    (				self):
         pass



def      snake_case__      (   ):



     '''simple docstring'''





     lowercase__   :       Any				=	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
     lowercase__   :       Dict				=	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
     lowercase__   :       Dict				=	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
     lowercase__   :       Any				=	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)
     lowercase__   :       Union[str, Any]				=	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 				SCREAMING_SNAKE_CASE__ (unittest.TestCase					):





    @slow
    def 				snake_case_    (				self):
         lowercase__   :       List[str]				=	TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased')

         lowercase__   :       List[str]				=	prepare_layoutlm_batch_inputs()

         # forward pass
         lowercase__   :       Dict				=	model(input_ids=a						,       bbox=a						,       attention_mask=a						,       token_type_ids=a)

         # test the sequence output on [0, :3, :3]
         lowercase__   :       Union[str, Any]				=	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]						,       a						,       atol=1e-3))

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

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





    @slow
    def 				snake_case_    (				self):
         # initialize model with randomly initialized sequence classification head
         lowercase__   :       List[Any]				=	TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'						,       num_labels=2)

         lowercase__   :       Any				=	prepare_layoutlm_batch_inputs()

         # forward pass
         lowercase__   :       int				=	model(
             input_ids=a						,       bbox=a						,       attention_mask=a						,       token_type_ids=a						,       labels=tf.convert_to_tensor([1, 1])						,       )

         # test whether we get a loss as a scalar
         lowercase__   :       Tuple				=	outputs.loss
         lowercase__   :       Any				=	(2,)
         self.assertEqual(loss.shape						,       a)

         # test the shape of the logits
         lowercase__   :       Union[str, Any]				=	outputs.logits
         lowercase__   :       Optional[Any]				=	(2, 2)
         self.assertEqual(logits.shape						,       a)





    @slow
    def 				snake_case_    (				self):
         # initialize model with randomly initialized token classification head
         lowercase__   :       Optional[Any]				=	TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'						,       num_labels=13)

         lowercase__   :       Optional[Any]				=	prepare_layoutlm_batch_inputs()

         # forward pass
         lowercase__   :       Dict				=	model(
             input_ids=a						,       bbox=a						,       attention_mask=a						,       token_type_ids=a						,       labels=a)

         # test the shape of the logits
         lowercase__   :       Optional[int]				=	outputs.logits
         lowercase__   :       Optional[Any]				=	tf.convert_to_tensor((2, 25, 13))
         self.assertEqual(logits.shape						,       a)





    @slow
    def 				snake_case_    (				self):
         # initialize model with randomly initialized token classification head
         lowercase__   :       Union[str, Any]				=	TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased')

         lowercase__   :       List[Any]				=	prepare_layoutlm_batch_inputs()

         # forward pass
         lowercase__   :       List[str]				=	model(input_ids=a						,       bbox=a						,       attention_mask=a						,       token_type_ids=a)

         # test the shape of the logits
         lowercase__   :       Optional[int]				=	tf.convert_to_tensor((2, 25))
         self.assertEqual(outputs.start_logits.shape						,       a)
         self.assertEqual(outputs.end_logits.shape						,       a)




def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     return 1 if digit in (0, 1) else (digit * factorial(digit - 1      ))

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     lowercase__   :       List[str]				=	0
     lowercase__   :       Optional[int]				=	number
     while duplicate > 0:
          lowercase__				,			lowercase__   :       Tuple				=	divmod(SCREAMING_SNAKE_CASE_     ,					10      )
          fact_sum += factorial(SCREAMING_SNAKE_CASE_      )
     return fact_sum == number


if __name__ == "__main__":
       print('''Program to check whether a number is a Krisnamurthy Number or not.''')
       snake_case_        =			int(input('''Enter number: ''').strip())
       print(
           F'''{number} is {'' if krishnamurthy(number) else 'not '}a Krishnamurthy Number.'''
       )

