
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .tokenization_wavaveca import WavaVecaCTCTokenizer

class __snake_case		(				lowerCAmelCase					):
    _a		:						int=    "Wav2Vec2FeatureExtractor"
    _a		:						Tuple=    "AutoTokenizer"
    def __init__(  self		,snake_case		,snake_case				):



           '''simple docstring'''







           super().__init__(snake_case		,snake_case				)
           lowercase							:					int	     =				self.feature_extractor
           lowercase							:					Union[str, Any]	     =				False
    @classmethod
    def 				_SCREAMING_SNAKE_CASE	(  cls		,snake_case		,**snake_case				):



           '''simple docstring'''







           try:
                  return super().from_pretrained(snake_case		,**snake_case				)
           except OSError:
                  warnings.warn(
                      f"Loading a tokenizer inside {cls.__name__} from a config that does not"
                      """ include a `tokenizer_class` attribute is deprecated and will be """
                      """removed in v5. Please add `'tokenizer_class': 'Wav2Vec2CTCTokenizer'`"""
                      """ attribute to either your `config.json` or `tokenizer_config.json` """
                      """file to suppress this warning: """		,snake_case		,)

                  lowercase							:					Optional[Any]	     =				WavaVecaFeatureExtractor.from_pretrained(snake_case		,**snake_case				)
                  lowercase							:					Any	     =				WavaVecaCTCTokenizer.from_pretrained(snake_case		,**snake_case				)

                  return cls(feature_extractor=snake_case		,tokenizer=snake_case				)
    def __call__(  self		,*snake_case		,**snake_case				):



           '''simple docstring'''







           if self._in_target_context_manager:
                  return self.current_processor(*snake_case		,**snake_case				)

           if "raw_speech" in kwargs:
                  warnings.warn("""Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."""				)
                  lowercase							:					Union[str, Any]	     =				kwargs.pop("""raw_speech"""				)
           else:
                  lowercase							:					Optional[Any]	     =				kwargs.pop("""audio"""		,snake_case				)
           lowercase							:					int	     =				kwargs.pop("""sampling_rate"""		,snake_case				)
           lowercase							:					List[str]	     =				kwargs.pop("""text"""		,snake_case				)
           if len(snake_case				) > 0:
                  lowercase							:					Dict	     =				args[0]
                  lowercase							:					Dict	     =				args[1:]

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

           if audio is not None:
                  lowercase							:					Optional[int]	     =				self.feature_extractor(snake_case		,*snake_case		,sampling_rate=snake_case		,**snake_case				)
           if text is not None:
                  lowercase							:					int	     =				self.tokenizer(snake_case		,**snake_case				)

           if text is None:
                  return inputs
           elif audio is None:
                  return encodings
           else:
                  lowercase							:					Dict	     =				encodings["""input_ids"""]
                  return inputs
    def 				_SCREAMING_SNAKE_CASE	(  self		,*snake_case		,**snake_case				):



           '''simple docstring'''







           if self._in_target_context_manager:
                  return self.current_processor.pad(*snake_case		,**snake_case				)

           lowercase							:					List[str]	     =				kwargs.pop("""input_features"""		,snake_case				)
           lowercase							:					List[Any]	     =				kwargs.pop("""labels"""		,snake_case				)
           if len(snake_case				) > 0:
                  lowercase							:					int	     =				args[0]
                  lowercase							:					int	     =				args[1:]

           if input_features is not None:
                  lowercase							:					Any	     =				self.feature_extractor.pad(snake_case		,*snake_case		,**snake_case				)
           if labels is not None:
                  lowercase							:					Optional[Any]	     =				self.tokenizer.pad(snake_case		,**snake_case				)

           if labels is None:
                  return input_features
           elif input_features is None:
                  return labels
           else:
                  lowercase							:					Dict	     =				labels["""input_ids"""]
                  return input_features
    def 				_SCREAMING_SNAKE_CASE	(  self		,*snake_case		,**snake_case				):



           '''simple docstring'''







           return self.tokenizer.batch_decode(*snake_case		,**snake_case				)
    def 				_SCREAMING_SNAKE_CASE	(  self		,*snake_case		,**snake_case				):



           '''simple docstring'''







           return self.tokenizer.decode(*snake_case		,**snake_case				)
    @contextmanager
    def 				_SCREAMING_SNAKE_CASE	(  self				):



           '''simple docstring'''







           warnings.warn(
               """`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your """
               """labels by using the argument `text` of the regular `__call__` method (either in the same call as """
               """your audio inputs, or in a separate call."""				)
           lowercase							:					str	     =				True
           lowercase							:					List[str]	     =				self.tokenizer
           yield
           lowercase							:					Union[str, Any]	     =				self.feature_extractor
           lowercase							:					Any	     =				False


import math
from datetime import datetime, timedelta







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   datetime:
       lowercase							:					Any	     =				year % 19
       lowercase							:					Optional[int]	     =				year % 4
       lowercase							:					Any	     =				year % 7
       lowercase							:					str	     =				math.floor(year / 100    )
       lowercase							:					List[str]	     =				math.floor((13 + 8 * leap_day_inhibits) / 25    )
       lowercase							:					Tuple	     =				leap_day_inhibits / 4
       lowercase							:					Any	     =				(
           15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
       ) % 30
       lowercase							:					Union[str, Any]	     =				(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

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

       # PHM -> Paschal Full Moon
       lowercase							:					List[Any]	     =				(
           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(SCREAMING_SNAKE_CASE__ ,     4 ,     19    )
       elif days_to_add == 28 and days_from_phm_to_sunday == 6:
              return datetime(SCREAMING_SNAKE_CASE__ ,     4 ,     18    )
       else:
              return datetime(SCREAMING_SNAKE_CASE__ ,     3 ,     22    ) + timedelta(
                  days=int(days_to_add + days_from_phm_to_sunday    )    )


if __name__ == "__main__":
  for year in (1994, 2000, 2010, 2021, 2023):
    lowercase  : List[str]						   =							"""will be""" if year > datetime.now().year else """was"""
    print(F'''Easter in {year} {tense} {gauss_easter(year)}''')
