





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


lowercase_          =		logging.get_logger(__name__)

lowercase_          =		{"""openai-gpt""": """https://huggingface.co/openai-gpt/resolve/main/config.json"""}
class     SCREAMING_SNAKE_CASE       (UpperCAmelCase				):
   _UpperCamelCase   :		Tuple			 =	'openai-gpt'
   _UpperCamelCase   :		Any			 =	{
       'max_position_embeddings': 'n_positions',
       'hidden_size': 'n_embd',
       'num_attention_heads': 'n_head',
       'num_hidden_layers': 'n_layer',
   }


   def __init__(   self      :    Optional[int]      ,					a      :    int=40_478      ,					a      :    Any=512      ,					a      :    Optional[int]=768      ,					a      :    List[str]=12      ,					a      :    List[str]=12      ,					a      :    str="gelu"      ,					a      :    List[str]=0.1      ,					a      :    str=0.1      ,					a      :    Union[str, Any]=0.1      ,					a      :    Tuple=1E-5      ,					a      :    Tuple=0.02      ,					a      :    Optional[int]="cls_index"      ,					a      :    Optional[int]=True      ,					a      :    Union[str, Any]=None      ,					a      :    int=True      ,					a      :    Any=0.1      ,					**a      :    Dict      ,					)->       Union[str, Any]:





     """simple docstring"""







     lowercase__           =  vocab_size
     lowercase__           =  n_positions
     lowercase__           =  n_embd
     lowercase__           =  n_layer
     lowercase__           =  n_head
     lowercase__           =  afn
     lowercase__           =  resid_pdrop
     lowercase__           =  embd_pdrop
     lowercase__           =  attn_pdrop
     lowercase__           =  layer_norm_epsilon
     lowercase__           =  initializer_range
     lowercase__           =  summary_type
     lowercase__           =  summary_use_proj
     lowercase__           =  summary_activation
     lowercase__           =  summary_first_dropout
     lowercase__           =  summary_proj_to_labels
     super().__init__(**a	)









from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

lowercase_          =		TypeVar("""KEY""")
lowercase_          =		TypeVar("""VAL""")
@dataclass(frozen=UpperCAmelCase      ,     slots=UpperCAmelCase				)
class     SCREAMING_SNAKE_CASE       (Generic[KEY, VAL]				):
   _UpperCamelCase   :		KEY
   _UpperCamelCase   :		VAL






class     SCREAMING_SNAKE_CASE       (_Item				):


   def __init__(   self      :    Optional[int]	)->       None:





     """simple docstring"""







     super().__init__(a      ,					a	)


   def __bool__(   self      :    str	)->       bool:





     """simple docstring"""







     return False






lowercase_          =		_DeletedItem()
class     SCREAMING_SNAKE_CASE       (MutableMapping[KEY, VAL]				):


   def __init__(   self      :    Tuple      ,					a      :    int = 8      ,					a      :    float = 0.75	)->       None:





     """simple docstring"""







     lowercase__           =  initial_block_size
     lowercase__           =  [None] * initial_block_size
     assert 0.0 < capacity_factor < 1.0
     lowercase__           =  capacity_factor
     lowercase__           =  0


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Any      ,					a      :    KEY	)->       int:





     """simple docstring"""







     return hash(a	) % len(self._buckets	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[Any]      ,					a      :    int	)->       int:





     """simple docstring"""







     return (ind + 1) % len(self._buckets	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Any      ,					a      :    int      ,					a      :    KEY      ,					a      :    VAL	)->       bool:





     """simple docstring"""







     lowercase__           =  self._buckets[ind]
     if not stored:
       lowercase__           =  _Item(a      ,					a	)
       self._len += 1
       return True
     elif stored.key == key:
       lowercase__           =  _Item(a      ,					a	)
       return True
     else:
       return False


   def 	SCREAMING_SNAKE_CASE_							(   self      :    str	)->       bool:





     """simple docstring"""







     lowercase__           =  len(self._buckets	) * self._capacity_factor
     return len(self	) >= int(a	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Tuple	)->       bool:





     """simple docstring"""







     if len(self._buckets	) <= self._initial_block_size:
       return False
     lowercase__           =  len(self._buckets	) * self._capacity_factor / 2
     return len(self	) < limit


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[str]      ,					a      :    int	)->       None:





     """simple docstring"""







     lowercase__           =  self._buckets
     lowercase__           =  [None] * new_size
     lowercase__           =  0
     for item in old_buckets:
       if item:
         self._add_item(item.key      ,					item.val	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[int]	)->       None:





     """simple docstring"""







     self._resize(len(self._buckets	) * 2	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[int]	)->       None:





     """simple docstring"""







     self._resize(len(self._buckets	) // 2	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Any      ,					a      :    KEY	)->       Iterator[int]:





     """simple docstring"""







     lowercase__           =  self._get_bucket_index(a	)
     for _ in range(len(self._buckets	)	):
       yield ind
       lowercase__           =  self._get_next_ind(a	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Tuple      ,					a      :    KEY      ,					a      :    VAL	)->       None:





     """simple docstring"""







     for ind in self._iterate_buckets(a	):
       if self._try_set(a      ,					a      ,					a	):
         break


   def __setitem__(   self      :    List[Any]      ,					a      :    KEY      ,					a      :    VAL	)->       None:





     """simple docstring"""







     if self._is_full():
       self._size_up()

     self._add_item(a      ,					a	)


   def __delitem__(   self      :    str      ,					a      :    KEY	)->       None:





     """simple docstring"""







     for ind in self._iterate_buckets(a	):
       lowercase__           =  self._buckets[ind]
       if item is None:
         raise KeyError(a	)
       if item is _deleted:
         continue
       if item.key == key:
         lowercase__           =  _deleted
         self._len -= 1
         break
     if self._is_sparse():
       self._size_down()


   def __getitem__(   self      :    List[str]      ,					a      :    KEY	)->       VAL:





     """simple docstring"""







     for ind in self._iterate_buckets(a	):
       lowercase__           =  self._buckets[ind]
       if item is None:
         break
       if item is _deleted:
         continue
       if item.key == key:
         return item.val
     raise KeyError(a	)


   def __len__(   self      :    Tuple	)->       int:





     """simple docstring"""







     return self._len


   def __iter__(   self      :    int	)->       Iterator[KEY]:





     """simple docstring"""







     yield from (item.key for item in self._buckets if item)


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





     """simple docstring"""







     lowercase__           =  ' ,'.join(
         f"""{item.key}: {item.val}""" for item in self._buckets if item	)
     return f"""HashMap({val_string})"""


