



"""simple docstring"""
import os
import unittest

from transformers import FunnelTokenizer, FunnelTokenizerFast
from transformers.models.funnel.tokenization_funnel import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin



@require_tokenizers
class    SCREAMING_SNAKE_CASE__						(      UpperCAmelCase__   ,    unittest.TestCase				):
   __lowerCAmelCase						:     List[Any]		=		FunnelTokenizer
   __lowerCAmelCase						:     Optional[int]		=		FunnelTokenizerFast
   __lowerCAmelCase						:     List[Any]		=		True
   __lowerCAmelCase						:     Optional[int]		=		True

   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[str]:





    '''simple docstring'''




    super().setUp()

    UpperCAmelCase			:      Any			=			[
        """<unk>""",
        """<cls>""",
        """<sep>""",
        """want""",
        """##want""",
        """##ed""",
        """wa""",
        """un""",
        """runn""",
        """##ing""",
        """,""",
        """low""",
        """lowest""",
    ]
    UpperCAmelCase			:      Tuple			=			os.path.join(self.tmpdirname   ,  VOCAB_FILES_NAMES["""vocab_file"""]		)
    with open(self.vocab_file   ,  """w"""   ,  encoding="""utf-8"""		) as vocab_writer:
     vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]		)		)

   def 			SCREAMING_SNAKE_CASE  (     self   ,  **_SCREAMING_SNAKE_CASE		)						->   Any:





    '''simple docstring'''




    return FunnelTokenizer.from_pretrained(self.tmpdirname   ,  **_SCREAMING_SNAKE_CASE		)

   def 			SCREAMING_SNAKE_CASE  (     self   ,  **_SCREAMING_SNAKE_CASE		)						->   str:





    '''simple docstring'''




    return FunnelTokenizerFast.from_pretrained(self.tmpdirname   ,  **_SCREAMING_SNAKE_CASE		)

   def 			SCREAMING_SNAKE_CASE  (     self   ,  _SCREAMING_SNAKE_CASE		)						->   str:





    '''simple docstring'''




    UpperCAmelCase			:      Optional[int]			=			"""UNwant\u00E9d,running"""
    UpperCAmelCase			:      Tuple			=			"""unwanted, running"""
    return input_text, output_text

   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[str]:





    '''simple docstring'''




    UpperCAmelCase			:      List[str]			=			self.tokenizer_class(self.vocab_file		)

    UpperCAmelCase			:      Optional[Any]			=			tokenizer.tokenize("""UNwant\u00E9d,running"""		)
    self.assertListEqual(_SCREAMING_SNAKE_CASE   ,  ["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""]		)
    self.assertListEqual(tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE		)   ,  [7, 4, 5, 10, 8, 9]		)




   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Dict:





    '''simple docstring'''




    UpperCAmelCase			:      Optional[int]			=			self.get_tokenizers(do_lower_case=_SCREAMING_SNAKE_CASE		)
    for tokenizer in tokenizers:
     UpperCAmelCase			:      List[Any]			=			tokenizer("""UNwant\u00E9d,running"""		)
     UpperCAmelCase			:      List[Any]			=			len(inputs["""input_ids"""]		) - 1
     self.assertListEqual(inputs["""token_type_ids"""]   ,  [2] + [0] * sentence_len		)

     UpperCAmelCase			:      Union[str, Any]			=			tokenizer("""UNwant\u00E9d,running"""   ,  """UNwant\u00E9d,running"""		)
     self.assertListEqual(inputs["""token_type_ids"""]   ,  [2] + [0] * sentence_len + [1] * sentence_len		)





"""simple docstring"""
import math
from datetime import datetime, timedelta

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

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

 # PHM -> Paschal Full Moon
 UpperCAmelCase			:      Tuple			=			(
     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(UpperCamelCase    ,	4    ,	19		)
 elif days_to_add == 28 and days_from_phm_to_sunday == 6:
  return datetime(UpperCamelCase    ,	4    ,	18		)
 else:
  return datetime(UpperCamelCase    ,	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):
            A:     Any										=	"will be" if year > datetime.now().year else "was"
            print(f"""Easter in {year} {tense} {gauss_easter(year)}""")
