




from __future__ import annotations

import sys
from collections import deque
from typing import Generic, TypeVar

_lowerCamelCase			:	Tuple							 =     TypeVar("""T""")


class        UpperCamelCase_					(				Generic[T]  ):

    '''simple docstring'''






    UpperCAmelCase__													=   42  # Cache store of keys
    UpperCAmelCase__													=   42  # References of the keys in cache
    UpperCAmelCase__													=   10  # Maximum capacity of cache


    def __init__(    self   :			List[Any]      ,				UpperCAmelCase__   :			int)		->None:





           '''simple docstring'''

           A__   				=					deque()
           A__   				=					set()
           if not n:
                  A__   				=					sys.maxsize
           elif n < 0:
                  raise ValueError('''n should be an integer greater than 0.''')
           else:
                  A__   				=					n


    def  SCREAMING_SNAKE_CASE							(    self   :			Optional[Any]      ,				UpperCAmelCase__   :			T)		->None:





           '''simple docstring'''

           if x not in self.key_reference:
                  if len(self.dq_store) == LRUCache._MAX_CAPACITY:
                         A__   				=					self.dq_store.pop()
                         self.key_reference.remove(UpperCAmelCase__)
           else:
                  self.dq_store.remove(UpperCAmelCase__)

           self.dq_store.appendleft(UpperCAmelCase__)
           self.key_reference.add(UpperCAmelCase__)


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





           '''simple docstring'''

           for k in self.dq_store:
                  print(UpperCAmelCase__)





    def __repr__(    self   :			Optional[Any])		->str:





           '''simple docstring'''

           return f"""LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store)}"""


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  _lowerCamelCase			:	LRUCache[str | int]							 =     LRUCache(4)
  lru_cache.refer("""A""")
  lru_cache.refer(2)
  lru_cache.refer(3)
  lru_cache.refer("""A""")
  lru_cache.refer(4)
  lru_cache.refer(5)
  lru_cache.display()

  print(lru_cache)
  assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"








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


_lowerCamelCase			:	Tuple							 =     logging.get_logger(__name__)

_lowerCamelCase			:	Tuple							 =     {
    """tiiuae/falcon-40b""": """https://huggingface.co/tiiuae/falcon-40b/resolve/main/config.json""",
    """tiiuae/falcon-7b""": """https://huggingface.co/tiiuae/falcon-7b/resolve/main/config.json""",
}


class        UpperCamelCase_					(				UpperCAmelCase__  ):

    '''simple docstring'''






    UpperCAmelCase__													=   '''falcon'''
    UpperCAmelCase__													=   ['''past_key_values''']


    def __init__(    self   :			Optional[Any]      ,				UpperCAmelCase__   :			str=65_024      ,				UpperCAmelCase__   :			List[Any]=4_544      ,				UpperCAmelCase__   :			Optional[Any]=32      ,				UpperCAmelCase__   :			Dict=71      ,				UpperCAmelCase__   :			Any=1e-5      ,				UpperCAmelCase__   :			Optional[int]=0.02      ,				UpperCAmelCase__   :			Optional[int]=True      ,				UpperCAmelCase__   :			Union[str, Any]=0.0      ,				UpperCAmelCase__   :			List[str]=0.0      ,				UpperCAmelCase__   :			str=None      ,				UpperCAmelCase__   :			Dict=False      ,				UpperCAmelCase__   :			List[str]=False      ,				UpperCAmelCase__   :			Optional[Any]=True      ,				UpperCAmelCase__   :			Optional[Any]=True      ,				UpperCAmelCase__   :			Optional[Any]=False      ,				UpperCAmelCase__   :			Dict=11      ,				UpperCAmelCase__   :			str=11      ,				**UpperCAmelCase__   :			Dict      ,				)		->Any:





           '''simple docstring'''

           A__   				=					vocab_size
           # Backward compatibility with n_embed kwarg
           A__   				=					kwargs.pop('''n_embed'''      ,				UpperCAmelCase__)
           A__   				=					hidden_size if n_embed is None else n_embed
           A__   				=					num_hidden_layers
           A__   				=					num_attention_heads
           A__   				=					layer_norm_epsilon
           A__   				=					initializer_range
           A__   				=					use_cache
           A__   				=					hidden_dropout
           A__   				=					attention_dropout

           A__   				=					bos_token_id
           A__   				=					eos_token_id
           A__   				=					num_attention_heads if num_kv_heads is None else num_kv_heads
           A__   				=					alibi
           A__   				=					new_decoder_architecture
           A__   				=					multi_query  # Ignored when new_decoder_architecture is True
           A__   				=					parallel_attn
           A__   				=					bias

           super().__init__(bos_token_id=UpperCAmelCase__      ,				eos_token_id=UpperCAmelCase__      ,				**UpperCAmelCase__)


    @property
    def  SCREAMING_SNAKE_CASE							(    self   :			str)		->int:





           '''simple docstring'''

           return self.hidden_size // self.num_attention_heads





    @property
    def  SCREAMING_SNAKE_CASE							(    self   :			str)		->Dict:





           '''simple docstring'''

           return not self.alibi


