




'''simple docstring'''





import os
import tempfile
import unittest

from transformers import NezhaConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
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 (
       MODEL_FOR_PRETRAINING_MAPPING,
       NezhaForMaskedLM,
       NezhaForMultipleChoice,
       NezhaForNextSentencePrediction,
       NezhaForPreTraining,
       NezhaForQuestionAnswering,
       NezhaForSequenceClassification,
       NezhaForTokenClassification,
       NezhaModel,
   )
   from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST

class        _a    :






     def __init__(			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE=13 ,_SCREAMING_SNAKE_CASE=7 ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=99 ,_SCREAMING_SNAKE_CASE=32 ,_SCREAMING_SNAKE_CASE=5 ,_SCREAMING_SNAKE_CASE=4 ,_SCREAMING_SNAKE_CASE=37 ,_SCREAMING_SNAKE_CASE="gelu" ,_SCREAMING_SNAKE_CASE=0.1 ,_SCREAMING_SNAKE_CASE=0.1 ,_SCREAMING_SNAKE_CASE=128 ,_SCREAMING_SNAKE_CASE=32 ,_SCREAMING_SNAKE_CASE=16 ,_SCREAMING_SNAKE_CASE=2 ,_SCREAMING_SNAKE_CASE=0.0_2 ,_SCREAMING_SNAKE_CASE=3 ,_SCREAMING_SNAKE_CASE=4 ,_SCREAMING_SNAKE_CASE=None ,)							->      str:
          _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






     def     _lowercase     (			self   )							->      List[str]:
          _snake_case							=				ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size   )

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

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

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

          _snake_case							=				self.get_config()

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






     def     _lowercase     (			self   )							->      Optional[int]:
          return NezhaConfig(
              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 ,is_decoder=__A ,initializer_range=self.initializer_range ,)






     def     _lowercase     (			self   )							->      str:
          (
              _snake_case	
          )							=				self.prepare_config_and_inputs()

          _snake_case							=				True
          _snake_case							=				floats_tensor([self.batch_size, self.seq_length, self.hidden_size]   )
          _snake_case							=				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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      List[str]:
          _snake_case							=				NezhaModel(config=__A   )
          model.to(__A   )
          model.eval()
          _snake_case							=				model(__A ,attention_mask=__A ,token_type_ids=__A   )
          _snake_case							=				model(__A ,token_type_ids=__A   )
          _snake_case							=				model(__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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,)							->      Tuple:
          _snake_case							=				True
          _snake_case							=				NezhaModel(__A   )
          model.to(__A   )
          model.eval()
          _snake_case							=				model(
              __A ,attention_mask=__A ,token_type_ids=__A ,encoder_hidden_states=__A ,encoder_attention_mask=__A ,)
          _snake_case							=				model(
              __A ,attention_mask=__A ,token_type_ids=__A ,encoder_hidden_states=__A ,)
          _snake_case							=				model(__A ,attention_mask=__A ,token_type_ids=__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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      int:
          _snake_case							=				NezhaForMaskedLM(config=__A   )
          model.to(__A   )
          model.eval()
          _snake_case							=				model(__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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Optional[int]:
          _snake_case							=				NezhaForNextSentencePrediction(config=__A   )
          model.to(__A   )
          model.eval()
          _snake_case							=				model(
              __A ,attention_mask=__A ,token_type_ids=__A ,labels=__A ,)
          self.parent.assertEqual(result.logits.shape ,(self.batch_size, 2)   )






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Any:
          _snake_case							=				NezhaForPreTraining(config=__A   )
          model.to(__A   )
          model.eval()
          _snake_case							=				model(
              __A ,attention_mask=__A ,token_type_ids=__A ,labels=__A ,next_sentence_label=__A ,)
          self.parent.assertEqual(result.prediction_logits.shape ,(self.batch_size, self.seq_length, self.vocab_size)   )
          self.parent.assertEqual(result.seq_relationship_logits.shape ,(self.batch_size, 2)   )






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      List[Any]:
          _snake_case							=				NezhaForQuestionAnswering(config=__A   )
          model.to(__A   )
          model.eval()
          _snake_case							=				model(
              __A ,attention_mask=__A ,token_type_ids=__A ,start_positions=__A ,end_positions=__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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Any:
          _snake_case							=				self.num_labels
          _snake_case							=				NezhaForSequenceClassification(__A   )
          model.to(__A   )
          model.eval()
          _snake_case							=				model(__A ,attention_mask=__A ,token_type_ids=__A ,labels=__A   )
          self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_labels)   )






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      List[Any]:
          _snake_case							=				self.num_labels
          _snake_case							=				NezhaForTokenClassification(config=__A   )
          model.to(__A   )
          model.eval()
          _snake_case							=				model(__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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Dict:
          _snake_case							=				self.num_choices
          _snake_case							=				NezhaForMultipleChoice(config=__A   )
          model.to(__A   )
          model.eval()
          _snake_case							=				input_ids.unsqueeze(1   ).expand(-1 ,self.num_choices ,-1   ).contiguous()
          _snake_case							=				token_type_ids.unsqueeze(1   ).expand(-1 ,self.num_choices ,-1   ).contiguous()
          _snake_case							=				input_mask.unsqueeze(1   ).expand(-1 ,self.num_choices ,-1   ).contiguous()
          _snake_case							=				model(
              __A ,attention_mask=__A ,token_type_ids=__A ,labels=__A ,)
          self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_choices)   )






     def     _lowercase     (			self   )							->      str:
          _snake_case							=				self.prepare_config_and_inputs()
          (
              _snake_case	
          )							=				config_and_inputs
          _snake_case							=				{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
          return config, inputs_dict







@require_torch
class        _a    (						A__ , A__ , A__ , unittest.TestCase							):
     SCREAMING_SNAKE_CASE_							:   Union[str, Any]       =						(
         (
             NezhaModel,
             NezhaForMaskedLM,
             NezhaForMultipleChoice,
             NezhaForNextSentencePrediction,
             NezhaForPreTraining,
             NezhaForQuestionAnswering,
             NezhaForSequenceClassification,
             NezhaForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     SCREAMING_SNAKE_CASE_							:   Optional[int]       =						(
         {
             "feature-extraction": NezhaModel,
             "fill-mask": NezhaForMaskedLM,
             "question-answering": NezhaForQuestionAnswering,
             "text-classification": NezhaForSequenceClassification,
             "token-classification": NezhaForTokenClassification,
             "zero-shot": NezhaForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     SCREAMING_SNAKE_CASE_							:   Optional[Any]       =						True






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE=False   )							->      Optional[Any]:
          _snake_case							=				super()._prepare_for_class(__A ,__A ,return_labels=__A   )

          if return_labels:
               if model_class in get_values(__A   ):
                    _snake_case							=				torch.zeros(
                        (self.model_tester.batch_size, self.model_tester.seq_length) ,dtype=torch.long ,device=__A   )
                    _snake_case							=				torch.zeros(
                        self.model_tester.batch_size ,dtype=torch.long ,device=__A   )
          return inputs_dict






     def     _lowercase     (			self   )							->      Optional[int]:
          _snake_case							=				NezhaModelTester(self   )
          _snake_case							=				ConfigTester(self ,config_class=__A ,hidden_size=37   )






     def     _lowercase     (			self   )							->      str:
          self.config_tester.run_common_tests()






     def     _lowercase     (			self   )							->      Any:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*__A   )






     def     _lowercase     (			self   )							->      Optional[Any]:
          _snake_case							=				self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_model_as_decoder(*__A   )






     def     _lowercase     (			self   )							->      str:
          # This regression test was failing with PyTorch < 1.3
          (
              _snake_case	
          )							=				self.model_tester.prepare_config_and_inputs_for_decoder()

          _snake_case							=				None

          self.model_tester.create_and_check_model_as_decoder(
              __A ,__A ,__A ,__A ,__A ,__A ,__A ,__A ,__A ,)






     def     _lowercase     (			self   )							->      Optional[int]:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*__A   )






     def     _lowercase     (			self   )							->      Tuple:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_multiple_choice(*__A   )






     def     _lowercase     (			self   )							->      Optional[Any]:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_next_sequence_prediction(*__A   )






     def     _lowercase     (			self   )							->      int:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_pretraining(*__A   )






     def     _lowercase     (			self   )							->      List[str]:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*__A   )






     def     _lowercase     (			self   )							->      Union[str, Any]:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*__A   )






     def     _lowercase     (			self   )							->      List[Any]:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*__A   )






     @slow
     def     _lowercase     (			self   )							->      str:
          for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _snake_case							=				NezhaModel.from_pretrained(__A   )
               self.assertIsNotNone(__A   )






     @slow
     @require_torch_gpu
     def     _lowercase     (			self   )							->      int:
          _snake_case							=				self.model_tester.prepare_config_and_inputs_for_common()
          for model_class in self.all_model_classes:
               # NezhaForMultipleChoice behaves incorrectly in JIT environments.
               if model_class == NezhaForMultipleChoice:
                    return

               _snake_case							=				True
               _snake_case							=				model_class(config=__A   )

               _snake_case							=				self._prepare_for_class(__A ,__A   )
               _snake_case							=				torch.jit.trace(
                   __A ,(inputs_dict["input_ids"].to("cpu"   ), inputs_dict["attention_mask"].to("cpu"   ))   )

               with tempfile.TemporaryDirectory() as tmp:
                    torch.jit.save(__A ,os.path.join(__A ,"bert.pt"   )   )
                    _snake_case							=				torch.jit.load(os.path.join(__A ,"bert.pt"   ) ,map_location=__A   )
                    loaded(inputs_dict["input_ids"].to(__A   ) ,inputs_dict["attention_mask"].to(__A   )   )







@require_torch
class        _a    (						unittest.TestCase							):






     @slow
     def     _lowercase     (			self   )							->      Tuple:
          _snake_case							=				NezhaModel.from_pretrained("sijunhe/nezha-cn-base"   )
          _snake_case							=				torch.tensor([[0, 1, 2, 3, 4, 5]]   )
          _snake_case							=				torch.tensor([[0, 1, 1, 1, 1, 1]]   )
          with torch.no_grad():
               _snake_case							=				model(__A ,attention_mask=__A   )[0]
          _snake_case							=				torch.Size((1, 6, 768)   )
          self.assertEqual(output.shape ,__A   )
          _snake_case							=				torch.tensor([[[0.0_6_8_5, 0.2_4_4_1, 0.1_1_0_2], [0.0_6_0_0, 0.1_9_0_6, 0.1_3_4_9], [0.0_2_2_1, 0.0_8_1_9, 0.0_5_8_6]]]   )

          self.assertTrue(torch.allclose(output[:, 1:4, 1:4] ,__A ,atol=1e-4   )   )






     @slow
     def     _lowercase     (			self   )							->      Tuple:
          _snake_case							=				NezhaForMaskedLM.from_pretrained("sijunhe/nezha-cn-base"   )
          _snake_case							=				torch.tensor([[0, 1, 2, 3, 4, 5]]   )
          _snake_case							=				torch.tensor([[1, 1, 1, 1, 1, 1]]   )
          with torch.no_grad():
               _snake_case							=				model(__A ,attention_mask=__A   )[0]
          _snake_case							=				torch.Size((1, 6, 21_128)   )
          self.assertEqual(output.shape ,__A   )
          _snake_case							=				torch.tensor(
              [[-2.7_9_3_9, -1.7_9_0_2, -2.2_1_8_9], [-2.8_5_8_5, -1.8_9_0_8, -2.3_7_2_3], [-2.6_4_9_9, -1.7_7_5_0, -2.2_5_5_8]]   )

          self.assertTrue(torch.allclose(output[:, 1:4, 1:4] ,__A ,atol=1e-4   )   )







'''simple docstring'''





from __future__ import annotations

from collections.abc import Callable
from typing import Generic, TypeVar

UpperCamelCase_						:      int       =						TypeVar('''T''')
UpperCamelCase_						:      Dict       =						TypeVar('''U''')

class        _a    (						Generic[T, U]							):






     def __init__(			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Dict:
          _snake_case							=				key
          _snake_case							=				val
          _snake_case							=				None
          _snake_case							=				None






     def __repr__(			self   )							->      str:
          return (
              f"""Node: key: {self.key}, val: {self.val}, """
              f"""has next: {bool(self.next   )}, has prev: {bool(self.prev   )}"""
          )







class        _a    (						Generic[T, U]							):






     def __init__(			self   )							->      None:
          _snake_case							=				DoubleLinkedListNode(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )
          _snake_case							=				DoubleLinkedListNode(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )
          _snake_case							, _snake_case							=				self.rear, self.head






     def __repr__(			self   )							->      str:
          _snake_case							=				["DoubleLinkedList"]
          _snake_case							=				self.head
          while node.next is not None:
               rep.append(str(_SCREAMING_SNAKE_CASE   )   )
               _snake_case							=				node.next
          rep.append(str(self.rear   )   )
          return ",\n    ".join(_SCREAMING_SNAKE_CASE   )






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE   )							->      None:
          _snake_case							=				self.rear.prev

          # All nodes other than self.head are guaranteed to have non-None previous
          assert previous is not None

          _snake_case							=				node
          _snake_case							=				previous
          _snake_case							=				node
          _snake_case							=				self.rear






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE   )							->      DoubleLinkedListNode[T, U] | None:

          if node.prev is None or node.next is None:
               return None

          _snake_case							=				node.next
          _snake_case							=				node.prev
          _snake_case							=				None
          _snake_case							=				None
          return node







class        _a    (						Generic[T, U]							):
     SCREAMING_SNAKE_CASE_							:   dict[Callable[[T], U], LRUCache[T, U]]       =						{}






     def __init__(			self ,_SCREAMING_SNAKE_CASE   )							->      str:
          _snake_case							=				DoubleLinkedList()
          _snake_case							=				capacity
          _snake_case							=				0
          _snake_case							=				0
          _snake_case							=				0
          _snake_case							=				{}






     def __repr__(			self   )							->      str:
          return (
              f"""CacheInfo(hits={self.hits}, misses={self.miss}, """
              f"""capacity={self.capacity}, current size={self.num_keys})"""
          )






     def __contains__(			self ,_SCREAMING_SNAKE_CASE   )							->      bool:
          return key in self.cache






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE   )							->      U | None:
          # Note: pythonic interface would throw KeyError rather than return None

          if key in self.cache:
               self.hits += 1
               _snake_case							=				self.cache[key]
               _snake_case							=				self.list.remove(self.cache[key]   )
               assert node == value_node

               # node is guaranteed not None because it is in self.cache
               assert node is not None
               self.list.add(_SCREAMING_SNAKE_CASE   )
               return node.val
          self.miss += 1
          return None






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      None:

          if key not in self.cache:
               if self.num_keys >= self.capacity:
                    # delete first node (oldest) when over capacity
                    _snake_case							=				self.list.head.next

                    # guaranteed to have a non-None first node when num_keys > 0
                    # explain to type checker via assertions
                    assert first_node is not None
                    assert first_node.key is not None
                    assert (
                        self.list.remove(_SCREAMING_SNAKE_CASE   ) is not None
                    )  # node guaranteed to be in list assert node.key is not None

                    del self.cache[first_node.key]
                    self.num_keys -= 1
               _snake_case							=				DoubleLinkedListNode(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )
               self.list.add(self.cache[key]   )
               self.num_keys += 1

          else:
               # bump node to the end of the list, update value
               _snake_case							=				self.list.remove(self.cache[key]   )
               assert node is not None  # node guaranteed to be in list
               _snake_case							=				value
               self.list.add(_SCREAMING_SNAKE_CASE   )






     @classmethod
     def     _lowercase     (			cls ,_SCREAMING_SNAKE_CASE = 128   )							->      Callable[[Callable[[T], U]], Callable[..., U]]:

          def cache_decorator_inner(_SCREAMING_SNAKE_CASE   ) -> Callable[..., U]:
               def cache_decorator_wrapper(*_SCREAMING_SNAKE_CASE   ) -> U:
                    if func not in cls.decorator_function_to_instance_map:
                         _snake_case							=				LRUCache(_SCREAMING_SNAKE_CASE   )

                    _snake_case							=				cls.decorator_function_to_instance_map[func].get(args[0]   )
                    if result is None:
                         _snake_case							=				func(*_SCREAMING_SNAKE_CASE   )
                         cls.decorator_function_to_instance_map[func].put(args[0] ,_SCREAMING_SNAKE_CASE   )
                    return result

               def cache_info() -> LRUCache[T, U]:
                    return cls.decorator_function_to_instance_map[func]

               setattr(_SCREAMING_SNAKE_CASE ,"cache_info" ,_SCREAMING_SNAKE_CASE   )  # noqa: B010

               return cache_decorator_wrapper

          return cache_decorator_inner


if __name__ == "__main__":
   import doctest

   doctest.testmod()


