"""simple docstring"""



from __future__ import annotations

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

_UpperCamelCase         =		TypeVar("T")
_UpperCamelCase         =		TypeVar("U")
class 	__UpperCAmelCase						(Generic[T, U]    ):







			'''simple docstring'''





			def __init__( self      ,			snake_case_      ,			snake_case_       ):







										'''simple docstring'''


										A__					:    Optional[Any]														= key
										A__					:    Any														= val
										A__					:    int														= 0
										A__					:    DoubleLinkedListNode[T, U] | None														= None
										A__					:    DoubleLinkedListNode[T, U] | None														= None





			def __repr__( self       ):







										'''simple docstring'''


										return "Node: key: {}, val: {}, freq: {}, has next: {}, has prev: {}".format(
										    self.key      ,			self.val      ,			self.freq      ,			self.next is not None      ,			self.prev is not None       )





class 	__UpperCAmelCase						(Generic[T, U]    ):







			'''simple docstring'''





			def __init__( self       ):







										'''simple docstring'''


										A__					:    DoubleLinkedListNode[T, U]														= DoubleLinkedListNode(snake_case_      ,			snake_case_       )
										A__					:    DoubleLinkedListNode[T, U]														= DoubleLinkedListNode(snake_case_      ,			snake_case_       )
										A__					:    List[str]														= self.rear, self.head





			def __repr__( self       ):







										'''simple docstring'''


										A__					:    int														= ["""DoubleLinkedList"""]
										A__					:    Tuple														= self.head
										while node.next is not None:
																	rep.append(str(snake_case_       )       )
																	A__					:    Optional[Any]														= node.next
										rep.append(str(self.rear       )       )
										return ",\n    ".join(snake_case_       )





			def 		lowerCamelCase				( self      ,			snake_case_       ):







										'''simple docstring'''


										A__					:    Optional[Any]														= self.rear.prev

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

										A__					:    str														= node
										A__					:    str														= previous
										A__					:    Optional[Any]														= node
										A__					:    int														= self.rear
										node.freq += 1
										self._position_node(snake_case_       )





			def 		lowerCamelCase				( self      ,			snake_case_       ):







										'''simple docstring'''


										while node.prev is not None and node.prev.freq > node.freq:
																	# swap node with previous node
																	A__					:    List[Any]														= node.prev

																	A__					:    Dict														= previous_node.prev
																	A__					:    Optional[Any]														= node.prev
																	A__					:    int														= previous_node
																	A__					:    Optional[int]														= node





			def 		lowerCamelCase				( self      ,			snake_case_       ):







										'''simple docstring'''


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

										A__					:    int														= node.next
										A__					:    Any														= node.prev
										A__					:    Optional[int]														= None
										A__					:    Union[str, Any]														= None
										return node





class 	__UpperCAmelCase						(Generic[T, U]    ):







			'''simple docstring'''
			_UpperCamelCase     :	dict[Callable[[T], U], LFUCache[T, U]]				    =							{}





			def __init__( self      ,			snake_case_       ):







										'''simple docstring'''


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





			def __repr__( self       ):







										'''simple docstring'''


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





			def __contains__( self      ,			snake_case_       ):







										'''simple docstring'''


										return key in self.cache





			def 		lowerCamelCase				( self      ,			snake_case_       ):







										'''simple docstring'''


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





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_       ):







										'''simple docstring'''


										if key not in self.cache:
																	if self.num_keys >= self.capacity:
																								# delete first node when over capacity
																								A__					:    Optional[Any]														= 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(snake_case_       ) is not None
																								# first_node guaranteed to be in list

																								del self.cache[first_node.key]
																								self.num_keys -= 1
																	A__					:    str														= DoubleLinkedListNode(snake_case_      ,			snake_case_       )
																	self.list.add(self.cache[key]       )
																	self.num_keys += 1

										else:
																	A__					:    List[str]														= self.list.remove(self.cache[key]       )
																	assert node is not None  # node guaranteed to be in list
																	A__					:    Union[str, Any]														= value
																	self.list.add(snake_case_       )





			@classmethod
			def 		lowerCamelCase				( cls      ,			snake_case_ = 128       ):







										'''simple docstring'''


										def cache_decorator_inner(snake_case_       ) -> Callable[..., U]:
																	def cache_decorator_wrapper(*snake_case_       ) -> U:
																								if func not in cls.decorator_function_to_instance_map:
																															A__					:    Any														= LFUCache(snake_case_       )

																								A__					:    Optional[Any]														= cls.decorator_function_to_instance_map[func].get(args[0]       )
																								if result is None:
																															A__					:    str														= func(*snake_case_       )
																															cls.decorator_function_to_instance_map[func].put(args[0]      ,			snake_case_       )
																								return result

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

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

																	return cache_decorator_wrapper

										return cache_decorator_inner


if __name__ == "__main__":
				import doctest

				doctest.testmod()






"""simple docstring"""



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


_UpperCamelCase         =		logging.get_logger(__name__)

_UpperCamelCase         =		{
    "facebook/opt-125m": "https://huggingface.co/facebook/opt-125m/blob/main/config.json",
    "facebook/opt-350m": "https://huggingface.co/facebook/opt-350m/blob/main/config.json",
    "facebook/opt-1.3b": "https://huggingface.co/facebook/opt-1.3b/blob/main/config.json",
    "facebook/opt-2.7b": "https://huggingface.co/facebook/opt-2.7b/blob/main/config.json",
    "facebook/opt-6.7b": "https://huggingface.co/facebook/opt-6.7b/blob/main/config.json",
    "facebook/opt-13b": "https://huggingface.co/facebook/opt-13b/blob/main/config.json",
}
class 	__UpperCAmelCase						(__A    ):







			'''simple docstring'''
			_UpperCamelCase     :	Dict				    =							'opt'
			_UpperCamelCase     :	Optional[Any]				    =							['past_key_values']





			def __init__( self      ,			snake_case_=50_272      ,			snake_case_=768      ,			snake_case_=12      ,			snake_case_=3_072      ,			snake_case_=2_048      ,			snake_case_=True      ,			snake_case_=False      ,			snake_case_=None      ,			snake_case_=0.1      ,			snake_case_=0.0      ,			snake_case_=12      ,			snake_case_="relu"      ,			snake_case_=0.0      ,			snake_case_=0.02      ,			snake_case_=True      ,			snake_case_=1      ,			snake_case_=2      ,			snake_case_=2      ,			snake_case_=True      ,			snake_case_=True      ,			**snake_case_      ,			):







										'''simple docstring'''


										super().__init__(
										    pad_token_id=snake_case_      ,			bos_token_id=snake_case_      ,			eos_token_id=snake_case_      ,			**snake_case_      ,			)
										A__					:    int														= vocab_size
										A__					:    List[str]														= max_position_embeddings
										A__					:    str														= num_attention_heads
										A__					:    Dict														= word_embed_proj_dim if word_embed_proj_dim is not None else hidden_size
										A__					:    Optional[int]														= ffn_dim
										A__					:    Optional[int]														= hidden_size
										A__					:    int														= num_hidden_layers
										A__					:    str														= dropout
										A__					:    Tuple														= attention_dropout
										A__					:    Optional[Any]														= activation_function
										A__					:    Any														= init_std
										A__					:    Optional[int]														= layerdrop
										A__					:    Optional[int]														= use_cache
										A__					:    int														= do_layer_norm_before
										# We keep these variables at `True` for backward compatibility.
										A__					:    str														= enable_bias
										A__					:    List[str]														= layer_norm_elementwise_affine

										# Note that the only purpose of `_remove_final_layer_norm` is to keep backward compatibility
										# with checkpoints that have been fine-tuned before transformers v4.20.1
										# see https://github.com/facebookresearch/metaseq/pull/164
										A__					:    str														= _remove_final_layer_norm





