





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


a__			:					Optional[int]       						=						logging.get_logger(__name__)

a__			:					Optional[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'),
    ]
)

a__			:					Dict       						=						_LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			str )							->     Union[str, Any]:

       """simple docstring"""


       for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
              if class_name in extractors:
                     UpperCAmelCase  =						model_type_to_module_name(SCREAMING_SNAKE_CASE_ )

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

       for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
              if getattr(SCREAMING_SNAKE_CASE_			,	'''__name__'''			,	SCREAMING_SNAKE_CASE_ ) == 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  =						importlib.import_module('''transformers''' )
       if hasattr(SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_ ):
              return getattr(SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_ )

       return None
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			Union[str, os.PathLike]			,	SCREAMING_SNAKE_CASE_ :			Optional[Union[str, os.PathLike]] = None			,	SCREAMING_SNAKE_CASE_ :			bool = False			,	SCREAMING_SNAKE_CASE_ :			bool = False			,	SCREAMING_SNAKE_CASE_ :			Optional[Dict[str, str]] = None			,	SCREAMING_SNAKE_CASE_ :			Optional[Union[bool, str]] = None			,	SCREAMING_SNAKE_CASE_ :			Optional[str] = None			,	SCREAMING_SNAKE_CASE_ :			bool = False			,	**SCREAMING_SNAKE_CASE_ :			Union[str, Any]			,	)							->     List[str]:

       """simple docstring"""


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






class     lowerCAmelCase__ :

       '''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(a__						)
       def 			__snake_case      ( cls					:				int       ,     a__					:				Union[str, Any]       ,     **a__					:				List[str]						):
              UpperCAmelCase  =						kwargs.pop('''config'''       ,     a__						)
              UpperCAmelCase  =						kwargs.pop('''trust_remote_code'''       ,     a__						)
              UpperCAmelCase  =						True

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

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

              UpperCAmelCase  =						image_processor_auto_map is not None
              UpperCAmelCase  =						image_processor_class is not None or type(a__						) in IMAGE_PROCESSOR_MAPPING
              UpperCAmelCase  =						resolve_trust_remote_code(
                  a__       ,     a__       ,     a__       ,     a__						)

              if has_remote_code and trust_remote_code:
                     UpperCAmelCase  =						get_class_from_dynamic_module(
                         a__       ,     a__       ,     **a__						)
                     UpperCAmelCase  =						kwargs.pop('''code_revision'''       ,     a__						)
                     if os.path.isdir(a__						):
                            image_processor_class.register_for_auto_class()
                     return image_processor_class.from_dict(a__       ,     **a__						)
              elif image_processor_class is not None:
                     return image_processor_class.from_dict(a__       ,     **a__						)
              # Last try: we use the IMAGE_PROCESSOR_MAPPING.
              elif type(a__						) in IMAGE_PROCESSOR_MAPPING:
                     UpperCAmelCase  =						IMAGE_PROCESSOR_MAPPING[type(a__						)]
                     return image_processor_class.from_dict(a__       ,     **a__						)

              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      ( a__					:				Union[str, Any]       ,     a__					:				Tuple						):
              IMAGE_PROCESSOR_MAPPING.register(a__       ,     a__						)










import math
from datetime import datetime, timedelta






def      _snake_case     (__lowercase):
   UpperCamelCase_						=  year % 19
   UpperCamelCase_						=  year % 4
   UpperCamelCase_						=  year % 7
   UpperCamelCase_						=  math.floor(year / 100)
   UpperCamelCase_						=  math.floor((13 + 8 * leap_day_inhibits) / 25)
   UpperCamelCase_						=  leap_day_inhibits / 4
   UpperCamelCase_						=  (
       15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
   ) % 30
   UpperCamelCase_						=  (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

   # days to be added to March 21
   UpperCamelCase_						=  (19 * metonic_cycle + secular_moon_shift) % 30

   # PHM -> Paschal Full Moon
   UpperCamelCase_						=  (
       2 * julian_leap_year
       + 4 * non_leap_year
       + 6 * days_to_add
       + century_starting_point
   ) % 7

   if days_to_add == 29 and days_from_phm_to_sunday == 6:
      return datetime(__lowercase     ,   4     ,   19)
   elif days_to_add == 28 and days_from_phm_to_sunday == 6:
      return datetime(__lowercase     ,   4     ,   18)
   else:
      return datetime(__lowercase     ,   3     ,   22) + timedelta(
          days=int(days_to_add + days_from_phm_to_sunday))


if __name__ == "__main__":
 for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3):
  snake_case__   :						Dict													=   """will be""" if year > datetime.now().year else """was"""
  print(f'Easter in {year} {tense} {gauss_easter(year)}')





