Application: gvSIG desktop

"""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