home *** CD-ROM | disk | FTP | other *** search
/ linuxmafia.com 2016 / linuxmafia.com.tar / linuxmafia.com / pub / palmos / pippy-0.6beta-src.tar.gz / pippy-0.6beta-src.tar / pippy-0.6beta-src / src / Lib / calendar.py < prev    next >
Text File  |  2000-12-21  |  5KB  |  169 lines
  1. """Calendar printing functions"""
  2.  
  3. # Revision 2: uses funtions from built-in time module
  4.  
  5. # Import functions and variables from time module
  6. from time import localtime, mktime
  7.  
  8. # Exception raised for bad input (with string parameter for details)
  9. error = ValueError
  10.  
  11. # Note when comparing these calendars to the ones printed by cal(1):
  12. # My calendars have Monday as the first day of the week, and Sunday as
  13. # the last!  (I believe this is the European convention.)
  14.  
  15. # Constants for months referenced later
  16. January = 1
  17. February = 2
  18.  
  19. # Number of days per month (except for February in leap years)
  20. mdays = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
  21.  
  22. # Full and abbreviated names of weekdays
  23. day_name = ['Monday', 'Tuesday', 'Wednesday', 'Thursday',
  24.             'Friday', 'Saturday', 'Sunday']
  25. day_abbr = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
  26.  
  27. # Full and abbreviated names of months (1-based arrays!!!)
  28. month_name = ['', 'January', 'February', 'March', 'April',
  29.               'May', 'June', 'July', 'August',
  30.               'September', 'October',  'November', 'December']
  31. month_abbr = ['   ', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
  32.               'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
  33.  
  34. def isleap(year):
  35.     """Return 1 for leap years, 0 for non-leap years."""
  36.     return year % 4 == 0 and (year % 100 <> 0 or year % 400 == 0)
  37.  
  38. def leapdays(y1, y2):
  39.     """Return number of leap years in range [y1, y2).
  40.     Assume y1 <= y2 and no funny (non-leap century) years."""
  41.     return (y2+3)/4 - (y1+3)/4
  42.  
  43. def weekday(year, month, day):
  44.     """Return weekday (0-6 ~ Mon-Sun) for year (1970-...), month (1-12), day (1-31)."""
  45.     secs = mktime((year, month, day, 0, 0, 0, 0, 0, 0))
  46.     tuple = localtime(secs)
  47.     return tuple[6]
  48.  
  49. def monthrange(year, month):
  50.     """Return weekday (0-6 ~ Mon-Sun) and number of days (28-31) for year, month."""
  51.     if not 1 <= month <= 12: raise ValueError, 'bad month number'
  52.     day1 = weekday(year, month, 1)
  53.     ndays = mdays[month] + (month == February and isleap(year))
  54.     return day1, ndays
  55.  
  56. def _monthcalendar(year, month):
  57.     """Return a matrix representing a month's calendar.
  58.     Each row represents a week; days outside this month are zero."""
  59.     day1, ndays = monthrange(year, month)
  60.     rows = []
  61.     r7 = range(7)
  62.     day = 1 - day1
  63.     while day <= ndays:
  64.         row = [0, 0, 0, 0, 0, 0, 0]
  65.         for i in r7:
  66.             if 1 <= day <= ndays: row[i] = day
  67.             day = day + 1
  68.         rows.append(row)
  69.     return rows
  70.  
  71. _mc_cache = {}
  72. def monthcalendar(year, month):
  73.     """Caching interface to _monthcalendar."""
  74.     key = (year, month)
  75.     if _mc_cache.has_key(key):
  76.         return _mc_cache[key]
  77.     else:
  78.         _mc_cache[key] = ret = _monthcalendar(year, month)
  79.         return ret
  80.  
  81. def _center(str, width):
  82.     """Center a string in a field."""
  83.     n = width - len(str)
  84.     if n <= 0: return str
  85.     return ' '*((n+1)/2) + str + ' '*((n)/2)
  86.  
  87. # XXX The following code knows that print separates items with space!
  88.  
  89. def prweek(week, width):
  90.     """Print a single week (no newline)."""
  91.     for day in week:
  92.         if day == 0: s = ''
  93.         else: s = `day`
  94.         print _center(s, width),
  95.  
  96. def weekheader(width):
  97.     """Return a header for a week."""
  98.     str = ''
  99.     if width >= 9: names = day_name
  100.     else: names = day_abbr
  101.     for i in range(7):
  102.         if str: str = str + ' '
  103.         str = str + _center(names[i%7][:width], width)
  104.     return str
  105.  
  106. def prmonth(year, month, w = 0, l = 0):
  107.     """Print a month's calendar."""
  108.     w = max(2, w)
  109.     l = max(1, l)
  110.     print _center(month_name[month] + ' ' + `year`, 7*(w+1) - 1),
  111.     print '\n'*l,
  112.     print weekheader(w),
  113.     print '\n'*l,
  114.     for week in monthcalendar(year, month):
  115.         prweek(week, w)
  116.         print '\n'*l,
  117.  
  118. # Spacing of month columns
  119. _colwidth = 7*3 - 1         # Amount printed by prweek()
  120. _spacing = ' '*4            # Spaces between columns
  121.  
  122. def format3c(a, b, c):
  123.     """3-column formatting for year calendars"""
  124.     print _center(a, _colwidth),
  125.     print _spacing,
  126.     print _center(b, _colwidth),
  127.     print _spacing,
  128.     print _center(c, _colwidth)
  129.  
  130. def prcal(year):
  131.     """Print a year's calendar."""
  132.     header = weekheader(2)
  133.     format3c('', `year`, '')
  134.     for q in range(January, January+12, 3):
  135.         print
  136.         format3c(month_name[q], month_name[q+1], month_name[q+2])
  137.         format3c(header, header, header)
  138.         data = []
  139.         height = 0
  140.         for month in range(q, q+3):
  141.             cal = monthcalendar(year, month)
  142.             if len(cal) > height: height = len(cal)
  143.             data.append(cal)
  144.         for i in range(height):
  145.             for cal in data:
  146.                 if i >= len(cal):
  147.                     print ' '*_colwidth,
  148.                 else:
  149.                     prweek(cal[i], 2)
  150.                 print _spacing,
  151.             print
  152.  
  153. EPOCH = 1970
  154. def timegm(tuple):
  155.     """Unrelated but handy function to calculate Unix timestamp from GMT."""
  156.     year, month, day, hour, minute, second = tuple[:6]
  157.     assert year >= EPOCH
  158.     assert 1 <= month <= 12
  159.     days = 365*(year-EPOCH) + leapdays(EPOCH, year)
  160.     for i in range(1, month):
  161.         days = days + mdays[i]
  162.     if month > 2 and isleap(year):
  163.         days = days + 1
  164.     days = days + day - 1
  165.     hours = days*24 + hour
  166.     minutes = hours*60 + minute
  167.     seconds = minutes*60 + second
  168.     return seconds
  169.