





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,
)


UpperCAmelCase_							=				logging.get_logger(__name__)

UpperCAmelCase_							=				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"""),
    ]
)

UpperCAmelCase_							=				_LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)





def  __magic_name__  (				lowercase				)				-> Optional[Any]:

							"""simple docstring"""



							for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
														if class_name in extractors:
																					lowercase_	:   int  				=     model_type_to_module_name(_A				)

																					lowercase_	:   List[Any]  				=     importlib.import_module(f""".{module_name}"""				,       """transformers.models"""				)
																					try:
																												return getattr(_A				,       _A				)
																					except AttributeError:
																												continue

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

							return None





def  __magic_name__  (				lowercase				,       lowercase = None				,       lowercase = False				,       lowercase = False				,       lowercase = None				,       lowercase = None				,       lowercase = None				,       lowercase = False				,       **lowercase				,       )				-> Tuple:

							"""simple docstring"""



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




class     UpperCamelCase__					:






		'''simple docstring'''






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






									"""simple docstring"""
									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(__snake_case  )
		def 						snake_case__				(							cls,   snake_case__,   **snake_case__  )       -> List[Any]:






									"""simple docstring"""
									lowercase_	:   Optional[int]  				=     kwargs.pop("""config""",   __snake_case  )
									lowercase_	:   Optional[Any]  				=     kwargs.pop("""trust_remote_code""",   __snake_case  )
									lowercase_	:   List[str]  				=     True

									lowercase_	:   Tuple  				=     ImageProcessingMixin.get_image_processor_dict(__snake_case,   **__snake_case  )
									lowercase_	:   str  				=     config_dict.get("""image_processor_type""",   __snake_case  )
									lowercase_	:   Optional[int]  				=     None
									if "AutoImageProcessor" in config_dict.get("""auto_map""",   {}  ):
																lowercase_	:   str  				=     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_	:   List[Any]  				=     config_dict.pop("""feature_extractor_type""",   __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_	:   List[Any]  				=     feature_extractor_class.replace("""FeatureExtractor""",   """ImageProcessor"""  )
																if "AutoFeatureExtractor" in config_dict.get("""auto_map""",   {}  ):
																							lowercase_	:   Optional[Any]  				=     config_dict['auto_map']['AutoFeatureExtractor']
																							lowercase_	:   Optional[Any]  				=     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(__snake_case,   __snake_case  ):
																							lowercase_	:   Dict  				=     AutoConfig.from_pretrained(__snake_case,   **__snake_case  )
																# It could be in `config.image_processor_type``
																lowercase_	:   List[Any]  				=     getattr(__snake_case,   """image_processor_type""",   __snake_case  )
																if hasattr(__snake_case,   """auto_map"""  ) and "AutoImageProcessor" in config.auto_map:
																							lowercase_	:   str  				=     config.auto_map['AutoImageProcessor']

									if image_processor_class is not None:
																lowercase_	:   Tuple  				=     image_processor_class_from_name(__snake_case  )

									lowercase_	:   Optional[Any]  				=     image_processor_auto_map is not None
									lowercase_	:   List[str]  				=     image_processor_class is not None or type(__snake_case  ) in IMAGE_PROCESSOR_MAPPING
									lowercase_	:   Dict  				=     resolve_trust_remote_code(
									    __snake_case,   __snake_case,   __snake_case,   __snake_case  )

									if has_remote_code and trust_remote_code:
																lowercase_	:   Dict  				=     get_class_from_dynamic_module(
																    __snake_case,   __snake_case,   **__snake_case  )
																lowercase_	:   List[str]  				=     kwargs.pop("""code_revision""",   __snake_case  )
																if os.path.isdir(__snake_case  ):
																							image_processor_class.register_for_auto_class()
																return image_processor_class.from_dict(__snake_case,   **__snake_case  )
									elif image_processor_class is not None:
																return image_processor_class.from_dict(__snake_case,   **__snake_case  )
									# Last try: we use the IMAGE_PROCESSOR_MAPPING.
									elif type(__snake_case  ) in IMAGE_PROCESSOR_MAPPING:
																lowercase_	:   str  				=     IMAGE_PROCESSOR_MAPPING[type(__snake_case  )]
																return image_processor_class.from_dict(__snake_case,   **__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__				(							snake_case__,   snake_case__  )       -> Tuple:






									"""simple docstring"""
									IMAGE_PROCESSOR_MAPPING.register(__snake_case,   __snake_case  )




'''simple docstring'''






from typing import TYPE_CHECKING

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


lowerCAmelCase:   List[str]					=		{
    'configuration_falcon': ['FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FalconConfig'],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase:   str					=		[
         'FALCON_PRETRAINED_MODEL_ARCHIVE_LIST',
         'FalconForCausalLM',
         'FalconModel',
         'FalconPreTrainedModel',
         'FalconForSequenceClassification',
         'FalconForTokenClassification',
         'FalconForQuestionAnswering',
     ]


if TYPE_CHECKING:
     from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_falcon import (
              FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
              FalconForCausalLM,
              FalconForQuestionAnswering,
              FalconForSequenceClassification,
              FalconForTokenClassification,
              FalconModel,
              FalconPreTrainedModel,
          )


else:
     import sys

     lowerCAmelCase:   Optional[int]					=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)