| """Calendar printing functions | |
| Note when comparing these calendars to the ones printed by cal(1): By | |
| default, these calendars have Monday as the first day of the week, and | |
| Sunday as the last (the European convention). Use setfirstweekday() to | |
| set the first day of the week (0=Monday, 6=Sunday).""" | |
| import sys | |
| import datetime | |
| import locale as _locale | |
| __all__ = ["IllegalMonthError", "IllegalWeekdayError", "setfirstweekday", | |
| "firstweekday", "isleap", "leapdays", "weekday", "monthrange", | |
| "monthcalendar", "prmonth", "month", "prcal", "calendar", | |
| "timegm", "month_name", "month_abbr", "day_name", "day_abbr"] | |
| # Exception raised for bad input (with string parameter for details) | |
| error = ValueError | |
| # Exceptions raised for bad input | |
| class IllegalMonthError(ValueError): | |
| def __init__(self, month): | |
| self.month = month | |
| def __str__(self): | |
| return "bad month number %r; must be 1-12" % self.month | |
| class IllegalWeekdayError(ValueError): | |
| def __init__(self, weekday): | |
| self.weekday = weekday | |
| def __str__(self): | |
| return "bad weekday number %r; must be 0 (Monday) to 6 (Sunday)" % self.weekday | |
| # Constants for months referenced later | |
| January = 1 | |
| February = 2 | |
| # Number of days per month (except for February in leap years) | |
| mdays = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] | |
| # This module used to have hard-coded lists of day and month names, as | |
| # English strings. The classes following emulate a read-only version of | |
| # that, but supply localized names. Note that the values are computed | |
| # fresh on each call, in case the user changes locale between calls. | |
| class _localized_month: | |
| _months = [datetime.date(2001, i+1, 1).strftime for i in range(12)] | |
| _months.insert(0, lambda x: "") | |
| def __init__(self, format): | |
| self.format = format | |
| def __getitem__(self, i): | |
| funcs = self._months[i] | |
| if isinstance(i, slice): | |
| return [f(self.format) for f in funcs] | |
| else: | |
| return funcs(self.format) | |
| def __len__(self): | |
| return 13 | |
| class _localized_day: | |
| # January 1, 2001, was a Monday. | |
| _days = [datetime.date(2001, 1, i+1).strftime for i in range(7)] | |
| def __init__(self, format): | |
| self.format = format | |
| def __getitem__(self, i): | |
| funcs = self._days[i] | |
| if isinstance(i, slice): | |
| return [f(self.format) for f in funcs] | |
| else: | |
| return funcs(self.format) | |
| def __len__(self): | |
| return 7 | |
| # Full and abbreviated names of weekdays | |
| day_name = _localized_day('%A') | |
| day_abbr = _localized_day('%a') | |
| # Full and abbreviated names of months (1-based arrays!!!) | |
| month_name = _localized_month('%B') | |
| month_abbr = _localized_month('%b') | |
| # Constants for weekdays | |
| (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7) | |
| def isleap(year): | |
| """Return True for leap years, False for non-leap years.""" | |
| return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0) | |
| def leapdays(y1, y2): | |
| """Return number of leap years in range [y1, y2). | |
| Assume y1 <= y2.""" | |
| y1 -= 1 | |
| y2 -= 1 | |
| return (y2//4 - y1//4) - (y2//100 - y1//100) + (y2//400 - y1//400) | |
| def weekday(year, month, day): | |
| """Return weekday (0-6 ~ Mon-Sun) for year (1970-...), month (1-12), | |
| day (1-31).""" | |
| return datetime.date(year, month, day).weekday() | |
| def monthrange(year, month): | |
| """Return weekday (0-6 ~ Mon-Sun) and number of days (28-31) for | |
| year, month.""" | |
| if not 1 <= month <= 12: | |
| raise IllegalMonthError(month) | |
| day1 = weekday(year, month, 1) | |
| ndays = mdays[month] + (month == February and isleap(year)) | |
| return day1, ndays | |
| class Calendar(object): | |
| """ | |
| Base calendar class. This class doesn't do any formatting. It simply | |
| provides data to subclasses. | |
| """ | |
| def __init__(self, firstweekday=0): | |
| self.firstweekday = firstweekday # 0 = Monday, 6 = Sunday | |
| def getfirstweekday(self): | |
| return self._firstweekday % 7 | |
| def setfirstweekday(self, firstweekday): | |
| self._firstweekday = firstweekday | |
| firstweekday = property(getfirstweekday, setfirstweekday) | |
| def iterweekdays(self): | |
| """ | |
| Return a iterator for one week of weekday numbers starting with the | |
| configured first one. | |
| """ | |
| for i in range(self.firstweekday, self.firstweekday + 7): | |
| yield i%7 | |
| def itermonthdates(self, year, month): | |
| """ | |
| Return an iterator for one month. The iterator will yield datetime.date | |
| values and will always iterate through complete weeks, so it will yield | |
| dates outside the specified month. | |
| """ | |
| date = datetime.date(year, month, 1) | |
| # Go back to the beginning of the week | |
| days = (date.weekday() - self.firstweekday) % 7 | |
| date -= datetime.timedelta(days=days) | |
| oneday = datetime.timedelta(days=1) | |
| while True: | |
| yield date | |
| date += oneday | |
| if date.month != month and date.weekday() == self.firstweekday: | |
| break | |
| def itermonthdays2(self, year, month): | |
| """ | |
| Like itermonthdates(), but will yield (day number, weekday number) | |
| tuples. For days outside the specified month the day number is 0. | |
| """ | |
| for date in self.itermonthdates(year, month): | |
| if date.month != month: | |
| yield (0, date.weekday()) | |
| else: | |
| yield (date.day, date.weekday()) | |
| def itermonthdays(self, year, month): | |
| """ | |
| Like itermonthdates(), but will yield day numbers. For days outside | |
| the specified month the day number is 0. | |
| """ | |
| for date in self.itermonthdates(year, month): | |
| if date.month != month: | |
| yield 0 | |
| else: | |
| yield date.day | |
| def monthdatescalendar(self, year, month): | |
| """ | |
| Return a matrix (list of lists) representing a month's calendar. | |
| Each row represents a week; week entries are datetime.date values. | |
| """ | |
| dates = list(self.itermonthdates(year, month)) | |
| return [ dates[i:i+7] for i in range(0, len(dates), 7) ] | |
| def monthdays2calendar(self, year, month): | |
| """ | |
| Return a matrix representing a month's calendar. | |
| Each row represents a week; week entries are | |
| (day number, weekday number) tuples. Day numbers outside this month | |
| are zero. | |
| """ | |
| days = list(self.itermonthdays2(year, month)) | |
| return [ days[i:i+7] for i in range(0, len(days), 7) ] | |
| def monthdayscalendar(self, year, month): | |
| """ | |
| Return a matrix representing a month's calendar. | |
| Each row represents a week; days outside this month are zero. | |
| """ | |
| days = list(self.itermonthdays(year, month)) | |
| return [ days[i:i+7] for i in range(0, len(days), 7) ] | |
| def yeardatescalendar(self, year, width=3): | |
| """ | |
| Return the data for the specified year ready for formatting. The return | |
| value is a list of month rows. Each month row contains upto width months. | |
| Each month contains between 4 and 6 weeks and each week contains 1-7 | |
| days. Days are datetime.date objects. | |
| """ | |
| months = [ | |
| self.monthdatescalendar(year, i) | |
| for i in range(January, January+12) | |
| ] | |
| return [months[i:i+width] for i in range(0, len(months), width) ] | |
| def yeardays2calendar(self, year, width=3): | |
| """ | |
| Return the data for the specified year ready for formatting (similar to | |
| yeardatescalendar()). Entries in the week lists are | |
| (day number, weekday number) tuples. Day numbers outside this month are | |
| zero. | |
| """ | |
| months = [ | |
| self.monthdays2calendar(year, i) | |
| for i in range(January, January+12) | |
| ] | |
| return [months[i:i+width] for i in range(0, len(months), width) ] | |
| def yeardayscalendar(self, year, width=3): | |
| """ | |
| Return the data for the specified year ready for formatting (similar to | |
| yeardatescalendar()). Entries in the week lists are day numbers. | |
| Day numbers outside this month are zero. | |
| """ | |
| months = [ | |
| self.monthdayscalendar(year, i) | |
| for i in range(January, January+12) | |
| ] | |
| return [months[i:i+width] for i in range(0, len(months), width) ] | |
| class TextCalendar(Calendar): | |
| """ | |
| Subclass of Calendar that outputs a calendar as a simple plain text | |
| similar to the UNIX program cal. | |
| """ | |
| def prweek(self, theweek, width): | |
| """ | |
| Print a single week (no newline). | |
| """ | |
| print self.formatweek(theweek, width), | |
| def formatday(self, day, weekday, width): | |
| """ | |
| Returns a formatted day. | |
| """ | |
| if day == 0: | |
| s = '' | |
| else: | |
| s = '%2i' % day # right-align single-digit days | |
| return s.center(width) | |
| def formatweek(self, theweek, width): | |
| """ | |
| Returns a single week in a string (no newline). | |
| """ | |
| return ' '.join(self.formatday(d, wd, width) for (d, wd) in theweek) | |
| def formatweekday(self, day, width): | |
| """ | |
| Returns a formatted week day name. | |
| """ | |
| if width >= 9: | |
| names = day_name | |
| else: | |
| names = day_abbr | |
| return names[day][:width].center(width) | |
| def formatweekheader(self, width): | |
| """ | |
| Return a header for a week. | |
| """ | |
| return ' '.join(self.formatweekday(i, width) for i in self.iterweekdays()) | |
| def formatmonthname(self, theyear, themonth, width, withyear=True): | |
| """ | |
| Return a formatted month name. | |
| """ | |
| s = month_name[themonth] | |
| if withyear: | |
| s = "%s %r" % (s, theyear) | |
| return s.center(width) | |
| def prmonth(self, theyear, themonth, w=0, l=0): | |
| """ | |
| Print a month's calendar. | |
| """ | |
| print self.formatmonth(theyear, themonth, w, l), | |
| def formatmonth(self, theyear, themonth, w=0, l=0): | |
| """ | |
| Return a month's calendar string (multi-line). | |
| """ | |
| w = max(2, w) | |
| l = max(1, l) | |
| s = self.formatmonthname(theyear, themonth, 7 * (w + 1) - 1) | |
| s = s.rstrip() | |
| s += '\n' * l | |
| s += self.formatweekheader(w).rstrip() | |
| s += '\n' * l | |
| for week in self.monthdays2calendar(theyear, themonth): | |
| s += self.formatweek(week, w).rstrip() | |
| s += '\n' * l | |
| return s | |
| def formatyear(self, theyear, w=2, l=1, c=6, m=3): | |
| """ | |
| Returns a year's calendar as a multi-line string. | |
| """ | |
| w = max(2, w) | |
| l = max(1, l) | |
| c = max(2, c) | |
| colwidth = (w + 1) * 7 - 1 | |
| v = [] | |
| a = v.append | |
| a(repr(theyear).center(colwidth*m+c*(m-1)).rstrip()) | |
| a('\n'*l) | |
| header = self.formatweekheader(w) | |
| for (i, row) in enumerate(self.yeardays2calendar(theyear, m)): | |
| # months in this row | |
| months = range(m*i+1, min(m*(i+1)+1, 13)) | |
| a('\n'*l) | |
| names = (self.formatmonthname(theyear, k, colwidth, False) | |
| for k in months) | |
| a(formatstring(names, colwidth, c).rstrip()) | |
| a('\n'*l) | |
| headers = (header for k in months) | |
| a(formatstring(headers, colwidth, c).rstrip()) | |
| a('\n'*l) | |
| # max number of weeks for this row | |
| height = max(len(cal) for cal in row) | |
| for j in range(height): | |
| weeks = [] | |
| for cal in row: | |
| if j >= len(cal): | |
| weeks.append('') | |
| else: | |
| weeks.append(self.formatweek(cal[j], w)) | |
| a(formatstring(weeks, colwidth, c).rstrip()) | |
| a('\n' * l) | |
| return ''.join(v) | |
| def pryear(self, theyear, w=0, l=0, c=6, m=3): | |
| """Print a year's calendar.""" | |
| print self.formatyear(theyear, w, l, c, m) | |
| class HTMLCalendar(Calendar): | |
| """ | |
| This calendar returns complete HTML pages. | |
| """ | |
| # CSS classes for the day <td>s | |
| cssclasses = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"] | |
| def formatday(self, day, weekday): | |
| """ | |
| Return a day as a table cell. | |
| """ | |
| if day == 0: | |
| return '<td class="noday"> </td>' # day outside month | |
| else: | |
| return '<td class="%s">%d</td>' % (self.cssclasses[weekday], day) | |
| def formatweek(self, theweek): | |
| """ | |
| Return a complete week as a table row. | |
| """ | |
| s = ''.join(self.formatday(d, wd) for (d, wd) in theweek) | |
| return '<tr>%s</tr>' % s | |
| def formatweekday(self, day): | |
| """ | |
| Return a weekday name as a table header. | |
| """ | |
| return '<th class="%s">%s</th>' % (self.cssclasses[day], day_abbr[day]) | |
| def formatweekheader(self): | |
| """ | |
| Return a header for a week as a table row. | |
| """ | |
| s = ''.join(self.formatweekday(i) for i in self.iterweekdays()) | |
| return '<tr>%s</tr>' % s | |
| def formatmonthname(self, theyear, themonth, withyear=True): | |
| """ | |
| Return a month name as a table row. | |
| """ | |
| if withyear: | |
| s = '%s %s' % (month_name[themonth], theyear) | |
| else: | |
| s = '%s' % month_name[themonth] | |
| return '<tr><th colspan="7" class="month">%s</th></tr>' % s | |
| def formatmonth(self, theyear, themonth, withyear=True): | |
| """ | |
| Return a formatted month as a table. | |
| """ | |
| v = [] | |
| a = v.append | |
| a('<table border="0" cellpadding="0" cellspacing="0" class="month">') | |
| a('\n') | |
| a(self.formatmonthname(theyear, themonth, withyear=withyear)) | |
| a('\n') | |
| a(self.formatweekheader()) | |
| a('\n') | |
| for week in self.monthdays2calendar(theyear, themonth): | |
| a(self.formatweek(week)) | |
| a('\n') | |
| a('</table>') | |
| a('\n') | |
| return ''.join(v) | |
| def formatyear(self, theyear, width=3): | |
| """ | |
| Return a formatted year as a table of tables. | |
| """ | |
| v = [] | |
| a = v.append | |
| width = max(width, 1) | |
| a('<table border="0" cellpadding="0" cellspacing="0" class="year">') | |
| a('\n') | |
| a('<tr><th colspan="%d" class="year">%s</th></tr>' % (width, theyear)) | |
| for i in range(January, January+12, width): | |
| # months in this row | |
| months = range(i, min(i+width, 13)) | |
| a('<tr>') | |
| for m in months: | |
| a('<td>') | |
| a(self.formatmonth(theyear, m, withyear=False)) | |
| a('</td>') | |
| a('</tr>') | |
| a('</table>') | |
| return ''.join(v) | |
| def formatyearpage(self, theyear, width=3, css='calendar.css', encoding=None): | |
| """ | |
| Return a formatted year as a complete HTML page. | |
| """ | |
| if encoding is None: | |
| encoding = sys.getdefaultencoding() | |
| v = [] | |
| a = v.append | |
| a('<?xml version="1.0" encoding="%s"?>\n' % encoding) | |
| a('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n') | |
| a('<html>\n') | |
| a('<head>\n') | |
| a('<meta http-equiv="Content-Type" content="text/html; charset=%s" />\n' % encoding) | |
| if css is not None: | |
| a('<link rel="stylesheet" type="text/css" href="%s" />\n' % css) | |
| a('<title>Calendar for %d</title>\n' % theyear) | |
| a('</head>\n') | |
| a('<body>\n') | |
| a(self.formatyear(theyear, width)) | |
| a('</body>\n') | |
| a('</html>\n') | |
| return ''.join(v).encode(encoding, "xmlcharrefreplace") | |
| class TimeEncoding: | |
| def __init__(self, locale): | |
| self.locale = locale | |
| def __enter__(self): | |
| self.oldlocale = _locale.getlocale(_locale.LC_TIME) | |
| _locale.setlocale(_locale.LC_TIME, self.locale) | |
| def __exit__(self, *args): | |
| _locale.setlocale(_locale.LC_TIME, self.oldlocale) | |
| class LocaleTextCalendar(TextCalendar): | |
| """ | |
| This class can be passed a locale name in the constructor and will return | |
| month and weekday names in the specified locale. If this locale includes | |
| an encoding all strings containing month and weekday names will be returned | |
| as unicode. | |
| """ | |
| def __init__(self, firstweekday=0, locale=None): | |
| TextCalendar.__init__(self, firstweekday) | |
| if locale is None: | |
| locale = _locale.getdefaultlocale() | |
| self.locale = locale | |
| def formatweekday(self, day, width): | |
| with TimeEncoding(self.locale) as encoding: | |
| if width >= 9: | |
| names = day_name | |
| else: | |
| names = day_abbr | |
| name = names[day] | |
| if encoding is not None: | |
| name = name.decode(encoding) | |
| return name[:width].center(width) | |
| def formatmonthname(self, theyear, themonth, width, withyear=True): | |
| with TimeEncoding(self.locale) as encoding: | |
| s = month_name[themonth] | |
| if encoding is not None: | |
| s = s.decode(encoding) | |
| if withyear: | |
| s = "%s %r" % (s, theyear) | |
| return s.center(width) | |
| class LocaleHTMLCalendar(HTMLCalendar): | |
| """ | |
| This class can be passed a locale name in the constructor and will return | |
| month and weekday names in the specified locale. If this locale includes | |
| an encoding all strings containing month and weekday names will be returned | |
| as unicode. | |
| """ | |
| def __init__(self, firstweekday=0, locale=None): | |
| HTMLCalendar.__init__(self, firstweekday) | |
| if locale is None: | |
| locale = _locale.getdefaultlocale() | |
| self.locale = locale | |
| def formatweekday(self, day): | |
| with TimeEncoding(self.locale) as encoding: | |
| s = day_abbr[day] | |
| if encoding is not None: | |
| s = s.decode(encoding) | |
| return '<th class="%s">%s</th>' % (self.cssclasses[day], s) | |
| def formatmonthname(self, theyear, themonth, withyear=True): | |
| with TimeEncoding(self.locale) as encoding: | |
| s = month_name[themonth] | |
| if encoding is not None: | |
| s = s.decode(encoding) | |
| if withyear: | |
| s = '%s %s' % (s, theyear) | |
| return '<tr><th colspan="7" class="month">%s</th></tr>' % s | |
| # Support for old module level interface | |
| c = TextCalendar() | |
| firstweekday = c.getfirstweekday | |
| def setfirstweekday(firstweekday): | |
| try: | |
| firstweekday.__index__ | |
| except AttributeError: | |
| raise IllegalWeekdayError(firstweekday) | |
| if not MONDAY <= firstweekday <= SUNDAY: | |
| raise IllegalWeekdayError(firstweekday) | |
| c.firstweekday = firstweekday | |
| monthcalendar = c.monthdayscalendar | |
| prweek = c.prweek | |
| week = c.formatweek | |
| weekheader = c.formatweekheader | |
| prmonth = c.prmonth | |
| month = c.formatmonth | |
| calendar = c.formatyear | |
| prcal = c.pryear | |
| # Spacing of month columns for multi-column year calendar | |
| _colwidth = 7*3 - 1 # Amount printed by prweek() | |
| _spacing = 6 # Number of spaces between columns | |
| def format(cols, colwidth=_colwidth, spacing=_spacing): | |
| """Prints multi-column formatting for year calendars""" | |
| print formatstring(cols, colwidth, spacing) | |
| def formatstring(cols, colwidth=_colwidth, spacing=_spacing): | |
| """Returns a string formatted from n strings, centered within n columns.""" | |
| spacing *= ' ' | |
| return spacing.join(c.center(colwidth) for c in cols) | |
| EPOCH = 1970 | |
| _EPOCH_ORD = datetime.date(EPOCH, 1, 1).toordinal() | |
| def timegm(tuple): | |
| """Unrelated but handy function to calculate Unix timestamp from GMT.""" | |
| year, month, day, hour, minute, second = tuple[:6] | |
| days = datetime.date(year, month, 1).toordinal() - _EPOCH_ORD + day - 1 | |
| hours = days*24 + hour | |
| minutes = hours*60 + minute | |
| seconds = minutes*60 + second | |
| return seconds | |
| def main(args): | |
| import optparse | |
| parser = optparse.OptionParser(usage="usage: %prog [options] [year [month]]") | |
| parser.add_option( | |
| "-w", "--width", | |
| dest="width", type="int", default=2, | |
| help="width of date column (default 2, text only)" | |
| ) | |
| parser.add_option( | |
| "-l", "--lines", | |
| dest="lines", type="int", default=1, | |
| help="number of lines for each week (default 1, text only)" | |
| ) | |
| parser.add_option( | |
| "-s", "--spacing", | |
| dest="spacing", type="int", default=6, | |
| help="spacing between months (default 6, text only)" | |
| ) | |
| parser.add_option( | |
| "-m", "--months", | |
| dest="months", type="int", default=3, | |
| help="months per row (default 3, text only)" | |
| ) | |
| parser.add_option( | |
| "-c", "--css", | |
| dest="css", default="calendar.css", | |
| help="CSS to use for page (html only)" | |
| ) | |
| parser.add_option( | |
| "-L", "--locale", | |
| dest="locale", default=None, | |
| help="locale to be used from month and weekday names" | |
| ) | |
| parser.add_option( | |
| "-e", "--encoding", | |
| dest="encoding", default=None, | |
| help="Encoding to use for output" | |
| ) | |
| parser.add_option( | |
| "-t", "--type", | |
| dest="type", default="text", | |
| choices=("text", "html"), | |
| help="output type (text or html)" | |
| ) | |
| (options, args) = parser.parse_args(args) | |
| if options.locale and not options.encoding: | |
| parser.error("if --locale is specified --encoding is required") | |
| sys.exit(1) | |
| locale = options.locale, options.encoding | |
| if options.type == "html": | |
| if options.locale: | |
| cal = LocaleHTMLCalendar(locale=locale) | |
| else: | |
| cal = HTMLCalendar() | |
| encoding = options.encoding | |
| if encoding is None: | |
| encoding = sys.getdefaultencoding() | |
| optdict = dict(encoding=encoding, css=options.css) | |
| if len(args) == 1: | |
| print cal.formatyearpage(datetime.date.today().year, **optdict) | |
| elif len(args) == 2: | |
| print cal.formatyearpage(int(args[1]), **optdict) | |
| else: | |
| parser.error("incorrect number of arguments") | |
| sys.exit(1) | |
| else: | |
| if options.locale: | |
| cal = LocaleTextCalendar(locale=locale) | |
| else: | |
| cal = TextCalendar() | |
| optdict = dict(w=options.width, l=options.lines) | |
| if len(args) != 3: | |
| optdict["c"] = options.spacing | |
| optdict["m"] = options.months | |
| if len(args) == 1: | |
| result = cal.formatyear(datetime.date.today().year, **optdict) | |
| elif len(args) == 2: | |
| result = cal.formatyear(int(args[1]), **optdict) | |
| elif len(args) == 3: | |
| result = cal.formatmonth(int(args[1]), int(args[2]), **optdict) | |
| else: | |
| parser.error("incorrect number of arguments") | |
| sys.exit(1) | |
| if options.encoding: | |
| result = result.encode(options.encoding) | |
| print result | |
| if __name__ == "__main__": | |
| main(sys.argv) |