Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
2a5754adef
gramps/src/Calendar.py
Don Allingham f43d2fdd15 Calendar entry code fix 
svn: r1244
2003-01-08 05:31:17 +00:00

1286 lines
42 KiB
Python
Raw Blame History

#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2001 Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
"""
Calendar conversion routines for GRAMPS.
The original algorithms for this module came from Scott E. Lee's
C implementation. The original C source can be found at Scott's
web site at http://www.scottlee.com
"""
__author__ = "Donald N. Allingham"
__version__ = "$Revision$"
import math
from intl import gettext as _
import re
#-------------------------------------------------------------------------
#
# Constants
#
#-------------------------------------------------------------------------
UNDEF = -999999
EXACT = 0
ABOUT = 1
BEFORE = 2
AFTER = 3
#-------------------------------------------------------------------------
#
# Regular expressions for parsing
#
#-------------------------------------------------------------------------
_modifiers = '(' + \
_("abt\.?") + '|' + \
_("about") + '|' + \
_("est\.?") + '|' + \
_("circa") + '|' + \
_("around") + '|' + \
_("before") + '|' + \
_("after") + '|' + \
_("aft\.?") + '|' + \
_("bef\.?") + \
'|abt|aft|after|before|bef)'
_start = "^\s*" + _modifiers + "?\s*"
fmt1 = re.compile(_start+"(\S+)(\s+\d+\s*,)?\s*([?\d]+)?\s*$", re.IGNORECASE)
fmt2 = re.compile(_start+"(\d+)\.?\s+([^\d]+)(\s+\d+)?\s*$", re.IGNORECASE)
fmt3 = re.compile(_start+r"([?\d]+)\s*[./-]\s*([?\d]+)\s*[./-]\s*([?\d]+)\s*$",
re.IGNORECASE)
fmt7 = re.compile(_start+r"([?\d]+)\s*[./-]\s*([?\d]+)\s*$", re.IGNORECASE)
fmt4 = re.compile(_start+"(\S+)\s+(\d+)\s*$", re.IGNORECASE)
fmt5 = re.compile(_start+"(\d+)\s*$", re.IGNORECASE)
fmt6 = re.compile(_start+"(\S+)\s*$", re.IGNORECASE)
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def set_format_code(code):
Calendar.FORMATCODE = code
#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def get_format_code():
return Calendar.FORMATCODE
#-------------------------------------------------------------------------
#
# Calendar - base calendar
#
#-------------------------------------------------------------------------
class Calendar:
ENTRYCODE = 0
FORMATCODE = 0
MONTHS = [
_("January"), _("February"), _("March"), _("April"),
_("May"), _("June"), _("July"), _("August"),
_("September"), _("October"), _("November"), _("December")]
M2NUM = {
(MONTHS[0][0:3]).lower(): 1, (MONTHS[1][0:3]).lower(): 2,
(MONTHS[2][0:3]).lower(): 3, (MONTHS[3][0:3]).lower(): 4,
(MONTHS[4][0:3]).lower(): 5, (MONTHS[5][0:3]).lower(): 6,
(MONTHS[6][0:3]).lower(): 7, (MONTHS[7][0:3]).lower(): 8,
(MONTHS[8][0:3]).lower(): 9, (MONTHS[9][0:3]).lower(): 10,
(MONTHS[10][0:3]).lower(): 11, (MONTHS[11][0:3]).lower(): 12
}
M2V = {
_("abt") : ABOUT, _("about") : ABOUT,
_("abt.") : ABOUT, _("est") : ABOUT,
_("est.") : ABOUT, _("circa") : ABOUT,
_("around") : ABOUT, _("before") : BEFORE,
_("bef") : BEFORE, _("bef.") : BEFORE,
_("after") : AFTER, _("aft.") : AFTER,
_("aft") : AFTER,
# And the untranslated versions for reading saved data from XML.
"abt" : ABOUT, "about" : ABOUT,
"bef" : BEFORE, "bef." : BEFORE,
"aft." : AFTER, "abt." : ABOUT,
"est." : ABOUT, "est" : ABOUT,
"after" : AFTER, "before" : BEFORE,
"aft" : AFTER,
}
MODE = {
ABOUT : _("about"),
BEFORE : _("before"),
AFTER : _("after")}
EM2NUM ={
"jan" : 1, "feb" : 2, "mar" : 3, "apr" : 4,
"may" : 5, "jun" : 6, "jul" : 7, "aug" : 8,
"sep" : 9, "oct" :10, "nov" : 11,"dec" : 12
}
NAME = "Undefined Calendar"
TNAME = _("Undefined Calendar")
def mlen(self):
return -1
def __init__(self,source=None):
if source:
self.get_ymd(source.get_sdn())
def month(self,val):
try:
return Calendar.MONTHS[val-1]
except:
return "Illegal Month"
def check(self):
return 0
def quote_display(self,year,month,day,mode):
return "%s (%s)" % (text,Calendar.NAME)
def display(self,year,month,day,mode):
return _FMT_FUNC[Calendar.FORMATCODE](self,year,month,day,mode)
def format_yymmdd(self,year,month,day,mode):
if month == UNDEF and day == UNDEF and year == UNDEF :
return ""
elif day == UNDEF:
if month == UNDEF:
retval = str(self.year)
elif self.year == UNDEF:
retval = "????-%02d-??" % (month)
else:
retval = "%04d-%02d" % (year,month)
elif month == UNDEF:
retval = "%04d-??-%02d" % (year,day)
else:
if year == UNDEF:
retval = "????-%02d-%02d" % (month,day)
else:
retval = "%04d-%02d-%02d" % (year,month,day)
return self.fmt_mode(retval,mode)
def format_mon_dd_year(self,year,month,day,mode):
"""
Formats the date in the form of DD Month Year, such as
January 20, 2000
"""
if month == UNDEF and day == UNDEF and year == UNDEF:
return ""
elif day == UNDEF:
if month == UNDEF:
retval = str(year)
elif year == UNDEF:
retval = self.month(month)
else:
retval = "%s %d" % (self.month(month),year)
elif month == UNDEF:
retval = str(year)
else:
if year == UNDEF:
retval = "%s %d, ????" % (self.month(month),day)
else:
retval = "%s %d, %d" % (self.month(month),day,year)
return self.fmt_mode(retval,mode)
def format_MON_dd_year(self,year,month,day,mode):
"""
Formats the date in the form of DD Month Year, such as
January 20, 2000
"""
if month == UNDEF and day == UNDEF and year == UNDEF:
return ""
elif day == UNDEF:
if month == UNDEF:
retval = str(year)
elif year == UNDEF:
retval = self.month(month).upper()[0:3]
else:
retval = "%s %d" % (self.month(month).upper()[0:3],year)
elif month == UNDEF:
retval = str(year)
else:
if year == UNDEF:
retval = "%s %d, ????" % (self.month(month).upper()[0:3],day)
else:
retval = "%s %d, %d" % (self.month(month).upper()[0:3],day,year)
return self.fmt_mode(retval,mode)
def format_dd_mon_year(self,year,month,day,mode):
"""
Formats the date in the form of DD Month Year, such as
20 January 2000
"""
if year==UNDEF:
if month == UNDEF:
d = ""
elif day == UNDEF:
d = self.month(month)
else:
d = "%02d %s" % (day,self.month(month))
elif month == UNDEF:
d = str(year)
elif day == UNDEF:
d = "%s %d" % (self.month(month),year)
else:
d = "%02d %s %d" % (day,self.month(month),year)
return self.fmt_mode(d,mode)
def format_dd_MON_year(self,year,month,day,mode):
"""
Formats the date in the form of DD. Month Year, such as
20. January 2000
"""
if month == UNDEF and day == UNDEF and year == UNDEF :
return ""
elif day == UNDEF:
if month == UNDEF:
retval = str(year)
elif year == UNDEF:
retval = self.month(month).upper()[0:3]
else:
retval = "%s %d" % (self.month(month).upper()[0:3],year)
elif month == UNDEF:
retval = str(year)
else:
month_str = self.month(month).upper()[0:3]
if self.year == UNDEF:
retval = "%d %s ????" % (day,month_str)
else:
retval = "%d %s %d" % (day,month_str,year)
return self.fmt_mode(retval,mode)
def format_dd_dot_MON_year(self,year,month,day,mode):
"""
Formats the date in the form of DD. Month Year, such as
20. January 2000
"""
if month == UNDEF and day == UNDEF and year == UNDEF :
return ""
elif day == UNDEF:
if month == UNDEF:
retval = str(year)
elif year == UNDEF:
retval = self.month(month).upper()[0:3]
else:
retval = "%s %d" % (self.month(month).upper()[0:3],year)
elif month == UNDEF:
retval = str(year)
else:
month_str = self.month(month).upper()[0:3]
if self.year == UNDEF:
retval = "%d. %s ????" % (day,month_str)
else:
retval = "%d. %s %d" % (day,month_str,year)
return self.fmt_mode(retval,mode)
def format4(self,year,month,day,mode):
return self._get_mmddyyyy(year,month,day,mode,"/")
def format5(self,year,month,day,mode):
return self._get_mmddyyyy(year,month,day,mode,"-")
def format6(self,year,month,day,mode):
return self._get_ddmmyyyy(year,month,day,mode,"/")
def format7(self,year,month,day,mode):
return self._get_ddmmyyyy(year,month,day,mode,"-")
def format8(self,year,month,day,mode):
return self._get_mmddyyyy(year,month,day,mode,".")
def format9(self,year,month,day,mode):
return self._get_ddmmyyyy(year,month,day,mode,".")
def format11(self,year,month,day,mode):
return self._get_yyyymmdd(year,month,day,mode,"/")
def format12(self,year,month,day,mode):
return self._get_yyyymmdd(year,month,day,mode,"-")
def format13(self,year,month,day,mode):
return self._get_yyyymmdd(year,month,day,mode,".")
def _get_mmddyyyy(self,year,month,day,mode,sep):
if month == UNDEF and day == UNDEF and year == UNDEF :
return ""
elif day == UNDEF:
if month == UNDEF:
retval = str(year)
elif year == UNDEF:
retval = "%02d%s??%s??" % (month+1,sep,sep)
else:
retval = "%02d%s??%s%04d" % (month+1,sep,sep,year)
elif month == UNDEF:
retval = "??%s%02d%s%04d" % (sep,day,sep,year)
else:
if year == UNDEF:
retval = "%02d%s%02d%s????" % (month+1,sep,day,sep)
else:
retval = "%02d%s%02d%s%04d" % (month+1,sep,day,sep,year)
return self.fmt_mode(retval,mode)
def _get_yyyymmdd(self,year,month,day,mode,sep):
retval = ""
if month == UNDEF and day == UNDEF and year == UNDEF :
pass
elif day == UNDEF:
if month == UNDEF:
retval = str(self.year)
elif year == UNDEF:
retval = "????%s%02d%s??" % (sep,month+1,sep)
else:
retval = "%04d%s%02d" % (year,sep,month+1)
elif month == UNDEF:
retval = "%04d%s??%s%02d" % (year,sep,sep,day)
else:
if year == UNDEF:
retval = "????%s%02d%s%02d" % (sep,month+1,sep,day)
else:
retval = "%02d%s%02d%s%02d" % (year,sep,month+1,sep,day)
return self.fmt_mode(retval,mode)
def _get_ddmmyyyy(self,year,month,day,mode,sep):
retval = ""
if month == UNDEF and day == UNDEF and year == UNDEF :
pass
elif day == UNDEF:
if month == UNDEF:
retval = str(year)
elif year == UNDEF:
retval = "??%s%02d%s??" % (sep,month+1,sep)
else:
retval = "??%s%02d%s%04d" % (sep,month+1,sep,year)
elif month == UNDEF:
retval = "%02d%s??%s%04d" % (day,sep,sep,year)
else:
if year == UNDEF:
retval = "%02d%s%02d%s????" % (day,sep,month+1,sep)
else:
retval = "%02d%s%02d%s%04d" % (day,sep,month+1,sep,year)
return self.fmt_mode(retval,mode)
def fmt_mode(self,val,mode):
if Calendar.MODE.has_key(mode):
return "%s %s" % (Calendar.MODE[mode],val)
else:
return val
def get_ymd(self,val):
return (0,0,0)
def get_sdn(self,y,m,d):
return 0
def set_mode_value(self,val):
if not val:
return EXACT
else:
try:
return Calendar.M2V[val.lower()]
except KeyError:
return EXACT
def set_value(self,s):
try:
return int(s)
except:
return UNDEF
def set_month_string(self,text):
val = unicode(text[0:self.mlen()]).lower()
try:
return Calendar.M2NUM[val]
except KeyError:
if Calendar.EM2NUM.has_key(val):
return Calendar.EM2NUM[val]
else:
return UNDEF
def set(self,text):
mode = UNDEF
year = UNDEF
month = UNDEF
day = UNDEF
match = fmt2.match(text)
if match != None:
matches = match.groups()
mode = self.set_mode_value(matches[0])
month = self.set_month_string(matches[2])
day = self.set_value(matches[1])
if len(matches) == 4 and matches[3] != None:
year = self.set_value(matches[3])
return (year,month,day,mode)
match = fmt5.match(text)
if match != None:
matches = match.groups()
mode = self.set_mode_value(matches[0])
year = self.set_value(matches[1])
return (year,month,day,mode)
match = fmt7.match(text)
if match != None:
matches = match.groups()
mode = self.set_mode_value(matches[0])
if Calendar.ENTRYCODE == 2:
month = self.set_value(matches[2])
year = self.set_value(matches[1])
else:
month = self.set_value(matches[1])
year = self.set_value(matches[2])
return (year,month,day,mode)
match = fmt3.match(text)
if match != None:
matches = match.groups()
mode = self.set_mode_value(matches[0])
if Calendar.ENTRYCODE == 0:
month = self.set_value(matches[1])
day = self.set_value(matches[2])
year = self.set_value(matches[3])
elif Calendar.ENTRYCODE == 1:
month = self.set_value(matches[2])
day = self.set_value(matches[1])
year = self.set_value(matches[3])
else:
month = self.set_value(matches[2])
day = self.set_value(matches[3])
year = self.set_value(matches[1])
return (year,month,day,mode)
match = fmt1.match(text)
if match != None:
matches = match.groups()
mode = self.set_mode_value(matches[0])
month = self.set_month_string(unicode(matches[1]))
if matches[2]:
val = matches[2].replace(',','')
day = self.set_value(val)
year = self.set_value(matches[3])
return (year,month,day,mode)
match = fmt4.match(text)
if match != None:
matches = match.groups()
mode = self.set_mode_value(matches[0])
month = self.set_month_string(unicode(matches[1]))
if len(matches) == 4:
year = self.set_value(matches[3])
return (year,month,day,mode)
match = fmt6.match(text)
if match != None:
matches = match.groups()
mode = self.set_mode_value(matches[0])
month = self.set_value(matches[1])
return (year,month,day,mode)
#-------------------------------------------------------------------------
#
# Hebrew calendar
#
#-------------------------------------------------------------------------
class Hebrew(Calendar):
"""Jewish Calendar"""
HALAKIM_PER_HOUR = 1080
HALAKIM_PER_DAY = 25920
HALAKIM_PER_LUNAR_CYCLE = ((29 * HALAKIM_PER_DAY) + 13753)
HALAKIM_PER_METONIC_CYCLE = (HALAKIM_PER_LUNAR_CYCLE * (12 * 19 + 7))
SDN_OFFSET = 347997
NEW_MOON_OF_CREATION = 31524
SUNDAY = 0
MONDAY = 1
TUESDAY = 2
WEDNESDAY= 3
FRIDAY = 5
NOON = (18 * HALAKIM_PER_HOUR)
AM3_11_20 = ((9 * HALAKIM_PER_HOUR) + 204)
AM9_32_43 = ((15 * HALAKIM_PER_HOUR) + 589)
monthsPerYear = [
12, 12, 13, 12, 12, 13, 12, 13, 12, 12,
13, 12, 12, 13, 12, 12, 13, 12, 13 ]
yearOffset = [
0, 12, 24, 37, 49, 61, 74, 86, 99, 111, 123,
136, 148, 160, 173, 185, 197, 210, 222 ]
MONTHS = [
"Tishri", "Heshvan", "Kislev", "Tevet", "Shevat", "AdarI",
"AdarII", "Nisan", "Iyyar", "Sivan", "Tammuz", "Av",
"Elul",]
M2NUM = {
"tishri" : 1, "heshvan" : 2, "kislev" : 3, "tevet" : 4,
"shevat" : 5, "adari" : 6, "adarii" : 7, "nisan" : 8,
"iyyar" : 9, "sivan" :10, "tammuz" :11, "av" : 12,
"elul" : 13,"tsh" : 1, "csh" : 2, "ksl" : 3,
"tvt" : 4, "shv" : 5, "adr" : 6, "ads" : 7,
"nsn" : 8, "iyr" : 9, "svn" :10, "tmz" : 11,
"aav" :12, "ell" :13,
}
NAME = "Hebrew"
TNAME = _("Hebrew")
def quote_display(self,year,month,day,mode):
return "%s (%s)" % (self.display(year,month,day,mode),Hebrew.NAME)
def month(self,val):
try:
return Hebrew.MONTHS[val-1]
except:
return "Illegal Month"
def set_month_string(self,text):
try:
return Hebrew.M2NUM[unicode(text.lower())]
except KeyError:
return UNDEF
def Tishri1(self,metonicYear, moladDay, moladHalakim):
tishri1 = moladDay
dow = tishri1 % 7
leapYear = metonicYear in [ 2, 5, 7, 10, 13, 16, 18]
lastWasLeapYear = metonicYear in [ 3, 6, 8, 11, 14, 17, 0]
# Apply rules 2, 3 and 4.
if ((moladHalakim >= Hebrew.NOON) or
((not leapYear) and dow == Hebrew.TUESDAY and
moladHalakim >= Hebrew.AM3_11_20) or
(lastWasLeapYear and dow == Hebrew.MONDAY and moladHalakim >= Hebrew.AM9_32_43)) :
tishri1 = tishri1 + 1
dow = dow + 1
if dow == 7:
dow = 0
# Apply rule 1 after the others because it can cause an additional
# delay of one day
if dow == Hebrew.WEDNESDAY or dow == Hebrew.FRIDAY or dow == Hebrew.SUNDAY:
tishri1 = tishri1 + 1
return tishri1
def MoladOfMetonicCycle(self,metonicCycle):
# Start with the time of the first molad after creation.
r1 = Hebrew.NEW_MOON_OF_CREATION
# Calculate metonicCycle * HALAKIM_PER_METONIC_CYCLE. The upper 32
# bits of the result will be in r2 and the lower 16 bits will be
# in r1.
r1 = r1 + (metonicCycle * (Hebrew.HALAKIM_PER_METONIC_CYCLE & 0xFFFF))
r2 = r1 >> 16
r2 = r2 + (metonicCycle * ((Hebrew.HALAKIM_PER_METONIC_CYCLE >> 16) & 0xFFFF))
# Calculate r2r1 / HALAKIM_PER_DAY. The remainder will be in r1, the
# upper 16 bits of the quotient will be in d2 and the lower 16 bits
# will be in d1.
d2 = r2 / Hebrew.HALAKIM_PER_DAY
r2 = r2 - (d2 * Hebrew.HALAKIM_PER_DAY)
r1 = (r2 << 16) | (r1 & 0xFFFF)
d1 = r1 / Hebrew.HALAKIM_PER_DAY
r1 = r1 - ( d1 * Hebrew.HALAKIM_PER_DAY)
MoladDay = (d2 << 16) | d1
MoladHalakim = r1
return (MoladDay,MoladHalakim)
def TishriMolad(self,inputDay):
# Estimate the metonic cycle number. Note that this may be an under
# estimate because there are 6939.6896 days in a metonic cycle not
# 6940, but it will never be an over estimate. The loop below will
# correct for any error in this estimate. */
metonicCycle = (inputDay + 310) / 6940
# Calculate the time of the starting molad for this metonic cycle. */
(moladDay, moladHalakim) = self.MoladOfMetonicCycle(metonicCycle)
# If the above was an under estimate, increment the cycle number until
# the correct one is found. For modern dates this loop is about 98.6%
# likely to not execute, even once, because the above estimate is
# really quite close.
while moladDay < (inputDay - 6940 + 310):
metonicCycle = metonicCycle + 1
moladHalakim = moladHalakim + Hebrew.HALAKIM_PER_METONIC_CYCLE
moladDay = moladDay + ( moladHalakim / Hebrew.HALAKIM_PER_DAY)
moladHalakim = moladHalakim % Hebrew.HALAKIM_PER_DAY
# Find the molad of Tishri closest to this date.
for metonicYear in range(0,18):
if moladDay > inputDay - 74:
break
moladHalakim = moladHalakim + \
(Hebrew.HALAKIM_PER_LUNAR_CYCLE * Hebrew.monthsPerYear[metonicYear])
moladDay = moladDay + (moladHalakim / Hebrew.HALAKIM_PER_DAY)
moladHalakim = moladHalakim % Hebrew.HALAKIM_PER_DAY
else:
metonicYear = metonicYear + 1
return (metonicCycle, metonicYear, moladDay, moladHalakim)
def StartOfYear(self,year):
MetonicCycle = (year - 1) / 19;
MetonicYear = (year - 1) % 19;
(MoladDay, MoladHalakim) = self.MoladOfMetonicCycle(MetonicCycle)
MoladHalakim = MoladHalakim + (Hebrew.HALAKIM_PER_LUNAR_CYCLE * Hebrew.yearOffset[MetonicYear])
MoladDay = MoladDay + (MoladHalakim / Hebrew.HALAKIM_PER_DAY)
MoladHalakim = MoladHalakim % Hebrew.HALAKIM_PER_DAY
pTishri1 = self.Tishri1(MetonicYear, MoladDay, MoladHalakim);
return (MetonicCycle, MetonicYear, MoladDay, MoladHalakim, pTishri1)
def get_ymd(self,sdn):
"""Converts an SDN number to a Julian calendar date"""
if sdn <= Hebrew.SDN_OFFSET :
return (0,0,0)
inputDay = sdn - Hebrew.SDN_OFFSET
(metonicCycle, metonicYear, day, halakim) = self.TishriMolad(inputDay)
tishri1 = self.Tishri1(metonicYear, day, halakim);
if inputDay >= tishri1:
# It found Tishri 1 at the start of the year
Year = (metonicCycle * 19) + metonicYear + 1
if inputDay < tishri1 + 59:
if inputDay < tishri1 + 30:
Month = 1
Day = inputDay - tishri1 + 1
else:
Month = 2
Day = inputDay - tishri1 - 29
return (Year, Month, Day)
# We need the length of the year to figure this out, so find
# Tishri 1 of the next year. */
halakim = halakim + (Hebrew.HALAKIM_PER_LUNAR_CYCLE * Hebrew.monthsPerYear[metonicYear])
day = day + (halakim / Hebrew.HALAKIM_PER_DAY)
halakim = halakim % Hebrew.HALAKIM_PER_DAY;
tishri1After = self.Tishri1((metonicYear + 1) % 19, day, halakim);
else:
# It found Tishri 1 at the end of the year.
Year = metonicCycle * 19 + metonicYear
if inputDay >= tishri1 - 177:
# It is one of the last 6 months of the year.
if inputDay > tishri1 - 30:
Month = 13
Day = inputDay - tishri1 + 30
elif inputDay > tishri1 - 60:
Month = 12
Day = inputDay - tishri1 + 60
elif inputDay > tishri1 - 89:
Month = 11
Day = inputDay - tishri1 + 89
elif inputDay > tishri1 - 119:
Month = 10
Day = inputDay - tishri1 + 119
elif inputDay > tishri1 - 148:
Month = 9
Day = inputDay - tishri1 + 148
else:
Month = 8
Day = inputDay - tishri1 + 178
return (Year,Month,Day)
else:
if Hebrew.monthsPerYear[(Year - 1) % 19] == 13:
Month = 7
Day = inputDay - tishri1 + 207
if Day > 0:
return (Year,Month,Day)
Month = Month - 1
Day = Day + 30
if Day > 0:
return (Year,Month,Day)
Month = Month - 1
Day = Day + 30
else:
Month = 6
Day = inputDay - tishri1 + 207
if Day > 0:
return (Year,Month,Day)
Month = Month - 1
Day = Day + 30
if Day > 0:
return (Year,Month,Day)
Month = Month - 1
Day = Day + 29
if Day > 0:
return (Year,Month,Day)
# We need the length of the year to figure this out, so find
# Tishri 1 of this year
tishri1After = tishri1;
(metonicCycle,metonicYear,day,halakim) = self.TishriMolad(day-365)
tishri1 = self.Tishri1(metonicYear, day, halakim)
yearLength = tishri1After - tishri1;
cday = inputDay - tishri1 - 29;
if yearLength == 355 or yearLength == 385 :
# Heshvan has 30 days
if day <= 30:
Month = 2
Day = cday
return (Year,Month,Day)
day = day - 30
else:
# Heshvan has 29 days
if day <= 29:
Month = 2
Day = cday
return (Year,Month,Day)
cday = cday - 29
# It has to be Kislev
return (Year,3,cday)
def get_sdn(self,year, month, day):
"""Converts a Jewish calendar date to an SDN number"""
if year <= 0 or day <= 0 or day > 30 :
return 0
if month == 1 or month == 2:
# It is Tishri or Heshvan - don't need the year length.
(metonicCycle,metonicYear,moladDay,moladHalakim,tishri1) = self.StartOfYear(year)
if month == 1:
sdn = tishri1 + day - 1
else:
sdn = tishri1 + day + 29
elif month == 3:
# It is Kislev - must find the year length.
# Find the start of the year.
(metonicCycle,metonicYear,moladDay,moladHalakim,tishri1) = self.StartOfYear(year)
# Find the end of the year.
moladHalakim = moladHalakim + (Hebrew.HALAKIM_PER_LUNAR_CYCLE*Hebrew.monthsPerYear[metonicYear])
moladDay = moladDay + (moladHalakim / Hebrew.HALAKIM_PER_DAY)
moladHalakim = moladHalakim % Hebrew.HALAKIM_PER_DAY
tishri1After = self.Tishri1((metonicYear + 1) % 19, moladDay, moladHalakim)
yearLength = tishri1After - tishri1
if yearLength == 355 or yearLength == 385:
sdn = tishri1 + day + 59
else:
sdn = tishri1 + day + 58
elif month == 4 or month == 5 or month == 6:
# It is Tevet, Shevat or Adar I - don't need the year length
(metonicCycle,metonicYear,moladDay,moladHalakim,tishri1After) = self.StartOfYear(year+1)
if Hebrew.monthsPerYear[(year - 1) % 19] == 12:
lengthOfAdarIAndII = 29
else:
lengthOfAdarIAndII = 59
if month == 4:
sdn = tishri1After + day - lengthOfAdarIAndII - 237
elif month == 5:
sdn = tishri1After + day - lengthOfAdarIAndII - 208
else:
sdn = tishri1After + day - lengthOfAdarIAndII - 178
else:
# It is Adar II or later - don't need the year length.
(metonicCycle,metonicYear,moladDay,moladHalakim,tishri1After) = self.StartOfYear(year+1)
if month == 7:
sdn = tishri1After + day - 207
elif month == 8:
sdn = tishri1After + day - 178
elif month == 9:
sdn = tishri1After + day - 148
elif month == 10:
sdn = tishri1After + day - 119
elif month == 11:
sdn = tishri1After + day - 89
elif month == 12:
sdn = tishri1After + day - 60
elif month == 13:
sdn = tishri1After + day - 30
else:
return 0
return sdn + Hebrew.SDN_OFFSET
#-------------------------------------------------------------------------
#
# Persian
#
#-------------------------------------------------------------------------
class Persian(Calendar):
"""Persian Calendar"""
EPOCH = 1948320.5
SDN_475_1_1 = 2121446
MONTHS = [ "Farvardin", "Ordibehesht", "Khordad", "Tir", "Mordad",
"Shahrivar", "Mehr", "Aban", "Azar", "Dey", "Bahman", "Esfand" ]
M2NUM = {
"farvardin" : 1, "ordibehesht" : 2, "khordad" : 3,
"tir" : 4, "mordad" : 5, "shahrivar" : 6,
"mehr" : 7, "aban" : 8, "azar" : 9,
"dey" : 10, "bahman" : 11, "esfand" : 12
}
NAME = "Persian"
TNAME = _("Persian")
def quote_display(self,year,month,day,mode):
return "%s (%s)" % (self.display(year,month,day,mode),Persian.NAME)
def set_month_string(self,text):
try:
return Persian.M2NUM[unicode(text.lower())]
except KeyError:
return UNDEF
def month(self,val):
try:
return Persian.MONTHS[val-1]
except:
return "Illegal Month"
def get_sdn(self,year, month, day):
if year >= 0:
epbase = year - 474
else:
epbase = year - 473
epyear = 474 + epbase % 2820
if month <= 7:
v1 = (month - 1) * 31
else:
v1 = ((month - 1) * 30) + 6
v2 = math.floor(((epyear * 682) - 110) / 2816)
v3 = (epyear - 1) * 365 + day
v4 = math.floor(epbase / 2820) * 1029983
return int(math.ceil(v1 + v2 + v3 + v4 + Persian.EPOCH - 1))
def get_ymd(self,sdn):
sdn = math.floor(sdn) + 0.5
depoch = sdn - self.get_sdn(475,1,1)
cycle = math.floor(depoch / 1029983)
cyear = depoch % 1029983
if cyear == 1029982:
ycycle = 2820
else:
aux1 = math.floor(cyear / 366)
aux2 = cyear % 366
ycycle = math.floor(((2134 * aux1) + (2816 * aux2) + 2815) / 1028522) + aux1 + 1;
year = ycycle + (2820 * cycle) + 474
if year <= 0:
year = year - 1;
yday = sdn - self.get_sdn(year, 1, 1) + 1
if yday < 186:
month = math.ceil(yday / 31)
else:
month = math.ceil((yday - 6) / 30)
day = (sdn - self.get_sdn(year, month, 1)) + 1
return (int(year), int(month), int(day))
#-------------------------------------------------------------------------
#
# FrenchRepublic
#
#-------------------------------------------------------------------------
class FrenchRepublic(Calendar):
"""French Republic Calendar"""
SDN_OFFSET = 2375474
DAYS_PER_4_YEARS = 1461
DAYS_PER_MONTH = 30
FIRST_VALID = 2375840
LAST_VALID = 2380952
MONTHS = [
unicode("Vend<EFBFBD>miaire",'latin-1'), unicode("Brumaire",'latin-1'),
unicode("Frimaire",'latin-1'), unicode("Niv<EFBFBD>se",'latin-1'),
unicode("Pluvi<EFBFBD>se",'latin-1'), unicode("Vent<EFBFBD>se",'latin-1'),
unicode("Germinal",'latin-1'), unicode("Flor<EFBFBD>al",'latin-1'),
unicode("Prairial",'latin-1'), unicode("Messidor",'latin-1'),
unicode("Thermidor",'latin-1'), unicode("Fructidor",'latin-1'),
unicode("Extra",'latin-1'),]
M2NUM = {
"vend" : 1, "brum" : 2, "frim" : 3, "nivo" : 4, "pluv" : 5, "vent" : 6,
"germ" : 7, "flor" : 8, "prai" : 9, "mess" :10, "ther" :11, "fruc" :12,
"extr" : 13,"comp" :13, unicode("niv<EFBFBD>",'latin-1') : 4
}
NAME = "French Republican"
TNAME = _("French Republican")
def quote_display(self,year,month,day,mode):
return "%s (%s)" % (self.display(year,month,day,mode),FrenchRepublic.NAME)
def mlen(self):
return 4
def month(self,val):
try:
return FrenchRepublic.MONTHS[val-1]
except:
return "Illegal Month"
def set_month_string(self,text):
val = (unicode(text)[0:4]).lower()
try:
return FrenchRepublic.M2NUM[val]
except KeyError:
return UNDEF
def get_sdn(self,y,m,d):
"""Converts a French Republican Calendar date to an SDN number"""
if (y < 1 or y > 14 or m < 1 or m > 13 or d < 1 or d > 30):
return 0
return (y*FrenchRepublic.DAYS_PER_4_YEARS)/4 + \
(m-1)*FrenchRepublic.DAYS_PER_MONTH + \
d + FrenchRepublic.SDN_OFFSET
def get_ymd(self,sdn):
"""Converts an SDN number to a French Republican Calendar date"""
if (sdn < FrenchRepublic.FIRST_VALID or sdn > FrenchRepublic.LAST_VALID) :
return (0,0,0)
temp = (sdn-FrenchRepublic.SDN_OFFSET)*4 - 1
year = temp/FrenchRepublic.DAYS_PER_4_YEARS
dayOfYear = (temp%FrenchRepublic.DAYS_PER_4_YEARS)/4
month = (dayOfYear/FrenchRepublic.DAYS_PER_MONTH)+1
day = (dayOfYear%FrenchRepublic.DAYS_PER_MONTH)+1
return (year,month,day)
#-------------------------------------------------------------------------
#
# Gregorian
#
#-------------------------------------------------------------------------
class Gregorian(Calendar):
"""Gregorian Calendar"""
SDN_OFFSET = 32045
DAYS_PER_5_MONTHS = 153
DAYS_PER_4_YEARS = 1461
DAYS_PER_400_YEARS = 146097
NAME = "Gregorian"
TNAME = _("Gregorian")
def quote_display(self,year,month,day,mode):
return self.display(year,month,day,mode)
def mlen(self):
return 3
def get_ymd(self,sdn):
"""Converts an SDN number to a gregorial date"""
if sdn <= 0:
return (0,0,0)
temp = (Gregorian.SDN_OFFSET + sdn) * 4 - 1
# Calculate the century (year/100)
century = temp / Gregorian.DAYS_PER_400_YEARS
# Calculate the year and day of year (1 <= dayOfYear <= 366)
temp = ((temp % Gregorian.DAYS_PER_400_YEARS) / 4) * 4 + 3
year = (century * 100) + (temp / Gregorian.DAYS_PER_4_YEARS)
dayOfYear = (temp % Gregorian.DAYS_PER_4_YEARS) / 4 + 1
# Calculate the month and day of month
temp = dayOfYear * 5 - 3
month = temp / Gregorian.DAYS_PER_5_MONTHS
day = (temp % Gregorian.DAYS_PER_5_MONTHS) / 5 + 1
# Convert to the normal beginning of the year
if month < 10 :
month = month + 3
else:
year = year + 1
month = month - 9
# Adjust to the B.C./A.D. type numbering
year = year - 4800
if year <= 0:
year = year - 1
return (year,month,day)
def get_sdn(self,iyear,imonth,iday):
"""Converts a gregorian date to an SDN number"""
# check for invalid dates
if iyear==0 or iyear<-4714 or imonth<=0 or imonth>12 or iday<=0 or iday>31:
return 0
# check for dates before SDN 1 (Nov 25, 4714 B.C.)
if iyear == -4714:
if imonth < 11 or imonth == 11 and iday < 25:
return 0
if iyear < 0:
year = iyear + 4801
else:
year = iyear + 4800
# Adjust the start of the year
if imonth > 2:
month = imonth - 3
else:
month = imonth + 9
year = year - 1
return( ((year / 100) * Gregorian.DAYS_PER_400_YEARS) / 4
+ ((year % 100) * Gregorian.DAYS_PER_4_YEARS) / 4
+ (month * Gregorian.DAYS_PER_5_MONTHS + 2) / 5
+ iday
- Gregorian.SDN_OFFSET );
#-------------------------------------------------------------------------
#
# Julian
#
#-------------------------------------------------------------------------
class Julian(Calendar):
"""Julian calendar"""
SDN_OFFSET = 32083
DAYS_PER_5_MONTHS = 153
DAYS_PER_4_YEARS = 1461
NAME = "Julian"
TNAME = _("Julian")
def quote_display(self,year,month,day,mode):
return "%s (%s)" % (self.display(year,month,day,mode),Julian.NAME)
def mlen(self):
return 3
def get_ymd(self,sdn):
"""Converts an SDN number to a Julian date"""
if sdn <= 0 :
return (0,0,0)
temp = (sdn + Julian.SDN_OFFSET) * 4 - 1
# Calculate the year and day of year (1 <= dayOfYear <= 366)
year = temp / Julian.DAYS_PER_4_YEARS
dayOfYear = (temp % Julian.DAYS_PER_4_YEARS) / 4 + 1
# Calculate the month and day of month
temp = dayOfYear * 5 - 3;
month = temp / Julian.DAYS_PER_5_MONTHS;
day = (temp % Julian.DAYS_PER_5_MONTHS) / 5 + 1;
# Convert to the normal beginning of the year
if month < 10:
month = month + 3
else:
year = year + 1
month = month - 9
# Adjust to the B.C./A.D. type numbering
year = year - 4800
if year <= 0:
year = year - 1
return (year,month,day)
def get_sdn(self,iyear,imonth,iday):
"""Converts a Julian calendar date to an SDN number"""
# check for invalid dates
if iyear==0 or iyear<-4713 or imonth<=0 or imonth>12 or iday<=0 or iday>31:
return 0
# check for dates before SDN 1 (Jan 2, 4713 B.C.)
if iyear == -4713:
if imonth == 1 and iday == 1:
return 0
# Make year always a positive number
if iyear < 0:
year = iyear + 4801
else:
year = iyear + 4800
# Adjust the start of the year
if imonth > 2:
month = imonth - 3
else:
month = imonth + 9
year = year - 1
return (year*Julian.DAYS_PER_4_YEARS)/4 + \
(month*Julian.DAYS_PER_5_MONTHS+2)/5 + \
iday - Julian.SDN_OFFSET
#-------------------------------------------------------------------------
#
# Islamic
#
#-------------------------------------------------------------------------
class Islamic(Calendar):
"""Islamic calendar"""
EPOCH = 1948439.5
MONTHS = [
"Muharram", "Safar", "Rabi`al-Awwal", "Rabi`ath-Thani",
"Jumada l-Ula", "Jumada t-Tania", "Rajab", "Sha`ban",
"Ramadan", "Shawwal", "Dhu l-Qa`da", "Dhu l-Hijja"
]
M2NUM = {
"muharram" : 1, "safar" : 2, "rabi`al-awwal" : 3,
"rabi`ath-thani" : 4, "jumada l-ula" : 5 , "jumada t-tania" : 6,
"rajab" : 7, "sha`ban" : 8, "ramadan" : 9,
"shawwal" : 10, "dhu l-qa`da" : 11, "dhu l-hijja" : 12
}
NAME = "Islamic"
TNAME = _("Islamic")
def quote_display(self,year,month,day,mode):
return "%s (%s)" % (self.display(year,month,day,mode),Islamic.NAME)
def set_month_string(self,text):
try:
return Islamic.M2NUM[unicode(text.lower())]
except KeyError:
return UNDEF
def month(self,val):
try:
return Islamic.MONTHS[val-1]
except:
return "Illegal Month"
def get_sdn(self,year, month, day):
v1 = math.ceil(29.5 * (month - 1))
v2 = (year - 1) * 354
v3 = math.floor((3 + (11 *year)) / 30)
return int(math.ceil((day + v1 + v2 + v3 + Islamic.EPOCH) - 1))
def get_ymd(self,sdn):
sdn = math.floor(sdn) + 0.5
year = int(math.floor(((30*(sdn-Islamic.EPOCH))+10646)/10631))
month = int(min(12, math.ceil((sdn-(29+self.get_sdn(year,1,1)))/29.5) + 1))
day = int((sdn - self.get_sdn(year,month,1)) + 1)
return (year,month,day)
_FMT_FUNC = [
Calendar.format_mon_dd_year,
Calendar.format_MON_dd_year,
Calendar.format_dd_MON_year,
Calendar.format4,
Calendar.format5,
Calendar.format6,
Calendar.format7,
Calendar.format9,
Calendar.format_dd_dot_MON_year,
Calendar.format11,
Calendar.format12,
Calendar.format13,
]
#-------------------------------------------------------------------------
#
# Calendar registration
#
#-------------------------------------------------------------------------
_calendars = {}
def register( class_obj ):
_calendars[class_obj.NAME] = class_obj
def find_calendar(name):
try:
return _calendars[name]
except:
return None
def calendar_names():
list = []
for n in _calendars.values():
list.append(n)
list.sort()
return list
register(Gregorian)
register(FrenchRepublic)
register(Julian)
register(Persian)
register(Hebrew)
register(Islamic)
Reference in New Issue View Git Blame Copy Permalink