






'''simple docstring'''




import unittest

from transformers import 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, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        RemBertConfig,
        RemBertForCausalLM,
        RemBertForMaskedLM,
        RemBertForMultipleChoice,
        RemBertForQuestionAnswering,
        RemBertForSequenceClassification,
        RemBertForTokenClassification,
        RemBertModel,
    )
    from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST

class      _UpperCAmelCase    :




   """simple docstring"""

   def __init__(	self				:			Union[str, Any]   ,   __UpperCAmelCase				:			List[str]   ,   __UpperCAmelCase				:			List[Any]=13   ,   __UpperCAmelCase				:			List[str]=7   ,   __UpperCAmelCase				:			Tuple=True   ,   __UpperCAmelCase				:			Dict=True   ,   __UpperCAmelCase				:			List[str]=True   ,   __UpperCAmelCase				:			str=True   ,   __UpperCAmelCase				:			str=99   ,   __UpperCAmelCase				:			int=32   ,   __UpperCAmelCase				:			Union[str, Any]=18   ,   __UpperCAmelCase				:			str=43   ,   __UpperCAmelCase				:			Optional[int]=5   ,   __UpperCAmelCase				:			List[str]=4   ,   __UpperCAmelCase				:			List[Any]=37   ,   __UpperCAmelCase				:			Optional[Any]="gelu"   ,   __UpperCAmelCase				:			int=0.1   ,   __UpperCAmelCase				:			Tuple=0.1   ,   __UpperCAmelCase				:			Dict=512   ,   __UpperCAmelCase				:			List[Any]=16   ,   __UpperCAmelCase				:			Union[str, Any]=2   ,   __UpperCAmelCase				:			Optional[int]=0.02   ,   __UpperCAmelCase				:			List[str]=3   ,   __UpperCAmelCase				:			List[str]=4   ,   __UpperCAmelCase				:			List[Any]=None   ,   ):





         '''simple docstring'''





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

   def 		lowerCAmelCase				(	self				:			List[str]	):





         '''simple docstring'''





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

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

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

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

         _A      =			RemBertConfig(
             vocab_size=self.vocab_size   ,   hidden_size=self.hidden_size   ,   input_embedding_size=self.input_embedding_size   ,   output_embedding_size=self.output_embedding_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   ,   is_decoder=__UpperCAmelCase   ,   initializer_range=self.initializer_range   ,   )

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

   def 		lowerCAmelCase				(	self				:			Union[str, Any]	):





         '''simple docstring'''





         (
             (
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			
         )      =			self.prepare_config_and_inputs()

         _A      =			True
         _A      =			floats_tensor([self.batch_size, self.seq_length, self.hidden_size]	)
         _A      =			ids_tensor([self.batch_size, self.seq_length]   ,   vocab_size=2	)

         return (
             config,
             input_ids,
             token_type_ids,
             input_mask,
             sequence_labels,
             token_labels,
             choice_labels,
             encoder_hidden_states,
             encoder_attention_mask,
         )

   def 		lowerCAmelCase				(	self				:			str   ,   __UpperCAmelCase				:			str   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			Any   ,   __UpperCAmelCase				:			Dict   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			List[str]   ,   __UpperCAmelCase				:			Any	):





         '''simple docstring'''





         _A      =			RemBertModel(config=__UpperCAmelCase	)
         model.to(__UpperCAmelCase	)
         model.eval()
         _A      =			model(__UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase	)
         _A      =			model(__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase	)
         _A      =			model(__UpperCAmelCase	)
         self.parent.assertEqual(result.last_hidden_state.shape   ,   (self.batch_size, self.seq_length, self.hidden_size)	)

   def 		lowerCAmelCase				(	self				:			Optional[int]   ,   __UpperCAmelCase				:			Tuple   ,   __UpperCAmelCase				:			Tuple   ,   __UpperCAmelCase				:			List[str]   ,   __UpperCAmelCase				:			str   ,   __UpperCAmelCase				:			Dict   ,   __UpperCAmelCase				:			Optional[int]   ,   __UpperCAmelCase				:			List[str]   ,   __UpperCAmelCase				:			Optional[int]   ,   __UpperCAmelCase				:			Any   ,   ):





         '''simple docstring'''





         _A      =			True
         _A      =			RemBertModel(__UpperCAmelCase	)
         model.to(__UpperCAmelCase	)
         model.eval()
         _A      =			model(
             __UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase   ,   encoder_hidden_states=__UpperCAmelCase   ,   encoder_attention_mask=__UpperCAmelCase   ,   )
         _A      =			model(
             __UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase   ,   encoder_hidden_states=__UpperCAmelCase   ,   )
         _A      =			model(__UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase	)
         self.parent.assertEqual(result.last_hidden_state.shape   ,   (self.batch_size, self.seq_length, self.hidden_size)	)

   def 		lowerCAmelCase				(	self				:			Optional[int]   ,   __UpperCAmelCase				:			Union[str, Any]   ,   __UpperCAmelCase				:			Any   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			Any   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			Any   ,   __UpperCAmelCase				:			List[str]   ,   ):





         '''simple docstring'''





         _A      =			RemBertForCausalLM(config=__UpperCAmelCase	)
         model.to(__UpperCAmelCase	)
         model.eval()
         _A      =			model(__UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase   ,   labels=__UpperCAmelCase	)
         self.parent.assertEqual(result.logits.shape   ,   (self.batch_size, self.seq_length, self.vocab_size)	)

   def 		lowerCAmelCase				(	self				:			Optional[Any]   ,   __UpperCAmelCase				:			Optional[Any]   ,   __UpperCAmelCase				:			Tuple   ,   __UpperCAmelCase				:			Optional[int]   ,   __UpperCAmelCase				:			Tuple   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			Union[str, Any]   ,   __UpperCAmelCase				:			List[Any]	):





         '''simple docstring'''





         _A      =			RemBertForMaskedLM(config=__UpperCAmelCase	)
         model.to(__UpperCAmelCase	)
         model.eval()
         _A      =			model(__UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase   ,   labels=__UpperCAmelCase	)
         self.parent.assertEqual(result.logits.shape   ,   (self.batch_size, self.seq_length, self.vocab_size)	)

   def 		lowerCAmelCase				(	self				:			int   ,   __UpperCAmelCase				:			Dict   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			Any   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			List[str]   ,   __UpperCAmelCase				:			str   ,   __UpperCAmelCase				:			Optional[int]   ,   __UpperCAmelCase				:			Optional[Any]   ,   ):





         '''simple docstring'''





         _A      =			True
         _A      =			True
         _A      =			RemBertForCausalLM(config=__UpperCAmelCase	)
         model.to(__UpperCAmelCase	)
         model.eval()

         # first forward pass
         _A      =			model(
             __UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   encoder_hidden_states=__UpperCAmelCase   ,   encoder_attention_mask=__UpperCAmelCase   ,   use_cache=__UpperCAmelCase   ,   )
         _A      =			outputs.past_key_values

         # create hypothetical multiple next token and extent to next_input_ids
         _A      =			ids_tensor((self.batch_size, 3)   ,   config.vocab_size	)
         _A      =			ids_tensor((self.batch_size, 3)   ,   vocab_size=2	)

         # append to next input_ids and
         _A      =			torch.cat([input_ids, next_tokens]   ,   dim=-1	)
         _A      =			torch.cat([input_mask, next_mask]   ,   dim=-1	)

         _A      =			model(
             __UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   encoder_hidden_states=__UpperCAmelCase   ,   encoder_attention_mask=__UpperCAmelCase   ,   output_hidden_states=__UpperCAmelCase   ,   )["hidden_states"][0]
         _A      =			model(
             __UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   encoder_hidden_states=__UpperCAmelCase   ,   encoder_attention_mask=__UpperCAmelCase   ,   past_key_values=__UpperCAmelCase   ,   output_hidden_states=__UpperCAmelCase   ,   )["hidden_states"][0]

         # select random slice
         _A      =			ids_tensor((1,)   ,   output_from_past.shape[-1]	).item()
         _A      =			output_from_no_past[:, -3:, random_slice_idx].detach()
         _A      =			output_from_past[:, :, random_slice_idx].detach()

         self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]	)

         # test that outputs are equal for slice
         self.parent.assertTrue(torch.allclose(__UpperCAmelCase   ,   __UpperCAmelCase   ,   atol=1E-3	)	)

   def 		lowerCAmelCase				(	self				:			Union[str, Any]   ,   __UpperCAmelCase				:			Union[str, Any]   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			Tuple   ,   __UpperCAmelCase				:			Dict   ,   __UpperCAmelCase				:			List[Any]	):





         '''simple docstring'''





         _A      =			RemBertForQuestionAnswering(config=__UpperCAmelCase	)
         model.to(__UpperCAmelCase	)
         model.eval()
         _A      =			model(
             __UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase   ,   start_positions=__UpperCAmelCase   ,   end_positions=__UpperCAmelCase   ,   )
         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				:			str   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			Tuple   ,   __UpperCAmelCase				:			Dict   ,   __UpperCAmelCase				:			str   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			Dict	):





         '''simple docstring'''





         _A      =			self.num_labels
         _A      =			RemBertForSequenceClassification(__UpperCAmelCase	)
         model.to(__UpperCAmelCase	)
         model.eval()
         _A      =			model(__UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase   ,   labels=__UpperCAmelCase	)
         self.parent.assertEqual(result.logits.shape   ,   (self.batch_size, self.num_labels)	)

   def 		lowerCAmelCase				(	self				:			Optional[Any]   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			Union[str, Any]   ,   __UpperCAmelCase				:			Optional[Any]   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			Any   ,   __UpperCAmelCase				:			List[str]   ,   __UpperCAmelCase				:			List[Any]	):





         '''simple docstring'''





         _A      =			self.num_labels
         _A      =			RemBertForTokenClassification(config=__UpperCAmelCase	)
         model.to(__UpperCAmelCase	)
         model.eval()
         _A      =			model(__UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase   ,   labels=__UpperCAmelCase	)
         self.parent.assertEqual(result.logits.shape   ,   (self.batch_size, self.seq_length, self.num_labels)	)

   def 		lowerCAmelCase				(	self				:			str   ,   __UpperCAmelCase				:			Union[str, Any]   ,   __UpperCAmelCase				:			int   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			List[str]   ,   __UpperCAmelCase				:			Tuple   ,   __UpperCAmelCase				:			List[Any]   ,   __UpperCAmelCase				:			Any	):





         '''simple docstring'''





         _A      =			self.num_choices
         _A      =			RemBertForMultipleChoice(config=__UpperCAmelCase	)
         model.to(__UpperCAmelCase	)
         model.eval()
         _A      =			input_ids.unsqueeze(1	).expand(-1   ,   self.num_choices   ,   -1	).contiguous()
         _A      =			token_type_ids.unsqueeze(1	).expand(-1   ,   self.num_choices   ,   -1	).contiguous()
         _A      =			input_mask.unsqueeze(1	).expand(-1   ,   self.num_choices   ,   -1	).contiguous()
         _A      =			model(
             __UpperCAmelCase   ,   attention_mask=__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase   ,   labels=__UpperCAmelCase   ,   )
         self.parent.assertEqual(result.logits.shape   ,   (self.batch_size, self.num_choices)	)

   def 		lowerCAmelCase				(	self				:			Optional[int]	):





         '''simple docstring'''





         _A      =			self.prepare_config_and_inputs()
         (
             (
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			
         )      =			config_and_inputs
         _A      =			{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
         return config, inputs_dict





@require_torch
class      _UpperCAmelCase    (  snake_case_							,					snake_case_							,					unittest.TestCase		):




   """simple docstring"""

   snake_case					       =		(
       (
           RemBertModel,
           RemBertForMaskedLM,
           RemBertForCausalLM,
           RemBertForMultipleChoice,
           RemBertForQuestionAnswering,
           RemBertForSequenceClassification,
           RemBertForTokenClassification,
       )
       if is_torch_available()
       else ()
   )
   snake_case					       =		(RemBertForCausalLM,) if is_torch_available() else ()
   snake_case					       =		(
       {
           '''feature-extraction''': RemBertModel,
           '''fill-mask''': RemBertForMaskedLM,
           '''question-answering''': RemBertForQuestionAnswering,
           '''text-classification''': RemBertForSequenceClassification,
           '''text-generation''': RemBertForCausalLM,
           '''token-classification''': RemBertForTokenClassification,
           '''zero-shot''': RemBertForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )

   def 		lowerCAmelCase				(	self				:			Dict	):





         '''simple docstring'''





         _A      =			RemBertModelTester(self	)
         _A      =			ConfigTester(self   ,   config_class=__UpperCAmelCase   ,   hidden_size=37	)

   def 		lowerCAmelCase				(	self				:			Optional[Any]	):





         '''simple docstring'''





         self.config_tester.run_common_tests()

   def 		lowerCAmelCase				(	self				:			Dict	):





         '''simple docstring'''





         _A      =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__UpperCAmelCase	)

   def 		lowerCAmelCase				(	self				:			Optional[Any]	):





         '''simple docstring'''





         _A      =			self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
               _A      =			type
               self.model_tester.create_and_check_model(*__UpperCAmelCase	)

   def 		lowerCAmelCase				(	self				:			str	):





         '''simple docstring'''





         _A      =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*__UpperCAmelCase	)

   def 		lowerCAmelCase				(	self				:			Union[str, Any]	):





         '''simple docstring'''





         _A      =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*__UpperCAmelCase	)

   def 		lowerCAmelCase				(	self				:			str	):





         '''simple docstring'''





         _A      =			self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_decoder_model_past_large_inputs(*__UpperCAmelCase	)

   def 		lowerCAmelCase				(	self				:			Union[str, Any]	):





         '''simple docstring'''





         _A      =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*__UpperCAmelCase	)

   def 		lowerCAmelCase				(	self				:			Optional[Any]	):





         '''simple docstring'''





         _A      =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*__UpperCAmelCase	)

   def 		lowerCAmelCase				(	self				:			Optional[Any]	):





         '''simple docstring'''





         _A      =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*__UpperCAmelCase	)

   def 		lowerCAmelCase				(	self				:			int	):





         '''simple docstring'''





         _A      =			self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_model_as_decoder(*__UpperCAmelCase	)

   def 		lowerCAmelCase				(	self				:			List[str]	):





         '''simple docstring'''





         (
             (
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			(
             _A
         )  ,			
         )      =			self.model_tester.prepare_config_and_inputs_for_decoder()

         _A      =			None

         self.model_tester.create_and_check_model_as_decoder(
             __UpperCAmelCase   ,   __UpperCAmelCase   ,   __UpperCAmelCase   ,   __UpperCAmelCase   ,   __UpperCAmelCase   ,   __UpperCAmelCase   ,   __UpperCAmelCase   ,   __UpperCAmelCase   ,   __UpperCAmelCase   ,   )

   @slow
   def 		lowerCAmelCase				(	self				:			Union[str, Any]	):





         '''simple docstring'''





         for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _A      =			RemBertModel.from_pretrained(__UpperCAmelCase	)
               self.assertIsNotNone(__UpperCAmelCase	)





@require_torch
class      _UpperCAmelCase    (  unittest.TestCase		):




   """simple docstring"""

   @slow
   def 		lowerCAmelCase				(	self				:			str	):





         '''simple docstring'''





         _A      =			RemBertModel.from_pretrained("google/rembert"	)
         _A      =			torch.tensor([[312, 56498, 313, 2125, 313]]	)
         _A      =			torch.tensor([[0, 0, 0, 1, 1]]	)
         with torch.no_grad():
               _A      =			model(__UpperCAmelCase   ,   token_type_ids=__UpperCAmelCase   ,   output_hidden_states=__UpperCAmelCase	)

         _A      =			1152

         _A      =			torch.Size((1, 5, hidden_size)	)
         self.assertEqual(output["last_hidden_state"].shape   ,   __UpperCAmelCase	)

         _A      =			torch.tensor(
             [
                 [
                     [0.0754, -0.2022, 0.1904],
                     [-0.3354, -0.3692, -0.4791],
                     [-0.2314, -0.6729, -0.0749],
                     [-0.0396, -0.3105, -0.4234],
                     [-0.1571, -0.0525, 0.5353],
                 ]
             ]	)

         # Running on the original tf implementation gives slightly different results here.
         # Not clear why this variations is present
         # TODO: Find reason for discrepancy
         # expected_original_implementation = [[
         #     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
         #     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
         #     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
         #     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
         #     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
         # ]]

         self.assertTrue(torch.allclose(output["last_hidden_state"][:, :, :3]   ,   __UpperCAmelCase   ,   atol=1E-4	)	)













'''simple docstring'''




from __future__ import annotations

from collections.abc import Iterator
from typing import Any

class      _UpperCAmelCase    :




   """simple docstring"""

   def __init__(	self				:			Any   ,   __UpperCAmelCase				:			Any	):





         '''simple docstring'''





         _A      =			data
         _A      =			None

   def __str__(	self				:			str	):





         '''simple docstring'''





         return f'''{self.data}'''





class      _UpperCAmelCase    :




   """simple docstring"""

   def __init__(	self				:			Optional[int]	):





         '''simple docstring'''





         _A      =			None
         _A      =			None

   def __iter__(	self				:			List[Any]	):





         '''simple docstring'''





         _A      =			self.front
         while node:
               yield node.data
               _A      =			node.next

   def __len__(	self				:			Union[str, Any]	):





         '''simple docstring'''





         return len(tuple(iter(self	)	)	)

   def __str__(	self				:			int	):





         '''simple docstring'''





         return " <- ".join(str(__UpperCAmelCase	) for item in self	)

   def 		lowerCAmelCase				(	self				:			List[Any]	):





         '''simple docstring'''





         return len(self	) == 0

   def 		lowerCAmelCase				(	self				:			int   ,   __UpperCAmelCase				:			Any	):





         '''simple docstring'''





         _A      =			Node(__UpperCAmelCase	)
         if self.is_empty():
               _A      =			_A      =			node
         else:
               assert isinstance(self.rear   ,   __UpperCAmelCase	)
               _A      =			node
               _A      =			node

   def 		lowerCAmelCase				(	self				:			str	):





         '''simple docstring'''





         if self.is_empty():
               raise IndexError("dequeue from empty queue"	)
         assert isinstance(self.front   ,   __UpperCAmelCase	)
         _A      =			self.front
         _A      =			self.front.next
         if self.front is None:
               _A      =			None
         return node.data

   def 		lowerCAmelCase				(	self				:			int	):





         '''simple docstring'''





         _A      =			_A      =			None


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

    testmod()





