mirror of
https://github.com/python/cpython
synced 2024-09-04 15:56:13 +00:00
![Christian Heimes](/assets/img/avatar_default.png)
svn+ssh://pythondev@svn.python.org/python/trunk ........ r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines Remove month parameter from Calendar.yeardatescalendar(), Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods don't have such a parameter. Fixes issue #2017. Rewrap content to 80 chars. ........ r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines Fixes issue 1959. Converted tests to unittest. Thanks Giampaolo Rodola. ........ r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines Fixed refcounts and error handling. Should not be merged to py3k branch. ........ r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN raise InvalidOperation (and return False if InvalidOperation is trapped). ........ r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines Remove incorrect usage of :const: in documentation. ........ r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines Revert accidental changes to test_queue in r60605. ........ r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. ........ r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines Fix broken link in decimal documentation. ........ r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines IEEE 754 should be IEEE 854; give precise reference for comparisons involving NaNs. ........ r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line Return ints instead of longs for tuple.count() and tuple.index(). ........ r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line Merge 60627. ........ r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs. ........ r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines Cast a struct to a void pointer so as to do a type-safe pointer comparison (mistmatch found by clang). ........ r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines Remove unnecessary curly braces around an int literal. ........ r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line Update URL ........ r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines Fixes issue 2026. Tests converted to unittest. Thanks Giampaolo Rodola. ........ r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet. ........ r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines Fixes Issue 1401. When redirected, a possible POST get converted to GET, so it loses its payload. So, it also must lose the headers related to the payload (if it has no content any more, it shouldn't indicate content length and type). ........ r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines Clarify that the output of TextCalendar.formatmonth() and TextCalendar.formatyear() for custom instances won't be influenced by calls to the module global setfirstweekday() function. Fixes #2018. ........ r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines Fix documentation for Calendar.iterweekdays(): firstweekday is a property. Fixes second part of #2018. ........ r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines Fix typo in docstring for Calendar.itermonthdays(). ........ r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line The float conversion recipe is simpler in Py2.6 ........ r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line Fix typo ........ r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines Make sure a switch statement does not have repetitive case statements. Error found through LLVM post-2.1 svn. ........ r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line Deallocate content of the dict free list on interpreter shutdown ........ r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line Use prefix decrement ........ r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines issue 2045: Infinite recursion when printing a subclass of defaultdict, if default_factory is set to a bound method. Will backport. ........ r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines Oops! 2.6's Rational.__ne__ didn't work. ........ r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines Update big5hkscs codec to conform to the HKSCS:2004 revision. ........ r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines Remove unnecessary modulo division. The preceding test guarantees that 0 <= i < len. ........ r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line Speed-up __iter__() mixin method. ........ r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line Fill-in missing Set comparisons ........ r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line Add advice on choosing between DictMixin and MutableMapping ........
706 lines
22 KiB
Python
706 lines
22 KiB
Python
"""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)."""
|
|
|
|
from __future__ import with_statement
|
|
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 1 for leap years, 0 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), 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))
|
|
|
|
|
|
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.setlocale(_locale.LC_TIME, self.locale)
|
|
return _locale.getlocale(_locale.LC_TIME)[1]
|
|
|
|
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):
|
|
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)
|