ENH: ISO8601-compliant datetime string conversion in iterrows() and Series construction.

pandas/core/dtypes/cast.py

@@ -860,7 +860,9 @@ def maybe_castable(arr):
     return arr.dtype.name not in _POSSIBLY_CAST_DTYPES
 
 
-def maybe_infer_to_datetimelike(value, convert_dates=False):
+def maybe_infer_to_datetimelike(value,
+                                convert_dates=False,
+                                require_iso8601=False):
     """
     we might have a array (or single object) that is datetime like,
     and no dtype is passed don't change the value unless we find a
@@ -875,6 +877,8 @@ def maybe_infer_to_datetimelike(value, convert_dates=False):
     convert_dates : boolean, default False
        if True try really hard to convert dates (such as datetime.date), other
        leave inferred dtype 'date' alone
+    require_iso8601 : boolean, default False
+        If True, only try to infer ISO8601-compliant datetime string.
 
     """
 
@@ -901,18 +905,19 @@ def maybe_infer_to_datetimelike(value, convert_dates=False):
     if not len(v):
         return value
 
-    def try_datetime(v):
+    def try_datetime(v, require_iso8601=require_iso8601):
         # safe coerce to datetime64
         try:
-            v = tslib.array_to_datetime(v, errors='raise')
+            v = tslib.array_to_datetime(v,
+                                        require_iso8601=require_iso8601,
+                                        errors='raise')
         except ValueError:
-
             # we might have a sequence of the same-datetimes with tz's
             # if so coerce to a DatetimeIndex; if they are not the same,
             # then these stay as object dtype
             try:
                 from pandas import to_datetime
-                return to_datetime(v)
+                return to_datetime(v, require_iso8601=require_iso8601)
             except Exception:
                 pass
 
@@ -957,7 +962,8 @@ def try_timedelta(v):
     return value
 
 
-def maybe_cast_to_datetime(value, dtype, errors='raise'):
+def maybe_cast_to_datetime(value, dtype, require_iso8601=False,
+                           errors='raise'):
     """ try to cast the array/value to a datetimelike dtype, converting float
     nan to iNaT
     """
@@ -1074,7 +1080,9 @@ def maybe_cast_to_datetime(value, dtype, errors='raise'):
         # conversion
         elif not (is_array and not (issubclass(value.dtype.type, np.integer) or
                                     value.dtype == np.object_)):
-            value = maybe_infer_to_datetimelike(value)
+            value = \
+                maybe_infer_to_datetimelike(value,
+                                            require_iso8601=require_iso8601)
 
     return value
 

pandas/core/frame.py

@@ -710,10 +710,16 @@ def iteritems(self):
             for i, k in enumerate(self.columns):
                 yield k, self._ixs(i, axis=1)
 
-    def iterrows(self):
+    def iterrows(self, require_iso8601=False):
         """
         Iterate over DataFrame rows as (index, Series) pairs.
 
+        Parameters
+        ----------
+        require_iso8601 : boolean, default False
+            If True, only try to infer ISO8601-compliant datetime string in
+            iterated rows.
+
         Notes
         -----
 
@@ -755,7 +761,10 @@ def iterrows(self):
         columns = self.columns
         klass = self._constructor_sliced
         for k, v in zip(self.index, self.values):
-            s = klass(v, index=columns, name=k)
+            s = klass(v,
+                      index=columns,
+                      name=k,
+                      require_iso8601=require_iso8601)
             yield k, s
 
     def itertuples(self, index=True, name="Pandas"):

pandas/core/series.py

@@ -146,7 +146,7 @@ class Series(base.IndexOpsMixin, generic.NDFrame):
          'from_csv', 'valid'])
 
     def __init__(self, data=None, index=None, dtype=None, name=None,
-                 copy=False, fastpath=False):
+                 copy=False, fastpath=False, require_iso8601=False):
 
         # we are called internally, so short-circuit
         if fastpath:
@@ -236,7 +236,8 @@ def __init__(self, data=None, index=None, dtype=None, name=None,
                     data = data.copy()
             else:
                 data = _sanitize_array(data, index, dtype, copy,
-                                       raise_cast_failure=True)
+                                       raise_cast_failure=True,
+                                       require_iso8601=require_iso8601)
 
                 data = SingleBlockManager(data, index, fastpath=True)
 
@@ -3129,7 +3130,7 @@ def _sanitize_index(data, index, copy=False):
 
 
 def _sanitize_array(data, index, dtype=None, copy=False,
-                    raise_cast_failure=False):
+                    raise_cast_failure=False, require_iso8601=False):
     """ sanitize input data to an ndarray, copy if specified, coerce to the
     dtype if specified
     """
@@ -3145,15 +3146,17 @@ def _sanitize_array(data, index, dtype=None, copy=False,
         else:
             data = data.copy()
 
-    def _try_cast(arr, take_fast_path):
+    def _try_cast(arr, take_fast_path, require_iso8601=require_iso8601):
 
         # perf shortcut as this is the most common case
         if take_fast_path:
             if maybe_castable(arr) and not copy and dtype is None:
                 return arr
 
         try:
-            subarr = maybe_cast_to_datetime(arr, dtype)
+            subarr = maybe_cast_to_datetime(arr,
+                                            dtype,
+                                            require_iso8601=require_iso8601)
             if not is_extension_type(subarr):
                 subarr = np.array(subarr, dtype=dtype, copy=copy)
         except (ValueError, TypeError):
@@ -3211,7 +3214,9 @@ def _try_cast(arr, take_fast_path):
         else:
             subarr = maybe_convert_platform(data)
 
-        subarr = maybe_cast_to_datetime(subarr, dtype)
+        subarr = maybe_cast_to_datetime(subarr,
+                                        dtype,
+                                        require_iso8601=require_iso8601)
 
     elif isinstance(data, range):
         # GH 16804
@@ -3233,7 +3238,9 @@ def _try_cast(arr, take_fast_path):
                 dtype, value = infer_dtype_from_scalar(value)
             else:
                 # need to possibly convert the value here
-                value = maybe_cast_to_datetime(value, dtype)
+                value = maybe_cast_to_datetime(subarr,
+                                               dtype,
+                                               require_iso8601=require_iso8601)
 
             subarr = construct_1d_arraylike_from_scalar(
                 value, len(index), dtype)

pandas/core/tools/datetimes.py

@@ -105,8 +105,8 @@ def _convert_and_box_cache(arg, cache_array, box, errors, name=None):
 
 def to_datetime(arg, errors='raise', dayfirst=False, yearfirst=False,
                 utc=None, box=True, format=None, exact=True,
-                unit=None, infer_datetime_format=False, origin='unix',
-                cache=False):
+                unit=None, infer_datetime_format=False, require_iso8601=False,
+                origin='unix', cache=False):
     """
     Convert argument to datetime.
 
@@ -167,6 +167,8 @@ def to_datetime(arg, errors='raise', dayfirst=False, yearfirst=False,
         datetime strings, and if it can be inferred, switch to a faster
         method of parsing them. In some cases this can increase the parsing
         speed by ~5-10x.
+    require_iso8601 : boolean, default False
+        If True, only try to infer ISO8601-compliant datetime string.
     origin : scalar, default is 'unix'
         Define the reference date. The numeric values would be parsed as number
         of units (defined by `unit`) since this reference date.
@@ -273,7 +275,8 @@ def to_datetime(arg, errors='raise', dayfirst=False, yearfirst=False,
 
     tz = 'utc' if utc else None
 
-    def _convert_listlike(arg, box, format, name=None, tz=tz):
+    def _convert_listlike(arg, box, format, name=None, tz=tz,
+                          require_iso8601=require_iso8601):
 
         if isinstance(arg, (list, tuple)):
             arg = np.array(arg, dtype='O')
@@ -313,11 +316,8 @@ def _convert_listlike(arg, box, format, name=None, tz=tz):
                             '1-d array, or Series')
 
         arg = _ensure_object(arg)
-        require_iso8601 = False
-
         if infer_datetime_format and format is None:
             format = _guess_datetime_format_for_array(arg, dayfirst=dayfirst)
-
         if format is not None:
             # There is a special fast-path for iso8601 formatted
             # datetime strings, so in those cases don't use the inferred