2 pybind11/chrono.h: Transparent conversion between std::chrono and python's datetime
4 Copyright (c) 2016 Trent Houliston <trent@houliston.me> and
5 Wenzel Jakob <wenzel.jakob@epfl.ch>
7 All rights reserved. Use of this source code is governed by a
8 BSD-style license that can be found in the LICENSE file.
19 // Backport the PyDateTime_DELTA functions from Python3.3 if required
20 #ifndef PyDateTime_DELTA_GET_DAYS
21 #define PyDateTime_DELTA_GET_DAYS(o) (((PyDateTime_Delta*)o)->days)
23 #ifndef PyDateTime_DELTA_GET_SECONDS
24 #define PyDateTime_DELTA_GET_SECONDS(o) (((PyDateTime_Delta*)o)->seconds)
26 #ifndef PyDateTime_DELTA_GET_MICROSECONDS
27 #define PyDateTime_DELTA_GET_MICROSECONDS(o) (((PyDateTime_Delta*)o)->microseconds)
30 NAMESPACE_BEGIN(PYBIND11_NAMESPACE
)
31 NAMESPACE_BEGIN(detail
)
33 template <typename type
> class duration_caster
{
35 typedef typename
type::rep rep
;
36 typedef typename
type::period period
;
38 typedef std::chrono::duration
<uint_fast32_t, std::ratio
<86400>> days
;
40 bool load(handle src
, bool) {
41 using namespace std::chrono
;
43 // Lazy initialise the PyDateTime import
44 if (!PyDateTimeAPI
) { PyDateTime_IMPORT
; }
46 if (!src
) return false;
47 // If invoked with datetime.delta object
48 if (PyDelta_Check(src
.ptr())) {
49 value
= type(duration_cast
<duration
<rep
, period
>>(
50 days(PyDateTime_DELTA_GET_DAYS(src
.ptr()))
51 + seconds(PyDateTime_DELTA_GET_SECONDS(src
.ptr()))
52 + microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src
.ptr()))));
55 // If invoked with a float we assume it is seconds and convert
56 else if (PyFloat_Check(src
.ptr())) {
57 value
= type(duration_cast
<duration
<rep
, period
>>(duration
<double>(PyFloat_AsDouble(src
.ptr()))));
63 // If this is a duration just return it back
64 static const std::chrono::duration
<rep
, period
>& get_duration(const std::chrono::duration
<rep
, period
> &src
) {
68 // If this is a time_point get the time_since_epoch
69 template <typename Clock
> static std::chrono::duration
<rep
, period
> get_duration(const std::chrono::time_point
<Clock
, std::chrono::duration
<rep
, period
>> &src
) {
70 return src
.time_since_epoch();
73 static handle
cast(const type
&src
, return_value_policy
/* policy */, handle
/* parent */) {
74 using namespace std::chrono
;
76 // Use overloaded function to get our duration from our source
77 // Works out if it is a duration or time_point and get the duration
78 auto d
= get_duration(src
);
80 // Lazy initialise the PyDateTime import
81 if (!PyDateTimeAPI
) { PyDateTime_IMPORT
; }
83 // Declare these special duration types so the conversions happen with the correct primitive types (int)
84 using dd_t
= duration
<int, std::ratio
<86400>>;
85 using ss_t
= duration
<int, std::ratio
<1>>;
86 using us_t
= duration
<int, std::micro
>;
88 auto dd
= duration_cast
<dd_t
>(d
);
90 auto ss
= duration_cast
<ss_t
>(subd
);
91 auto us
= duration_cast
<us_t
>(subd
- ss
);
92 return PyDelta_FromDSU(dd
.count(), ss
.count(), us
.count());
95 PYBIND11_TYPE_CASTER(type
, _("datetime.timedelta"));
98 // This is for casting times on the system clock into datetime.datetime instances
99 template <typename Duration
> class type_caster
<std::chrono::time_point
<std::chrono::system_clock
, Duration
>> {
101 typedef std::chrono::time_point
<std::chrono::system_clock
, Duration
> type
;
102 bool load(handle src
, bool) {
103 using namespace std::chrono
;
105 // Lazy initialise the PyDateTime import
106 if (!PyDateTimeAPI
) { PyDateTime_IMPORT
; }
108 if (!src
) return false;
113 if (PyDateTime_Check(src
.ptr())) {
114 cal
.tm_sec
= PyDateTime_DATE_GET_SECOND(src
.ptr());
115 cal
.tm_min
= PyDateTime_DATE_GET_MINUTE(src
.ptr());
116 cal
.tm_hour
= PyDateTime_DATE_GET_HOUR(src
.ptr());
117 cal
.tm_mday
= PyDateTime_GET_DAY(src
.ptr());
118 cal
.tm_mon
= PyDateTime_GET_MONTH(src
.ptr()) - 1;
119 cal
.tm_year
= PyDateTime_GET_YEAR(src
.ptr()) - 1900;
121 msecs
= microseconds(PyDateTime_DATE_GET_MICROSECOND(src
.ptr()));
122 } else if (PyDate_Check(src
.ptr())) {
126 cal
.tm_mday
= PyDateTime_GET_DAY(src
.ptr());
127 cal
.tm_mon
= PyDateTime_GET_MONTH(src
.ptr()) - 1;
128 cal
.tm_year
= PyDateTime_GET_YEAR(src
.ptr()) - 1900;
130 msecs
= microseconds(0);
131 } else if (PyTime_Check(src
.ptr())) {
132 cal
.tm_sec
= PyDateTime_TIME_GET_SECOND(src
.ptr());
133 cal
.tm_min
= PyDateTime_TIME_GET_MINUTE(src
.ptr());
134 cal
.tm_hour
= PyDateTime_TIME_GET_HOUR(src
.ptr());
135 cal
.tm_mday
= 1; // This date (day, month, year) = (1, 0, 70)
136 cal
.tm_mon
= 0; // represents 1-Jan-1970, which is the first
137 cal
.tm_year
= 70; // earliest available date for Python's datetime
139 msecs
= microseconds(PyDateTime_TIME_GET_MICROSECOND(src
.ptr()));
143 value
= system_clock::from_time_t(std::mktime(&cal
)) + msecs
;
147 static handle
cast(const std::chrono::time_point
<std::chrono::system_clock
, Duration
> &src
, return_value_policy
/* policy */, handle
/* parent */) {
148 using namespace std::chrono
;
150 // Lazy initialise the PyDateTime import
151 if (!PyDateTimeAPI
) { PyDateTime_IMPORT
; }
153 std::time_t tt
= system_clock::to_time_t(time_point_cast
<system_clock::duration
>(src
));
154 // this function uses static memory so it's best to copy it out asap just in case
155 // otherwise other code that is using localtime may break this (not just python code)
156 std::tm localtime
= *std::localtime(&tt
);
158 // Declare these special duration types so the conversions happen with the correct primitive types (int)
159 using us_t
= duration
<int, std::micro
>;
161 return PyDateTime_FromDateAndTime(localtime
.tm_year
+ 1900,
162 localtime
.tm_mon
+ 1,
167 (duration_cast
<us_t
>(src
.time_since_epoch() % seconds(1))).count());
169 PYBIND11_TYPE_CASTER(type
, _("datetime.datetime"));
172 // Other clocks that are not the system clock are not measured as datetime.datetime objects
173 // since they are not measured on calendar time. So instead we just make them timedeltas
174 // Or if they have passed us a time as a float we convert that
175 template <typename Clock
, typename Duration
> class type_caster
<std::chrono::time_point
<Clock
, Duration
>>
176 : public duration_caster
<std::chrono::time_point
<Clock
, Duration
>> {
179 template <typename Rep
, typename Period
> class type_caster
<std::chrono::duration
<Rep
, Period
>>
180 : public duration_caster
<std::chrono::duration
<Rep
, Period
>> {
183 NAMESPACE_END(detail
)
184 NAMESPACE_END(PYBIND11_NAMESPACE
)