code: 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 :					Union[str, Any]      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					str=13      ,_lowerCAmelCase :					str=7      ,_lowerCAmelCase :					List[str]=True      ,_lowerCAmelCase :					Optional[int]=True      ,_lowerCAmelCase :					List[Any]=True      ,_lowerCAmelCase :					int=True      ,_lowerCAmelCase :					str=99      ,_lowerCAmelCase :					Optional[int]=32      ,_lowerCAmelCase :					List[str]=5      ,_lowerCAmelCase :					int=4      ,_lowerCAmelCase :					str=37      ,_lowerCAmelCase :					Optional[int]="gelu"      ,_lowerCAmelCase :					Union[str, Any]=0.1      ,_lowerCAmelCase :					List[str]=0.1      ,_lowerCAmelCase :					List[str]=512      ,_lowerCAmelCase :					Optional[Any]=16      ,_lowerCAmelCase :					Tuple=2      ,_lowerCAmelCase :					Optional[int]=0.0_2      ,_lowerCAmelCase :					List[Any]=3      ,_lowerCAmelCase :					Optional[Any]=4      ,_lowerCAmelCase :					List[Any]=None      ,_lowerCAmelCase :					Optional[Any]=1_000      ,):
  
  
  							"""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 							UpperCamelCase_						( self :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size						)
  
  							__snake_case		       =     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]:
  													__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		       =     None
  							if self.use_input_mask:
  									__snake_case		       =     ids_tensor([self.batch_size, self.seq_length]      ,vocab_size=2						)
  
  							__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		       =     self.get_config()
  
  							return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
  
  
  
  
  					def 							UpperCamelCase_						( self :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							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 							UpperCamelCase_						( self :					List[Any]      ,_lowerCAmelCase :					int      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					int      ,_lowerCAmelCase :					List[str]      ,_lowerCAmelCase :					List[Any]      ,_lowerCAmelCase :					Union[str, Any]      ,_lowerCAmelCase :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     LayoutLMModel(config=_lowerCAmelCase						)
  							model.to(_lowerCAmelCase						)
  							model.eval()
  							__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 							UpperCamelCase_						( self :					Optional[Any]      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					Any      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					int      ,_lowerCAmelCase :					Any      ,_lowerCAmelCase :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     LayoutLMForMaskedLM(config=_lowerCAmelCase						)
  							model.to(_lowerCAmelCase						)
  							model.eval()
  							__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 							UpperCamelCase_						( self :					Optional[int]      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					List[Any]      ,_lowerCAmelCase :					Any      ,_lowerCAmelCase :					Any      ,_lowerCAmelCase :					Union[str, Any]      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.num_labels
  							__snake_case		       =     LayoutLMForSequenceClassification(_lowerCAmelCase						)
  							model.to(_lowerCAmelCase						)
  							model.eval()
  							__snake_case		       =     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 							UpperCamelCase_						( self :					Union[str, Any]      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					Optional[int]      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					Optional[Any]      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					List[str]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.num_labels
  							__snake_case		       =     LayoutLMForTokenClassification(config=_lowerCAmelCase						)
  							model.to(_lowerCAmelCase						)
  							model.eval()
  							__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 							UpperCamelCase_						( self :					Dict      ,_lowerCAmelCase :					List[Any]      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					Any      ,_lowerCAmelCase :					int      ,_lowerCAmelCase :					Union[str, Any]      ,_lowerCAmelCase :					Optional[int]      ,_lowerCAmelCase :					List[str]      ,_lowerCAmelCase :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     LayoutLMForQuestionAnswering(config=_lowerCAmelCase						)
  							model.to(_lowerCAmelCase						)
  							model.eval()
  							__snake_case		       =     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 							UpperCamelCase_						( self :					List[str]						):
  
  
  							"""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_torch
  class 					UpperCamelCase	(     snake_case__			,      snake_case__			,      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 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     LayoutLMModelTester(self						)
  							__snake_case		       =     ConfigTester(self      ,config_class=_lowerCAmelCase      ,hidden_size=37						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							self.config_tester.run_common_tests()
  
  
  
  
  					def 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.model_tester.prepare_config_and_inputs()
  							self.model_tester.create_and_check_model(*_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.model_tester.prepare_config_and_inputs()
  							for type in ["absolute", "relative_key", "relative_key_query"]:
  									__snake_case		       =     type
  									self.model_tester.create_and_check_model(*_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.model_tester.prepare_config_and_inputs()
  							self.model_tester.create_and_check_for_masked_lm(*_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.model_tester.prepare_config_and_inputs()
  							self.model_tester.create_and_check_for_sequence_classification(*_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.model_tester.prepare_config_and_inputs()
  							self.model_tester.create_and_check_for_token_classification(*_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     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 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							pass
  
  
  
  
  def 							_lowerCamelCase(				)  ->   Dict:
  		# Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
  		# fmt: off
  		__snake_case		       =     torch.tensor([[101,1019,1014,1016,1037,1_2849,4747,1004,1_4246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,1_1300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,1_9274,2772,6205,2_7814,1_6147,1_6147,4343,2047,1_0283,1_0969,1_4389,1012,2338,102]]						,						device=__snake_case	)  # noqa: E231
  		__snake_case		       =     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=__snake_case	)  # noqa: E231
  		__snake_case		       =     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],[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]]]						,						device=__snake_case	)  # noqa: E231
  		__snake_case		       =     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=__snake_case	)  # noqa: E231
  		# these are sequence labels (i.e. at the token level)
  		__snake_case		       =     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=__snake_case	)  # noqa: E231
  		# fmt: on
  
  		return input_ids, attention_mask, bbox, token_type_ids, labels
  
  
  
  
  
  @require_torch
  class 					UpperCamelCase	(     unittest.TestCase      ):
  
  
  
  
  					@slow
  					def 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"						).to(_lowerCAmelCase						)
  
  							__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		       =     torch.tensor(
  							    [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]]      ,device=_lowerCAmelCase      ,)
  
  							self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]      ,_lowerCAmelCase      ,atol=1E-3						)						)
  
  							# test the pooled output on [1, :3]
  							__snake_case		       =     torch.tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]      ,device=_lowerCAmelCase						)
  
  							self.assertTrue(torch.allclose(outputs.pooler_output[1, :3]      ,_lowerCAmelCase      ,atol=1E-3						)						)
  
  
  
  
  					@slow
  					def 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"      ,num_labels=2						).to(
  							    _lowerCAmelCase						)
  
  							__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=torch.tensor([1, 1]      ,device=_lowerCAmelCase						)      ,)
  
  							# test whether we get a loss as a scalar
  							__snake_case		       =     outputs.loss
  							__snake_case		       =     torch.Size([]						)
  							self.assertEqual(loss.shape      ,_lowerCAmelCase						)
  
  							# test the shape of the logits
  							__snake_case		       =     outputs.logits
  							__snake_case		       =     torch.Size((2, 2)						)
  							self.assertEqual(logits.shape      ,_lowerCAmelCase						)
  
  
  
  
  					@slow
  					def 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"      ,num_labels=13						).to(
  							    _lowerCAmelCase						)
  
  							__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 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
  							__snake_case		       =     outputs.logits
  							__snake_case		       =     torch.Size((2, 25, 13)						)
  							self.assertEqual(logits.shape      ,_lowerCAmelCase						)
  
  
  
  
  
  
  
  					@slow
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     LayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"						).to(_lowerCAmelCase						)
  
  							__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		       =     torch.Size((2, 25)						)
  							self.assertEqual(outputs.start_logits.shape      ,_lowerCAmelCase						)
  							self.assertEqual(outputs.end_logits.shape      ,_lowerCAmelCase						)
  
  
  
  
  
  
style_context: from __future__ import annotations
  
  from collections.abc import Iterable
  from dataclasses import dataclass
  from typing import Any
  
  
  
  
  class 					UpperCamelCase	:
  					__UpperCamelCase						=   ("""_front""", """_back""", """_len""")
  
  
  
  
  					@dataclass
  					class 					UpperCamelCase	:
  										__UpperCamelCase						=   None
  										__UpperCamelCase						=   None
  										__UpperCamelCase						=   None
  
  
  
  
  					class 					UpperCamelCase	:
  										__UpperCamelCase						=   ("""_cur""",)
  
  
  
  
  										def __init__( self :					Dict      ,_lowerCAmelCase :					Deque._Node | None						):
  
  
  												"""simple docstring"""
  
  
  
  
  												__snake_case		       =     cur
  
  
  
  
  										def __iter__( self :					Dict						):
  
  
  												"""simple docstring"""
  
  
  
  
  												return self
  
  
  
  
  
  
  
  										def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  												"""simple docstring"""
  
  
  
  
  												if self._cur is None:
  														# finished iterating
  														raise StopIteration
  												__snake_case		       =     self._cur.val
  												__snake_case		       =     self._cur.next_node
  
  												return val
  
  
  
  
  					def __init__( self :					Optional[int]      ,_lowerCAmelCase :					Iterable[Any] | None = None						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     None
  							__snake_case		       =     None
  							__snake_case		       =     0
  
  							if iterable is not None:
  									# append every value to the deque
  									for val in iterable:
  											self.append(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self._Node(_lowerCAmelCase      ,_lowerCAmelCase      ,_lowerCAmelCase						)
  							if self.is_empty():
  									# front = back
  									__snake_case		       =     __snake_case		       =     node
  									__snake_case		       =     1
  							else:
  									# connect nodes
  									__snake_case		       =     node
  									__snake_case		       =     self._back
  									__snake_case		       =     node  # assign new back to the new node
  
  									self._len += 1
  
  									# make sure there were no errors
  									assert not self.is_empty(), "Error on appending value."
  
  
  
  
  					def 							UpperCamelCase_						( self :					Any      ,_lowerCAmelCase :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self._Node(_lowerCAmelCase      ,_lowerCAmelCase      ,_lowerCAmelCase						)
  							if self.is_empty():
  									# front = back
  									__snake_case		       =     __snake_case		       =     node
  									__snake_case		       =     1
  							else:
  									# connect nodes
  									__snake_case		       =     self._front
  									__snake_case		       =     node
  									__snake_case		       =     node  # assign new front to the new node
  
  									self._len += 1
  
  									# make sure there were no errors
  									assert not self.is_empty(), "Error on appending value."
  
  
  
  
  					def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Iterable[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							for val in iterable:
  									self.append(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[int]      ,_lowerCAmelCase :					Iterable[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							for val in iterable:
  									self.appendleft(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							assert not self.is_empty(), "Deque is empty."
  
  							__snake_case		       =     self._back
  							__snake_case		       =     self._back.prev_node  # set new back
  							# drop the last node - python will deallocate memory automatically
  							__snake_case		       =     None
  
  							self._len -= 1
  
  							return topop.val
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[str]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							assert not self.is_empty(), "Deque is empty."
  
  							__snake_case		       =     self._front
  							__snake_case		       =     self._front.next_node  # set new front and drop the first node
  							__snake_case		       =     None
  
  							self._len -= 1
  
  							return topop.val
  
  
  
  
  					def 							UpperCamelCase_						( self :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return self._front is None
  
  
  
  
  					def __len__( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return self._len
  
  
  
  
  					def __eq__( self :					Union[str, Any]      ,_lowerCAmelCase :					object						):
  
  
  							"""simple docstring"""
  
  
  
  
  							if not isinstance(_lowerCAmelCase      ,_lowerCAmelCase						):
  									return NotImplemented
  
  							__snake_case		       =     self._front
  							__snake_case		       =     other._front
  
  							# if the length of the dequeues are not the same, they are not equal
  							if len(self						) != len(_lowerCAmelCase						):
  									return False
  
  							while me is not None and oth is not None:
  									# compare every value
  									if me.val != oth.val:
  											return False
  									__snake_case		       =     me.next_node
  									__snake_case		       =     oth.next_node
  
  							return True
  
  
  
  
  					def __iter__( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return Deque._Iterator(self._front						)
  
  
  
  
  
  
  
  					def __repr__( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     []
  							__snake_case		       =     self._front
  							while aux is not None:
  									# append the values in a list to display
  									values_list.append(aux.val						)
  									__snake_case		       =     aux.next_node
  
  							return F"""[{", ".join(repr(_lowerCAmelCase						) for val in values_list						)}]"""
  
  
  if __name__ == "__main__":
  		import doctest
  
  		doctest.testmod()
  
  
  
  
  
  