





'''simple docstring'''

import warnings

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase					:		Any		=							logging.get_logger(__name__)

UpperCAmelCase					:		Union[str, Any]		=							{
    'xlnet-base-cased': 'https://huggingface.co/xlnet-base-cased/resolve/main/config.json',
    'xlnet-large-cased': 'https://huggingface.co/xlnet-large-cased/resolve/main/config.json',
}





class lowerCamelCase						(a__					):
  _lowercase  :	Optional[int]       					=				"""xlnet"""
  _lowercase  :	Optional[Any]       					=				["""mems"""]
  _lowercase  :	Any       					=				{
      """n_token""": """vocab_size""",  # Backward compatibility
      """hidden_size""": """d_model""",
      """num_attention_heads""": """n_head""",
      """num_hidden_layers""": """n_layer""",
  }







  def __init__(		self     ,     lowercase__=32_000     ,     lowercase__=1_024     ,     lowercase__=24     ,     lowercase__=16     ,     lowercase__=4_096     ,     lowercase__="gelu"     ,     lowercase__=True     ,     lowercase__="bi"     ,     lowercase__=0.02     ,     lowercase__=1E-1_2     ,     lowercase__=0.1     ,     lowercase__=512     ,     lowercase__=None     ,     lowercase__=True     ,     lowercase__=False     ,     lowercase__=False     ,     lowercase__=-1     ,     lowercase__=False     ,     lowercase__="last"     ,     lowercase__=True     ,     lowercase__="tanh"     ,     lowercase__=0.1     ,     lowercase__=5     ,     lowercase__=5     ,     lowercase__=5     ,     lowercase__=1     ,     lowercase__=2     ,     **lowercase__     ,     )		->						Dict:






        """simple docstring"""





        _snake_case		:	Union[str, Any]					     =     vocab_size
        _snake_case		:	Dict					     =     d_model
        _snake_case		:	int					     =     n_layer
        _snake_case		:	Union[str, Any]					     =     n_head
        if d_model % n_head != 0:
              raise ValueError(F'''\'d_model % n_head\' ({d_model % n_head}) should be equal to 0'''		)
        if "d_head" in kwargs:
              if kwargs["d_head"] != d_model // n_head:
                    raise ValueError(
                        F'''`d_head` ({kwargs["d_head"]}) should be equal to `d_model // n_head` ({d_model // n_head})'''		)
        _snake_case		:	str					     =     d_model // n_head
        _snake_case		:	Any					     =     ff_activation
        _snake_case		:	int					     =     d_inner
        _snake_case		:	List[Any]					     =     untie_r
        _snake_case		:	Optional[int]					     =     attn_type

        _snake_case		:	Optional[Any]					     =     initializer_range
        _snake_case		:	str					     =     layer_norm_eps

        _snake_case		:	List[Any]					     =     dropout
        _snake_case		:	Any					     =     mem_len
        _snake_case		:	List[Any]					     =     reuse_len
        _snake_case		:	Union[str, Any]					     =     bi_data
        _snake_case		:	List[str]					     =     clamp_len
        _snake_case		:	Optional[int]					     =     same_length

        _snake_case		:	List[Any]					     =     summary_type
        _snake_case		:	str					     =     summary_use_proj
        _snake_case		:	Optional[Any]					     =     summary_activation
        _snake_case		:	Optional[Any]					     =     summary_last_dropout
        _snake_case		:	List[Any]					     =     start_n_top
        _snake_case		:	List[str]					     =     end_n_top

        _snake_case		:	Tuple					     =     bos_token_id
        _snake_case		:	List[Any]					     =     pad_token_id
        _snake_case		:	Optional[int]					     =     eos_token_id

        if "use_cache" in kwargs:
              warnings.warn(
                  '''The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`'''
                  ''' instead.'''     ,     lowercase__     ,     )
              _snake_case		:	Optional[int]					     =     kwargs['''use_cache''']

        _snake_case		:	int					     =     use_mems_eval
        _snake_case		:	Union[str, Any]					     =     use_mems_train
        super().__init__(pad_token_id=lowercase__     ,     bos_token_id=lowercase__     ,     eos_token_id=lowercase__     ,     **lowercase__		)







  @property
  def 				UpperCAmelCase_				(		self		)		->						List[Any]:






        """simple docstring"""





        logger.info(F'''The model {self.model_type} is one of the few models that has no sequence length limit.'''		)
        return -1







  @max_position_embeddings.setter
  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						Optional[int]:






        """simple docstring"""





        raise NotImplementedError(
            F'''The model {self.model_type} is one of the few models that has no sequence length limit.'''		)









'''simple docstring'''

from __future__ import annotations

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

UpperCAmelCase					:		Any		=							TypeVar('T')
UpperCAmelCase					:		str		=							TypeVar('U')





class lowerCamelCase						(Generic[T, U]					):







  def __init__(		self     ,     lowercase__     ,     lowercase__		)		->						List[Any]:






        """simple docstring"""





        _snake_case		:	str					     =     key
        _snake_case		:	Optional[int]					     =     val
        _snake_case		:	DoubleLinkedListNode[T, U] | None					     =     None
        _snake_case		:	DoubleLinkedListNode[T, U] | None					     =     None







  def __repr__(		self		)		->						str:






        """simple docstring"""





        return (
            F'''Node: key: {self.key}, val: {self.val}, '''
            F'''has next: {bool(self.next		)}, has prev: {bool(self.prev		)}'''
        )





class lowerCamelCase						(Generic[T, U]					):







  def __init__(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	DoubleLinkedListNode[T, U]					     =     DoubleLinkedListNode(lowercase__     ,     lowercase__		)
        _snake_case		:	DoubleLinkedListNode[T, U]					     =     DoubleLinkedListNode(lowercase__     ,     lowercase__		)
        _snake_case     ,							_snake_case		:	Union[str, Any]					     =     self.rear, self.head







  def __repr__(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	List[Any]					     =     ['''DoubleLinkedList''']
        _snake_case		:	str					     =     self.head
        while node.next is not None:
              rep.append(str(lowercase__		)		)
              _snake_case		:	List[str]					     =     node.next
        rep.append(str(self.rear		)		)
        return ",\n    ".join(lowercase__		)







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						None:






        """simple docstring"""





        _snake_case		:	Tuple					     =     self.rear.prev

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

        _snake_case		:	Union[str, Any]					     =     node
        _snake_case		:	Optional[Any]					     =     previous
        _snake_case		:	int					     =     node
        _snake_case		:	Union[str, Any]					     =     self.rear







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						DoubleLinkedListNode[T, U] | None:






        """simple docstring"""





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

        _snake_case		:	Optional[int]					     =     node.next
        _snake_case		:	Any					     =     node.prev
        _snake_case		:	List[str]					     =     None
        _snake_case		:	Optional[int]					     =     None
        return node





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







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






        """simple docstring"""





        _snake_case		:	DoubleLinkedList[T, U]					     =     DoubleLinkedList()
        _snake_case		:	Union[str, Any]					     =     capacity
        _snake_case		:	int					     =     0
        _snake_case		:	Dict					     =     0
        _snake_case		:	Union[str, Any]					     =     0
        _snake_case		:	dict[T, DoubleLinkedListNode[T, U]]					     =     {}







  def __repr__(		self		)		->						str:






        """simple docstring"""





        return (
            F'''CacheInfo(hits={self.hits}, misses={self.miss}, '''
            F'''capacity={self.capacity}, current size={self.num_keys})'''
        )







  def __contains__(		self     ,     lowercase__		)		->						bool:






        """simple docstring"""





        return key in self.cache







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						U | None:






        """simple docstring"""





        if key in self.cache:
              self.hits += 1
              _snake_case		:	DoubleLinkedListNode[T, U]					     =     self.cache[key]
              _snake_case		:	Tuple					     =     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(lowercase__		)
              return node.val
        self.miss += 1
        return None







  def 				UpperCAmelCase_				(		self     ,     lowercase__     ,     lowercase__		)		->						None:






        """simple docstring"""





        if key not in self.cache:
              if self.num_keys >= self.capacity:
                    # delete first node (oldest) when over capacity
                    _snake_case		:	Dict					     =     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(lowercase__		) 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		:	Optional[int]					     =     DoubleLinkedListNode(lowercase__     ,     lowercase__		)
              self.list.add(self.cache[key]		)
              self.num_keys += 1

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







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






        """simple docstring"""





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

                    _snake_case		:	Union[str, Any]					     =     cls.decorator_function_to_instance_map[func].get(args[0]		)
                    if result is None:
                          _snake_case		:	Tuple					     =     func(*lowercase__		)
                          cls.decorator_function_to_instance_map[func].put(args[0]     ,     lowercase__		)
                    return result

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

              setattr(lowercase__     ,     '''cache_info'''     ,     lowercase__		)  # noqa: B010

              return cache_decorator_wrapper

        return cache_decorator_inner


if __name__ == "__main__":
   import doctest

   doctest.testmod()


