Lib/calendar.py

   1 """Calendar printing functions
   2
   3 Note when comparing these calendars to the ones printed by cal(1): By
   4 default, these calendars have Monday as the first day of the week, and
   5 Sunday as the last (the European convention). Use setfirstweekday() to
   6 set the first day of the week (0=Monday, 6=Sunday)."""
   7
   8 import datetime
   9
  10 __all__ = ["error","setfirstweekday","firstweekday","isleap",
  11            "leapdays","weekday","monthrange","monthcalendar",
  12            "prmonth","month","prcal","calendar","timegm",
  13            "month_name", "month_abbr", "day_name", "day_abbr",
  14            "weekheader"]
  15
  16 # Exception raised for bad input (with string parameter for details)
  17 error = ValueError
  18
  19 # Constants for months referenced later
  20 January = 1
  21 February = 2
  22
  23 # Number of days per month (except for February in leap years)
  24 mdays = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
  25
  26 # This module used to have hard-coded lists of day and month names, as
  27 # English strings.  The classes following emulate a read-only version of
  28 # that, but supply localized names.  Note that the values are computed
  29 # fresh on each call, in case the user changes locale between calls.
  30
  31 class _localized_month:
  32
  33     _months = [datetime.date(2001, i+1, 1).strftime for i in range(12)]
  34     _months.insert(0, lambda x: "")
  35
  36     def __init__(self, format):
  37         self.format = format
  38
  39     def __getitem__(self, i):
  40         funcs = self._months[i]
  41         if isinstance(i, slice):
  42             return [f(self.format) for f in funcs]
  43         else:
  44             return funcs(self.format)
  45
  46     def __len__(self):
  47         return 13
  48
  49 class _localized_day:
  50
  51     # January 1, 2001, was a Monday.
  52     _days = [datetime.date(2001, 1, i+1).strftime for i in range(7)]
  53
  54     def __init__(self, format):
  55         self.format = format
  56
  57     def __getitem__(self, i):
  58         funcs = self._days[i]
  59         if isinstance(i, slice):
  60             return [f(self.format) for f in funcs]
  61         else:
  62             return funcs(self.format)
  63
  64     def __len__(self):
  65         return 7
  66
  67 # Full and abbreviated names of weekdays
  68 day_name = _localized_day('%A')
  69 day_abbr = _localized_day('%a')
  70
  71 # Full and abbreviated names of months (1-based arrays!!!)
  72 month_name = _localized_month('%B')
  73 month_abbr = _localized_month('%b')
  74
  75 # Constants for weekdays
  76 (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)
  77
  78 _firstweekday = 0                       # 0 = Monday, 6 = Sunday
  79
  80 def firstweekday():
  81     return _firstweekday
  82
  83 def setfirstweekday(weekday):
  84     """Set weekday (Monday=0, Sunday=6) to start each week."""
  85     global _firstweekday
  86     if not MONDAY <= weekday <= SUNDAY:
  87         raise ValueError, \
  88               'bad weekday number; must be 0 (Monday) to 6 (Sunday)'
  89     _firstweekday = weekday
  90
  91 def isleap(year):
  92     """Return 1 for leap years, 0 for non-leap years."""
  93     return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
  94
  95 def leapdays(y1, y2):
  96     """Return number of leap years in range [y1, y2).
  97        Assume y1 <= y2."""
  98     y1 -= 1
  99     y2 -= 1
 100     return (y2//4 - y1//4) - (y2//100 - y1//100) + (y2//400 - y1//400)
 101
 102 def weekday(year, month, day):
 103     """Return weekday (0-6 ~ Mon-Sun) for year (1970-...), month (1-12),
 104        day (1-31)."""
 105     return datetime.date(year, month, day).weekday()
 106
 107 def monthrange(year, month):
 108     """Return weekday (0-6 ~ Mon-Sun) and number of days (28-31) for
 109        year, month."""
 110     if not 1 <= month <= 12:
 111         raise ValueError, 'bad month number'
 112     day1 = weekday(year, month, 1)
 113     ndays = mdays[month] + (month == February and isleap(year))
 114     return day1, ndays
 115
 116 def monthcalendar(year, month):
 117     """Return a matrix representing a month's calendar.
 118        Each row represents a week; days outside this month are zero."""
 119     day1, ndays = monthrange(year, month)
 120     rows = []
 121     r7 = range(7)
 122     day = (_firstweekday - day1 + 6) % 7 - 5   # for leading 0's in first week
 123     while day <= ndays:
 124         row = [0, 0, 0, 0, 0, 0, 0]
 125         for i in r7:
 126             if 1 <= day <= ndays: row[i] = day
 127             day = day + 1
 128         rows.append(row)
 129     return rows
 130
 131 def prweek(theweek, width):
 132     """Print a single week (no newline)."""
 133     print week(theweek, width),
 134
 135 def week(theweek, width):
 136     """Returns a single week in a string (no newline)."""
 137     days = []
 138     for day in theweek:
 139         if day == 0:
 140             s = ''
 141         else:
 142             s = '%2i' % day             # right-align single-digit days
 143         days.append(s.center(width))
 144     return ' '.join(days)
 145
 146 def weekheader(width):
 147     """Return a header for a week."""
 148     if width >= 9:
 149         names = day_name
 150     else:
 151         names = day_abbr
 152     days = []
 153     for i in range(_firstweekday, _firstweekday + 7):
 154         days.append(names[i%7][:width].center(width))
 155     return ' '.join(days)
 156
 157 def prmonth(theyear, themonth, w=0, l=0):
 158     """Print a month's calendar."""
 159     print month(theyear, themonth, w, l),
 160
 161 def month(theyear, themonth, w=0, l=0):
 162     """Return a month's calendar string (multi-line)."""
 163     w = max(2, w)
 164     l = max(1, l)
 165     s = ("%s %r" % (month_name[themonth], theyear)).center(
 166                  7 * (w + 1) - 1).rstrip() + \
 167          '\n' * l + weekheader(w).rstrip() + '\n' * l
 168     for aweek in monthcalendar(theyear, themonth):
 169         s = s + week(aweek, w).rstrip() + '\n' * l
 170     return s[:-l] + '\n'
 171
 172 # Spacing of month columns for 3-column year calendar
 173 _colwidth = 7*3 - 1         # Amount printed by prweek()
 174 _spacing = 6                # Number of spaces between columns
 175
 176 def format3c(a, b, c, colwidth=_colwidth, spacing=_spacing):
 177     """Prints 3-column formatting for year calendars"""
 178     print format3cstring(a, b, c, colwidth, spacing)
 179
 180 def format3cstring(a, b, c, colwidth=_colwidth, spacing=_spacing):
 181     """Returns a string formatted from 3 strings, centered within 3 columns."""
 182     return (a.center(colwidth) + ' ' * spacing + b.center(colwidth) +
 183             ' ' * spacing + c.center(colwidth))
 184
 185 def prcal(year, w=0, l=0, c=_spacing):
 186     """Print a year's calendar."""
 187     print calendar(year, w, l, c),
 188
 189 def calendar(year, w=0, l=0, c=_spacing):
 190     """Returns a year's calendar as a multi-line string."""
 191     w = max(2, w)
 192     l = max(1, l)
 193     c = max(2, c)
 194     colwidth = (w + 1) * 7 - 1
 195     s = repr(year).center(colwidth * 3 + c * 2).rstrip() + '\n' * l
 196     header = weekheader(w)
 197     header = format3cstring(header, header, header, colwidth, c).rstrip()
 198     for q in range(January, January+12, 3):
 199         s = (s + '\n' * l +
 200              format3cstring(month_name[q], month_name[q+1], month_name[q+2],
 201                             colwidth, c).rstrip() +
 202              '\n' * l + header + '\n' * l)
 203         data = []
 204         height = 0
 205         for amonth in range(q, q + 3):
 206             cal = monthcalendar(year, amonth)
 207             if len(cal) > height:
 208                 height = len(cal)
 209             data.append(cal)
 210         for i in range(height):
 211             weeks = []
 212             for cal in data:
 213                 if i >= len(cal):
 214                     weeks.append('')
 215                 else:
 216                     weeks.append(week(cal[i], w))
 217             s = s + format3cstring(weeks[0], weeks[1], weeks[2],
 218                                    colwidth, c).rstrip() + '\n' * l
 219     return s[:-l] + '\n'
 220
 221 EPOCH = 1970
 222 _EPOCH_ORD = datetime.date(EPOCH, 1, 1).toordinal()
 223
 224 def timegm(tuple):
 225     """Unrelated but handy function to calculate Unix timestamp from GMT."""
 226     year, month, day, hour, minute, second = tuple[:6]
 227     days = datetime.date(year, month, 1).toordinal() - _EPOCH_ORD + day - 1
 228     hours = days*24 + hour
 229     minutes = hours*60 + minute
 230     seconds = minutes*60 + second
 231     return seconds