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

						def __init__(	self				:      Any							,							__lowerCamelCase				:      int							,							__lowerCamelCase				:      Any=13							,							__lowerCamelCase				:      Union[str, Any]=7							,							__lowerCamelCase				:      Union[str, Any]=True							,							__lowerCamelCase				:      str=True							,							__lowerCamelCase				:      List[str]=True							,							__lowerCamelCase				:      Dict=True							,							__lowerCamelCase				:      int=99							,							__lowerCamelCase				:      Tuple=32							,							__lowerCamelCase				:      str=2							,							__lowerCamelCase				:      Dict=4							,							__lowerCamelCase				:      Dict=37							,							__lowerCamelCase				:      Tuple="gelu"							,							__lowerCamelCase				:      Union[str, Any]=0.1							,							__lowerCamelCase				:      List[str]=0.1							,							__lowerCamelCase				:      Dict=5_12							,							__lowerCamelCase				:      str=16							,							__lowerCamelCase				:      str=2							,							__lowerCamelCase				:      Optional[Any]=0.02							,							__lowerCamelCase				:      Any=3							,							__lowerCamelCase				:      int=4							,							__lowerCamelCase				:      int=None							,							__lowerCamelCase				:      Dict=10_00							,							)							->		Optional[int]:


									'''simple docstring'''

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

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


									'''simple docstring'''

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

									# convert bbox to numpy since TF does not support item assignment
									lowercase							=		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							=		bbox[i, j, 3]
																		lowercase							=		bbox[i, j, 1]
																		lowercase							=		t
															if bbox[i, j, 2] < bbox[i, j, 0]:
																		lowercase							=		bbox[i, j, 2]
																		lowercase							=		bbox[i, j, 0]
																		lowercase							=		t
									lowercase							=		tf.convert_to_tensor(__lowerCamelCase   )

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

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

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

									lowercase							=		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        __a		(	self				:      int							,							__lowerCamelCase				:      str							,							__lowerCamelCase				:      Optional[Any]							,							__lowerCamelCase				:      List[Any]							,							__lowerCamelCase				:      int							,							__lowerCamelCase				:      List[Any]							,							__lowerCamelCase				:      List[Any]							,							__lowerCamelCase				:      List[Any]							,							__lowerCamelCase				:      Union[str, Any]   )							->		Optional[int]:


									'''simple docstring'''

									lowercase							=		TFLayoutLMModel(config=__lowerCamelCase   )

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


									'''simple docstring'''

									lowercase							=		TFLayoutLMForMaskedLM(config=__lowerCamelCase   )

									lowercase							=		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        __a		(	self				:      Any							,							__lowerCamelCase				:      Optional[Any]							,							__lowerCamelCase				:      List[str]							,							__lowerCamelCase				:      int							,							__lowerCamelCase				:      Optional[int]							,							__lowerCamelCase				:      List[Any]							,							__lowerCamelCase				:      Union[str, Any]							,							__lowerCamelCase				:      Any							,							__lowerCamelCase				:      Any   )							->		int:


									'''simple docstring'''

									lowercase							=		self.num_labels
									lowercase							=		TFLayoutLMForSequenceClassification(config=__lowerCamelCase   )

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

						def        __a		(	self				:      Optional[Any]							,							__lowerCamelCase				:      Optional[Any]							,							__lowerCamelCase				:      List[Any]							,							__lowerCamelCase				:      Optional[int]							,							__lowerCamelCase				:      Tuple							,							__lowerCamelCase				:      Tuple							,							__lowerCamelCase				:      List[Any]							,							__lowerCamelCase				:      Optional[int]							,							__lowerCamelCase				:      Any   )							->		List[str]:


									'''simple docstring'''

									lowercase							=		self.num_labels
									lowercase							=		TFLayoutLMForTokenClassification(config=__lowerCamelCase   )

									lowercase							=		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        __a		(	self				:      Optional[Any]							,							__lowerCamelCase				:      List[Any]							,							__lowerCamelCase				:      Optional[int]							,							__lowerCamelCase				:      List[Any]							,							__lowerCamelCase				:      Optional[int]							,							__lowerCamelCase				:      List[Any]							,							__lowerCamelCase				:      Tuple							,							__lowerCamelCase				:      str							,							__lowerCamelCase				:      List[Any]   )							->		str:


									'''simple docstring'''

									lowercase							=		TFLayoutLMForQuestionAnswering(config=__lowerCamelCase   )

									lowercase							=		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        __a		(	self				:      str   )							->		int:


									'''simple docstring'''

									lowercase							=		self.prepare_config_and_inputs()
									(
									    (
									    lowercase
									)		,(
									    lowercase
									)		,(
									    lowercase
									)		,(
									    lowercase
									)		,(
									    lowercase
									)		,(
									    lowercase
									)		,(
									    lowercase
									)		,(
									    lowercase
									)		,
									)							=		config_and_inputs
									lowercase							=		{
									    '''input_ids''': input_ids,
									    '''bbox''': bbox,
									    '''token_type_ids''': token_type_ids,
									    '''attention_mask''': input_mask,
									}
									return config, inputs_dict






@require_tf
class      __lowercase					(    _A       ,     _A       ,     unittest.TestCase    ):
						lowercase					 =     (
						    (
						        TFLayoutLMModel,
						        TFLayoutLMForMaskedLM,
						        TFLayoutLMForTokenClassification,
						        TFLayoutLMForSequenceClassification,
						        TFLayoutLMForQuestionAnswering,
						    )
						    if is_tf_available()
						    else ()
						)
						lowercase					 =     (
						    {
						        'feature-extraction': TFLayoutLMModel,
						        'fill-mask': TFLayoutLMForMaskedLM,
						        'text-classification': TFLayoutLMForSequenceClassification,
						        'token-classification': TFLayoutLMForTokenClassification,
						        'zero-shot': TFLayoutLMForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						lowercase					 =     False
						lowercase					 =     True
						lowercase					 =     10

						def        __a		(	self				:      str   )							->		Dict:


									'''simple docstring'''

									lowercase							=		TFLayoutLMModelTester(self   )
									lowercase							=		ConfigTester(self							,							config_class=__lowerCamelCase							,							hidden_size=37   )

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


									'''simple docstring'''

									self.config_tester.run_common_tests()

						def        __a		(	self				:      List[Any]   )							->		Dict:


									'''simple docstring'''

									lowercase							=		self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__lowerCamelCase   )

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


									'''simple docstring'''

									lowercase							=		self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*__lowerCamelCase   )

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


									'''simple docstring'''

									lowercase							=		self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*__lowerCamelCase   )

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


									'''simple docstring'''

									lowercase							=		self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase   )

						def        __a		(	self				:      List[Any]   )							->		Dict:


									'''simple docstring'''

									lowercase							=		self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*__lowerCamelCase   )

						@slow
						def        __a		(	self				:      Dict   )							->		Any:


									'''simple docstring'''

									for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowercase							=		TFLayoutLMModel.from_pretrained(__lowerCamelCase   )
												self.assertIsNotNone(__lowerCamelCase   )



						@unittest.skip('''Onnx compliancy broke with TF 2.10'''   )
						def        __a		(	self				:      Union[str, Any]   )							->		List[str]:


									'''simple docstring'''

									pass






def        __UpperCAmelCase    (       )->       Optional[Any]:



			"""simple docstring"""







			lowercase							=		tf.convert_to_tensor([[101,1019,1014,1016,1037,12849,4747,1004,14246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,11300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,19274,2772,6205,27814,16147,16147,4343,2047,10283,10969,14389,1012,2338,102]]       )  # noqa: E231
			lowercase							=		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							=		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],[1000,1000,1000,1000]],[[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],[1000,1000,1000,1000]]]       )  # noqa: E231
			lowercase							=		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							=		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      __lowercase					(    unittest.TestCase    ):

						@slow
						def        __a		(	self				:      Union[str, Any]   )							->		Dict:


									'''simple docstring'''

									lowercase							=		TFLayoutLMModel.from_pretrained('''microsoft/layoutlm-base-uncased'''   )

									lowercase		,lowercase		,lowercase		,lowercase		,lowercase							=		prepare_layoutlm_batch_inputs()

									# forward pass
									lowercase							=		model(input_ids=__lowerCamelCase							,							bbox=__lowerCamelCase							,							attention_mask=__lowerCamelCase							,							token_type_ids=__lowerCamelCase   )

									# test the sequence output on [0, :3, :3]
									lowercase							=		tf.convert_to_tensor(
									    [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]							,							)

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

									# test the pooled output on [1, :3]
									lowercase							=		tf.convert_to_tensor([-0.6580, -0.0214, 0.8552]   )

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

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


									'''simple docstring'''

									lowercase							=		TFLayoutLMForSequenceClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''							,							num_labels=2   )

									lowercase		,lowercase		,lowercase		,lowercase		,lowercase							=		prepare_layoutlm_batch_inputs()

									# forward pass
									lowercase							=		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
									lowercase							=		outputs.loss
									lowercase							=		(2,)
									self.assertEqual(loss.shape							,							__lowerCamelCase   )

									# test the shape of the logits
									lowercase							=		outputs.logits
									lowercase							=		(2, 2)
									self.assertEqual(logits.shape							,							__lowerCamelCase   )

						@slow
						def        __a		(	self				:      Union[str, Any]   )							->		Optional[int]:


									'''simple docstring'''

									lowercase							=		TFLayoutLMForTokenClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''							,							num_labels=13   )

									lowercase		,lowercase		,lowercase		,lowercase		,lowercase							=		prepare_layoutlm_batch_inputs()

									# forward pass
									lowercase							=		model(
									    input_ids=__lowerCamelCase							,							bbox=__lowerCamelCase							,							attention_mask=__lowerCamelCase							,							token_type_ids=__lowerCamelCase							,							labels=__lowerCamelCase   )

									# test the shape of the logits
									lowercase							=		outputs.logits
									lowercase							=		tf.convert_to_tensor((2, 25, 13)   )
									self.assertEqual(logits.shape							,							__lowerCamelCase   )



						@slow
						def        __a		(	self				:      int   )							->		int:


									'''simple docstring'''

									lowercase							=		TFLayoutLMForQuestionAnswering.from_pretrained('''microsoft/layoutlm-base-uncased'''   )

									lowercase		,lowercase		,lowercase		,lowercase		,lowercase							=		prepare_layoutlm_batch_inputs()

									# forward pass
									lowercase							=		model(input_ids=__lowerCamelCase							,							bbox=__lowerCamelCase							,							attention_mask=__lowerCamelCase							,							token_type_ids=__lowerCamelCase   )

									# test the shape of the logits
									lowercase							=		tf.convert_to_tensor((2, 25)   )
									self.assertEqual(outputs.start_logits.shape							,							__lowerCamelCase   )
									self.assertEqual(outputs.end_logits.shape							,							__lowerCamelCase   )






from __future__ import annotations

from collections.abc import MutableSequence






class      __lowercase					:

						def __init__(	self				:      Optional[Any]							,							__lowerCamelCase				:      int							,							__lowerCamelCase				:      MutableSequence[float]   )							->		None:


									'''simple docstring'''

									if len(__lowerCamelCase   ) != degree + 1:
												raise ValueError(
												    '''The number of coefficients should be equal to the degree + 1.'''   )

									lowercase							=		list(__lowerCamelCase   )
									lowercase							=		degree

						def __add__(	self				:      Any							,							__lowerCamelCase				:      Polynomial   )							->		Polynomial:


									'''simple docstring'''

									if self.degree > polynomial_a.degree:
												lowercase							=		self.coefficients[:]
												for i in range(polynomial_a.degree + 1   ):
															coefficients[i] += polynomial_a.coefficients[i]
												return Polynomial(self.degree							,							__lowerCamelCase   )
									else:
												lowercase							=		polynomial_a.coefficients[:]
												for i in range(self.degree + 1   ):
															coefficients[i] += self.coefficients[i]
												return Polynomial(polynomial_a.degree							,							__lowerCamelCase   )

						def __sub__(	self				:      str							,							__lowerCamelCase				:      Polynomial   )							->		Polynomial:


									'''simple docstring'''

									return self + polynomial_a * Polynomial(0							,							[-1]   )

						def __neg__(	self				:      str   )							->		Polynomial:


									'''simple docstring'''

									return Polynomial(self.degree							,							[-c for c in self.coefficients]   )

						def __mul__(	self				:      List[str]							,							__lowerCamelCase				:      Polynomial   )							->		Polynomial:


									'''simple docstring'''

									lowercase							=		[0] * (self.degree + polynomial_a.degree + 1)
									for i in range(self.degree + 1   ):
												for j in range(polynomial_a.degree + 1   ):
															coefficients[i + j] += (
															    self.coefficients[i] * polynomial_a.coefficients[j]
															)

									return Polynomial(self.degree + polynomial_a.degree							,							__lowerCamelCase   )

						def        __a		(	self				:      List[str]							,							__lowerCamelCase				:      int | float   )							->		int | float:


									'''simple docstring'''

									lowercase							=		0
									for i in range(self.degree + 1   ):
												result += self.coefficients[i] * (substitution**i)
									return result

						def __str__(	self				:      str   )							->		str:


									'''simple docstring'''

									lowercase							=		''''''
									for i in range(self.degree							,							-1							,							-1   ):
												if self.coefficients[i] == 0:
															continue
												elif self.coefficients[i] > 0:
															if polynomial:
																		polynomial += " + "
												else:
															polynomial += " - "

												if i == 0:
															polynomial += str(abs(self.coefficients[i]   )   )
												elif i == 1:
															polynomial += str(abs(self.coefficients[i]   )   ) + "x"
												else:
															polynomial += str(abs(self.coefficients[i]   )   ) + "x^" + str(__lowerCamelCase   )

									return polynomial

						def __repr__(	self				:      Tuple   )							->		str:


									'''simple docstring'''

									return self.__str__()

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


									'''simple docstring'''

									lowercase							=		[0] * self.degree
									for i in range(self.degree   ):
												lowercase							=		self.coefficients[i + 1] * (i + 1)
									return Polynomial(self.degree - 1							,							__lowerCamelCase   )

						def        __a		(	self				:      Union[str, Any]							,							__lowerCamelCase				:      int | float = 0   )							->		Polynomial:


									'''simple docstring'''

									lowercase							=		[0] * (self.degree + 2)
									lowercase							=		constant
									for i in range(self.degree + 1   ):
												lowercase							=		self.coefficients[i] / (i + 1)
									return Polynomial(self.degree + 1							,							__lowerCamelCase   )

						def __eq__(	self				:      Tuple							,							__lowerCamelCase				:      object   )							->		bool:


									'''simple docstring'''

									if not isinstance(__lowerCamelCase							,							__lowerCamelCase   ):
												return False

									if self.degree != polynomial_a.degree:
												return False

									for i in range(self.degree + 1   ):
												if self.coefficients[i] != polynomial_a.coefficients[i]:
															return False

									return True



						def __ne__(	self				:      Tuple							,							__lowerCamelCase				:      object   )							->		bool:


									'''simple docstring'''

									return not self.__eq__(__lowerCamelCase   )





