


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    :						Tuple     =							logging.get_logger(__name__)

__UpperCamelCase    :						List[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'),
    ]
)

__UpperCamelCase    :						Optional[int]     =							_LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)

def   _UpperCAmelCase       (     UpperCAmelCase      :			str      ):
      """simple docstring"""




      for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
            if class_name in extractors:
                  __lowerCamelCase     :      Any       						=						model_type_to_module_name(UpperCAmelCase__      )

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

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

      return None

def   _UpperCAmelCase       (     UpperCAmelCase      :			Union[str, os.PathLike]						,	UpperCAmelCase      :			Optional[Union[str, os.PathLike]] = None						,	UpperCAmelCase      :			bool = False						,	UpperCAmelCase      :			bool = False						,	UpperCAmelCase      :			Optional[Dict[str, str]] = None						,	UpperCAmelCase      :			Optional[Union[bool, str]] = None						,	UpperCAmelCase      :			Optional[str] = None						,	UpperCAmelCase      :			bool = False						,	**UpperCAmelCase      :			Dict						,	):
      """simple docstring"""




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




class 							_UpperCamelCase :

   '''simple docstring'''







   def __init__(  self  : List[str]							):






         '''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(__UpperCamelCase							)
   def   _snake_case    (  cls  : Tuple       ,  _lowerCamelCase  : Union[str, Any]       ,  **_lowerCamelCase  : Optional[Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      Union[str, Any]       						=						kwargs.pop("""config"""       ,  __UpperCamelCase							)
         __lowerCamelCase     :      str       						=						kwargs.pop("""trust_remote_code"""       ,  __UpperCamelCase							)
         __lowerCamelCase     :      str       						=						True

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

         if image_processor_class is not None:
               __lowerCamelCase     :      List[Any]       						=						image_processor_class_from_name(__UpperCamelCase							)

         __lowerCamelCase     :      Optional[int]       						=						image_processor_auto_map is not None
         __lowerCamelCase     :      Optional[int]       						=						image_processor_class is not None or type(__UpperCamelCase							) in IMAGE_PROCESSOR_MAPPING
         __lowerCamelCase     :      int       						=						resolve_trust_remote_code(
             __UpperCamelCase       ,  __UpperCamelCase       ,  __UpperCamelCase       ,  __UpperCamelCase							)

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

         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    (  _lowerCamelCase  : Optional[int]       ,  _lowerCamelCase  : Tuple							):






         '''simple docstring'''



         IMAGE_PROCESSOR_MAPPING.register(__UpperCamelCase       ,  __UpperCamelCase							)







def   _UpperCAmelCase       (     ):
      """simple docstring"""




      __lowerCamelCase     :      Optional[int]       						=						[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

      __lowerCamelCase     :      str       						=						6
      __lowerCamelCase     :      Optional[int]       						=						1
      __lowerCamelCase     :      Optional[int]       						=						1_901

      __lowerCamelCase     :      Optional[Any]       						=						0

      while year < 2_001:
            day += 7

            if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
                  if day > days_per_month[month - 1] and month != 2:
                        month += 1
                        __lowerCamelCase     :      Tuple       						=						day - days_per_month[month - 2]
                  elif day > 29 and month == 2:
                        month += 1
                        __lowerCamelCase     :      str       						=						day - 29
            else:
                  if day > days_per_month[month - 1]:
                        month += 1
                        __lowerCamelCase     :      Any       						=						day - days_per_month[month - 2]

            if month > 12:
                  year += 1
                  __lowerCamelCase     :      Optional[Any]       						=						1

            if year < 2_001 and day == 1:
                  sundays += 1
      return sundays


if __name__ == "__main__":
    print(solution())



