wip

Author: MarcoGorelli

pandas/_libs/tslib.pyx

@@ -546,17 +546,10 @@ cpdef array_to_datetime(
                     seen_datetime = True
                     iresult[i] = get_datetime64_nanos(val, NPY_FR_ns)
 
-                elif is_integer_object(val) or is_float_object(val):
-                    if require_iso8601:
-                        if is_coerce:
-                            iresult[i] = NPY_NAT
-                            continue
-                        elif is_raise:
-                            raise ValueError(
-                                f"time data \"{val}\" at position {i} doesn't "
-                                f"match format \"{format}\""
-                            )
-                        return values, tz_out
+                elif (
+                    (is_integer_object(val) or is_float_object(val))
+                    and format is None
+                ):
                     # these must be ns unit by-definition
                     seen_integer = True
 
@@ -575,7 +568,11 @@ cpdef array_to_datetime(
                         except OverflowError:
                             iresult[i] = NPY_NAT
 
-                elif isinstance(val, str):
+                elif (
+                    (is_integer_object(val) or is_float_object(val))
+                    or isinstance(val, str)
+                ):
+                    print("val", val)
                     # string
                     if type(val) is not str:
                         # GH#32264 np.str_ object
@@ -589,6 +586,7 @@ cpdef array_to_datetime(
                         val, &dts, &out_bestunit, &out_local,
                         &out_tzoffset, False, format, exact
                     )
+                    print("failed", string_to_dts_failed)
                     if string_to_dts_failed:
                         # An error at this point is a _parsing_ error
                         # specifically _not_ OutOfBoundsDatetime
@@ -655,6 +653,7 @@ cpdef array_to_datetime(
                             # parsing mixed naive and aware strings
                             out_tzoffset_vals.add("naive")
                         iresult[i] = value
+                        print("value", value)
                         check_dts_bounds(&dts)
 
                 else:

pandas/_libs/tslibs/parsing.pyx

@@ -18,6 +18,13 @@ from cpython.object cimport PyObject_Str
 from cython cimport Py_ssize_t
 from libc.string cimport strchr
 
+from pandas._libs.missing cimport checknull_with_nat_and_na
+from pandas._libs.tslibs.conversion cimport (
+    _TSObject,
+    cast_from_unit,
+    convert_datetime_to_tsobject,
+)
+
 import_datetime()
 
 import numpy as np
@@ -32,6 +39,8 @@ from numpy cimport (
     float64_t,
 )
 
+from pandas._libs.tslibs.nattype cimport NPY_NAT
+
 cnp.import_array()
 
 # dateutil compat
@@ -61,7 +70,9 @@ from pandas._libs.tslibs.np_datetime cimport (
     string_to_dts,
 )
 from pandas._libs.tslibs.offsets cimport is_offset_object
+
 from pandas._libs.tslibs.strptime import array_strptime
+
 from pandas._libs.tslibs.util cimport (
     get_c_string_buf_and_size,
     is_array,
@@ -744,21 +755,53 @@ def try_parse_dates(
     return result.base  # .base to access underlying ndarray
 
 
-def try_parse_year_month_day(
-    object[:] years, object[:] months, object[:] days
-) -> np.ndarray:
+cpdef try_parse_year_month_day(
+    object[:] values,
+    str errors,
+    bint exact,
+):
     cdef:
         Py_ssize_t i, n
-        object[::1] result
+        #object[::1] result
+        object val
+        int year, month, day
+        bint is_ignore = errors=="ignore"
+        bint is_coerce = errors=="coerce"
+        bint is_raise = errors=="raise"
 
-    n = len(years)
-    # TODO(cython3): Use len instead of `shape[0]`
-    if months.shape[0] != n or days.shape[0] != n:
-        raise ValueError("Length of years/months/days must all be equal")
-    result = np.empty(n, dtype="O")
+    n = len(values)
+    #result = np.empty(n, dtype="O")
+    result = np.empty(n, dtype="M8[ns]")
+    iresult = result.view("i8")
 
     for i in range(n):
-        result[i] = datetime(int(years[i]), int(months[i]), int(days[i]))
+        val = values[i]
+        if checknull_with_nat_and_na(val):
+            iresult[i] = NPY_NAT
+            continue
+        strval = str(val)
+        if strval in nat_strings:
+            result[i] = NPY_NAT
+            continue
+        year = int(strval[:4])
+        month = int(strval[4:6])
+        day = int(strval[6:8])
+        if exact and strval[8:]:
+            if is_coerce:
+                result[i] = NPY_NAT
+            elif is_raise:
+                raise ValueError(f"{val} does not match format '%Y%m%d'")
+        from pandas._libs.tslibs import OutOfBoundsDatetime
+        try:
+            dt =datetime(year, month, day)
+            ts = convert_datetime_to_tsobject(dt, None)
+        except (OutOfBoundsDatetime, ValueError):
+            if is_coerce:
+                iresult[i] = NPY_NAT
+            elif is_raise:
+                raise
+        else:
+            iresult[i] = ts.value
 
     return result.base  # .base to access underlying ndarray
 
@@ -890,7 +933,7 @@ def format_is_iso(f: str) -> bint:
     but must be consistent.  Leading 0s in dates and times are optional.
     """
     iso_template = "%Y{date_sep}%m{date_sep}%d{time_sep}%H:%M:%S{micro_or_tz}".format
-    excluded_formats = ["%Y%m%d", "%Y%m", "%Y"]
+    excluded_formats = ["%Y%m", "%Y"]
 
     for date_sep in [" ", "/", "\\", "-", ".", ""]:
         for time_sep in [" ", "T"]:

pandas/core/tools/datetimes.py

@@ -532,7 +532,7 @@ def _to_datetime_with_format(
         orig_arg = ensure_object(orig_arg)
         try:
             # may return None without raising
-            result = _attempt_YYYYMMDD(orig_arg, errors=errors)
+            result = _attempt_YYYYMMDD(orig_arg, errors=errors, exact=exact)
         except (ValueError, TypeError, OutOfBoundsDatetime) as err:
             raise ValueError(
                 "cannot convert the input to '%Y%m%d' date format"
@@ -1244,7 +1244,9 @@ def coerce(values):
     return values
 
 
-def _attempt_YYYYMMDD(arg: npt.NDArray[np.object_], errors: str) -> np.ndarray | None:
+def _attempt_YYYYMMDD(
+    arg: npt.NDArray[np.object_], errors: str, exact: bool
+) -> np.ndarray | None:
     """
     try to parse the YYYYMMDD/%Y%m%d format, try to deal with NaT-like,
     arg is a passed in as an object dtype, but could really be ints/strings
@@ -1255,13 +1257,12 @@ def _attempt_YYYYMMDD(arg: npt.NDArray[np.object_], errors: str) -> np.ndarray |
     arg : np.ndarray[object]
     errors : {'raise','ignore','coerce'}
     """
+    return parsing.try_parse_year_month_day(arg, errors, exact)
 
     def calc(carg):
         # calculate the actual result
         carg = carg.astype(object, copy=False)
-        parsed = parsing.try_parse_year_month_day(
-            carg / 10000, carg / 100 % 100, carg % 100
-        )
+        parsed = parsing.try_parse_year_month_day(carg)
         return tslib.array_to_datetime(parsed, errors=errors)[0]
 
     def calc_with_mask(carg, mask):
@@ -1275,7 +1276,7 @@ def calc_with_mask(carg, mask):
 
     # try intlike / strings that are ints
     try:
-        return calc(arg.astype(np.int64))
+        return calc(arg)
     except (ValueError, OverflowError, TypeError):
         pass
 

pandas/tests/tools/test_to_datetime.py

@@ -125,14 +125,16 @@ def test_to_datetime_format_YYYYMMDD_with_nat(self, cache):
         expected[2] = np.nan
         ser[2] = np.nan
 
-        result = to_datetime(ser, format="%Y%m%d", cache=cache)
-        tm.assert_series_equal(result, expected)
+        with pytest.raises(ValueError, match=None):
+            result = to_datetime(ser, format="%Y%m%d", cache=cache)
+        # tm.assert_series_equal(result, expected)
 
         # string with NaT
         ser2 = ser.apply(str)
         ser2[2] = "nat"
-        result = to_datetime(ser2, format="%Y%m%d", cache=cache)
-        tm.assert_series_equal(result, expected)
+        with pytest.raises(ValueError, match=None):
+            result = to_datetime(ser2, format="%Y%m%d", cache=cache)
+        # tm.assert_series_equal(result, expected)
 
     def test_to_datetime_format_YYYYMMDD_ignore(self, cache):
         # coercion