numpy 1.9.3__zip → 1.10.0__zip

numpy-1.10.0.post2/numpy/core/src/multiarray/datetime.c

@@ -0,0 +1,3821 @@
+/*
+ * This file implements core functionality for NumPy datetime.
+ *
+ * Written by Mark Wiebe (mwwiebe@gmail.com)
+ * Copyright (c) 2011 by Enthought, Inc.
+ *
+ * See LICENSE.txt for the license.
+ */
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <datetime.h>
+
+#include <time.h>
+
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#define _MULTIARRAYMODULE
+#include <numpy/arrayobject.h>
+
+#include "npy_config.h"
+#include "npy_pycompat.h"
+
+#include "numpy/arrayscalars.h"
+#include "methods.h"
+#include "_datetime.h"
+#include "datetime_strings.h"
+
+/*
+ * Imports the PyDateTime functions so we can create these objects.
+ * This is called during module initialization
+ */
+NPY_NO_EXPORT void
+numpy_pydatetime_import(void)
+{
+    PyDateTime_IMPORT;
+}
+
+/* Exported as DATETIMEUNITS in multiarraymodule.c */
+NPY_NO_EXPORT char *_datetime_strings[NPY_DATETIME_NUMUNITS] = {
+    "Y",
+    "M",
+    "W",
+    "<invalid>",
+    "D",
+    "h",
+    "m",
+    "s",
+    "ms",
+    "us",
+    "ns",
+    "ps",
+    "fs",
+    "as",
+    "generic"
+};
+
+/* Days per month, regular year and leap year */
+NPY_NO_EXPORT int _days_per_month_table[2][12] = {
+    { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
+    { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
+};
+
+/*
+ * Returns 1 if the given year is a leap year, 0 otherwise.
+ */
+NPY_NO_EXPORT int
+is_leapyear(npy_int64 year)
+{
+    return (year & 0x3) == 0 && /* year % 4 == 0 */
+           ((year % 100) != 0 ||
+            (year % 400) == 0);
+}
+
+/*
+ * Calculates the days offset from the 1970 epoch.
+ */
+NPY_NO_EXPORT npy_int64
+get_datetimestruct_days(const npy_datetimestruct *dts)
+{
+    int i, month;
+    npy_int64 year, days = 0;
+    int *month_lengths;
+
+    year = dts->year - 1970;
+    days = year * 365;
+
+    /* Adjust for leap years */
+    if (days >= 0) {
+        /*
+         * 1968 is the closest leap year before 1970.
+         * Exclude the current year, so add 1.
+         */
+        year += 1;
+        /* Add one day for each 4 years */
+        days += year / 4;
+        /* 1900 is the closest previous year divisible by 100 */
+        year += 68;
+        /* Subtract one day for each 100 years */
+        days -= year / 100;
+        /* 1600 is the closest previous year divisible by 400 */
+        year += 300;
+        /* Add one day for each 400 years */
+        days += year / 400;
+    }
+    else {
+        /*
+         * 1972 is the closest later year after 1970.
+         * Include the current year, so subtract 2.
+         */
+        year -= 2;
+        /* Subtract one day for each 4 years */
+        days += year / 4;
+        /* 2000 is the closest later year divisible by 100 */
+        year -= 28;
+        /* Add one day for each 100 years */
+        days -= year / 100;
+        /* 2000 is also the closest later year divisible by 400 */
+        /* Subtract one day for each 400 years */
+        days += year / 400;
+    }
+
+    month_lengths = _days_per_month_table[is_leapyear(dts->year)];
+    month = dts->month - 1;
+
+    /* Add the months */
+    for (i = 0; i < month; ++i) {
+        days += month_lengths[i];
+    }
+
+    /* Add the days */
+    days += dts->day - 1;
+
+    return days;
+}
+
+/*
+ * Calculates the minutes offset from the 1970 epoch.
+ */
+NPY_NO_EXPORT npy_int64
+get_datetimestruct_minutes(const npy_datetimestruct *dts)
+{
+    npy_int64 days = get_datetimestruct_days(dts) * 24 * 60;
+    days += dts->hour * 60;
+    days += dts->min;
+
+    return days;
+}
+
+/*
+ * Modifies '*days_' to be the day offset within the year,
+ * and returns the year.
+ */
+static npy_int64
+days_to_yearsdays(npy_int64 *days_)
+{
+    const npy_int64 days_per_400years = (400*365 + 100 - 4 + 1);
+    /* Adjust so it's relative to the year 2000 (divisible by 400) */
+    npy_int64 days = (*days_) - (365*30 + 7);
+    npy_int64 year;
+
+    /* Break down the 400 year cycle to get the year and day within the year */
+    if (days >= 0) {
+        year = 400 * (days / days_per_400years);
+        days = days % days_per_400years;
+    }
+    else {
+        year = 400 * ((days - (days_per_400years - 1)) / days_per_400years);
+        days = days % days_per_400years;
+        if (days < 0) {
+            days += days_per_400years;
+        }
+    }
+
+    /* Work out the year/day within the 400 year cycle */
+    if (days >= 366) {
+        year += 100 * ((days-1) / (100*365 + 25 - 1));
+        days = (days-1) % (100*365 + 25 - 1);
+        if (days >= 365) {
+            year += 4 * ((days+1) / (4*365 + 1));
+            days = (days+1) % (4*365 + 1);
+            if (days >= 366) {
+                year += (days-1) / 365;
+                days = (days-1) % 365;
+            }
+        }
+    }
+
+    *days_ = days;
+    return year + 2000;
+}
+
+/* Extracts the month number from a 'datetime64[D]' value */
+NPY_NO_EXPORT int
+days_to_month_number(npy_datetime days)
+{
+    npy_int64 year;
+    int *month_lengths, i;
+
+    year = days_to_yearsdays(&days);
+    month_lengths = _days_per_month_table[is_leapyear(year)];
+
+    for (i = 0; i < 12; ++i) {
+        if (days < month_lengths[i]) {
+            return i + 1;
+        }
+        else {
+            days -= month_lengths[i];
+        }
+    }
+
+    /* Should never get here */
+    return 1;
+}
+
+/*
+ * Fills in the year, month, day in 'dts' based on the days
+ * offset from 1970.
+ */
+static void
+set_datetimestruct_days(npy_int64 days, npy_datetimestruct *dts)
+{
+    int *month_lengths, i;
+
+    dts->year = days_to_yearsdays(&days);
+    month_lengths = _days_per_month_table[is_leapyear(dts->year)];
+
+    for (i = 0; i < 12; ++i) {
+        if (days < month_lengths[i]) {
+            dts->month = i + 1;
+            dts->day = (int)days + 1;
+            return;
+        }
+        else {
+            days -= month_lengths[i];
+        }
+    }
+}
+
+/*
+ * Converts a datetime from a datetimestruct to a datetime based
+ * on some metadata. The date is assumed to be valid.
+ *
+ * TODO: If meta->num is really big, there could be overflow
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT int
+convert_datetimestruct_to_datetime(PyArray_DatetimeMetaData *meta,
+                                    const npy_datetimestruct *dts,
+                                    npy_datetime *out)
+{
+    npy_datetime ret;
+    NPY_DATETIMEUNIT base = meta->base;
+
+    /* If the datetimestruct is NaT, return NaT */
+    if (dts->year == NPY_DATETIME_NAT) {
+        *out = NPY_DATETIME_NAT;
+        return 0;
+    }
+
+    /* Cannot instantiate a datetime with generic units */
+    if (meta->base == NPY_FR_GENERIC) {
+        PyErr_SetString(PyExc_ValueError,
+                    "Cannot create a NumPy datetime other than NaT "
+                    "with generic units");
+        return -1;
+    }
+
+    if (base == NPY_FR_Y) {
+        /* Truncate to the year */
+        ret = dts->year - 1970;
+    }
+    else if (base == NPY_FR_M) {
+        /* Truncate to the month */
+        ret = 12 * (dts->year - 1970) + (dts->month - 1);
+    }
+    else {
+        /* Otherwise calculate the number of days to start */
+        npy_int64 days = get_datetimestruct_days(dts);
+
+        switch (base) {
+            case NPY_FR_W:
+                /* Truncate to weeks */
+                if (days >= 0) {
+                    ret = days / 7;
+                }
+                else {
+                    ret = (days - 6) / 7;
+                }
+                break;
+            case NPY_FR_D:
+                ret = days;
+                break;
+            case NPY_FR_h:
+                ret = days * 24 +
+                      dts->hour;
+                break;
+            case NPY_FR_m:
+                ret = (days * 24 +
+                      dts->hour) * 60 +
+                      dts->min;
+                break;
+            case NPY_FR_s:
+                ret = ((days * 24 +
+                      dts->hour) * 60 +
+                      dts->min) * 60 +
+                      dts->sec;
+                break;
+            case NPY_FR_ms:
+                ret = (((days * 24 +
+                      dts->hour) * 60 +
+                      dts->min) * 60 +
+                      dts->sec) * 1000 +
+                      dts->us / 1000;
+                break;
+            case NPY_FR_us:
+                ret = (((days * 24 +
+                      dts->hour) * 60 +
+                      dts->min) * 60 +
+                      dts->sec) * 1000000 +
+                      dts->us;
+                break;
+            case NPY_FR_ns:
+                ret = ((((days * 24 +
+                      dts->hour) * 60 +
+                      dts->min) * 60 +
+                      dts->sec) * 1000000 +
+                      dts->us) * 1000 +
+                      dts->ps / 1000;
+                break;
+            case NPY_FR_ps:
+                ret = ((((days * 24 +
+                      dts->hour) * 60 +
+                      dts->min) * 60 +
+                      dts->sec) * 1000000 +
+                      dts->us) * 1000000 +
+                      dts->ps;
+                break;
+            case NPY_FR_fs:
+                /* only 2.6 hours */
+                ret = (((((days * 24 +
+                      dts->hour) * 60 +
+                      dts->min) * 60 +
+                      dts->sec) * 1000000 +
+                      dts->us) * 1000000 +
+                      dts->ps) * 1000 +
+                      dts->as / 1000;
+                break;
+            case NPY_FR_as:
+                /* only 9.2 secs */
+                ret = (((((days * 24 +
+                      dts->hour) * 60 +
+                      dts->min) * 60 +
+                      dts->sec) * 1000000 +
+                      dts->us) * 1000000 +
+                      dts->ps) * 1000000 +
+                      dts->as;
+                break;
+            default:
+                /* Something got corrupted */
+                PyErr_SetString(PyExc_ValueError,
+                        "NumPy datetime metadata with corrupt unit value");
+                return -1;
+        }
+    }
+
+    /* Divide by the multiplier */
+    if (meta->num > 1) {
+        if (ret >= 0) {
+            ret /= meta->num;
+        }
+        else {
+            ret = (ret - meta->num + 1) / meta->num;
+        }
+    }
+
+    *out = ret;
+
+    return 0;
+}
+
+/*NUMPY_API
+ * Create a datetime value from a filled datetime struct and resolution unit.
+ *
+ * TO BE REMOVED - NOT USED INTERNALLY.
+ */
+NPY_NO_EXPORT npy_datetime
+PyArray_DatetimeStructToDatetime(NPY_DATETIMEUNIT fr, npy_datetimestruct *d)
+{
+    PyErr_SetString(PyExc_RuntimeError,
+            "The NumPy PyArray_DatetimeStructToDatetime function has "
+            "been removed");
+    return -1;
+}
+
+/*NUMPY_API
+ * Create a timdelta value from a filled timedelta struct and resolution unit.
+ *
+ * TO BE REMOVED - NOT USED INTERNALLY.
+ */
+NPY_NO_EXPORT npy_datetime
+PyArray_TimedeltaStructToTimedelta(NPY_DATETIMEUNIT fr, npy_timedeltastruct *d)
+{
+    PyErr_SetString(PyExc_RuntimeError,
+            "The NumPy PyArray_TimedeltaStructToTimedelta function has "
+            "been removed");
+    return -1;
+}
+
+/*
+ * Converts a datetime based on the given metadata into a datetimestruct
+ */
+NPY_NO_EXPORT int
+convert_datetime_to_datetimestruct(PyArray_DatetimeMetaData *meta,
+                                    npy_datetime dt,
+                                    npy_datetimestruct *out)
+{
+    npy_int64 perday;
+
+    /* Initialize the output to all zeros */
+    memset(out, 0, sizeof(npy_datetimestruct));
+    out->year = 1970;
+    out->month = 1;
+    out->day = 1;
+
+    /* NaT is signaled in the year */
+    if (dt == NPY_DATETIME_NAT) {
+        out->year = NPY_DATETIME_NAT;
+        return 0;
+    }
+
+    /* Datetimes can't be in generic units */
+    if (meta->base == NPY_FR_GENERIC) {
+        PyErr_SetString(PyExc_ValueError,
+                    "Cannot convert a NumPy datetime value other than NaT "
+                    "with generic units");
+        return -1;
+    }
+
+    /* TODO: Change to a mechanism that avoids the potential overflow */
+    dt *= meta->num;
+
+    /*
+     * Note that care must be taken with the / and % operators
+     * for negative values.
+     */
+    switch (meta->base) {
+        case NPY_FR_Y:
+            out->year = 1970 + dt;
+            break;
+
+        case NPY_FR_M:
+            if (dt >= 0) {
+                out->year  = 1970 + dt / 12;
+                out->month = dt % 12 + 1;
+            }
+            else {
+                out->year  = 1969 + (dt + 1) / 12;
+                out->month = 12 + (dt + 1)% 12;
+            }
+            break;
+
+        case NPY_FR_W:
+            /* A week is 7 days */
+            set_datetimestruct_days(dt * 7, out);
+            break;
+
+        case NPY_FR_D:
+            set_datetimestruct_days(dt, out);
+            break;
+
+        case NPY_FR_h:
+            perday = 24LL;
+
+            if (dt >= 0) {
+                set_datetimestruct_days(dt / perday, out);
+                dt  = dt % perday;
+            }
+            else {
+                set_datetimestruct_days((dt - (perday-1)) / perday, out);
+                dt = (perday-1) + (dt + 1) % perday;
+            }
+            out->hour = (int)dt;
+            break;
+
+        case NPY_FR_m:
+            perday = 24LL * 60;
+
+            if (dt >= 0) {
+                set_datetimestruct_days(dt / perday, out);
+                dt  = dt % perday;
+            }
+            else {
+                set_datetimestruct_days((dt - (perday-1)) / perday, out);
+                dt = (perday-1) + (dt + 1) % perday;
+            }
+            out->hour = (int)(dt / 60);
+            out->min = (int)(dt % 60);
+            break;
+
+        case NPY_FR_s:
+            perday = 24LL * 60 * 60;
+
+            if (dt >= 0) {
+                set_datetimestruct_days(dt / perday, out);
+                dt  = dt % perday;
+            }
+            else {
+                set_datetimestruct_days((dt - (perday-1)) / perday, out);
+                dt = (perday-1) + (dt + 1) % perday;
+            }
+            out->hour = (int)(dt / (60*60));
+            out->min = (int)((dt / 60) % 60);
+            out->sec = (int)(dt % 60);
+            break;
+
+        case NPY_FR_ms:
+            perday = 24LL * 60 * 60 * 1000;
+
+            if (dt >= 0) {
+                set_datetimestruct_days(dt / perday, out);
+                dt  = dt % perday;
+            }
+            else {
+                set_datetimestruct_days((dt - (perday-1)) / perday, out);
+                dt = (perday-1) + (dt + 1) % perday;
+            }
+            out->hour = (int)(dt / (60*60*1000LL));
+            out->min = (int)((dt / (60*1000LL)) % 60);
+            out->sec = (int)((dt / 1000LL) % 60);
+            out->us = (int)((dt % 1000LL) * 1000);
+            break;
+
+        case NPY_FR_us:
+            perday = 24LL * 60LL * 60LL * 1000LL * 1000LL;
+
+            if (dt >= 0) {
+                set_datetimestruct_days(dt / perday, out);
+                dt  = dt % perday;
+            }
+            else {
+                set_datetimestruct_days((dt - (perday-1)) / perday, out);
+                dt = (perday-1) + (dt + 1) % perday;
+            }
+            out->hour = (int)(dt / (60*60*1000000LL));
+            out->min = (int)((dt / (60*1000000LL)) % 60);
+            out->sec = (int)((dt / 1000000LL) % 60);
+            out->us = (int)(dt % 1000000LL);
+            break;
+
+        case NPY_FR_ns:
+            perday = 24LL * 60LL * 60LL * 1000LL * 1000LL * 1000LL;
+
+            if (dt >= 0) {
+                set_datetimestruct_days(dt / perday, out);
+                dt  = dt % perday;
+            }
+            else {
+                set_datetimestruct_days((dt - (perday-1)) / perday, out);
+                dt = (perday-1) + (dt + 1) % perday;
+            }
+            out->hour = (int)(dt / (60*60*1000000000LL));
+            out->min = (int)((dt / (60*1000000000LL)) % 60);
+            out->sec = (int)((dt / 1000000000LL) % 60);
+            out->us = (int)((dt / 1000LL) % 1000000LL);
+            out->ps = (int)((dt % 1000LL) * 1000);
+            break;
+
+        case NPY_FR_ps:
+            perday = 24LL * 60 * 60 * 1000 * 1000 * 1000 * 1000;
+
+            if (dt >= 0) {
+                set_datetimestruct_days(dt / perday, out);
+                dt  = dt % perday;
+            }
+            else {
+                set_datetimestruct_days((dt - (perday-1)) / perday, out);
+                dt = (perday-1) + (dt + 1) % perday;
+            }
+            out->hour = (int)(dt / (60*60*1000000000000LL));
+            out->min = (int)((dt / (60*1000000000000LL)) % 60);
+            out->sec = (int)((dt / 1000000000000LL) % 60);
+            out->us = (int)((dt / 1000000LL) % 1000000LL);
+            out->ps = (int)(dt % 1000000LL);
+            break;
+
+        case NPY_FR_fs:
+            /* entire range is only +- 2.6 hours */
+            if (dt >= 0) {
+                out->hour = (int)(dt / (60*60*1000000000000000LL));
+                out->min = (int)((dt / (60*1000000000000000LL)) % 60);
+                out->sec = (int)((dt / 1000000000000000LL) % 60);
+                out->us = (int)((dt / 1000000000LL) % 1000000LL);
+                out->ps = (int)((dt / 1000LL) % 1000000LL);
+                out->as = (int)((dt % 1000LL) * 1000);
+            }
+            else {
+                npy_datetime minutes;
+
+                minutes = dt / (60*1000000000000000LL);
+                dt = dt % (60*1000000000000000LL);
+                if (dt < 0) {
+                    dt += (60*1000000000000000LL);
+                    --minutes;
+                }
+                /* Offset the negative minutes */
+                add_minutes_to_datetimestruct(out, minutes);
+                out->sec = (int)((dt / 1000000000000000LL) % 60);
+                out->us = (int)((dt / 1000000000LL) % 1000000LL);
+                out->ps = (int)((dt / 1000LL) % 1000000LL);
+                out->as = (int)((dt % 1000LL) * 1000);
+            }
+            break;
+
+        case NPY_FR_as:
+            /* entire range is only +- 9.2 seconds */
+            if (dt >= 0) {
+                out->sec = (int)((dt / 1000000000000000000LL) % 60);
+                out->us = (int)((dt / 1000000000000LL) % 1000000LL);
+                out->ps = (int)((dt / 1000000LL) % 1000000LL);
+                out->as = (int)(dt % 1000000LL);
+            }
+            else {
+                npy_datetime seconds;
+
+                seconds = dt / 1000000000000000000LL;
+                dt = dt % 1000000000000000000LL;
+                if (dt < 0) {
+                    dt += 1000000000000000000LL;
+                    --seconds;
+                }
+                /* Offset the negative seconds */
+                add_seconds_to_datetimestruct(out, seconds);
+                out->us = (int)((dt / 1000000000000LL) % 1000000LL);
+                out->ps = (int)((dt / 1000000LL) % 1000000LL);
+                out->as = (int)(dt % 1000000LL);
+            }
+            break;
+
+        default:
+            PyErr_SetString(PyExc_RuntimeError,
+                        "NumPy datetime metadata is corrupted with invalid "
+                        "base unit");
+            return -1;
+    }
+
+    return 0;
+}
+
+
+/*NUMPY_API
+ * Fill the datetime struct from the value and resolution unit.
+ *
+ * TO BE REMOVED - NOT USED INTERNALLY.
+ */
+NPY_NO_EXPORT void
+PyArray_DatetimeToDatetimeStruct(npy_datetime val, NPY_DATETIMEUNIT fr,
+                                 npy_datetimestruct *result)
+{
+    PyErr_SetString(PyExc_RuntimeError,
+            "The NumPy PyArray_DatetimeToDatetimeStruct function has "
+            "been removed");
+    memset(result, -1, sizeof(npy_datetimestruct));
+}
+
+/*
+ * FIXME: Overflow is not handled at all
+ *   To convert from Years or Months,
+ *   multiplication by the average is done
+ */
+
+/*NUMPY_API
+ * Fill the timedelta struct from the timedelta value and resolution unit.
+ *
+ * TO BE REMOVED - NOT USED INTERNALLY.
+ */
+NPY_NO_EXPORT void
+PyArray_TimedeltaToTimedeltaStruct(npy_timedelta val, NPY_DATETIMEUNIT fr,
+                                 npy_timedeltastruct *result)
+{
+    PyErr_SetString(PyExc_RuntimeError,
+            "The NumPy PyArray_TimedeltaToTimedeltaStruct function has "
+            "been removed");
+    memset(result, -1, sizeof(npy_timedeltastruct));
+}
+
+/*
+ * Creates a datetime or timedelta dtype using a copy of the provided metadata.
+ */
+NPY_NO_EXPORT PyArray_Descr *
+create_datetime_dtype(int type_num, PyArray_DatetimeMetaData *meta)
+{
+    PyArray_Descr *dtype = NULL;
+    PyArray_DatetimeMetaData *dt_data;
+
+    /* Create a default datetime or timedelta */
+    if (type_num == NPY_DATETIME || type_num == NPY_TIMEDELTA) {
+        dtype = PyArray_DescrNewFromType(type_num);
+    }
+    else {
+        PyErr_SetString(PyExc_RuntimeError,
+                "Asked to create a datetime type with a non-datetime "
+                "type number");
+        return NULL;
+    }
+
+    if (dtype == NULL) {
+        return NULL;
+    }
+
+    dt_data = &(((PyArray_DatetimeDTypeMetaData *)dtype->c_metadata)->meta);
+
+    /* Copy the metadata */
+    *dt_data = *meta;
+
+    return dtype;
+}
+
+/*
+ * Creates a datetime or timedelta dtype using the given unit.
+ */
+NPY_NO_EXPORT PyArray_Descr *
+create_datetime_dtype_with_unit(int type_num, NPY_DATETIMEUNIT unit)
+{
+    PyArray_DatetimeMetaData meta;
+    meta.base = unit;
+    meta.num = 1;
+    return create_datetime_dtype(type_num, &meta);
+}
+
+/*
+ * This function returns a pointer to the DateTimeMetaData
+ * contained within the provided datetime dtype.
+ */
+NPY_NO_EXPORT PyArray_DatetimeMetaData *
+get_datetime_metadata_from_dtype(PyArray_Descr *dtype)
+{
+    if (!PyDataType_ISDATETIME(dtype)) {
+        PyErr_SetString(PyExc_TypeError,
+                "cannot get datetime metadata from non-datetime type");
+        return NULL;
+    }
+
+    return &(((PyArray_DatetimeDTypeMetaData *)dtype->c_metadata)->meta);
+}
+
+/*
+ * Converts a substring given by 'str' and 'len' into
+ * a date time unit multiplier + enum value, which are populated
+ * into out_meta. Other metadata is left along.
+ *
+ * 'metastr' is only used in the error message, and may be NULL.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT int
+parse_datetime_extended_unit_from_string(char *str, Py_ssize_t len,
+                                    char *metastr,
+                                    PyArray_DatetimeMetaData *out_meta)
+{
+    char *substr = str, *substrend = NULL;
+    int den = 1;
+
+    /* First comes an optional integer multiplier */
+    out_meta->num = (int)strtol(substr, &substrend, 10);
+    if (substr == substrend) {
+        out_meta->num = 1;
+    }
+    substr = substrend;
+
+    /* Next comes the unit itself, followed by either '/' or the string end */
+    substrend = substr;
+    while (substrend-str < len && *substrend != '/') {
+        ++substrend;
+    }
+    if (substr == substrend) {
+        goto bad_input;
+    }
+    out_meta->base = parse_datetime_unit_from_string(substr,
+                                        substrend-substr, metastr);
+    if (out_meta->base == -1) {
+        return -1;
+    }
+    substr = substrend;
+
+    /* Next comes an optional integer denominator */
+    if (substr-str < len && *substr == '/') {
+        substr++;
+        den = (int)strtol(substr, &substrend, 10);
+        /* If the '/' exists, there must be a number followed by ']' */
+        if (substr == substrend || *substrend != ']') {
+            goto bad_input;
+        }
+        substr = substrend + 1;
+    }
+    else if (substr-str != len) {
+        goto bad_input;
+    }
+
+    if (den != 1) {
+        if (convert_datetime_divisor_to_multiple(
+                                out_meta, den, metastr) < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+
+bad_input:
+    if (metastr != NULL) {
+        PyErr_Format(PyExc_TypeError,
+                "Invalid datetime metadata string \"%s\" at position %d",
+                metastr, (int)(substr-metastr));
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+                "Invalid datetime metadata string \"%s\"",
+                str);
+    }
+
+    return -1;
+}
+
+/*
+ * Parses the metadata string into the metadata C structure.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT int
+parse_datetime_metadata_from_metastr(char *metastr, Py_ssize_t len,
+                                    PyArray_DatetimeMetaData *out_meta)
+{
+    char *substr = metastr, *substrend = NULL;
+
+    /* Treat the empty string as generic units */
+    if (len == 0) {
+        out_meta->base = NPY_FR_GENERIC;
+        out_meta->num = 1;
+
+        return 0;
+    }
+
+    /* The metadata string must start with a '[' */
+    if (len < 3 || *substr++ != '[') {
+        goto bad_input;
+    }
+
+    substrend = substr;
+    while (substrend - metastr < len && *substrend != ']') {
+        ++substrend;
+    }
+    if (substrend - metastr == len || substr == substrend) {
+        substr = substrend;
+        goto bad_input;
+    }
+
+    /* Parse the extended unit inside the [] */
+    if (parse_datetime_extended_unit_from_string(substr, substrend-substr,
+                                                    metastr, out_meta) < 0) {
+        return -1;
+    }
+
+    substr = substrend+1;
+
+    if (substr - metastr != len) {
+        goto bad_input;
+    }
+
+    return 0;
+
+bad_input:
+    if (substr != metastr) {
+        PyErr_Format(PyExc_TypeError,
+                "Invalid datetime metadata string \"%s\" at position %d",
+                metastr, (int)(substr-metastr));
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+                "Invalid datetime metadata string \"%s\"",
+                metastr);
+    }
+
+    return -1;
+}
+
+/*
+ * Converts a datetype dtype string into a dtype descr object.
+ * The "type" string should be NULL-terminated.
+ */
+NPY_NO_EXPORT PyArray_Descr *
+parse_dtype_from_datetime_typestr(char *typestr, Py_ssize_t len)
+{
+    PyArray_DatetimeMetaData meta;
+    char *metastr = NULL;
+    int is_timedelta = 0;
+    Py_ssize_t metalen = 0;
+
+    if (len < 2) {
+        PyErr_Format(PyExc_TypeError,
+                "Invalid datetime typestr \"%s\"",
+                typestr);
+        return NULL;
+    }
+
+    /*
+     * First validate that the root is correct,
+     * and get the metadata string address
+     */
+    if (typestr[0] == 'm' && typestr[1] == '8') {
+        is_timedelta = 1;
+        metastr = typestr + 2;
+        metalen = len - 2;
+    }
+    else if (typestr[0] == 'M' && typestr[1] == '8') {
+        is_timedelta = 0;
+        metastr = typestr + 2;
+        metalen = len - 2;
+    }
+    else if (len >= 11 && strncmp(typestr, "timedelta64", 11) == 0) {
+        is_timedelta = 1;
+        metastr = typestr + 11;
+        metalen = len - 11;
+    }
+    else if (len >= 10 && strncmp(typestr, "datetime64", 10) == 0) {
+        is_timedelta = 0;
+        metastr = typestr + 10;
+        metalen = len - 10;
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+                "Invalid datetime typestr \"%s\"",
+                typestr);
+        return NULL;
+    }
+
+    /* Parse the metadata string into a metadata struct */
+    if (parse_datetime_metadata_from_metastr(metastr, metalen, &meta) < 0) {
+        return NULL;
+    }
+
+    return create_datetime_dtype(is_timedelta ? NPY_TIMEDELTA : NPY_DATETIME,
+                                    &meta);
+}
+
+static NPY_DATETIMEUNIT _multiples_table[16][4] = {
+    {12, 52, 365},                            /* NPY_FR_Y */
+    {NPY_FR_M, NPY_FR_W, NPY_FR_D},
+    {4,  30, 720},                            /* NPY_FR_M */
+    {NPY_FR_W, NPY_FR_D, NPY_FR_h},
+    {7,  168, 10080},                         /* NPY_FR_W */
+    {NPY_FR_D, NPY_FR_h, NPY_FR_m},
+    {0},                                      /* Gap for removed NPY_FR_B */
+    {0},
+    {24, 1440, 86400},                        /* NPY_FR_D */
+    {NPY_FR_h, NPY_FR_m, NPY_FR_s},
+    {60, 3600},                               /* NPY_FR_h */
+    {NPY_FR_m, NPY_FR_s},
+    {60, 60000},                              /* NPY_FR_m */
+    {NPY_FR_s, NPY_FR_ms},
+    {1000, 1000000},                          /* >=NPY_FR_s */
+    {0, 0}
+};
+
+
+
+/*
+ * Translate divisors into multiples of smaller units.
+ * 'metastr' is used for the error message if the divisor doesn't work,
+ * and can be NULL if the metadata didn't come from a string.
+ *
+ * This function only affects the 'base' and 'num' values in the metadata.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT int
+convert_datetime_divisor_to_multiple(PyArray_DatetimeMetaData *meta,
+                                    int den, char *metastr)
+{
+    int i, num, ind;
+    NPY_DATETIMEUNIT *totry;
+    NPY_DATETIMEUNIT *baseunit;
+    int q, r;
+
+    if (meta->base == NPY_FR_GENERIC) {
+        PyErr_SetString(PyExc_ValueError,
+            "Can't use 'den' divisor with generic units");
+        return -1;
+    }
+
+    ind = ((int)meta->base - (int)NPY_FR_Y)*2;
+    totry = _multiples_table[ind];
+    baseunit = _multiples_table[ind + 1];
+
+    num = 3;
+    if (meta->base == NPY_FR_W) {
+        num = 4;
+    }
+    else if (meta->base > NPY_FR_D) {
+        num = 2;
+    }
+    if (meta->base >= NPY_FR_s) {
+        ind = ((int)NPY_FR_s - (int)NPY_FR_Y)*2;
+        totry = _multiples_table[ind];
+        baseunit = _multiples_table[ind + 1];
+        baseunit[0] = meta->base + 1;
+        baseunit[1] = meta->base + 2;
+        if (meta->base == NPY_FR_as - 1) {
+            num = 1;
+        }
+        if (meta->base == NPY_FR_as) {
+            num = 0;
+        }
+    }
+
+    for (i = 0; i < num; i++) {
+        q = totry[i] / den;
+        r = totry[i] % den;
+        if (r == 0) {
+            break;
+        }
+    }
+    if (i == num) {
+        if (metastr == NULL) {
+            PyErr_Format(PyExc_ValueError,
+                    "divisor (%d) is not a multiple of a lower-unit "
+                    "in datetime metadata", den);
+        }
+        else {
+            PyErr_Format(PyExc_ValueError,
+                    "divisor (%d) is not a multiple of a lower-unit "
+                    "in datetime metadata \"%s\"", den, metastr);
+        }
+        return -1;
+    }
+    meta->base = baseunit[i];
+    meta->num *= q;
+
+    return 0;
+}
+
+/*
+ * Lookup table for factors between datetime units, except
+ * for years and months.
+ */
+static npy_uint32
+_datetime_factors[] = {
+    1,  /* Years - not used */
+    1,  /* Months - not used */
+    7,  /* Weeks -> Days */
+    1,  /* Business Days - was removed but a gap still exists in the enum */
+    24, /* Days -> Hours */
+    60, /* Hours -> Minutes */
+    60, /* Minutes -> Seconds */
+    1000,
+    1000,
+    1000,
+    1000,
+    1000,
+    1000,
+    1,   /* Attoseconds are the smallest base unit */
+    0    /* Generic units don't have a conversion */
+};
+
+/*
+ * Returns the scale factor between the units. Does not validate
+ * that bigbase represents larger units than littlebase, or that
+ * the units are not generic.
+ *
+ * Returns 0 if there is an overflow.
+ */
+static npy_uint64
+get_datetime_units_factor(NPY_DATETIMEUNIT bigbase, NPY_DATETIMEUNIT littlebase)
+{
+    npy_uint64 factor = 1;
+    int unit = (int)bigbase;
+    while (littlebase > unit) {
+        factor *= _datetime_factors[unit];
+        /*
+         * Detect overflow by disallowing the top 16 bits to be 1.
+         * That alows a margin of error much bigger than any of
+         * the datetime factors.
+         */
+        if (factor&0xff00000000000000ULL) {
+            return 0;
+        }
+        ++unit;
+    }
+    return factor;
+}
+
+/* Euclidean algorithm on two positive numbers */
+static npy_uint64
+_uint64_euclidean_gcd(npy_uint64 x, npy_uint64 y)
+{
+    npy_uint64 tmp;
+
+    if (x > y) {
+        tmp = x;
+        x = y;
+        y = tmp;
+    }
+    while (x != y && y != 0) {
+        tmp = x % y;
+        x = y;
+        y = tmp;
+    }
+
+    return x;
+}
+
+/*
+ * Computes the conversion factor to convert data with 'src_meta' metadata
+ * into data with 'dst_meta' metadata.
+ *
+ * If overflow occurs, both out_num and out_denom are set to 0, but
+ * no error is set.
+ */
+NPY_NO_EXPORT void
+get_datetime_conversion_factor(PyArray_DatetimeMetaData *src_meta,
+                                PyArray_DatetimeMetaData *dst_meta,
+                                npy_int64 *out_num, npy_int64 *out_denom)
+{
+    int src_base, dst_base, swapped;
+    npy_uint64 num = 1, denom = 1, tmp, gcd;
+
+    /* Generic units change to the destination with no conversion factor */
+    if (src_meta->base == NPY_FR_GENERIC) {
+        *out_num = 1;
+        *out_denom = 1;
+        return;
+    }
+    /*
+     * Converting to a generic unit from something other than a generic
+     * unit is an error.
+     */
+    else if (dst_meta->base == NPY_FR_GENERIC) {
+        PyErr_SetString(PyExc_ValueError,
+                    "Cannot convert from specific units to generic "
+                    "units in NumPy datetimes or timedeltas");
+        *out_num = 0;
+        *out_denom = 0;
+        return;
+    }
+
+    if (src_meta->base <= dst_meta->base) {
+        src_base = src_meta->base;
+        dst_base = dst_meta->base;
+        swapped = 0;
+    }
+    else {
+        src_base = dst_meta->base;
+        dst_base = src_meta->base;
+        swapped = 1;
+    }
+
+    if (src_base != dst_base) {
+        /*
+         * Conversions between years/months and other units use
+         * the factor averaged over the 400 year leap year cycle.
+         */
+        if (src_base == NPY_FR_Y) {
+            if (dst_base == NPY_FR_M) {
+                num *= 12;
+            }
+            else if (dst_base == NPY_FR_W) {
+                num *= (97 + 400*365);
+                denom *= 400*7;
+            }
+            else {
+                /* Year -> Day */
+                num *= (97 + 400*365);
+                denom *= 400;
+                /* Day -> dst_base */
+                num *= get_datetime_units_factor(NPY_FR_D, dst_base);
+            }
+        }
+        else if (src_base == NPY_FR_M) {
+            if (dst_base == NPY_FR_W) {
+                num *= (97 + 400*365);
+                denom *= 400*12*7;
+            }
+            else {
+                /* Month -> Day */
+                num *= (97 + 400*365);
+                denom *= 400*12;
+                /* Day -> dst_base */
+                num *= get_datetime_units_factor(NPY_FR_D, dst_base);
+            }
+        }
+        else {
+            num *= get_datetime_units_factor(src_base, dst_base);
+        }
+    }
+
+    /* If something overflowed, make both num and denom 0 */
+    if (denom == 0 || num == 0) {
+        PyErr_Format(PyExc_OverflowError,
+                    "Integer overflow while computing the conversion "
+                    "factor between NumPy datetime units %s and %s",
+                    _datetime_strings[src_base],
+                    _datetime_strings[dst_base]);
+        *out_num = 0;
+        *out_denom = 0;
+        return;
+    }
+
+    /* Swap the numerator and denominator if necessary */
+    if (swapped) {
+        tmp = num;
+        num = denom;
+        denom = tmp;
+    }
+
+    num *= src_meta->num;
+    denom *= dst_meta->num;
+
+    /* Return as a fraction in reduced form */
+    gcd = _uint64_euclidean_gcd(num, denom);
+    *out_num = (npy_int64)(num / gcd);
+    *out_denom = (npy_int64)(denom / gcd);
+}
+
+/*
+ * Determines whether the 'divisor' metadata divides evenly into
+ * the 'dividend' metadata.
+ */
+NPY_NO_EXPORT npy_bool
+datetime_metadata_divides(
+                        PyArray_DatetimeMetaData *dividend,
+                        PyArray_DatetimeMetaData *divisor,
+                        int strict_with_nonlinear_units)
+{
+    npy_uint64 num1, num2;
+
+    /* Generic units divide into anything */
+    if (divisor->base == NPY_FR_GENERIC) {
+        return 1;
+    }
+    /* Non-generic units never divide into generic units */
+    else if (dividend->base == NPY_FR_GENERIC) {
+        return 0;
+    }
+
+    num1 = (npy_uint64)dividend->num;
+    num2 = (npy_uint64)divisor->num;
+
+    /* If the bases are different, factor in a conversion */
+    if (dividend->base != divisor->base) {
+        /*
+         * Years and Months are incompatible with
+         * all other units (except years and months are compatible
+         * with each other).
+         */
+        if (dividend->base == NPY_FR_Y) {
+            if (divisor->base == NPY_FR_M) {
+                num1 *= 12;
+            }
+            else if (strict_with_nonlinear_units) {
+                return 0;
+            }
+            else {
+                /* Could do something complicated here */
+                return 1;
+            }
+        }
+        else if (divisor->base == NPY_FR_Y) {
+            if (dividend->base == NPY_FR_M) {
+                num2 *= 12;
+            }
+            else if (strict_with_nonlinear_units) {
+                return 0;
+            }
+            else {
+                /* Could do something complicated here */
+                return 1;
+            }
+        }
+        else if (dividend->base == NPY_FR_M || divisor->base == NPY_FR_M) {
+            if (strict_with_nonlinear_units) {
+                return 0;
+            }
+            else {
+                /* Could do something complicated here */
+                return 1;
+            }
+        }
+
+        /* Take the greater base (unit sizes are decreasing in enum) */
+        if (dividend->base > divisor->base) {
+            num2 *= get_datetime_units_factor(divisor->base, dividend->base);
+            if (num2 == 0) {
+                return 0;
+            }
+        }
+        else {
+            num1 *= get_datetime_units_factor(dividend->base, divisor->base);
+            if (num1 == 0) {
+                return 0;
+            }
+        }
+    }
+
+    /* Crude, incomplete check for overflow */
+    if (num1&0xff00000000000000LL || num2&0xff00000000000000LL ) {
+        return 0;
+    }
+
+    return (num1 % num2) == 0;
+}
+
+/*
+ * This provides the casting rules for the DATETIME data type units.
+ *
+ * Notably, there is a barrier between 'date units' and 'time units'
+ * for all but 'unsafe' casting.
+ */
+NPY_NO_EXPORT npy_bool
+can_cast_datetime64_units(NPY_DATETIMEUNIT src_unit,
+                          NPY_DATETIMEUNIT dst_unit,
+                          NPY_CASTING casting)
+{
+    switch (casting) {
+        /* Allow anything with unsafe casting */
+        case NPY_UNSAFE_CASTING:
+            return 1;
+
+        /*
+         * Only enforce the 'date units' vs 'time units' barrier with
+         * 'same_kind' casting.
+         */
+        case NPY_SAME_KIND_CASTING:
+            if (src_unit == NPY_FR_GENERIC || dst_unit == NPY_FR_GENERIC) {
+                return src_unit == dst_unit;
+            }
+            else {
+                return (src_unit <= NPY_FR_D && dst_unit <= NPY_FR_D) ||
+                       (src_unit > NPY_FR_D && dst_unit > NPY_FR_D);
+            }
+
+        /*
+         * Enforce the 'date units' vs 'time units' barrier and that
+         * casting is only allowed towards more precise units with
+         * 'safe' casting.
+         */
+        case NPY_SAFE_CASTING:
+            if (src_unit == NPY_FR_GENERIC || dst_unit == NPY_FR_GENERIC) {
+                return src_unit == dst_unit;
+            }
+            else {
+                return (src_unit <= dst_unit) &&
+                       ((src_unit <= NPY_FR_D && dst_unit <= NPY_FR_D) ||
+                        (src_unit > NPY_FR_D && dst_unit > NPY_FR_D));
+            }
+
+        /* Enforce equality with 'no' or 'equiv' casting */
+        default:
+            return src_unit == dst_unit;
+    }
+}
+
+/*
+ * This provides the casting rules for the TIMEDELTA data type units.
+ *
+ * Notably, there is a barrier between the nonlinear years and
+ * months units, and all the other units.
+ */
+NPY_NO_EXPORT npy_bool
+can_cast_timedelta64_units(NPY_DATETIMEUNIT src_unit,
+                          NPY_DATETIMEUNIT dst_unit,
+                          NPY_CASTING casting)
+{
+    switch (casting) {
+        /* Allow anything with unsafe casting */
+        case NPY_UNSAFE_CASTING:
+            return 1;
+
+        /*
+         * Only enforce the 'date units' vs 'time units' barrier with
+         * 'same_kind' casting.
+         */
+        case NPY_SAME_KIND_CASTING:
+            if (src_unit == NPY_FR_GENERIC || dst_unit == NPY_FR_GENERIC) {
+                return src_unit == dst_unit;
+            }
+            else {
+                return (src_unit <= NPY_FR_M && dst_unit <= NPY_FR_M) ||
+                       (src_unit > NPY_FR_M && dst_unit > NPY_FR_M);
+            }
+
+        /*
+         * Enforce the 'date units' vs 'time units' barrier and that
+         * casting is only allowed towards more precise units with
+         * 'safe' casting.
+         */
+        case NPY_SAFE_CASTING:
+            if (src_unit == NPY_FR_GENERIC || dst_unit == NPY_FR_GENERIC) {
+                return src_unit == dst_unit;
+            }
+            else {
+                return (src_unit <= dst_unit) &&
+                       ((src_unit <= NPY_FR_M && dst_unit <= NPY_FR_M) ||
+                        (src_unit > NPY_FR_M && dst_unit > NPY_FR_M));
+            }
+
+        /* Enforce equality with 'no' or 'equiv' casting */
+        default:
+            return src_unit == dst_unit;
+    }
+}
+
+/*
+ * This provides the casting rules for the DATETIME data type metadata.
+ */
+NPY_NO_EXPORT npy_bool
+can_cast_datetime64_metadata(PyArray_DatetimeMetaData *src_meta,
+                             PyArray_DatetimeMetaData *dst_meta,
+                             NPY_CASTING casting)
+{
+    switch (casting) {
+        case NPY_UNSAFE_CASTING:
+            return 1;
+
+        case NPY_SAME_KIND_CASTING:
+            return can_cast_datetime64_units(src_meta->base, dst_meta->base,
+                                             casting);
+
+        case NPY_SAFE_CASTING:
+            return can_cast_datetime64_units(src_meta->base, dst_meta->base,
+                                                             casting) &&
+                   datetime_metadata_divides(src_meta, dst_meta, 0);
+
+        default:
+            return src_meta->base == dst_meta->base &&
+                   src_meta->num == dst_meta->num;
+    }
+}
+
+/*
+ * This provides the casting rules for the TIMEDELTA data type metadata.
+ */
+NPY_NO_EXPORT npy_bool
+can_cast_timedelta64_metadata(PyArray_DatetimeMetaData *src_meta,
+                             PyArray_DatetimeMetaData *dst_meta,
+                             NPY_CASTING casting)
+{
+    switch (casting) {
+        case NPY_UNSAFE_CASTING:
+            return 1;
+
+        case NPY_SAME_KIND_CASTING:
+            return can_cast_timedelta64_units(src_meta->base, dst_meta->base,
+                                             casting);
+
+        case NPY_SAFE_CASTING:
+            return can_cast_timedelta64_units(src_meta->base, dst_meta->base,
+                                                             casting) &&
+                   datetime_metadata_divides(src_meta, dst_meta, 1);
+
+        default:
+            return src_meta->base == dst_meta->base &&
+                   src_meta->num == dst_meta->num;
+    }
+}
+
+/*
+ * Tests whether a datetime64 can be cast from the source metadata
+ * to the destination metadata according to the specified casting rule.
+ *
+ * Returns -1 if an exception was raised, 0 otherwise.
+ */
+NPY_NO_EXPORT int
+raise_if_datetime64_metadata_cast_error(char *object_type,
+                            PyArray_DatetimeMetaData *src_meta,
+                            PyArray_DatetimeMetaData *dst_meta,
+                            NPY_CASTING casting)
+{
+    if (can_cast_datetime64_metadata(src_meta, dst_meta, casting)) {
+        return 0;
+    }
+    else {
+        PyObject *errmsg;
+        errmsg = PyUString_FromFormat("Cannot cast %s "
+                    "from metadata ", object_type);
+        errmsg = append_metastr_to_string(src_meta, 0, errmsg);
+        PyUString_ConcatAndDel(&errmsg,
+                PyUString_FromString(" to "));
+        errmsg = append_metastr_to_string(dst_meta, 0, errmsg);
+        PyUString_ConcatAndDel(&errmsg,
+                PyUString_FromFormat(" according to the rule %s",
+                        npy_casting_to_string(casting)));
+        PyErr_SetObject(PyExc_TypeError, errmsg);
+        Py_DECREF(errmsg);
+        return -1;
+    }
+}
+
+/*
+ * Tests whether a timedelta64 can be cast from the source metadata
+ * to the destination metadata according to the specified casting rule.
+ *
+ * Returns -1 if an exception was raised, 0 otherwise.
+ */
+NPY_NO_EXPORT int
+raise_if_timedelta64_metadata_cast_error(char *object_type,
+                            PyArray_DatetimeMetaData *src_meta,
+                            PyArray_DatetimeMetaData *dst_meta,
+                            NPY_CASTING casting)
+{
+    if (can_cast_timedelta64_metadata(src_meta, dst_meta, casting)) {
+        return 0;
+    }
+    else {
+        PyObject *errmsg;
+        errmsg = PyUString_FromFormat("Cannot cast %s "
+                    "from metadata ", object_type);
+        errmsg = append_metastr_to_string(src_meta, 0, errmsg);
+        PyUString_ConcatAndDel(&errmsg,
+                PyUString_FromString(" to "));
+        errmsg = append_metastr_to_string(dst_meta, 0, errmsg);
+        PyUString_ConcatAndDel(&errmsg,
+                PyUString_FromFormat(" according to the rule %s",
+                        npy_casting_to_string(casting)));
+        PyErr_SetObject(PyExc_TypeError, errmsg);
+        Py_DECREF(errmsg);
+        return -1;
+    }
+}
+
+/*
+ * Computes the GCD of the two date-time metadata values. Raises
+ * an exception if there is no reasonable GCD, such as with
+ * years and days.
+ *
+ * The result is placed in 'out_meta'.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT int
+compute_datetime_metadata_greatest_common_divisor(
+                        PyArray_DatetimeMetaData *meta1,
+                        PyArray_DatetimeMetaData *meta2,
+                        PyArray_DatetimeMetaData *out_meta,
+                        int strict_with_nonlinear_units1,
+                        int strict_with_nonlinear_units2)
+{
+    NPY_DATETIMEUNIT base;
+    npy_uint64 num1, num2, num;
+
+    /* If either unit is generic, adopt the metadata from the other one */
+    if (meta1->base == NPY_FR_GENERIC) {
+        *out_meta = *meta2;
+        return 0;
+    }
+    else if (meta2->base == NPY_FR_GENERIC) {
+        *out_meta = *meta1;
+        return 0;
+    }
+
+    num1 = (npy_uint64)meta1->num;
+    num2 = (npy_uint64)meta2->num;
+
+    /* First validate that the units have a reasonable GCD */
+    if (meta1->base == meta2->base) {
+        base = meta1->base;
+    }
+    else {
+        /*
+         * Years and Months are incompatible with
+         * all other units (except years and months are compatible
+         * with each other).
+         */
+        if (meta1->base == NPY_FR_Y) {
+            if (meta2->base == NPY_FR_M) {
+                base = NPY_FR_M;
+                num1 *= 12;
+            }
+            else if (strict_with_nonlinear_units1) {
+                goto incompatible_units;
+            }
+            else {
+                base = meta2->base;
+                /* Don't multiply num1 since there is no even factor */
+            }
+        }
+        else if (meta2->base == NPY_FR_Y) {
+            if (meta1->base == NPY_FR_M) {
+                base = NPY_FR_M;
+                num2 *= 12;
+            }
+            else if (strict_with_nonlinear_units2) {
+                goto incompatible_units;
+            }
+            else {
+                base = meta1->base;
+                /* Don't multiply num2 since there is no even factor */
+            }
+        }
+        else if (meta1->base == NPY_FR_M) {
+            if (strict_with_nonlinear_units1) {
+                goto incompatible_units;
+            }
+            else {
+                base = meta2->base;
+                /* Don't multiply num1 since there is no even factor */
+            }
+        }
+        else if (meta2->base == NPY_FR_M) {
+            if (strict_with_nonlinear_units2) {
+                goto incompatible_units;
+            }
+            else {
+                base = meta1->base;
+                /* Don't multiply num2 since there is no even factor */
+            }
+        }
+
+        /* Take the greater base (unit sizes are decreasing in enum) */
+        if (meta1->base > meta2->base) {
+            base = meta1->base;
+            num2 *= get_datetime_units_factor(meta2->base, meta1->base);
+            if (num2 == 0) {
+                goto units_overflow;
+            }
+        }
+        else {
+            base = meta2->base;
+            num1 *= get_datetime_units_factor(meta1->base, meta2->base);
+            if (num1 == 0) {
+                goto units_overflow;
+            }
+        }
+    }
+
+    /* Compute the GCD of the resulting multipliers */
+    num = _uint64_euclidean_gcd(num1, num2);
+
+    /* Fill the 'out_meta' values */
+    out_meta->base = base;
+    out_meta->num = (int)num;
+    if (out_meta->num <= 0 || num != (npy_uint64)out_meta->num) {
+        goto units_overflow;
+    }
+
+    return 0;
+
+incompatible_units: {
+        PyObject *errmsg;
+        errmsg = PyUString_FromString("Cannot get "
+                    "a common metadata divisor for "
+                    "NumPy datetime metadata ");
+        errmsg = append_metastr_to_string(meta1, 0, errmsg);
+        PyUString_ConcatAndDel(&errmsg,
+                PyUString_FromString(" and "));
+        errmsg = append_metastr_to_string(meta2, 0, errmsg);
+        PyUString_ConcatAndDel(&errmsg,
+                PyUString_FromString(" because they have "
+                    "incompatible nonlinear base time units"));
+        PyErr_SetObject(PyExc_TypeError, errmsg);
+        Py_DECREF(errmsg);
+        return -1;
+    }
+units_overflow: {
+        PyObject *errmsg;
+        errmsg = PyUString_FromString("Integer overflow "
+                    "getting a common metadata divisor for "
+                    "NumPy datetime metadata ");
+        errmsg = append_metastr_to_string(meta1, 0, errmsg);
+        PyUString_ConcatAndDel(&errmsg,
+                PyUString_FromString(" and "));
+        errmsg = append_metastr_to_string(meta2, 0, errmsg);
+        PyErr_SetObject(PyExc_OverflowError, errmsg);
+        Py_DECREF(errmsg);
+        return -1;
+    }
+}
+
+/*
+ * Both type1 and type2 must be either NPY_DATETIME or NPY_TIMEDELTA.
+ * Applies the type promotion rules between the two types, returning
+ * the promoted type.
+ */
+NPY_NO_EXPORT PyArray_Descr *
+datetime_type_promotion(PyArray_Descr *type1, PyArray_Descr *type2)
+{
+    int type_num1, type_num2;
+    PyArray_Descr *dtype;
+    int is_datetime;
+
+    type_num1 = type1->type_num;
+    type_num2 = type2->type_num;
+
+    is_datetime = (type_num1 == NPY_DATETIME || type_num2 == NPY_DATETIME);
+
+    /* Create a DATETIME or TIMEDELTA dtype */
+    dtype = PyArray_DescrNewFromType(is_datetime ? NPY_DATETIME :
+                                                   NPY_TIMEDELTA);
+    if (dtype == NULL) {
+        return NULL;
+    }
+
+    /*
+     * Get the metadata GCD, being strict about nonlinear units for
+     * timedelta and relaxed for datetime.
+     */
+    if (compute_datetime_metadata_greatest_common_divisor(
+                                    get_datetime_metadata_from_dtype(type1),
+                                    get_datetime_metadata_from_dtype(type2),
+                                    get_datetime_metadata_from_dtype(dtype),
+                                    type_num1 == NPY_TIMEDELTA,
+                                    type_num2 == NPY_TIMEDELTA) < 0) {
+        Py_DECREF(dtype);
+        return NULL;
+    }
+
+    return dtype;
+}
+
+/*
+ * Converts a substring given by 'str' and 'len' into
+ * a date time unit enum value. The 'metastr' parameter
+ * is used for error messages, and may be NULL.
+ *
+ * Generic units have no representation as a string in this form.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT NPY_DATETIMEUNIT
+parse_datetime_unit_from_string(char *str, Py_ssize_t len, char *metastr)
+{
+    /* Use switch statements so the compiler can make it fast */
+    if (len == 1) {
+        switch (str[0]) {
+            case 'Y':
+                return NPY_FR_Y;
+            case 'M':
+                return NPY_FR_M;
+            case 'W':
+                return NPY_FR_W;
+            case 'D':
+                return NPY_FR_D;
+            case 'h':
+                return NPY_FR_h;
+            case 'm':
+                return NPY_FR_m;
+            case 's':
+                return NPY_FR_s;
+        }
+    }
+    /* All the two-letter units are variants of seconds */
+    else if (len == 2 && str[1] == 's') {
+        switch (str[0]) {
+            case 'm':
+                return NPY_FR_ms;
+            case 'u':
+                return NPY_FR_us;
+            case 'n':
+                return NPY_FR_ns;
+            case 'p':
+                return NPY_FR_ps;
+            case 'f':
+                return NPY_FR_fs;
+            case 'a':
+                return NPY_FR_as;
+        }
+    }
+
+    /* If nothing matched, it's an error */
+    if (metastr == NULL) {
+        PyErr_Format(PyExc_TypeError,
+                "Invalid datetime unit \"%s\" in metadata",
+                str);
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+                "Invalid datetime unit in metadata string \"%s\"",
+                metastr);
+    }
+    return -1;
+}
+
+
+NPY_NO_EXPORT PyObject *
+convert_datetime_metadata_to_tuple(PyArray_DatetimeMetaData *meta)
+{
+    PyObject *dt_tuple;
+
+    dt_tuple = PyTuple_New(2);
+    if (dt_tuple == NULL) {
+        return NULL;
+    }
+
+    PyTuple_SET_ITEM(dt_tuple, 0,
+            PyUString_FromString(_datetime_strings[meta->base]));
+    PyTuple_SET_ITEM(dt_tuple, 1,
+            PyInt_FromLong(meta->num));
+
+    return dt_tuple;
+}
+
+/*
+ * Converts a metadata tuple into a datetime metadata C struct.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT int
+convert_datetime_metadata_tuple_to_datetime_metadata(PyObject *tuple,
+                                        PyArray_DatetimeMetaData *out_meta)
+{
+    char *basestr = NULL;
+    Py_ssize_t len = 0, tuple_size;
+    int den = 1;
+    PyObject *unit_str = NULL;
+
+    if (!PyTuple_Check(tuple)) {
+        PyObject *errmsg;
+        errmsg = PyUString_FromString("Require tuple for tuple to NumPy "
+                                      "datetime metadata conversion, not ");
+        PyUString_ConcatAndDel(&errmsg, PyObject_Repr(tuple));
+        PyErr_SetObject(PyExc_TypeError, errmsg);
+        Py_DECREF(errmsg);
+        return -1;
+    }
+
+    tuple_size = PyTuple_GET_SIZE(tuple);
+    if (tuple_size < 2 || tuple_size > 4) {
+        PyErr_SetString(PyExc_TypeError,
+                        "Require tuple of size 2 to 4 for "
+                        "tuple to NumPy datetime metadata conversion");
+        return -1;
+    }
+
+    unit_str = PyTuple_GET_ITEM(tuple, 0);
+    Py_INCREF(unit_str);
+    if (PyUnicode_Check(unit_str)) {
+        /* Allow unicode format strings: convert to bytes */
+        PyObject *tmp = PyUnicode_AsASCIIString(unit_str);
+        Py_DECREF(unit_str);
+        if (tmp == NULL) {
+            return -1;
+        }
+        unit_str = tmp;
+    }
+    if (PyBytes_AsStringAndSize(unit_str, &basestr, &len) < 0) {
+        Py_DECREF(unit_str);
+        return -1;
+    }
+
+    out_meta->base = parse_datetime_unit_from_string(basestr, len, NULL);
+    if (out_meta->base == -1) {
+        Py_DECREF(unit_str);
+        return -1;
+    }
+
+    Py_DECREF(unit_str);
+
+    /* Convert the values to longs */
+    out_meta->num = PyInt_AsLong(PyTuple_GET_ITEM(tuple, 1));
+    if (out_meta->num == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+
+    if (tuple_size == 4) {
+        den = PyInt_AsLong(PyTuple_GET_ITEM(tuple, 2));
+        if (den == -1 && PyErr_Occurred()) {
+            return -1;
+        }
+    }
+
+    if (out_meta->num <= 0 || den <= 0) {
+        PyErr_SetString(PyExc_TypeError,
+                        "Invalid tuple values for "
+                        "tuple to NumPy datetime metadata conversion");
+        return -1;
+    }
+
+    if (den != 1) {
+        if (convert_datetime_divisor_to_multiple(out_meta, den, NULL) < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+/*
+ * Converts an input object into datetime metadata. The input
+ * may be either a string or a tuple.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT int
+convert_pyobject_to_datetime_metadata(PyObject *obj,
+                                      PyArray_DatetimeMetaData *out_meta)
+{
+    PyObject *ascii = NULL;
+    char *str = NULL;
+    Py_ssize_t len = 0;
+
+    if (PyTuple_Check(obj)) {
+        return convert_datetime_metadata_tuple_to_datetime_metadata(obj,
+                                                                out_meta);
+    }
+
+    /* Get an ASCII string */
+    if (PyUnicode_Check(obj)) {
+        /* Allow unicode format strings: convert to bytes */
+        ascii = PyUnicode_AsASCIIString(obj);
+        if (ascii == NULL) {
+            return -1;
+        }
+    }
+    else if (PyBytes_Check(obj)) {
+        ascii = obj;
+        Py_INCREF(ascii);
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                "Invalid object for specifying NumPy datetime metadata");
+        return -1;
+    }
+
+    if (PyBytes_AsStringAndSize(ascii, &str, &len) < 0) {
+        Py_DECREF(ascii);
+        return -1;
+    }
+
+    if (len > 0 && str[0] == '[') {
+        int r = parse_datetime_metadata_from_metastr(str, len, out_meta);
+        Py_DECREF(ascii);
+        return r;
+    }
+    else {
+        if (parse_datetime_extended_unit_from_string(str, len,
+                                                NULL, out_meta) < 0) {
+            Py_DECREF(ascii);
+            return -1;
+        }
+
+        Py_DECREF(ascii);
+        return 0;
+    }
+}
+
+/*
+ * 'ret' is a PyUString containing the datetime string, and this
+ * function appends the metadata string to it.
+ *
+ * If 'skip_brackets' is true, skips the '[]'.
+ *
+ * This function steals the reference 'ret'
+ */
+NPY_NO_EXPORT PyObject *
+append_metastr_to_string(PyArray_DatetimeMetaData *meta,
+                                    int skip_brackets,
+                                    PyObject *ret)
+{
+    PyObject *res;
+    int num;
+    char *basestr;
+
+    if (ret == NULL) {
+        return NULL;
+    }
+
+    if (meta->base == NPY_FR_GENERIC) {
+        /* Without brackets, give a string "generic" */
+        if (skip_brackets) {
+            PyUString_ConcatAndDel(&ret, PyUString_FromString("generic"));
+            return ret;
+        }
+        /* But with brackets, append nothing */
+        else {
+            return ret;
+        }
+    }
+
+    num = meta->num;
+    if (meta->base >= 0 && meta->base < NPY_DATETIME_NUMUNITS) {
+        basestr = _datetime_strings[meta->base];
+    }
+    else {
+        PyErr_SetString(PyExc_RuntimeError,
+                "NumPy datetime metadata is corrupted");
+        return NULL;
+    }
+
+    if (num == 1) {
+        if (skip_brackets) {
+            res = PyUString_FromFormat("%s", basestr);
+        }
+        else {
+            res = PyUString_FromFormat("[%s]", basestr);
+        }
+    }
+    else {
+        if (skip_brackets) {
+            res = PyUString_FromFormat("%d%s", num, basestr);
+        }
+        else {
+            res = PyUString_FromFormat("[%d%s]", num, basestr);
+        }
+    }
+
+    PyUString_ConcatAndDel(&ret, res);
+    return ret;
+}
+
+/*
+ * Adjusts a datetimestruct based on a seconds offset. Assumes
+ * the current values are valid.
+ */
+NPY_NO_EXPORT void
+add_seconds_to_datetimestruct(npy_datetimestruct *dts, int seconds)
+{
+    int minutes;
+
+    dts->sec += seconds;
+    if (dts->sec < 0) {
+        minutes = dts->sec / 60;
+        dts->sec = dts->sec % 60;
+        if (dts->sec < 0) {
+            --minutes;
+            dts->sec += 60;
+        }
+        add_minutes_to_datetimestruct(dts, minutes);
+    }
+    else if (dts->sec >= 60) {
+        minutes = dts->sec / 60;
+        dts->sec = dts->sec % 60;
+        add_minutes_to_datetimestruct(dts, minutes);
+    }
+}
+
+/*
+ * Adjusts a datetimestruct based on a minutes offset. Assumes
+ * the current values are valid.
+ */
+NPY_NO_EXPORT void
+add_minutes_to_datetimestruct(npy_datetimestruct *dts, int minutes)
+{
+    int isleap;
+
+    /* MINUTES */
+    dts->min += minutes;
+    while (dts->min < 0) {
+        dts->min += 60;
+        dts->hour--;
+    }
+    while (dts->min >= 60) {
+        dts->min -= 60;
+        dts->hour++;
+    }
+
+    /* HOURS */
+    while (dts->hour < 0) {
+        dts->hour += 24;
+        dts->day--;
+    }
+    while (dts->hour >= 24) {
+        dts->hour -= 24;
+        dts->day++;
+    }
+
+    /* DAYS */
+    if (dts->day < 1) {
+        dts->month--;
+        if (dts->month < 1) {
+            dts->year--;
+            dts->month = 12;
+        }
+        isleap = is_leapyear(dts->year);
+        dts->day += _days_per_month_table[isleap][dts->month-1];
+    }
+    else if (dts->day > 28) {
+        isleap = is_leapyear(dts->year);
+        if (dts->day > _days_per_month_table[isleap][dts->month-1]) {
+            dts->day -= _days_per_month_table[isleap][dts->month-1];
+            dts->month++;
+            if (dts->month > 12) {
+                dts->year++;
+                dts->month = 1;
+            }
+        }
+    }
+}
+
+/*
+ * Tests for and converts a Python datetime.datetime or datetime.date
+ * object into a NumPy npy_datetimestruct.
+ *
+ * While the C API has PyDate_* and PyDateTime_* functions, the following
+ * implementation just asks for attributes, and thus supports
+ * datetime duck typing. The tzinfo time zone conversion would require
+ * this style of access anyway.
+ *
+ * 'out_bestunit' gives a suggested unit based on whether the object
+ *      was a datetime.date or datetime.datetime object.
+ *
+ * If 'apply_tzinfo' is 1, this function uses the tzinfo to convert
+ * to UTC time, otherwise it returns the struct with the local time.
+ *
+ * Returns -1 on error, 0 on success, and 1 (with no error set)
+ * if obj doesn't have the neeeded date or datetime attributes.
+ */
+NPY_NO_EXPORT int
+convert_pydatetime_to_datetimestruct(PyObject *obj, npy_datetimestruct *out,
+                                     NPY_DATETIMEUNIT *out_bestunit,
+                                     int apply_tzinfo)
+{
+    PyObject *tmp;
+    int isleap;
+
+    /* Initialize the output to all zeros */
+    memset(out, 0, sizeof(npy_datetimestruct));
+    out->month = 1;
+    out->day = 1;
+
+    /* Need at least year/month/day attributes */
+    if (!PyObject_HasAttrString(obj, "year") ||
+            !PyObject_HasAttrString(obj, "month") ||
+            !PyObject_HasAttrString(obj, "day")) {
+        return 1;
+    }
+
+    /* Get the year */
+    tmp = PyObject_GetAttrString(obj, "year");
+    if (tmp == NULL) {
+        return -1;
+    }
+    out->year = PyInt_AsLong(tmp);
+    if (out->year == -1 && PyErr_Occurred()) {
+        Py_DECREF(tmp);
+        return -1;
+    }
+    Py_DECREF(tmp);
+
+    /* Get the month */
+    tmp = PyObject_GetAttrString(obj, "month");
+    if (tmp == NULL) {
+        return -1;
+    }
+    out->month = PyInt_AsLong(tmp);
+    if (out->month == -1 && PyErr_Occurred()) {
+        Py_DECREF(tmp);
+        return -1;
+    }
+    Py_DECREF(tmp);
+
+    /* Get the day */
+    tmp = PyObject_GetAttrString(obj, "day");
+    if (tmp == NULL) {
+        return -1;
+    }
+    out->day = PyInt_AsLong(tmp);
+    if (out->day == -1 && PyErr_Occurred()) {
+        Py_DECREF(tmp);
+        return -1;
+    }
+    Py_DECREF(tmp);
+
+    /* Validate that the month and day are valid for the year */
+    if (out->month < 1 || out->month > 12) {
+        goto invalid_date;
+    }
+    isleap = is_leapyear(out->year);
+    if (out->day < 1 ||
+                out->day > _days_per_month_table[isleap][out->month-1]) {
+        goto invalid_date;
+    }
+
+    /* Check for time attributes (if not there, return success as a date) */
+    if (!PyObject_HasAttrString(obj, "hour") ||
+            !PyObject_HasAttrString(obj, "minute") ||
+            !PyObject_HasAttrString(obj, "second") ||
+            !PyObject_HasAttrString(obj, "microsecond")) {
+        /* The best unit for date is 'D' */
+        if (out_bestunit != NULL) {
+            *out_bestunit = NPY_FR_D;
+        }
+        return 0;
+    }
+
+    /* Get the hour */
+    tmp = PyObject_GetAttrString(obj, "hour");
+    if (tmp == NULL) {
+        return -1;
+    }
+    out->hour = PyInt_AsLong(tmp);
+    if (out->hour == -1 && PyErr_Occurred()) {
+        Py_DECREF(tmp);
+        return -1;
+    }
+    Py_DECREF(tmp);
+
+    /* Get the minute */
+    tmp = PyObject_GetAttrString(obj, "minute");
+    if (tmp == NULL) {
+        return -1;
+    }
+    out->min = PyInt_AsLong(tmp);
+    if (out->min == -1 && PyErr_Occurred()) {
+        Py_DECREF(tmp);
+        return -1;
+    }
+    Py_DECREF(tmp);
+
+    /* Get the second */
+    tmp = PyObject_GetAttrString(obj, "second");
+    if (tmp == NULL) {
+        return -1;
+    }
+    out->sec = PyInt_AsLong(tmp);
+    if (out->sec == -1 && PyErr_Occurred()) {
+        Py_DECREF(tmp);
+        return -1;
+    }
+    Py_DECREF(tmp);
+
+    /* Get the microsecond */
+    tmp = PyObject_GetAttrString(obj, "microsecond");
+    if (tmp == NULL) {
+        return -1;
+    }
+    out->us = PyInt_AsLong(tmp);
+    if (out->us == -1 && PyErr_Occurred()) {
+        Py_DECREF(tmp);
+        return -1;
+    }
+    Py_DECREF(tmp);
+
+    if (out->hour < 0 || out->hour >= 24 ||
+            out->min < 0 || out->min >= 60 ||
+            out->sec < 0 || out->sec >= 60 ||
+            out->us < 0 || out->us >= 1000000) {
+        goto invalid_time;
+    }
+
+    /* Apply the time zone offset if it exists */
+    if (apply_tzinfo && PyObject_HasAttrString(obj, "tzinfo")) {
+        tmp = PyObject_GetAttrString(obj, "tzinfo");
+        if (tmp == NULL) {
+            return -1;
+        }
+        if (tmp == Py_None) {
+            Py_DECREF(tmp);
+        }
+        else {
+            PyObject *offset;
+            int seconds_offset, minutes_offset;
+
+            /* The utcoffset function should return a timedelta */
+            offset = PyObject_CallMethod(tmp, "utcoffset", "O", obj);
+            if (offset == NULL) {
+                Py_DECREF(tmp);
+                return -1;
+            }
+            Py_DECREF(tmp);
+
+            /*
+             * The timedelta should have a function "total_seconds"
+             * which contains the value we want.
+             */
+            tmp = PyObject_CallMethod(offset, "total_seconds", "");
+            if (tmp == NULL) {
+                return -1;
+            }
+            seconds_offset = PyInt_AsLong(tmp);
+            if (seconds_offset == -1 && PyErr_Occurred()) {
+                Py_DECREF(tmp);
+                return -1;
+            }
+            Py_DECREF(tmp);
+
+            /* Convert to a minutes offset and apply it */
+            minutes_offset = seconds_offset / 60;
+
+            add_minutes_to_datetimestruct(out, -minutes_offset);
+        }
+    }
+
+    /* The resolution of Python's datetime is 'us' */
+    if (out_bestunit != NULL) {
+        *out_bestunit = NPY_FR_us;
+    }
+
+    return 0;
+
+invalid_date:
+    PyErr_Format(PyExc_ValueError,
+            "Invalid date (%d,%d,%d) when converting to NumPy datetime",
+            (int)out->year, (int)out->month, (int)out->day);
+    return -1;
+
+invalid_time:
+    PyErr_Format(PyExc_ValueError,
+            "Invalid time (%d,%d,%d,%d) when converting "
+            "to NumPy datetime",
+            (int)out->hour, (int)out->min, (int)out->sec, (int)out->us);
+    return -1;
+}
+
+/*
+ * Gets a tzoffset in minutes by calling the fromutc() function on
+ * the Python datetime.tzinfo object.
+ */
+NPY_NO_EXPORT int
+get_tzoffset_from_pytzinfo(PyObject *timezone_obj, npy_datetimestruct *dts)
+{
+    PyObject *dt, *loc_dt;
+    npy_datetimestruct loc_dts;
+
+    /* Create a Python datetime to give to the timezone object */
+    dt = PyDateTime_FromDateAndTime((int)dts->year, dts->month, dts->day,
+                            dts->hour, dts->min, 0, 0);
+    if (dt == NULL) {
+        return -1;
+    }
+
+    /* Convert the datetime from UTC to local time */
+    loc_dt = PyObject_CallMethod(timezone_obj, "fromutc", "O", dt);
+    Py_DECREF(dt);
+    if (loc_dt == NULL) {
+        return -1;
+    }
+
+    /* Convert the local datetime into a datetimestruct */
+    if (convert_pydatetime_to_datetimestruct(loc_dt, &loc_dts, NULL, 0) < 0) {
+        Py_DECREF(loc_dt);
+        return -1;
+    }
+
+    Py_DECREF(loc_dt);
+
+    /* Calculate the tzoffset as the difference between the datetimes */
+    return (int)(get_datetimestruct_minutes(&loc_dts) -
+                 get_datetimestruct_minutes(dts));
+}
+
+/*
+ * Converts a PyObject * into a datetime, in any of the forms supported.
+ *
+ * If the units metadata isn't known ahead of time, set meta->base
+ * to -1, and this function will populate meta with either default
+ * values or values from the input object.
+ *
+ * The 'casting' parameter is used to control what kinds of inputs
+ * are accepted, and what happens. For example, with 'unsafe' casting,
+ * unrecognized inputs are converted to 'NaT' instead of throwing an error,
+ * while with 'safe' casting an error will be thrown if any precision
+ * from the input will be thrown away.
+ *
+ * Returns -1 on error, 0 on success.
+ */
+NPY_NO_EXPORT int
+convert_pyobject_to_datetime(PyArray_DatetimeMetaData *meta, PyObject *obj,
+                                NPY_CASTING casting, npy_datetime *out)
+{
+    if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
+        PyObject *bytes = NULL;
+        char *str = NULL;
+        Py_ssize_t len = 0;
+        npy_datetimestruct dts;
+        NPY_DATETIMEUNIT bestunit = -1;
+
+        /* Convert to an ASCII string for the date parser */
+        if (PyUnicode_Check(obj)) {
+            bytes = PyUnicode_AsASCIIString(obj);
+            if (bytes == NULL) {
+                return -1;
+            }
+        }
+        else {
+            bytes = obj;
+            Py_INCREF(bytes);
+        }
+        if (PyBytes_AsStringAndSize(bytes, &str, &len) < 0) {
+            Py_DECREF(bytes);
+            return -1;
+        }
+
+        /* Parse the ISO date */
+        if (parse_iso_8601_datetime(str, len, meta->base, casting,
+                                &dts, NULL, &bestunit, NULL) < 0) {
+            Py_DECREF(bytes);
+            return -1;
+        }
+
+        /* Use the detected unit if none was specified */
+        if (meta->base == -1) {
+            meta->base = bestunit;
+            meta->num = 1;
+        }
+
+        if (convert_datetimestruct_to_datetime(meta, &dts, out) < 0) {
+            Py_DECREF(bytes);
+            return -1;
+        }
+
+        Py_DECREF(bytes);
+        return 0;
+    }
+    /* Do no conversion on raw integers */
+    else if (PyInt_Check(obj) || PyLong_Check(obj)) {
+        /* Don't allow conversion from an integer without specifying a unit */
+        if (meta->base == -1 || meta->base == NPY_FR_GENERIC) {
+            PyErr_SetString(PyExc_ValueError, "Converting an integer to a "
+                            "NumPy datetime requires a specified unit");
+            return -1;
+        }
+        *out = PyLong_AsLongLong(obj);
+        return 0;
+    }
+    /* Datetime scalar */
+    else if (PyArray_IsScalar(obj, Datetime)) {
+        PyDatetimeScalarObject *dts = (PyDatetimeScalarObject *)obj;
+
+        /* Copy the scalar directly if units weren't specified */
+        if (meta->base == -1) {
+            *meta = dts->obmeta;
+            *out = dts->obval;
+
+            return 0;
+        }
+        /* Otherwise do a casting transformation */
+        else {
+            /* Allow NaT (not-a-time) values to slip through any rule */
+            if (dts->obval != NPY_DATETIME_NAT &&
+                        raise_if_datetime64_metadata_cast_error(
+                                "NumPy timedelta64 scalar",
+                                &dts->obmeta, meta, casting) < 0) {
+                return -1;
+            }
+            else {
+                return cast_datetime_to_datetime(&dts->obmeta, meta,
+                                                    dts->obval, out);
+            }
+        }
+    }
+    /* Datetime zero-dimensional array */
+    else if (PyArray_Check(obj) &&
+              PyArray_NDIM((PyArrayObject *)obj) == 0 &&
+              PyArray_DESCR((PyArrayObject *)obj)->type_num == NPY_DATETIME) {
+        PyArrayObject *arr = (PyArrayObject *)obj;
+        PyArray_DatetimeMetaData *arr_meta;
+        npy_datetime dt = 0;
+
+        arr_meta = get_datetime_metadata_from_dtype(PyArray_DESCR(arr));
+        if (arr_meta == NULL) {
+            return -1;
+        }
+        PyArray_DESCR(arr)->f->copyswap(&dt,
+                                PyArray_DATA(arr),
+                                !PyArray_ISNOTSWAPPED(arr),
+                                obj);
+
+        /* Copy the value directly if units weren't specified */
+        if (meta->base == -1) {
+            *meta = *arr_meta;
+            *out = dt;
+
+            return 0;
+        }
+        /* Otherwise do a casting transformation */
+        else {
+            /* Allow NaT (not-a-time) values to slip through any rule */
+            if (dt != NPY_DATETIME_NAT &&
+                        raise_if_datetime64_metadata_cast_error(
+                                "NumPy timedelta64 scalar",
+                                arr_meta, meta, casting) < 0) {
+                return -1;
+            }
+            else {
+                return cast_datetime_to_datetime(arr_meta, meta, dt, out);
+            }
+        }
+    }
+    /* Convert from a Python date or datetime object */
+    else {
+        int code;
+        npy_datetimestruct dts;
+        NPY_DATETIMEUNIT bestunit = -1;
+
+        code = convert_pydatetime_to_datetimestruct(obj, &dts, &bestunit, 1);
+        if (code == -1) {
+            return -1;
+        }
+        else if (code == 0) {
+            /* Use the detected unit if none was specified */
+            if (meta->base == -1) {
+                meta->base = bestunit;
+                meta->num = 1;
+            }
+            else {
+                PyArray_DatetimeMetaData obj_meta;
+                obj_meta.base = bestunit;
+                obj_meta.num = 1;
+
+                if (raise_if_datetime64_metadata_cast_error(
+                                bestunit == NPY_FR_D ? "datetime.date object"
+                                                 : "datetime.datetime object",
+                                &obj_meta, meta, casting) < 0) {
+                    return -1;
+                }
+            }
+
+            return convert_datetimestruct_to_datetime(meta, &dts, out);
+        }
+    }
+
+    /*
+     * With unsafe casting, convert unrecognized objects into NaT
+     * and with same_kind casting, convert None into NaT
+     */
+    if (casting == NPY_UNSAFE_CASTING ||
+            (obj == Py_None && casting == NPY_SAME_KIND_CASTING)) {
+        if (meta->base == -1) {
+            meta->base = NPY_FR_GENERIC;
+            meta->num = 1;
+        }
+        *out = NPY_DATETIME_NAT;
+        return 0;
+    }
+    else {
+        PyErr_SetString(PyExc_ValueError,
+                "Could not convert object to NumPy datetime");
+        return -1;
+    }
+}
+
+/*
+ * Converts a PyObject * into a timedelta, in any of the forms supported
+ *
+ * If the units metadata isn't known ahead of time, set meta->base
+ * to -1, and this function will populate meta with either default
+ * values or values from the input object.
+ *
+ * The 'casting' parameter is used to control what kinds of inputs
+ * are accepted, and what happens. For example, with 'unsafe' casting,
+ * unrecognized inputs are converted to 'NaT' instead of throwing an error,
+ * while with 'safe' casting an error will be thrown if any precision
+ * from the input will be thrown away.
+ *
+ * Returns -1 on error, 0 on success.
+ */
+NPY_NO_EXPORT int
+convert_pyobject_to_timedelta(PyArray_DatetimeMetaData *meta, PyObject *obj,
+                                NPY_CASTING casting, npy_timedelta *out)
+{
+    if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
+        PyObject *bytes = NULL;
+        char *str = NULL;
+        Py_ssize_t len = 0;
+        int succeeded = 0;
+
+        /* Convert to an ASCII string for the date parser */
+        if (PyUnicode_Check(obj)) {
+            bytes = PyUnicode_AsASCIIString(obj);
+            if (bytes == NULL) {
+                return -1;
+            }
+        }
+        else {
+            bytes = obj;
+            Py_INCREF(bytes);
+        }
+        if (PyBytes_AsStringAndSize(bytes, &str, &len) < 0) {
+            Py_DECREF(bytes);
+            return -1;
+        }
+
+        /* Check for a NaT string */
+        if (len <= 0 || (len == 3 &&
+                        tolower(str[0]) == 'n' &&
+                        tolower(str[1]) == 'a' &&
+                        tolower(str[2]) == 't')) {
+            *out = NPY_DATETIME_NAT;
+            succeeded = 1;
+        }
+        /* Parse as an integer */
+        else {
+            char *strend = NULL;
+
+            *out = strtol(str, &strend, 10);
+            if (strend - str == len) {
+                succeeded = 1;
+            }
+        }
+        Py_DECREF(bytes);
+
+        if (succeeded) {
+            /* Use generic units if none was specified */
+            if (meta->base == -1) {
+                meta->base = NPY_FR_GENERIC;
+                meta->num = 1;
+            }
+
+            return 0;
+        }
+    }
+    /* Do no conversion on raw integers */
+    else if (PyInt_Check(obj) || PyLong_Check(obj)) {
+        /* Use the default unit if none was specified */
+        if (meta->base == -1) {
+            meta->base = NPY_DATETIME_DEFAULTUNIT;
+            meta->num = 1;
+        }
+
+        *out = PyLong_AsLongLong(obj);
+        return 0;
+    }
+    /* Timedelta scalar */
+    else if (PyArray_IsScalar(obj, Timedelta)) {
+        PyTimedeltaScalarObject *dts = (PyTimedeltaScalarObject *)obj;
+
+        /* Copy the scalar directly if units weren't specified */
+        if (meta->base == -1) {
+            *meta = dts->obmeta;
+            *out = dts->obval;
+
+            return 0;
+        }
+        /* Otherwise do a casting transformation */
+        else {
+            /* Allow NaT (not-a-time) values to slip through any rule */
+            if (dts->obval != NPY_DATETIME_NAT &&
+                        raise_if_timedelta64_metadata_cast_error(
+                                "NumPy timedelta64 scalar",
+                                &dts->obmeta, meta, casting) < 0) {
+                return -1;
+            }
+            else {
+                return cast_timedelta_to_timedelta(&dts->obmeta, meta,
+                                                    dts->obval, out);
+            }
+        }
+    }
+    /* Timedelta zero-dimensional array */
+    else if (PyArray_Check(obj) &&
+             PyArray_NDIM((PyArrayObject *)obj) == 0 &&
+             PyArray_DESCR((PyArrayObject *)obj)->type_num == NPY_TIMEDELTA) {
+        PyArrayObject *arr = (PyArrayObject *)obj;
+        PyArray_DatetimeMetaData *arr_meta;
+        npy_timedelta dt = 0;
+
+        arr_meta = get_datetime_metadata_from_dtype(PyArray_DESCR(arr));
+        if (arr_meta == NULL) {
+            return -1;
+        }
+        PyArray_DESCR(arr)->f->copyswap(&dt,
+                                PyArray_DATA(arr),
+                                !PyArray_ISNOTSWAPPED(arr),
+                                obj);
+
+        /* Copy the value directly if units weren't specified */
+        if (meta->base == -1) {
+            *meta = *arr_meta;
+            *out = dt;
+
+            return 0;
+        }
+        /* Otherwise do a casting transformation */
+        else {
+            /* Allow NaT (not-a-time) values to slip through any rule */
+            if (dt != NPY_DATETIME_NAT &&
+                        raise_if_timedelta64_metadata_cast_error(
+                                "NumPy timedelta64 scalar",
+                                arr_meta, meta, casting) < 0) {
+                return -1;
+            }
+            else {
+                return cast_timedelta_to_timedelta(arr_meta, meta, dt, out);
+            }
+        }
+    }
+    /* Convert from a Python timedelta object */
+    else if (PyObject_HasAttrString(obj, "days") &&
+                PyObject_HasAttrString(obj, "seconds") &&
+                PyObject_HasAttrString(obj, "microseconds")) {
+        PyObject *tmp;
+        PyArray_DatetimeMetaData us_meta;
+        npy_timedelta td;
+        npy_int64 days;
+        int seconds = 0, useconds = 0;
+
+        /* Get the days */
+        tmp = PyObject_GetAttrString(obj, "days");
+        if (tmp == NULL) {
+            return -1;
+        }
+        days = PyLong_AsLongLong(tmp);
+        if (days == -1 && PyErr_Occurred()) {
+            Py_DECREF(tmp);
+            return -1;
+        }
+        Py_DECREF(tmp);
+
+        /* Get the seconds */
+        tmp = PyObject_GetAttrString(obj, "seconds");
+        if (tmp == NULL) {
+            return -1;
+        }
+        seconds = PyInt_AsLong(tmp);
+        if (seconds == -1 && PyErr_Occurred()) {
+            Py_DECREF(tmp);
+            return -1;
+        }
+        Py_DECREF(tmp);
+
+        /* Get the microseconds */
+        tmp = PyObject_GetAttrString(obj, "microseconds");
+        if (tmp == NULL) {
+            return -1;
+        }
+        useconds = PyInt_AsLong(tmp);
+        if (useconds == -1 && PyErr_Occurred()) {
+            Py_DECREF(tmp);
+            return -1;
+        }
+        Py_DECREF(tmp);
+
+        td = days*(24*60*60*1000000LL) + seconds*1000000LL + useconds;
+
+        /* Use microseconds if none was specified */
+        if (meta->base == -1) {
+            meta->base = NPY_FR_us;
+            meta->num = 1;
+
+            *out = td;
+
+            return 0;
+        }
+        else {
+            /*
+             * Detect the largest unit where every value after is zero,
+             * to allow safe casting to seconds if microseconds is zero,
+             * for instance.
+             */
+            if (td % 1000LL != 0) {
+                us_meta.base = NPY_FR_us;
+            }
+            else if (td % 1000000LL != 0) {
+                us_meta.base = NPY_FR_ms;
+            }
+            else if (td % (60*1000000LL) != 0) {
+                us_meta.base = NPY_FR_s;
+            }
+            else if (td % (60*60*1000000LL) != 0) {
+                us_meta.base = NPY_FR_m;
+            }
+            else if (td % (24*60*60*1000000LL) != 0) {
+                us_meta.base = NPY_FR_D;
+            }
+            else if (td % (7*24*60*60*1000000LL) != 0) {
+                us_meta.base = NPY_FR_W;
+            }
+            us_meta.num = 1;
+
+            if (raise_if_timedelta64_metadata_cast_error(
+                                "datetime.timedelta object",
+                                &us_meta, meta, casting) < 0) {
+                return -1;
+            }
+            else {
+                /* Switch back to microseconds for the casting operation */
+                us_meta.base = NPY_FR_us;
+
+                return cast_timedelta_to_timedelta(&us_meta, meta, td, out);
+            }
+        }
+    }
+
+    /*
+     * With unsafe casting, convert unrecognized objects into NaT
+     * and with same_kind casting, convert None into NaT
+     */
+    if (casting == NPY_UNSAFE_CASTING ||
+            (obj == Py_None && casting == NPY_SAME_KIND_CASTING)) {
+        if (meta->base == -1) {
+            meta->base = NPY_FR_GENERIC;
+            meta->num = 1;
+        }
+        *out = NPY_DATETIME_NAT;
+        return 0;
+    }
+    else {
+        PyErr_SetString(PyExc_ValueError,
+                "Could not convert object to NumPy timedelta");
+        return -1;
+    }
+}
+
+/*
+ * Converts a datetime into a PyObject *.
+ *
+ * Not-a-time is returned as the string "NaT".
+ * For days or coarser, returns a datetime.date.
+ * For microseconds or coarser, returns a datetime.datetime.
+ * For units finer than microseconds, returns an integer.
+ */
+NPY_NO_EXPORT PyObject *
+convert_datetime_to_pyobject(npy_datetime dt, PyArray_DatetimeMetaData *meta)
+{
+    PyObject *ret = NULL;
+    npy_datetimestruct dts;
+
+    /*
+     * Convert NaT (not-a-time) and any value with generic units
+     * into None.
+     */
+    if (dt == NPY_DATETIME_NAT || meta->base == NPY_FR_GENERIC) {
+        Py_RETURN_NONE;
+    }
+
+    /* If the type's precision is greater than microseconds, return an int */
+    if (meta->base > NPY_FR_us) {
+        return PyLong_FromLongLong(dt);
+    }
+
+    /* Convert to a datetimestruct */
+    if (convert_datetime_to_datetimestruct(meta, dt, &dts) < 0) {
+        return NULL;
+    }
+
+    /*
+     * If the year is outside the range of years supported by Python's
+     * datetime, or the datetime64 falls on a leap second,
+     * return a raw int.
+     */
+    if (dts.year < 1 || dts.year > 9999 || dts.sec == 60) {
+        return PyLong_FromLongLong(dt);
+    }
+
+    /* If the type's precision is greater than days, return a datetime */
+    if (meta->base > NPY_FR_D) {
+        ret = PyDateTime_FromDateAndTime(dts.year, dts.month, dts.day,
+                                dts.hour, dts.min, dts.sec, dts.us);
+    }
+    /* Otherwise return a date */
+    else {
+        ret = PyDate_FromDate(dts.year, dts.month, dts.day);
+    }
+
+    return ret;
+}
+
+/*
+ * Converts a timedelta into a PyObject *.
+ *
+ * Not-a-time is returned as the string "NaT".
+ * For microseconds or coarser, returns a datetime.timedelta.
+ * For units finer than microseconds, returns an integer.
+ */
+NPY_NO_EXPORT PyObject *
+convert_timedelta_to_pyobject(npy_timedelta td, PyArray_DatetimeMetaData *meta)
+{
+    PyObject *ret = NULL;
+    npy_timedelta value;
+    int days = 0, seconds = 0, useconds = 0;
+
+    /*
+     * Convert NaT (not-a-time) into None.
+     */
+    if (td == NPY_DATETIME_NAT) {
+        Py_RETURN_NONE;
+    }
+
+    /*
+     * If the type's precision is greater than microseconds, is
+     * Y/M/B (nonlinear units), or is generic units, return an int
+     */
+    if (meta->base > NPY_FR_us ||
+                    meta->base == NPY_FR_Y ||
+                    meta->base == NPY_FR_M ||
+                    meta->base == NPY_FR_GENERIC) {
+        return PyLong_FromLongLong(td);
+    }
+
+    value = td;
+
+    /* Apply the unit multiplier (TODO: overflow treatment...) */
+    value *= meta->num;
+
+    /* Convert to days/seconds/useconds */
+    switch (meta->base) {
+        case NPY_FR_W:
+            value *= 7;
+            break;
+        case NPY_FR_D:
+            break;
+        case NPY_FR_h:
+            seconds = (int)((value % 24) * (60*60));
+            value = value / 24;
+            break;
+        case NPY_FR_m:
+            seconds = (int)(value % (24*60)) * 60;
+            value = value / (24*60);
+            break;
+        case NPY_FR_s:
+            seconds = (int)(value % (24*60*60));
+            value = value / (24*60*60);
+            break;
+        case NPY_FR_ms:
+            useconds = (int)(value % 1000) * 1000;
+            value = value / 1000;
+            seconds = (int)(value % (24*60*60));
+            value = value / (24*60*60);
+            break;
+        case NPY_FR_us:
+            useconds = (int)(value % (1000*1000));
+            value = value / (1000*1000);
+            seconds = (int)(value % (24*60*60));
+            value = value / (24*60*60);
+            break;
+        default:
+            break;
+    }
+    /*
+     * 'value' represents days, and seconds/useconds are filled.
+     *
+     * If it would overflow the datetime.timedelta days, return a raw int
+     */
+    if (value < -999999999 || value > 999999999) {
+        return PyLong_FromLongLong(td);
+    }
+    else {
+        days = (int)value;
+        ret = PyDelta_FromDSU(days, seconds, useconds);
+        if (ret == NULL) {
+            return NULL;
+        }
+    }
+
+    return ret;
+}
+
+/*
+ * Returns true if the datetime metadata matches
+ */
+NPY_NO_EXPORT npy_bool
+has_equivalent_datetime_metadata(PyArray_Descr *type1, PyArray_Descr *type2)
+{
+    PyArray_DatetimeMetaData *meta1, *meta2;
+
+    if ((type1->type_num != NPY_DATETIME &&
+                        type1->type_num != NPY_TIMEDELTA) ||
+                    (type2->type_num != NPY_DATETIME &&
+                        type2->type_num != NPY_TIMEDELTA)) {
+        return 0;
+    }
+
+    meta1 = get_datetime_metadata_from_dtype(type1);
+    if (meta1 == NULL) {
+        PyErr_Clear();
+        return 0;
+    }
+    meta2 = get_datetime_metadata_from_dtype(type2);
+    if (meta2 == NULL) {
+        PyErr_Clear();
+        return 0;
+    }
+
+    /* For generic units, the num is ignored */
+    if (meta1->base == NPY_FR_GENERIC && meta2->base == NPY_FR_GENERIC) {
+        return 1;
+    }
+
+    return meta1->base == meta2->base &&
+            meta1->num == meta2->num;
+}
+
+/*
+ * Casts a single datetime from having src_meta metadata into
+ * dst_meta metadata.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT int
+cast_datetime_to_datetime(PyArray_DatetimeMetaData *src_meta,
+                          PyArray_DatetimeMetaData *dst_meta,
+                          npy_datetime src_dt,
+                          npy_datetime *dst_dt)
+{
+    npy_datetimestruct dts;
+
+    /* If the metadata is the same, short-circuit the conversion */
+    if (src_meta->base == dst_meta->base &&
+            src_meta->num == dst_meta->num) {
+        *dst_dt = src_dt;
+        return 0;
+    }
+
+    /* Otherwise convert through a datetimestruct */
+    if (convert_datetime_to_datetimestruct(src_meta, src_dt, &dts) < 0) {
+            *dst_dt = NPY_DATETIME_NAT;
+            return -1;
+    }
+    if (convert_datetimestruct_to_datetime(dst_meta, &dts, dst_dt) < 0) {
+        *dst_dt = NPY_DATETIME_NAT;
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Casts a single timedelta from having src_meta metadata into
+ * dst_meta metadata.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT int
+cast_timedelta_to_timedelta(PyArray_DatetimeMetaData *src_meta,
+                          PyArray_DatetimeMetaData *dst_meta,
+                          npy_timedelta src_dt,
+                          npy_timedelta *dst_dt)
+{
+    npy_int64 num = 0, denom = 0;
+
+    /* If the metadata is the same, short-circuit the conversion */
+    if (src_meta->base == dst_meta->base &&
+            src_meta->num == dst_meta->num) {
+        *dst_dt = src_dt;
+        return 0;
+    }
+
+    /* Get the conversion factor */
+    get_datetime_conversion_factor(src_meta, dst_meta, &num, &denom);
+
+    if (num == 0) {
+        return -1;
+    }
+
+    /* Apply the scaling */
+    if (src_dt < 0) {
+        *dst_dt = (src_dt * num - (denom - 1)) / denom;
+    }
+    else {
+        *dst_dt = src_dt * num / denom;
+    }
+
+    return 0;
+}
+
+/*
+ * Returns true if the object is something that is best considered
+ * a Datetime, false otherwise.
+ */
+static NPY_GCC_NONNULL(1) npy_bool
+is_any_numpy_datetime(PyObject *obj)
+{
+    return (PyArray_IsScalar(obj, Datetime) ||
+            (PyArray_Check(obj) && (
+                PyArray_DESCR((PyArrayObject *)obj)->type_num ==
+                                                        NPY_DATETIME)) ||
+            PyDate_Check(obj) ||
+            PyDateTime_Check(obj));
+}
+
+/*
+ * Returns true if the object is something that is best considered
+ * a Timedelta, false otherwise.
+ */
+static npy_bool
+is_any_numpy_timedelta(PyObject *obj)
+{
+    return (PyArray_IsScalar(obj, Timedelta) ||
+        (PyArray_Check(obj) && (
+            PyArray_DESCR((PyArrayObject *)obj)->type_num == NPY_TIMEDELTA)) ||
+        PyDelta_Check(obj));
+}
+
+/*
+ * Returns true if the object is something that is best considered
+ * a Datetime or Timedelta, false otherwise.
+ */
+NPY_NO_EXPORT npy_bool
+is_any_numpy_datetime_or_timedelta(PyObject *obj)
+{
+    return obj != NULL &&
+           (is_any_numpy_datetime(obj) ||
+            is_any_numpy_timedelta(obj));
+}
+
+/*
+ * Converts an array of PyObject * into datetimes and/or timedeltas,
+ * based on the values in type_nums.
+ *
+ * If inout_meta->base is -1, uses GCDs to calculate the metadata, filling
+ * in 'inout_meta' with the resulting metadata. Otherwise uses the provided
+ * 'inout_meta' for all the conversions.
+ *
+ * When obj[i] is NULL, out_value[i] will be set to NPY_DATETIME_NAT.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+NPY_NO_EXPORT int
+convert_pyobjects_to_datetimes(int count,
+                               PyObject **objs, int *type_nums,
+                               NPY_CASTING casting,
+                               npy_int64 *out_values,
+                               PyArray_DatetimeMetaData *inout_meta)
+{
+    int i, is_out_strict;
+    PyArray_DatetimeMetaData *meta;
+
+    /* No values trivially succeeds */
+    if (count == 0) {
+        return 0;
+    }
+
+    /* Use the inputs to resolve the unit metadata if requested */
+    if (inout_meta->base == -1) {
+        /* Allocate an array of metadata corresponding to the objects */
+        meta = PyArray_malloc(count * sizeof(PyArray_DatetimeMetaData));
+        if (meta == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+
+        /* Convert all the objects into timedeltas or datetimes */
+        for (i = 0; i < count; ++i) {
+            meta[i].base = -1;
+            meta[i].num = 1;
+
+            /* NULL -> NaT */
+            if (objs[i] == NULL) {
+                out_values[i] = NPY_DATETIME_NAT;
+                meta[i].base = NPY_FR_GENERIC;
+            }
+            else if (type_nums[i] == NPY_DATETIME) {
+                if (convert_pyobject_to_datetime(&meta[i], objs[i],
+                                            casting, &out_values[i]) < 0) {
+                    PyArray_free(meta);
+                    return -1;
+                }
+            }
+            else if (type_nums[i] == NPY_TIMEDELTA) {
+                if (convert_pyobject_to_timedelta(&meta[i], objs[i],
+                                            casting, &out_values[i]) < 0) {
+                    PyArray_free(meta);
+                    return -1;
+                }
+            }
+            else {
+                PyErr_SetString(PyExc_ValueError,
+                        "convert_pyobjects_to_datetimes requires that "
+                        "all the type_nums provided be datetime or timedelta");
+                PyArray_free(meta);
+                return -1;
+            }
+        }
+
+        /* Merge all the metadatas, starting with the first one */
+        *inout_meta = meta[0];
+        is_out_strict = (type_nums[0] == NPY_TIMEDELTA);
+
+        for (i = 1; i < count; ++i) {
+            if (compute_datetime_metadata_greatest_common_divisor(
+                                    &meta[i], inout_meta, inout_meta,
+                                    type_nums[i] == NPY_TIMEDELTA,
+                                    is_out_strict) < 0) {
+                PyArray_free(meta);
+                return -1;
+            }
+            is_out_strict = is_out_strict || (type_nums[i] == NPY_TIMEDELTA);
+        }
+
+        /* Convert all the values into the resolved unit metadata */
+        for (i = 0; i < count; ++i) {
+            if (type_nums[i] == NPY_DATETIME) {
+                if (cast_datetime_to_datetime(&meta[i], inout_meta,
+                                         out_values[i], &out_values[i]) < 0) {
+                    PyArray_free(meta);
+                    return -1;
+                }
+            }
+            else if (type_nums[i] == NPY_TIMEDELTA) {
+                if (cast_timedelta_to_timedelta(&meta[i], inout_meta,
+                                         out_values[i], &out_values[i]) < 0) {
+                    PyArray_free(meta);
+                    return -1;
+                }
+            }
+        }
+
+        PyArray_free(meta);
+    }
+    /* Otherwise convert to the provided unit metadata */
+    else {
+        /* Convert all the objects into timedeltas or datetimes */
+        for (i = 0; i < count; ++i) {
+            /* NULL -> NaT */
+            if (objs[i] == NULL) {
+                out_values[i] = NPY_DATETIME_NAT;
+            }
+            else if (type_nums[i] == NPY_DATETIME) {
+                if (convert_pyobject_to_datetime(inout_meta, objs[i],
+                                            casting, &out_values[i]) < 0) {
+                    return -1;
+                }
+            }
+            else if (type_nums[i] == NPY_TIMEDELTA) {
+                if (convert_pyobject_to_timedelta(inout_meta, objs[i],
+                                            casting, &out_values[i]) < 0) {
+                    return -1;
+                }
+            }
+            else {
+                PyErr_SetString(PyExc_ValueError,
+                        "convert_pyobjects_to_datetimes requires that "
+                        "all the type_nums provided be datetime or timedelta");
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+NPY_NO_EXPORT PyArrayObject *
+datetime_arange(PyObject *start, PyObject *stop, PyObject *step,
+                PyArray_Descr *dtype)
+{
+    PyArray_DatetimeMetaData meta;
+    /*
+     * Both datetime and timedelta are stored as int64, so they can
+     * share value variables.
+     */
+    npy_int64 values[3];
+    PyObject *objs[3];
+    int type_nums[3];
+
+    npy_intp i, length;
+    PyArrayObject *ret;
+    npy_int64 *ret_data;
+
+    /*
+     * First normalize the input parameters so there is no Py_None,
+     * and start is moved to stop if stop is unspecified.
+     */
+    if (step == Py_None) {
+        step = NULL;
+    }
+    if (stop == NULL || stop == Py_None) {
+        stop = start;
+        start = NULL;
+        /* If start was NULL or None, raise an exception */
+        if (stop == NULL || stop == Py_None) {
+            PyErr_SetString(PyExc_ValueError,
+                    "arange needs at least a stopping value");
+            return NULL;
+        }
+    }
+    if (start == Py_None) {
+        start = NULL;
+    }
+
+    /* Step must not be a Datetime */
+    if (step != NULL && is_any_numpy_datetime(step)) {
+        PyErr_SetString(PyExc_ValueError,
+                    "cannot use a datetime as a step in arange");
+        return NULL;
+    }
+
+    /* Check if the units of the given dtype are generic, in which
+     * case we use the code path that detects the units
+     */
+    if (dtype != NULL) {
+        PyArray_DatetimeMetaData *meta_tmp;
+
+        type_nums[0] = dtype->type_num;
+        if (type_nums[0] != NPY_DATETIME && type_nums[0] != NPY_TIMEDELTA) {
+            PyErr_SetString(PyExc_ValueError,
+                        "datetime_arange was given a non-datetime dtype");
+            return NULL;
+        }
+
+        meta_tmp = get_datetime_metadata_from_dtype(dtype);
+        if (meta_tmp == NULL) {
+            return NULL;
+        }
+
+        /*
+         * If the dtype specified is in generic units, detect the
+         * units from the input parameters.
+         */
+        if (meta_tmp->base == NPY_FR_GENERIC) {
+            dtype = NULL;
+            meta.base = -1;
+        }
+        /* Otherwise use the provided metadata */
+        else {
+            meta = *meta_tmp;
+        }
+    }
+    else {
+        if ((start && is_any_numpy_datetime(start)) ||
+            is_any_numpy_datetime(stop)) {
+            type_nums[0] = NPY_DATETIME;
+        }
+        else {
+            type_nums[0] = NPY_TIMEDELTA;
+        }
+
+        meta.base = -1;
+    }
+
+    if (type_nums[0] == NPY_DATETIME && start == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+                "arange requires both a start and a stop for "
+                "NumPy datetime64 ranges");
+        return NULL;
+    }
+
+    /* Set up to convert the objects to a common datetime unit metadata */
+    objs[0] = start;
+    objs[1] = stop;
+    objs[2] = step;
+    if (type_nums[0] == NPY_TIMEDELTA) {
+        type_nums[1] = NPY_TIMEDELTA;
+        type_nums[2] = NPY_TIMEDELTA;
+    }
+    else {
+        if (PyInt_Check(objs[1]) ||
+                        PyLong_Check(objs[1]) ||
+                        PyArray_IsScalar(objs[1], Integer) ||
+                        is_any_numpy_timedelta(objs[1])) {
+            type_nums[1] = NPY_TIMEDELTA;
+        }
+        else {
+            type_nums[1] = NPY_DATETIME;
+        }
+        type_nums[2] = NPY_TIMEDELTA;
+    }
+
+    /* Convert all the arguments */
+    if (convert_pyobjects_to_datetimes(3, objs, type_nums,
+                                NPY_SAME_KIND_CASTING, values, &meta) < 0) {
+        return NULL;
+    }
+
+    /* If no step was provided, default to 1 */
+    if (step == NULL) {
+        values[2] = 1;
+    }
+
+    /*
+     * In the case of arange(datetime, timedelta), convert
+     * the timedelta into a datetime by adding the start datetime.
+     */
+    if (type_nums[0] == NPY_DATETIME && type_nums[1] == NPY_TIMEDELTA) {
+        values[1] += values[0];
+    }
+
+    /* Now start, stop, and step have their values and matching metadata */
+    if (values[0] == NPY_DATETIME_NAT ||
+                    values[1] == NPY_DATETIME_NAT ||
+                    values[2] == NPY_DATETIME_NAT) {
+        PyErr_SetString(PyExc_ValueError,
+                    "arange: cannot use NaT (not-a-time) datetime values");
+        return NULL;
+    }
+
+    /* Calculate the array length */
+    if (values[2] > 0 && values[1] > values[0]) {
+        length = (values[1] - values[0] + (values[2] - 1)) / values[2];
+    }
+    else if (values[2] < 0 && values[1] < values[0]) {
+        length = (values[1] - values[0] + (values[2] + 1)) / values[2];
+    }
+    else if (values[2] != 0) {
+        length = 0;
+    }
+    else {
+        PyErr_SetString(PyExc_ValueError,
+                    "arange: step cannot be zero");
+        return NULL;
+    }
+
+    /* Create the dtype of the result */
+    if (dtype != NULL) {
+        Py_INCREF(dtype);
+    }
+    else {
+        dtype = create_datetime_dtype(type_nums[0], &meta);
+        if (dtype == NULL) {
+            return NULL;
+        }
+    }
+
+    /* Create the result array */
+    ret = (PyArrayObject *)PyArray_NewFromDescr(
+                            &PyArray_Type, dtype, 1, &length, NULL,
+                            NULL, 0, NULL);
+    if (ret == NULL) {
+        return NULL;
+    }
+
+    if (length > 0) {
+        /* Extract the data pointer */
+        ret_data = (npy_int64 *)PyArray_DATA(ret);
+
+        /* Create the timedeltas or datetimes */
+        for (i = 0; i < length; ++i) {
+            *ret_data = values[0];
+            values[0] += values[2];
+            ret_data++;
+        }
+    }
+
+    return ret;
+}
+
+/*
+ * Examines all the strings in the given string array, and parses them
+ * to find the right metadata.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+find_string_array_datetime64_type(PyArrayObject *arr,
+                        PyArray_DatetimeMetaData *meta)
+{
+    NpyIter* iter;
+    NpyIter_IterNextFunc *iternext;
+    char **dataptr;
+    npy_intp *strideptr, *innersizeptr;
+    PyArray_Descr *string_dtype;
+    int maxlen;
+    char *tmp_buffer = NULL;
+
+    npy_datetimestruct dts;
+    PyArray_DatetimeMetaData tmp_meta;
+
+    /* Handle zero-sized arrays specially */
+    if (PyArray_SIZE(arr) == 0) {
+        return 0;
+    }
+
+    string_dtype = PyArray_DescrFromType(NPY_STRING);
+    if (string_dtype == NULL) {
+        return -1;
+    }
+
+    /* Use unsafe casting to allow unicode -> ascii string */
+    iter = NpyIter_New((PyArrayObject *)arr,
+                            NPY_ITER_READONLY|
+                            NPY_ITER_EXTERNAL_LOOP|
+                            NPY_ITER_BUFFERED,
+                        NPY_KEEPORDER, NPY_UNSAFE_CASTING,
+                        string_dtype);
+    Py_DECREF(string_dtype);
+    if (iter == NULL) {
+        return -1;
+    }
+
+    iternext = NpyIter_GetIterNext(iter, NULL);
+    if (iternext == NULL) {
+        NpyIter_Deallocate(iter);
+        return -1;
+    }
+    dataptr = NpyIter_GetDataPtrArray(iter);
+    strideptr = NpyIter_GetInnerStrideArray(iter);
+    innersizeptr = NpyIter_GetInnerLoopSizePtr(iter);
+
+    /* Get the resulting string length */
+    maxlen = NpyIter_GetDescrArray(iter)[0]->elsize;
+
+    /* Allocate a buffer for strings which fill the buffer completely */
+    tmp_buffer = PyArray_malloc(maxlen+1);
+    if (tmp_buffer == NULL) {
+        PyErr_NoMemory();
+        NpyIter_Deallocate(iter);
+        return -1;
+    }
+
+    /* The iteration loop */
+    do {
+        /* Get the inner loop data/stride/count values */
+        char* data = *dataptr;
+        npy_intp stride = *strideptr;
+        npy_intp count = *innersizeptr;
+        char *tmp;
+
+        /* The inner loop */
+        while (count--) {
+            /* Replicating strnlen with memchr, because Mac OS X lacks it */
+            tmp = memchr(data, '\0', maxlen);
+
+            /* If the string is all full, use the buffer */
+            if (tmp == NULL) {
+                memcpy(tmp_buffer, data, maxlen);
+                tmp_buffer[maxlen] = '\0';
+
+                tmp_meta.base = -1;
+                if (parse_iso_8601_datetime(tmp_buffer, maxlen, -1,
+                                    NPY_UNSAFE_CASTING, &dts, NULL,
+                                    &tmp_meta.base, NULL) < 0) {
+                    goto fail;
+                }
+            }
+            /* Otherwise parse the data in place */
+            else {
+                tmp_meta.base = -1;
+                if (parse_iso_8601_datetime(data, tmp - data, -1,
+                                    NPY_UNSAFE_CASTING, &dts, NULL,
+                                    &tmp_meta.base, NULL) < 0) {
+                    goto fail;
+                }
+            }
+
+            tmp_meta.num = 1;
+            /* Combine it with 'meta' */
+            if (compute_datetime_metadata_greatest_common_divisor(meta,
+                            &tmp_meta, meta, 0, 0) < 0) {
+                goto fail;
+            }
+
+
+            data += stride;
+        }
+    } while(iternext(iter));
+
+    PyArray_free(tmp_buffer);
+    NpyIter_Deallocate(iter);
+
+    return 0;
+
+fail:
+    PyArray_free(tmp_buffer);
+    NpyIter_Deallocate(iter);
+
+    return -1;
+}
+
+
+/*
+ * Recursively determines the metadata for an NPY_DATETIME dtype.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+recursive_find_object_datetime64_type(PyObject *obj,
+                        PyArray_DatetimeMetaData *meta)
+{
+    /* Array -> use its metadata */
+    if (PyArray_Check(obj)) {
+        PyArrayObject *arr = (PyArrayObject *)obj;
+        PyArray_Descr *arr_dtype = PyArray_DESCR(arr);
+
+        if (arr_dtype->type_num == NPY_STRING ||
+                            arr_dtype->type_num == NPY_UNICODE) {
+            return find_string_array_datetime64_type(arr, meta);
+        }
+        /* If the array has metadata, use it */
+        else if (arr_dtype->type_num == NPY_DATETIME ||
+                    arr_dtype->type_num == NPY_TIMEDELTA) {
+            PyArray_DatetimeMetaData *tmp_meta;
+
+            /* Get the metadata from the type */
+            tmp_meta = get_datetime_metadata_from_dtype(arr_dtype);
+            if (tmp_meta == NULL) {
+                return -1;
+            }
+
+            /* Combine it with 'meta' */
+            if (compute_datetime_metadata_greatest_common_divisor(meta,
+                            tmp_meta, meta, 0, 0) < 0) {
+                return -1;
+            }
+
+            return 0;
+        }
+        /* If it's not an object array, stop looking */
+        else if (arr_dtype->type_num != NPY_OBJECT) {
+            return 0;
+        }
+    }
+    /* Datetime scalar -> use its metadata */
+    else if (PyArray_IsScalar(obj, Datetime)) {
+        PyDatetimeScalarObject *dts = (PyDatetimeScalarObject *)obj;
+
+        /* Combine it with 'meta' */
+        if (compute_datetime_metadata_greatest_common_divisor(meta,
+                        &dts->obmeta, meta, 0, 0) < 0) {
+            return -1;
+        }
+
+        return 0;
+    }
+    /* String -> parse it to find out */
+    else if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
+        npy_datetime tmp = 0;
+        PyArray_DatetimeMetaData tmp_meta;
+
+        tmp_meta.base = -1;
+        tmp_meta.num = 1;
+
+        if (convert_pyobject_to_datetime(&tmp_meta, obj,
+                                        NPY_UNSAFE_CASTING, &tmp) < 0) {
+            /* If it's a value error, clear the error */
+            if (PyErr_Occurred() &&
+                    PyErr_GivenExceptionMatches(PyErr_Occurred(),
+                                    PyExc_ValueError)) {
+                PyErr_Clear();
+                return 0;
+            }
+            /* Otherwise propagate the error */
+            else {
+                return -1;
+            }
+        }
+
+        /* Combine it with 'meta' */
+        if (compute_datetime_metadata_greatest_common_divisor(meta,
+                        &tmp_meta, meta, 0, 0) < 0) {
+            return -1;
+        }
+
+        return 0;
+    }
+    /* Python date object -> 'D' */
+    else if (PyDate_Check(obj)) {
+        PyArray_DatetimeMetaData tmp_meta;
+
+        tmp_meta.base = NPY_FR_D;
+        tmp_meta.num = 1;
+
+        /* Combine it with 'meta' */
+        if (compute_datetime_metadata_greatest_common_divisor(meta,
+                        &tmp_meta, meta, 0, 0) < 0) {
+            return -1;
+        }
+
+        return 0;
+    }
+    /* Python datetime object -> 'us' */
+    else if (PyDateTime_Check(obj)) {
+        PyArray_DatetimeMetaData tmp_meta;
+
+        tmp_meta.base = NPY_FR_us;
+        tmp_meta.num = 1;
+
+        /* Combine it with 'meta' */
+        if (compute_datetime_metadata_greatest_common_divisor(meta,
+                        &tmp_meta, meta, 0, 0) < 0) {
+            return -1;
+        }
+
+        return 0;
+    }
+
+    /* Now check if what we have left is a sequence for recursion */
+    if (PySequence_Check(obj)) {
+        Py_ssize_t i, len = PySequence_Size(obj);
+        if (len < 0 && PyErr_Occurred()) {
+            return -1;
+        }
+
+        for (i = 0; i < len; ++i) {
+            PyObject *f = PySequence_GetItem(obj, i);
+            if (f == NULL) {
+                return -1;
+            }
+            if (f == obj) {
+                Py_DECREF(f);
+                return 0;
+            }
+            if (recursive_find_object_datetime64_type(f, meta) < 0) {
+                Py_DECREF(f);
+                return -1;
+            }
+            Py_DECREF(f);
+        }
+
+        return 0;
+    }
+    /* Otherwise ignore it */
+    else {
+        return 0;
+    }
+}
+
+/*
+ * Recursively determines the metadata for an NPY_TIMEDELTA dtype.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+recursive_find_object_timedelta64_type(PyObject *obj,
+                        PyArray_DatetimeMetaData *meta)
+{
+    /* Array -> use its metadata */
+    if (PyArray_Check(obj)) {
+        PyArrayObject *arr = (PyArrayObject *)obj;
+        PyArray_Descr *arr_dtype = PyArray_DESCR(arr);
+
+        /* If the array has metadata, use it */
+        if (arr_dtype->type_num == NPY_DATETIME ||
+                    arr_dtype->type_num == NPY_TIMEDELTA) {
+            PyArray_DatetimeMetaData *tmp_meta;
+
+            /* Get the metadata from the type */
+            tmp_meta = get_datetime_metadata_from_dtype(arr_dtype);
+            if (tmp_meta == NULL) {
+                return -1;
+            }
+
+            /* Combine it with 'meta' */
+            if (compute_datetime_metadata_greatest_common_divisor(meta,
+                            tmp_meta, meta, 0, 0) < 0) {
+                return -1;
+            }
+
+            return 0;
+        }
+        /* If it's not an object array, stop looking */
+        else if (arr_dtype->type_num != NPY_OBJECT) {
+            return 0;
+        }
+    }
+    /* Datetime scalar -> use its metadata */
+    else if (PyArray_IsScalar(obj, Timedelta)) {
+        PyTimedeltaScalarObject *dts = (PyTimedeltaScalarObject *)obj;
+
+        /* Combine it with 'meta' */
+        if (compute_datetime_metadata_greatest_common_divisor(meta,
+                        &dts->obmeta, meta, 1, 1) < 0) {
+            return -1;
+        }
+
+        return 0;
+    }
+    /* String -> parse it to find out */
+    else if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
+        /* No timedelta parser yet */
+        return 0;
+    }
+    /* Python timedelta object -> 'us' */
+    else if (PyDelta_Check(obj)) {
+        PyArray_DatetimeMetaData tmp_meta;
+
+        tmp_meta.base = NPY_FR_us;
+        tmp_meta.num = 1;
+
+        /* Combine it with 'meta' */
+        if (compute_datetime_metadata_greatest_common_divisor(meta,
+                        &tmp_meta, meta, 0, 0) < 0) {
+            return -1;
+        }
+
+        return 0;
+    }
+
+    /* Now check if what we have left is a sequence for recursion */
+    if (PySequence_Check(obj)) {
+        Py_ssize_t i, len = PySequence_Size(obj);
+        if (len < 0 && PyErr_Occurred()) {
+            return -1;
+        }
+
+        for (i = 0; i < len; ++i) {
+            PyObject *f = PySequence_GetItem(obj, i);
+            if (f == NULL) {
+                return -1;
+            }
+            if (f == obj) {
+                Py_DECREF(f);
+                return 0;
+            }
+            if (recursive_find_object_timedelta64_type(f, meta) < 0) {
+                Py_DECREF(f);
+                return -1;
+            }
+            Py_DECREF(f);
+        }
+
+        return 0;
+    }
+    /* Otherwise ignore it */
+    else {
+        return 0;
+    }
+}
+
+/*
+ * Examines all the objects in the given Python object by
+ * recursively descending the sequence structure. Returns a
+ * datetime or timedelta type with metadata based on the data.
+ */
+NPY_NO_EXPORT PyArray_Descr *
+find_object_datetime_type(PyObject *obj, int type_num)
+{
+    PyArray_DatetimeMetaData meta;
+
+    meta.base = NPY_FR_GENERIC;
+    meta.num = 1;
+
+    if (type_num == NPY_DATETIME) {
+        if (recursive_find_object_datetime64_type(obj, &meta) < 0) {
+            return NULL;
+        }
+        else {
+            return create_datetime_dtype(type_num, &meta);
+        }
+    }
+    else if (type_num == NPY_TIMEDELTA) {
+        if (recursive_find_object_timedelta64_type(obj, &meta) < 0) {
+            return NULL;
+        }
+        else {
+            return create_datetime_dtype(type_num, &meta);
+        }
+    }
+    else {
+        PyErr_SetString(PyExc_ValueError,
+                    "find_object_datetime_type needs a datetime or "
+                    "timedelta type number");
+        return NULL;
+    }
+}