

'''simple docstring'''






import colorsys
import io

import cva
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import numpy as np
import torch
from matplotlib.backends.backend_agg import FigureCanvasAgg

from utils import img_tensorize


snake_case_       =       1_0_0_0
class 	SCREAMING_SNAKE_CASE__			:




    def __init__(					self				,     lowercase__				,     lowercase__=1.2				,     lowercase__="g"				,     lowercase__=0.5				,     lowercase__="-"				,     lowercase__="test_out.jpg"				,     lowercase__=True				,     lowercase__=False				,     lowercase__=None				,     lowercase__=None				,     lowercase__=0.7				,     ):






          """simple docstring"""






          if isinstance(lowercase__				,     torch.Tensor			):
                SCREAMING_SNAKE_CASE_      :			str     =       img.numpy().astype("np.uint8"			)
          if isinstance(lowercase__				,     lowercase__			):
                SCREAMING_SNAKE_CASE_      :			List[str]     =       img_tensorize(lowercase__			)
          assert isinstance(lowercase__				,     np.ndarray			)

          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_      :			Dict     =       img.shape[1], img.shape[0]
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       mplfigure.Figure(frameon=lowercase__			)
          SCREAMING_SNAKE_CASE_      :			List[str]     =       fig.get_dpi()
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       (width * scale + 1e-2) / dpi
          SCREAMING_SNAKE_CASE_      :			List[str]     =       (height * scale + 1e-2) / dpi
          fig.set_size_inches(lowercase__				,     lowercase__			)
          SCREAMING_SNAKE_CASE_      :			Tuple     =       fig.add_axes([0.0, 0.0, 1.0, 1.0]			)
          ax.axis("off"			)
          ax.set_xlim(0.0				,     lowercase__			)
          ax.set_ylim(lowercase__			)

          SCREAMING_SNAKE_CASE_      :			List[str]     =       saveas
          SCREAMING_SNAKE_CASE_      :			str     =       rgb
          SCREAMING_SNAKE_CASE_      :			str     =       pynb
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       img
          SCREAMING_SNAKE_CASE_      :			Dict     =       edgecolor
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       0.5
          SCREAMING_SNAKE_CASE_      :			int     =       linestyle
          SCREAMING_SNAKE_CASE_      :			str     =       int(np.sqrt(min(lowercase__				,     lowercase__			)			) * scale // 3			)
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       width
          SCREAMING_SNAKE_CASE_      :			Dict     =       height
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       scale
          SCREAMING_SNAKE_CASE_      :			Dict     =       fig
          SCREAMING_SNAKE_CASE_      :			List[str]     =       ax
          SCREAMING_SNAKE_CASE_      :			List[str]     =       pad
          SCREAMING_SNAKE_CASE_      :			Any     =       idaobj
          SCREAMING_SNAKE_CASE_      :			List[str]     =       idaattr
          SCREAMING_SNAKE_CASE_      :			List[str]     =       FigureCanvasAgg(lowercase__			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__=None			):






          """simple docstring"""






          if color is None:
                SCREAMING_SNAKE_CASE_      :			Dict     =       self.edgecolor
          ((SCREAMING_SNAKE_CASE_),						(SCREAMING_SNAKE_CASE_),						(SCREAMING_SNAKE_CASE_),						(SCREAMING_SNAKE_CASE_))      :			List[str]     =       box
          SCREAMING_SNAKE_CASE_      :			Tuple     =       xa - xa
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       ya - ya
          self.ax.add_patch(
              mpl.patches.Rectangle(
                  (xa, ya)				,     lowercase__				,     lowercase__				,     fill=lowercase__				,     edgecolor=lowercase__				,     linewidth=self.font_size // 3				,     alpha=self.alpha				,     linestyle=self.linestyle				,     )			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None			):






          """simple docstring"""






          if len(boxes.shape			) > 2:
                SCREAMING_SNAKE_CASE_      :			List[str]     =       boxes[0]
          if len(obj_ids.shape			) > 1:
                SCREAMING_SNAKE_CASE_      :			int     =       obj_ids[0]
          if len(obj_scores.shape			) > 1:
                SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       obj_scores[0]
          if len(attr_ids.shape			) > 1:
                SCREAMING_SNAKE_CASE_      :			List[str]     =       attr_ids[0]
          if len(attr_scores.shape			) > 1:
                SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       attr_scores[0]
          if isinstance(lowercase__				,     torch.Tensor			):
                SCREAMING_SNAKE_CASE_      :			int     =       boxes.numpy()
          if isinstance(lowercase__				,     lowercase__			):
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       np.array(lowercase__			)
          assert isinstance(lowercase__				,     np.ndarray			)
          SCREAMING_SNAKE_CASE_      :			int     =       np.prod(boxes[:, 2:] - boxes[:, :2]				,     axis=1			)
          SCREAMING_SNAKE_CASE_      :			List[str]     =       np.argsort(-areas			).tolist()
          SCREAMING_SNAKE_CASE_      :			List[str]     =       boxes[sorted_idxs] if boxes is not None else None
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       obj_ids[sorted_idxs] if obj_ids is not None else None
          SCREAMING_SNAKE_CASE_      :			int     =       obj_scores[sorted_idxs] if obj_scores is not None else None
          SCREAMING_SNAKE_CASE_      :			List[str]     =       attr_ids[sorted_idxs] if attr_ids is not None else None
          SCREAMING_SNAKE_CASE_      :			int     =       attr_scores[sorted_idxs] if attr_scores is not None else None

          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       [self._random_color(maximum=1			) for _ in range(len(lowercase__			)			)]
          SCREAMING_SNAKE_CASE_      :			Tuple     =       [assigned_colors[idx] for idx in sorted_idxs]
          if obj_ids is not None:
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       self._create_text_labels_attr(lowercase__				,     lowercase__				,     lowercase__				,     lowercase__			)
                for i in range(len(lowercase__			)			):
                      SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       assigned_colors[i]
                      self.add_box(boxes[i]				,     lowercase__			)
                      self.draw_labels(labels[i]				,     boxes[i]				,     lowercase__			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_      :			Optional[int]     =       box
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       (xa, ya)
          SCREAMING_SNAKE_CASE_      :			Dict     =       (ya - ya) * (xa - xa)
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       _SMALL_OBJ * self.scale
          if instance_area < small or ya - ya < 40 * self.scale:
                if ya >= self.height - 5:
                      SCREAMING_SNAKE_CASE_      :			Optional[int]     =       (xa, ya)
                else:
                      SCREAMING_SNAKE_CASE_      :			Optional[int]     =       (xa, ya)

          SCREAMING_SNAKE_CASE_      :			List[Any]     =       (ya - ya) / np.sqrt(self.height * self.width			)
          SCREAMING_SNAKE_CASE_      :			Dict     =       self._change_color_brightness(lowercase__				,     brightness_factor=0.7			)
          SCREAMING_SNAKE_CASE_      :			List[str]     =       np.clip((height_ratio - 0.02) / 0.08 + 1				,     1.2				,     2			)
          font_size *= 0.75 * self.font_size

          self.draw_text(
              text=lowercase__				,     position=lowercase__				,     color=lowercase__				,     )




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__				,     lowercase__="g"				,     lowercase__="left"				,     ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       0
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       self.font_size
          SCREAMING_SNAKE_CASE_      :			str     =       np.maximum(list(mplc.to_rgb(lowercase__			)			)				,     0.2			)
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       max(0.8				,     np.max(lowercase__			)			)
          SCREAMING_SNAKE_CASE_      :			List[str]     =       {
              "facecolor": "black",
              "alpha": self.alpha,
              "pad": self.pad,
              "edgecolor": "none",
          }
          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       position
          self.ax.text(
              lowercase__				,     lowercase__				,     lowercase__				,     size=font_size * self.scale				,     family="sans-serif"				,     bbox=lowercase__				,     verticalalignment="top"				,     horizontalalignment=lowercase__				,     color=lowercase__				,     zorder=10				,     rotation=lowercase__				,     )




    def   __lowerCamelCase      (					self				,     lowercase__=None			):






          """simple docstring"""






          if saveas is None:
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       self.saveas
          if saveas.lower().endswith(".jpg"			) or saveas.lower().endswith(".png"			):
                cva.imwrite(
                    lowercase__				,     self._get_buffer()[:, :, ::-1]				,     )
          else:
                self.fig.savefig(lowercase__			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       [self.idaobj[i] for i in classes]
          SCREAMING_SNAKE_CASE_      :			Dict     =       [self.idaattr[i] for i in attr_classes]
          SCREAMING_SNAKE_CASE_      :			str     =       [
              F"{label} {score:.2f} {attr} {attr_score:.2f}"
              for label, score, attr, attr_score in zip(lowercase__				,     lowercase__				,     lowercase__				,     lowercase__			)
          ]
          return labels




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Dict     =       [self.idaobj[i] for i in classes]
          if scores is not None:
                if labels is None:
                      SCREAMING_SNAKE_CASE_      :			List[str]     =       ["{:.0f}%".format(s * 100			) for s in scores]
                else:
                      SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       ["{} {:.0f}%".format(lowercase__				,     s * 100			) for li, s in zip(lowercase__				,     lowercase__			)]
          return labels




    def   __lowerCamelCase      (					self				,     lowercase__=255			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Tuple     =       np.random.randint(0				,     len(_COLORS			)			)
          SCREAMING_SNAKE_CASE_      :			int     =       _COLORS[idx] * maximum
          if not self.rgb:
                SCREAMING_SNAKE_CASE_      :			List[str]     =       ret[::-1]
          return ret




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          if not self.pynb:
                SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_      :			Optional[int]     =       self.canvas.print_to_buffer()
                if (width, height) != (self.width, self.height):
                      SCREAMING_SNAKE_CASE_      :			str     =       cva.resize(self.img				,     (width, height)			)
                else:
                      SCREAMING_SNAKE_CASE_      :			str     =       self.img
          else:
                SCREAMING_SNAKE_CASE_      :			List[str]     =       io.BytesIO()  # works for cairo backend
                self.canvas.print_rgba(lowercase__			)
                SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       self.width, self.height
                SCREAMING_SNAKE_CASE_      :			Dict     =       buf.getvalue()
                SCREAMING_SNAKE_CASE_      :			Dict     =       self.img

          SCREAMING_SNAKE_CASE_      :			Tuple     =       np.frombuffer(lowercase__				,     dtype="uint8"			)
          SCREAMING_SNAKE_CASE_      :			int     =       buffer.reshape(lowercase__				,     lowercase__				,     4			)
          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_      :			List[Any]     =       np.split(lowercase__				,     [3]				,     axis=2			)

          try:
                import numexpr as ne  # fuse them with numexpr

                SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       ne.evaluate("img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)"			)
          except ImportError:
                SCREAMING_SNAKE_CASE_      :			int     =       alpha.astype("float32"			) / 255.0
                SCREAMING_SNAKE_CASE_      :			List[str]     =       img * (1 - alpha) + rgb * alpha

          return visualized_image.astype("uint8"			)







    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          assert brightness_factor >= -1.0 and brightness_factor <= 1.0
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       mplc.to_rgb(lowercase__			)
          SCREAMING_SNAKE_CASE_      :			Tuple     =       colorsys.rgb_to_hls(*mplc.to_rgb(lowercase__			)			)
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       polygon_color[1] + (brightness_factor * polygon_color[1])
          SCREAMING_SNAKE_CASE_      :			Any     =       0.0 if modified_lightness < 0.0 else modified_lightness
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       1.0 if modified_lightness > 1.0 else modified_lightness
          SCREAMING_SNAKE_CASE_      :			Dict     =       colorsys.hls_to_rgb(polygon_color[0]				,     lowercase__				,     polygon_color[2]			)
          return modified_color






snake_case_       =       (
    np.array(
        [
            0.0_0_0,
            0.4_4_7,
            0.7_4_1,
            0.8_5_0,
            0.3_2_5,
            0.0_9_8,
            0.9_2_9,
            0.6_9_4,
            0.1_2_5,
            0.4_9_4,
            0.1_8_4,
            0.5_5_6,
            0.4_6_6,
            0.6_7_4,
            0.1_8_8,
            0.3_0_1,
            0.7_4_5,
            0.9_3_3,
            0.6_3_5,
            0.0_7_8,
            0.1_8_4,
            0.3_0_0,
            0.3_0_0,
            0.3_0_0,
            0.6_0_0,
            0.6_0_0,
            0.6_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.5_0_0,
            0.0_0_0,
            0.7_4_9,
            0.7_4_9,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.6_6_7,
            0.0_0_0,
            1.0_0_0,
            0.3_3_3,
            0.3_3_3,
            0.0_0_0,
            0.3_3_3,
            0.6_6_7,
            0.0_0_0,
            0.3_3_3,
            1.0_0_0,
            0.0_0_0,
            0.6_6_7,
            0.3_3_3,
            0.0_0_0,
            0.6_6_7,
            0.6_6_7,
            0.0_0_0,
            0.6_6_7,
            1.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.3_3_3,
            0.0_0_0,
            1.0_0_0,
            0.6_6_7,
            0.0_0_0,
            1.0_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.3_3_3,
            0.5_0_0,
            0.0_0_0,
            0.6_6_7,
            0.5_0_0,
            0.0_0_0,
            1.0_0_0,
            0.5_0_0,
            0.3_3_3,
            0.0_0_0,
            0.5_0_0,
            0.3_3_3,
            0.3_3_3,
            0.5_0_0,
            0.3_3_3,
            0.6_6_7,
            0.5_0_0,
            0.3_3_3,
            1.0_0_0,
            0.5_0_0,
            0.6_6_7,
            0.0_0_0,
            0.5_0_0,
            0.6_6_7,
            0.3_3_3,
            0.5_0_0,
            0.6_6_7,
            0.6_6_7,
            0.5_0_0,
            0.6_6_7,
            1.0_0_0,
            0.5_0_0,
            1.0_0_0,
            0.0_0_0,
            0.5_0_0,
            1.0_0_0,
            0.3_3_3,
            0.5_0_0,
            1.0_0_0,
            0.6_6_7,
            0.5_0_0,
            1.0_0_0,
            1.0_0_0,
            0.5_0_0,
            0.0_0_0,
            0.3_3_3,
            1.0_0_0,
            0.0_0_0,
            0.6_6_7,
            1.0_0_0,
            0.0_0_0,
            1.0_0_0,
            1.0_0_0,
            0.3_3_3,
            0.0_0_0,
            1.0_0_0,
            0.3_3_3,
            0.3_3_3,
            1.0_0_0,
            0.3_3_3,
            0.6_6_7,
            1.0_0_0,
            0.3_3_3,
            1.0_0_0,
            1.0_0_0,
            0.6_6_7,
            0.0_0_0,
            1.0_0_0,
            0.6_6_7,
            0.3_3_3,
            1.0_0_0,
            0.6_6_7,
            0.6_6_7,
            1.0_0_0,
            0.6_6_7,
            1.0_0_0,
            1.0_0_0,
            1.0_0_0,
            0.0_0_0,
            1.0_0_0,
            1.0_0_0,
            0.3_3_3,
            1.0_0_0,
            1.0_0_0,
            0.6_6_7,
            1.0_0_0,
            0.3_3_3,
            0.0_0_0,
            0.0_0_0,
            0.5_0_0,
            0.0_0_0,
            0.0_0_0,
            0.6_6_7,
            0.0_0_0,
            0.0_0_0,
            0.8_3_3,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.1_6_7,
            0.0_0_0,
            0.0_0_0,
            0.3_3_3,
            0.0_0_0,
            0.0_0_0,
            0.5_0_0,
            0.0_0_0,
            0.0_0_0,
            0.6_6_7,
            0.0_0_0,
            0.0_0_0,
            0.8_3_3,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.1_6_7,
            0.0_0_0,
            0.0_0_0,
            0.3_3_3,
            0.0_0_0,
            0.0_0_0,
            0.5_0_0,
            0.0_0_0,
            0.0_0_0,
            0.6_6_7,
            0.0_0_0,
            0.0_0_0,
            0.8_3_3,
            0.0_0_0,
            0.0_0_0,
            1.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.0_0_0,
            0.1_4_3,
            0.1_4_3,
            0.1_4_3,
            0.8_5_7,
            0.8_5_7,
            0.8_5_7,
            1.0_0_0,
            1.0_0_0,
            1.0_0_0,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)








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							)




