text: """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)."""
  
  # Revision 2: uses functions from built-in time module
  
  # Import functions and variables from time module
  from time import localtime, mktime
  
  __all__ = ["error","setfirstweekday","firstweekday","isleap",
             "leapdays","weekday","monthrange","monthcalendar",
             "prmonth","month","prcal","calendar","timegm"]
  
  # Exception raised for bad input (with string parameter for details)
  error = ValueError
  
  # 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]
  
  # Full and abbreviated names of weekdays
  day_name = ['Monday', 'Tuesday', 'Wednesday', 'Thursday',
              'Friday', 'Saturday', 'Sunday']
  day_abbr = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
  
  # Full and abbreviated names of months (1-based arrays!!!)
  month_name = ['', 'January', 'February', 'March', 'April',
                'May', 'June', 'July', 'August',
                'September', 'October',  'November', 'December']
  month_abbr = ['   ', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
                'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
  
  # Constants for weekdays
  (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)
  
  _firstweekday = 0                       # 0 = Monday, 6 = Sunday
  
  def firstweekday():
      return _firstweekday
  
  def setfirstweekday(weekday):
      """Set weekday (Monday=0, Sunday=6) to start each week."""
      global _firstweekday
      if not MONDAY <= weekday <= SUNDAY:
          raise ValueError, \
                'bad weekday number; must be 0 (Monday) to 6 (Sunday)'
      _firstweekday = weekday
  
  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)."""
      secs = mktime((year, month, day, 0, 0, 0, 0, 0, 0))
      tuple = localtime(secs)
      return tuple[6]
  
  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 ValueError, 'bad month number'
      day1 = weekday(year, month, 1)
      ndays = mdays[month] + (month == February and isleap(year))
      return day1, ndays
  
  def monthcalendar(year, month):
      """Return a matrix representing a month's calendar.
         Each row represents a week; days outside this month are zero."""
      day1, ndays = monthrange(year, month)
      rows = []
      r7 = range(7)
      day = (_firstweekday - day1 + 6) % 7 - 5   # for leading 0's in first week
      while day <= ndays:
          row = [0, 0, 0, 0, 0, 0, 0]
          for i in r7:
              if 1 <= day <= ndays: row[i] = day
              day = day + 1
          rows.append(row)
      return rows
  
  def _center(str, width):
      """Center a string in a field."""
      n = width - len(str)
      if n <= 0:
          return str
      return ' '*((n+1)/2) + str + ' '*((n)/2)
  
  def prweek(theweek, width):
      """Print a single week (no newline)."""
      print week(theweek, width),
  
  def week(theweek, width):
      """Returns a single week in a string (no newline)."""
      days = []
      for day in theweek:
          if day == 0:
              s = ''
          else:
              s = '%2i' % day             # right-align single-digit days
          days.append(_center(s, width))
      return ' '.join(days)
  
  def weekheader(width):
      """Return a header for a week."""
      if width >= 9:
          names = day_name
      else:
          names = day_abbr
      days = []
      for i in range(_firstweekday, _firstweekday + 7):
          days.append(_center(names[i%7][:width], width))
      return ' '.join(days)
  
  def prmonth(theyear, themonth, w=0, l=0):
      """Print a month's calendar."""
      print month(theyear, themonth, w, l),
  
  def month(theyear, themonth, w=0, l=0):
      """Return a month's calendar string (multi-line)."""
      w = max(2, w)
      l = max(1, l)
      s = (_center(month_name[themonth] + ' ' + `theyear`,
                   7 * (w + 1) - 1).rstrip() +
           '\n' * l + weekheader(w).rstrip() + '\n' * l)
      for aweek in monthcalendar(theyear, themonth):
          s = s + week(aweek, w).rstrip() + '\n' * l
      return s[:-l] + '\n'
  
  # Spacing of month columns for 3-column year calendar
  _colwidth = 7*3 - 1         # Amount printed by prweek()
  _spacing = 6                # Number of spaces between columns
  
  def format3c(a, b, c, colwidth=_colwidth, spacing=_spacing):
      """Prints 3-column formatting for year calendars"""
      print format3cstring(a, b, c, colwidth, spacing)
  
  def format3cstring(a, b, c, colwidth=_colwidth, spacing=_spacing):
      """Returns a string formatted from 3 strings, centered within 3 columns."""
      return (_center(a, colwidth) + ' ' * spacing + _center(b, colwidth) +
              ' ' * spacing + _center(c, colwidth))
  
  def prcal(year, w=0, l=0, c=_spacing):
      """Print a year's calendar."""
      print calendar(year, w, l, c),
  
  def calendar(year, w=0, l=0, c=_spacing):
      """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
      s = _center(`year`, colwidth * 3 + c * 2).rstrip() + '\n' * l
      header = weekheader(w)
      header = format3cstring(header, header, header, colwidth, c).rstrip()
      for q in range(January, January+12, 3):
          s = (s + '\n' * l +
               format3cstring(month_name[q], month_name[q+1], month_name[q+2],
                              colwidth, c).rstrip() +
               '\n' * l + header + '\n' * l)
          data = []
          height = 0
          for amonth in range(q, q + 3):
              cal = monthcalendar(year, amonth)
              if len(cal) > height:
                  height = len(cal)
              data.append(cal)
          for i in range(height):
              weeks = []
              for cal in data:
                  if i >= len(cal):
                      weeks.append('')
                  else:
                      weeks.append(week(cal[i], w))
              s = s + format3cstring(weeks[0], weeks[1], weeks[2],
                                     colwidth, c).rstrip() + '\n' * l
      return s[:-l] + '\n'
  
  EPOCH = 1970
  def timegm(tuple):
      """Unrelated but handy function to calculate Unix timestamp from GMT."""
      year, month, day, hour, minute, second = tuple[:6]
      assert year >= EPOCH
      assert 1 <= month <= 12
      days = 365*(year-EPOCH) + leapdays(EPOCH, year)
      for i in range(1, month):
          days = days + mdays[i]
      if month > 2 and isleap(year):
          days = days + 1
      days = days + day - 1
      hours = days*24 + hour
      minutes = hours*60 + minute
      seconds = minutes*60 + second
      return seconds
  