
"""simple docstring"""

import math
from timeit import timeit




def 			lowercase__  (    lowerCAmelCase :    int       )       ->					int:






    """simple docstring"""




    UpperCAmelCase  	=    0
    UpperCAmelCase  	=    abs(lowerCAmelCase       )
    while True:
        UpperCAmelCase  	=    n // 10
        digits += 1
        if n == 0:
            break
    return digits




def 			lowercase__  (    lowerCAmelCase :    int       )       ->					int:






    """simple docstring"""




    return 1 if n == 0 else math.floor(math.log(abs(lowerCAmelCase       )       , 10       ) + 1       )




def 			lowercase__  (    lowerCAmelCase :    int       )       ->					int:






    """simple docstring"""




    return len(str(abs(lowerCAmelCase       )       )       )




def 			lowercase__  (    )       ->					None:






    """simple docstring"""




    from collections.abc import Callable

    def benchmark_a_function(lowerCAmelCase :    Callable       , lowerCAmelCase :    int       ) -> None:
        UpperCAmelCase  	=    F"{func.__name__}({value})"
        UpperCAmelCase  	=    timeit(F"__main__.{call}"       , setup='import __main__'       )
        print(F"{call}: {func(lowerCAmelCase       )} -- {timing} seconds"       )

    for value in (262_144, 1_125_899_906_842_624, 1_267_650_600_228_229_401_496_703_205_376):
        for func in (num_digits, num_digits_fast, num_digits_faster):
            benchmark_a_function(lowerCAmelCase       , lowerCAmelCase       )
        print()


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   benchmark()










import importlib
import inspect
import json
import os
from collections import OrderedDict

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...image_processing_utils import ImageProcessingMixin
from ...tokenization_utils import TOKENIZER_CONFIG_FILE
from ...utils import FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)
from .feature_extraction_auto import AutoFeatureExtractor
from .image_processing_auto import AutoImageProcessor
from .tokenization_auto import AutoTokenizer


lowerCAmelCase_        =			logging.get_logger(__name__)

lowerCAmelCase_        =			OrderedDict(
    [
        ("""align""", """AlignProcessor"""),
        ("""altclip""", """AltCLIPProcessor"""),
        ("""bark""", """BarkProcessor"""),
        ("""blip""", """BlipProcessor"""),
        ("""blip-2""", """Blip2Processor"""),
        ("""bridgetower""", """BridgeTowerProcessor"""),
        ("""chinese_clip""", """ChineseCLIPProcessor"""),
        ("""clap""", """ClapProcessor"""),
        ("""clip""", """CLIPProcessor"""),
        ("""clipseg""", """CLIPSegProcessor"""),
        ("""flava""", """FlavaProcessor"""),
        ("""git""", """GitProcessor"""),
        ("""groupvit""", """CLIPProcessor"""),
        ("""hubert""", """Wav2Vec2Processor"""),
        ("""instructblip""", """InstructBlipProcessor"""),
        ("""layoutlmv2""", """LayoutLMv2Processor"""),
        ("""layoutlmv3""", """LayoutLMv3Processor"""),
        ("""markuplm""", """MarkupLMProcessor"""),
        ("""mctct""", """MCTCTProcessor"""),
        ("""mgp-str""", """MgpstrProcessor"""),
        ("""oneformer""", """OneFormerProcessor"""),
        ("""owlvit""", """OwlViTProcessor"""),
        ("""pix2struct""", """Pix2StructProcessor"""),
        ("""sam""", """SamProcessor"""),
        ("""sew""", """Wav2Vec2Processor"""),
        ("""sew-d""", """Wav2Vec2Processor"""),
        ("""speech_to_text""", """Speech2TextProcessor"""),
        ("""speech_to_text_2""", """Speech2Text2Processor"""),
        ("""speecht5""", """SpeechT5Processor"""),
        ("""trocr""", """TrOCRProcessor"""),
        ("""tvlt""", """TvltProcessor"""),
        ("""unispeech""", """Wav2Vec2Processor"""),
        ("""unispeech-sat""", """Wav2Vec2Processor"""),
        ("""vilt""", """ViltProcessor"""),
        ("""vision-text-dual-encoder""", """VisionTextDualEncoderProcessor"""),
        ("""wav2vec2""", """Wav2Vec2Processor"""),
        ("""wav2vec2-conformer""", """Wav2Vec2Processor"""),
        ("""wavlm""", """Wav2Vec2Processor"""),
        ("""whisper""", """WhisperProcessor"""),
        ("""xclip""", """XCLIPProcessor"""),
    ]
)

lowerCAmelCase_        =			_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)


def 			lowerCamelCase_		(					lowerCAmelCase:		str )->						Tuple:
  for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
    if class_name in processors:
      _snake_case      : Optional[Any]														=		model_type_to_module_name(lowerCAmelCase )

      _snake_case      : Tuple														=		importlib.import_module(F""".{module_name}"""			,							'transformers.models' )
      try:
        return getattr(lowerCAmelCase			,							lowerCAmelCase )
      except AttributeError:
        continue

  for processor in PROCESSOR_MAPPING._extra_content.values():
    if getattr(lowerCAmelCase			,							'__name__'			,							lowerCAmelCase ) == class_name:
      return processor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
  _snake_case      : Union[str, Any]														=		importlib.import_module('transformers' )
  if hasattr(lowerCAmelCase			,							lowerCAmelCase ):
    return getattr(lowerCAmelCase			,							lowerCAmelCase )

  return None







class 				_lowerCAmelCase			:


  '''simple docstring'''







  def __init__(					self					:    Optional[Any]							):


    '''simple docstring'''





    raise EnvironmentError(
        'AutoProcessor is designed to be instantiated '
        'using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method.'							)







  @classmethod
  @replace_list_option_in_docstrings(UpperCamelCase							)
  def UpperCamelCase_       (					cls					:    Optional[Any]					, UpperCamelCase					:    Optional[Any]					, **UpperCamelCase					:    Dict							):


    '''simple docstring'''





    _snake_case      : Optional[int]														=		kwargs.pop('config'					, UpperCamelCase							)
    _snake_case      : str														=		kwargs.pop('trust_remote_code'					, UpperCamelCase							)
    _snake_case      : List[Any]														=		True

    _snake_case      : str														=		None
    _snake_case      : str														=		None

    # First, let's see if we have a preprocessor config.
    # Filter the kwargs for `get_file_from_repo`.
    _snake_case      : Dict														=		{
        key: kwargs[key] for key in inspect.signature(UpperCamelCase							).parameters.keys() if key in kwargs
    }
    # Let's start by checking whether the processor class is saved in an image processor
    _snake_case      : List[Any]														=		get_file_from_repo(
        UpperCamelCase					, UpperCamelCase					, **UpperCamelCase							)
    if preprocessor_config_file is not None:
      _snake_case							,    _snake_case      : Optional[int]														=		ImageProcessingMixin.get_image_processor_dict(UpperCamelCase					, **UpperCamelCase							)
      _snake_case      : List[str]														=		config_dict.get('processor_class'					, UpperCamelCase							)
      if "AutoProcessor" in config_dict.get('auto_map'					, {}							):
        _snake_case      : Optional[Any]														=		config_dict['auto_map']['AutoProcessor']

        # If not found, let's check whether the processor class is saved in a feature extractor config
    if preprocessor_config_file is not None and processor_class is None:
      _snake_case							,    _snake_case      : Union[str, Any]														=		FeatureExtractionMixin.get_feature_extractor_dict(UpperCamelCase					, **UpperCamelCase							)
      _snake_case      : int														=		config_dict.get('processor_class'					, UpperCamelCase							)
      if "AutoProcessor" in config_dict.get('auto_map'					, {}							):
        _snake_case      : str														=		config_dict['auto_map']['AutoProcessor']

    if processor_class is None:
      # Next, let's check whether the processor class is saved in a tokenizer
      _snake_case      : Union[str, Any]														=		get_file_from_repo(
          UpperCamelCase					, UpperCamelCase					, **UpperCamelCase							)
      if tokenizer_config_file is not None:
        with open(UpperCamelCase					, encoding='utf-8'							) as reader:
          _snake_case      : Optional[int]														=		json.load(UpperCamelCase							)

        _snake_case      : int														=		config_dict.get('processor_class'					, UpperCamelCase							)
        if "AutoProcessor" in config_dict.get('auto_map'					, {}							):
          _snake_case      : str														=		config_dict['auto_map']['AutoProcessor']

    if processor_class is None:
      # Otherwise, load config, if it can be loaded.
      if not isinstance(UpperCamelCase					, UpperCamelCase							):
        _snake_case      : Dict														=		AutoConfig.from_pretrained(
            UpperCamelCase					, trust_remote_code=UpperCamelCase					, **UpperCamelCase							)

      # And check if the config contains the processor class.
      _snake_case      : str														=		getattr(UpperCamelCase					, 'processor_class'					, UpperCamelCase							)
      if hasattr(UpperCamelCase					, 'auto_map'							) and "AutoProcessor" in config.auto_map:
        _snake_case      : Any														=		config.auto_map['AutoProcessor']

    if processor_class is not None:
      _snake_case      : Tuple														=		processor_class_from_name(UpperCamelCase							)

    _snake_case      : int														=		processor_auto_map is not None
    _snake_case      : Optional[int]														=		processor_class is not None or type(UpperCamelCase							) in PROCESSOR_MAPPING
    _snake_case      : Union[str, Any]														=		resolve_trust_remote_code(
        UpperCamelCase					, UpperCamelCase					, UpperCamelCase					, UpperCamelCase							)

    if has_remote_code and trust_remote_code:
      _snake_case      : List[str]														=		get_class_from_dynamic_module(
          UpperCamelCase					, UpperCamelCase					, **UpperCamelCase							)
      _snake_case      : Optional[Any]														=		kwargs.pop('code_revision'					, UpperCamelCase							)
      if os.path.isdir(UpperCamelCase							):
        processor_class.register_for_auto_class()
      return processor_class.from_pretrained(
          UpperCamelCase					, trust_remote_code=UpperCamelCase					, **UpperCamelCase							)
    elif processor_class is not None:
      return processor_class.from_pretrained(
          UpperCamelCase					, trust_remote_code=UpperCamelCase					, **UpperCamelCase							)
    # Last try: we use the PROCESSOR_MAPPING.
    elif type(UpperCamelCase							) in PROCESSOR_MAPPING:
      return PROCESSOR_MAPPING[type(UpperCamelCase							)].from_pretrained(UpperCamelCase					, **UpperCamelCase							)

    # At this stage, there doesn't seem to be a `Processor` class available for this model, so let's try a
    # tokenizer.
    try:
      return AutoTokenizer.from_pretrained(
          UpperCamelCase					, trust_remote_code=UpperCamelCase					, **UpperCamelCase							)
    except Exception:
      try:
        return AutoImageProcessor.from_pretrained(
            UpperCamelCase					, trust_remote_code=UpperCamelCase					, **UpperCamelCase							)
      except Exception:
        pass

      try:
        return AutoFeatureExtractor.from_pretrained(
            UpperCamelCase					, trust_remote_code=UpperCamelCase					, **UpperCamelCase							)
      except Exception:
        pass

    raise ValueError(
        f"""Unrecognized processing class in {pretrained_model_name_or_path}. Can't instantiate a processor, a """
        'tokenizer, an image processor or a feature extractor for this model. Make sure the repository contains'
        'the files of at least one of those processing classes.'							)







  @staticmethod
  def UpperCamelCase_       (					UpperCamelCase					:    int					, UpperCamelCase					:    str							):


    '''simple docstring'''





    PROCESSOR_MAPPING.register(UpperCamelCase					, UpperCamelCase							)




