
import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_squeezebert import SqueezeBertTokenizer


lowercase  : Tuple						   =						logging.get_logger(__name__)

lowercase  : List[Any]						   =						{"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

lowercase  : List[str]						   =						{
    """vocab_file""": {
        """squeezebert/squeezebert-uncased""": (
            """https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/vocab.txt"""
        ),
        """squeezebert/squeezebert-mnli""": """https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/vocab.txt""",
        """squeezebert/squeezebert-mnli-headless""": (
            """https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/vocab.txt"""
        ),
    },
    """tokenizer_file""": {
        """squeezebert/squeezebert-uncased""": (
            """https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/tokenizer.json"""
        ),
        """squeezebert/squeezebert-mnli""": (
            """https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/tokenizer.json"""
        ),
        """squeezebert/squeezebert-mnli-headless""": (
            """https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/tokenizer.json"""
        ),
    },
}

lowercase  : Tuple						   =						{
    """squeezebert/squeezebert-uncased""": 512,
    """squeezebert/squeezebert-mnli""": 512,
    """squeezebert/squeezebert-mnli-headless""": 512,
}


lowercase  : Dict						   =						{
    """squeezebert/squeezebert-uncased""": {"""do_lower_case""": True},
    """squeezebert/squeezebert-mnli""": {"""do_lower_case""": True},
    """squeezebert/squeezebert-mnli-headless""": {"""do_lower_case""": True},
}

class __snake_case		(				__a					):
    _a		:						Optional[Any]=    VOCAB_FILES_NAMES
    _a		:						int=    PRETRAINED_VOCAB_FILES_MAP
    _a		:						int=    PRETRAINED_INIT_CONFIGURATION
    _a		:						Dict=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    _a		:						List[str]=    SqueezeBertTokenizer
    def __init__(  self		,snake_case=None		,snake_case=None		,snake_case=True		,snake_case="[UNK]"		,snake_case="[SEP]"		,snake_case="[PAD]"		,snake_case="[CLS]"		,snake_case="[MASK]"		,snake_case=True		,snake_case=None		,**snake_case		,):



           '''simple docstring'''







           super().__init__(
               UpperCamelCase__		,tokenizer_file=UpperCamelCase__		,do_lower_case=UpperCamelCase__		,unk_token=UpperCamelCase__		,sep_token=UpperCamelCase__		,pad_token=UpperCamelCase__		,cls_token=UpperCamelCase__		,mask_token=UpperCamelCase__		,tokenize_chinese_chars=UpperCamelCase__		,strip_accents=UpperCamelCase__		,**UpperCamelCase__		,)

           lowercase							:					Any	     =				json.loads(self.backend_tokenizer.normalizer.__getstate__()				)
           if (
               normalizer_state.get("""lowercase"""		,UpperCamelCase__				) != do_lower_case
               or normalizer_state.get("""strip_accents"""		,UpperCamelCase__				) != strip_accents
               or normalizer_state.get("""handle_chinese_chars"""		,UpperCamelCase__				) != tokenize_chinese_chars
           ):
                  lowercase							:					List[str]	     =				getattr(UpperCamelCase__		,normalizer_state.pop("""type"""				)				)
                  lowercase							:					Optional[int]	     =				do_lower_case
                  lowercase							:					Dict	     =				strip_accents
                  lowercase							:					Tuple	     =				tokenize_chinese_chars
                  lowercase							:					List[str]	     =				normalizer_class(**UpperCamelCase__				)

           lowercase							:					str	     =				do_lower_case
    def 				_SCREAMING_SNAKE_CASE	(  self		,snake_case		,snake_case=None				):



           '''simple docstring'''







           lowercase							:					int	     =				[self.cls_token_id] + token_ids_a + [self.sep_token_id]

           if token_ids_a:
                  output += token_ids_a + [self.sep_token_id]

           return output
    def 				_SCREAMING_SNAKE_CASE	(  self		,snake_case		,snake_case = None				):



           '''simple docstring'''







           lowercase							:					Union[str, Any]	     =				[self.sep_token_id]
           lowercase							:					List[Any]	     =				[self.cls_token_id]
           if token_ids_a is None:
                  return len(cls + token_ids_a + sep				) * [0]
           return len(cls + token_ids_a + sep				) * [0] + len(token_ids_a + sep				) * [1]
    def 				_SCREAMING_SNAKE_CASE	(  self		,snake_case		,snake_case = None				):



           '''simple docstring'''







           lowercase							:					Tuple	     =				self._tokenizer.model.save(UpperCamelCase__		,name=UpperCamelCase__				)
           return tuple(UpperCamelCase__				)


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