codingutf8 2022 the huggingface inc team licensed under the apache license version 2 0 the license you may not use this file except in compliance with the license you may obtain a copy of the license at http www apache orglicenseslicense2 0 unless required by applicable law or agreed to in writing software distributed under the license is distributed on an as is basis without warranties or conditions of any kind either express or implied see the license for the specific language governing permissions and limitations under the license autoimageprocessor class import importlib import json import os import warnings from collections import ordereddict from typing import dict optional union build the list of all image processors from configurationutils import pretrainedconfig from dynamicmoduleutils import getclassfromdynamicmodule resolvetrustremotecode from imageprocessingutils import imageprocessingmixin from utils import configname imageprocessorname getfilefromrepo logging from autofactory import lazyautomapping from configurationauto import configmappingnames autoconfig modeltypetomodulename replacelistoptionindocstrings logger logging getloggername imageprocessormappingnames ordereddict align efficientnetimageprocessor beit beitimageprocessor bit bitimageprocessor blip blipimageprocessor blip2 blipimageprocessor bridgetower bridgetowerimageprocessor chineseclip chineseclipimageprocessor clip clipimageprocessor clipseg vitimageprocessor conditionaldetr conditionaldetrimageprocessor convnext convnextimageprocessor convnextv2 convnextimageprocessor cvt convnextimageprocessor data2vecvision beitimageprocessor deformabledetr deformabledetrimageprocessor deit deitimageprocessor deta detaimageprocessor detr detrimageprocessor dinat vitimageprocessor dinov2 bitimageprocessor donutswin donutimageprocessor dpt dptimageprocessor efficientformer efficientformerimageprocessor efficientnet efficientnetimageprocessor flava flavaimageprocessor focalnet bitimageprocessor fuyu fuyuimageprocessor git clipimageprocessor glpn glpnimageprocessor groupvit clipimageprocessor idefics ideficsimageprocessor imagegpt imagegptimageprocessor instructblip blipimageprocessor kosmos2 clipimageprocessor layoutlmv2 layoutlmv2imageprocessor layoutlmv3 layoutlmv3imageprocessor levit levitimageprocessor mask2former mask2formerimageprocessor maskformer maskformerimageprocessor mgpstr vitimageprocessor mobilenetv1 mobilenetv1imageprocessor mobilenetv2 mobilenetv2imageprocessor mobilevit mobilevitimageprocessor mobilevit mobilevitimageprocessor mobilevitv2 mobilevitimageprocessor nat vitimageprocessor nougat nougatimageprocessor oneformer oneformerimageprocessor owlv2 owlv2imageprocessor owlvit owlvitimageprocessor perceiver perceiverimageprocessor pix2struct pix2structimageprocessor poolformer poolformerimageprocessor pvt pvtimageprocessor regnet convnextimageprocessor resnet convnextimageprocessor sam samimageprocessor segformer segformerimageprocessor swiftformer vitimageprocessor swin vitimageprocessor swin2sr swin2srimageprocessor swinv2 vitimageprocessor tabletransformer detrimageprocessor timesformer videomaeimageprocessor tvlt tvltimageprocessor tvp tvpimageprocessor upernet segformerimageprocessor van convnextimageprocessor videomae videomaeimageprocessor vilt viltimageprocessor vit vitimageprocessor vithybrid vithybridimageprocessor vitmae vitimageprocessor vitmsn vitimageprocessor vitmatte vitmatteimageprocessor xclip clipimageprocessor yolos yolosimageprocessor imageprocessormapping lazyautomappingconfigmappingnames imageprocessormappingnames def imageprocessorclassfromnameclassname str for modulename extractors in imageprocessormappingnames items if classname in extractors modulename modeltypetomodulenamemodulename module importlib importmodulef modulename transformers models try return getattrmodule classname except attributeerror continue for extractor in imageprocessormapping extracontent items if getattrextractor name none classname return extractor 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 mainmodule importlib importmoduletransformers if hasattrmainmodule classname return getattrmainmodule classname return none def getimageprocessorconfig pretrainedmodelnameorpath unionstr os pathlike cachedir optionalunionstr os pathlike none forcedownload bool false resumedownload bool false proxies optionaldictstr str none token optionalunionbool str none revision optionalstr none localfilesonly bool false kwargs download configuration from huggingface co and cache this model does not have a image processor config so the result will be an empty dict save a pretrained image processor locally and you can reload its config def initself raise environmenterror autoimageprocessor is designed to be instantiated using the autoimageprocessor frompretrainedpretrainedmodelnameorpath method classmethod replacelistoptionindocstringsimageprocessormappingnames def frompretrainedcls pretrainedmodelnameorpath kwargs r instantiate one of the image processor classes of the library from a pretrained model vocabulary the image processor class to instantiate is selected based on the modeltype property of the config object either passed as an argument or loaded from pretrainedmodelnameorpath if possible or when it s missing by falling back to using pattern matching on pretrainedmodelnameorpath list options params pretrainedmodelnameorpath str or os pathlike this can be either a string the model id of a pretrained imageprocessor hosted inside a model repo on huggingface co valid model ids can be located at the rootlevel like bertbaseuncased or namespaced under a user or organization name like dbmdzbertbasegermancased a path to a directory containing a image processor file saved using the imageprocessingutils imageprocessingmixin savepretrained method e g mymodeldirectory a path or url to a saved image processor json file e g mymodeldirectorypreprocessorconfig json cachedir str or os pathlike optional path to a directory in which a downloaded pretrained model image processor should be cached if the standard cache should not be used forcedownload bool optional defaults to false whether or not to force to redownload the image processor files and override the cached versions if they exist resumedownload bool optional defaults to false whether or not to delete incompletely received file attempts to resume the download if such a file exists proxies dictstr str optional a dictionary of proxy servers to use by protocol or endpoint e g http foo bar 3128 http hostname foo bar 4012 the proxies are used on each request token str or bool optional the token to use as http bearer ization for remote files if true will use the token generated when running huggingfacecli login stored in huggingface revision str optional defaults to main the specific model version to use it can be a branch name a tag name or a commit id since we use a gitbased system for storing models and other artifacts on huggingface co so revision can be any identifier allowed by git returnunusedkwargs bool optional defaults to false if false then this function returns just the final image processor object if true then this functions returns a tupleimageprocessor unusedkwargs where unusedkwargs is a dictionary consisting of the keyvalue pairs whose keys are not image processor attributes i e the part of kwargs which has not been used to update imageprocessor and is otherwise ignored trustremotecode bool optional defaults to false whether or not to allow for custom models defined on the hub in their own modeling files this option should only be set to true for repositories you trust and in which you have read the code as it will execute code present on the hub on your local machine kwargs dictstr any optional the values in kwargs of any keys which are image processor attributes will be used to override the loaded values behavior concerning keyvalue pairs whose keys are not image processor attributes is controlled by the returnunusedkwargs keyword parameter tip passing tokentrue is required when you want to use a private model tip examples python from transformers import autoimageprocessor download image processor from huggingface co and cache imageprocessor autoimageprocessor frompretrainedgooglevitbasepatch16224in21k if image processor files are in a directory e g image processor was saved using savepretrained testsavedmodel imageprocessor autoimageprocessor frompretrained testsavedmodel useauthtoken kwargs popuseauthtoken none if useauthtoken is not none warnings warn the useauthtoken argument is deprecated and will be removed in v5 of transformers please use token instead futurewarning if kwargs gettoken none is not none raise valueerror token and useauthtoken are both specified please set only the argument token kwargstoken useauthtoken config kwargs popconfig none trustremotecode kwargs poptrustremotecode none kwargsfromauto true configdict imageprocessingmixin getimageprocessordictpretrainedmodelnameorpath kwargs imageprocessorclass configdict getimageprocessortype none imageprocessorautomap none if autoimageprocessor in configdict getautomap imageprocessorautomap configdictautomapautoimageprocessor if we still don t have the image processor class check if we re loading from a previous feature extractor config and if so infer the image processor class from there if imageprocessorclass is none and imageprocessorautomap is none featureextractorclass configdict popfeatureextractortype none if featureextractorclass is not none logger warning could not find image processor class in the image processor config or the model config loading based on pattern matching with the model s feature extractor configuration imageprocessorclass featureextractorclass replacefeatureextractor imageprocessor if autofeatureextractor in configdict getautomap featureextractorautomap configdictautomapautofeatureextractor imageprocessorautomap featureextractorautomap replacefeatureextractor imageprocessor logger warning could not find image processor auto map in the image processor config or the model config loading based on pattern matching with the model s feature extractor configuration if we don t find the image processor class in the image processor config let s try the model config if imageprocessorclass is none and imageprocessorautomap is none if not isinstanceconfig pretrainedconfig config autoconfig frompretrainedpretrainedmodelnameorpath kwargs it could be in config imageprocessortype imageprocessorclass getattrconfig imageprocessortype none if hasattrconfig automap and autoimageprocessor in config automap imageprocessorautomap config automapautoimageprocessor if imageprocessorclass is not none imageprocessorclass imageprocessorclassfromnameimageprocessorclass hasremotecode imageprocessorautomap is not none haslocalcode imageprocessorclass is not none or typeconfig in imageprocessormapping trustremotecode resolvetrustremotecode trustremotecode pretrainedmodelnameorpath haslocalcode hasremotecode if hasremotecode and trustremotecode imageprocessorclass getclassfromdynamicmodule imageprocessorautomap pretrainedmodelnameorpath kwargs kwargs popcoderevision none if os path isdirpretrainedmodelnameorpath imageprocessorclass registerforautoclass return imageprocessorclass fromdictconfigdict kwargs elif imageprocessorclass is not none return imageprocessorclass fromdictconfigdict kwargs last try we use the imageprocessormapping elif typeconfig in imageprocessormapping imageprocessorclass imageprocessormappingtypeconfig return imageprocessorclass fromdictconfigdict kwargs raise valueerror funrecognized image processor in pretrainedmodelnameorpath should have a fimageprocessortype key in its imageprocessorname of configname or one of the following fmodeltype keys in its configname joinc for c in imageprocessormappingnames keys staticmethod def registerconfigclass imageprocessorclass existokfalse imageprocessormapping registerconfigclass imageprocessorclass existokexistok coding utf 8 2022 the huggingface inc team licensed under the apache license version 2 0 the license you may not use this file except in compliance with the license you may obtain a copy of the license at http www apache org licenses license 2 0 unless required by applicable law or agreed to in writing software distributed under the license is distributed on an as is basis without warranties or conditions of any kind either express or implied see the license for the specific language governing permissions and limitations under the license autoimageprocessor class build the list of all image processors 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 loads the image processor configuration from a pretrained model image processor configuration args pretrained_model_name_or_path str or os pathlike this can be either a string the model id of a pretrained model configuration hosted inside a model repo on huggingface co valid model ids can be located at the root level like bert base uncased or namespaced under a user or organization name like dbmdz bert base german cased a path to a directory containing a configuration file saved using the pretrainedtokenizer save_pretrained method e g my_model_directory cache_dir str or os pathlike optional path to a directory in which a downloaded pretrained model configuration should be cached if the standard cache should not be used force_download bool optional defaults to false whether or not to force to re download the configuration files and override the cached versions if they exist resume_download bool optional defaults to false whether or not to delete incompletely received file attempts to resume the download if such a file exists proxies dict str str optional a dictionary of proxy servers to use by protocol or endpoint e g http foo bar 3128 http hostname foo bar 4012 the proxies are used on each request token str or bool optional the token to use as http bearer ization for remote files if true will use the token generated when running huggingface cli login stored in huggingface revision str optional defaults to main the specific model version to use it can be a branch name a tag name or a commit id since we use a git based system for storing models and other artifacts on huggingface co so revision can be any identifier allowed by git local_files_only bool optional defaults to false if true will only try to load the image processor configuration from local files tip passing token true is required when you want to use a private model tip returns dict the configuration of the image processor examples python download configuration from huggingface co and cache image_processor_config get_image_processor_config bert base uncased this model does not have a image processor config so the result will be an empty dict image_processor_config get_image_processor_config xlm roberta base save a pretrained image processor locally and you can reload its config from transformers import autotokenizer image_processor autoimageprocessor from_pretrained google vit base patch16 224 in21k image_processor save_pretrained image processor test image_processor_config get_image_processor_config image processor test this is a generic image processor class that will be instantiated as one of the image processor classes of the library when created with the autoimageprocessor from_pretrained class method this class cannot be instantiated directly using __init__ throws an error instantiate one of the image processor classes of the library from a pretrained model vocabulary the image processor class to instantiate is selected based on the model_type property of the config object either passed as an argument or loaded from pretrained_model_name_or_path if possible or when it s missing by falling back to using pattern matching on pretrained_model_name_or_path list options params pretrained_model_name_or_path str or os pathlike this can be either a string the model id of a pretrained image_processor hosted inside a model repo on huggingface co valid model ids can be located at the root level like bert base uncased or namespaced under a user or organization name like dbmdz bert base german cased a path to a directory containing a image processor file saved using the image_processing_utils imageprocessingmixin save_pretrained method e g my_model_directory a path or url to a saved image processor json file e g my_model_directory preprocessor_config json cache_dir str or os pathlike optional path to a directory in which a downloaded pretrained model image processor should be cached if the standard cache should not be used force_download bool optional defaults to false whether or not to force to re download the image processor files and override the cached versions if they exist resume_download bool optional defaults to false whether or not to delete incompletely received file attempts to resume the download if such a file exists proxies dict str str optional a dictionary of proxy servers to use by protocol or endpoint e g http foo bar 3128 http hostname foo bar 4012 the proxies are used on each request token str or bool optional the token to use as http bearer ization for remote files if true will use the token generated when running huggingface cli login stored in huggingface revision str optional defaults to main the specific model version to use it can be a branch name a tag name or a commit id since we use a git based system for storing models and other artifacts on huggingface co so revision can be any identifier allowed by git return_unused_kwargs bool optional defaults to false if false then this function returns just the final image processor object if true then this functions returns a tuple image_processor unused_kwargs where unused_kwargs is a dictionary consisting of the key value pairs whose keys are not image processor attributes i e the part of kwargs which has not been used to update image_processor and is otherwise ignored trust_remote_code bool optional defaults to false whether or not to allow for custom models defined on the hub in their own modeling files this option should only be set to true for repositories you trust and in which you have read the code as it will execute code present on the hub on your local machine kwargs dict str any optional the values in kwargs of any keys which are image processor attributes will be used to override the loaded values behavior concerning key value pairs whose keys are not image processor attributes is controlled by the return_unused_kwargs keyword parameter tip passing token true is required when you want to use a private model tip examples python from transformers import autoimageprocessor download image processor from huggingface co and cache image_processor autoimageprocessor from_pretrained google vit base patch16 224 in21k if image processor files are in a directory e g image processor was saved using save_pretrained test saved_model image_processor autoimageprocessor from_pretrained test saved_model if we still don t have the image processor class check if we re loading from a previous feature extractor config and if so infer the image processor class from there if we don t find the image processor class in the image processor config let s try the model config it could be in config image_processor_type last try we use the image_processor_mapping register a new image processor for this class args config_class pretrainedconfig the configuration corresponding to the model to register image_processor_class imageprocessingmixin the image processor to register
import importlib
import json
import os
import warnings
from collections import OrderedDict
from typing import Dict, Optional, Union


from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_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,
)


logger = logging.get_logger(__name__)

IMAGE_PROCESSOR_MAPPING_NAMES = OrderedDict(
    [
        ("align", "EfficientNetImageProcessor"),
        ("beit", "BeitImageProcessor"),
        ("bit", "BitImageProcessor"),
        ("blip", "BlipImageProcessor"),
        ("blip-2", "BlipImageProcessor"),
        ("bridgetower", "BridgeTowerImageProcessor"),
        ("chinese_clip", "ChineseCLIPImageProcessor"),
        ("clip", "CLIPImageProcessor"),
        ("clipseg", "ViTImageProcessor"),
        ("conditional_detr", "ConditionalDetrImageProcessor"),
        ("convnext", "ConvNextImageProcessor"),
        ("convnextv2", "ConvNextImageProcessor"),
        ("cvt", "ConvNextImageProcessor"),
        ("data2vec-vision", "BeitImageProcessor"),
        ("deformable_detr", "DeformableDetrImageProcessor"),
        ("deit", "DeiTImageProcessor"),
        ("deta", "DetaImageProcessor"),
        ("detr", "DetrImageProcessor"),
        ("dinat", "ViTImageProcessor"),
        ("dinov2", "BitImageProcessor"),
        ("donut-swin", "DonutImageProcessor"),
        ("dpt", "DPTImageProcessor"),
        ("efficientformer", "EfficientFormerImageProcessor"),
        ("efficientnet", "EfficientNetImageProcessor"),
        ("flava", "FlavaImageProcessor"),
        ("focalnet", "BitImageProcessor"),
        ("fuyu", "FuyuImageProcessor"),
        ("git", "CLIPImageProcessor"),
        ("glpn", "GLPNImageProcessor"),
        ("groupvit", "CLIPImageProcessor"),
        ("idefics", "IdeficsImageProcessor"),
        ("imagegpt", "ImageGPTImageProcessor"),
        ("instructblip", "BlipImageProcessor"),
        ("kosmos-2", "CLIPImageProcessor"),
        ("layoutlmv2", "LayoutLMv2ImageProcessor"),
        ("layoutlmv3", "LayoutLMv3ImageProcessor"),
        ("levit", "LevitImageProcessor"),
        ("mask2former", "Mask2FormerImageProcessor"),
        ("maskformer", "MaskFormerImageProcessor"),
        ("mgp-str", "ViTImageProcessor"),
        ("mobilenet_v1", "MobileNetV1ImageProcessor"),
        ("mobilenet_v2", "MobileNetV2ImageProcessor"),
        ("mobilevit", "MobileViTImageProcessor"),
        ("mobilevit", "MobileViTImageProcessor"),
        ("mobilevitv2", "MobileViTImageProcessor"),
        ("nat", "ViTImageProcessor"),
        ("nougat", "NougatImageProcessor"),
        ("oneformer", "OneFormerImageProcessor"),
        ("owlv2", "Owlv2ImageProcessor"),
        ("owlvit", "OwlViTImageProcessor"),
        ("perceiver", "PerceiverImageProcessor"),
        ("pix2struct", "Pix2StructImageProcessor"),
        ("poolformer", "PoolFormerImageProcessor"),
        ("pvt", "PvtImageProcessor"),
        ("regnet", "ConvNextImageProcessor"),
        ("resnet", "ConvNextImageProcessor"),
        ("sam", "SamImageProcessor"),
        ("segformer", "SegformerImageProcessor"),
        ("swiftformer", "ViTImageProcessor"),
        ("swin", "ViTImageProcessor"),
        ("swin2sr", "Swin2SRImageProcessor"),
        ("swinv2", "ViTImageProcessor"),
        ("table-transformer", "DetrImageProcessor"),
        ("timesformer", "VideoMAEImageProcessor"),
        ("tvlt", "TvltImageProcessor"),
        ("tvp", "TvpImageProcessor"),
        ("upernet", "SegformerImageProcessor"),
        ("van", "ConvNextImageProcessor"),
        ("videomae", "VideoMAEImageProcessor"),
        ("vilt", "ViltImageProcessor"),
        ("vit", "ViTImageProcessor"),
        ("vit_hybrid", "ViTHybridImageProcessor"),
        ("vit_mae", "ViTImageProcessor"),
        ("vit_msn", "ViTImageProcessor"),
        ("vitmatte", "VitMatteImageProcessor"),
        ("xclip", "CLIPImageProcessor"),
        ("yolos", "YolosImageProcessor"),
    ]
)

IMAGE_PROCESSOR_MAPPING = _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)


def image_processor_class_from_name(class_name: str):
    for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
        if class_name in extractors:
            module_name = model_type_to_module_name(module_name)

            module = importlib.import_module(f".{module_name}", "transformers.models")
            try:
                return getattr(module, class_name)
            except AttributeError:
                continue

    for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
        if getattr(extractor, "__name__", None) == class_name:
            return extractor

    
    
    main_module = importlib.import_module("transformers")
    if hasattr(main_module, class_name):
        return getattr(main_module, class_name)

    return None


def get_image_processor_config(
    pretrained_model_name_or_path: Union[str, os.PathLike],
    cache_dir: Optional[Union[str, os.PathLike]] = None,
    force_download: bool = False,
    resume_download: bool = False,
    proxies: Optional[Dict[str, str]] = None,
    token: Optional[Union[bool, str]] = None,
    revision: Optional[str] = None,
    local_files_only: bool = False,
    **kwargs,
):
    
    use_auth_token = kwargs.pop("use_auth_token", None)
    if use_auth_token is not None:
        warnings.warn(
            "The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers. Please use `token` instead.",
            FutureWarning,
        )
        if token is not None:
            raise ValueError("`token` and `use_auth_token` are both specified. Please set only the argument `token`.")
        token = use_auth_token

    resolved_config_file = get_file_from_repo(
        pretrained_model_name_or_path,
        IMAGE_PROCESSOR_NAME,
        cache_dir=cache_dir,
        force_download=force_download,
        resume_download=resume_download,
        proxies=proxies,
        token=token,
        revision=revision,
        local_files_only=local_files_only,
    )
    if resolved_config_file is None:
        logger.info(
            "Could not locate the image processor configuration file, will try to use the model config instead."
        )
        return {}

    with open(resolved_config_file, encoding="utf-8") as reader:
        return json.load(reader)


class AutoImageProcessor:
    r

    def __init__(self):
        raise EnvironmentError(
            "AutoImageProcessor is designed to be instantiated "
            "using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method."
        )

    @classmethod
    @replace_list_option_in_docstrings(IMAGE_PROCESSOR_MAPPING_NAMES)
    def from_pretrained(cls, pretrained_model_name_or_path, **kwargs):
        r
        use_auth_token = kwargs.pop("use_auth_token", None)
        if use_auth_token is not None:
            warnings.warn(
                "The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers. Please use `token` instead.",
                FutureWarning,
            )
            if kwargs.get("token", None) is not None:
                raise ValueError(
                    "`token` and `use_auth_token` are both specified. Please set only the argument `token`."
                )
            kwargs["token"] = use_auth_token

        config = kwargs.pop("config", None)
        trust_remote_code = kwargs.pop("trust_remote_code", None)
        kwargs["_from_auto"] = True

        config_dict, _ = ImageProcessingMixin.get_image_processor_dict(pretrained_model_name_or_path, **kwargs)
        image_processor_class = config_dict.get("image_processor_type", None)
        image_processor_auto_map = None
        if "AutoImageProcessor" in config_dict.get("auto_map", {}):
            image_processor_auto_map = config_dict["auto_map"]["AutoImageProcessor"]

        
        
        if image_processor_class is None and image_processor_auto_map is None:
            feature_extractor_class = config_dict.pop("feature_extractor_type", None)
            if feature_extractor_class is not None:
                logger.warning(
                    "Could not find image processor class in the image processor config or the model config. Loading"
                    " based on pattern matching with the model's feature extractor configuration."
                )
                image_processor_class = feature_extractor_class.replace("FeatureExtractor", "ImageProcessor")
            if "AutoFeatureExtractor" in config_dict.get("auto_map", {}):
                feature_extractor_auto_map = config_dict["auto_map"]["AutoFeatureExtractor"]
                image_processor_auto_map = feature_extractor_auto_map.replace("FeatureExtractor", "ImageProcessor")
                logger.warning(
                    "Could not find image processor auto map in the image processor config or the model config."
                    " Loading based on pattern matching with the model's feature extractor configuration."
                )

        
        if image_processor_class is None and image_processor_auto_map is None:
            if not isinstance(config, PretrainedConfig):
                config = AutoConfig.from_pretrained(pretrained_model_name_or_path, **kwargs)
            
            image_processor_class = getattr(config, "image_processor_type", None)
            if hasattr(config, "auto_map") and "AutoImageProcessor" in config.auto_map:
                image_processor_auto_map = config.auto_map["AutoImageProcessor"]

        if image_processor_class is not None:
            image_processor_class = image_processor_class_from_name(image_processor_class)

        has_remote_code = image_processor_auto_map is not None
        has_local_code = image_processor_class is not None or type(config) in IMAGE_PROCESSOR_MAPPING
        trust_remote_code = resolve_trust_remote_code(
            trust_remote_code, pretrained_model_name_or_path, has_local_code, has_remote_code
        )

        if has_remote_code and trust_remote_code:
            image_processor_class = get_class_from_dynamic_module(
                image_processor_auto_map, pretrained_model_name_or_path, **kwargs
            )
            _ = kwargs.pop("code_revision", None)
            if os.path.isdir(pretrained_model_name_or_path):
                image_processor_class.register_for_auto_class()
            return image_processor_class.from_dict(config_dict, **kwargs)
        elif image_processor_class is not None:
            return image_processor_class.from_dict(config_dict, **kwargs)
        
        elif type(config) in IMAGE_PROCESSOR_MAPPING:
            image_processor_class = IMAGE_PROCESSOR_MAPPING[type(config)]
            return image_processor_class.from_dict(config_dict, **kwargs)

        raise ValueError(
            f"Unrecognized image processor in {pretrained_model_name_or_path}. Should have a "
            f"`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following "
            f"`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys())}"
        )

    @staticmethod
    def register(config_class, image_processor_class, exist_ok=False):
        
        IMAGE_PROCESSOR_MAPPING.register(config_class, image_processor_class, exist_ok=exist_ok)