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"""
  
  
  
  
  # Lint as: python3
  
  import hashlib
  from typing import Union
  
  
  
  
  
  def 			a_   (  lowercase__   :Union[str, int, bytes]    ):
  			if isinstance(lowercase__, lowercase__    ):
  						# Data already in bytes, returns as it as
  						return hash_data
  			elif isinstance(lowercase__, lowercase__    ):
  						# We keep the data as it as for it ot be later encoded to UTF-8
  						# However replace `\\` with `/` for Windows compatibility
  						__lowerCamelCase        =			hash_data.replace("""\\""", """/"""    )
  			elif isinstance(lowercase__, lowercase__    ):
  						__lowerCamelCase        =			str(lowercase__    )
  			else:
  						# If data is not of the required type, raise error
  						raise InvalidKeyError(lowercase__    )
  
  			return hash_data.encode("""utf-8"""    )
  
  
  
  
  class  __snake_case      (lowerCamelCase     ):
  
  
  
  
  							def __init__(    self:						Union[str, Any]    ,       A_:						Tuple      ):
  										__lowerCamelCase        =			"""\nFAILURE TO GENERATE DATASET: Invalid key type detected"""
  										__lowerCamelCase        =			f'\nFound Key {hash_data} of type {type(A_      )}'
  										__lowerCamelCase        =			"""\nKeys should be either str, int or bytes type"""
  										super().__init__(f'{self.prefix}{self.err_msg}{self.suffix}'      )
  
  
  
  
  class  __snake_case      (lowerCamelCase     ):
  
  
  
  
  							def __init__(    self:						Any    ,       A_:						Dict    ,       A_:						List[Any]    ,       A_:						List[str]=""      ):
  										__lowerCamelCase        =			key
  										__lowerCamelCase        =			duplicate_key_indices
  										__lowerCamelCase        =			fix_msg
  										__lowerCamelCase        =			"""Found multiple examples generated with the same key"""
  										if len(A_      ) <= 20:
  													__lowerCamelCase        =			f'\nThe examples at index {", ".join(A_      )} have the key {key}'
  										else:
  													__lowerCamelCase        =			f'\nThe examples at index {", ".join(duplicate_key_indices[:20]      )}... ({len(A_      ) - 20} more) have the key {key}'
  										__lowerCamelCase        =			"""\n""" + fix_msg if fix_msg else """"""
  										super().__init__(f'{self.prefix}{self.err_msg}{self.suffix}'      )
  
  
  
  
  class  __snake_case      :
  
  
  
  
  							def __init__(    self:						Dict    ,       A_:						str      ):
  										__lowerCamelCase        =			hashlib.mda(_as_bytes(A_      )      )
  
  
  
  
  							def      __a      (    self:						int    ,       A_:						Union[str, int, bytes]      ):
  										__lowerCamelCase        =			self._split_mda.copy()
  										__lowerCamelCase        =			_as_bytes(A_      )
  										mda.update(A_      )
  										# Convert to integer with hexadecimal conversion
  										return int(mda.hexdigest()    ,       16      )
  
  
  
  
  