Ejemplo n.º 1
0
def get_omer_time(user_data: UserData) -> Optional[str]:
    tz_name = TimezoneFinder().timezone_at(lat=user_data.latitude,
                                           lng=user_data.longitude)
    location = GeoLocation('',
                           user_data.latitude,
                           user_data.longitude,
                           time_zone=tz_name)
    calendar = ZmanimCalendar(60, geo_location=location, date=date.today())
    jcalendar = JewishCalendar.from_date(date.today())

    omer_day = jcalendar.day_of_omer()
    if not omer_day:
        return

    if jcalendar.is_assur_bemelacha(
    ) and jcalendar.is_tomorrow_assur_bemelacha():
        return
    elif jcalendar.is_tomorrow_assur_bemelacha():
        omer_time = calendar.candle_lighting()
    else:
        omer_time = calendar.tzais()

    if isinstance(omer_time, dt):
        return omer_time.isoformat()
Ejemplo n.º 2
0
 def test_candle_lighting_using_elevation(self):
     calendar = ZmanimCalendar(geo_location=test_helper.lakewood(), date=date(2017, 10, 17))
     calendar.use_elevation = True
     self.assertEqual(calendar.candle_lighting().replace(microsecond=0).isoformat(), "2017-10-17T17:55:58-04:00")
Ejemplo n.º 3
0
def get_yom_tov(name: str, date_: date, lat: float, lng: float, elevation: int,
                cl: int, havdala_opinion: HavdalaChoices) -> YomTov:
    """
    There are different holiday dates sets:
    [Y] - one yom tov — Generic yom tov in Israel
    [Y Y] - two yom tovs — Generic yom tov in diaspora
    [Y S] - one yom tov and shabbat
    [S Y Y]
    [Y S]
    [Y Y S]
    """
    tz = get_tz(lat, lng)
    diaspora = is_diaspora(tz)
    day_1_date = _get_first_day_date(name, date_, diaspora)

    shabbat_date = None
    day_2_date = None

    eve_date = day_1_date - 1  # Y

    if (diaspora
            and not name == 'yom_kippur') or name == 'rosh_hashana':  # Y Y
        day_2_date = day_1_date + 1
        # yt_dates.append(first_day + 1)

    last_yt_date = day_2_date or day_1_date

    if day_1_date.day_of_week == 1:  # S Y Y
        # eve_date = day_1_date - 2
        shabbat_date = day_1_date - 1
    elif last_yt_date.day_of_week == 6:  # Y S / Y Y S
        shabbat_date = last_yt_date + 1

    # checks
    assert eve_date.has_candle_lighting()
    assert day_1_date.is_assur_bemelacha()
    if day_2_date:
        assert day_2_date.is_yom_tov_sheni()
        assert day_2_date.is_assur_bemelacha()

    data = {}
    shabbat_term = None

    if shabbat_date and shabbat_date < day_1_date:
        shabbat_term = 'pre_shabbat'
        data[shabbat_term] = {'date': shabbat_date.gregorian_date}

    data['day_1'] = {'date': day_1_date.gregorian_date}

    if day_2_date:
        data['day_2'] = {'date': day_2_date.gregorian_date}

    if shabbat_date and shabbat_date > last_yt_date:
        shabbat_term = 'post_shabbat'
        data[shabbat_term] = {'date': shabbat_date.gregorian_date}

    if name == 'succot':
        date_hoshana_rabba = day_1_date + 6
        data['hoshana_rabba'] = date_hoshana_rabba.gregorian_date

    # zmanim calculation
    havdala_params = HAVDALA_PARAMS[havdala_opinion.name]

    location = GeoLocation('', lat, lng, tz, elevation)

    eve_zmanim_calc = ZmanimCalendar(cl,
                                     geo_location=location,
                                     date=eve_date.gregorian_date)
    first_day_calc = ZmanimCalendar(cl,
                                    geo_location=location,
                                    date=day_1_date.gregorian_date)

    if shabbat_date:
        shabbat_eve_date = shabbat_date - 1
        eve_shabbat_calc = ZmanimCalendar(cl,
                                          geo_location=location,
                                          date=shabbat_eve_date.gregorian_date)
        shabbat_calc = ZmanimCalendar(cl,
                                      geo_location=location,
                                      date=shabbat_date.gregorian_date)
        data[shabbat_term][
            'candle_lighting'] = eve_shabbat_calc.candle_lighting()

        if shabbat_date > day_1_date:
            data[shabbat_term]['havdala'] = shabbat_calc.tzais(havdala_params)

    if shabbat_term == 'pre_shabbat':
        data['day_1']['candle_lighting'] = eve_zmanim_calc.tzais(
            havdala_params)
    else:
        data['day_1']['candle_lighting'] = eve_zmanim_calc.candle_lighting()

    if not day_2_date:

        data['day_1']['havdala'] = first_day_calc.tzais(havdala_params)
        # return resp
    else:
        second_day_calc = ZmanimCalendar(cl,
                                         geo_location=location,
                                         date=day_2_date.gregorian_date)
        data['day_2']['candle_lighting'] = first_day_calc.tzais(havdala_params)
        if not shabbat_date or shabbat_date < day_2_date:
            data['day_2']['havdala'] = second_day_calc.tzais(havdala_params)

    part_2_data = {}
    if name == 'pesach':
        part_2 = get_yom_tov('pesach_2', date_, lat, lng, elevation, cl,
                             havdala_opinion)
        part_2_data = {
            'pesach_part_2_day_1': part_2.day_1,
            'pesach_part_2_day_2': part_2.day_2,
        }

    settings = Settings(cl_offset=cl,
                        havdala_opinion=havdala_opinion,
                        coordinates=(lat, lng),
                        elevation=elevation,
                        date=date_,
                        yomtov_name=name)
    return YomTov(settings=settings, **data, **part_2_data)