Commit | Line | Data |
---|---|---|
920dae64 AT |
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 |