

import math
from datetime import datetime, timedelta






def 					lowerCamelCase_     (							UpperCAmelCase_							:     int	)						->				datetime:




 '''simple docstring'''




 _UpperCamelCase   :		Tuple			=						year % 1_9
 _UpperCamelCase   :		int			=						year % 4
 _UpperCamelCase   :		List[Any]			=						year % 7
 _UpperCamelCase   :		Optional[int]			=						math.floor(year / 1_0_0	)
 _UpperCamelCase   :		Optional[Any]			=						math.floor((1_3 + 8 * leap_day_inhibits) / 2_5	)
 _UpperCamelCase   :		Any			=						leap_day_inhibits / 4
 _UpperCamelCase   :		List[str]			=						(
     1_5 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
 ) % 3_0
 _UpperCamelCase   :		Optional[int]			=						(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

 # days to be added to March 21
 _UpperCamelCase   :		Optional[int]			=						(1_9 * metonic_cycle + secular_moon_shift) % 3_0

 # PHM -> Paschal Full Moon
 _UpperCamelCase   :		Optional[int]			=						(
     2 * julian_leap_year
     + 4 * non_leap_year
     + 6 * days_to_add
     + century_starting_point
 ) % 7

 if days_to_add == 2_9 and days_from_phm_to_sunday == 6:
  return datetime(UpperCAmelCase_							,       4							,       1_9	)
 elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
  return datetime(UpperCAmelCase_							,       4							,       1_8	)
 else:
  return datetime(UpperCAmelCase_							,       3							,       2_2	) + 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):
              lowerCAmelCase__								=		"""will be""" if year > datetime.now().year else """was"""
              print(f'Easter in {year} {tense} {gauss_easter(year)}')







from ...processing_utils import ProcessorMixin







class 	lowercase    (				_lowercase							):


		"""simple docstring"""




		a__					       =  ["image_processor", "feature_extractor"]
		a__					       =  "TvltImageProcessor"
		a__					       =  "TvltFeatureExtractor"


		def __init__(				self	,       __snake_case	,       __snake_case):
			super().__init__(image_processor=__snake_case	,       feature_extractor=__snake_case)

			_UpperCamelCase   :		List[str]			=						image_processor
			_UpperCamelCase   :		Dict			=						feature_extractor


		def __call__(				self	,       __snake_case=None	,       __snake_case=None	,       __snake_case=None	,       __snake_case=None	,       __snake_case=False	,       __snake_case=False	,       *__snake_case	,       **__snake_case	,       ):

			if images is None and audio is None:
				raise ValueError('You need to specify either an `images` or `audio` input to process.')

			_UpperCamelCase   :		Union[str, Any]			=						None
			if images is not None:
				_UpperCamelCase   :		Tuple			=						self.image_processor(__snake_case	,       mask_pixel=__snake_case	,       *__snake_case	,       **__snake_case)
			if images_mixed is not None:
				_UpperCamelCase   :		Union[str, Any]			=						self.image_processor(__snake_case	,       is_mixed=__snake_case	,       *__snake_case	,       **__snake_case)
			if audio is not None:
				_UpperCamelCase   :		Tuple			=						self.feature_extractor(
				    __snake_case	,       *__snake_case	,       sampling_rate=__snake_case	,       mask_audio=__snake_case	,       **__snake_case)

			_UpperCamelCase   :		Tuple			=						{}
			if audio is not None:
				output_dict.update(__snake_case)
			if images is not None:
				output_dict.update(__snake_case)
			if images_mixed_dict is not None:
				output_dict.update(__snake_case)
			return output_dict






		@property
		def 		A__					(				self):
			_UpperCamelCase   :		List[Any]			=						self.image_processor.model_input_names
			_UpperCamelCase   :		List[Any]			=						self.feature_extractor.model_input_names
			return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names))




