



import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
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,
)


lowerCAmelCase__					  =  logging.get_logger(__name__)

lowerCAmelCase__					  =  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'''),
        ('''donut-swin''', '''DonutImageProcessor'''),
        ('''dpt''', '''DPTImageProcessor'''),
        ('''efficientformer''', '''EfficientFormerImageProcessor'''),
        ('''efficientnet''', '''EfficientNetImageProcessor'''),
        ('''flava''', '''FlavaImageProcessor'''),
        ('''focalnet''', '''BitImageProcessor'''),
        ('''git''', '''CLIPImageProcessor'''),
        ('''glpn''', '''GLPNImageProcessor'''),
        ('''groupvit''', '''CLIPImageProcessor'''),
        ('''imagegpt''', '''ImageGPTImageProcessor'''),
        ('''instructblip''', '''BlipImageProcessor'''),
        ('''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'''),
        ('''oneformer''', '''OneFormerImageProcessor'''),
        ('''owlvit''', '''OwlViTImageProcessor'''),
        ('''perceiver''', '''PerceiverImageProcessor'''),
        ('''pix2struct''', '''Pix2StructImageProcessor'''),
        ('''poolformer''', '''PoolFormerImageProcessor'''),
        ('''regnet''', '''ConvNextImageProcessor'''),
        ('''resnet''', '''ConvNextImageProcessor'''),
        ('''sam''', '''SamImageProcessor'''),
        ('''segformer''', '''SegformerImageProcessor'''),
        ('''swiftformer''', '''ViTImageProcessor'''),
        ('''swin''', '''ViTImageProcessor'''),
        ('''swin2sr''', '''Swin2SRImageProcessor'''),
        ('''swinv2''', '''ViTImageProcessor'''),
        ('''table-transformer''', '''DetrImageProcessor'''),
        ('''timesformer''', '''VideoMAEImageProcessor'''),
        ('''tvlt''', '''TvltImageProcessor'''),
        ('''upernet''', '''SegformerImageProcessor'''),
        ('''van''', '''ConvNextImageProcessor'''),
        ('''videomae''', '''VideoMAEImageProcessor'''),
        ('''vilt''', '''ViltImageProcessor'''),
        ('''vit''', '''ViTImageProcessor'''),
        ('''vit_hybrid''', '''ViTHybridImageProcessor'''),
        ('''vit_mae''', '''ViTImageProcessor'''),
        ('''vit_msn''', '''ViTImageProcessor'''),
        ('''xclip''', '''CLIPImageProcessor'''),
        ('''yolos''', '''YolosImageProcessor'''),
    ]
)

lowerCAmelCase__					  =  _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)


def  __lowerCamelCase (       lowerCamelCase__						):

				"""simple docstring"""


				for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
								if class_name in extractors:
												lowercase__					:   Tuple													=					model_type_to_module_name(lowerCamelCase__						)

												lowercase__					:   Any													=					importlib.import_module(F""".{module_name}"""					,			"transformers.models"						)
												try:
																return getattr(lowerCamelCase__					,			lowerCamelCase__						)
												except AttributeError:
																continue

				for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
								if getattr(lowerCamelCase__					,			"__name__"					,			lowerCamelCase__						) == class_name:
												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.
				lowercase__					:   List[Any]													=					importlib.import_module("transformers"						)
				if hasattr(lowerCamelCase__					,			lowerCamelCase__						):
								return getattr(lowerCamelCase__					,			lowerCamelCase__						)

				return None


def  __lowerCamelCase (       lowerCamelCase__					,			lowerCamelCase__ = None					,			lowerCamelCase__ = False					,			lowerCamelCase__ = False					,			lowerCamelCase__ = None					,			lowerCamelCase__ = None					,			lowerCamelCase__ = None					,			lowerCamelCase__ = False					,			**lowerCamelCase__					,			):

				"""simple docstring"""


				lowercase__					:   Dict													=					get_file_from_repo(
				    lowerCamelCase__					,			lowerCamelCase__					,			cache_dir=lowerCamelCase__					,			force_download=lowerCamelCase__					,			resume_download=lowerCamelCase__					,			proxies=lowerCamelCase__					,			use_auth_token=lowerCamelCase__					,			revision=lowerCamelCase__					,			local_files_only=lowerCamelCase__					,			)
				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(lowerCamelCase__					,			encoding="utf-8"						) as reader:
								return json.load(lowerCamelCase__						)

class 				snake_case__:

					"""simple docstring"""






					def __init__(							self :     List[str]					):
									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(SCREAMING_SNAKE_CASE					)
					def 			snake_case					(							cls :     Union[str, Any]				,       SCREAMING_SNAKE_CASE :     Union[str, Any]				,       **SCREAMING_SNAKE_CASE :     int					):
									lowercase__					:   List[str]													=					kwargs.pop("config"				,       SCREAMING_SNAKE_CASE					)
									lowercase__					:   List[Any]													=					kwargs.pop("trust_remote_code"				,       SCREAMING_SNAKE_CASE					)
									lowercase__					:   Optional[int]													=					True

									lowercase__							,							lowercase__					:   Optional[Any]													=					ImageProcessingMixin.get_image_processor_dict(SCREAMING_SNAKE_CASE				,       **SCREAMING_SNAKE_CASE					)
									lowercase__					:   int													=					config_dict.get("image_processor_type"				,       SCREAMING_SNAKE_CASE					)
									lowercase__					:   Any													=					None
									if "AutoImageProcessor" in config_dict.get("auto_map"				,       {}					):
													lowercase__					:   Union[str, Any]													=					config_dict["auto_map"]["AutoImageProcessor"]

									# 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 image_processor_class is None and image_processor_auto_map is None:
													lowercase__					:   Tuple													=					config_dict.pop("feature_extractor_type"				,       SCREAMING_SNAKE_CASE					)
													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."					)
																	lowercase__					:   Any													=					feature_extractor_class.replace("FeatureExtractor"				,       "ImageProcessor"					)
													if "AutoFeatureExtractor" in config_dict.get("auto_map"				,       {}					):
																	lowercase__					:   List[Any]													=					config_dict["auto_map"]["AutoFeatureExtractor"]
																	lowercase__					:   Tuple													=					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 we don't find the image processor class in the image processor config, let's try the model config.
									if image_processor_class is None and image_processor_auto_map is None:
													if not isinstance(SCREAMING_SNAKE_CASE				,       SCREAMING_SNAKE_CASE					):
																	lowercase__					:   int													=					AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE				,       **SCREAMING_SNAKE_CASE					)
													# It could be in `config.image_processor_type``
													lowercase__					:   int													=					getattr(SCREAMING_SNAKE_CASE				,       "image_processor_type"				,       SCREAMING_SNAKE_CASE					)
													if hasattr(SCREAMING_SNAKE_CASE				,       "auto_map"					) and "AutoImageProcessor" in config.auto_map:
																	lowercase__					:   Any													=					config.auto_map["AutoImageProcessor"]

									if image_processor_class is not None:
													lowercase__					:   Optional[int]													=					image_processor_class_from_name(SCREAMING_SNAKE_CASE					)

									lowercase__					:   Tuple													=					image_processor_auto_map is not None
									lowercase__					:   Tuple													=					image_processor_class is not None or type(SCREAMING_SNAKE_CASE					) in IMAGE_PROCESSOR_MAPPING
									lowercase__					:   Optional[int]													=					resolve_trust_remote_code(
									    SCREAMING_SNAKE_CASE				,       SCREAMING_SNAKE_CASE				,       SCREAMING_SNAKE_CASE				,       SCREAMING_SNAKE_CASE					)

									if has_remote_code and trust_remote_code:
													lowercase__					:   Optional[Any]													=					get_class_from_dynamic_module(
													    SCREAMING_SNAKE_CASE				,       SCREAMING_SNAKE_CASE				,       **SCREAMING_SNAKE_CASE					)
													lowercase__					:   Dict													=					kwargs.pop("code_revision"				,       SCREAMING_SNAKE_CASE					)
													if os.path.isdir(SCREAMING_SNAKE_CASE					):
																	image_processor_class.register_for_auto_class()
													return image_processor_class.from_dict(SCREAMING_SNAKE_CASE				,       **SCREAMING_SNAKE_CASE					)
									elif image_processor_class is not None:
													return image_processor_class.from_dict(SCREAMING_SNAKE_CASE				,       **SCREAMING_SNAKE_CASE					)
									# Last try: we use the IMAGE_PROCESSOR_MAPPING.
									elif type(SCREAMING_SNAKE_CASE					) in IMAGE_PROCESSOR_MAPPING:
													lowercase__					:   List[Any]													=					IMAGE_PROCESSOR_MAPPING[type(SCREAMING_SNAKE_CASE					)]
													return image_processor_class.from_dict(SCREAMING_SNAKE_CASE				,       **SCREAMING_SNAKE_CASE					)

									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 			snake_case					(							SCREAMING_SNAKE_CASE :     Optional[int]				,       SCREAMING_SNAKE_CASE :     str					):
									IMAGE_PROCESSOR_MAPPING.register(SCREAMING_SNAKE_CASE				,       SCREAMING_SNAKE_CASE					)









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase__					  =  {}

try:
				if not is_sentencepiece_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase__					  =  ['''NllbTokenizer''']

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase__					  =  ['''NllbTokenizerFast''']


if TYPE_CHECKING:
				try:
								if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_nllb import NllbTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_nllb_fast import NllbTokenizerFast

else:
				import sys

				lowerCAmelCase__					  =  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




