Add date dtype

pandas/core/arrays/dates.py

@@ -0,0 +1,191 @@
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.arrays.datetimelike import DatelikeOps, DatetimeLikeArrayMixin
+from pandas.core.arrays.datetimes import sequence_to_dt64ns
+from pandas.core.dtypes.common import (
+    is_integer_dtype,
+    is_datetime64_dtype,
+    is_object_dtype,
+    pandas_dtype,
+)
+from pandas.core.dtypes.generic import ABCSeries, ABCIndexClass
+from pandas.core.dtypes.dtypes import DateDtype
+from pandas.core.construction import array
+from pandas._libs.tslibs import Timestamp
+from pandas._libs.tslibs.conversion import NS_DTYPE
+from pandas._libs import tslib, lib
+
+import numpy as np
+
+D_DATETIME_DTYPE = "datetime64[D]"
+INTEGER_BACKEND = "i8"
+VALID_TYPES = {INTEGER_BACKEND, "datetime64[ns]", D_DATETIME_DTYPE, "object"}
+
+
+def _to_date_values(values, copy=False):
+    data, _, _ = sequence_to_dt64ns(values, copy=copy)
+    return data.astype(D_DATETIME_DTYPE)
+
+
+class DateArray(DatetimeLikeArrayMixin, DatelikeOps):
+    """
+    Pandas ExtensionArray for date (year, month, day only) data.
+
+     .. warning::
+
+       DateArray is currently experimental, and its API may change
+       without warning. In particular, :attr:`DateArray.dtype` is
+       expected to change to always be an instance of an ``ExtensionDtype``
+       subclass.
+
+    Parameters
+    ----------
+    values : Series, Index, DateArray, ndarray
+        The date data.
+    freq : str or Offset, optional
+    dtype : pd.DateDtype
+
+    copy : bool, default False
+        Whether to copy the underlying array of values.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    None
+    """
+
+    freq = "D"
+
+    def __init__(self, values, copy=False):
+        if isinstance(values, (ABCSeries, ABCIndexClass)):
+            values = values._values
+
+        if isinstance(values, type(self)):
+            values = values._data
+
+        if not isinstance(values, np.ndarray):
+            msg = (
+                f"Unexpected type '{type(values).__name__}'. 'values' must be "
+                "a DateArray ndarray, or Series or Index containing one of"
+                " those."
+            )
+            raise ValueError(msg)
+
+        if not self._is_compatible_dtype(values.dtype):
+            msg = (
+                f"The dtype of 'values' is incorrect. Must be one of {VALID_TYPES}."
+                f" Got {values.dtype} instead."
+            )
+            raise ValueError(msg)
+
+        if values.dtype == INTEGER_BACKEND:
+            values = values.view(D_DATETIME_DTYPE)
+        elif values.dtype != "datetime64[D]":
+            values = _to_date_values(values, copy)
+
+        if copy:
+            values = values.copy()
+
+        self._data = values
+
+    @staticmethod
+    def _is_compatible_dtype(dtype):
+        return (
+            is_integer_dtype(dtype)
+            or is_object_dtype(dtype)
+            or is_datetime64_dtype(dtype)
+            or dtype == "datetime64[D]"
+        )
+
+    @classmethod
+    def _simple_new(cls, values, **kwargs):
+        assert isinstance(values, np.ndarray)
+        if values.dtype == INTEGER_BACKEND:
+            values = values.view(D_DATETIME_DTYPE)
+
+        result = object.__new__(cls)
+        result._data = values
+        return result
+
+    @classmethod
+    def _from_sequence(cls, scalars, dtype=None, copy=False):
+        """
+        Construct a new ExtensionArray from a sequence of scalars.
+
+        Parameters
+        ----------
+        scalars : Sequence
+            Each element will be an instance of the scalar type for this
+            array, ``cls.dtype.type``.
+        dtype : dtype, optional
+            Construct for this particular dtype. This should be a Dtype
+            compatible with the ExtensionArray.
+        copy : bool, default False
+            If True, copy the underlying data.
+
+        Returns
+        -------
+        DateArray
+        """
+        if (
+            isinstance(scalars, np.ndarray)
+            and lib.infer_dtype(scalars, skipna=True) == "integer"
+        ):
+            values = scalars.astype(INTEGER_BACKEND)
+        elif is_integer_dtype(scalars):
+            values = scalars._data
+        else:
+            values = _to_date_values(scalars, copy)
+        return cls._simple_new(values)
+
+    @property
+    def dtype(self) -> ExtensionDtype:
+        return DateDtype()
+
+    def __iter__(self):
+        for date_data in self._data:
+            yield date_data
+
+    @property
+    def _box_func(self):
+        # TODO Implement Datestamp of a similar form in cython
+        return lambda x: Timestamp(x, freq="D", tz="utc")
+
+    @property
+    def asi8(self) -> np.ndarray:
+        return self._data.view(INTEGER_BACKEND)
+
+    @property
+    def as_datetime_i8(self) -> np.ndarray:
+        return self._data.astype(NS_DTYPE).view(INTEGER_BACKEND)
+
+    @property
+    def date(self):
+        timestamps = self.as_datetime_i8
+        return tslib.ints_to_pydatetime(timestamps, box="date")
+
+    def astype(self, dtype, copy=True):
+        dtype = pandas_dtype(dtype)
+        if isinstance(dtype, type(self.dtype)):
+            if copy:
+                return self.copy()
+            return self
+        if is_datetime64_dtype(dtype):
+            return array(self._data, dtype=NS_DTYPE)
+        if is_object_dtype(dtype):
+            return self._box_values(self.as_datetime_i8)
+        return super().astype(dtype, copy)
+
+    def _format_native_types(self, na_rep="NaT", date_format=None):
+        from pandas.io.formats.format import _get_format_datetime64_from_values
+
+        fmt = _get_format_datetime64_from_values(self, date_format)
+
+        return tslib.format_array_from_datetime(
+            self.as_datetime_i8, tz="utc", format=fmt, na_rep=na_rep
+        )
+
+    def __len__(self):
+        return len(self._data)

pandas/core/arrays/datetimes.py

@@ -29,6 +29,7 @@
     is_datetime64_dtype,
     is_datetime64_ns_dtype,
     is_datetime64tz_dtype,
+    is_date_dtype,
     is_dtype_equal,
     is_extension_array_dtype,
     is_float_dtype,
@@ -601,6 +602,8 @@ def astype(self, dtype, copy=True):
             return self
         elif is_period_dtype(dtype):
             return self.to_period(freq=dtype.freq)
+        elif is_date_dtype(dtype):
+            return dtype.construct_array_type()._from_sequence(self._data, copy)
         return dtl.DatetimeLikeArrayMixin.astype(self, dtype, copy)
 
     # -----------------------------------------------------------------

pandas/core/dtypes/common.py

@@ -14,6 +14,7 @@
 from pandas.core.dtypes.dtypes import (
     CategoricalDtype,
     DatetimeTZDtype,
+    DateDtype,
     ExtensionDtype,
     IntervalDtype,
     PeriodDtype,
@@ -419,6 +420,38 @@ def is_datetime64tz_dtype(arr_or_dtype) -> bool:
     return DatetimeTZDtype.is_dtype(arr_or_dtype)
 
 
+def is_date_dtype(arr_or_dtype) -> bool:
+    """
+    Check whether an array-like or dtype is of the date dtype.
+
+    Parameters
+    ----------
+    arr_or_dtype : array-like
+        The array-like or dtype to check.
+
+    Returns
+    -------
+    boolean
+        Whether or not the array-like or dtype is of the date dtype.
+
+    Examples
+    --------
+    >>> is_date_dtype(object)
+    False
+    >>> is_date_dtype(np.datetime64)
+    False
+    >>> is_date_dtype(pd.Date64Dtype())
+    True
+    >>> is_date_dtype([1, 2, 3])
+    False
+    >>> is_date_dtype(pd.Series([], dtype="date"))
+    True
+    >>> is_date_dtype('0 days')
+    False
+    """
+    return DateDtype.is_dtype(arr_or_dtype)
+
+
 def is_timedelta64_dtype(arr_or_dtype) -> bool:
     """
     Check whether an array-like or dtype is of the timedelta64 dtype.

pandas/io/formats/format.py

@@ -46,6 +46,7 @@
     is_complex_dtype,
     is_datetime64_dtype,
     is_datetime64tz_dtype,
+    is_date_dtype,
     is_extension_array_dtype,
     is_float,
     is_float_dtype,
@@ -60,6 +61,7 @@
 
 from pandas.core.arrays.datetimes import DatetimeArray
 from pandas.core.arrays.timedeltas import TimedeltaArray
+from pandas.core.arrays.dates import DateArray
 from pandas.core.base import PandasObject
 import pandas.core.common as com
 from pandas.core.construction import extract_array
@@ -1120,6 +1122,8 @@ def format_array(
         fmt_klass = Datetime64TZFormatter
     elif is_timedelta64_dtype(values.dtype):
         fmt_klass = Timedelta64Formatter
+    elif is_date_dtype(values.dtype):
+        fmt_klass = DateFormatter
     elif is_extension_array_dtype(values.dtype):
         fmt_klass = ExtensionArrayFormatter
     elif is_float_dtype(values.dtype) or is_complex_dtype(values.dtype):
@@ -1447,6 +1451,26 @@ def _format_strings(self) -> List[str]:
         return fmt_values.tolist()
 
 
+class DateFormatter(GenericArrayFormatter):
+    def __init__(
+        self,
+        values: Union[np.ndarray, "Series", DateArray],
+        nat_rep: str = "NaT",
+        date_format: None = None,
+        **kwargs,
+    ):
+        super().__init__(values, **kwargs)
+        self.nat_rep = nat_rep
+        self.date_format = date_format
+
+    def _format_strings(self) -> List[str]:
+        values = self.values
+        if self.formatter is not None and callable(self.formatter):
+            return [self.formatter(x) for x in values]
+
+        return values._data.astype("str")
+
+
 class ExtensionArrayFormatter(GenericArrayFormatter):
     def _format_strings(self) -> List[str]:
         values = extract_array(self.values, extract_numpy=True)
@@ -1605,7 +1629,8 @@ def _get_format_datetime64(
 
 
 def _get_format_datetime64_from_values(
-    values: Union[np.ndarray, DatetimeArray, DatetimeIndex], date_format: Optional[str]
+    values: Union[np.ndarray, DatetimeArray, DatetimeIndex, DateArray],
+    date_format: Optional[str],
 ) -> Optional[str]:
     """ given values and a date_format, return a string format """
     if isinstance(values, np.ndarray) and values.ndim > 1: