def __init__(self, geo_location: Optional[GeoLocation] = None, date: Optional[date] = None, calculator: Optional[AstronomicalCalculations] = None):
if geo_location is None:
geo_location = GeoLocation.GMT()
if date is None:
date = datetime.today()
if calculator is None:
calculator = NOAACalculator()
self.geo_location = geo_location
self.date = date
self.astronomical_calculator = calculator
def is_asur_bemelaha(dt_: dt, lat: float, lng: float,
elevation: float) -> BooleanResp:
# todo add tzeis option
tz = get_tz(lat, lng)
is_israel = not is_diaspora(tz)
location = GeoLocation('', lat, lng, tz, elevation)
calendar = ZmanimCalendar(geo_location=location, date=dt_.date())
dt_ = dt_.astimezone(pytz.timezone(tz))
resp = calendar.is_assur_bemelacha(current_time=dt_, in_israel=is_israel)
return BooleanResp(result=resp)
def fast(name: str, date_: date, lat: Optional[float], lng: Optional[float],
elevation: int, havdala_opinion: HavdalaChoices) -> Fast:
tz = get_tz(lat, lng)
diaspora = is_diaspora(tz)
is_9_av = True if name == 'fast_9_av' else None
havdala_params = HAVDALA_PARAMS[havdala_opinion.name]
data = {'moved_fast': False}
fast_date = _get_first_day_date(name, date_, diaspora)
# Deferred fasts
if name in ('fast_gedalia', 'fast_17_tammuz',
'fast_9_av') and fast_date.day_of_week == 7:
fast_date.forward(1)
data['moved_fast'] = True
if name == 'fast_esther' and fast_date.day_of_week == 7:
fast_date.forward(-2)
data['moved_fast'] = True
location = GeoLocation('', lat, lng, tz, elevation)
fast_calc = ZmanimCalendar(geo_location=location,
date=fast_date.gregorian_date)
if is_9_av:
eve_calc = ZmanimCalendar(geo_location=location,
date=(fast_date - 1).gregorian_date)
data['fast_start'] = eve_calc.shkia()
data['chatzot'] = fast_calc.chatzos()
else:
if fast_calc.alos():
data['fast_start'] = fast_calc.alos()
else:
eve_calc = ZmanimCalendar(geo_location=location,
date=(fast_date - 1).gregorian_date)
data['fast_start'] = eve_calc.chatzos() + timedelta(hours=12)
# calculate additional fast ending times:
# sunset = fast_calc.shkia()
# sba_time = (sunset + timedelta(minutes=31))
# nvr_time = (sunset + timedelta(minutes=28))
# ssk_time = (sunset + timedelta(minutes=25))
data['havdala'] = fast_calc.tzais(havdala_params)
settings = Settings(havdala_opinion=havdala_opinion,
coordinates=(lat, lng),
elevation=elevation,
date=date_,
fast_name=name)
return Fast(settings=settings, **data)
def molad_as_datetime(self) -> datetime:
m = self.molad()
location_name = 'Jerusalem, Israel'
latitude = 31.778 # Har Habayis latitude
longitude = 35.2354 # Har Habayis longitude
zone = tz.gettz('Asia/Jerusalem')
geo = GeoLocation(location_name, latitude, longitude, zone)
seconds = m.molad_chalakim * 10 / 3.0
seconds, microseconds = divmod(seconds * 10**6, 10**6)
# molad as local mean time
time = datetime(m.gregorian_year,
m.gregorian_month,
m.gregorian_day,
m.molad_hours,
m.molad_minutes,
int(seconds),
int(microseconds),
tzinfo=tz.gettz('Etc/GMT-2'))
# molad as Jerusalem standard time
micro_offset = geo.local_mean_time_offset() * 1000
time -= timedelta(microseconds=micro_offset)
# molad as UTC
return time.astimezone(tz.UTC)
def get_zmanim(date_: date, lat: float, lng: float, elevation: float,
settings: ZmanimRequest) -> ZmanimResponse:
tz = get_tz(lat, lng)
jewish_date = JewishDate(date_).jewish_date
jewish_date = f'{jewish_date[0]}-{jewish_date[1]}-{jewish_date[2]}'
location = GeoLocation('', lat, lng, tz, elevation)
calendar = ZmanimCalendar(geo_location=location, date=date_)
zmanim = _calculate_zmanim(calendar, settings)
settings = Settings(date=date_,
coordinates=(lat, lng),
elevation=elevation,
jewish_date=jewish_date)
return ZmanimResponse(settings=settings, **zmanim)
async def get_zmanim(lang: str, date: Date, lat: float, lng: float,
elevation: float, settings: ZmanimSettingsModel) -> dict:
# cl?
_ = get_translator(lang)
tz = get_tz(lat, lng)
location = GeoLocation('', lat, lng, tz, elevation)
calendar = ZmanimCalendar(geo_location=location, date=date)
zmanim = _calculate_zmanim(calendar, settings)
return zmanim
raw_data = await get_calendar_data(tz, date, lat, lng)
zmanim_data: dict = raw_data['zmanim']
# select only needed zmanim
zmanim_data = {k: v for k, v in zmanim_data.items() if settings[k]}
# translate zmanim
zmanim_data = {_(txt.zmanim_names[k]): v for k, v in zmanim_data.items()}
return zmanim_data
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()
def test_local_mean_time_offset_on_center_meridian(self):
geo = GeoLocation('Sample', 40, -75, 'America/New_York')
self.assertEqual(geo.local_mean_time_offset(), 0)
def test_local_mean_time_offset_for_gmt(self):
geo = GeoLocation.GMT()
self.assertEqual(geo.local_mean_time_offset(), 0)
def hooper_bay():
return GeoLocation('Hooper Bay, Alaska',
61.520182,
-166.1740437,
'America/Anchorage',
elevation=8)
def los_angeles():
return GeoLocation('Los Angeles, CA',
34.0201613,
-118.6919095,
'America/Los_Angeles',
elevation=71)
def tokyo():
return GeoLocation('Tokyo, Japan',
35.6733227,
139.6403486,
'Asia/Tokyo',
elevation=40)
def test_standard_time_offset_for_standard_timezone(self):
geo = GeoLocation.GMT()
geo.time_zone = 'America/New_York'
self.assertEqual(geo.standard_time_offset(), -5 * GeoLocation.HOUR_MILLIS)
def test_longitude_cartography_west(self):
geo = GeoLocation.GMT()
geo.longitude = 41, 7, 5.17296, 'W'
self.assertEqual(geo.longitude, -41.1181036)
def test_longitude_numeric(self):
geo = GeoLocation.GMT()
geo.longitude = 23.4
self.assertEqual(geo.longitude, 23.4)
def test_latitude_cartography_south(self):
geo = GeoLocation.GMT()
geo.latitude = 41, 7, 5.17296, 'S'
self.assertEqual(geo.latitude, -41.1181036)
def test_latitude_numeric(self):
geo = GeoLocation.GMT()
geo.latitude = 33.3
self.assertEqual(geo.latitude, 33.3)
def test_entry(time, tz):
geo = GeoLocation('Sample', 0, 0, tz)
return time, tz, geo.time_zone_offset_at(parser.parse(time))
def daneborg():
return GeoLocation('Daneborg, Greenland',
74.2999996,
-20.2420877,
'America/Godthab',
elevation=0)
def test_local_mean_time_offset_west_of_center_meridian(self):
geo = GeoLocation('Sample', 40, -76.25, 'America/New_York')
self.assertEqual(geo.local_mean_time_offset(), -1.25 * 4 * GeoLocation.MINUTE_MILLIS)
def test_standard_time_offset_for_gmt(self):
geo = GeoLocation.GMT()
self.assertEqual(geo.standard_time_offset(), 0)
def test_time_zone_with_string(self):
geo = GeoLocation.GMT()
geo.time_zone = 'America/New_York'
self.assertTrue(geo.time_zone._filename.endswith('/America/New_York'))
def test_time_zone_with_timezone_object(self):
geo = GeoLocation.GMT()
geo.time_zone = tz.gettz('America/New_York')
self.assertTrue(geo.time_zone._filename.endswith('/America/New_York'))
def lakewood():
return GeoLocation('Lakewood, NJ',
40.0721087,
-74.2400243,
'America/New_York',
elevation=15)
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)
def test_antimeridian_adjustment_for_standard_timezone(self):
geo = GeoLocation.GMT()
geo.time_zone = 'America/New_York'
self.assertEqual(geo.antimeridian_adjustment(), 0)
from zmanim.zmanim_calendar import ZmanimCalendar
from zmanim.util.geo_location import GeoLocation
location = GeoLocation(name='d',
latitude=34.837758,
longitude=32.090277,
time_zone='Asia/Hebron')
calendar = ZmanimCalendar(geo_location=location)
calendar.tzais()
def test_antimeridian_adjustment_for_westward_crossover(self):
geo = GeoLocation.GMT()
geo.longitude = 179
geo.time_zone = 'Etc/GMT+12'
self.assertEqual(geo.antimeridian_adjustment(), 1)
def test_antimeridian_adjustment_for_gmt(self):
geo = GeoLocation.GMT()
self.assertEqual(geo.antimeridian_adjustment(), 0)
def arctic_nunavut():
return GeoLocation('Fort Conger, NU Canada',
81.7449398,
-64.7945858,
'America/Toronto',
elevation=127)
