| """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 |
| from itertools import repeat |
| |
| __all__ = ["IllegalMonthError", "IllegalWeekdayError", "setfirstweekday", |
| "firstweekday", "isleap", "leapdays", "weekday", "monthrange", |
| "monthcalendar", "prmonth", "month", "prcal", "calendar", |
| "timegm", "month_name", "month_abbr", "day_name", "day_abbr", |
| "Calendar", "TextCalendar", "HTMLCalendar", "LocaleTextCalendar", |
| "LocaleHTMLCalendar", "weekheader"] |
| |
| # 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, month (1-12), day (1-31).""" |
| if not datetime.MINYEAR <= year <= datetime.MAXYEAR: |
| year = 2000 + year % 400 |
| 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 |
| |
| |
| def _monthlen(year, month): |
| return mdays[month] + (month == February and isleap(year)) |
| |
| |
| def _prevmonth(year, month): |
| if month == 1: |
| return year-1, 12 |
| else: |
| return year, month-1 |
| |
| |
| def _nextmonth(year, month): |
| if month == 12: |
| return year+1, 1 |
| else: |
| return year, month+1 |
| |
| |
| 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 an 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. |
| """ |
| for y, m, d in self.itermonthdays3(year, month): |
| yield datetime.date(y, m, d) |
| |
| def itermonthdays(self, year, month): |
| """ |
| Like itermonthdates(), but will yield day numbers. For days outside |
| the specified month the day number is 0. |
| """ |
| day1, ndays = monthrange(year, month) |
| days_before = (day1 - self.firstweekday) % 7 |
| yield from repeat(0, days_before) |
| yield from range(1, ndays + 1) |
| days_after = (self.firstweekday - day1 - ndays) % 7 |
| yield from repeat(0, days_after) |
| |
| 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 i, d in enumerate(self.itermonthdays(year, month), self.firstweekday): |
| yield d, i % 7 |
| |
| def itermonthdays3(self, year, month): |
| """ |
| Like itermonthdates(), but will yield (year, month, day) tuples. Can be |
| used for dates outside of datetime.date range. |
| """ |
| day1, ndays = monthrange(year, month) |
| days_before = (day1 - self.firstweekday) % 7 |
| days_after = (self.firstweekday - day1 - ndays) % 7 |
| y, m = _prevmonth(year, month) |
| end = _monthlen(y, m) + 1 |
| for d in range(end-days_before, end): |
| yield y, m, d |
| for d in range(1, ndays + 1): |
| yield year, month, d |
| y, m = _nextmonth(year, month) |
| for d in range(1, days_after + 1): |
| yield y, m, d |
| |
| def itermonthdays4(self, year, month): |
| """ |
| Like itermonthdates(), but will yield (year, month, day, day_of_week) tuples. |
| Can be used for dates outside of datetime.date range. |
| """ |
| for i, (y, m, d) in enumerate(self.itermonthdays3(year, month)): |
| yield y, m, d, (self.firstweekday + i) % 7 |
| |
| 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 up to 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), end='') |
| |
| 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), end='') |
| |
| 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), end='') |
| |
| |
| class HTMLCalendar(Calendar): |
| """ |
| This calendar returns complete HTML pages. |
| """ |
| |
| # CSS classes for the day <td>s |
| cssclasses = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"] |
| |
| # CSS classes for the day <th>s |
| cssclasses_weekday_head = cssclasses |
| |
| # CSS class for the days before and after current month |
| cssclass_noday = "noday" |
| |
| # CSS class for the month's head |
| cssclass_month_head = "month" |
| |
| # CSS class for the month |
| cssclass_month = "month" |
| |
| # CSS class for the year's table head |
| cssclass_year_head = "year" |
| |
| # CSS class for the whole year table |
| cssclass_year = "year" |
| |
| def formatday(self, day, weekday): |
| """ |
| Return a day as a table cell. |
| """ |
| if day == 0: |
| # day outside month |
| return '<td class="%s"> </td>' % self.cssclass_noday |
| 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_weekday_head[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="%s">%s</th></tr>' % ( |
| self.cssclass_month_head, 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="%s">' % ( |
| self.cssclass_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="%s">' % |
| self.cssclass_year) |
| a('\n') |
| a('<tr><th colspan="%d" class="%s">%s</th></tr>' % ( |
| width, self.cssclass_year_head, 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 different_locale: |
| 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 different_locale(self.locale): |
| if width >= 9: |
| names = day_name |
| else: |
| names = day_abbr |
| name = names[day] |
| return name[:width].center(width) |
| |
| def formatmonthname(self, theyear, themonth, width, withyear=True): |
| with different_locale(self.locale): |
| s = month_name[themonth] |
| 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 different_locale(self.locale): |
| s = day_abbr[day] |
| return '<th class="%s">%s</th>' % (self.cssclasses[day], s) |
| |
| def formatmonthname(self, theyear, themonth, withyear=True): |
| with different_locale(self.locale): |
| s = month_name[themonth] |
| 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): |
| 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 argparse |
| parser = argparse.ArgumentParser() |
| textgroup = parser.add_argument_group('text only arguments') |
| htmlgroup = parser.add_argument_group('html only arguments') |
| textgroup.add_argument( |
| "-w", "--width", |
| type=int, default=2, |
| help="width of date column (default 2)" |
| ) |
| textgroup.add_argument( |
| "-l", "--lines", |
| type=int, default=1, |
| help="number of lines for each week (default 1)" |
| ) |
| textgroup.add_argument( |
| "-s", "--spacing", |
| type=int, default=6, |
| help="spacing between months (default 6)" |
| ) |
| textgroup.add_argument( |
| "-m", "--months", |
| type=int, default=3, |
| help="months per row (default 3)" |
| ) |
| htmlgroup.add_argument( |
| "-c", "--css", |
| default="calendar.css", |
| help="CSS to use for page" |
| ) |
| parser.add_argument( |
| "-L", "--locale", |
| default=None, |
| help="locale to be used from month and weekday names" |
| ) |
| parser.add_argument( |
| "-e", "--encoding", |
| default=None, |
| help="encoding to use for output" |
| ) |
| parser.add_argument( |
| "-t", "--type", |
| default="text", |
| choices=("text", "html"), |
| help="output type (text or html)" |
| ) |
| parser.add_argument( |
| "year", |
| nargs='?', type=int, |
| help="year number (1-9999)" |
| ) |
| parser.add_argument( |
| "month", |
| nargs='?', type=int, |
| help="month number (1-12, text only)" |
| ) |
| |
| options = parser.parse_args(args[1:]) |
| |
| 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) |
| write = sys.stdout.buffer.write |
| if options.year is None: |
| write(cal.formatyearpage(datetime.date.today().year, **optdict)) |
| elif options.month is None: |
| write(cal.formatyearpage(options.year, **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 options.month is None: |
| optdict["c"] = options.spacing |
| optdict["m"] = options.months |
| if options.year is None: |
| result = cal.formatyear(datetime.date.today().year, **optdict) |
| elif options.month is None: |
| result = cal.formatyear(options.year, **optdict) |
| else: |
| result = cal.formatmonth(options.year, options.month, **optdict) |
| write = sys.stdout.write |
| if options.encoding: |
| result = result.encode(options.encoding) |
| write = sys.stdout.buffer.write |
| write(result) |
| |
| |
| if __name__ == "__main__": |
| main(sys.argv) |
