code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  from collections import OrderedDict
  from typing import Mapping
  
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfigWithPast
  from ...utils import logging
  
  
  _lowerCamelCase				:	int				    =       logging.get_logger(__name__)
  
  _lowerCamelCase				:	Optional[Any]				    =       {
      'uclanlp/plbart-base': 'https://huggingface.co/uclanlp/plbart-base/resolve/main/config.json',
      # See all PLBART models at https://huggingface.co/models?filter=plbart
  }
  
  
  
  class 							__UpperCAmelCase  (       A_						):
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowerCAmelCase 				=    '''plbart'''
  		__lowerCAmelCase 				=    ['''past_key_values''']
  		__lowerCAmelCase 				=    {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}
  
  
  
  
  
  
  
  		def __init__(self						:      List[Any]      ,      _lowerCAmelCase						:      int=5_0005      ,      _lowerCAmelCase						:      Tuple=1024      ,      _lowerCAmelCase						:      Optional[int]=6      ,      _lowerCAmelCase						:      Any=3072      ,      _lowerCAmelCase						:      Any=12      ,      _lowerCAmelCase						:      List[str]=6      ,      _lowerCAmelCase						:      Any=3072      ,      _lowerCAmelCase						:      Optional[int]=12      ,      _lowerCAmelCase						:      Any=0.0      ,      _lowerCAmelCase						:      Optional[Any]=0.0      ,      _lowerCAmelCase						:      str=True      ,      _lowerCAmelCase						:      List[Any]=True      ,      _lowerCAmelCase						:      List[str]="gelu"      ,      _lowerCAmelCase						:      List[Any]=768      ,      _lowerCAmelCase						:      Tuple=0.1      ,      _lowerCAmelCase						:      Optional[Any]=0.1      ,      _lowerCAmelCase						:      int=0.0      ,      _lowerCAmelCase						:      Any=0.02      ,      _lowerCAmelCase						:      int=0.0      ,      _lowerCAmelCase						:      Dict=True      ,      _lowerCAmelCase						:      Any=1      ,      _lowerCAmelCase						:      Optional[Any]=0      ,      _lowerCAmelCase						:      List[str]=2      ,      _lowerCAmelCase						:      Optional[Any]=2      ,      **_lowerCAmelCase						:      int      ,      ):
  			A							  =      vocab_size
  			A							  =      max_position_embeddings
  			A							  =      d_model
  			A							  =      encoder_ffn_dim
  			A							  =      encoder_layers
  			A							  =      encoder_attention_heads
  			A							  =      decoder_ffn_dim
  			A							  =      decoder_layers
  			A							  =      decoder_attention_heads
  			A							  =      dropout
  			A							  =      attention_dropout
  			A							  =      activation_dropout
  			A							  =      activation_function
  			A							  =      init_std
  			A							  =      encoder_layerdrop
  			A							  =      decoder_layerdrop
  			A							  =      classifier_dropout
  			A							  =      use_cache
  			A							  =      encoder_layers
  			A							  =      scale_embedding  # scale factor will be sqrt(d_model) if True
  			super().__init__(
  			    pad_token_id=_lowerCAmelCase      ,      bos_token_id=_lowerCAmelCase      ,      eos_token_id=_lowerCAmelCase      ,      is_encoder_decoder=_lowerCAmelCase      ,      forced_eos_token_id=_lowerCAmelCase      ,      **_lowerCAmelCase      ,      )
  
  
  
  
  
  
  class 							__UpperCAmelCase  (       A_						):
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		@property
  		def        A     (self						:      Optional[int]      ):
  			return OrderedDict(
  			    [
  			        ("""input_ids""", {0: """batch""", 1: """sequence"""}),
  			        ("""attention_mask""", {0: """batch""", 1: """sequence"""}),
  			    ]      )
  
  
  
  
  
  
  
  		@property
  		def        A     (self						:      Tuple      ):
  
  
  
  			if self.use_past:
  				return OrderedDict(
  				    [
  				        ("""last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  				        ("""past_keys""", {0: """batch""", 2: """sequence"""}),
  				        ("""encoder_last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  				    ]      )
  			else:
  				return OrderedDict(
  				    [
  				        ("""last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  				        ("""encoder_last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  				    ]      )
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  class 							__UpperCAmelCase  :
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def __init__(self						:      List[str]      ):
  			# numbermap keys are the number and its values are lists of indexes sorted
  			# in ascending order
  			A							  =      {}
  			# indexmap keys are an index and it's values are the number at that index
  			A							  =      {}
  
  
  
  
  
  
  
  		def        A     (self						:      Union[str, Any]      ,      _lowerCAmelCase						:      list | str | range      ,      _lowerCAmelCase						:      int      ):
  			if isinstance(_lowerCAmelCase      ,      (range, str)      ):
  				A							  =      list(_lowerCAmelCase      )
  			elif not isinstance(_lowerCAmelCase      ,      _lowerCAmelCase      ):
  				raise TypeError(
  				    """binary_search_delete() only accepts either a list, range or str"""      )
  
  			A							  =      0
  			A							  =      len(_lowerCAmelCase      ) - 1
  
  			while low <= high:
  				A							  =      (low + high) // 2
  				if array[mid] == item:
  					array.pop(_lowerCAmelCase      )
  					return array
  				elif array[mid] < item:
  					A							  =      mid + 1
  				else:
  					A							  =      mid - 1
  			raise ValueError(
  			    """Either the item is not in the array or the array was unsorted"""      )
  
  
  
  
  
  
  
  		def        A     (self						:      Dict      ,      _lowerCAmelCase						:      list | str | range      ,      _lowerCAmelCase						:      int      ):
  			if isinstance(_lowerCAmelCase      ,      (range, str)      ):
  				A							  =      list(_lowerCAmelCase      )
  			elif not isinstance(_lowerCAmelCase      ,      _lowerCAmelCase      ):
  				raise TypeError(
  				    """binary_search_insert() only accepts either a list, range or str"""      )
  
  			A							  =      0
  			A							  =      len(_lowerCAmelCase      ) - 1
  
  			while low <= high:
  				A							  =      (low + high) // 2
  				if array[mid] == index:
  					# If the item already exists in the array,
  					# insert it after the existing item
  					array.insert(mid + 1      ,      _lowerCAmelCase      )
  					return array
  				elif array[mid] < index:
  					A							  =      mid + 1
  				else:
  					A							  =      mid - 1
  
          # If the item doesn't exist in the array, insert it at the appropriate position
  			array.insert(_lowerCAmelCase      ,      _lowerCAmelCase      )
  			return array
  
  
  
  
  
  
  
  		def        A     (self						:      List[str]      ,      _lowerCAmelCase						:      int      ,      _lowerCAmelCase						:      int      ):
  			# Remove previous index
  			if index in self.indexmap:
  				A							  =      self.indexmap[index]
  				if len(self.numbermap[n]      ) == 1:
  					del self.numbermap[n]
  				else:
  					A							  =      self.binary_search_delete(self.numbermap[n]      ,      _lowerCAmelCase      )
  
          # Set new index
  			A							  =      number
  
  			# Number not seen before or empty so insert number value
  			if number not in self.numbermap:
  				A							  =      [index]
  
  			# Here we need to perform a binary search insertion in order to insert
  			# The item in the correct place
  			else:
  				A							  =      self.binary_search_insert(
  				    self.numbermap[number]      ,      _lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A     (self						:      int      ,      _lowerCAmelCase						:      int      ):
  			return self.numbermap.get(_lowerCAmelCase      ,      [-1]      )[0]
  
  
  if __name__ == "__main__":
  				import doctest
  
  				doctest.testmod()
  
  