code: 
  
  
  """simple docstring"""
  
  
  
  
  from ctypes import c_float, sizeof
  from enum import Enum
  from typing import TYPE_CHECKING, Optional, Union
  
  
  if TYPE_CHECKING:
  					from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore
  
  
  
  
  class  __snake_case      (lowerCamelCase     ):
  							__a				   =					c_float
  
  
  
  
  							@property
  							def      __a      (    self:						int      ):
  														return sizeof(self.value      )
  
  
  
  
  
  def 			a_   (  lowercase__   :int, lowercase__   :int, lowercase__   :int = 0    ):
  							# < 0 is possible if using a dynamic axis
  							if dimension <= 0:
  														__lowerCamelCase        =			fixed_dimension
  
  							dimension -= num_token_to_add
  							return dimension
  
  
  
  
  
  def 			a_   (  lowercase__   :int, lowercase__   :ParameterFormat    ):
  							return num_parameters * dtype.size
  
  
  
  
  
  def 			a_   (  lowercase__   :str    ):
  							from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore
  
  							try:
  														return AutoProcessor.from_pretrained(lowercase__    )
  							except (ValueError, OSError, KeyError):
  														__lowerCamelCase    ,__lowerCamelCase        =			None, None
  														try:
  																					__lowerCamelCase        =			AutoTokenizer.from_pretrained(lowercase__    )
  														except (OSError, KeyError):
  																					pass
  														try:
  																					__lowerCamelCase        =			AutoFeatureExtractor.from_pretrained(lowercase__    )
  														except (OSError, KeyError):
  																					pass
  
  														if tokenizer is not None and feature_extractor is not None:
  																					raise ValueError(
  																					    f'Couldn\'t auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor.'    )
  														elif tokenizer is None and feature_extractor is None:
  																					return None
  														elif tokenizer is not None:
  																					return tokenizer
  														else:
  																					return feature_extractor
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  import numpy as np
  
  
  
  
  
  def 			a_   (  lowercase__   :List[str]    ):
  			__lowerCamelCase        =			np.exp(lowercase__    )
  
  			# Add up the all the exponentials
  			__lowerCamelCase        =			np.sum(lowercase__    )
  
  			# Divide every exponent by the sum of all exponents
  			__lowerCamelCase        =			exponent_vector / sum_of_exponents
  
  			return softmax_vector
  
  
  if __name__ == "__main__":
  					print(softmax((0,)))
  
  
  
  
  