1 /* C implementation for the date/time type documented at
2 * http://www.zope.org/Members/fdrake/DateTimeWiki/FrontPage
6 #include "modsupport.h"
7 #include "structmember.h"
11 #include "timefuncs.h"
13 /* Differentiate between building the core module and building extension
22 /* We require that C int be at least 32 bits, and use int virtually
23 * everywhere. In just a few cases we use a temp long, where a Python
24 * API returns a C long. In such cases, we have to ensure that the
25 * final result fits in a C int (this can be an issue on 64-bit boxes).
28 # error "datetime.c requires that C int have at least 32 bits"
34 /* Nine decimal digits is easy to communicate, and leaves enough room
35 * so that two delta days can be added w/o fear of overflowing a signed
36 * 32-bit int, and with plenty of room left over to absorb any possible
37 * carries from adding seconds.
39 #define MAX_DELTA_DAYS 999999999
41 /* Rename the long macros in datetime.h to more reasonable short names. */
42 #define GET_YEAR PyDateTime_GET_YEAR
43 #define GET_MONTH PyDateTime_GET_MONTH
44 #define GET_DAY PyDateTime_GET_DAY
45 #define DATE_GET_HOUR PyDateTime_DATE_GET_HOUR
46 #define DATE_GET_MINUTE PyDateTime_DATE_GET_MINUTE
47 #define DATE_GET_SECOND PyDateTime_DATE_GET_SECOND
48 #define DATE_GET_MICROSECOND PyDateTime_DATE_GET_MICROSECOND
50 /* Date accessors for date and datetime. */
51 #define SET_YEAR(o, v) (((o)->data[0] = ((v) & 0xff00) >> 8), \
52 ((o)->data[1] = ((v) & 0x00ff)))
53 #define SET_MONTH(o, v) (PyDateTime_GET_MONTH(o) = (v))
54 #define SET_DAY(o, v) (PyDateTime_GET_DAY(o) = (v))
56 /* Date/Time accessors for datetime. */
57 #define DATE_SET_HOUR(o, v) (PyDateTime_DATE_GET_HOUR(o) = (v))
58 #define DATE_SET_MINUTE(o, v) (PyDateTime_DATE_GET_MINUTE(o) = (v))
59 #define DATE_SET_SECOND(o, v) (PyDateTime_DATE_GET_SECOND(o) = (v))
60 #define DATE_SET_MICROSECOND(o, v) \
61 (((o)->data[7] = ((v) & 0xff0000) >> 16), \
62 ((o)->data[8] = ((v) & 0x00ff00) >> 8), \
63 ((o)->data[9] = ((v) & 0x0000ff)))
65 /* Time accessors for time. */
66 #define TIME_GET_HOUR PyDateTime_TIME_GET_HOUR
67 #define TIME_GET_MINUTE PyDateTime_TIME_GET_MINUTE
68 #define TIME_GET_SECOND PyDateTime_TIME_GET_SECOND
69 #define TIME_GET_MICROSECOND PyDateTime_TIME_GET_MICROSECOND
70 #define TIME_SET_HOUR(o, v) (PyDateTime_TIME_GET_HOUR(o) = (v))
71 #define TIME_SET_MINUTE(o, v) (PyDateTime_TIME_GET_MINUTE(o) = (v))
72 #define TIME_SET_SECOND(o, v) (PyDateTime_TIME_GET_SECOND(o) = (v))
73 #define TIME_SET_MICROSECOND(o, v) \
74 (((o)->data[3] = ((v) & 0xff0000) >> 16), \
75 ((o)->data[4] = ((v) & 0x00ff00) >> 8), \
76 ((o)->data[5] = ((v) & 0x0000ff)))
78 /* Delta accessors for timedelta. */
79 #define GET_TD_DAYS(o) (((PyDateTime_Delta *)(o))->days)
80 #define GET_TD_SECONDS(o) (((PyDateTime_Delta *)(o))->seconds)
81 #define GET_TD_MICROSECONDS(o) (((PyDateTime_Delta *)(o))->microseconds)
83 #define SET_TD_DAYS(o, v) ((o)->days = (v))
84 #define SET_TD_SECONDS(o, v) ((o)->seconds = (v))
85 #define SET_TD_MICROSECONDS(o, v) ((o)->microseconds = (v))
87 /* p is a pointer to a time or a datetime object; HASTZINFO(p) returns
90 #define HASTZINFO(p) (((_PyDateTime_BaseTZInfo *)(p))->hastzinfo)
92 /* M is a char or int claiming to be a valid month. The macro is equivalent
93 * to the two-sided Python test
96 #define MONTH_IS_SANE(M) ((unsigned int)(M) - 1 < 12)
98 /* Forward declarations. */
99 static PyTypeObject PyDateTime_DateType
;
100 static PyTypeObject PyDateTime_DateTimeType
;
101 static PyTypeObject PyDateTime_DeltaType
;
102 static PyTypeObject PyDateTime_TimeType
;
103 static PyTypeObject PyDateTime_TZInfoType
;
105 /* ---------------------------------------------------------------------------
109 /* k = i+j overflows iff k differs in sign from both inputs,
110 * iff k^i has sign bit set and k^j has sign bit set,
111 * iff (k^i)&(k^j) has sign bit set.
113 #define SIGNED_ADD_OVERFLOWED(RESULT, I, J) \
114 ((((RESULT) ^ (I)) & ((RESULT) ^ (J))) < 0)
116 /* Compute Python divmod(x, y), returning the quotient and storing the
117 * remainder into *r. The quotient is the floor of x/y, and that's
118 * the real point of this. C will probably truncate instead (C99
119 * requires truncation; C89 left it implementation-defined).
120 * Simplification: we *require* that y > 0 here. That's appropriate
121 * for all the uses made of it. This simplifies the code and makes
122 * the overflow case impossible (divmod(LONG_MIN, -1) is the only
126 divmod(int x
, int y
, int *r
)
137 assert(0 <= *r
&& *r
< y
);
141 /* Round a double to the nearest long. |x| must be small enough to fit
142 * in a C long; this is not checked.
145 round_to_long(double x
)
154 /* ---------------------------------------------------------------------------
155 * General calendrical helper functions
158 /* For each month ordinal in 1..12, the number of days in that month,
159 * and the number of days before that month in the same year. These
160 * are correct for non-leap years only.
162 static int _days_in_month
[] = {
163 0, /* unused; this vector uses 1-based indexing */
164 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
167 static int _days_before_month
[] = {
168 0, /* unused; this vector uses 1-based indexing */
169 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
172 /* year -> 1 if leap year, else 0. */
176 /* Cast year to unsigned. The result is the same either way, but
177 * C can generate faster code for unsigned mod than for signed
178 * mod (especially for % 4 -- a good compiler should just grab
179 * the last 2 bits when the LHS is unsigned).
181 const unsigned int ayear
= (unsigned int)year
;
182 return ayear
% 4 == 0 && (ayear
% 100 != 0 || ayear
% 400 == 0);
185 /* year, month -> number of days in that month in that year */
187 days_in_month(int year
, int month
)
191 if (month
== 2 && is_leap(year
))
194 return _days_in_month
[month
];
197 /* year, month -> number of days in year preceeding first day of month */
199 days_before_month(int year
, int month
)
205 days
= _days_before_month
[month
];
206 if (month
> 2 && is_leap(year
))
211 /* year -> number of days before January 1st of year. Remember that we
212 * start with year 1, so days_before_year(1) == 0.
215 days_before_year(int year
)
218 /* This is incorrect if year <= 0; we really want the floor
219 * here. But so long as MINYEAR is 1, the smallest year this
220 * can see is 0 (this can happen in some normalization endcases),
221 * so we'll just special-case that.
225 return y
*365 + y
/4 - y
/100 + y
/400;
232 /* Number of days in 4, 100, and 400 year cycles. That these have
233 * the correct values is asserted in the module init function.
235 #define DI4Y 1461 /* days_before_year(5); days in 4 years */
236 #define DI100Y 36524 /* days_before_year(101); days in 100 years */
237 #define DI400Y 146097 /* days_before_year(401); days in 400 years */
239 /* ordinal -> year, month, day, considering 01-Jan-0001 as day 1. */
241 ord_to_ymd(int ordinal
, int *year
, int *month
, int *day
)
243 int n
, n1
, n4
, n100
, n400
, leapyear
, preceding
;
245 /* ordinal is a 1-based index, starting at 1-Jan-1. The pattern of
246 * leap years repeats exactly every 400 years. The basic strategy is
247 * to find the closest 400-year boundary at or before ordinal, then
248 * work with the offset from that boundary to ordinal. Life is much
249 * clearer if we subtract 1 from ordinal first -- then the values
250 * of ordinal at 400-year boundaries are exactly those divisible
254 * -- --- ---- ---------- ----------------
255 * 31 Dec -400 -DI400Y -DI400Y -1
256 * 1 Jan -399 -DI400Y +1 -DI400Y 400-year boundary
260 * 1 Jan 001 1 0 400-year boundary
264 * 31 Dec 400 DI400Y DI400Y -1
265 * 1 Jan 401 DI400Y +1 DI400Y 400-year boundary
267 assert(ordinal
>= 1);
269 n400
= ordinal
/ DI400Y
;
270 n
= ordinal
% DI400Y
;
271 *year
= n400
* 400 + 1;
273 /* Now n is the (non-negative) offset, in days, from January 1 of
274 * year, to the desired date. Now compute how many 100-year cycles
276 * Note that it's possible for n100 to equal 4! In that case 4 full
277 * 100-year cycles precede the desired day, which implies the
278 * desired day is December 31 at the end of a 400-year cycle.
283 /* Now compute how many 4-year cycles precede it. */
287 /* And now how many single years. Again n1 can be 4, and again
288 * meaning that the desired day is December 31 at the end of the
294 *year
+= n100
* 100 + n4
* 4 + n1
;
295 if (n1
== 4 || n100
== 4) {
303 /* Now the year is correct, and n is the offset from January 1. We
304 * find the month via an estimate that's either exact or one too
307 leapyear
= n1
== 3 && (n4
!= 24 || n100
== 3);
308 assert(leapyear
== is_leap(*year
));
309 *month
= (n
+ 50) >> 5;
310 preceding
= (_days_before_month
[*month
] + (*month
> 2 && leapyear
));
312 /* estimate is too large */
314 preceding
-= days_in_month(*year
, *month
);
318 assert(n
< days_in_month(*year
, *month
));
323 /* year, month, day -> ordinal, considering 01-Jan-0001 as day 1. */
325 ymd_to_ord(int year
, int month
, int day
)
327 return days_before_year(year
) + days_before_month(year
, month
) + day
;
330 /* Day of week, where Monday==0, ..., Sunday==6. 1/1/1 was a Monday. */
332 weekday(int year
, int month
, int day
)
334 return (ymd_to_ord(year
, month
, day
) + 6) % 7;
337 /* Ordinal of the Monday starting week 1 of the ISO year. Week 1 is the
338 * first calendar week containing a Thursday.
341 iso_week1_monday(int year
)
343 int first_day
= ymd_to_ord(year
, 1, 1); /* ord of 1/1 */
344 /* 0 if 1/1 is a Monday, 1 if a Tue, etc. */
345 int first_weekday
= (first_day
+ 6) % 7;
346 /* ordinal of closest Monday at or before 1/1 */
347 int week1_monday
= first_day
- first_weekday
;
349 if (first_weekday
> 3) /* if 1/1 was Fri, Sat, Sun */
354 /* ---------------------------------------------------------------------------
358 /* Check that -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS. If so, return 0.
359 * If not, raise OverflowError and return -1.
362 check_delta_day_range(int days
)
364 if (-MAX_DELTA_DAYS
<= days
&& days
<= MAX_DELTA_DAYS
)
366 PyErr_Format(PyExc_OverflowError
,
367 "days=%d; must have magnitude <= %d",
368 days
, MAX_DELTA_DAYS
);
372 /* Check that date arguments are in range. Return 0 if they are. If they
373 * aren't, raise ValueError and return -1.
376 check_date_args(int year
, int month
, int day
)
379 if (year
< MINYEAR
|| year
> MAXYEAR
) {
380 PyErr_SetString(PyExc_ValueError
,
381 "year is out of range");
384 if (month
< 1 || month
> 12) {
385 PyErr_SetString(PyExc_ValueError
,
386 "month must be in 1..12");
389 if (day
< 1 || day
> days_in_month(year
, month
)) {
390 PyErr_SetString(PyExc_ValueError
,
391 "day is out of range for month");
397 /* Check that time arguments are in range. Return 0 if they are. If they
398 * aren't, raise ValueError and return -1.
401 check_time_args(int h
, int m
, int s
, int us
)
403 if (h
< 0 || h
> 23) {
404 PyErr_SetString(PyExc_ValueError
,
405 "hour must be in 0..23");
408 if (m
< 0 || m
> 59) {
409 PyErr_SetString(PyExc_ValueError
,
410 "minute must be in 0..59");
413 if (s
< 0 || s
> 59) {
414 PyErr_SetString(PyExc_ValueError
,
415 "second must be in 0..59");
418 if (us
< 0 || us
> 999999) {
419 PyErr_SetString(PyExc_ValueError
,
420 "microsecond must be in 0..999999");
426 /* ---------------------------------------------------------------------------
427 * Normalization utilities.
430 /* One step of a mixed-radix conversion. A "hi" unit is equivalent to
431 * factor "lo" units. factor must be > 0. If *lo is less than 0, or
432 * at least factor, enough of *lo is converted into "hi" units so that
433 * 0 <= *lo < factor. The input values must be such that int overflow
437 normalize_pair(int *hi
, int *lo
, int factor
)
441 if (*lo
< 0 || *lo
>= factor
) {
442 const int num_hi
= divmod(*lo
, factor
, lo
);
443 const int new_hi
= *hi
+ num_hi
;
444 assert(! SIGNED_ADD_OVERFLOWED(new_hi
, *hi
, num_hi
));
447 assert(0 <= *lo
&& *lo
< factor
);
450 /* Fiddle days (d), seconds (s), and microseconds (us) so that
453 * The input values must be such that the internals don't overflow.
454 * The way this routine is used, we don't get close.
457 normalize_d_s_us(int *d
, int *s
, int *us
)
459 if (*us
< 0 || *us
>= 1000000) {
460 normalize_pair(s
, us
, 1000000);
461 /* |s| can't be bigger than about
462 * |original s| + |original us|/1000000 now.
466 if (*s
< 0 || *s
>= 24*3600) {
467 normalize_pair(d
, s
, 24*3600);
468 /* |d| can't be bigger than about
470 * (|original s| + |original us|/1000000) / (24*3600) now.
473 assert(0 <= *s
&& *s
< 24*3600);
474 assert(0 <= *us
&& *us
< 1000000);
477 /* Fiddle years (y), months (m), and days (d) so that
479 * 1 <= *d <= days_in_month(*y, *m)
480 * The input values must be such that the internals don't overflow.
481 * The way this routine is used, we don't get close.
484 normalize_y_m_d(int *y
, int *m
, int *d
)
486 int dim
; /* # of days in month */
488 /* This gets muddy: the proper range for day can't be determined
489 * without knowing the correct month and year, but if day is, e.g.,
490 * plus or minus a million, the current month and year values make
491 * no sense (and may also be out of bounds themselves).
492 * Saying 12 months == 1 year should be non-controversial.
494 if (*m
< 1 || *m
> 12) {
496 normalize_pair(y
, m
, 12);
498 /* |y| can't be bigger than about
499 * |original y| + |original m|/12 now.
502 assert(1 <= *m
&& *m
<= 12);
504 /* Now only day can be out of bounds (year may also be out of bounds
505 * for a datetime object, but we don't care about that here).
506 * If day is out of bounds, what to do is arguable, but at least the
507 * method here is principled and explainable.
509 dim
= days_in_month(*y
, *m
);
510 if (*d
< 1 || *d
> dim
) {
511 /* Move day-1 days from the first of the month. First try to
512 * get off cheap if we're only one day out of range
513 * (adjustments for timezone alone can't be worse than that).
518 *d
= days_in_month(*y
, *m
);
525 else if (*d
== dim
+ 1) {
526 /* move forward a day */
535 int ordinal
= ymd_to_ord(*y
, *m
, 1) +
537 ord_to_ymd(ordinal
, y
, m
, d
);
544 /* Fiddle out-of-bounds months and days so that the result makes some kind
545 * of sense. The parameters are both inputs and outputs. Returns < 0 on
546 * failure, where failure means the adjusted year is out of bounds.
549 normalize_date(int *year
, int *month
, int *day
)
553 normalize_y_m_d(year
, month
, day
);
554 if (MINYEAR
<= *year
&& *year
<= MAXYEAR
)
557 PyErr_SetString(PyExc_OverflowError
,
558 "date value out of range");
564 /* Force all the datetime fields into range. The parameters are both
565 * inputs and outputs. Returns < 0 on error.
568 normalize_datetime(int *year
, int *month
, int *day
,
569 int *hour
, int *minute
, int *second
,
572 normalize_pair(second
, microsecond
, 1000000);
573 normalize_pair(minute
, second
, 60);
574 normalize_pair(hour
, minute
, 60);
575 normalize_pair(day
, hour
, 24);
576 return normalize_date(year
, month
, day
);
579 /* ---------------------------------------------------------------------------
580 * Basic object allocation: tp_alloc implementations. These allocate
581 * Python objects of the right size and type, and do the Python object-
582 * initialization bit. If there's not enough memory, they return NULL after
583 * setting MemoryError. All data members remain uninitialized trash.
585 * We abuse the tp_alloc "nitems" argument to communicate whether a tzinfo
586 * member is needed. This is ugly, imprecise, and possibly insecure.
587 * tp_basicsize for the time and datetime types is set to the size of the
588 * struct that has room for the tzinfo member, so subclasses in Python will
589 * allocate enough space for a tzinfo member whether or not one is actually
590 * needed. That's the "ugly and imprecise" parts. The "possibly insecure"
591 * part is that PyType_GenericAlloc() (which subclasses in Python end up
592 * using) just happens today to effectively ignore the nitems argument
593 * when tp_itemsize is 0, which it is for these type objects. If that
594 * changes, perhaps the callers of tp_alloc slots in this file should
595 * be changed to force a 0 nitems argument unless the type being allocated
596 * is a base type implemented in this file (so that tp_alloc is time_alloc
597 * or datetime_alloc below, which know about the nitems abuse).
601 time_alloc(PyTypeObject
*type
, Py_ssize_t aware
)
606 PyObject_MALLOC(aware
?
607 sizeof(PyDateTime_Time
) :
608 sizeof(_PyDateTime_BaseTime
));
610 return (PyObject
*)PyErr_NoMemory();
611 PyObject_INIT(self
, type
);
616 datetime_alloc(PyTypeObject
*type
, Py_ssize_t aware
)
621 PyObject_MALLOC(aware
?
622 sizeof(PyDateTime_DateTime
) :
623 sizeof(_PyDateTime_BaseDateTime
));
625 return (PyObject
*)PyErr_NoMemory();
626 PyObject_INIT(self
, type
);
630 /* ---------------------------------------------------------------------------
631 * Helpers for setting object fields. These work on pointers to the
632 * appropriate base class.
635 /* For date and datetime. */
637 set_date_fields(PyDateTime_Date
*self
, int y
, int m
, int d
)
645 /* ---------------------------------------------------------------------------
646 * Create various objects, mostly without range checking.
649 /* Create a date instance with no range checking. */
651 new_date_ex(int year
, int month
, int day
, PyTypeObject
*type
)
653 PyDateTime_Date
*self
;
655 self
= (PyDateTime_Date
*) (type
->tp_alloc(type
, 0));
657 set_date_fields(self
, year
, month
, day
);
658 return (PyObject
*) self
;
661 #define new_date(year, month, day) \
662 new_date_ex(year, month, day, &PyDateTime_DateType)
664 /* Create a datetime instance with no range checking. */
666 new_datetime_ex(int year
, int month
, int day
, int hour
, int minute
,
667 int second
, int usecond
, PyObject
*tzinfo
, PyTypeObject
*type
)
669 PyDateTime_DateTime
*self
;
670 char aware
= tzinfo
!= Py_None
;
672 self
= (PyDateTime_DateTime
*) (type
->tp_alloc(type
, aware
));
674 self
->hastzinfo
= aware
;
675 set_date_fields((PyDateTime_Date
*)self
, year
, month
, day
);
676 DATE_SET_HOUR(self
, hour
);
677 DATE_SET_MINUTE(self
, minute
);
678 DATE_SET_SECOND(self
, second
);
679 DATE_SET_MICROSECOND(self
, usecond
);
682 self
->tzinfo
= tzinfo
;
685 return (PyObject
*)self
;
688 #define new_datetime(y, m, d, hh, mm, ss, us, tzinfo) \
689 new_datetime_ex(y, m, d, hh, mm, ss, us, tzinfo, \
690 &PyDateTime_DateTimeType)
692 /* Create a time instance with no range checking. */
694 new_time_ex(int hour
, int minute
, int second
, int usecond
,
695 PyObject
*tzinfo
, PyTypeObject
*type
)
697 PyDateTime_Time
*self
;
698 char aware
= tzinfo
!= Py_None
;
700 self
= (PyDateTime_Time
*) (type
->tp_alloc(type
, aware
));
702 self
->hastzinfo
= aware
;
704 TIME_SET_HOUR(self
, hour
);
705 TIME_SET_MINUTE(self
, minute
);
706 TIME_SET_SECOND(self
, second
);
707 TIME_SET_MICROSECOND(self
, usecond
);
710 self
->tzinfo
= tzinfo
;
713 return (PyObject
*)self
;
716 #define new_time(hh, mm, ss, us, tzinfo) \
717 new_time_ex(hh, mm, ss, us, tzinfo, &PyDateTime_TimeType)
719 /* Create a timedelta instance. Normalize the members iff normalize is
720 * true. Passing false is a speed optimization, if you know for sure
721 * that seconds and microseconds are already in their proper ranges. In any
722 * case, raises OverflowError and returns NULL if the normalized days is out
726 new_delta_ex(int days
, int seconds
, int microseconds
, int normalize
,
729 PyDateTime_Delta
*self
;
732 normalize_d_s_us(&days
, &seconds
, µseconds
);
733 assert(0 <= seconds
&& seconds
< 24*3600);
734 assert(0 <= microseconds
&& microseconds
< 1000000);
736 if (check_delta_day_range(days
) < 0)
739 self
= (PyDateTime_Delta
*) (type
->tp_alloc(type
, 0));
742 SET_TD_DAYS(self
, days
);
743 SET_TD_SECONDS(self
, seconds
);
744 SET_TD_MICROSECONDS(self
, microseconds
);
746 return (PyObject
*) self
;
749 #define new_delta(d, s, us, normalize) \
750 new_delta_ex(d, s, us, normalize, &PyDateTime_DeltaType)
752 /* ---------------------------------------------------------------------------
756 /* Ensure that p is None or of a tzinfo subclass. Return 0 if OK; if not
757 * raise TypeError and return -1.
760 check_tzinfo_subclass(PyObject
*p
)
762 if (p
== Py_None
|| PyTZInfo_Check(p
))
764 PyErr_Format(PyExc_TypeError
,
765 "tzinfo argument must be None or of a tzinfo subclass, "
767 Py_TYPE(p
)->tp_name
);
771 /* Return tzinfo.methname(tzinfoarg), without any checking of results.
772 * If tzinfo is None, returns None.
775 call_tzinfo_method(PyObject
*tzinfo
, char *methname
, PyObject
*tzinfoarg
)
779 assert(tzinfo
&& methname
&& tzinfoarg
);
780 assert(check_tzinfo_subclass(tzinfo
) >= 0);
781 if (tzinfo
== Py_None
) {
786 result
= PyObject_CallMethod(tzinfo
, methname
, "O", tzinfoarg
);
790 /* If self has a tzinfo member, return a BORROWED reference to it. Else
791 * return NULL, which is NOT AN ERROR. There are no error returns here,
792 * and the caller must not decref the result.
795 get_tzinfo_member(PyObject
*self
)
797 PyObject
*tzinfo
= NULL
;
799 if (PyDateTime_Check(self
) && HASTZINFO(self
))
800 tzinfo
= ((PyDateTime_DateTime
*)self
)->tzinfo
;
801 else if (PyTime_Check(self
) && HASTZINFO(self
))
802 tzinfo
= ((PyDateTime_Time
*)self
)->tzinfo
;
807 /* Call getattr(tzinfo, name)(tzinfoarg), and extract an int from the
808 * result. tzinfo must be an instance of the tzinfo class. If the method
809 * returns None, this returns 0 and sets *none to 1. If the method doesn't
810 * return None or timedelta, TypeError is raised and this returns -1. If it
811 * returnsa timedelta and the value is out of range or isn't a whole number
812 * of minutes, ValueError is raised and this returns -1.
813 * Else *none is set to 0 and the integer method result is returned.
816 call_utc_tzinfo_method(PyObject
*tzinfo
, char *name
, PyObject
*tzinfoarg
,
822 assert(tzinfo
!= NULL
);
823 assert(PyTZInfo_Check(tzinfo
));
824 assert(tzinfoarg
!= NULL
);
827 u
= call_tzinfo_method(tzinfo
, name
, tzinfoarg
);
831 else if (u
== Py_None
) {
835 else if (PyDelta_Check(u
)) {
836 const int days
= GET_TD_DAYS(u
);
837 if (days
< -1 || days
> 0)
838 result
= 24*60; /* trigger ValueError below */
840 /* next line can't overflow because we know days
843 int ss
= days
* 24 * 3600 + GET_TD_SECONDS(u
);
844 result
= divmod(ss
, 60, &ss
);
845 if (ss
|| GET_TD_MICROSECONDS(u
)) {
846 PyErr_Format(PyExc_ValueError
,
847 "tzinfo.%s() must return a "
848 "whole number of minutes",
855 PyErr_Format(PyExc_TypeError
,
856 "tzinfo.%s() must return None or "
857 "timedelta, not '%s'",
858 name
, Py_TYPE(u
)->tp_name
);
862 if (result
< -1439 || result
> 1439) {
863 PyErr_Format(PyExc_ValueError
,
864 "tzinfo.%s() returned %d; must be in "
872 /* Call tzinfo.utcoffset(tzinfoarg), and extract an integer from the
873 * result. tzinfo must be an instance of the tzinfo class. If utcoffset()
874 * returns None, call_utcoffset returns 0 and sets *none to 1. If uctoffset()
875 * doesn't return None or timedelta, TypeError is raised and this returns -1.
876 * If utcoffset() returns an invalid timedelta (out of range, or not a whole
877 * # of minutes), ValueError is raised and this returns -1. Else *none is
878 * set to 0 and the offset is returned (as int # of minutes east of UTC).
881 call_utcoffset(PyObject
*tzinfo
, PyObject
*tzinfoarg
, int *none
)
883 return call_utc_tzinfo_method(tzinfo
, "utcoffset", tzinfoarg
, none
);
886 /* Call tzinfo.name(tzinfoarg), and return the offset as a timedelta or None.
889 offset_as_timedelta(PyObject
*tzinfo
, char *name
, PyObject
*tzinfoarg
) {
892 assert(tzinfo
&& name
&& tzinfoarg
);
893 if (tzinfo
== Py_None
) {
899 int offset
= call_utc_tzinfo_method(tzinfo
, name
, tzinfoarg
,
901 if (offset
< 0 && PyErr_Occurred())
908 result
= new_delta(0, offset
* 60, 0, 1);
913 /* Call tzinfo.dst(tzinfoarg), and extract an integer from the
914 * result. tzinfo must be an instance of the tzinfo class. If dst()
915 * returns None, call_dst returns 0 and sets *none to 1. If dst()
916 & doesn't return None or timedelta, TypeError is raised and this
917 * returns -1. If dst() returns an invalid timedelta for a UTC offset,
918 * ValueError is raised and this returns -1. Else *none is set to 0 and
919 * the offset is returned (as an int # of minutes east of UTC).
922 call_dst(PyObject
*tzinfo
, PyObject
*tzinfoarg
, int *none
)
924 return call_utc_tzinfo_method(tzinfo
, "dst", tzinfoarg
, none
);
927 /* Call tzinfo.tzname(tzinfoarg), and return the result. tzinfo must be
928 * an instance of the tzinfo class or None. If tzinfo isn't None, and
929 * tzname() doesn't return None or a string, TypeError is raised and this
933 call_tzname(PyObject
*tzinfo
, PyObject
*tzinfoarg
)
937 assert(tzinfo
!= NULL
);
938 assert(check_tzinfo_subclass(tzinfo
) >= 0);
939 assert(tzinfoarg
!= NULL
);
941 if (tzinfo
== Py_None
) {
946 result
= PyObject_CallMethod(tzinfo
, "tzname", "O", tzinfoarg
);
948 if (result
!= NULL
&& result
!= Py_None
&& ! PyString_Check(result
)) {
949 PyErr_Format(PyExc_TypeError
, "tzinfo.tzname() must "
950 "return None or a string, not '%s'",
951 Py_TYPE(result
)->tp_name
);
959 /* an exception has been set; the caller should pass it on */
962 /* type isn't date, datetime, or time subclass */
966 * datetime with !hastzinfo
967 * datetime with None tzinfo,
968 * datetime where utcoffset() returns None
969 * time with !hastzinfo
970 * time with None tzinfo,
971 * time where utcoffset() returns None
975 /* time or datetime where utcoffset() doesn't return None */
979 /* Classify an object as to whether it's naive or offset-aware. See
980 * the "naivety" typedef for details. If the type is aware, *offset is set
981 * to minutes east of UTC (as returned by the tzinfo.utcoffset() method).
982 * If the type is offset-naive (or unknown, or error), *offset is set to 0.
983 * tzinfoarg is the argument to pass to the tzinfo.utcoffset() method.
986 classify_utcoffset(PyObject
*op
, PyObject
*tzinfoarg
, int *offset
)
991 assert(tzinfoarg
!= NULL
);
993 tzinfo
= get_tzinfo_member(op
); /* NULL means no tzinfo, not error */
994 if (tzinfo
== Py_None
)
996 if (tzinfo
== NULL
) {
997 /* note that a datetime passes the PyDate_Check test */
998 return (PyTime_Check(op
) || PyDate_Check(op
)) ?
999 OFFSET_NAIVE
: OFFSET_UNKNOWN
;
1001 *offset
= call_utcoffset(tzinfo
, tzinfoarg
, &none
);
1002 if (*offset
== -1 && PyErr_Occurred())
1003 return OFFSET_ERROR
;
1004 return none
? OFFSET_NAIVE
: OFFSET_AWARE
;
1007 /* Classify two objects as to whether they're naive or offset-aware.
1008 * This isn't quite the same as calling classify_utcoffset() twice: for
1009 * binary operations (comparison and subtraction), we generally want to
1010 * ignore the tzinfo members if they're identical. This is by design,
1011 * so that results match "naive" expectations when mixing objects from a
1012 * single timezone. So in that case, this sets both offsets to 0 and
1013 * both naiveties to OFFSET_NAIVE.
1014 * The function returns 0 if everything's OK, and -1 on error.
1017 classify_two_utcoffsets(PyObject
*o1
, int *offset1
, naivety
*n1
,
1018 PyObject
*tzinfoarg1
,
1019 PyObject
*o2
, int *offset2
, naivety
*n2
,
1020 PyObject
*tzinfoarg2
)
1022 if (get_tzinfo_member(o1
) == get_tzinfo_member(o2
)) {
1023 *offset1
= *offset2
= 0;
1024 *n1
= *n2
= OFFSET_NAIVE
;
1027 *n1
= classify_utcoffset(o1
, tzinfoarg1
, offset1
);
1028 if (*n1
== OFFSET_ERROR
)
1030 *n2
= classify_utcoffset(o2
, tzinfoarg2
, offset2
);
1031 if (*n2
== OFFSET_ERROR
)
1037 /* repr is like "someclass(arg1, arg2)". If tzinfo isn't None,
1039 * ", tzinfo=" + repr(tzinfo)
1040 * before the closing ")".
1043 append_keyword_tzinfo(PyObject
*repr
, PyObject
*tzinfo
)
1047 assert(PyString_Check(repr
));
1049 if (tzinfo
== Py_None
)
1051 /* Get rid of the trailing ')'. */
1052 assert(PyString_AsString(repr
)[PyString_Size(repr
)-1] == ')');
1053 temp
= PyString_FromStringAndSize(PyString_AsString(repr
),
1054 PyString_Size(repr
) - 1);
1060 /* Append ", tzinfo=". */
1061 PyString_ConcatAndDel(&repr
, PyString_FromString(", tzinfo="));
1063 /* Append repr(tzinfo). */
1064 PyString_ConcatAndDel(&repr
, PyObject_Repr(tzinfo
));
1066 /* Add a closing paren. */
1067 PyString_ConcatAndDel(&repr
, PyString_FromString(")"));
1071 /* ---------------------------------------------------------------------------
1072 * String format helpers.
1076 format_ctime(PyDateTime_Date
*date
, int hours
, int minutes
, int seconds
)
1078 static const char *DayNames
[] = {
1079 "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"
1081 static const char *MonthNames
[] = {
1082 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1083 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
1087 int wday
= weekday(GET_YEAR(date
), GET_MONTH(date
), GET_DAY(date
));
1089 PyOS_snprintf(buffer
, sizeof(buffer
), "%s %s %2d %02d:%02d:%02d %04d",
1090 DayNames
[wday
], MonthNames
[GET_MONTH(date
) - 1],
1091 GET_DAY(date
), hours
, minutes
, seconds
,
1093 return PyString_FromString(buffer
);
1096 /* Add an hours & minutes UTC offset string to buf. buf has no more than
1097 * buflen bytes remaining. The UTC offset is gotten by calling
1098 * tzinfo.uctoffset(tzinfoarg). If that returns None, \0 is stored into
1099 * *buf, and that's all. Else the returned value is checked for sanity (an
1100 * integer in range), and if that's OK it's converted to an hours & minutes
1101 * string of the form
1103 * Returns 0 if everything is OK. If the return value from utcoffset() is
1104 * bogus, an appropriate exception is set and -1 is returned.
1107 format_utcoffset(char *buf
, size_t buflen
, const char *sep
,
1108 PyObject
*tzinfo
, PyObject
*tzinfoarg
)
1116 offset
= call_utcoffset(tzinfo
, tzinfoarg
, &none
);
1117 if (offset
== -1 && PyErr_Occurred())
1128 hours
= divmod(offset
, 60, &minutes
);
1129 PyOS_snprintf(buf
, buflen
, "%c%02d%s%02d", sign
, hours
, sep
, minutes
);
1134 make_freplacement(PyObject
*object
)
1136 char freplacement
[64];
1137 if (PyTime_Check(object
))
1138 sprintf(freplacement
, "%06d", TIME_GET_MICROSECOND(object
));
1139 else if (PyDateTime_Check(object
))
1140 sprintf(freplacement
, "%06d", DATE_GET_MICROSECOND(object
));
1142 sprintf(freplacement
, "%06d", 0);
1144 return PyString_FromStringAndSize(freplacement
, strlen(freplacement
));
1147 /* I sure don't want to reproduce the strftime code from the time module,
1148 * so this imports the module and calls it. All the hair is due to
1149 * giving special meanings to the %z, %Z and %f format codes via a
1150 * preprocessing step on the format string.
1151 * tzinfoarg is the argument to pass to the object's tzinfo method, if
1155 wrap_strftime(PyObject
*object
, PyObject
*format
, PyObject
*timetuple
,
1156 PyObject
*tzinfoarg
)
1158 PyObject
*result
= NULL
; /* guilty until proved innocent */
1160 PyObject
*zreplacement
= NULL
; /* py string, replacement for %z */
1161 PyObject
*Zreplacement
= NULL
; /* py string, replacement for %Z */
1162 PyObject
*freplacement
= NULL
; /* py string, replacement for %f */
1164 char *pin
; /* pointer to next char in input format */
1165 char ch
; /* next char in input format */
1167 PyObject
*newfmt
= NULL
; /* py string, the output format */
1168 char *pnew
; /* pointer to available byte in output format */
1169 int totalnew
; /* number bytes total in output format buffer,
1170 exclusive of trailing \0 */
1171 int usednew
; /* number bytes used so far in output format buffer */
1173 char *ptoappend
; /* pointer to string to append to output buffer */
1174 int ntoappend
; /* # of bytes to append to output buffer */
1176 assert(object
&& format
&& timetuple
);
1177 assert(PyString_Check(format
));
1179 /* Give up if the year is before 1900.
1180 * Python strftime() plays games with the year, and different
1181 * games depending on whether envar PYTHON2K is set. This makes
1182 * years before 1900 a nightmare, even if the platform strftime
1183 * supports them (and not all do).
1184 * We could get a lot farther here by avoiding Python's strftime
1185 * wrapper and calling the C strftime() directly, but that isn't
1186 * an option in the Python implementation of this module.
1190 PyObject
*pyyear
= PySequence_GetItem(timetuple
, 0);
1191 if (pyyear
== NULL
) return NULL
;
1192 assert(PyInt_Check(pyyear
));
1193 year
= PyInt_AsLong(pyyear
);
1196 PyErr_Format(PyExc_ValueError
, "year=%ld is before "
1197 "1900; the datetime strftime() "
1198 "methods require year >= 1900",
1204 /* Scan the input format, looking for %z/%Z/%f escapes, building
1205 * a new format. Since computing the replacements for those codes
1206 * is expensive, don't unless they're actually used.
1208 totalnew
= PyString_Size(format
) + 1; /* realistic if no %z/%Z/%f */
1209 newfmt
= PyString_FromStringAndSize(NULL
, totalnew
);
1210 if (newfmt
== NULL
) goto Done
;
1211 pnew
= PyString_AsString(newfmt
);
1214 pin
= PyString_AsString(format
);
1215 while ((ch
= *pin
++) != '\0') {
1217 ptoappend
= pin
- 1;
1220 else if ((ch
= *pin
++) == '\0') {
1221 /* There's a lone trailing %; doesn't make sense. */
1222 PyErr_SetString(PyExc_ValueError
, "strftime format "
1226 /* A % has been seen and ch is the character after it. */
1227 else if (ch
== 'z') {
1228 if (zreplacement
== NULL
) {
1229 /* format utcoffset */
1231 PyObject
*tzinfo
= get_tzinfo_member(object
);
1232 zreplacement
= PyString_FromString("");
1233 if (zreplacement
== NULL
) goto Done
;
1234 if (tzinfo
!= Py_None
&& tzinfo
!= NULL
) {
1235 assert(tzinfoarg
!= NULL
);
1236 if (format_utcoffset(buf
,
1242 Py_DECREF(zreplacement
);
1243 zreplacement
= PyString_FromString(buf
);
1244 if (zreplacement
== NULL
) goto Done
;
1247 assert(zreplacement
!= NULL
);
1248 ptoappend
= PyString_AS_STRING(zreplacement
);
1249 ntoappend
= PyString_GET_SIZE(zreplacement
);
1251 else if (ch
== 'Z') {
1253 if (Zreplacement
== NULL
) {
1254 PyObject
*tzinfo
= get_tzinfo_member(object
);
1255 Zreplacement
= PyString_FromString("");
1256 if (Zreplacement
== NULL
) goto Done
;
1257 if (tzinfo
!= Py_None
&& tzinfo
!= NULL
) {
1259 assert(tzinfoarg
!= NULL
);
1260 temp
= call_tzname(tzinfo
, tzinfoarg
);
1261 if (temp
== NULL
) goto Done
;
1262 if (temp
!= Py_None
) {
1263 assert(PyString_Check(temp
));
1264 /* Since the tzname is getting
1265 * stuffed into the format, we
1266 * have to double any % signs
1267 * so that strftime doesn't
1268 * treat them as format codes.
1270 Py_DECREF(Zreplacement
);
1271 Zreplacement
= PyObject_CallMethod(
1275 if (Zreplacement
== NULL
)
1277 if (!PyString_Check(Zreplacement
)) {
1278 PyErr_SetString(PyExc_TypeError
, "tzname.replace() did not return a string");
1286 assert(Zreplacement
!= NULL
);
1287 ptoappend
= PyString_AS_STRING(Zreplacement
);
1288 ntoappend
= PyString_GET_SIZE(Zreplacement
);
1290 else if (ch
== 'f') {
1291 /* format microseconds */
1292 if (freplacement
== NULL
) {
1293 freplacement
= make_freplacement(object
);
1294 if (freplacement
== NULL
)
1297 assert(freplacement
!= NULL
);
1298 assert(PyString_Check(freplacement
));
1299 ptoappend
= PyString_AS_STRING(freplacement
);
1300 ntoappend
= PyString_GET_SIZE(freplacement
);
1303 /* percent followed by neither z nor Z */
1304 ptoappend
= pin
- 2;
1308 /* Append the ntoappend chars starting at ptoappend to
1311 assert(ptoappend
!= NULL
);
1312 assert(ntoappend
>= 0);
1315 while (usednew
+ ntoappend
> totalnew
) {
1316 int bigger
= totalnew
<< 1;
1317 if ((bigger
>> 1) != totalnew
) { /* overflow */
1321 if (_PyString_Resize(&newfmt
, bigger
) < 0)
1324 pnew
= PyString_AsString(newfmt
) + usednew
;
1326 memcpy(pnew
, ptoappend
, ntoappend
);
1328 usednew
+= ntoappend
;
1329 assert(usednew
<= totalnew
);
1332 if (_PyString_Resize(&newfmt
, usednew
) < 0)
1335 PyObject
*time
= PyImport_ImportModuleNoBlock("time");
1338 result
= PyObject_CallMethod(time
, "strftime", "OO",
1343 Py_XDECREF(freplacement
);
1344 Py_XDECREF(zreplacement
);
1345 Py_XDECREF(Zreplacement
);
1351 isoformat_date(PyDateTime_Date
*dt
, char buffer
[], int bufflen
)
1354 x
= PyOS_snprintf(buffer
, bufflen
,
1356 GET_YEAR(dt
), GET_MONTH(dt
), GET_DAY(dt
));
1361 isoformat_time(PyDateTime_DateTime
*dt
, char buffer
[], int bufflen
)
1363 int us
= DATE_GET_MICROSECOND(dt
);
1365 PyOS_snprintf(buffer
, bufflen
,
1366 "%02d:%02d:%02d", /* 8 characters */
1368 DATE_GET_MINUTE(dt
),
1369 DATE_GET_SECOND(dt
));
1371 PyOS_snprintf(buffer
+ 8, bufflen
- 8, ".%06d", us
);
1374 /* ---------------------------------------------------------------------------
1375 * Wrap functions from the time module. These aren't directly available
1376 * from C. Perhaps they should be.
1379 /* Call time.time() and return its result (a Python float). */
1383 PyObject
*result
= NULL
;
1384 PyObject
*time
= PyImport_ImportModuleNoBlock("time");
1387 result
= PyObject_CallMethod(time
, "time", "()");
1393 /* Build a time.struct_time. The weekday and day number are automatically
1394 * computed from the y,m,d args.
1397 build_struct_time(int y
, int m
, int d
, int hh
, int mm
, int ss
, int dstflag
)
1400 PyObject
*result
= NULL
;
1402 time
= PyImport_ImportModuleNoBlock("time");
1404 result
= PyObject_CallMethod(time
, "struct_time",
1409 days_before_month(y
, m
) + d
,
1416 /* ---------------------------------------------------------------------------
1417 * Miscellaneous helpers.
1420 /* For obscure reasons, we need to use tp_richcompare instead of tp_compare.
1421 * The comparisons here all most naturally compute a cmp()-like result.
1422 * This little helper turns that into a bool result for rich comparisons.
1425 diff_to_bool(int diff
, int op
)
1431 case Py_EQ
: istrue
= diff
== 0; break;
1432 case Py_NE
: istrue
= diff
!= 0; break;
1433 case Py_LE
: istrue
= diff
<= 0; break;
1434 case Py_GE
: istrue
= diff
>= 0; break;
1435 case Py_LT
: istrue
= diff
< 0; break;
1436 case Py_GT
: istrue
= diff
> 0; break;
1438 assert(! "op unknown");
1439 istrue
= 0; /* To shut up compiler */
1441 result
= istrue
? Py_True
: Py_False
;
1446 /* Raises a "can't compare" TypeError and returns NULL. */
1448 cmperror(PyObject
*a
, PyObject
*b
)
1450 PyErr_Format(PyExc_TypeError
,
1451 "can't compare %s to %s",
1452 Py_TYPE(a
)->tp_name
, Py_TYPE(b
)->tp_name
);
1456 /* ---------------------------------------------------------------------------
1457 * Cached Python objects; these are set by the module init function.
1460 /* Conversion factors. */
1461 static PyObject
*us_per_us
= NULL
; /* 1 */
1462 static PyObject
*us_per_ms
= NULL
; /* 1000 */
1463 static PyObject
*us_per_second
= NULL
; /* 1000000 */
1464 static PyObject
*us_per_minute
= NULL
; /* 1e6 * 60 as Python int */
1465 static PyObject
*us_per_hour
= NULL
; /* 1e6 * 3600 as Python long */
1466 static PyObject
*us_per_day
= NULL
; /* 1e6 * 3600 * 24 as Python long */
1467 static PyObject
*us_per_week
= NULL
; /* 1e6*3600*24*7 as Python long */
1468 static PyObject
*seconds_per_day
= NULL
; /* 3600*24 as Python int */
1470 /* ---------------------------------------------------------------------------
1471 * Class implementations.
1475 * PyDateTime_Delta implementation.
1478 /* Convert a timedelta to a number of us,
1479 * (24*3600*self.days + self.seconds)*1000000 + self.microseconds
1480 * as a Python int or long.
1481 * Doing mixed-radix arithmetic by hand instead is excruciating in C,
1482 * due to ubiquitous overflow possibilities.
1485 delta_to_microseconds(PyDateTime_Delta
*self
)
1487 PyObject
*x1
= NULL
;
1488 PyObject
*x2
= NULL
;
1489 PyObject
*x3
= NULL
;
1490 PyObject
*result
= NULL
;
1492 x1
= PyInt_FromLong(GET_TD_DAYS(self
));
1495 x2
= PyNumber_Multiply(x1
, seconds_per_day
); /* days in seconds */
1501 /* x2 has days in seconds */
1502 x1
= PyInt_FromLong(GET_TD_SECONDS(self
)); /* seconds */
1505 x3
= PyNumber_Add(x1
, x2
); /* days and seconds in seconds */
1512 /* x3 has days+seconds in seconds */
1513 x1
= PyNumber_Multiply(x3
, us_per_second
); /* us */
1519 /* x1 has days+seconds in us */
1520 x2
= PyInt_FromLong(GET_TD_MICROSECONDS(self
));
1523 result
= PyNumber_Add(x1
, x2
);
1532 /* Convert a number of us (as a Python int or long) to a timedelta.
1535 microseconds_to_delta_ex(PyObject
*pyus
, PyTypeObject
*type
)
1542 PyObject
*tuple
= NULL
;
1543 PyObject
*num
= NULL
;
1544 PyObject
*result
= NULL
;
1546 tuple
= PyNumber_Divmod(pyus
, us_per_second
);
1550 num
= PyTuple_GetItem(tuple
, 1); /* us */
1553 temp
= PyLong_AsLong(num
);
1555 if (temp
== -1 && PyErr_Occurred())
1557 assert(0 <= temp
&& temp
< 1000000);
1560 /* The divisor was positive, so this must be an error. */
1561 assert(PyErr_Occurred());
1565 num
= PyTuple_GetItem(tuple
, 0); /* leftover seconds */
1571 tuple
= PyNumber_Divmod(num
, seconds_per_day
);
1576 num
= PyTuple_GetItem(tuple
, 1); /* seconds */
1579 temp
= PyLong_AsLong(num
);
1581 if (temp
== -1 && PyErr_Occurred())
1583 assert(0 <= temp
&& temp
< 24*3600);
1587 /* The divisor was positive, so this must be an error. */
1588 assert(PyErr_Occurred());
1592 num
= PyTuple_GetItem(tuple
, 0); /* leftover days */
1596 temp
= PyLong_AsLong(num
);
1597 if (temp
== -1 && PyErr_Occurred())
1600 if ((long)d
!= temp
) {
1601 PyErr_SetString(PyExc_OverflowError
, "normalized days too "
1602 "large to fit in a C int");
1605 result
= new_delta_ex(d
, s
, us
, 0, type
);
1613 #define microseconds_to_delta(pymicros) \
1614 microseconds_to_delta_ex(pymicros, &PyDateTime_DeltaType)
1617 multiply_int_timedelta(PyObject
*intobj
, PyDateTime_Delta
*delta
)
1623 pyus_in
= delta_to_microseconds(delta
);
1624 if (pyus_in
== NULL
)
1627 pyus_out
= PyNumber_Multiply(pyus_in
, intobj
);
1629 if (pyus_out
== NULL
)
1632 result
= microseconds_to_delta(pyus_out
);
1633 Py_DECREF(pyus_out
);
1638 divide_timedelta_int(PyDateTime_Delta
*delta
, PyObject
*intobj
)
1644 pyus_in
= delta_to_microseconds(delta
);
1645 if (pyus_in
== NULL
)
1648 pyus_out
= PyNumber_FloorDivide(pyus_in
, intobj
);
1650 if (pyus_out
== NULL
)
1653 result
= microseconds_to_delta(pyus_out
);
1654 Py_DECREF(pyus_out
);
1659 delta_add(PyObject
*left
, PyObject
*right
)
1661 PyObject
*result
= Py_NotImplemented
;
1663 if (PyDelta_Check(left
) && PyDelta_Check(right
)) {
1665 /* The C-level additions can't overflow because of the
1668 int days
= GET_TD_DAYS(left
) + GET_TD_DAYS(right
);
1669 int seconds
= GET_TD_SECONDS(left
) + GET_TD_SECONDS(right
);
1670 int microseconds
= GET_TD_MICROSECONDS(left
) +
1671 GET_TD_MICROSECONDS(right
);
1672 result
= new_delta(days
, seconds
, microseconds
, 1);
1675 if (result
== Py_NotImplemented
)
1681 delta_negative(PyDateTime_Delta
*self
)
1683 return new_delta(-GET_TD_DAYS(self
),
1684 -GET_TD_SECONDS(self
),
1685 -GET_TD_MICROSECONDS(self
),
1690 delta_positive(PyDateTime_Delta
*self
)
1692 /* Could optimize this (by returning self) if this isn't a
1693 * subclass -- but who uses unary + ? Approximately nobody.
1695 return new_delta(GET_TD_DAYS(self
),
1696 GET_TD_SECONDS(self
),
1697 GET_TD_MICROSECONDS(self
),
1702 delta_abs(PyDateTime_Delta
*self
)
1706 assert(GET_TD_MICROSECONDS(self
) >= 0);
1707 assert(GET_TD_SECONDS(self
) >= 0);
1709 if (GET_TD_DAYS(self
) < 0)
1710 result
= delta_negative(self
);
1712 result
= delta_positive(self
);
1718 delta_subtract(PyObject
*left
, PyObject
*right
)
1720 PyObject
*result
= Py_NotImplemented
;
1722 if (PyDelta_Check(left
) && PyDelta_Check(right
)) {
1724 PyObject
*minus_right
= PyNumber_Negative(right
);
1726 result
= delta_add(left
, minus_right
);
1727 Py_DECREF(minus_right
);
1733 if (result
== Py_NotImplemented
)
1738 /* This is more natural as a tp_compare, but doesn't work then: for whatever
1739 * reason, Python's try_3way_compare ignores tp_compare unless
1740 * PyInstance_Check returns true, but these aren't old-style classes.
1743 delta_richcompare(PyDateTime_Delta
*self
, PyObject
*other
, int op
)
1745 int diff
= 42; /* nonsense */
1747 if (PyDelta_Check(other
)) {
1748 diff
= GET_TD_DAYS(self
) - GET_TD_DAYS(other
);
1750 diff
= GET_TD_SECONDS(self
) - GET_TD_SECONDS(other
);
1752 diff
= GET_TD_MICROSECONDS(self
) -
1753 GET_TD_MICROSECONDS(other
);
1756 else if (op
== Py_EQ
|| op
== Py_NE
)
1757 diff
= 1; /* any non-zero value will do */
1759 else /* stop this from falling back to address comparison */
1760 return cmperror((PyObject
*)self
, other
);
1762 return diff_to_bool(diff
, op
);
1765 static PyObject
*delta_getstate(PyDateTime_Delta
*self
);
1768 delta_hash(PyDateTime_Delta
*self
)
1770 if (self
->hashcode
== -1) {
1771 PyObject
*temp
= delta_getstate(self
);
1773 self
->hashcode
= PyObject_Hash(temp
);
1777 return self
->hashcode
;
1781 delta_multiply(PyObject
*left
, PyObject
*right
)
1783 PyObject
*result
= Py_NotImplemented
;
1785 if (PyDelta_Check(left
)) {
1787 if (PyInt_Check(right
) || PyLong_Check(right
))
1788 result
= multiply_int_timedelta(right
,
1789 (PyDateTime_Delta
*) left
);
1791 else if (PyInt_Check(left
) || PyLong_Check(left
))
1792 result
= multiply_int_timedelta(left
,
1793 (PyDateTime_Delta
*) right
);
1795 if (result
== Py_NotImplemented
)
1801 delta_divide(PyObject
*left
, PyObject
*right
)
1803 PyObject
*result
= Py_NotImplemented
;
1805 if (PyDelta_Check(left
)) {
1807 if (PyInt_Check(right
) || PyLong_Check(right
))
1808 result
= divide_timedelta_int(
1809 (PyDateTime_Delta
*)left
,
1813 if (result
== Py_NotImplemented
)
1818 /* Fold in the value of the tag ("seconds", "weeks", etc) component of a
1819 * timedelta constructor. sofar is the # of microseconds accounted for
1820 * so far, and there are factor microseconds per current unit, the number
1821 * of which is given by num. num * factor is added to sofar in a
1822 * numerically careful way, and that's the result. Any fractional
1823 * microseconds left over (this can happen if num is a float type) are
1824 * added into *leftover.
1825 * Note that there are many ways this can give an error (NULL) return.
1828 accum(const char* tag
, PyObject
*sofar
, PyObject
*num
, PyObject
*factor
,
1834 assert(num
!= NULL
);
1836 if (PyInt_Check(num
) || PyLong_Check(num
)) {
1837 prod
= PyNumber_Multiply(num
, factor
);
1840 sum
= PyNumber_Add(sofar
, prod
);
1845 if (PyFloat_Check(num
)) {
1852 /* The Plan: decompose num into an integer part and a
1853 * fractional part, num = intpart + fracpart.
1854 * Then num * factor ==
1855 * intpart * factor + fracpart * factor
1856 * and the LHS can be computed exactly in long arithmetic.
1857 * The RHS is again broken into an int part and frac part.
1858 * and the frac part is added into *leftover.
1860 dnum
= PyFloat_AsDouble(num
);
1861 if (dnum
== -1.0 && PyErr_Occurred())
1863 fracpart
= modf(dnum
, &intpart
);
1864 x
= PyLong_FromDouble(intpart
);
1868 prod
= PyNumber_Multiply(x
, factor
);
1873 sum
= PyNumber_Add(sofar
, prod
);
1878 if (fracpart
== 0.0)
1880 /* So far we've lost no information. Dealing with the
1881 * fractional part requires float arithmetic, and may
1882 * lose a little info.
1884 assert(PyInt_Check(factor
) || PyLong_Check(factor
));
1885 if (PyInt_Check(factor
))
1886 dnum
= (double)PyInt_AsLong(factor
);
1888 dnum
= PyLong_AsDouble(factor
);
1891 fracpart
= modf(dnum
, &intpart
);
1892 x
= PyLong_FromDouble(intpart
);
1898 y
= PyNumber_Add(sum
, x
);
1901 *leftover
+= fracpart
;
1905 PyErr_Format(PyExc_TypeError
,
1906 "unsupported type for timedelta %s component: %s",
1907 tag
, Py_TYPE(num
)->tp_name
);
1912 delta_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kw
)
1914 PyObject
*self
= NULL
;
1916 /* Argument objects. */
1917 PyObject
*day
= NULL
;
1918 PyObject
*second
= NULL
;
1919 PyObject
*us
= NULL
;
1920 PyObject
*ms
= NULL
;
1921 PyObject
*minute
= NULL
;
1922 PyObject
*hour
= NULL
;
1923 PyObject
*week
= NULL
;
1925 PyObject
*x
= NULL
; /* running sum of microseconds */
1926 PyObject
*y
= NULL
; /* temp sum of microseconds */
1927 double leftover_us
= 0.0;
1929 static char *keywords
[] = {
1930 "days", "seconds", "microseconds", "milliseconds",
1931 "minutes", "hours", "weeks", NULL
1934 if (PyArg_ParseTupleAndKeywords(args
, kw
, "|OOOOOOO:__new__",
1937 &ms
, &minute
, &hour
, &week
) == 0)
1940 x
= PyInt_FromLong(0);
1951 y
= accum("microseconds", x
, us
, us_per_us
, &leftover_us
);
1955 y
= accum("milliseconds", x
, ms
, us_per_ms
, &leftover_us
);
1959 y
= accum("seconds", x
, second
, us_per_second
, &leftover_us
);
1963 y
= accum("minutes", x
, minute
, us_per_minute
, &leftover_us
);
1967 y
= accum("hours", x
, hour
, us_per_hour
, &leftover_us
);
1971 y
= accum("days", x
, day
, us_per_day
, &leftover_us
);
1975 y
= accum("weeks", x
, week
, us_per_week
, &leftover_us
);
1979 /* Round to nearest whole # of us, and add into x. */
1980 PyObject
*temp
= PyLong_FromLong(round_to_long(leftover_us
));
1985 y
= PyNumber_Add(x
, temp
);
1990 self
= microseconds_to_delta_ex(x
, type
);
1999 delta_nonzero(PyDateTime_Delta
*self
)
2001 return (GET_TD_DAYS(self
) != 0
2002 || GET_TD_SECONDS(self
) != 0
2003 || GET_TD_MICROSECONDS(self
) != 0);
2007 delta_repr(PyDateTime_Delta
*self
)
2009 if (GET_TD_MICROSECONDS(self
) != 0)
2010 return PyString_FromFormat("%s(%d, %d, %d)",
2011 Py_TYPE(self
)->tp_name
,
2013 GET_TD_SECONDS(self
),
2014 GET_TD_MICROSECONDS(self
));
2015 if (GET_TD_SECONDS(self
) != 0)
2016 return PyString_FromFormat("%s(%d, %d)",
2017 Py_TYPE(self
)->tp_name
,
2019 GET_TD_SECONDS(self
));
2021 return PyString_FromFormat("%s(%d)",
2022 Py_TYPE(self
)->tp_name
,
2027 delta_str(PyDateTime_Delta
*self
)
2029 int days
= GET_TD_DAYS(self
);
2030 int seconds
= GET_TD_SECONDS(self
);
2031 int us
= GET_TD_MICROSECONDS(self
);
2036 size_t buflen
= sizeof(buf
);
2039 minutes
= divmod(seconds
, 60, &seconds
);
2040 hours
= divmod(minutes
, 60, &minutes
);
2043 n
= PyOS_snprintf(pbuf
, buflen
, "%d day%s, ", days
,
2044 (days
== 1 || days
== -1) ? "" : "s");
2045 if (n
< 0 || (size_t)n
>= buflen
)
2048 buflen
-= (size_t)n
;
2051 n
= PyOS_snprintf(pbuf
, buflen
, "%d:%02d:%02d",
2052 hours
, minutes
, seconds
);
2053 if (n
< 0 || (size_t)n
>= buflen
)
2056 buflen
-= (size_t)n
;
2059 n
= PyOS_snprintf(pbuf
, buflen
, ".%06d", us
);
2060 if (n
< 0 || (size_t)n
>= buflen
)
2065 return PyString_FromStringAndSize(buf
, pbuf
- buf
);
2068 PyErr_SetString(PyExc_SystemError
, "goofy result from PyOS_snprintf");
2072 /* Pickle support, a simple use of __reduce__. */
2074 /* __getstate__ isn't exposed */
2076 delta_getstate(PyDateTime_Delta
*self
)
2078 return Py_BuildValue("iii", GET_TD_DAYS(self
),
2079 GET_TD_SECONDS(self
),
2080 GET_TD_MICROSECONDS(self
));
2084 delta_reduce(PyDateTime_Delta
* self
)
2086 return Py_BuildValue("ON", Py_TYPE(self
), delta_getstate(self
));
2089 #define OFFSET(field) offsetof(PyDateTime_Delta, field)
2091 static PyMemberDef delta_members
[] = {
2093 {"days", T_INT
, OFFSET(days
), READONLY
,
2094 PyDoc_STR("Number of days.")},
2096 {"seconds", T_INT
, OFFSET(seconds
), READONLY
,
2097 PyDoc_STR("Number of seconds (>= 0 and less than 1 day).")},
2099 {"microseconds", T_INT
, OFFSET(microseconds
), READONLY
,
2100 PyDoc_STR("Number of microseconds (>= 0 and less than 1 second).")},
2104 static PyMethodDef delta_methods
[] = {
2105 {"__reduce__", (PyCFunction
)delta_reduce
, METH_NOARGS
,
2106 PyDoc_STR("__reduce__() -> (cls, state)")},
2111 static char delta_doc
[] =
2112 PyDoc_STR("Difference between two datetime values.");
2114 static PyNumberMethods delta_as_number
= {
2115 delta_add
, /* nb_add */
2116 delta_subtract
, /* nb_subtract */
2117 delta_multiply
, /* nb_multiply */
2118 delta_divide
, /* nb_divide */
2119 0, /* nb_remainder */
2122 (unaryfunc
)delta_negative
, /* nb_negative */
2123 (unaryfunc
)delta_positive
, /* nb_positive */
2124 (unaryfunc
)delta_abs
, /* nb_absolute */
2125 (inquiry
)delta_nonzero
, /* nb_nonzero */
2138 0, /*nb_inplace_add*/
2139 0, /*nb_inplace_subtract*/
2140 0, /*nb_inplace_multiply*/
2141 0, /*nb_inplace_divide*/
2142 0, /*nb_inplace_remainder*/
2143 0, /*nb_inplace_power*/
2144 0, /*nb_inplace_lshift*/
2145 0, /*nb_inplace_rshift*/
2146 0, /*nb_inplace_and*/
2147 0, /*nb_inplace_xor*/
2148 0, /*nb_inplace_or*/
2149 delta_divide
, /* nb_floor_divide */
2150 0, /* nb_true_divide */
2151 0, /* nb_inplace_floor_divide */
2152 0, /* nb_inplace_true_divide */
2155 static PyTypeObject PyDateTime_DeltaType
= {
2156 PyVarObject_HEAD_INIT(NULL
, 0)
2157 "datetime.timedelta", /* tp_name */
2158 sizeof(PyDateTime_Delta
), /* tp_basicsize */
2159 0, /* tp_itemsize */
2165 (reprfunc
)delta_repr
, /* tp_repr */
2166 &delta_as_number
, /* tp_as_number */
2167 0, /* tp_as_sequence */
2168 0, /* tp_as_mapping */
2169 (hashfunc
)delta_hash
, /* tp_hash */
2171 (reprfunc
)delta_str
, /* tp_str */
2172 PyObject_GenericGetAttr
, /* tp_getattro */
2173 0, /* tp_setattro */
2174 0, /* tp_as_buffer */
2175 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
|
2176 Py_TPFLAGS_BASETYPE
, /* tp_flags */
2177 delta_doc
, /* tp_doc */
2178 0, /* tp_traverse */
2180 (richcmpfunc
)delta_richcompare
, /* tp_richcompare */
2181 0, /* tp_weaklistoffset */
2183 0, /* tp_iternext */
2184 delta_methods
, /* tp_methods */
2185 delta_members
, /* tp_members */
2189 0, /* tp_descr_get */
2190 0, /* tp_descr_set */
2191 0, /* tp_dictoffset */
2194 delta_new
, /* tp_new */
2199 * PyDateTime_Date implementation.
2202 /* Accessor properties. */
2205 date_year(PyDateTime_Date
*self
, void *unused
)
2207 return PyInt_FromLong(GET_YEAR(self
));
2211 date_month(PyDateTime_Date
*self
, void *unused
)
2213 return PyInt_FromLong(GET_MONTH(self
));
2217 date_day(PyDateTime_Date
*self
, void *unused
)
2219 return PyInt_FromLong(GET_DAY(self
));
2222 static PyGetSetDef date_getset
[] = {
2223 {"year", (getter
)date_year
},
2224 {"month", (getter
)date_month
},
2225 {"day", (getter
)date_day
},
2231 static char *date_kws
[] = {"year", "month", "day", NULL
};
2234 date_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kw
)
2236 PyObject
*self
= NULL
;
2242 /* Check for invocation from pickle with __getstate__ state */
2243 if (PyTuple_GET_SIZE(args
) == 1 &&
2244 PyString_Check(state
= PyTuple_GET_ITEM(args
, 0)) &&
2245 PyString_GET_SIZE(state
) == _PyDateTime_DATE_DATASIZE
&&
2246 MONTH_IS_SANE(PyString_AS_STRING(state
)[2]))
2248 PyDateTime_Date
*me
;
2250 me
= (PyDateTime_Date
*) (type
->tp_alloc(type
, 0));
2252 char *pdata
= PyString_AS_STRING(state
);
2253 memcpy(me
->data
, pdata
, _PyDateTime_DATE_DATASIZE
);
2256 return (PyObject
*)me
;
2259 if (PyArg_ParseTupleAndKeywords(args
, kw
, "iii", date_kws
,
2260 &year
, &month
, &day
)) {
2261 if (check_date_args(year
, month
, day
) < 0)
2263 self
= new_date_ex(year
, month
, day
, type
);
2268 /* Return new date from localtime(t). */
2270 date_local_from_time_t(PyObject
*cls
, double ts
)
2274 PyObject
*result
= NULL
;
2276 t
= _PyTime_DoubleToTimet(ts
);
2277 if (t
== (time_t)-1 && PyErr_Occurred())
2281 result
= PyObject_CallFunction(cls
, "iii",
2286 PyErr_SetString(PyExc_ValueError
,
2287 "timestamp out of range for "
2288 "platform localtime() function");
2292 /* Return new date from current time.
2293 * We say this is equivalent to fromtimestamp(time.time()), and the
2294 * only way to be sure of that is to *call* time.time(). That's not
2295 * generally the same as calling C's time.
2298 date_today(PyObject
*cls
, PyObject
*dummy
)
2307 /* Note well: today() is a class method, so this may not call
2308 * date.fromtimestamp. For example, it may call
2309 * datetime.fromtimestamp. That's why we need all the accuracy
2310 * time.time() delivers; if someone were gonzo about optimization,
2311 * date.today() could get away with plain C time().
2313 result
= PyObject_CallMethod(cls
, "fromtimestamp", "O", time
);
2318 /* Return new date from given timestamp (Python timestamp -- a double). */
2320 date_fromtimestamp(PyObject
*cls
, PyObject
*args
)
2323 PyObject
*result
= NULL
;
2325 if (PyArg_ParseTuple(args
, "d:fromtimestamp", ×tamp
))
2326 result
= date_local_from_time_t(cls
, timestamp
);
2330 /* Return new date from proleptic Gregorian ordinal. Raises ValueError if
2331 * the ordinal is out of range.
2334 date_fromordinal(PyObject
*cls
, PyObject
*args
)
2336 PyObject
*result
= NULL
;
2339 if (PyArg_ParseTuple(args
, "i:fromordinal", &ordinal
)) {
2345 PyErr_SetString(PyExc_ValueError
, "ordinal must be "
2348 ord_to_ymd(ordinal
, &year
, &month
, &day
);
2349 result
= PyObject_CallFunction(cls
, "iii",
2360 /* date + timedelta -> date. If arg negate is true, subtract the timedelta
2364 add_date_timedelta(PyDateTime_Date
*date
, PyDateTime_Delta
*delta
, int negate
)
2366 PyObject
*result
= NULL
;
2367 int year
= GET_YEAR(date
);
2368 int month
= GET_MONTH(date
);
2369 int deltadays
= GET_TD_DAYS(delta
);
2370 /* C-level overflow is impossible because |deltadays| < 1e9. */
2371 int day
= GET_DAY(date
) + (negate
? -deltadays
: deltadays
);
2373 if (normalize_date(&year
, &month
, &day
) >= 0)
2374 result
= new_date(year
, month
, day
);
2379 date_add(PyObject
*left
, PyObject
*right
)
2381 if (PyDateTime_Check(left
) || PyDateTime_Check(right
)) {
2382 Py_INCREF(Py_NotImplemented
);
2383 return Py_NotImplemented
;
2385 if (PyDate_Check(left
)) {
2387 if (PyDelta_Check(right
))
2389 return add_date_timedelta((PyDateTime_Date
*) left
,
2390 (PyDateTime_Delta
*) right
,
2395 * 'right' must be one of us, or we wouldn't have been called
2397 if (PyDelta_Check(left
))
2399 return add_date_timedelta((PyDateTime_Date
*) right
,
2400 (PyDateTime_Delta
*) left
,
2403 Py_INCREF(Py_NotImplemented
);
2404 return Py_NotImplemented
;
2408 date_subtract(PyObject
*left
, PyObject
*right
)
2410 if (PyDateTime_Check(left
) || PyDateTime_Check(right
)) {
2411 Py_INCREF(Py_NotImplemented
);
2412 return Py_NotImplemented
;
2414 if (PyDate_Check(left
)) {
2415 if (PyDate_Check(right
)) {
2417 int left_ord
= ymd_to_ord(GET_YEAR(left
),
2420 int right_ord
= ymd_to_ord(GET_YEAR(right
),
2423 return new_delta(left_ord
- right_ord
, 0, 0, 0);
2425 if (PyDelta_Check(right
)) {
2427 return add_date_timedelta((PyDateTime_Date
*) left
,
2428 (PyDateTime_Delta
*) right
,
2432 Py_INCREF(Py_NotImplemented
);
2433 return Py_NotImplemented
;
2437 /* Various ways to turn a date into a string. */
2440 date_repr(PyDateTime_Date
*self
)
2443 const char *type_name
;
2445 type_name
= Py_TYPE(self
)->tp_name
;
2446 PyOS_snprintf(buffer
, sizeof(buffer
), "%s(%d, %d, %d)",
2448 GET_YEAR(self
), GET_MONTH(self
), GET_DAY(self
));
2450 return PyString_FromString(buffer
);
2454 date_isoformat(PyDateTime_Date
*self
)
2458 isoformat_date(self
, buffer
, sizeof(buffer
));
2459 return PyString_FromString(buffer
);
2462 /* str() calls the appropriate isoformat() method. */
2464 date_str(PyDateTime_Date
*self
)
2466 return PyObject_CallMethod((PyObject
*)self
, "isoformat", "()");
2471 date_ctime(PyDateTime_Date
*self
)
2473 return format_ctime(self
, 0, 0, 0);
2477 date_strftime(PyDateTime_Date
*self
, PyObject
*args
, PyObject
*kw
)
2479 /* This method can be inherited, and needs to call the
2480 * timetuple() method appropriate to self's class.
2485 static char *keywords
[] = {"format", NULL
};
2487 if (! PyArg_ParseTupleAndKeywords(args
, kw
, "O!:strftime", keywords
,
2488 &PyString_Type
, &format
))
2491 tuple
= PyObject_CallMethod((PyObject
*)self
, "timetuple", "()");
2494 result
= wrap_strftime((PyObject
*)self
, format
, tuple
,
2501 date_format(PyDateTime_Date
*self
, PyObject
*args
)
2505 if (!PyArg_ParseTuple(args
, "O:__format__", &format
))
2508 /* Check for str or unicode */
2509 if (PyString_Check(format
)) {
2510 /* If format is zero length, return str(self) */
2511 if (PyString_GET_SIZE(format
) == 0)
2512 return PyObject_Str((PyObject
*)self
);
2513 } else if (PyUnicode_Check(format
)) {
2514 /* If format is zero length, return str(self) */
2515 if (PyUnicode_GET_SIZE(format
) == 0)
2516 return PyObject_Unicode((PyObject
*)self
);
2518 PyErr_Format(PyExc_ValueError
,
2519 "__format__ expects str or unicode, not %.200s",
2520 Py_TYPE(format
)->tp_name
);
2523 return PyObject_CallMethod((PyObject
*)self
, "strftime", "O", format
);
2529 date_isoweekday(PyDateTime_Date
*self
)
2531 int dow
= weekday(GET_YEAR(self
), GET_MONTH(self
), GET_DAY(self
));
2533 return PyInt_FromLong(dow
+ 1);
2537 date_isocalendar(PyDateTime_Date
*self
)
2539 int year
= GET_YEAR(self
);
2540 int week1_monday
= iso_week1_monday(year
);
2541 int today
= ymd_to_ord(year
, GET_MONTH(self
), GET_DAY(self
));
2545 week
= divmod(today
- week1_monday
, 7, &day
);
2548 week1_monday
= iso_week1_monday(year
);
2549 week
= divmod(today
- week1_monday
, 7, &day
);
2551 else if (week
>= 52 && today
>= iso_week1_monday(year
+ 1)) {
2555 return Py_BuildValue("iii", year
, week
+ 1, day
+ 1);
2558 /* Miscellaneous methods. */
2560 /* This is more natural as a tp_compare, but doesn't work then: for whatever
2561 * reason, Python's try_3way_compare ignores tp_compare unless
2562 * PyInstance_Check returns true, but these aren't old-style classes.
2565 date_richcompare(PyDateTime_Date
*self
, PyObject
*other
, int op
)
2567 int diff
= 42; /* nonsense */
2569 if (PyDate_Check(other
))
2570 diff
= memcmp(self
->data
, ((PyDateTime_Date
*)other
)->data
,
2571 _PyDateTime_DATE_DATASIZE
);
2573 else if (PyObject_HasAttrString(other
, "timetuple")) {
2574 /* A hook for other kinds of date objects. */
2575 Py_INCREF(Py_NotImplemented
);
2576 return Py_NotImplemented
;
2578 else if (op
== Py_EQ
|| op
== Py_NE
)
2579 diff
= 1; /* any non-zero value will do */
2581 else /* stop this from falling back to address comparison */
2582 return cmperror((PyObject
*)self
, other
);
2584 return diff_to_bool(diff
, op
);
2588 date_timetuple(PyDateTime_Date
*self
)
2590 return build_struct_time(GET_YEAR(self
),
2597 date_replace(PyDateTime_Date
*self
, PyObject
*args
, PyObject
*kw
)
2601 int year
= GET_YEAR(self
);
2602 int month
= GET_MONTH(self
);
2603 int day
= GET_DAY(self
);
2605 if (! PyArg_ParseTupleAndKeywords(args
, kw
, "|iii:replace", date_kws
,
2606 &year
, &month
, &day
))
2608 tuple
= Py_BuildValue("iii", year
, month
, day
);
2611 clone
= date_new(Py_TYPE(self
), tuple
, NULL
);
2616 static PyObject
*date_getstate(PyDateTime_Date
*self
);
2619 date_hash(PyDateTime_Date
*self
)
2621 if (self
->hashcode
== -1) {
2622 PyObject
*temp
= date_getstate(self
);
2624 self
->hashcode
= PyObject_Hash(temp
);
2628 return self
->hashcode
;
2632 date_toordinal(PyDateTime_Date
*self
)
2634 return PyInt_FromLong(ymd_to_ord(GET_YEAR(self
), GET_MONTH(self
),
2639 date_weekday(PyDateTime_Date
*self
)
2641 int dow
= weekday(GET_YEAR(self
), GET_MONTH(self
), GET_DAY(self
));
2643 return PyInt_FromLong(dow
);
2646 /* Pickle support, a simple use of __reduce__. */
2648 /* __getstate__ isn't exposed */
2650 date_getstate(PyDateTime_Date
*self
)
2652 return Py_BuildValue(
2654 PyString_FromStringAndSize((char *)self
->data
,
2655 _PyDateTime_DATE_DATASIZE
));
2659 date_reduce(PyDateTime_Date
*self
, PyObject
*arg
)
2661 return Py_BuildValue("(ON)", Py_TYPE(self
), date_getstate(self
));
2664 static PyMethodDef date_methods
[] = {
2666 /* Class methods: */
2668 {"fromtimestamp", (PyCFunction
)date_fromtimestamp
, METH_VARARGS
|
2670 PyDoc_STR("timestamp -> local date from a POSIX timestamp (like "
2673 {"fromordinal", (PyCFunction
)date_fromordinal
, METH_VARARGS
|
2675 PyDoc_STR("int -> date corresponding to a proleptic Gregorian "
2678 {"today", (PyCFunction
)date_today
, METH_NOARGS
| METH_CLASS
,
2679 PyDoc_STR("Current date or datetime: same as "
2680 "self.__class__.fromtimestamp(time.time()).")},
2682 /* Instance methods: */
2684 {"ctime", (PyCFunction
)date_ctime
, METH_NOARGS
,
2685 PyDoc_STR("Return ctime() style string.")},
2687 {"strftime", (PyCFunction
)date_strftime
, METH_VARARGS
| METH_KEYWORDS
,
2688 PyDoc_STR("format -> strftime() style string.")},
2690 {"__format__", (PyCFunction
)date_format
, METH_VARARGS
,
2691 PyDoc_STR("Formats self with strftime.")},
2693 {"timetuple", (PyCFunction
)date_timetuple
, METH_NOARGS
,
2694 PyDoc_STR("Return time tuple, compatible with time.localtime().")},
2696 {"isocalendar", (PyCFunction
)date_isocalendar
, METH_NOARGS
,
2697 PyDoc_STR("Return a 3-tuple containing ISO year, week number, and "
2700 {"isoformat", (PyCFunction
)date_isoformat
, METH_NOARGS
,
2701 PyDoc_STR("Return string in ISO 8601 format, YYYY-MM-DD.")},
2703 {"isoweekday", (PyCFunction
)date_isoweekday
, METH_NOARGS
,
2704 PyDoc_STR("Return the day of the week represented by the date.\n"
2705 "Monday == 1 ... Sunday == 7")},
2707 {"toordinal", (PyCFunction
)date_toordinal
, METH_NOARGS
,
2708 PyDoc_STR("Return proleptic Gregorian ordinal. January 1 of year "
2711 {"weekday", (PyCFunction
)date_weekday
, METH_NOARGS
,
2712 PyDoc_STR("Return the day of the week represented by the date.\n"
2713 "Monday == 0 ... Sunday == 6")},
2715 {"replace", (PyCFunction
)date_replace
, METH_VARARGS
| METH_KEYWORDS
,
2716 PyDoc_STR("Return date with new specified fields.")},
2718 {"__reduce__", (PyCFunction
)date_reduce
, METH_NOARGS
,
2719 PyDoc_STR("__reduce__() -> (cls, state)")},
2724 static char date_doc
[] =
2725 PyDoc_STR("date(year, month, day) --> date object");
2727 static PyNumberMethods date_as_number
= {
2728 date_add
, /* nb_add */
2729 date_subtract
, /* nb_subtract */
2730 0, /* nb_multiply */
2732 0, /* nb_remainder */
2735 0, /* nb_negative */
2736 0, /* nb_positive */
2737 0, /* nb_absolute */
2741 static PyTypeObject PyDateTime_DateType
= {
2742 PyVarObject_HEAD_INIT(NULL
, 0)
2743 "datetime.date", /* tp_name */
2744 sizeof(PyDateTime_Date
), /* tp_basicsize */
2745 0, /* tp_itemsize */
2751 (reprfunc
)date_repr
, /* tp_repr */
2752 &date_as_number
, /* tp_as_number */
2753 0, /* tp_as_sequence */
2754 0, /* tp_as_mapping */
2755 (hashfunc
)date_hash
, /* tp_hash */
2757 (reprfunc
)date_str
, /* tp_str */
2758 PyObject_GenericGetAttr
, /* tp_getattro */
2759 0, /* tp_setattro */
2760 0, /* tp_as_buffer */
2761 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
|
2762 Py_TPFLAGS_BASETYPE
, /* tp_flags */
2763 date_doc
, /* tp_doc */
2764 0, /* tp_traverse */
2766 (richcmpfunc
)date_richcompare
, /* tp_richcompare */
2767 0, /* tp_weaklistoffset */
2769 0, /* tp_iternext */
2770 date_methods
, /* tp_methods */
2772 date_getset
, /* tp_getset */
2775 0, /* tp_descr_get */
2776 0, /* tp_descr_set */
2777 0, /* tp_dictoffset */
2780 date_new
, /* tp_new */
2785 * PyDateTime_TZInfo implementation.
2788 /* This is a pure abstract base class, so doesn't do anything beyond
2789 * raising NotImplemented exceptions. Real tzinfo classes need
2790 * to derive from this. This is mostly for clarity, and for efficiency in
2791 * datetime and time constructors (their tzinfo arguments need to
2792 * be subclasses of this tzinfo class, which is easy and quick to check).
2794 * Note: For reasons having to do with pickling of subclasses, we have
2795 * to allow tzinfo objects to be instantiated. This wasn't an issue
2796 * in the Python implementation (__init__() could raise NotImplementedError
2797 * there without ill effect), but doing so in the C implementation hit a
2802 tzinfo_nogo(const char* methodname
)
2804 PyErr_Format(PyExc_NotImplementedError
,
2805 "a tzinfo subclass must implement %s()",
2810 /* Methods. A subclass must implement these. */
2813 tzinfo_tzname(PyDateTime_TZInfo
*self
, PyObject
*dt
)
2815 return tzinfo_nogo("tzname");
2819 tzinfo_utcoffset(PyDateTime_TZInfo
*self
, PyObject
*dt
)
2821 return tzinfo_nogo("utcoffset");
2825 tzinfo_dst(PyDateTime_TZInfo
*self
, PyObject
*dt
)
2827 return tzinfo_nogo("dst");
2831 tzinfo_fromutc(PyDateTime_TZInfo
*self
, PyDateTime_DateTime
*dt
)
2833 int y
, m
, d
, hh
, mm
, ss
, us
;
2840 if (! PyDateTime_Check(dt
)) {
2841 PyErr_SetString(PyExc_TypeError
,
2842 "fromutc: argument must be a datetime");
2845 if (! HASTZINFO(dt
) || dt
->tzinfo
!= (PyObject
*)self
) {
2846 PyErr_SetString(PyExc_ValueError
, "fromutc: dt.tzinfo "
2851 off
= call_utcoffset(dt
->tzinfo
, (PyObject
*)dt
, &none
);
2852 if (off
== -1 && PyErr_Occurred())
2855 PyErr_SetString(PyExc_ValueError
, "fromutc: non-None "
2856 "utcoffset() result required");
2860 dst
= call_dst(dt
->tzinfo
, (PyObject
*)dt
, &none
);
2861 if (dst
== -1 && PyErr_Occurred())
2864 PyErr_SetString(PyExc_ValueError
, "fromutc: non-None "
2865 "dst() result required");
2872 hh
= DATE_GET_HOUR(dt
);
2873 mm
= DATE_GET_MINUTE(dt
);
2874 ss
= DATE_GET_SECOND(dt
);
2875 us
= DATE_GET_MICROSECOND(dt
);
2879 if ((mm
< 0 || mm
>= 60) &&
2880 normalize_datetime(&y
, &m
, &d
, &hh
, &mm
, &ss
, &us
) < 0)
2882 result
= new_datetime(y
, m
, d
, hh
, mm
, ss
, us
, dt
->tzinfo
);
2886 dst
= call_dst(dt
->tzinfo
, result
, &none
);
2887 if (dst
== -1 && PyErr_Occurred())
2895 if ((mm
< 0 || mm
>= 60) &&
2896 normalize_datetime(&y
, &m
, &d
, &hh
, &mm
, &ss
, &us
) < 0)
2899 result
= new_datetime(y
, m
, d
, hh
, mm
, ss
, us
, dt
->tzinfo
);
2903 PyErr_SetString(PyExc_ValueError
, "fromutc: tz.dst() gave"
2904 "inconsistent results; cannot convert");
2906 /* fall thru to failure */
2913 * Pickle support. This is solely so that tzinfo subclasses can use
2914 * pickling -- tzinfo itself is supposed to be uninstantiable.
2918 tzinfo_reduce(PyObject
*self
)
2920 PyObject
*args
, *state
, *tmp
;
2921 PyObject
*getinitargs
, *getstate
;
2923 tmp
= PyTuple_New(0);
2927 getinitargs
= PyObject_GetAttrString(self
, "__getinitargs__");
2928 if (getinitargs
!= NULL
) {
2929 args
= PyObject_CallObject(getinitargs
, tmp
);
2930 Py_DECREF(getinitargs
);
2942 getstate
= PyObject_GetAttrString(self
, "__getstate__");
2943 if (getstate
!= NULL
) {
2944 state
= PyObject_CallObject(getstate
, tmp
);
2945 Py_DECREF(getstate
);
2946 if (state
== NULL
) {
2956 dictptr
= _PyObject_GetDictPtr(self
);
2957 if (dictptr
&& *dictptr
&& PyDict_Size(*dictptr
))
2964 if (state
== Py_None
) {
2966 return Py_BuildValue("(ON)", Py_TYPE(self
), args
);
2969 return Py_BuildValue("(ONN)", Py_TYPE(self
), args
, state
);
2972 static PyMethodDef tzinfo_methods
[] = {
2974 {"tzname", (PyCFunction
)tzinfo_tzname
, METH_O
,
2975 PyDoc_STR("datetime -> string name of time zone.")},
2977 {"utcoffset", (PyCFunction
)tzinfo_utcoffset
, METH_O
,
2978 PyDoc_STR("datetime -> minutes east of UTC (negative for "
2981 {"dst", (PyCFunction
)tzinfo_dst
, METH_O
,
2982 PyDoc_STR("datetime -> DST offset in minutes east of UTC.")},
2984 {"fromutc", (PyCFunction
)tzinfo_fromutc
, METH_O
,
2985 PyDoc_STR("datetime in UTC -> datetime in local time.")},
2987 {"__reduce__", (PyCFunction
)tzinfo_reduce
, METH_NOARGS
,
2988 PyDoc_STR("-> (cls, state)")},
2993 static char tzinfo_doc
[] =
2994 PyDoc_STR("Abstract base class for time zone info objects.");
2996 statichere PyTypeObject PyDateTime_TZInfoType
= {
2997 PyObject_HEAD_INIT(NULL
)
2999 "datetime.tzinfo", /* tp_name */
3000 sizeof(PyDateTime_TZInfo
), /* tp_basicsize */
3001 0, /* tp_itemsize */
3008 0, /* tp_as_number */
3009 0, /* tp_as_sequence */
3010 0, /* tp_as_mapping */
3014 PyObject_GenericGetAttr
, /* tp_getattro */
3015 0, /* tp_setattro */
3016 0, /* tp_as_buffer */
3017 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
|
3018 Py_TPFLAGS_BASETYPE
, /* tp_flags */
3019 tzinfo_doc
, /* tp_doc */
3020 0, /* tp_traverse */
3022 0, /* tp_richcompare */
3023 0, /* tp_weaklistoffset */
3025 0, /* tp_iternext */
3026 tzinfo_methods
, /* tp_methods */
3031 0, /* tp_descr_get */
3032 0, /* tp_descr_set */
3033 0, /* tp_dictoffset */
3036 PyType_GenericNew
, /* tp_new */
3041 * PyDateTime_Time implementation.
3044 /* Accessor properties.
3048 time_hour(PyDateTime_Time
*self
, void *unused
)
3050 return PyInt_FromLong(TIME_GET_HOUR(self
));
3054 time_minute(PyDateTime_Time
*self
, void *unused
)
3056 return PyInt_FromLong(TIME_GET_MINUTE(self
));
3059 /* The name time_second conflicted with some platform header file. */
3061 py_time_second(PyDateTime_Time
*self
, void *unused
)
3063 return PyInt_FromLong(TIME_GET_SECOND(self
));
3067 time_microsecond(PyDateTime_Time
*self
, void *unused
)
3069 return PyInt_FromLong(TIME_GET_MICROSECOND(self
));
3073 time_tzinfo(PyDateTime_Time
*self
, void *unused
)
3075 PyObject
*result
= HASTZINFO(self
) ? self
->tzinfo
: Py_None
;
3080 static PyGetSetDef time_getset
[] = {
3081 {"hour", (getter
)time_hour
},
3082 {"minute", (getter
)time_minute
},
3083 {"second", (getter
)py_time_second
},
3084 {"microsecond", (getter
)time_microsecond
},
3085 {"tzinfo", (getter
)time_tzinfo
},
3093 static char *time_kws
[] = {"hour", "minute", "second", "microsecond",
3097 time_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kw
)
3099 PyObject
*self
= NULL
;
3105 PyObject
*tzinfo
= Py_None
;
3107 /* Check for invocation from pickle with __getstate__ state */
3108 if (PyTuple_GET_SIZE(args
) >= 1 &&
3109 PyTuple_GET_SIZE(args
) <= 2 &&
3110 PyString_Check(state
= PyTuple_GET_ITEM(args
, 0)) &&
3111 PyString_GET_SIZE(state
) == _PyDateTime_TIME_DATASIZE
&&
3112 ((unsigned char) (PyString_AS_STRING(state
)[0])) < 24)
3114 PyDateTime_Time
*me
;
3117 if (PyTuple_GET_SIZE(args
) == 2) {
3118 tzinfo
= PyTuple_GET_ITEM(args
, 1);
3119 if (check_tzinfo_subclass(tzinfo
) < 0) {
3120 PyErr_SetString(PyExc_TypeError
, "bad "
3121 "tzinfo state arg");
3125 aware
= (char)(tzinfo
!= Py_None
);
3126 me
= (PyDateTime_Time
*) (type
->tp_alloc(type
, aware
));
3128 char *pdata
= PyString_AS_STRING(state
);
3130 memcpy(me
->data
, pdata
, _PyDateTime_TIME_DATASIZE
);
3132 me
->hastzinfo
= aware
;
3135 me
->tzinfo
= tzinfo
;
3138 return (PyObject
*)me
;
3141 if (PyArg_ParseTupleAndKeywords(args
, kw
, "|iiiiO", time_kws
,
3142 &hour
, &minute
, &second
, &usecond
,
3144 if (check_time_args(hour
, minute
, second
, usecond
) < 0)
3146 if (check_tzinfo_subclass(tzinfo
) < 0)
3148 self
= new_time_ex(hour
, minute
, second
, usecond
, tzinfo
,
3159 time_dealloc(PyDateTime_Time
*self
)
3161 if (HASTZINFO(self
)) {
3162 Py_XDECREF(self
->tzinfo
);
3164 Py_TYPE(self
)->tp_free((PyObject
*)self
);
3168 * Indirect access to tzinfo methods.
3171 /* These are all METH_NOARGS, so don't need to check the arglist. */
3173 time_utcoffset(PyDateTime_Time
*self
, PyObject
*unused
) {
3174 return offset_as_timedelta(HASTZINFO(self
) ? self
->tzinfo
: Py_None
,
3175 "utcoffset", Py_None
);
3179 time_dst(PyDateTime_Time
*self
, PyObject
*unused
) {
3180 return offset_as_timedelta(HASTZINFO(self
) ? self
->tzinfo
: Py_None
,
3185 time_tzname(PyDateTime_Time
*self
, PyObject
*unused
) {
3186 return call_tzname(HASTZINFO(self
) ? self
->tzinfo
: Py_None
,
3191 * Various ways to turn a time into a string.
3195 time_repr(PyDateTime_Time
*self
)
3198 const char *type_name
= Py_TYPE(self
)->tp_name
;
3199 int h
= TIME_GET_HOUR(self
);
3200 int m
= TIME_GET_MINUTE(self
);
3201 int s
= TIME_GET_SECOND(self
);
3202 int us
= TIME_GET_MICROSECOND(self
);
3203 PyObject
*result
= NULL
;
3206 PyOS_snprintf(buffer
, sizeof(buffer
),
3207 "%s(%d, %d, %d, %d)", type_name
, h
, m
, s
, us
);
3209 PyOS_snprintf(buffer
, sizeof(buffer
),
3210 "%s(%d, %d, %d)", type_name
, h
, m
, s
);
3212 PyOS_snprintf(buffer
, sizeof(buffer
),
3213 "%s(%d, %d)", type_name
, h
, m
);
3214 result
= PyString_FromString(buffer
);
3215 if (result
!= NULL
&& HASTZINFO(self
))
3216 result
= append_keyword_tzinfo(result
, self
->tzinfo
);
3221 time_str(PyDateTime_Time
*self
)
3223 return PyObject_CallMethod((PyObject
*)self
, "isoformat", "()");
3227 time_isoformat(PyDateTime_Time
*self
, PyObject
*unused
)
3231 /* Reuse the time format code from the datetime type. */
3232 PyDateTime_DateTime datetime
;
3233 PyDateTime_DateTime
*pdatetime
= &datetime
;
3235 /* Copy over just the time bytes. */
3236 memcpy(pdatetime
->data
+ _PyDateTime_DATE_DATASIZE
,
3238 _PyDateTime_TIME_DATASIZE
);
3240 isoformat_time(pdatetime
, buf
, sizeof(buf
));
3241 result
= PyString_FromString(buf
);
3242 if (result
== NULL
|| ! HASTZINFO(self
) || self
->tzinfo
== Py_None
)
3245 /* We need to append the UTC offset. */
3246 if (format_utcoffset(buf
, sizeof(buf
), ":", self
->tzinfo
,
3251 PyString_ConcatAndDel(&result
, PyString_FromString(buf
));
3256 time_strftime(PyDateTime_Time
*self
, PyObject
*args
, PyObject
*kw
)
3261 static char *keywords
[] = {"format", NULL
};
3263 if (! PyArg_ParseTupleAndKeywords(args
, kw
, "O!:strftime", keywords
,
3264 &PyString_Type
, &format
))
3267 /* Python's strftime does insane things with the year part of the
3268 * timetuple. The year is forced to (the otherwise nonsensical)
3269 * 1900 to worm around that.
3271 tuple
= Py_BuildValue("iiiiiiiii",
3272 1900, 1, 1, /* year, month, day */
3273 TIME_GET_HOUR(self
),
3274 TIME_GET_MINUTE(self
),
3275 TIME_GET_SECOND(self
),
3276 0, 1, -1); /* weekday, daynum, dst */
3279 assert(PyTuple_Size(tuple
) == 9);
3280 result
= wrap_strftime((PyObject
*)self
, format
, tuple
, Py_None
);
3286 * Miscellaneous methods.
3289 /* This is more natural as a tp_compare, but doesn't work then: for whatever
3290 * reason, Python's try_3way_compare ignores tp_compare unless
3291 * PyInstance_Check returns true, but these aren't old-style classes.
3294 time_richcompare(PyDateTime_Time
*self
, PyObject
*other
, int op
)
3298 int offset1
, offset2
;
3300 if (! PyTime_Check(other
)) {
3301 if (op
== Py_EQ
|| op
== Py_NE
) {
3302 PyObject
*result
= op
== Py_EQ
? Py_False
: Py_True
;
3306 /* Stop this from falling back to address comparison. */
3307 return cmperror((PyObject
*)self
, other
);
3309 if (classify_two_utcoffsets((PyObject
*)self
, &offset1
, &n1
, Py_None
,
3310 other
, &offset2
, &n2
, Py_None
) < 0)
3312 assert(n1
!= OFFSET_UNKNOWN
&& n2
!= OFFSET_UNKNOWN
);
3313 /* If they're both naive, or both aware and have the same offsets,
3314 * we get off cheap. Note that if they're both naive, offset1 ==
3315 * offset2 == 0 at this point.
3317 if (n1
== n2
&& offset1
== offset2
) {
3318 diff
= memcmp(self
->data
, ((PyDateTime_Time
*)other
)->data
,
3319 _PyDateTime_TIME_DATASIZE
);
3320 return diff_to_bool(diff
, op
);
3323 if (n1
== OFFSET_AWARE
&& n2
== OFFSET_AWARE
) {
3324 assert(offset1
!= offset2
); /* else last "if" handled it */
3325 /* Convert everything except microseconds to seconds. These
3326 * can't overflow (no more than the # of seconds in 2 days).
3328 offset1
= TIME_GET_HOUR(self
) * 3600 +
3329 (TIME_GET_MINUTE(self
) - offset1
) * 60 +
3330 TIME_GET_SECOND(self
);
3331 offset2
= TIME_GET_HOUR(other
) * 3600 +
3332 (TIME_GET_MINUTE(other
) - offset2
) * 60 +
3333 TIME_GET_SECOND(other
);
3334 diff
= offset1
- offset2
;
3336 diff
= TIME_GET_MICROSECOND(self
) -
3337 TIME_GET_MICROSECOND(other
);
3338 return diff_to_bool(diff
, op
);
3342 PyErr_SetString(PyExc_TypeError
,
3343 "can't compare offset-naive and "
3344 "offset-aware times");
3349 time_hash(PyDateTime_Time
*self
)
3351 if (self
->hashcode
== -1) {
3356 n
= classify_utcoffset((PyObject
*)self
, Py_None
, &offset
);
3357 assert(n
!= OFFSET_UNKNOWN
);
3358 if (n
== OFFSET_ERROR
)
3361 /* Reduce this to a hash of another object. */
3363 temp
= PyString_FromStringAndSize((char *)self
->data
,
3364 _PyDateTime_TIME_DATASIZE
);
3369 assert(n
== OFFSET_AWARE
);
3370 assert(HASTZINFO(self
));
3371 hour
= divmod(TIME_GET_HOUR(self
) * 60 +
3372 TIME_GET_MINUTE(self
) - offset
,
3375 if (0 <= hour
&& hour
< 24)
3376 temp
= new_time(hour
, minute
,
3377 TIME_GET_SECOND(self
),
3378 TIME_GET_MICROSECOND(self
),
3381 temp
= Py_BuildValue("iiii",
3383 TIME_GET_SECOND(self
),
3384 TIME_GET_MICROSECOND(self
));
3387 self
->hashcode
= PyObject_Hash(temp
);
3391 return self
->hashcode
;
3395 time_replace(PyDateTime_Time
*self
, PyObject
*args
, PyObject
*kw
)
3399 int hh
= TIME_GET_HOUR(self
);
3400 int mm
= TIME_GET_MINUTE(self
);
3401 int ss
= TIME_GET_SECOND(self
);
3402 int us
= TIME_GET_MICROSECOND(self
);
3403 PyObject
*tzinfo
= HASTZINFO(self
) ? self
->tzinfo
: Py_None
;
3405 if (! PyArg_ParseTupleAndKeywords(args
, kw
, "|iiiiO:replace",
3407 &hh
, &mm
, &ss
, &us
, &tzinfo
))
3409 tuple
= Py_BuildValue("iiiiO", hh
, mm
, ss
, us
, tzinfo
);
3412 clone
= time_new(Py_TYPE(self
), tuple
, NULL
);
3418 time_nonzero(PyDateTime_Time
*self
)
3423 if (TIME_GET_SECOND(self
) || TIME_GET_MICROSECOND(self
)) {
3424 /* Since utcoffset is in whole minutes, nothing can
3425 * alter the conclusion that this is nonzero.
3430 if (HASTZINFO(self
) && self
->tzinfo
!= Py_None
) {
3431 offset
= call_utcoffset(self
->tzinfo
, Py_None
, &none
);
3432 if (offset
== -1 && PyErr_Occurred())
3435 return (TIME_GET_MINUTE(self
) - offset
+ TIME_GET_HOUR(self
)*60) != 0;
3438 /* Pickle support, a simple use of __reduce__. */
3440 /* Let basestate be the non-tzinfo data string.
3441 * If tzinfo is None, this returns (basestate,), else (basestate, tzinfo).
3442 * So it's a tuple in any (non-error) case.
3443 * __getstate__ isn't exposed.
3446 time_getstate(PyDateTime_Time
*self
)
3448 PyObject
*basestate
;
3449 PyObject
*result
= NULL
;
3451 basestate
= PyString_FromStringAndSize((char *)self
->data
,
3452 _PyDateTime_TIME_DATASIZE
);
3453 if (basestate
!= NULL
) {
3454 if (! HASTZINFO(self
) || self
->tzinfo
== Py_None
)
3455 result
= PyTuple_Pack(1, basestate
);
3457 result
= PyTuple_Pack(2, basestate
, self
->tzinfo
);
3458 Py_DECREF(basestate
);
3464 time_reduce(PyDateTime_Time
*self
, PyObject
*arg
)
3466 return Py_BuildValue("(ON)", Py_TYPE(self
), time_getstate(self
));
3469 static PyMethodDef time_methods
[] = {
3471 {"isoformat", (PyCFunction
)time_isoformat
, METH_NOARGS
,
3472 PyDoc_STR("Return string in ISO 8601 format, HH:MM:SS[.mmmmmm]"
3475 {"strftime", (PyCFunction
)time_strftime
, METH_VARARGS
| METH_KEYWORDS
,
3476 PyDoc_STR("format -> strftime() style string.")},
3478 {"__format__", (PyCFunction
)date_format
, METH_VARARGS
,
3479 PyDoc_STR("Formats self with strftime.")},
3481 {"utcoffset", (PyCFunction
)time_utcoffset
, METH_NOARGS
,
3482 PyDoc_STR("Return self.tzinfo.utcoffset(self).")},
3484 {"tzname", (PyCFunction
)time_tzname
, METH_NOARGS
,
3485 PyDoc_STR("Return self.tzinfo.tzname(self).")},
3487 {"dst", (PyCFunction
)time_dst
, METH_NOARGS
,
3488 PyDoc_STR("Return self.tzinfo.dst(self).")},
3490 {"replace", (PyCFunction
)time_replace
, METH_VARARGS
| METH_KEYWORDS
,
3491 PyDoc_STR("Return time with new specified fields.")},
3493 {"__reduce__", (PyCFunction
)time_reduce
, METH_NOARGS
,
3494 PyDoc_STR("__reduce__() -> (cls, state)")},
3499 static char time_doc
[] =
3500 PyDoc_STR("time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n\
3502 All arguments are optional. tzinfo may be None, or an instance of\n\
3503 a tzinfo subclass. The remaining arguments may be ints or longs.\n");
3505 static PyNumberMethods time_as_number
= {
3507 0, /* nb_subtract */
3508 0, /* nb_multiply */
3510 0, /* nb_remainder */
3513 0, /* nb_negative */
3514 0, /* nb_positive */
3515 0, /* nb_absolute */
3516 (inquiry
)time_nonzero
, /* nb_nonzero */
3519 statichere PyTypeObject PyDateTime_TimeType
= {
3520 PyObject_HEAD_INIT(NULL
)
3522 "datetime.time", /* tp_name */
3523 sizeof(PyDateTime_Time
), /* tp_basicsize */
3524 0, /* tp_itemsize */
3525 (destructor
)time_dealloc
, /* tp_dealloc */
3530 (reprfunc
)time_repr
, /* tp_repr */
3531 &time_as_number
, /* tp_as_number */
3532 0, /* tp_as_sequence */
3533 0, /* tp_as_mapping */
3534 (hashfunc
)time_hash
, /* tp_hash */
3536 (reprfunc
)time_str
, /* tp_str */
3537 PyObject_GenericGetAttr
, /* tp_getattro */
3538 0, /* tp_setattro */
3539 0, /* tp_as_buffer */
3540 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
|
3541 Py_TPFLAGS_BASETYPE
, /* tp_flags */
3542 time_doc
, /* tp_doc */
3543 0, /* tp_traverse */
3545 (richcmpfunc
)time_richcompare
, /* tp_richcompare */
3546 0, /* tp_weaklistoffset */
3548 0, /* tp_iternext */
3549 time_methods
, /* tp_methods */
3551 time_getset
, /* tp_getset */
3554 0, /* tp_descr_get */
3555 0, /* tp_descr_set */
3556 0, /* tp_dictoffset */
3558 time_alloc
, /* tp_alloc */
3559 time_new
, /* tp_new */
3564 * PyDateTime_DateTime implementation.
3567 /* Accessor properties. Properties for day, month, and year are inherited
3572 datetime_hour(PyDateTime_DateTime
*self
, void *unused
)
3574 return PyInt_FromLong(DATE_GET_HOUR(self
));
3578 datetime_minute(PyDateTime_DateTime
*self
, void *unused
)
3580 return PyInt_FromLong(DATE_GET_MINUTE(self
));
3584 datetime_second(PyDateTime_DateTime
*self
, void *unused
)
3586 return PyInt_FromLong(DATE_GET_SECOND(self
));
3590 datetime_microsecond(PyDateTime_DateTime
*self
, void *unused
)
3592 return PyInt_FromLong(DATE_GET_MICROSECOND(self
));
3596 datetime_tzinfo(PyDateTime_DateTime
*self
, void *unused
)
3598 PyObject
*result
= HASTZINFO(self
) ? self
->tzinfo
: Py_None
;
3603 static PyGetSetDef datetime_getset
[] = {
3604 {"hour", (getter
)datetime_hour
},
3605 {"minute", (getter
)datetime_minute
},
3606 {"second", (getter
)datetime_second
},
3607 {"microsecond", (getter
)datetime_microsecond
},
3608 {"tzinfo", (getter
)datetime_tzinfo
},
3616 static char *datetime_kws
[] = {
3617 "year", "month", "day", "hour", "minute", "second",
3618 "microsecond", "tzinfo", NULL
3622 datetime_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kw
)
3624 PyObject
*self
= NULL
;
3633 PyObject
*tzinfo
= Py_None
;
3635 /* Check for invocation from pickle with __getstate__ state */
3636 if (PyTuple_GET_SIZE(args
) >= 1 &&
3637 PyTuple_GET_SIZE(args
) <= 2 &&
3638 PyString_Check(state
= PyTuple_GET_ITEM(args
, 0)) &&
3639 PyString_GET_SIZE(state
) == _PyDateTime_DATETIME_DATASIZE
&&
3640 MONTH_IS_SANE(PyString_AS_STRING(state
)[2]))
3642 PyDateTime_DateTime
*me
;
3645 if (PyTuple_GET_SIZE(args
) == 2) {
3646 tzinfo
= PyTuple_GET_ITEM(args
, 1);
3647 if (check_tzinfo_subclass(tzinfo
) < 0) {
3648 PyErr_SetString(PyExc_TypeError
, "bad "
3649 "tzinfo state arg");
3653 aware
= (char)(tzinfo
!= Py_None
);
3654 me
= (PyDateTime_DateTime
*) (type
->tp_alloc(type
, aware
));
3656 char *pdata
= PyString_AS_STRING(state
);
3658 memcpy(me
->data
, pdata
, _PyDateTime_DATETIME_DATASIZE
);
3660 me
->hastzinfo
= aware
;
3663 me
->tzinfo
= tzinfo
;
3666 return (PyObject
*)me
;
3669 if (PyArg_ParseTupleAndKeywords(args
, kw
, "iii|iiiiO", datetime_kws
,
3670 &year
, &month
, &day
, &hour
, &minute
,
3671 &second
, &usecond
, &tzinfo
)) {
3672 if (check_date_args(year
, month
, day
) < 0)
3674 if (check_time_args(hour
, minute
, second
, usecond
) < 0)
3676 if (check_tzinfo_subclass(tzinfo
) < 0)
3678 self
= new_datetime_ex(year
, month
, day
,
3679 hour
, minute
, second
, usecond
,
3685 /* TM_FUNC is the shared type of localtime() and gmtime(). */
3686 typedef struct tm
*(*TM_FUNC
)(const time_t *timer
);
3689 * Build datetime from a time_t and a distinct count of microseconds.
3690 * Pass localtime or gmtime for f, to control the interpretation of timet.
3693 datetime_from_timet_and_us(PyObject
*cls
, TM_FUNC f
, time_t timet
, int us
,
3697 PyObject
*result
= NULL
;
3701 /* The platform localtime/gmtime may insert leap seconds,
3702 * indicated by tm->tm_sec > 59. We don't care about them,
3703 * except to the extent that passing them on to the datetime
3704 * constructor would raise ValueError for a reason that
3705 * made no sense to the user.
3707 if (tm
->tm_sec
> 59)
3709 result
= PyObject_CallFunction(cls
, "iiiiiiiO",
3720 PyErr_SetString(PyExc_ValueError
,
3721 "timestamp out of range for "
3722 "platform localtime()/gmtime() function");
3727 * Build datetime from a Python timestamp. Pass localtime or gmtime for f,
3728 * to control the interpretation of the timestamp. Since a double doesn't
3729 * have enough bits to cover a datetime's full range of precision, it's
3730 * better to call datetime_from_timet_and_us provided you have a way
3731 * to get that much precision (e.g., C time() isn't good enough).
3734 datetime_from_timestamp(PyObject
*cls
, TM_FUNC f
, double timestamp
,
3741 timet
= _PyTime_DoubleToTimet(timestamp
);
3742 if (timet
== (time_t)-1 && PyErr_Occurred())
3744 fraction
= timestamp
- (double)timet
;
3745 us
= (int)round_to_long(fraction
* 1e6
);
3747 /* Truncation towards zero is not what we wanted
3748 for negative numbers (Python's mod semantics) */
3752 /* If timestamp is less than one microsecond smaller than a
3753 * full second, round up. Otherwise, ValueErrors are raised
3754 * for some floats. */
3755 if (us
== 1000000) {
3759 return datetime_from_timet_and_us(cls
, f
, timet
, us
, tzinfo
);
3763 * Build most accurate possible datetime for current time. Pass localtime or
3764 * gmtime for f as appropriate.
3767 datetime_best_possible(PyObject
*cls
, TM_FUNC f
, PyObject
*tzinfo
)
3769 #ifdef HAVE_GETTIMEOFDAY
3772 #ifdef GETTIMEOFDAY_NO_TZ
3775 gettimeofday(&t
, (struct timezone
*)NULL
);
3777 return datetime_from_timet_and_us(cls
, f
, t
.tv_sec
, (int)t
.tv_usec
,
3780 #else /* ! HAVE_GETTIMEOFDAY */
3781 /* No flavor of gettimeofday exists on this platform. Python's
3782 * time.time() does a lot of other platform tricks to get the
3783 * best time it can on the platform, and we're not going to do
3784 * better than that (if we could, the better code would belong
3785 * in time.time()!) We're limited by the precision of a double,
3794 dtime
= PyFloat_AsDouble(time
);
3796 if (dtime
== -1.0 && PyErr_Occurred())
3798 return datetime_from_timestamp(cls
, f
, dtime
, tzinfo
);
3799 #endif /* ! HAVE_GETTIMEOFDAY */
3802 /* Return best possible local time -- this isn't constrained by the
3803 * precision of a timestamp.
3806 datetime_now(PyObject
*cls
, PyObject
*args
, PyObject
*kw
)
3809 PyObject
*tzinfo
= Py_None
;
3810 static char *keywords
[] = {"tz", NULL
};
3812 if (! PyArg_ParseTupleAndKeywords(args
, kw
, "|O:now", keywords
,
3815 if (check_tzinfo_subclass(tzinfo
) < 0)
3818 self
= datetime_best_possible(cls
,
3819 tzinfo
== Py_None
? localtime
: gmtime
,
3821 if (self
!= NULL
&& tzinfo
!= Py_None
) {
3822 /* Convert UTC to tzinfo's zone. */
3823 PyObject
*temp
= self
;
3824 self
= PyObject_CallMethod(tzinfo
, "fromutc", "O", self
);
3830 /* Return best possible UTC time -- this isn't constrained by the
3831 * precision of a timestamp.
3834 datetime_utcnow(PyObject
*cls
, PyObject
*dummy
)
3836 return datetime_best_possible(cls
, gmtime
, Py_None
);
3839 /* Return new local datetime from timestamp (Python timestamp -- a double). */
3841 datetime_fromtimestamp(PyObject
*cls
, PyObject
*args
, PyObject
*kw
)
3845 PyObject
*tzinfo
= Py_None
;
3846 static char *keywords
[] = {"timestamp", "tz", NULL
};
3848 if (! PyArg_ParseTupleAndKeywords(args
, kw
, "d|O:fromtimestamp",
3849 keywords
, ×tamp
, &tzinfo
))
3851 if (check_tzinfo_subclass(tzinfo
) < 0)
3854 self
= datetime_from_timestamp(cls
,
3855 tzinfo
== Py_None
? localtime
: gmtime
,
3858 if (self
!= NULL
&& tzinfo
!= Py_None
) {
3859 /* Convert UTC to tzinfo's zone. */
3860 PyObject
*temp
= self
;
3861 self
= PyObject_CallMethod(tzinfo
, "fromutc", "O", self
);
3867 /* Return new UTC datetime from timestamp (Python timestamp -- a double). */
3869 datetime_utcfromtimestamp(PyObject
*cls
, PyObject
*args
)
3872 PyObject
*result
= NULL
;
3874 if (PyArg_ParseTuple(args
, "d:utcfromtimestamp", ×tamp
))
3875 result
= datetime_from_timestamp(cls
, gmtime
, timestamp
,
3880 /* Return new datetime from time.strptime(). */
3882 datetime_strptime(PyObject
*cls
, PyObject
*args
)
3884 static PyObject
*module
= NULL
;
3885 PyObject
*result
= NULL
, *obj
, *st
= NULL
, *frac
= NULL
;
3886 const char *string
, *format
;
3888 if (!PyArg_ParseTuple(args
, "ss:strptime", &string
, &format
))
3891 if (module
== NULL
&&
3892 (module
= PyImport_ImportModuleNoBlock("_strptime")) == NULL
)
3895 /* _strptime._strptime returns a two-element tuple. The first
3896 element is a time.struct_time object. The second is the
3897 microseconds (which are not defined for time.struct_time). */
3898 obj
= PyObject_CallMethod(module
, "_strptime", "ss", string
, format
);
3900 int i
, good_timetuple
= 1;
3902 if (PySequence_Check(obj
) && PySequence_Size(obj
) == 2) {
3903 st
= PySequence_GetItem(obj
, 0);
3904 frac
= PySequence_GetItem(obj
, 1);
3905 if (st
== NULL
|| frac
== NULL
)
3907 /* copy y/m/d/h/m/s values out of the
3909 if (good_timetuple
&&
3910 PySequence_Check(st
) &&
3911 PySequence_Size(st
) >= 6) {
3912 for (i
=0; i
< 6; i
++) {
3913 PyObject
*p
= PySequence_GetItem(st
, i
);
3919 ia
[i
] = PyInt_AsLong(p
);
3927 /* follow that up with a little dose of microseconds */
3928 if (PyInt_Check(frac
))
3929 ia
[6] = PyInt_AsLong(frac
);
3936 result
= PyObject_CallFunction(cls
, "iiiiiii",
3937 ia
[0], ia
[1], ia
[2],
3938 ia
[3], ia
[4], ia
[5],
3941 PyErr_SetString(PyExc_ValueError
,
3942 "unexpected value from _strptime._strptime");
3950 /* Return new datetime from date/datetime and time arguments. */
3952 datetime_combine(PyObject
*cls
, PyObject
*args
, PyObject
*kw
)
3954 static char *keywords
[] = {"date", "time", NULL
};
3957 PyObject
*result
= NULL
;
3959 if (PyArg_ParseTupleAndKeywords(args
, kw
, "O!O!:combine", keywords
,
3960 &PyDateTime_DateType
, &date
,
3961 &PyDateTime_TimeType
, &time
)) {
3962 PyObject
*tzinfo
= Py_None
;
3964 if (HASTZINFO(time
))
3965 tzinfo
= ((PyDateTime_Time
*)time
)->tzinfo
;
3966 result
= PyObject_CallFunction(cls
, "iiiiiiiO",
3970 TIME_GET_HOUR(time
),
3971 TIME_GET_MINUTE(time
),
3972 TIME_GET_SECOND(time
),
3973 TIME_GET_MICROSECOND(time
),
3984 datetime_dealloc(PyDateTime_DateTime
*self
)
3986 if (HASTZINFO(self
)) {
3987 Py_XDECREF(self
->tzinfo
);
3989 Py_TYPE(self
)->tp_free((PyObject
*)self
);
3993 * Indirect access to tzinfo methods.
3996 /* These are all METH_NOARGS, so don't need to check the arglist. */
3998 datetime_utcoffset(PyDateTime_DateTime
*self
, PyObject
*unused
) {
3999 return offset_as_timedelta(HASTZINFO(self
) ? self
->tzinfo
: Py_None
,
4000 "utcoffset", (PyObject
*)self
);
4004 datetime_dst(PyDateTime_DateTime
*self
, PyObject
*unused
) {
4005 return offset_as_timedelta(HASTZINFO(self
) ? self
->tzinfo
: Py_None
,
4006 "dst", (PyObject
*)self
);
4010 datetime_tzname(PyDateTime_DateTime
*self
, PyObject
*unused
) {
4011 return call_tzname(HASTZINFO(self
) ? self
->tzinfo
: Py_None
,
4016 * datetime arithmetic.
4019 /* factor must be 1 (to add) or -1 (to subtract). The result inherits
4020 * the tzinfo state of date.
4023 add_datetime_timedelta(PyDateTime_DateTime
*date
, PyDateTime_Delta
*delta
,
4026 /* Note that the C-level additions can't overflow, because of
4027 * invariant bounds on the member values.
4029 int year
= GET_YEAR(date
);
4030 int month
= GET_MONTH(date
);
4031 int day
= GET_DAY(date
) + GET_TD_DAYS(delta
) * factor
;
4032 int hour
= DATE_GET_HOUR(date
);
4033 int minute
= DATE_GET_MINUTE(date
);
4034 int second
= DATE_GET_SECOND(date
) + GET_TD_SECONDS(delta
) * factor
;
4035 int microsecond
= DATE_GET_MICROSECOND(date
) +
4036 GET_TD_MICROSECONDS(delta
) * factor
;
4038 assert(factor
== 1 || factor
== -1);
4039 if (normalize_datetime(&year
, &month
, &day
,
4040 &hour
, &minute
, &second
, µsecond
) < 0)
4043 return new_datetime(year
, month
, day
,
4044 hour
, minute
, second
, microsecond
,
4045 HASTZINFO(date
) ? date
->tzinfo
: Py_None
);
4049 datetime_add(PyObject
*left
, PyObject
*right
)
4051 if (PyDateTime_Check(left
)) {
4052 /* datetime + ??? */
4053 if (PyDelta_Check(right
))
4054 /* datetime + delta */
4055 return add_datetime_timedelta(
4056 (PyDateTime_DateTime
*)left
,
4057 (PyDateTime_Delta
*)right
,
4060 else if (PyDelta_Check(left
)) {
4061 /* delta + datetime */
4062 return add_datetime_timedelta((PyDateTime_DateTime
*) right
,
4063 (PyDateTime_Delta
*) left
,
4066 Py_INCREF(Py_NotImplemented
);
4067 return Py_NotImplemented
;
4071 datetime_subtract(PyObject
*left
, PyObject
*right
)
4073 PyObject
*result
= Py_NotImplemented
;
4075 if (PyDateTime_Check(left
)) {
4076 /* datetime - ??? */
4077 if (PyDateTime_Check(right
)) {
4078 /* datetime - datetime */
4080 int offset1
, offset2
;
4081 int delta_d
, delta_s
, delta_us
;
4083 if (classify_two_utcoffsets(left
, &offset1
, &n1
, left
,
4084 right
, &offset2
, &n2
,
4087 assert(n1
!= OFFSET_UNKNOWN
&& n2
!= OFFSET_UNKNOWN
);
4089 PyErr_SetString(PyExc_TypeError
,
4090 "can't subtract offset-naive and "
4091 "offset-aware datetimes");
4094 delta_d
= ymd_to_ord(GET_YEAR(left
),
4097 ymd_to_ord(GET_YEAR(right
),
4100 /* These can't overflow, since the values are
4101 * normalized. At most this gives the number of
4102 * seconds in one day.
4104 delta_s
= (DATE_GET_HOUR(left
) -
4105 DATE_GET_HOUR(right
)) * 3600 +
4106 (DATE_GET_MINUTE(left
) -
4107 DATE_GET_MINUTE(right
)) * 60 +
4108 (DATE_GET_SECOND(left
) -
4109 DATE_GET_SECOND(right
));
4110 delta_us
= DATE_GET_MICROSECOND(left
) -
4111 DATE_GET_MICROSECOND(right
);
4112 /* (left - offset1) - (right - offset2) =
4113 * (left - right) + (offset2 - offset1)
4115 delta_s
+= (offset2
- offset1
) * 60;
4116 result
= new_delta(delta_d
, delta_s
, delta_us
, 1);
4118 else if (PyDelta_Check(right
)) {
4119 /* datetime - delta */
4120 result
= add_datetime_timedelta(
4121 (PyDateTime_DateTime
*)left
,
4122 (PyDateTime_Delta
*)right
,
4127 if (result
== Py_NotImplemented
)
4132 /* Various ways to turn a datetime into a string. */
4135 datetime_repr(PyDateTime_DateTime
*self
)
4138 const char *type_name
= Py_TYPE(self
)->tp_name
;
4141 if (DATE_GET_MICROSECOND(self
)) {
4142 PyOS_snprintf(buffer
, sizeof(buffer
),
4143 "%s(%d, %d, %d, %d, %d, %d, %d)",
4145 GET_YEAR(self
), GET_MONTH(self
), GET_DAY(self
),
4146 DATE_GET_HOUR(self
), DATE_GET_MINUTE(self
),
4147 DATE_GET_SECOND(self
),
4148 DATE_GET_MICROSECOND(self
));
4150 else if (DATE_GET_SECOND(self
)) {
4151 PyOS_snprintf(buffer
, sizeof(buffer
),
4152 "%s(%d, %d, %d, %d, %d, %d)",
4154 GET_YEAR(self
), GET_MONTH(self
), GET_DAY(self
),
4155 DATE_GET_HOUR(self
), DATE_GET_MINUTE(self
),
4156 DATE_GET_SECOND(self
));
4159 PyOS_snprintf(buffer
, sizeof(buffer
),
4160 "%s(%d, %d, %d, %d, %d)",
4162 GET_YEAR(self
), GET_MONTH(self
), GET_DAY(self
),
4163 DATE_GET_HOUR(self
), DATE_GET_MINUTE(self
));
4165 baserepr
= PyString_FromString(buffer
);
4166 if (baserepr
== NULL
|| ! HASTZINFO(self
))
4168 return append_keyword_tzinfo(baserepr
, self
->tzinfo
);
4172 datetime_str(PyDateTime_DateTime
*self
)
4174 return PyObject_CallMethod((PyObject
*)self
, "isoformat", "(s)", " ");
4178 datetime_isoformat(PyDateTime_DateTime
*self
, PyObject
*args
, PyObject
*kw
)
4181 static char *keywords
[] = {"sep", NULL
};
4186 if (!PyArg_ParseTupleAndKeywords(args
, kw
, "|c:isoformat", keywords
,
4189 cp
= isoformat_date((PyDateTime_Date
*)self
, buffer
, sizeof(buffer
));
4192 isoformat_time(self
, cp
, sizeof(buffer
) - (cp
- buffer
));
4193 result
= PyString_FromString(buffer
);
4194 if (result
== NULL
|| ! HASTZINFO(self
))
4197 /* We need to append the UTC offset. */
4198 if (format_utcoffset(buffer
, sizeof(buffer
), ":", self
->tzinfo
,
4199 (PyObject
*)self
) < 0) {
4203 PyString_ConcatAndDel(&result
, PyString_FromString(buffer
));
4208 datetime_ctime(PyDateTime_DateTime
*self
)
4210 return format_ctime((PyDateTime_Date
*)self
,
4211 DATE_GET_HOUR(self
),
4212 DATE_GET_MINUTE(self
),
4213 DATE_GET_SECOND(self
));
4216 /* Miscellaneous methods. */
4218 /* This is more natural as a tp_compare, but doesn't work then: for whatever
4219 * reason, Python's try_3way_compare ignores tp_compare unless
4220 * PyInstance_Check returns true, but these aren't old-style classes.
4223 datetime_richcompare(PyDateTime_DateTime
*self
, PyObject
*other
, int op
)
4227 int offset1
, offset2
;
4229 if (! PyDateTime_Check(other
)) {
4230 /* If other has a "timetuple" attr, that's an advertised
4231 * hook for other classes to ask to get comparison control.
4232 * However, date instances have a timetuple attr, and we
4233 * don't want to allow that comparison. Because datetime
4234 * is a subclass of date, when mixing date and datetime
4235 * in a comparison, Python gives datetime the first shot
4236 * (it's the more specific subtype). So we can stop that
4237 * combination here reliably.
4239 if (PyObject_HasAttrString(other
, "timetuple") &&
4240 ! PyDate_Check(other
)) {
4241 /* A hook for other kinds of datetime objects. */
4242 Py_INCREF(Py_NotImplemented
);
4243 return Py_NotImplemented
;
4245 if (op
== Py_EQ
|| op
== Py_NE
) {
4246 PyObject
*result
= op
== Py_EQ
? Py_False
: Py_True
;
4250 /* Stop this from falling back to address comparison. */
4251 return cmperror((PyObject
*)self
, other
);
4254 if (classify_two_utcoffsets((PyObject
*)self
, &offset1
, &n1
,
4256 other
, &offset2
, &n2
,
4259 assert(n1
!= OFFSET_UNKNOWN
&& n2
!= OFFSET_UNKNOWN
);
4260 /* If they're both naive, or both aware and have the same offsets,
4261 * we get off cheap. Note that if they're both naive, offset1 ==
4262 * offset2 == 0 at this point.
4264 if (n1
== n2
&& offset1
== offset2
) {
4265 diff
= memcmp(self
->data
, ((PyDateTime_DateTime
*)other
)->data
,
4266 _PyDateTime_DATETIME_DATASIZE
);
4267 return diff_to_bool(diff
, op
);
4270 if (n1
== OFFSET_AWARE
&& n2
== OFFSET_AWARE
) {
4271 PyDateTime_Delta
*delta
;
4273 assert(offset1
!= offset2
); /* else last "if" handled it */
4274 delta
= (PyDateTime_Delta
*)datetime_subtract((PyObject
*)self
,
4278 diff
= GET_TD_DAYS(delta
);
4280 diff
= GET_TD_SECONDS(delta
) |
4281 GET_TD_MICROSECONDS(delta
);
4283 return diff_to_bool(diff
, op
);
4287 PyErr_SetString(PyExc_TypeError
,
4288 "can't compare offset-naive and "
4289 "offset-aware datetimes");
4294 datetime_hash(PyDateTime_DateTime
*self
)
4296 if (self
->hashcode
== -1) {
4301 n
= classify_utcoffset((PyObject
*)self
, (PyObject
*)self
,
4303 assert(n
!= OFFSET_UNKNOWN
);
4304 if (n
== OFFSET_ERROR
)
4307 /* Reduce this to a hash of another object. */
4308 if (n
== OFFSET_NAIVE
)
4309 temp
= PyString_FromStringAndSize(
4311 _PyDateTime_DATETIME_DATASIZE
);
4316 assert(n
== OFFSET_AWARE
);
4317 assert(HASTZINFO(self
));
4318 days
= ymd_to_ord(GET_YEAR(self
),
4321 seconds
= DATE_GET_HOUR(self
) * 3600 +
4322 (DATE_GET_MINUTE(self
) - offset
) * 60 +
4323 DATE_GET_SECOND(self
);
4324 temp
= new_delta(days
,
4326 DATE_GET_MICROSECOND(self
),
4330 self
->hashcode
= PyObject_Hash(temp
);
4334 return self
->hashcode
;
4338 datetime_replace(PyDateTime_DateTime
*self
, PyObject
*args
, PyObject
*kw
)
4342 int y
= GET_YEAR(self
);
4343 int m
= GET_MONTH(self
);
4344 int d
= GET_DAY(self
);
4345 int hh
= DATE_GET_HOUR(self
);
4346 int mm
= DATE_GET_MINUTE(self
);
4347 int ss
= DATE_GET_SECOND(self
);
4348 int us
= DATE_GET_MICROSECOND(self
);
4349 PyObject
*tzinfo
= HASTZINFO(self
) ? self
->tzinfo
: Py_None
;
4351 if (! PyArg_ParseTupleAndKeywords(args
, kw
, "|iiiiiiiO:replace",
4353 &y
, &m
, &d
, &hh
, &mm
, &ss
, &us
,
4356 tuple
= Py_BuildValue("iiiiiiiO", y
, m
, d
, hh
, mm
, ss
, us
, tzinfo
);
4359 clone
= datetime_new(Py_TYPE(self
), tuple
, NULL
);
4365 datetime_astimezone(PyDateTime_DateTime
*self
, PyObject
*args
, PyObject
*kw
)
4367 int y
, m
, d
, hh
, mm
, ss
, us
;
4372 static char *keywords
[] = {"tz", NULL
};
4374 if (! PyArg_ParseTupleAndKeywords(args
, kw
, "O!:astimezone", keywords
,
4375 &PyDateTime_TZInfoType
, &tzinfo
))
4378 if (!HASTZINFO(self
) || self
->tzinfo
== Py_None
)
4381 /* Conversion to self's own time zone is a NOP. */
4382 if (self
->tzinfo
== tzinfo
) {
4384 return (PyObject
*)self
;
4387 /* Convert self to UTC. */
4388 offset
= call_utcoffset(self
->tzinfo
, (PyObject
*)self
, &none
);
4389 if (offset
== -1 && PyErr_Occurred())
4395 m
= GET_MONTH(self
);
4397 hh
= DATE_GET_HOUR(self
);
4398 mm
= DATE_GET_MINUTE(self
);
4399 ss
= DATE_GET_SECOND(self
);
4400 us
= DATE_GET_MICROSECOND(self
);
4403 if ((mm
< 0 || mm
>= 60) &&
4404 normalize_datetime(&y
, &m
, &d
, &hh
, &mm
, &ss
, &us
) < 0)
4407 /* Attach new tzinfo and let fromutc() do the rest. */
4408 result
= new_datetime(y
, m
, d
, hh
, mm
, ss
, us
, tzinfo
);
4409 if (result
!= NULL
) {
4410 PyObject
*temp
= result
;
4412 result
= PyObject_CallMethod(tzinfo
, "fromutc", "O", temp
);
4418 PyErr_SetString(PyExc_ValueError
, "astimezone() cannot be applied to "
4419 "a naive datetime");
4424 datetime_timetuple(PyDateTime_DateTime
*self
)
4428 if (HASTZINFO(self
) && self
->tzinfo
!= Py_None
) {
4431 dstflag
= call_dst(self
->tzinfo
, (PyObject
*)self
, &none
);
4432 if (dstflag
== -1 && PyErr_Occurred())
4437 else if (dstflag
!= 0)
4441 return build_struct_time(GET_YEAR(self
),
4444 DATE_GET_HOUR(self
),
4445 DATE_GET_MINUTE(self
),
4446 DATE_GET_SECOND(self
),
4451 datetime_getdate(PyDateTime_DateTime
*self
)
4453 return new_date(GET_YEAR(self
),
4459 datetime_gettime(PyDateTime_DateTime
*self
)
4461 return new_time(DATE_GET_HOUR(self
),
4462 DATE_GET_MINUTE(self
),
4463 DATE_GET_SECOND(self
),
4464 DATE_GET_MICROSECOND(self
),
4469 datetime_gettimetz(PyDateTime_DateTime
*self
)
4471 return new_time(DATE_GET_HOUR(self
),
4472 DATE_GET_MINUTE(self
),
4473 DATE_GET_SECOND(self
),
4474 DATE_GET_MICROSECOND(self
),
4475 HASTZINFO(self
) ? self
->tzinfo
: Py_None
);
4479 datetime_utctimetuple(PyDateTime_DateTime
*self
)
4481 int y
= GET_YEAR(self
);
4482 int m
= GET_MONTH(self
);
4483 int d
= GET_DAY(self
);
4484 int hh
= DATE_GET_HOUR(self
);
4485 int mm
= DATE_GET_MINUTE(self
);
4486 int ss
= DATE_GET_SECOND(self
);
4487 int us
= 0; /* microseconds are ignored in a timetuple */
4490 if (HASTZINFO(self
) && self
->tzinfo
!= Py_None
) {
4493 offset
= call_utcoffset(self
->tzinfo
, (PyObject
*)self
, &none
);
4494 if (offset
== -1 && PyErr_Occurred())
4497 /* Even if offset is 0, don't call timetuple() -- tm_isdst should be
4498 * 0 in a UTC timetuple regardless of what dst() says.
4501 /* Subtract offset minutes & normalize. */
4505 stat
= normalize_datetime(&y
, &m
, &d
, &hh
, &mm
, &ss
, &us
);
4507 /* At the edges, it's possible we overflowed
4508 * beyond MINYEAR or MAXYEAR.
4510 if (PyErr_ExceptionMatches(PyExc_OverflowError
))
4516 return build_struct_time(y
, m
, d
, hh
, mm
, ss
, 0);
4519 /* Pickle support, a simple use of __reduce__. */
4521 /* Let basestate be the non-tzinfo data string.
4522 * If tzinfo is None, this returns (basestate,), else (basestate, tzinfo).
4523 * So it's a tuple in any (non-error) case.
4524 * __getstate__ isn't exposed.
4527 datetime_getstate(PyDateTime_DateTime
*self
)
4529 PyObject
*basestate
;
4530 PyObject
*result
= NULL
;
4532 basestate
= PyString_FromStringAndSize((char *)self
->data
,
4533 _PyDateTime_DATETIME_DATASIZE
);
4534 if (basestate
!= NULL
) {
4535 if (! HASTZINFO(self
) || self
->tzinfo
== Py_None
)
4536 result
= PyTuple_Pack(1, basestate
);
4538 result
= PyTuple_Pack(2, basestate
, self
->tzinfo
);
4539 Py_DECREF(basestate
);
4545 datetime_reduce(PyDateTime_DateTime
*self
, PyObject
*arg
)
4547 return Py_BuildValue("(ON)", Py_TYPE(self
), datetime_getstate(self
));
4550 static PyMethodDef datetime_methods
[] = {
4552 /* Class methods: */
4554 {"now", (PyCFunction
)datetime_now
,
4555 METH_VARARGS
| METH_KEYWORDS
| METH_CLASS
,
4556 PyDoc_STR("[tz] -> new datetime with tz's local day and time.")},
4558 {"utcnow", (PyCFunction
)datetime_utcnow
,
4559 METH_NOARGS
| METH_CLASS
,
4560 PyDoc_STR("Return a new datetime representing UTC day and time.")},
4562 {"fromtimestamp", (PyCFunction
)datetime_fromtimestamp
,
4563 METH_VARARGS
| METH_KEYWORDS
| METH_CLASS
,
4564 PyDoc_STR("timestamp[, tz] -> tz's local time from POSIX timestamp.")},
4566 {"utcfromtimestamp", (PyCFunction
)datetime_utcfromtimestamp
,
4567 METH_VARARGS
| METH_CLASS
,
4568 PyDoc_STR("timestamp -> UTC datetime from a POSIX timestamp "
4569 "(like time.time()).")},
4571 {"strptime", (PyCFunction
)datetime_strptime
,
4572 METH_VARARGS
| METH_CLASS
,
4573 PyDoc_STR("string, format -> new datetime parsed from a string "
4574 "(like time.strptime()).")},
4576 {"combine", (PyCFunction
)datetime_combine
,
4577 METH_VARARGS
| METH_KEYWORDS
| METH_CLASS
,
4578 PyDoc_STR("date, time -> datetime with same date and time fields")},
4580 /* Instance methods: */
4582 {"date", (PyCFunction
)datetime_getdate
, METH_NOARGS
,
4583 PyDoc_STR("Return date object with same year, month and day.")},
4585 {"time", (PyCFunction
)datetime_gettime
, METH_NOARGS
,
4586 PyDoc_STR("Return time object with same time but with tzinfo=None.")},
4588 {"timetz", (PyCFunction
)datetime_gettimetz
, METH_NOARGS
,
4589 PyDoc_STR("Return time object with same time and tzinfo.")},
4591 {"ctime", (PyCFunction
)datetime_ctime
, METH_NOARGS
,
4592 PyDoc_STR("Return ctime() style string.")},
4594 {"timetuple", (PyCFunction
)datetime_timetuple
, METH_NOARGS
,
4595 PyDoc_STR("Return time tuple, compatible with time.localtime().")},
4597 {"utctimetuple", (PyCFunction
)datetime_utctimetuple
, METH_NOARGS
,
4598 PyDoc_STR("Return UTC time tuple, compatible with time.localtime().")},
4600 {"isoformat", (PyCFunction
)datetime_isoformat
, METH_VARARGS
| METH_KEYWORDS
,
4601 PyDoc_STR("[sep] -> string in ISO 8601 format, "
4602 "YYYY-MM-DDTHH:MM:SS[.mmmmmm][+HH:MM].\n\n"
4603 "sep is used to separate the year from the time, and "
4604 "defaults to 'T'.")},
4606 {"utcoffset", (PyCFunction
)datetime_utcoffset
, METH_NOARGS
,
4607 PyDoc_STR("Return self.tzinfo.utcoffset(self).")},
4609 {"tzname", (PyCFunction
)datetime_tzname
, METH_NOARGS
,
4610 PyDoc_STR("Return self.tzinfo.tzname(self).")},
4612 {"dst", (PyCFunction
)datetime_dst
, METH_NOARGS
,
4613 PyDoc_STR("Return self.tzinfo.dst(self).")},
4615 {"replace", (PyCFunction
)datetime_replace
, METH_VARARGS
| METH_KEYWORDS
,
4616 PyDoc_STR("Return datetime with new specified fields.")},
4618 {"astimezone", (PyCFunction
)datetime_astimezone
, METH_VARARGS
| METH_KEYWORDS
,
4619 PyDoc_STR("tz -> convert to local time in new timezone tz\n")},
4621 {"__reduce__", (PyCFunction
)datetime_reduce
, METH_NOARGS
,
4622 PyDoc_STR("__reduce__() -> (cls, state)")},
4627 static char datetime_doc
[] =
4628 PyDoc_STR("datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n\
4630 The year, month and day arguments are required. tzinfo may be None, or an\n\
4631 instance of a tzinfo subclass. The remaining arguments may be ints or longs.\n");
4633 static PyNumberMethods datetime_as_number
= {
4634 datetime_add
, /* nb_add */
4635 datetime_subtract
, /* nb_subtract */
4636 0, /* nb_multiply */
4638 0, /* nb_remainder */
4641 0, /* nb_negative */
4642 0, /* nb_positive */
4643 0, /* nb_absolute */
4647 statichere PyTypeObject PyDateTime_DateTimeType
= {
4648 PyObject_HEAD_INIT(NULL
)
4650 "datetime.datetime", /* tp_name */
4651 sizeof(PyDateTime_DateTime
), /* tp_basicsize */
4652 0, /* tp_itemsize */
4653 (destructor
)datetime_dealloc
, /* tp_dealloc */
4658 (reprfunc
)datetime_repr
, /* tp_repr */
4659 &datetime_as_number
, /* tp_as_number */
4660 0, /* tp_as_sequence */
4661 0, /* tp_as_mapping */
4662 (hashfunc
)datetime_hash
, /* tp_hash */
4664 (reprfunc
)datetime_str
, /* tp_str */
4665 PyObject_GenericGetAttr
, /* tp_getattro */
4666 0, /* tp_setattro */
4667 0, /* tp_as_buffer */
4668 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
|
4669 Py_TPFLAGS_BASETYPE
, /* tp_flags */
4670 datetime_doc
, /* tp_doc */
4671 0, /* tp_traverse */
4673 (richcmpfunc
)datetime_richcompare
, /* tp_richcompare */
4674 0, /* tp_weaklistoffset */
4676 0, /* tp_iternext */
4677 datetime_methods
, /* tp_methods */
4679 datetime_getset
, /* tp_getset */
4680 &PyDateTime_DateType
, /* tp_base */
4682 0, /* tp_descr_get */
4683 0, /* tp_descr_set */
4684 0, /* tp_dictoffset */
4686 datetime_alloc
, /* tp_alloc */
4687 datetime_new
, /* tp_new */
4691 /* ---------------------------------------------------------------------------
4692 * Module methods and initialization.
4695 static PyMethodDef module_methods
[] = {
4699 /* C API. Clients get at this via PyDateTime_IMPORT, defined in
4702 static PyDateTime_CAPI CAPI
= {
4703 &PyDateTime_DateType
,
4704 &PyDateTime_DateTimeType
,
4705 &PyDateTime_TimeType
,
4706 &PyDateTime_DeltaType
,
4707 &PyDateTime_TZInfoType
,
4712 datetime_fromtimestamp
,
4720 PyObject
*m
; /* a module object */
4721 PyObject
*d
; /* its dict */
4724 m
= Py_InitModule3("datetime", module_methods
,
4725 "Fast implementation of the datetime type.");
4729 if (PyType_Ready(&PyDateTime_DateType
) < 0)
4731 if (PyType_Ready(&PyDateTime_DateTimeType
) < 0)
4733 if (PyType_Ready(&PyDateTime_DeltaType
) < 0)
4735 if (PyType_Ready(&PyDateTime_TimeType
) < 0)
4737 if (PyType_Ready(&PyDateTime_TZInfoType
) < 0)
4740 /* timedelta values */
4741 d
= PyDateTime_DeltaType
.tp_dict
;
4743 x
= new_delta(0, 0, 1, 0);
4744 if (x
== NULL
|| PyDict_SetItemString(d
, "resolution", x
) < 0)
4748 x
= new_delta(-MAX_DELTA_DAYS
, 0, 0, 0);
4749 if (x
== NULL
|| PyDict_SetItemString(d
, "min", x
) < 0)
4753 x
= new_delta(MAX_DELTA_DAYS
, 24*3600-1, 1000000-1, 0);
4754 if (x
== NULL
|| PyDict_SetItemString(d
, "max", x
) < 0)
4759 d
= PyDateTime_DateType
.tp_dict
;
4761 x
= new_date(1, 1, 1);
4762 if (x
== NULL
|| PyDict_SetItemString(d
, "min", x
) < 0)
4766 x
= new_date(MAXYEAR
, 12, 31);
4767 if (x
== NULL
|| PyDict_SetItemString(d
, "max", x
) < 0)
4771 x
= new_delta(1, 0, 0, 0);
4772 if (x
== NULL
|| PyDict_SetItemString(d
, "resolution", x
) < 0)
4777 d
= PyDateTime_TimeType
.tp_dict
;
4779 x
= new_time(0, 0, 0, 0, Py_None
);
4780 if (x
== NULL
|| PyDict_SetItemString(d
, "min", x
) < 0)
4784 x
= new_time(23, 59, 59, 999999, Py_None
);
4785 if (x
== NULL
|| PyDict_SetItemString(d
, "max", x
) < 0)
4789 x
= new_delta(0, 0, 1, 0);
4790 if (x
== NULL
|| PyDict_SetItemString(d
, "resolution", x
) < 0)
4794 /* datetime values */
4795 d
= PyDateTime_DateTimeType
.tp_dict
;
4797 x
= new_datetime(1, 1, 1, 0, 0, 0, 0, Py_None
);
4798 if (x
== NULL
|| PyDict_SetItemString(d
, "min", x
) < 0)
4802 x
= new_datetime(MAXYEAR
, 12, 31, 23, 59, 59, 999999, Py_None
);
4803 if (x
== NULL
|| PyDict_SetItemString(d
, "max", x
) < 0)
4807 x
= new_delta(0, 0, 1, 0);
4808 if (x
== NULL
|| PyDict_SetItemString(d
, "resolution", x
) < 0)
4812 /* module initialization */
4813 PyModule_AddIntConstant(m
, "MINYEAR", MINYEAR
);
4814 PyModule_AddIntConstant(m
, "MAXYEAR", MAXYEAR
);
4816 Py_INCREF(&PyDateTime_DateType
);
4817 PyModule_AddObject(m
, "date", (PyObject
*) &PyDateTime_DateType
);
4819 Py_INCREF(&PyDateTime_DateTimeType
);
4820 PyModule_AddObject(m
, "datetime",
4821 (PyObject
*)&PyDateTime_DateTimeType
);
4823 Py_INCREF(&PyDateTime_TimeType
);
4824 PyModule_AddObject(m
, "time", (PyObject
*) &PyDateTime_TimeType
);
4826 Py_INCREF(&PyDateTime_DeltaType
);
4827 PyModule_AddObject(m
, "timedelta", (PyObject
*) &PyDateTime_DeltaType
);
4829 Py_INCREF(&PyDateTime_TZInfoType
);
4830 PyModule_AddObject(m
, "tzinfo", (PyObject
*) &PyDateTime_TZInfoType
);
4832 x
= PyCObject_FromVoidPtrAndDesc(&CAPI
, (void*) DATETIME_API_MAGIC
,
4836 PyModule_AddObject(m
, "datetime_CAPI", x
);
4838 /* A 4-year cycle has an extra leap day over what we'd get from
4839 * pasting together 4 single years.
4841 assert(DI4Y
== 4 * 365 + 1);
4842 assert(DI4Y
== days_before_year(4+1));
4844 /* Similarly, a 400-year cycle has an extra leap day over what we'd
4845 * get from pasting together 4 100-year cycles.
4847 assert(DI400Y
== 4 * DI100Y
+ 1);
4848 assert(DI400Y
== days_before_year(400+1));
4850 /* OTOH, a 100-year cycle has one fewer leap day than we'd get from
4851 * pasting together 25 4-year cycles.
4853 assert(DI100Y
== 25 * DI4Y
- 1);
4854 assert(DI100Y
== days_before_year(100+1));
4856 us_per_us
= PyInt_FromLong(1);
4857 us_per_ms
= PyInt_FromLong(1000);
4858 us_per_second
= PyInt_FromLong(1000000);
4859 us_per_minute
= PyInt_FromLong(60000000);
4860 seconds_per_day
= PyInt_FromLong(24 * 3600);
4861 if (us_per_us
== NULL
|| us_per_ms
== NULL
|| us_per_second
== NULL
||
4862 us_per_minute
== NULL
|| seconds_per_day
== NULL
)
4865 /* The rest are too big for 32-bit ints, but even
4866 * us_per_week fits in 40 bits, so doubles should be exact.
4868 us_per_hour
= PyLong_FromDouble(3600000000.0);
4869 us_per_day
= PyLong_FromDouble(86400000000.0);
4870 us_per_week
= PyLong_FromDouble(604800000000.0);
4871 if (us_per_hour
== NULL
|| us_per_day
== NULL
|| us_per_week
== NULL
)
4875 /* ---------------------------------------------------------------------------
4876 Some time zone algebra. For a datetime x, let
4877 x.n = x stripped of its timezone -- its naive time.
4878 x.o = x.utcoffset(), and assuming that doesn't raise an exception or
4880 x.d = x.dst(), and assuming that doesn't raise an exception or
4882 x.s = x's standard offset, x.o - x.d
4884 Now some derived rules, where k is a duration (timedelta).
4887 This follows from the definition of x.s.
4889 2. If x and y have the same tzinfo member, x.s = y.s.
4890 This is actually a requirement, an assumption we need to make about
4891 sane tzinfo classes.
4893 3. The naive UTC time corresponding to x is x.n - x.o.
4894 This is again a requirement for a sane tzinfo class.
4897 This follows from #2, and that datimetimetz+timedelta preserves tzinfo.
4899 5. (x+k).n = x.n + k
4900 Again follows from how arithmetic is defined.
4902 Now we can explain tz.fromutc(x). Let's assume it's an interesting case
4903 (meaning that the various tzinfo methods exist, and don't blow up or return
4906 The function wants to return a datetime y with timezone tz, equivalent to x.
4907 x is already in UTC.
4913 The algorithm starts by attaching tz to x.n, and calling that y. So
4914 x.n = y.n at the start. Then it wants to add a duration k to y, so that [1]
4915 becomes true; in effect, we want to solve [2] for k:
4917 (y+k).n - (y+k).o = x.n [2]
4919 By #1, this is the same as
4921 (y+k).n - ((y+k).s + (y+k).d) = x.n [3]
4923 By #5, (y+k).n = y.n + k, which equals x.n + k because x.n=y.n at the start.
4924 Substituting that into [3],
4926 x.n + k - (y+k).s - (y+k).d = x.n; the x.n terms cancel, leaving
4927 k - (y+k).s - (y+k).d = 0; rearranging,
4928 k = (y+k).s - (y+k).d; by #4, (y+k).s == y.s, so
4931 On the RHS, (y+k).d can't be computed directly, but y.s can be, and we
4932 approximate k by ignoring the (y+k).d term at first. Note that k can't be
4933 very large, since all offset-returning methods return a duration of magnitude
4934 less than 24 hours. For that reason, if y is firmly in std time, (y+k).d must
4935 be 0, so ignoring it has no consequence then.
4937 In any case, the new value is
4941 It's helpful to step back at look at [4] from a higher level: it's simply
4942 mapping from UTC to tz's standard time.
4948 we have an equivalent time, and are almost done. The insecurity here is
4949 at the start of daylight time. Picture US Eastern for concreteness. The wall
4950 time jumps from 1:59 to 3:00, and wall hours of the form 2:MM don't make good
4951 sense then. The docs ask that an Eastern tzinfo class consider such a time to
4952 be EDT (because it's "after 2"), which is a redundant spelling of 1:MM EST
4953 on the day DST starts. We want to return the 1:MM EST spelling because that's
4954 the only spelling that makes sense on the local wall clock.
4956 In fact, if [5] holds at this point, we do have the standard-time spelling,
4957 but that takes a bit of proof. We first prove a stronger result. What's the
4958 difference between the LHS and RHS of [5]? Let
4960 diff = x.n - (z.n - z.o) [6]
4965 y.n + y.s = since y.n = x.n
4966 x.n + y.s = since z and y are have the same tzinfo member,
4970 Plugging that back into [6] gives
4973 x.n - ((x.n + z.s) - z.o) = expanding
4974 x.n - x.n - z.s + z.o = cancelling
4980 If [5] is true now, diff = 0, so z.d = 0 too, and we have the standard-time
4981 spelling we wanted in the endcase described above. We're done. Contrarily,
4982 if z.d = 0, then we have a UTC equivalent, and are also done.
4984 If [5] is not true now, diff = z.d != 0, and z.d is the offset we need to
4985 add to z (in effect, z is in tz's standard time, and we need to shift the
4986 local clock into tz's daylight time).
4990 z' = z + z.d = z + diff [7]
4992 and we can again ask whether
4994 z'.n - z'.o = x.n [8]
4996 If so, we're done. If not, the tzinfo class is insane, according to the
4997 assumptions we've made. This also requires a bit of proof. As before, let's
4998 compute the difference between the LHS and RHS of [8] (and skipping some of
4999 the justifications for the kinds of substitutions we've done several times
5002 diff' = x.n - (z'.n - z'.o) = replacing z'.n via [7]
5003 x.n - (z.n + diff - z'.o) = replacing diff via [6]
5004 x.n - (z.n + x.n - (z.n - z.o) - z'.o) =
5005 x.n - z.n - x.n + z.n - z.o + z'.o = cancel x.n
5006 - z.n + z.n - z.o + z'.o = cancel z.n
5007 - z.o + z'.o = #1 twice
5008 -z.s - z.d + z'.s + z'.d = z and z' have same tzinfo
5011 So z' is UTC-equivalent to x iff z'.d = z.d at this point. If they are equal,
5012 we've found the UTC-equivalent so are done. In fact, we stop with [7] and
5013 return z', not bothering to compute z'.d.
5015 How could z.d and z'd differ? z' = z + z.d [7], so merely moving z' by
5016 a dst() offset, and starting *from* a time already in DST (we know z.d != 0),
5017 would have to change the result dst() returns: we start in DST, and moving
5018 a little further into it takes us out of DST.
5020 There isn't a sane case where this can happen. The closest it gets is at
5021 the end of DST, where there's an hour in UTC with no spelling in a hybrid
5022 tzinfo class. In US Eastern, that's 5:MM UTC = 0:MM EST = 1:MM EDT. During
5023 that hour, on an Eastern clock 1:MM is taken as being in standard time (6:MM
5024 UTC) because the docs insist on that, but 0:MM is taken as being in daylight
5025 time (4:MM UTC). There is no local time mapping to 5:MM UTC. The local
5026 clock jumps from 1:59 back to 1:00 again, and repeats the 1:MM hour in
5027 standard time. Since that's what the local clock *does*, we want to map both
5028 UTC hours 5:MM and 6:MM to 1:MM Eastern. The result is ambiguous
5029 in local time, but so it goes -- it's the way the local clock works.
5031 When x = 5:MM UTC is the input to this algorithm, x.o=0, y.o=-5 and y.d=0,
5032 so z=0:MM. z.d=60 (minutes) then, so [5] doesn't hold and we keep going.
5033 z' = z + z.d = 1:MM then, and z'.d=0, and z'.d - z.d = -60 != 0 so [8]
5034 (correctly) concludes that z' is not UTC-equivalent to x.
5036 Because we know z.d said z was in daylight time (else [5] would have held and
5037 we would have stopped then), and we know z.d != z'.d (else [8] would have held
5038 and we would have stopped then), and there are only 2 possible values dst() can
5039 return in Eastern, it follows that z'.d must be 0 (which it is in the example,
5040 but the reasoning doesn't depend on the example -- it depends on there being
5041 two possible dst() outcomes, one zero and the other non-zero). Therefore
5042 z' must be in standard time, and is the spelling we want in this case.
5044 Note again that z' is not UTC-equivalent as far as the hybrid tzinfo class is
5045 concerned (because it takes z' as being in standard time rather than the
5046 daylight time we intend here), but returning it gives the real-life "local
5047 clock repeats an hour" behavior when mapping the "unspellable" UTC hour into
5050 When the input is 6:MM, z=1:MM and z.d=0, and we stop at once, again with
5051 the 1:MM standard time spelling we want.
5053 So how can this break? One of the assumptions must be violated. Two
5056 1) [2] effectively says that y.s is invariant across all y belong to a given
5057 time zone. This isn't true if, for political reasons or continental drift,
5058 a region decides to change its base offset from UTC.
5060 2) There may be versions of "double daylight" time where the tail end of
5061 the analysis gives up a step too early. I haven't thought about that
5064 In any case, it's clear that the default fromutc() is strong enough to handle
5065 "almost all" time zones: so long as the standard offset is invariant, it
5066 doesn't matter if daylight time transition points change from year to year, or
5067 if daylight time is skipped in some years; it doesn't matter how large or
5068 small dst() may get within its bounds; and it doesn't even matter if some
5069 perverse time zone returns a negative dst()). So a breaking case must be
5070 pretty bizarre, and a tzinfo subclass can override fromutc() if it is.
5071 --------------------------------------------------------------------------- */