'''simple docstring'''


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


snake_case__					:      List[Any]				      =  logging.get_logger(__name__)

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

snake_case__					:      str				      =  _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)


def  _lowerCamelCase   (				lowerCamelCase_ :							str       ):



     """simple docstring"""





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

               UpperCAmelCase_							:       Optional[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.
     UpperCAmelCase_							:       Tuple       =				importlib.import_module('transformers'       )
     if hasattr(lowerCamelCase_     ,					lowerCamelCase_       ):
          return getattr(lowerCamelCase_     ,					lowerCamelCase_       )

     return None


def  _lowerCamelCase   (				lowerCamelCase_ :							Union[str, os.PathLike]     ,					lowerCamelCase_ :							Optional[Union[str, os.PathLike]] = None     ,					lowerCamelCase_ :							bool = False     ,					lowerCamelCase_ :							bool = False     ,					lowerCamelCase_ :							Optional[Dict[str, str]] = None     ,					lowerCamelCase_ :							Optional[Union[bool, str]] = None     ,					lowerCamelCase_ :							Optional[str] = None     ,					lowerCamelCase_ :							bool = False     ,					**lowerCamelCase_ :							str     ,					):



     """simple docstring"""





     UpperCAmelCase_							:       List[str]       =				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 					__SCREAMING_SNAKE_CASE						:







  '''simple docstring'''






  def __init__(			self						):




       '''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 _UpperCamelCase					(			cls				,		snake_case_				,		**snake_case_						):




       '''simple docstring'''

       UpperCAmelCase_							:       Tuple       =				kwargs.pop('config'				,		snake_case_						)
       UpperCAmelCase_							:       List[str]       =				kwargs.pop('trust_remote_code'				,		snake_case_						)
       UpperCAmelCase_							:       Optional[int]       =				True

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

       if image_processor_class is not None:
            UpperCAmelCase_							:       List[str]       =				image_processor_class_from_name(snake_case_						)

       UpperCAmelCase_							:       Tuple       =				image_processor_auto_map is not None
       UpperCAmelCase_							:       Optional[int]       =				image_processor_class is not None or type(snake_case_						) in IMAGE_PROCESSOR_MAPPING
       UpperCAmelCase_							:       List[Any]       =				resolve_trust_remote_code(
           snake_case_				,		snake_case_				,		snake_case_				,		snake_case_						)

       if has_remote_code and trust_remote_code:
            UpperCAmelCase_							:       List[str]       =				get_class_from_dynamic_module(
                snake_case_				,		snake_case_				,		**snake_case_						)
            UpperCAmelCase_							:       Union[str, Any]       =				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:
            UpperCAmelCase_							:       List[Any]       =				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 _UpperCamelCase					(			snake_case_				,		snake_case_						):




       '''simple docstring'''

       IMAGE_PROCESSOR_MAPPING.register(snake_case_				,		snake_case_						)







'''simple docstring'''


def  _lowerCamelCase   (				lowerCamelCase_ :							int     ,					lowerCamelCase_ :							int       ):



     """simple docstring"""





     return int(input_a == input_a == 0       )


def  _lowerCamelCase   (				):



     """simple docstring"""





     print('Truth Table of NOR Gate:'       )
     print('|   Input 1   |  Input 2  | Output |'       )
     print(F'''|      0      |    0      |  {nor_gate(0     ,					0       )}     |'''       )
     print(F'''|      0      |    1      |  {nor_gate(0     ,					1       )}     |'''       )
     print(F'''|      1      |    0      |  {nor_gate(1     ,					0       )}     |'''       )
     print(F'''|      1      |    1      |  {nor_gate(1     ,					1       )}     |'''       )


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 main()






