Revert "[Triton-MLIR][pybind11] Update pybind11 to 2.10.0" (#702)

Reverts openai/triton#694

python/src/pybind11/chrono.h

@@ -0,0 +1,187 @@
+/*
+    pybind11/chrono.h: Transparent conversion between std::chrono and python's
+   datetime
+
+    Copyright (c) 2016 Trent Houliston <trent@houliston.me> and
+                       Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+#include <chrono>
+#include <cmath>
+#include <ctime>
+#include <datetime.h>
+
+// Backport the PyDateTime_DELTA functions from Python3.3 if required
+#ifndef PyDateTime_DELTA_GET_DAYS
+#define PyDateTime_DELTA_GET_DAYS(o) (((PyDateTime_Delta *)o)->days)
+#endif
+#ifndef PyDateTime_DELTA_GET_SECONDS
+#define PyDateTime_DELTA_GET_SECONDS(o) (((PyDateTime_Delta *)o)->seconds)
+#endif
+#ifndef PyDateTime_DELTA_GET_MICROSECONDS
+#define PyDateTime_DELTA_GET_MICROSECONDS(o)                                   \
+  (((PyDateTime_Delta *)o)->microseconds)
+#endif
+
+NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+NAMESPACE_BEGIN(detail)
+
+template <typename type> class duration_caster {
+public:
+  typedef typename type::rep rep;
+  typedef typename type::period period;
+
+  typedef std::chrono::duration<uint_fast32_t, std::ratio<86400>> days;
+
+  bool load(handle src, bool) {
+    using namespace std::chrono;
+
+    // Lazy initialise the PyDateTime import
+    if (!PyDateTimeAPI) {
+      PyDateTime_IMPORT;
+    }
+
+    if (!src)
+      return false;
+    // If invoked with datetime.delta object
+    if (PyDelta_Check(src.ptr())) {
+      value = type(duration_cast<duration<rep, period>>(
+          days(PyDateTime_DELTA_GET_DAYS(src.ptr())) +
+          seconds(PyDateTime_DELTA_GET_SECONDS(src.ptr())) +
+          microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src.ptr()))));
+      return true;
+    }
+    // If invoked with a float we assume it is seconds and convert
+    else if (PyFloat_Check(src.ptr())) {
+      value = type(duration_cast<duration<rep, period>>(
+          duration<double>(PyFloat_AsDouble(src.ptr()))));
+      return true;
+    } else
+      return false;
+  }
+
+  // If this is a duration just return it back
+  static const std::chrono::duration<rep, period> &
+  get_duration(const std::chrono::duration<rep, period> &src) {
+    return src;
+  }
+
+  // If this is a time_point get the time_since_epoch
+  template <typename Clock>
+  static std::chrono::duration<rep, period> get_duration(
+      const std::chrono::time_point<Clock, std::chrono::duration<rep, period>>
+          &src) {
+    return src.time_since_epoch();
+  }
+
+  static handle cast(const type &src, return_value_policy /* policy */,
+                     handle /* parent */) {
+    using namespace std::chrono;
+
+    // Use overloaded function to get our duration from our source
+    // Works out if it is a duration or time_point and get the duration
+    auto d = get_duration(src);
+
+    // Lazy initialise the PyDateTime import
+    if (!PyDateTimeAPI) {
+      PyDateTime_IMPORT;
+    }
+
+    // Declare these special duration types so the conversions happen with the
+    // correct primitive types (int)
+    using dd_t = duration<int, std::ratio<86400>>;
+    using ss_t = duration<int, std::ratio<1>>;
+    using us_t = duration<int, std::micro>;
+
+    auto dd = duration_cast<dd_t>(d);
+    auto subd = d - dd;
+    auto ss = duration_cast<ss_t>(subd);
+    auto us = duration_cast<us_t>(subd - ss);
+    return PyDelta_FromDSU(dd.count(), ss.count(), us.count());
+  }
+
+  PYBIND11_TYPE_CASTER(type, _("datetime.timedelta"));
+};
+
+// This is for casting times on the system clock into datetime.datetime
+// instances
+template <typename Duration>
+class type_caster<
+    std::chrono::time_point<std::chrono::system_clock, Duration>> {
+public:
+  typedef std::chrono::time_point<std::chrono::system_clock, Duration> type;
+  bool load(handle src, bool) {
+    using namespace std::chrono;
+
+    // Lazy initialise the PyDateTime import
+    if (!PyDateTimeAPI) {
+      PyDateTime_IMPORT;
+    }
+
+    if (!src)
+      return false;
+    if (PyDateTime_Check(src.ptr())) {
+      std::tm cal;
+      cal.tm_sec = PyDateTime_DATE_GET_SECOND(src.ptr());
+      cal.tm_min = PyDateTime_DATE_GET_MINUTE(src.ptr());
+      cal.tm_hour = PyDateTime_DATE_GET_HOUR(src.ptr());
+      cal.tm_mday = PyDateTime_GET_DAY(src.ptr());
+      cal.tm_mon = PyDateTime_GET_MONTH(src.ptr()) - 1;
+      cal.tm_year = PyDateTime_GET_YEAR(src.ptr()) - 1900;
+      cal.tm_isdst = -1;
+
+      value = system_clock::from_time_t(std::mktime(&cal)) +
+              microseconds(PyDateTime_DATE_GET_MICROSECOND(src.ptr()));
+      return true;
+    } else
+      return false;
+  }
+
+  static handle
+  cast(const std::chrono::time_point<std::chrono::system_clock, Duration> &src,
+       return_value_policy /* policy */, handle /* parent */) {
+    using namespace std::chrono;
+
+    // Lazy initialise the PyDateTime import
+    if (!PyDateTimeAPI) {
+      PyDateTime_IMPORT;
+    }
+
+    std::time_t tt = system_clock::to_time_t(src);
+    // this function uses static memory so it's best to copy it out asap just in
+    // case otherwise other code that is using localtime may break this (not
+    // just python code)
+    std::tm localtime = *std::localtime(&tt);
+
+    // Declare these special duration types so the conversions happen with the
+    // correct primitive types (int)
+    using us_t = duration<int, std::micro>;
+
+    return PyDateTime_FromDateAndTime(
+        localtime.tm_year + 1900, localtime.tm_mon + 1, localtime.tm_mday,
+        localtime.tm_hour, localtime.tm_min, localtime.tm_sec,
+        (duration_cast<us_t>(src.time_since_epoch() % seconds(1))).count());
+  }
+  PYBIND11_TYPE_CASTER(type, _("datetime.datetime"));
+};
+
+// Other clocks that are not the system clock are not measured as
+// datetime.datetime objects since they are not measured on calendar time. So
+// instead we just make them timedeltas Or if they have passed us a time as a
+// float we convert that
+template <typename Clock, typename Duration>
+class type_caster<std::chrono::time_point<Clock, Duration>>
+    : public duration_caster<std::chrono::time_point<Clock, Duration>> {};
+
+template <typename Rep, typename Period>
+class type_caster<std::chrono::duration<Rep, Period>>
+    : public duration_caster<std::chrono::duration<Rep, Period>> {};
+
+NAMESPACE_END(detail)
+NAMESPACE_END(PYBIND11_NAMESPACE)