Add date dtype

pandas/core/api.py

@@ -8,6 +8,7 @@
     DatetimeTZDtype,
     IntervalDtype,
     PeriodDtype,
+    DateDtype
 )
 from pandas.core.dtypes.missing import isna, isnull, notna, notnull
 

pandas/core/arrays/__init__.py

@@ -13,6 +13,7 @@
 from pandas.core.arrays.sparse import SparseArray
 from pandas.core.arrays.string_ import StringArray
 from pandas.core.arrays.timedeltas import TimedeltaArray
+from pandas.core.arrays.dates import DateArray
 
 __all__ = [
     "ExtensionArray",
@@ -31,4 +32,5 @@
     "SparseArray",
     "StringArray",
     "TimedeltaArray",
+    "DateArray"
 ]

pandas/core/arrays/dates.py

@@ -0,0 +1,184 @@
+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,
+    is_string_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 DT64NS_DTYPE
+from pandas._libs import tslib, lib
+from pandas.core.arrays._mixins import _T
+
+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.
+
+    Parameters
+    ----------
+    values : Series, Index, DateArray, ndarray
+        The date data.
+    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)
+
+    def _from_backing_data(self: _T, arr: np.ndarray) -> _T:
+        return type(self)(arr)
+
+    @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(DT64NS_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=DT64NS_DTYPE)
+        if is_object_dtype(dtype):
+            return self._box_values(self.as_datetime_i8)
+        if is_string_dtype(dtype):
+            return array(self._format_native_types())
+        return super().astype(dtype, copy)
+
+    def _format_native_types(self, na_rep="NaT", date_format=None):
+        return tslib.format_array_from_datetime(
+            self.as_datetime_i8, tz="utc", format="%Y-%m-%d", 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/arrays/integer.py

@@ -14,6 +14,7 @@
 from pandas.core.dtypes.common import (
     is_bool_dtype,
     is_datetime64_dtype,
+    is_date_dtype,
     is_float,
     is_float_dtype,
     is_integer,
@@ -453,6 +454,8 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
         elif isinstance(dtype, BooleanDtype):
             result = self._data.astype("bool", copy=False)
             return BooleanArray(result, mask=self._mask, copy=False)
+        elif is_date_dtype(dtype):
+            return dtype.construct_array_type()._from_sequence(self._data, copy=False)
 
         # coerce
         if is_float_dtype(dtype):

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/core/dtypes/dtypes.py

@@ -3,6 +3,7 @@
 """
 
 import re
+import datetime
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -34,6 +35,7 @@
         IntervalArray,
         PeriodArray,
         DatetimeArray,
+        DateArray,
     )
     from pandas import Categorical  # noqa: F401
 
@@ -1232,3 +1234,88 @@ def __from_arrow__(
             results.append(iarr)
 
         return IntervalArray._concat_same_type(results)
+
+
+@register_extension_dtype
+class DateDtype(PandasExtensionDtype):
+    """
+    An ExtensionDtype to hold a single date.
+    The attributes name & type are set when subclasses are created.
+    """
+
+    _date_aliases = {"date", "date64"}
+    _unit = "D"
+    _numpy_dtype = np.dtype("datetime64[D]")
+
+    def __str__(self):
+        return "date"
+
+    @property
+    def name(self) -> str_type:
+        return str(self)
+
+    @property
+    def type(self):
+        return datetime.date
+
+    @property
+    def na_value(self):
+        return NaT
+
+    def __repr__(self):
+        return type(self)
+
+    @property
+    def kind(self):
+        return self._numpy_dtype.kind
+
+    @property
+    def itemsize(self):
+        """ Return the number of bytes in this dtype """
+        return self.numpy_dtype.itemsize
+
+    @classmethod
+    def construct_from_string(cls, string: str):
+        if not isinstance(string, str):
+            raise TypeError(
+                f"'construct_from_string' expects a string, got {type(string)}"
+            )
+
+        if string in cls._date_aliases:
+            return cls()
+
+        msg = (
+            f"Cannot construct a 'DateDtype' from '{string}'.\n\n"
+            "Incorrectly formatted string passed to constructor. "
+            "Valid formats include only date"
+        )
+        raise TypeError(msg)
+
+    @classmethod
+    def construct_array_type(cls):
+        """
+        Return the array type associated with this dtype.
+        Returns
+        -------
+        type
+        """
+        from pandas.core.arrays import DateArray
+
+        return DateArray
+
+    # TODO make from arrow
+
+    @classmethod
+    def is_dtype(cls, dtype) -> bool:
+        if isinstance(dtype, str):
+            if dtype.lower().startswith("date"):
+                try:
+                    if cls.construct_from_string(dtype) is not None:
+                        return True
+                    else:
+                        return False
+                except (ValueError, TypeError):
+                    return False
+            else:
+                return False
+        return super().is_dtype(dtype)