Lines Matching refs:self
677 PyObject *self = (PyObject *)PyObject_Malloc(size);
678 if (self == NULL) {
681 _PyObject_Init(self, type);
682 return self;
689 PyObject *self = (PyObject *)PyObject_Malloc(size);
690 if (self == NULL) {
693 _PyObject_Init(self, type);
694 return self;
704 set_date_fields(PyDateTime_Date *self, int y, int m, int d)
706 self->hashcode = -1;
707 SET_YEAR(self, y);
708 SET_MONTH(self, m);
709 SET_DAY(self, d);
947 PyDateTime_Date *self;
953 self = (PyDateTime_Date *)(type->tp_alloc(type, 0));
954 if (self != NULL)
955 set_date_fields(self, year, month, day);
956 return (PyObject *)self;
991 PyDateTime_DateTime *self;
1004 self = (PyDateTime_DateTime *) (type->tp_alloc(type, aware));
1005 if (self != NULL) {
1006 self->hastzinfo = aware;
1007 set_date_fields((PyDateTime_Date *)self, year, month, day);
1008 DATE_SET_HOUR(self, hour);
1009 DATE_SET_MINUTE(self, minute);
1010 DATE_SET_SECOND(self, second);
1011 DATE_SET_MICROSECOND(self, usecond);
1014 self->tzinfo = tzinfo;
1016 DATE_SET_FOLD(self, fold);
1018 return (PyObject *)self;
1072 PyDateTime_Time *self;
1082 self = (PyDateTime_Time *) (type->tp_alloc(type, aware));
1083 if (self != NULL) {
1084 self->hastzinfo = aware;
1085 self->hashcode = -1;
1086 TIME_SET_HOUR(self, hour);
1087 TIME_SET_MINUTE(self, minute);
1088 TIME_SET_SECOND(self, second);
1089 TIME_SET_MICROSECOND(self, usecond);
1092 self->tzinfo = tzinfo;
1094 TIME_SET_FOLD(self, fold);
1096 return (PyObject *)self;
1119 PyDateTime_Delta *self;
1129 self = (PyDateTime_Delta *) (type->tp_alloc(type, 0));
1130 if (self != NULL) {
1131 self->hashcode = -1;
1132 SET_TD_DAYS(self, days);
1133 SET_TD_SECONDS(self, seconds);
1134 SET_TD_MICROSECONDS(self, microseconds);
1136 return (PyObject *) self;
1162 PyDateTime_TimeZone *self;
1169 self = (PyDateTime_TimeZone *)(type->tp_alloc(type, 0));
1170 if (self == NULL) {
1174 self->offset = offset;
1176 self->name = name;
1177 return (PyObject *)self;
1180 static int delta_bool(PyDateTime_Delta *self);
1226 /* If self has a tzinfo member, return a BORROWED reference to it. Else
1231 get_tzinfo_member(PyObject *self)
1235 if (PyDateTime_Check(self) && HASTZINFO(self))
1236 tzinfo = ((PyDateTime_DateTime *)self)->tzinfo;
1237 else if (PyTime_Check(self) && HASTZINFO(self))
1238 tzinfo = ((PyDateTime_Time *)self)->tzinfo;
1449 static PyObject *delta_negative(PyDateTime_Delta *self);
1841 * (24*3600*self.days + self.seconds)*1000000 + self.microseconds
1847 delta_to_microseconds(PyDateTime_Delta *self)
1854 x1 = PyLong_FromLong(GET_TD_DAYS(self));
1864 x1 = PyLong_FromLong(GET_TD_SECONDS(self)); /* seconds */
1882 x2 = PyLong_FromLong(GET_TD_MICROSECONDS(self));
2176 delta_negative(PyDateTime_Delta *self)
2178 return new_delta(-GET_TD_DAYS(self),
2179 -GET_TD_SECONDS(self),
2180 -GET_TD_MICROSECONDS(self),
2185 delta_positive(PyDateTime_Delta *self)
2187 /* Could optimize this (by returning self) if this isn't a
2190 return new_delta(GET_TD_DAYS(self),
2191 GET_TD_SECONDS(self),
2192 GET_TD_MICROSECONDS(self),
2197 delta_abs(PyDateTime_Delta *self)
2201 assert(GET_TD_MICROSECONDS(self) >= 0);
2202 assert(GET_TD_SECONDS(self) >= 0);
2204 if (GET_TD_DAYS(self) < 0)
2205 result = delta_negative(self);
2207 result = delta_positive(self);
2235 delta_cmp(PyObject *self, PyObject *other)
2237 int diff = GET_TD_DAYS(self) - GET_TD_DAYS(other);
2239 diff = GET_TD_SECONDS(self) - GET_TD_SECONDS(other);
2241 diff = GET_TD_MICROSECONDS(self) -
2248 delta_richcompare(PyObject *self, PyObject *other, int op)
2251 int diff = delta_cmp(self, other);
2259 static PyObject *delta_getstate(PyDateTime_Delta *self);
2262 delta_hash(PyDateTime_Delta *self)
2264 if (self->hashcode == -1) {
2265 PyObject *temp = delta_getstate(self);
2267 self->hashcode = PyObject_Hash(temp);
2271 return self->hashcode;
2512 PyObject *self = NULL;
2613 self = microseconds_to_delta_ex(x, type);
2616 return self;
2622 delta_bool(PyDateTime_Delta *self)
2624 return (GET_TD_DAYS(self) != 0
2625 || GET_TD_SECONDS(self) != 0
2626 || GET_TD_MICROSECONDS(self) != 0);
2630 delta_repr(PyDateTime_Delta *self)
2640 if (GET_TD_DAYS(self) != 0) {
2641 Py_SETREF(args, PyUnicode_FromFormat("days=%d", GET_TD_DAYS(self)));
2648 if (GET_TD_SECONDS(self) != 0) {
2650 GET_TD_SECONDS(self)));
2657 if (GET_TD_MICROSECONDS(self) != 0) {
2659 GET_TD_MICROSECONDS(self)));
2672 PyObject *repr = PyUnicode_FromFormat("%s(%S)", Py_TYPE(self)->tp_name,
2679 delta_str(PyDateTime_Delta *self)
2681 int us = GET_TD_MICROSECONDS(self);
2682 int seconds = GET_TD_SECONDS(self);
2685 int days = GET_TD_DAYS(self);
2711 delta_getstate(PyDateTime_Delta *self)
2713 return Py_BuildValue("iii", GET_TD_DAYS(self),
2714 GET_TD_SECONDS(self),
2715 GET_TD_MICROSECONDS(self));
2719 delta_total_seconds(PyObject *self, PyObject *Py_UNUSED(ignored))
2724 total_microseconds = delta_to_microseconds((PyDateTime_Delta *)self);
2735 delta_reduce(PyDateTime_Delta* self, PyObject *Py_UNUSED(ignored))
2737 return Py_BuildValue("ON", Py_TYPE(self), delta_getstate(self));
2857 date_year(PyDateTime_Date *self, void *unused)
2859 return PyLong_FromLong(GET_YEAR(self));
2863 date_month(PyDateTime_Date *self, void *unused)
2865 return PyLong_FromLong(GET_MONTH(self));
2869 date_day(PyDateTime_Date *self, void *unused)
2871 return PyLong_FromLong(GET_DAY(self));
2902 PyObject *self = NULL;
2935 self = date_from_pickle(type, state);
2937 return self;
2944 self = new_date_ex(year, month, day, type);
2946 return self;
3222 date_repr(PyDateTime_Date *self)
3225 Py_TYPE(self)->tp_name,
3226 GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
3230 date_isoformat(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored))
3233 GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
3238 date_str(PyDateTime_Date *self)
3240 return _PyObject_CallMethodIdNoArgs((PyObject *)self, &PyId_isoformat);
3245 date_ctime(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored))
3247 return format_ctime(self, 0, 0, 0);
3251 date_strftime(PyDateTime_Date *self, PyObject *args, PyObject *kw)
3254 * timetuple() method appropriate to self's class.
3266 tuple = _PyObject_CallMethodIdNoArgs((PyObject *)self, &PyId_timetuple);
3269 result = wrap_strftime((PyObject *)self, format, tuple,
3270 (PyObject *)self);
3276 date_format(PyDateTime_Date *self, PyObject *args)
3283 /* if the format is zero length, return str(self) */
3285 return PyObject_Str((PyObject *)self);
3287 return _PyObject_CallMethodIdOneArg((PyObject *)self, &PyId_strftime,
3294 date_isoweekday(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored))
3296 int dow = weekday(GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
3312 iso_calendar_date_repr(PyDateTime_IsoCalendarDate *self)
3314 PyObject* year = PyTuple_GetItem((PyObject *)self, 0);
3318 PyObject* week = PyTuple_GetItem((PyObject *)self, 1);
3322 PyObject* weekday = PyTuple_GetItem((PyObject *)self, 2);
3328 Py_TYPE(self)->tp_name, year, week, weekday);
3332 iso_calendar_date_reduce(PyObject *self, PyObject *Py_UNUSED(ignored))
3337 PyTuple_GET_ITEM(self, 0),
3338 PyTuple_GET_ITEM(self, 1),
3339 PyTuple_GET_ITEM(self, 2)
3346 iso_calendar_date_year(PyDateTime_IsoCalendarDate *self, void *unused)
3348 PyObject *year = PyTuple_GetItem((PyObject *)self, 0);
3357 iso_calendar_date_week(PyDateTime_IsoCalendarDate *self, void *unused)
3359 PyObject *week = PyTuple_GetItem((PyObject *)self, 1);
3368 iso_calendar_date_weekday(PyDateTime_IsoCalendarDate *self, void *unused)
3370 PyObject *weekday = PyTuple_GetItem((PyObject *)self, 2);
3418 PyDateTime_IsoCalendarDate *self;
3419 self = (PyDateTime_IsoCalendarDate *) type->tp_alloc(type, 3);
3420 if (self == NULL) {
3424 PyTuple_SET_ITEM(self, 0, PyLong_FromLong(year));
3425 PyTuple_SET_ITEM(self, 1, PyLong_FromLong(week));
3426 PyTuple_SET_ITEM(self, 2, PyLong_FromLong(weekday));
3428 return (PyObject *)self;
3432 date_isocalendar(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored))
3434 int year = GET_YEAR(self);
3436 int today = ymd_to_ord(year, GET_MONTH(self), GET_DAY(self));
3462 date_richcompare(PyObject *self, PyObject *other, int op)
3465 int diff = memcmp(((PyDateTime_Date *)self)->data,
3475 date_timetuple(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored))
3477 return build_struct_time(GET_YEAR(self),
3478 GET_MONTH(self),
3479 GET_DAY(self),
3484 date_replace(PyDateTime_Date *self, PyObject *args, PyObject *kw)
3488 int year = GET_YEAR(self);
3489 int month = GET_MONTH(self);
3490 int day = GET_DAY(self);
3498 clone = date_new(Py_TYPE(self), tuple, NULL);
3510 static PyObject *date_getstate(PyDateTime_Date *self);
3513 date_hash(PyDateTime_Date *self)
3515 if (self->hashcode == -1) {
3516 self->hashcode = generic_hash(
3517 (unsigned char *)self->data, _PyDateTime_DATE_DATASIZE);
3520 return self->hashcode;
3524 date_toordinal(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored))
3526 return PyLong_FromLong(ymd_to_ord(GET_YEAR(self), GET_MONTH(self),
3527 GET_DAY(self)));
3531 date_weekday(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored))
3533 int dow = weekday(GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
3542 date_getstate(PyDateTime_Date *self)
3545 field = PyBytes_FromStringAndSize((char*)self->data,
3551 date_reduce(PyDateTime_Date *self, PyObject *arg)
3553 return Py_BuildValue("(ON)", Py_TYPE(self), date_getstate(self));
3578 "self.__class__.fromtimestamp(time.time()).")},
3589 PyDoc_STR("Formats self with strftime.")},
3709 tzinfo_tzname(PyDateTime_TZInfo *self, PyObject *dt)
3715 tzinfo_utcoffset(PyDateTime_TZInfo *self, PyObject *dt)
3721 tzinfo_dst(PyDateTime_TZInfo *self, PyObject *dt)
3730 static PyObject *datetime_utcoffset(PyObject *self, PyObject *);
3731 static PyObject *datetime_dst(PyObject *self, PyObject *);
3734 tzinfo_fromutc(PyDateTime_TZInfo *self, PyObject *dt)
3745 if (GET_DT_TZINFO(dt) != (PyObject *)self) {
3747 "is not self");
3812 tzinfo_reduce(PyObject *self, PyObject *Py_UNUSED(ignored))
3818 if (_PyObject_LookupAttrId(self, &PyId___getinitargs__, &getinitargs) < 0) {
3832 state = _PyObject_GetState(self);
3838 return Py_BuildValue("(ONN)", Py_TYPE(self), args, state);
3922 timezone_dealloc(PyDateTime_TimeZone *self)
3924 Py_CLEAR(self->offset);
3925 Py_CLEAR(self->name);
3926 Py_TYPE(self)->tp_free((PyObject *)self);
3930 timezone_richcompare(PyDateTime_TimeZone *self,
3938 return delta_richcompare(self->offset, other->offset, op);
3942 timezone_hash(PyDateTime_TimeZone *self)
3944 return delta_hash((PyDateTime_Delta *)self->offset);
3962 timezone_repr(PyDateTime_TimeZone *self)
3965 to use Py_TYPE(self)->tp_name here. */
3966 const char *type_name = Py_TYPE(self)->tp_name;
3968 if (((PyObject *)self) == PyDateTime_TimeZone_UTC)
3971 if (self->name == NULL)
3972 return PyUnicode_FromFormat("%s(%R)", type_name, self->offset);
3974 return PyUnicode_FromFormat("%s(%R, %R)", type_name, self->offset,
3975 self->name);
3980 timezone_str(PyDateTime_TimeZone *self)
3986 if (self->name != NULL) {
3987 Py_INCREF(self->name);
3988 return self->name;
3990 if ((PyObject *)self == PyDateTime_TimeZone_UTC ||
3991 (GET_TD_DAYS(self->offset) == 0 &&
3992 GET_TD_SECONDS(self->offset) == 0 &&
3993 GET_TD_MICROSECONDS(self->offset) == 0))
3996 if (GET_TD_DAYS(self->offset) < 0) {
3998 offset = delta_negative((PyDateTime_Delta *)self->offset);
4004 offset = self->offset;
4026 timezone_tzname(PyDateTime_TimeZone *self, PyObject *dt)
4031 return timezone_str(self);
4035 timezone_utcoffset(PyDateTime_TimeZone *self, PyObject *dt)
4040 Py_INCREF(self->offset);
4041 return self->offset;
4045 timezone_dst(PyObject *self, PyObject *dt)
4054 timezone_fromutc(PyDateTime_TimeZone *self, PyDateTime_DateTime *dt)
4061 if (!HASTZINFO(dt) || dt->tzinfo != (PyObject *)self) {
4063 "is not self");
4067 return add_datetime_timedelta(dt, (PyDateTime_Delta *)self->offset, 1);
4071 timezone_getinitargs(PyDateTime_TimeZone *self, PyObject *Py_UNUSED(ignored))
4073 if (self->name == NULL)
4074 return Py_BuildValue("(O)", self->offset);
4075 return Py_BuildValue("(OO)", self->offset, self->name);
4150 time_hour(PyDateTime_Time *self, void *unused)
4152 return PyLong_FromLong(TIME_GET_HOUR(self));
4156 time_minute(PyDateTime_Time *self, void *unused)
4158 return PyLong_FromLong(TIME_GET_MINUTE(self));
4163 py_time_second(PyDateTime_Time *self, void *unused)
4165 return PyLong_FromLong(TIME_GET_SECOND(self));
4169 time_microsecond(PyDateTime_Time *self, void *unused)
4171 return PyLong_FromLong(TIME_GET_MICROSECOND(self));
4175 time_tzinfo(PyDateTime_Time *self, void *unused)
4177 PyObject *result = HASTZINFO(self) ? self->tzinfo : Py_None;
4183 time_fold(PyDateTime_Time *self, void *unused)
4185 return PyLong_FromLong(TIME_GET_FOLD(self));
4241 PyObject *self = NULL;
4280 self = time_from_pickle(type, state, tzinfo);
4282 return self;
4291 self = new_time_ex2(hour, minute, second, usecond, tzinfo, fold,
4294 return self;
4302 time_dealloc(PyDateTime_Time *self)
4304 if (HASTZINFO(self)) {
4305 Py_XDECREF(self->tzinfo);
4307 Py_TYPE(self)->tp_free((PyObject *)self);
4316 time_utcoffset(PyObject *self, PyObject *unused) {
4317 return call_utcoffset(GET_TIME_TZINFO(self), Py_None);
4321 time_dst(PyObject *self, PyObject *unused) {
4322 return call_dst(GET_TIME_TZINFO(self), Py_None);
4326 time_tzname(PyDateTime_Time *self, PyObject *unused) {
4327 return call_tzname(GET_TIME_TZINFO(self), Py_None);
4335 time_repr(PyDateTime_Time *self)
4337 const char *type_name = Py_TYPE(self)->tp_name;
4338 int h = TIME_GET_HOUR(self);
4339 int m = TIME_GET_MINUTE(self);
4340 int s = TIME_GET_SECOND(self);
4341 int us = TIME_GET_MICROSECOND(self);
4342 int fold = TIME_GET_FOLD(self);
4353 if (result != NULL && HASTZINFO(self))
4354 result = append_keyword_tzinfo(result, self->tzinfo);
4361 time_str(PyDateTime_Time *self)
4363 return _PyObject_CallMethodIdNoArgs((PyObject *)self, &PyId_isoformat);
4367 time_isoformat(PyDateTime_Time *self, PyObject *args, PyObject *kw)
4373 int us = TIME_GET_MICROSECOND(self);
4414 TIME_GET_HOUR(self), TIME_GET_MINUTE(self),
4415 TIME_GET_SECOND(self), us);
4418 if (result == NULL || !HASTZINFO(self) || self->tzinfo == Py_None)
4422 if (format_utcoffset(buf, sizeof(buf), ":", self->tzinfo,
4432 time_strftime(PyDateTime_Time *self, PyObject *args, PyObject *kw)
4449 TIME_GET_HOUR(self),
4450 TIME_GET_MINUTE(self),
4451 TIME_GET_SECOND(self),
4456 result = wrap_strftime((PyObject *)self, format, tuple,
4467 time_richcompare(PyObject *self, PyObject *other, int op)
4476 if (GET_TIME_TZINFO(self) == GET_TIME_TZINFO(other)) {
4477 diff = memcmp(((PyDateTime_Time *)self)->data,
4482 offset1 = time_utcoffset(self, NULL);
4495 diff = memcmp(((PyDateTime_Time *)self)->data,
4504 offsecs1 = TIME_GET_HOUR(self) * 3600 +
4505 TIME_GET_MINUTE(self) * 60 +
4506 TIME_GET_SECOND(self) -
4516 diff = TIME_GET_MICROSECOND(self) -
4540 time_hash(PyDateTime_Time *self)
4542 if (self->hashcode == -1) {
4544 if (TIME_GET_FOLD(self)) {
4545 self0 = new_time_ex2(TIME_GET_HOUR(self),
4546 TIME_GET_MINUTE(self),
4547 TIME_GET_SECOND(self),
4548 TIME_GET_MICROSECOND(self),
4549 HASTZINFO(self) ? self->tzinfo : Py_None,
4550 0, Py_TYPE(self));
4555 self0 = (PyObject *)self;
4566 self->hashcode = generic_hash(
4567 (unsigned char *)self->data, _PyDateTime_TIME_DATASIZE);
4571 assert(HASTZINFO(self));
4572 seconds = TIME_GET_HOUR(self) * 3600 +
4573 TIME_GET_MINUTE(self) * 60 +
4574 TIME_GET_SECOND(self);
4575 microseconds = TIME_GET_MICROSECOND(self);
4587 self->hashcode = PyObject_Hash(temp2);
4592 return self->hashcode;
4596 time_replace(PyDateTime_Time *self, PyObject *args, PyObject *kw)
4600 int hh = TIME_GET_HOUR(self);
4601 int mm = TIME_GET_MINUTE(self);
4602 int ss = TIME_GET_SECOND(self);
4603 int us = TIME_GET_MICROSECOND(self);
4604 PyObject *tzinfo = HASTZINFO(self) ? self->tzinfo : Py_None;
4605 int fold = TIME_GET_FOLD(self);
4619 clone = time_new(Py_TYPE(self), tuple, NULL);
4693 time_getstate(PyDateTime_Time *self, int proto)
4698 basestate = PyBytes_FromStringAndSize((char *)self->data,
4701 if (proto > 3 && TIME_GET_FOLD(self))
4704 if (! HASTZINFO(self) || self->tzinfo == Py_None)
4707 result = PyTuple_Pack(2, basestate, self->tzinfo);
4714 time_reduce_ex(PyDateTime_Time *self, PyObject *args)
4720 return Py_BuildValue("(ON)", Py_TYPE(self), time_getstate(self, proto));
4724 time_reduce(PyDateTime_Time *self, PyObject *arg)
4726 return Py_BuildValue("(ON)", Py_TYPE(self), time_getstate(self, 2));
4743 PyDoc_STR("Formats self with strftime.")},
4746 PyDoc_STR("Return self.tzinfo.utcoffset(self).")},
4749 PyDoc_STR("Return self.tzinfo.tzname(self).")},
4752 PyDoc_STR("Return self.tzinfo.dst(self).")},
4826 datetime_hour(PyDateTime_DateTime *self, void *unused)
4828 return PyLong_FromLong(DATE_GET_HOUR(self));
4832 datetime_minute(PyDateTime_DateTime *self, void *unused)
4834 return PyLong_FromLong(DATE_GET_MINUTE(self));
4838 datetime_second(PyDateTime_DateTime *self, void *unused)
4840 return PyLong_FromLong(DATE_GET_SECOND(self));
4844 datetime_microsecond(PyDateTime_DateTime *self, void *unused)
4846 return PyLong_FromLong(DATE_GET_MICROSECOND(self));
4850 datetime_tzinfo(PyDateTime_DateTime *self, void *unused)
4852 PyObject *result = HASTZINFO(self) ? self->tzinfo : Py_None;
4858 datetime_fold(PyDateTime_DateTime *self, void *unused)
4860 return PyLong_FromLong(DATE_GET_FOLD(self));
4918 PyObject *self = NULL;
4960 self = datetime_from_pickle(type, state, tzinfo);
4962 return self;
4971 self = new_datetime_ex2(year, month, day,
4975 return self;
5151 PyObject *self;
5159 self = datetime_best_possible((PyObject *)type,
5163 if (self != NULL && tz != Py_None) {
5165 self = _PyObject_CallMethodId(tz, &PyId_fromutc, "N", self);
5167 return self;
5183 PyObject *self;
5194 self = datetime_from_timestamp(cls,
5199 if (self != NULL && tzinfo != Py_None) {
5201 self = _PyObject_CallMethodId(tzinfo, &PyId_fromutc, "N", self);
5203 return self;
5529 datetime_dealloc(PyDateTime_DateTime *self)
5531 if (HASTZINFO(self)) {
5532 Py_XDECREF(self->tzinfo);
5534 Py_TYPE(self)->tp_free((PyObject *)self);
5543 datetime_utcoffset(PyObject *self, PyObject *unused) {
5544 return call_utcoffset(GET_DT_TZINFO(self), self);
5548 datetime_dst(PyObject *self, PyObject *unused) {
5549 return call_dst(GET_DT_TZINFO(self), self);
5553 datetime_tzname(PyObject *self, PyObject *unused) {
5554 return call_tzname(GET_DT_TZINFO(self), self);
5703 datetime_repr(PyDateTime_DateTime *self)
5705 const char *type_name = Py_TYPE(self)->tp_name;
5708 if (DATE_GET_MICROSECOND(self)) {
5712 GET_YEAR(self), GET_MONTH(self), GET_DAY(self),
5713 DATE_GET_HOUR(self), DATE_GET_MINUTE(self),
5714 DATE_GET_SECOND(self),
5715 DATE_GET_MICROSECOND(self));
5717 else if (DATE_GET_SECOND(self)) {
5721 GET_YEAR(self), GET_MONTH(self), GET_DAY(self),
5722 DATE_GET_HOUR(self), DATE_GET_MINUTE(self),
5723 DATE_GET_SECOND(self));
5729 GET_YEAR(self), GET_MONTH(self), GET_DAY(self),
5730 DATE_GET_HOUR(self), DATE_GET_MINUTE(self));
5732 if (baserepr != NULL && DATE_GET_FOLD(self) != 0)
5733 baserepr = append_keyword_fold(baserepr, DATE_GET_FOLD(self));
5734 if (baserepr == NULL || ! HASTZINFO(self))
5736 return append_keyword_tzinfo(baserepr, self->tzinfo);
5740 datetime_str(PyDateTime_DateTime *self)
5742 return _PyObject_CallMethodId((PyObject *)self, &PyId_isoformat, "s", " ");
5746 datetime_isoformat(PyDateTime_DateTime *self, PyObject *args, PyObject *kw)
5753 int us = DATE_GET_MICROSECOND(self);
5793 GET_YEAR(self), GET_MONTH(self),
5794 GET_DAY(self), (int)sep,
5795 DATE_GET_HOUR(self), DATE_GET_MINUTE(self),
5796 DATE_GET_SECOND(self), us);
5799 if (!result || !HASTZINFO(self))
5803 if (format_utcoffset(buffer, sizeof(buffer), ":", self->tzinfo,
5804 (PyObject *)self) < 0) {
5813 datetime_ctime(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored))
5815 return format_ctime((PyDateTime_Date *)self,
5816 DATE_GET_HOUR(self),
5817 DATE_GET_MINUTE(self),
5818 DATE_GET_SECOND(self));
5859 pep495_eq_exception(PyObject *self, PyObject *other,
5865 flip_offset = get_flip_fold_offset(self);
5888 datetime_richcompare(PyObject *self, PyObject *other, int op)
5907 return cmperror(self, other);
5912 if (GET_DT_TZINFO(self) == GET_DT_TZINFO(other)) {
5913 diff = memcmp(((PyDateTime_DateTime *)self)->data,
5918 offset1 = datetime_utcoffset(self, NULL);
5931 diff = memcmp(((PyDateTime_DateTime *)self)->data,
5935 int ex = pep495_eq_exception(self, other, offset1, offset2);
5947 delta = (PyDateTime_Delta *)datetime_subtract((PyObject *)self,
5957 int ex = pep495_eq_exception(self, other, offset1, offset2);
5985 datetime_hash(PyDateTime_DateTime *self)
5987 if (self->hashcode == -1) {
5989 if (DATE_GET_FOLD(self)) {
5990 self0 = new_datetime_ex2(GET_YEAR(self),
5991 GET_MONTH(self),
5992 GET_DAY(self),
5993 DATE_GET_HOUR(self),
5994 DATE_GET_MINUTE(self),
5995 DATE_GET_SECOND(self),
5996 DATE_GET_MICROSECOND(self),
5997 HASTZINFO(self) ? self->tzinfo : Py_None,
5998 0, Py_TYPE(self));
6003 self0 = (PyObject *)self;
6014 self->hashcode = generic_hash(
6015 (unsigned char *)self->data, _PyDateTime_DATETIME_DATASIZE);
6020 assert(HASTZINFO(self));
6021 days = ymd_to_ord(GET_YEAR(self),
6022 GET_MONTH(self),
6023 GET_DAY(self));
6024 seconds = DATE_GET_HOUR(self) * 3600 +
6025 DATE_GET_MINUTE(self) * 60 +
6026 DATE_GET_SECOND(self);
6028 DATE_GET_MICROSECOND(self),
6040 self->hashcode = PyObject_Hash(temp2);
6045 return self->hashcode;
6049 datetime_replace(PyDateTime_DateTime *self, PyObject *args, PyObject *kw)
6053 int y = GET_YEAR(self);
6054 int m = GET_MONTH(self);
6055 int d = GET_DAY(self);
6056 int hh = DATE_GET_HOUR(self);
6057 int mm = DATE_GET_MINUTE(self);
6058 int ss = DATE_GET_SECOND(self);
6059 int us = DATE_GET_MICROSECOND(self);
6060 PyObject *tzinfo = HASTZINFO(self) ? self->tzinfo : Py_None;
6061 int fold = DATE_GET_FOLD(self);
6076 clone = datetime_new(Py_TYPE(self), tuple, NULL);
6199 datetime_astimezone(PyDateTime_DateTime *self, PyObject *args, PyObject *kw)
6215 if (!HASTZINFO(self) || self->tzinfo == Py_None) {
6217 self_tzinfo = local_timezone_from_local(self);
6221 self_tzinfo = self->tzinfo;
6225 /* Conversion to self's own time zone is a NOP. */
6228 Py_INCREF(self);
6229 return self;
6232 /* Convert self to UTC. */
6233 offset = call_utcoffset(self_tzinfo, (PyObject *)self);
6247 /* result = self - offset */
6248 result = (PyDateTime_DateTime *)add_datetime_timedelta(self,
6303 datetime_timetuple(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored))
6307 if (HASTZINFO(self) && self->tzinfo != Py_None) {
6310 dst = call_dst(self->tzinfo, (PyObject *)self);
6318 return build_struct_time(GET_YEAR(self),
6319 GET_MONTH(self),
6320 GET_DAY(self),
6321 DATE_GET_HOUR(self),
6322 DATE_GET_MINUTE(self),
6323 DATE_GET_SECOND(self),
6378 datetime_timestamp(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored))
6382 if (HASTZINFO(self) && self->tzinfo != Py_None) {
6384 delta = datetime_subtract((PyObject *)self, PyDateTime_Epoch);
6392 seconds = local_to_seconds(GET_YEAR(self),
6393 GET_MONTH(self),
6394 GET_DAY(self),
6395 DATE_GET_HOUR(self),
6396 DATE_GET_MINUTE(self),
6397 DATE_GET_SECOND(self),
6398 DATE_GET_FOLD(self));
6402 DATE_GET_MICROSECOND(self) / 1e6);
6408 datetime_getdate(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored))
6410 return new_date(GET_YEAR(self),
6411 GET_MONTH(self),
6412 GET_DAY(self));
6416 datetime_gettime(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored))
6418 return new_time(DATE_GET_HOUR(self),
6419 DATE_GET_MINUTE(self),
6420 DATE_GET_SECOND(self),
6421 DATE_GET_MICROSECOND(self),
6423 DATE_GET_FOLD(self));
6427 datetime_gettimetz(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored))
6429 return new_time(DATE_GET_HOUR(self),
6430 DATE_GET_MINUTE(self),
6431 DATE_GET_SECOND(self),
6432 DATE_GET_MICROSECOND(self),
6433 GET_DT_TZINFO(self),
6434 DATE_GET_FOLD(self));
6438 datetime_utctimetuple(PyDateTime_DateTime *self, PyObject *Py_UNUSED(ignored))
6444 tzinfo = GET_DT_TZINFO(self);
6446 utcself = self;
6451 offset = call_utcoffset(tzinfo, (PyObject *)self);
6456 utcself = self;
6460 utcself = (PyDateTime_DateTime *)add_datetime_timedelta(self,
6486 datetime_getstate(PyDateTime_DateTime *self, int proto)
6491 basestate = PyBytes_FromStringAndSize((char *)self->data,
6494 if (proto > 3 && DATE_GET_FOLD(self))
6497 if (! HASTZINFO(self) || self->tzinfo == Py_None)
6500 result = PyTuple_Pack(2, basestate, self->tzinfo);
6507 datetime_reduce_ex(PyDateTime_DateTime *self, PyObject *args)
6513 return Py_BuildValue("(ON)", Py_TYPE(self), datetime_getstate(self, proto));
6517 datetime_reduce(PyDateTime_DateTime *self, PyObject *arg)
6519 return Py_BuildValue("(ON)", Py_TYPE(self), datetime_getstate(self, 2));
6587 PyDoc_STR("Return self.tzinfo.utcoffset(self).")},
6590 PyDoc_STR("Return self.tzinfo.tzname(self).")},
6593 PyDoc_STR("Return self.tzinfo.dst(self).")},