def alternate_hebrew_date(self): """Get the day's Hebrew date if it's before the alternate_nighttime The default TimeInfo.hebrew_date bases its date on sunset. Use this attribute to base the Hebrew date on the alternate date Returns: tuple -- hebrew date formated as (year, month, day) """ if self.is_night(): if self.date_time < self.alternate_nighttime(): date_time = self.date_time greg_year = int(date_time.strftime("%Y")) greg_month = int(date_time.strftime("%m")) greg_day = int(date_time.strftime("%d")) alternate_hebrew_date = hebrew.from_gregorian( greg_year, greg_month, greg_day) else: alternate_hebrew_date = self.hebrew_date() else: alternate_hebrew_date = self.hebrew_date() return alternate_hebrew_date
def get_dates(birthday): dates = [] first_year, month, day = hebrew.from_gregorian(*birthday) for year in range(first_year, first_year + MAX_AGE): gregorian_date = hebrew.to_gregorian(year, month, day) dates.append(date(*gregorian_date)) return dates
def get_hebrew_date(dt_obj:datetime) -> tuple: """ :param dt_obj : datetime object :return: en date and he date for Hebrew date """ from convertdate import hebrew months = [ ("Nisan", "ניסן"), ("Iyar", "אייר"), ("Sivan", "סיוון"), ("Tammuz", "תמוז"), ("Av", "אב"), ("Elul", "אלול"), ("Tishrei", "תשרי"), ("Cheshvan", "חשון"), ("Kislev", "כסלו"), ("Tevet", "טבת"), ("Shevat", "שבט"), ("Adar", "אדר"), ("Adar II", "אדר ב׳"), ] y, m, d = hebrew.from_gregorian(dt_obj.year, dt_obj.month, dt_obj.day) en = "{} {}, {}".format(months[m-1][0], d, y) he = "{} {}, {}".format(months[m-1][1], d, y) return en, he
def getHebrewCalendarDateName( n ): if not isinstance( n, RPNDateTime ): raise ValueError( 'time type required for this operator' ) date = hebrew.from_gregorian( n.year, n.month, n.day ) return hebrewDays[ n.weekday( ) ] + ', ' + hebrewMonths[ date[ 1 ] - 1 ] + \ ' ' + str( date[ 2 ] ) + ', ' + str( date[ 0 ] )
def test_returntype(self): self.assertSequenceType(coptic.from_gregorian(2020, 6, 4), int) self.assertSequenceType(hebrew.from_gregorian(2020, 6, 4), int) self.assertSequenceType(islamic.from_gregorian(2020, 6, 4), int) self.assertSequenceType(indian_civil.from_gregorian(2020, 6, 4), int) self.assertSequenceType(iso.from_gregorian(2020, 6, 4), int) self.assertSequenceType(julian.from_gregorian(2020, 6, 4), int) self.assertSequenceType(persian.from_gregorian(2020, 6, 4), int)
def hebrew_date(self): """Return the Hebrew date as a tuple Returns: tuple -- Hebrew date (year, month, day) """ if self.is_night() and self.is_pm(): date_time = self.date_time + timedelta(days=1) else: date_time = self.date_time greg_year = int(date_time.strftime("%Y")) greg_month = int(date_time.strftime("%m")) greg_day = int(date_time.strftime("%d")) return hebrew.from_gregorian(greg_year, greg_month, greg_day)
def plus_thirteen(greg): greg2 = greg + timedelta(days=1) (hy,hm,hd)= hebrew.from_gregorian(greg2.year,greg2.month,greg2.day) if hebrew.year_months(hy+13) >= hm: if hebrew.month_days(hy+13,hm) >= hd: #month and day fit hdate = (hy+13,hm,hd) elif hebrew.year_months(hy+13) >= hm + 1: #another month in year, not enough days in month if (hm+1 == 7): hdate = (hy + 14,hm+1,1) else: hdate = (hy + 13,hm+1,1) else: #not enough months in year, not enough days in month hdate = (hy + 13, 1,1) else: #not enough months in year hdate = (hy+13,1,1) return hdate
def get_rh(loc, lang): tz = f.get_tz_by_location(loc) tz_time = pytz.timezone(tz) now = datetime.now(tz_time) hebrew_date = hebrew.from_gregorian(now.year, now.month, now.day) # проверка на рош ашану if hebrew_date[1] == 6: hebrew_date = ( hebrew_date[0], hebrew_date[1] + 1, hebrew_date[2] ) url = f'{URL}/getHolidayCalData.php?hebrewYear={hebrew_date[0]}' chodesh_dict = get_chodesh_dict(hebrew_date, url) length_of_rh = get_rh_lenght(hebrew_date) length_str = f'{length_of_rh}' if lang == 'Русский': rh = 'Месяц: {month}\n' \ 'Продолжительность Рош Ходеша: {length} {length_r}\n' \ 'Рош Ходеш: {rh}\n' \ 'Молад: {mol}'.format( month=data.jewish_months[get_month_name(chodesh_dict)], length=length_str, length_r=data.length_r[length_str], rh=get_rh_date_and_day(hebrew_date, length_of_rh, lang), mol=get_molad(chodesh_dict, lang) ) elif lang == 'English': rh = 'Month: {month}\n' \ 'Rosh Chodesh duration: {length} {length_r}\n' \ 'Rosh Chodesh: {rh}\n' \ 'Molad: {mol}'.format( month=get_month_name(chodesh_dict), length=length_str, length_r=data.length_e[length_str], rh=get_rh_date_and_day(hebrew_date, length_of_rh, lang), mol=get_molad(chodesh_dict, lang) ) return rh
def getHebrewCalendarDateNameOperator( n ): date = hebrew.from_gregorian( n.year, n.month, n.day ) return hebrewDays[ n.weekday( ) ] + ', ' + hebrewMonths[ date[ 1 ] - 1 ] + \ ' ' + str( date[ 2 ] ) + ', ' + str( date[ 0 ] )
def getHebrewCalendarDateOperator( n ): return list( hebrew.from_gregorian( n.year, n.month, n.day ) )
def moonphase(year, month, day, do_print=False): h = year // 100 # integer division for the century yy = year % 100 # year within the century # The "golden number" for this year is the year modulo 19, but # adjusted to be centered around 0 -- i.e., -9 to 9 instead # of 0 to 19. This improves the accuracy of the approximation # to within +/- 1 day. g = (yy + 9) % 19 - 9 # There is an interesting 6 century near-repetition in the # century correction. It would be interesting to find a # algorithm that handles the different corrections between # centuries 17|23|29, 20|26, 21|27, and 24|30. try: c = {17:7, 18:1, 19:-4, 20:-8, 21:16, 22:11, 23:6, 24:1, 25:-4, 26:-9, 27:15, 28:11, 29:6, 30:0}[h] except KeyError: print("No century correction available for {}00-{}99".format(h,h)) return # Golden number correction: modulo 30, from -29 to 29. gc = g * 11 while ( gc < -29 ): gc += 30; if (gc > 0): gc %= 30; # January/February correction: if month < 3: mc = 2 else: mc = 0 phase = (month + mc + day + gc + c + 30 ) % 30 if (do_print): # It's nice to see what the Golden correction for the year # plus the century correction is. This lets us quickly calculate the # correction for any other date in the same year. gcpc = (gc + c) % 30 if gcpc <= 0: gcpc_alt = gcpc + 30 else: gcpc_alt = gcpc - 30 print("yy =", yy) print("g =", g) print("month + day + mc =", month + day + mc) print("gc =", gc) print("c =", c) print("Dates in the year", year, "have moon phase correction gc + c =", gcpc, "or", gcpc_alt) print(("\n\t{:04}/{:02}/{:02} has " "estimated moon phase = {}\n").format(year, month, day, phase)) if phase < 2: print("\tNew moon [or slightly after]") elif phase < 7: print("\tWaxing crescent") elif phase < 9: print("\tFirst quarter") elif phase < 14: print("\tWaxing gibbous") elif phase < 16: print("\tFull moon") elif phase < 22: print("\tWaning gibbous") elif phase < 24: print("\tLast quarter") elif phase < 29: print("\tWaning (de)crescent") elif phase < 31: print("\tNew moon [or slightly before]") try: # If you have the ephem package installed, you # can compare the estimate to the actual lunar phase import ephem thisdate = ephem.Date('{:04}/{:02}/{:02} 00:00:01'.format(year, month, day)) prevmoon = ephem.previous_new_moon(thisdate) nextmoon = ephem.next_new_moon(thisdate) prevfull = ephem.previous_full_moon(thisdate) nextfull = ephem.next_full_moon(thisdate) prevymd = prevmoon.tuple()[:3] nextymd = nextmoon.tuple()[:3] pfymd = prevfull.tuple()[:3] nfymd = nextfull.tuple()[:3] print("\n\t{}".format(prevmoon), "UTC = Previous New Moon") print("\t{}".format(nextmoon), "UTC = Next New Moon") print("\t{}".format(prevfull), "UTC = Previous Full Moon") print("\t{}".format(nextfull), "UTC = Next Full Moon") try: from convertdate import julianday thisjdc = julianday.from_gregorian(year, month, day) prevjdc = julianday.from_gregorian(*prevymd) nextjdc = julianday.from_gregorian(*nextymd) pfjdc = julianday.from_gregorian(*pfymd) nfjdc = julianday.from_gregorian(*nfymd) print("\t{:2} days since prev new moon".format(int(thisjdc - prevjdc))) print("\t{:2} days until next new moon".format(int(nextjdc - thisjdc))) print("\t{:2} days since prev full moon".format(int(thisjdc - pfjdc))) print("\t{:2} days until next full moon".format(int(nfjdc - thisjdc))) except: print("julianday doesn't work") pass except: pass try: # If you have convertdate installed, you can compare the lunar # phase to the hebrew calendar date: from convertdate import hebrew hyear, hmonth, hday = hebrew.from_gregorian(year, month, day) print("\n\tHebrew date = {} {}, {}\n".format( hday, hmonths[hmonth], hyear )) except: pass return phase
def moonphase(year, month, day, do_print=False): h = year // 100 # integer division for the century yy = year % 100 # year within the century # The "golden number" for this year is the year modulo 19, but # adjusted to be centered around 0 -- i.e., -9 to 9 instead # of 0 to 19. This improves the accuracy of the approximation # to within +/- 1 day. g = (yy + 9) % 19 - 9 # There is an interesting 6 century near-repetition in the # century correction. It would be interesting to find a # algorithm that handles the different corrections between # centuries 17|23|29, 20|26, 21|27, and 24|30. try: c = { 17: 7, 18: 1, 19: -4, 20: -8, 21: 16, 22: 11, 23: 6, 24: 1, 25: -4, 26: -9, 27: 15, 28: 11, 29: 6, 30: 0 }[h] except KeyError: print("No century correction available for {}00-{}99".format(h, h)) return # Golden number correction: modulo 30, from -29 to 29. gc = g * 11 while (gc < -29): gc += 30 if (gc > 0): gc %= 30 # January/February correction: if month < 3: mc = 2 else: mc = 0 phase = (month + mc + day + gc + c + 30) % 30 if (do_print): # It's nice to see what the Golden correction for the year # plus the century correction is. This lets us quickly calculate the # correction for any other date in the same year. gcpc = (gc + c) % 30 if gcpc <= 0: gcpc_alt = gcpc + 30 else: gcpc_alt = gcpc - 30 print("yy =", yy) print("g =", g) print("month + day + mc =", month + day + mc) print("gc =", gc) print("c =", c) print("Dates in the year", year, "have moon phase correction gc + c =", gcpc, "or", gcpc_alt) print(("\n\t{:04}/{:02}/{:02} has " "estimated moon phase = {}\n").format(year, month, day, phase)) if phase < 2: print("\tNew moon [or slightly after]") elif phase < 7: print("\tWaxing crescent") elif phase < 9: print("\tFirst quarter") elif phase < 14: print("\tWaxing gibbous") elif phase < 16: print("\tFull moon") elif phase < 22: print("\tWaning gibbous") elif phase < 24: print("\tLast quarter") elif phase < 29: print("\tWaning (de)crescent") elif phase < 31: print("\tNew moon [or slightly before]") try: # If you have the ephem package installed, you # can compare the estimate to the actual lunar phase import ephem thisdate = ephem.Date('{:04}/{:02}/{:02} 00:00:01'.format( year, month, day)) prevmoon = ephem.previous_new_moon(thisdate) nextmoon = ephem.next_new_moon(thisdate) prevfull = ephem.previous_full_moon(thisdate) nextfull = ephem.next_full_moon(thisdate) prevymd = prevmoon.tuple()[:3] nextymd = nextmoon.tuple()[:3] pfymd = prevfull.tuple()[:3] nfymd = nextfull.tuple()[:3] print("\n\t{}".format(prevmoon), "UTC = Previous New Moon") print("\t{}".format(nextmoon), "UTC = Next New Moon") print("\t{}".format(prevfull), "UTC = Previous Full Moon") print("\t{}".format(nextfull), "UTC = Next Full Moon") try: from convertdate import julianday thisjdc = julianday.from_gregorian(year, month, day) prevjdc = julianday.from_gregorian(*prevymd) nextjdc = julianday.from_gregorian(*nextymd) pfjdc = julianday.from_gregorian(*pfymd) nfjdc = julianday.from_gregorian(*nfymd) print("\t{:2} days since prev new moon".format( int(thisjdc - prevjdc))) print("\t{:2} days until next new moon".format( int(nextjdc - thisjdc))) print("\t{:2} days since prev full moon".format( int(thisjdc - pfjdc))) print("\t{:2} days until next full moon".format( int(nfjdc - thisjdc))) except: print("julianday doesn't work") pass except: pass try: # If you have convertdate installed, you can compare the lunar # phase to the hebrew calendar date: from convertdate import hebrew hyear, hmonth, hday = hebrew.from_gregorian(year, month, day) print("\n\tHebrew date = {} {}, {}\n".format( hday, hmonths[hmonth], hyear)) except: pass return phase
def do_the_things(lat, lon, chagdays=2, offset=0): tf = TimezoneFinder() tzname = tf.timezone_at(lng=lon, lat=lat) try: tz = pytz.timezone(tzname) except pytz.exceptions.UnknownTimeZoneError: tz = pytz.timezone('UTC') now = datetime.datetime.now(tz=tz) if offset is not None: now += datetime.timedelta(minutes=offset) noon = tz.localize( datetime.datetime(year=now.year, month=now.month, day=now.day, hour=12, minute=30)) today = now.date() tomorrow = today + datetime.timedelta(days=1) # Get Hebrew calendar dates hebtoday = hebrew.from_gregorian(today.year, today.month, today.day) hebtomorrow = hebrew.from_gregorian(tomorrow.year, tomorrow.month, tomorrow.day) hebmonthtoday = hebrew_monthname(hebtoday) hebmonthtomorrow = hebrew_monthname(hebtomorrow) omertoday = omer_day(hebtoday) omertonight = omer_day(hebtomorrow) # Set up ephem info to determine sunset and nightfall herenow = ephem.Observer() herenow.lat, herenow.lon = lat * ephem.pi / 180, lon * ephem.pi / 180 herenow.date = ephem.Date(now.astimezone(pytz.utc)) herenoon = ephem.Observer() herenoon.lat, herenoon.lon = lat * ephem.pi / 180, lon * ephem.pi / 180 herenoon.date = ephem.Date(noon.astimezone(pytz.utc)) sun = ephem.Sun() # Determine "set" and "dark" for today (may be in the past) try: todayrise_eph = herenoon.previous_rising(sun) todayrise = pytz.utc.localize(todayrise_eph.datetime()).astimezone(tz) todayrise_txt = todayrise.isoformat(timespec='seconds') tonightset_eph = herenoon.next_setting(sun) tonightset = pytz.utc.localize( tonightset_eph.datetime()).astimezone(tz) tonightset_txt = tonightset.isoformat(timespec='seconds') except ephem.NeverUpError: todayrise_txt = 'downallday' tonightset_txt = 'downallday' except ephem.AlwaysUpError: todayrise_txt = 'upallday' tonightset_txt = 'upallday' oldhorizon = herenoon.horizon oldpressure = herenoon.pressure herenoon.pressure = 0 # All horizon math is from top of sun disk # We need to take into account sun's radius, averaging .266 degrees herenoon.horizon = "-8.233" # middle of sun 8.5 deg try: tonightdark_eph = herenoon.next_setting(sun) tonightdark = pytz.utc.localize( tonightdark_eph.datetime()).astimezone(tz) tonightdark_txt = tonightdark.isoformat(timespec='seconds') except ephem.NeverUpError: tonightdark_txt = 'alwaysdark' except ephem.AlwaysUpError: tonightdark_txt = 'none' herenoon.horizon = oldhorizon herenoon.pressure = oldpressure # Status of sun, handle no-rise/no-set cases first if todayrise_txt == "upallday": sunnow = "up" elif (todayrise_txt == 'downallday' and (tonightdark == 'alwaysdark' or tonightdark < now)): sunnow = "down" elif todayrise_txt == 'downallday': sunnow = "twilight" # normal cases elif todayrise > now: sunnow = "notyetup" elif tonightset > now: sunnow = "up" elif (tonightdark_txt == 'none' or tonightdark > now): sunnow = "twilight" else: sunnow = "down" # Is it Shabbat or a holiday? shabbat_or_holiday_today = (today.isoweekday() == 6) if (jewish_holiday(date=hebtoday, chagdays=chagdays)): shabbat_or_holiday_today = True shabbat_or_holiday_tonight = (today.isoweekday() == 5) if (jewish_holiday(date=hebtomorrow, chagdays=chagdays)): shabbat_or_holiday_tonight = True # Combine hebdate logic and shabbat/holiday logic with sun up/down logic if (sunnow == "notyetup" or sunnow == "up"): shabbat_or_holiday_now = shabbat_or_holiday_today hebrew_date_now = "{} {}, {}".format(hebtoday[2], hebmonthtoday, hebtoday[0]) omernow = omertoday elif (sunnow == "down"): shabbat_or_holiday_now = shabbat_or_holiday_tonight hebrew_date_now = "{} {}, {}".format(hebtomorrow[2], hebmonthtomorrow, hebtomorrow[0]) omernow = omertonight elif (sunnow == "twilight"): shabbat_or_holiday_now = (shabbat_or_holiday_today or shabbat_or_holiday_tonight) hebrew_date_now = "indeterminate" if omertoday > 0 and omertonight > 0: omernow = omertoday + 0.5 else: omernow = 0 else: raise ValueError("How is the sun not up or down or twilight?") # time for output to_return = {} to_return["results"] = { "now": now.astimezone(tz).isoformat(timespec='seconds'), "sunrise": todayrise_txt, "sunset": tonightset_txt, "jewish_twilight_end": tonightdark_txt, "sun_now": sunnow, "hebrew_date_today": "{} {}, {}".format(hebtoday[2], hebmonthtoday, hebtoday[0]), "hebrew_date_tonight": "{} {}, {}".format(hebtomorrow[2], hebmonthtomorrow, hebtomorrow[0]), "hebrew_date_now": hebrew_date_now, "shabbat_or_yom_tov_today": shabbat_or_holiday_today, "shabbat_or_yom_tov_tonight": shabbat_or_holiday_tonight, "shabbat_or_yom_tov_now": shabbat_or_holiday_now, } if omertoday > 0: to_return["results"]["omer_today"] = omertoday if omertonight > 0: to_return["results"]["omer_tonight"] = omertonight if omernow > 0: to_return["results"]["omer_now"] = omernow return json.dumps(to_return)
def to_heb_year_month_day(d): return hebrew.from_gregorian(d.year, d.month, d.day)
import pandas as pd from dateutil import rrule, parser from convertdate import hebrew date1 = '2001-01-01' date2 = '2020-01-01' datesx = list( rrule.rrule(rrule.DAILY, dtstart=parser.parse(date1), until=parser.parse(date2))) hebrewCalendar = pd.DataFrame() hebrewCalendar['date'] = datesx hebrewCalendar['hebrewDate'] = hebrewCalendar['date'].apply( lambda x: hebrew.from_gregorian(x.year, x.month, x.day)) hebrewCalendar['hebrewMonth'] = hebrewCalendar['hebrewDate'].apply( lambda x: x[1]) hebrewCalendar['hebrewYear'] = hebrewCalendar['hebrewDate'].apply( lambda x: x[0]) Hebrew_months = { 1: 'NISAN', 2: 'IYYAR', 3: 'SIVAN', 4: 'TAMMUZ', 5: 'AV', 6: 'ELUL', 7: 'TISHRI', 8: 'HESHVAN',
# !/usr/bin/env python # -*- coding: utf-8 -*- # Load all the settings from the json file with open('settings.json') as s: obj = s.read() settings = json.loads(obj) SENDER_EMAIL = settings["SENDER_EMAIL"] SENDER_PASSWORD = settings["SENDER_PASSWORD"] TIME = settings["TIME"] # Get today and convert it to Hebrew today_gregorian_date = datetime.datetime.now() today_hebrew_date = dates.HebrewDate.today() year = hebrew.from_gregorian(today_gregorian_date.year, today_gregorian_date.month, today_gregorian_date.day) year = year[0] # This Hebrew Year two_weeks_from_today = today_hebrew_date + 14 # Collect all the deceased info in separated arrays deceased_month = [] deceased_day = [] deceased_donor = [] deceased_relation = [] deceased_name = [] deceased_SoD = [] deceased_email = [] # Array for ALL the email addresses all_emails = []
def getHebDate(date): """Returns the year, month, day of the Hebrew date for a DateTime object""" day = date.day month = date.month year = date.year return hebrew.from_gregorian(year, month, day)
blackouts.append(cycle_blackouts[cycle_blackout_index]) except: pass try: blackouts.append(cycle_blackouts2[cycle_blackout_index2]) except: pass blackout_inds = [dt_to_week(parse(d).date(),sat) for d in blackouts] for person in people: # bnei_bday = parse(person['DOB']).date() + relativedelta(years=12 if person.get('Gender')=='f' else 13) dob = parse(person['dob']).date() if dob.year == 2018: dob = dob.replace(year=2008) hdob= hebrew.from_gregorian(*unpack(dob)) #year,month,day (hebrew) hbmbd = plus_thirteen(dob) gbmbd = hebrew.to_gregorian(*hbmbd) bmdate = next_sat(*gbmbd) hbmdate = hebrew.from_gregorian(*bmdate) weeks_til = dt_to_week(date(*bmdate),sat) earliest = max(0,weeks_til - early_threshold) latest = weeks_til + late_threshold days_before_sat = (date(year = bmdate[0],month=bmdate[1],day=bmdate[2]) - date(year = gbmbd[0], month = gbmbd[1],day= gbmbd[2])).days # print(f"bmdate is {date(year = bmdate[0],month=bmdate[1],day=bmdate[2]).strftime('%A, %B %d, %Y')}, gbmbd is {date(year = gbmbd[0], month = gbmbd[1],day= gbmbd[2]).strftime('%A, %B %d, %Y')}, and days_before_sat is {days_before_sat}\n") nondates = [] notes = '' for key in nondatekeys: if (person[key] is not None) and (person[key] != ''): nd=parse(person[key]).date() if nd.year==21:
def getHebrewCalendarDate( n ): if not isinstance( n, RPNDateTime ): raise ValueError( 'time type required for this operator' ) return list( hebrew.from_gregorian( n.year, n.month, n.day ) )
def plus_thirteen2(greg): greg2 = greg + timedelta(days=1) (hy,hm,hd)= hebrew.from_gregorian(greg2.year,greg2.month,greg2.day) h = hebrew.to_jd_gregorianyear(greg2.year+13,hm,hd) print(f"Converted gregorian {greg2} to hebrew {h}") return h