


'''simple docstring'''







from unittest import TestCase

from datasets import Sequence, Value
from datasets.arrow_dataset import Dataset
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_	):



     """simple docstring"""






     def a	( self   ):

            '''simple docstring'''

            return [
                {"col_1": 3, "col_2": "a"},
                {"col_1": 2, "col_2": "b"},
                {"col_1": 1, "col_2": "c"},
                {"col_1": 0, "col_2": "d"},
            ]







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Tuple   			=       {'col_1': [3, 2, 1, 0], 'col_2': ['a', 'b', 'c', 'd']}
            return Dataset.from_dict(snake_case__   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Any   			=       self._create_example_records()
            _lowerCAmelCase    :							Dict   			=       Dataset.from_list(snake_case__   )
            self.assertListEqual(dset.column_names      ,	['col_1', 'col_2']   )
            for i, r in enumerate(snake_case__   ):
                   self.assertDictEqual(snake_case__      ,	example_records[i]   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[str]   			=       self._create_example_records()
            _lowerCAmelCase    :							List[Any]   			=       Dataset.from_list(snake_case__   )
            _lowerCAmelCase    :							List[str]   			=       Dataset.from_dict({k: [r[k] for r in example_records] for k in example_records[0]}   )
            self.assertEqual(dset.info      ,	dset_from_dict.info   )







     def a	( self   ):  # checks what happens with missing columns

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       [{'col_1': 1}, {'col_2': 'x'}]
            _lowerCAmelCase    :							List[str]   			=       Dataset.from_list(snake_case__   )
            self.assertDictEqual(dset[0]      ,	{'col_1': 1}   )
            self.assertDictEqual(dset[1]      ,	{'col_1': None}   )  # NB: first record is used for columns







     def a	( self   ):  # checks if the type can be inferred from the second record

            '''simple docstring'''

            _lowerCAmelCase    :							Dict   			=       [{'col_1': []}, {'col_1': [1, 2]}]
            _lowerCAmelCase    :							Optional[Any]   			=       Dataset.from_list(snake_case__   )
            self.assertEqual(dset.info.features['col_1']      ,	Sequence(Value('int64'   )   )   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Union[str, Any]   			=       Dataset.from_list([]   )
            self.assertEqual(len(snake_case__   )      ,	0   )
            self.assertListEqual(dset.column_names      ,	[]   )





'''simple docstring'''







import math
from datetime import datetime, timedelta






def 			lowercase				(_A					):







       """simple docstring"""







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

       # days to be added to March 21
       _lowerCAmelCase    :							Dict   			=       (1_9 * metonic_cycle + secular_moon_shift) % 3_0

       # PHM -> Paschal Full Moon
       _lowerCAmelCase    :							Union[str, Any]   			=       (
           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(_A   ,						4   ,						1_9					)
       elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
              return datetime(_A   ,						4   ,						1_8					)
       else:
              return datetime(_A   ,						3   ,						2_2					) + timedelta(
                  days=int(days_to_add + days_from_phm_to_sunday					)					)


if __name__ == "__main__":
       for year in (19_94, 20_00, 20_10, 20_21, 20_23):
              lowerCAmelCase    :     List[str]					=						"""will be""" if year > datetime.now().year else """was"""
              print(F'''Easter in {year} {tense} {gauss_easter(year)}''')

