





import json
import os
import pickle
import subprocess
from hashlib import mda
from pathlib import Path
from tempfile import gettempdir
from textwrap import dedent
from types import CodeType, FunctionType
from unittest import TestCase
from unittest.mock import patch

import pytest
from multiprocess import Pool
from packaging import version

import datasets
from datasets.fingerprint import Hasher, fingerprint_transform
from datasets.table import InMemoryTable

from .utils import (
    require_regex,
    require_spacy,
    require_spacy_model,
    require_tiktoken,
    require_torch,
    require_transformers,
)







class 		_lowerCAmelCase:

  """simple docstring"""







  def __init__(   self    ,							UpperCAmelCase      )->   Tuple:
     __A    =  foo





  def __call__(   self      )->   Optional[int]:
     return self.foo







class 		_lowerCAmelCase(		datasets.Dataset):

  """simple docstring"""







  @fingerprint_transform(inplace=A_      )
  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							*UpperCAmelCase    ,							**UpperCAmelCase      )->   List[Any]:
     return DatasetChild(self.data    ,							fingerprint=A_      )





  @fingerprint_transform(inplace=A_      )
  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							*UpperCAmelCase    ,							**UpperCAmelCase      )->   Any:
     return DatasetChild(self.data    ,							fingerprint=A_      )







class 		_lowerCAmelCase:

  """simple docstring"""







  def __init__(   self    ,							UpperCAmelCase      )->   Optional[Any]:
     __A    =  callable

  def __call__(   self    ,							*UpperCAmelCase    ,							**UpperCAmelCase      )->   Any:
     if self.callable is not None:
        return self.callable(*A_    ,							**A_      )





  def __getstate__(   self      )->   int:
     raise pickle.PicklingError()







class 		_lowerCAmelCase(		__lowercase):

  """simple docstring"""







  @require_transformers
  @pytest.mark.integration
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   int:
     from transformers import AutoTokenizer

     def encode(UpperCAmelCase      ):
        return tokenizer(A_      )

     # TODO: add hash consistency tests across sessions
     __A    =  AutoTokenizer.from_pretrained('''bert-base-uncased'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  mda(datasets.utils.py_utils.dumps(lambda UpperCAmelCase      : tokenizer(A_      )      )      ).hexdigest()
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  AutoTokenizer.from_pretrained('''bert-base-cased'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  mda(datasets.utils.py_utils.dumps(lambda UpperCAmelCase      : tokenizer(A_      )      )      ).hexdigest()
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  AutoTokenizer.from_pretrained('''bert-base-uncased'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  mda(datasets.utils.py_utils.dumps(lambda UpperCAmelCase      : tokenizer(A_      )      )      ).hexdigest()
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )

  @require_transformers
  @pytest.mark.integration
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   str:
     from transformers import AutoTokenizer

     __A    =  AutoTokenizer.from_pretrained('''gpt2'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     tokenizer('''Hello world !'''      )  # call once to change the tokenizer's cache
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )





  @require_regex
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   List[str]:
     import regex

     __A    =  regex.Regex('''foo'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  regex.Regex('''bar'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  regex.Regex('''foo'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )







class 		_lowerCAmelCase(		__lowercase):

  """simple docstring"""







  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Tuple:
     def func():
        return foo

     __A    =  [0]
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  [1]
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  [0]
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[Any]:
     def func():
        pass

     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()

     def func():
        pass

     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[Any]:
     __A    =  mda(datasets.utils.py_utils.dumps(Foo([0]      )      )      ).hexdigest()
     __A    =  mda(datasets.utils.py_utils.dumps(Foo([1]      )      )      ).hexdigest()
     __A    =  mda(datasets.utils.py_utils.dumps(Foo([0]      )      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Tuple:
     __A    =  mda(datasets.utils.py_utils.dumps(Foo([0]      ).__call__      )      ).hexdigest()
     __A    =  mda(datasets.utils.py_utils.dumps(Foo([1]      ).__call__      )      ).hexdigest()
     __A    =  mda(datasets.utils.py_utils.dumps(Foo([0]      ).__call__      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[Any]:
     __A    =  (
         '''co_argcount''',
         '''co_kwonlyargcount''',
         '''co_nlocals''',
         '''co_stacksize''',
         '''co_flags''',
         '''co_code''',
         '''co_consts''',
         '''co_names''',
         '''co_varnames''',
         '''co_filename''',
         '''co_name''',
         '''co_firstlineno''',
         '''co_lnotab''',
         '''co_freevars''',
         '''co_cellvars''',
     )

     def _create_code_pyaa(*UpperCAmelCase      ):
        if hasattr(args[-3]    ,							'''encode'''      ):
           __A    =  list(A_      )
           __A    =  args[-3].encode()  # co_lnotab
           __A    =  args[-10].encode()  # co_code
        if hasattr(A_    ,							'''co_posonlyargcount'''      ):
           if len(A_      ) == 16:
              return CodeType(*A_      )
           elif len(A_      ) == 15:
              return CodeType(args[0]    ,							0    ,							*args[1:]      )
           return CodeType(args[0]    ,							0    ,							0    ,							*args[1:]      )
        elif hasattr(A_    ,							'''co_kwonlyargcount'''      ):
           if len(A_      ) == 16:
              return CodeType(args[0]    ,							*args[2:]      )
           elif len(A_      ) == 15:
              return CodeType(*A_      )
           return CodeType(args[0]    ,							0    ,							*args[1:]      )
        if len(A_      ) == 16:
           return CodeType(args[0]    ,							*args[3:]      )
        elif len(A_      ) == 15:
           return CodeType(args[0]    ,							*args[2:]      )
        return CodeType(*A_      )

     def create_ipython_func(UpperCAmelCase    ,							UpperCAmelCase      ):
        def func():
           return returned_obj

        __A    =  func.__code__
        # Use _create_code from dill in order to make it work for different python versions
        if datasets.config.PY_VERSION < version.parse('''3.8'''      ):
           __A    =  _create_code_pyaa(
               *[getattr(A_    ,							A_      ) if k != '''co_filename''' else co_filename for k in code_args_pyaa]      )
        else:
           __A    =  code.replace(co_filename=A_      )
        return FunctionType(A_    ,							func.__globals__    ,							func.__name__    ,							func.__defaults__    ,							func.__closure__      )

     __A   ,		__A    =  '''<ipython-input-2-e0383a102aae>''', [0]
     __A    =  mda(datasets.utils.py_utils.dumps(create_ipython_func(A_    ,							A_      )      )      ).hexdigest()
     __A   ,		__A    =  '''<ipython-input-2-e0383a102aae>''', [1]
     __A    =  mda(datasets.utils.py_utils.dumps(create_ipython_func(A_    ,							A_      )      )      ).hexdigest()
     __A   ,		__A    =  '''<ipython-input-5-713f6613acf3>''', [0]
     __A    =  mda(datasets.utils.py_utils.dumps(create_ipython_func(A_    ,							A_      )      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )

     __A   ,		__A    =  os.path.join(gettempdir()    ,							'''ipykernel_12345'''    ,							'''321456789.py'''      ), [0]
     __A    =  mda(datasets.utils.py_utils.dumps(create_ipython_func(A_    ,							A_      )      )      ).hexdigest()
     __A   ,		__A    =  os.path.join(gettempdir()    ,							'''ipykernel_12345'''    ,							'''321456789.py'''      ), [1]
     __A    =  mda(datasets.utils.py_utils.dumps(create_ipython_func(A_    ,							A_      )      )      ).hexdigest()
     __A   ,		__A    =  os.path.join(gettempdir()    ,							'''ipykernel_12345'''    ,							'''654123987.py'''      ), [0]
     __A    =  mda(datasets.utils.py_utils.dumps(create_ipython_func(A_    ,							A_      )      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )





  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Tuple:
     __A   ,		__A    =  [0], [1]

     def func():
        return foo, bar

     __A    =  '''__main__'''

     def globalvars_mocka_side_effect(UpperCAmelCase    ,							*UpperCAmelCase    ,							**UpperCAmelCase      ):
        return {"foo": foo, "bar": bar}

     def globalvars_mocka_side_effect(UpperCAmelCase    ,							*UpperCAmelCase    ,							**UpperCAmelCase      ):
        return {"bar": bar, "foo": foo}

     with patch('''dill.detect.globalvars'''    ,							side_effect=A_      ) as globalvars_mocka:
        __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
        self.assertGreater(globalvars_mocka.call_count    ,							0      )
     with patch('''dill.detect.globalvars'''    ,							side_effect=A_      ) as globalvars_mocka:
        __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
        self.assertGreater(globalvars_mocka.call_count    ,							0      )
     self.assertEqual(A_    ,							A_      )







class 		_lowerCAmelCase(		__lowercase):

  """simple docstring"""







  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Union[str, Any]:
     __A    =  Hasher.hash('''hello'''      )
     __A    =  Hasher.hash('''hello'''      )
     __A    =  Hasher.hash('''there'''      )
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[Any]:
     __A    =  Hasher.hash(Foo('''hello'''      )      )
     __A    =  Hasher.hash(Foo('''hello'''      )      )
     __A    =  Hasher.hash(Foo('''there'''      )      )
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   str:
     __A    =  Hasher()
     for x in ["hello", Foo('''hello'''      )]:
        hasher.update(A_      )
     __A    =  hasher.hexdigest()
     __A    =  Hasher()
     for x in ["hello", Foo('''hello'''      )]:
        hasher.update(A_      )
     __A    =  hasher.hexdigest()
     __A    =  Hasher()
     for x in ["there", Foo('''there'''      )]:
        hasher.update(A_      )
     __A    =  hasher.hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[Any]:
     with self.assertRaises(pickle.PicklingError      ):
        Hasher.hash(UnpicklableCallable(Foo('''hello'''      )      )      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Union[str, Any]:
     __A    =  '''abc'''
     __A    =  [string, string]  # two strings have the same ids
     __A    =  [string, string]
     __A    =  json.loads(f"[\"{string}\", \"{string}\"]"      )  # two strings have different ids
     self.assertIs(obja[0]    ,							A_      )
     self.assertIs(obja[0]    ,							obja[1]      )
     self.assertIs(obja[0]    ,							A_      )
     self.assertIs(obja[0]    ,							obja[1]      )
     self.assertIsNot(obja[0]    ,							A_      )
     self.assertIsNot(obja[0]    ,							obja[1]      )
     __A    =  Hasher.hash(A_      )
     __A    =  Hasher.hash(A_      )
     __A    =  Hasher.hash(A_      )
     self.assertEqual(A_    ,							A_      )
     self.assertEqual(A_    ,							A_      )

  @require_tiktoken
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Dict:
     import tiktoken

     __A    =  tiktoken.get_encoding('''gpt2'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  tiktoken.get_encoding('''r50k_base'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  tiktoken.get_encoding('''gpt2'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )

  @require_torch
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   List[str]:
     import torch

     __A    =  torch.tensor([1.0]      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  torch.tensor([2.0]      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  torch.tensor([1.0]      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )





  @require_spacy
  @require_spacy_model('''en_core_web_sm'''      )
  @require_spacy_model('''fr_core_news_sm'''      )
  @pytest.mark.integration
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[int]:
     import spacy

     __A    =  spacy.load('''en_core_web_sm'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  spacy.load('''fr_core_news_sm'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     __A    =  spacy.load('''en_core_web_sm'''      )
     __A    =  mda(datasets.utils.py_utils.dumps(A_      )      ).hexdigest()
     self.assertEqual(A_    ,							A_      )
     self.assertNotEqual(A_    ,							A_      )
@pytest.mark.integration
def  __UpperCamelCase    (						snake_case      )    ->		Dict:


   '''simple docstring'''







   __A    =  tmp_path / '''dir1'''
   __A    =  tmp_path / '''dir2'''
   dira.mkdir()
   dira.mkdir()
   __A    =  '''script.py'''
   __A    =  dedent(
       '''
    from datasets.fingerprint import Hasher
    def foo():
        pass
    print(Hasher.hash(foo))
    '''      )
   __A    =  dira / script_filename
   __A    =  dira / script_filename
   with script_patha.open('''w'''      ) as f:
      f.write(__UpperCAmelCase      )
   with script_patha.open('''w'''      ) as f:
      f.write(__UpperCAmelCase      )
   __A    =  subprocess.check_output(['''python''', str(__UpperCAmelCase      )]      )
   __A    =  subprocess.check_output(['''python''', str(__UpperCAmelCase      )]      )
   assert fingerprinta == fingerprinta
def  __UpperCamelCase    (						)    ->		Optional[Any]:


   '''simple docstring'''







   __A    =  {'''a''': [0, 1, 2]}
   __A    =  DatasetChild(InMemoryTable.from_pydict(__UpperCAmelCase      )      )
   __A    =  dataset.funca()._fingerprint
   assert expected_fingerprint == dataset.funca()._fingerprint
   assert expected_fingerprint != dataset.funca()._fingerprint

   with Pool(2      ) as p:
      assert expected_fingerprint == p.apply_async(dataset.funca      ).get()._fingerprint
      assert expected_fingerprint != p.apply_async(dataset.funca      ).get()._fingerprint
def  __UpperCamelCase    (						)    ->		Optional[int]:


   '''simple docstring'''







   __A    =  {'''a''': [0, 1, 2]}







   class 		_lowerCAmelCase(		datasets.Dataset):

     """simple docstring"""







     @fingerprint_transform(inplace=A_      )
     def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase      )->   Any:
        return DummyDatasetChild(self.data    ,							fingerprint=A_      )
   __A    =  DummyDatasetChild(InMemoryTable.from_pydict(__UpperCAmelCase      )      ).func()







   class 		_lowerCAmelCase(		datasets.Dataset):

     """simple docstring"""







     @fingerprint_transform(inplace=A_    ,							version='''1.0.0'''      )
     def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase      )->   Dict:
        return DummyDatasetChild(self.data    ,							fingerprint=A_      )
   __A    =  DummyDatasetChild(InMemoryTable.from_pydict(__UpperCAmelCase      )      ).func()







   class 		_lowerCAmelCase(		datasets.Dataset):

     """simple docstring"""







     @fingerprint_transform(inplace=A_    ,							version='''2.0.0'''      )
     def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase      )->   Optional[Any]:
        return DummyDatasetChild(self.data    ,							fingerprint=A_      )
   __A    =  DummyDatasetChild(InMemoryTable.from_pydict(__UpperCAmelCase      )      ).func()

   assert len({fingeprint_no_version, fingeprint_a, fingeprint_a}      ) == 3
def  __UpperCamelCase    (						)    ->		Dict:


   '''simple docstring'''







   __A    =  Hasher()
   hasher.update(lambda snake_case      : x      )


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


snake_case__						      =			logging.get_logger(__name__)

snake_case__						      =			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'),
    ]
)

snake_case__						      =			_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)
def    __magic_name__(	__UpperCAmelCase		)    ->     List[str]:



      '''simple docstring'''

      for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
            if class_name in processors:
                  _lowerCamelCase           =					model_type_to_module_name(__UpperCAmelCase		)

                  _lowerCamelCase           =					importlib.import_module(F'.{module_name}'			,    '''transformers.models'''		)
                  try:
                        return getattr(__UpperCAmelCase			,    __UpperCAmelCase		)
                  except AttributeError:
                        continue

      for processor in PROCESSOR_MAPPING._extra_content.values():
            if getattr(__UpperCAmelCase			,    '''__name__'''			,    __UpperCAmelCase		) == 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.
      _lowerCamelCase           =					importlib.import_module('''transformers'''		)
      if hasattr(__UpperCAmelCase			,    __UpperCAmelCase		):
            return getattr(__UpperCAmelCase			,    __UpperCAmelCase		)

      return None




class 			UpperCamelCase					:

     '''simple docstring'''

     def __init__(       self    )			->					List[str]:






           """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(A_    )
     def 		UpperCamelCase_    (       cls					,					A_					,					**A_    )			->					List[Any]:






           """simple docstring"""
           _lowerCamelCase           =					kwargs.pop('''config'''					,					A_    )
           _lowerCamelCase           =					kwargs.pop('''trust_remote_code'''					,					A_    )
           _lowerCamelCase           =					True

           _lowerCamelCase           =					None
           _lowerCamelCase           =					None

           # First, let's see if we have a preprocessor config.
           # Filter the kwargs for `get_file_from_repo`.
           _lowerCamelCase           =					{
               key: kwargs[key] for key in inspect.signature(A_    ).parameters.keys() if key in kwargs
           }
           # Let's start by checking whether the processor class is saved in an image processor
           _lowerCamelCase           =					get_file_from_repo(
               A_					,					A_					,					**A_    )
           if preprocessor_config_file is not None:
                 _lowerCamelCase     ,       _lowerCamelCase           =					ImageProcessingMixin.get_image_processor_dict(A_					,					**A_    )
                 _lowerCamelCase           =					config_dict.get('''processor_class'''					,					A_    )
                 if "AutoProcessor" in config_dict.get('''auto_map'''					,					{}    ):
                       _lowerCamelCase           =					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:
                 _lowerCamelCase     ,       _lowerCamelCase           =					FeatureExtractionMixin.get_feature_extractor_dict(A_					,					**A_    )
                 _lowerCamelCase           =					config_dict.get('''processor_class'''					,					A_    )
                 if "AutoProcessor" in config_dict.get('''auto_map'''					,					{}    ):
                       _lowerCamelCase           =					config_dict['''auto_map''']['''AutoProcessor''']

           if processor_class is None:
                 # Next, let's check whether the processor class is saved in a tokenizer
                 _lowerCamelCase           =					get_file_from_repo(
                     A_					,					A_					,					**A_    )
                 if tokenizer_config_file is not None:
                       with open(A_					,					encoding='''utf-8'''    ) as reader:
                             _lowerCamelCase           =					json.load(A_    )

                       _lowerCamelCase           =					config_dict.get('''processor_class'''					,					A_    )
                       if "AutoProcessor" in config_dict.get('''auto_map'''					,					{}    ):
                             _lowerCamelCase           =					config_dict['''auto_map''']['''AutoProcessor''']

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

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

           if processor_class is not None:
                 _lowerCamelCase           =					processor_class_from_name(A_    )

           _lowerCamelCase           =					processor_auto_map is not None
           _lowerCamelCase           =					processor_class is not None or type(A_    ) in PROCESSOR_MAPPING
           _lowerCamelCase           =					resolve_trust_remote_code(
               A_					,					A_					,					A_					,					A_    )

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

           # 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(
                     A_					,					trust_remote_code=A_					,					**A_    )
           except Exception:
                 try:
                       return AutoImageProcessor.from_pretrained(
                           A_					,					trust_remote_code=A_					,					**A_    )
                 except Exception:
                       pass

                 try:
                       return AutoFeatureExtractor.from_pretrained(
                           A_					,					trust_remote_code=A_					,					**A_    )
                 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_    (       A_					,					A_    )			->					List[Any]:






           """simple docstring"""
           PROCESSOR_MAPPING.register(A_					,					A_    )