REF: make Tick entirely cdef

Author: jbrockmendel

pandas/_libs/tslibs/offsets.pyx

@@ -5,6 +5,7 @@ from typing import Any
 import warnings
 from cpython.datetime cimport (PyDateTime_IMPORT,
                                PyDateTime_Check,
+                               PyDate_Check,
                                PyDelta_Check,
                                datetime, timedelta, date,
                                time as dt_time)
@@ -35,6 +36,8 @@ from pandas._libs.tslibs.np_datetime cimport (
 from pandas._libs.tslibs.timezones cimport utc_pytz as UTC
 from pandas._libs.tslibs.tzconversion cimport tz_convert_single
 
+from .timedeltas cimport delta_to_nanoseconds
+
 # ---------------------------------------------------------------------
 # Constants
 
@@ -87,19 +90,19 @@ for _d in DAYS:
 # Misc Helpers
 
 cdef bint is_offset_object(object obj):
-    return isinstance(obj, _BaseOffset)
+    return isinstance(obj, BaseOffset)
 
 
 cdef bint is_tick_object(object obj):
-    return isinstance(obj, _Tick)
+    return isinstance(obj, Tick)
 
 
 cdef to_offset(object obj):
     """
     Wrap pandas.tseries.frequencies.to_offset to keep centralize runtime
     imports
     """
-    if isinstance(obj, _BaseOffset):
+    if isinstance(obj, BaseOffset):
         return obj
     from pandas.tseries.frequencies import to_offset
     return to_offset(obj)
@@ -167,10 +170,11 @@ def apply_wraps(func):
     def wrapper(self, other):
         if other is NaT:
             return NaT
-        elif isinstance(other, (timedelta, BaseOffset)):
+        elif isinstance(other, BaseOffset) or PyDelta_Check(other):
             # timedelta path
             return func(self, other)
-        elif isinstance(other, (datetime, date)) or is_datetime64_object(other):
+        elif is_datetime64_object(other) or PyDate_Check(other):
+            # PyDate_Check includes date, datetime
             other = as_timestamp(other)
         else:
             # This will end up returning NotImplemented back in __add__
@@ -233,7 +237,6 @@ cdef _wrap_timedelta_result(result):
     """
     if PyDelta_Check(result):
         # convert Timedelta back to a Tick
-        from pandas.tseries.offsets import delta_to_tick
         return delta_to_tick(result)
 
     return result
@@ -404,7 +407,7 @@ class ApplyTypeError(TypeError):
 # ---------------------------------------------------------------------
 # Base Classes
 
-cdef class _BaseOffset:
+cdef class BaseOffset:
     """
     Base class for DateOffset methods that are not overridden by subclasses
     and will (after pickle errors are resolved) go into a cdef class.
@@ -483,6 +486,9 @@ cdef class _BaseOffset:
         return type(self)(n=1, normalize=self.normalize, **self.kwds)
 
     def __add__(self, other):
+        if not isinstance(self, BaseOffset):
+            # cython semantics; this is __radd__
+            return other.__add__(self)
         try:
             return self.apply(other)
         except ApplyTypeError:
@@ -494,6 +500,9 @@ cdef class _BaseOffset:
         elif type(other) == type(self):
             return type(self)(self.n - other.n, normalize=self.normalize,
                               **self.kwds)
+        elif not isinstance(self, BaseOffset):
+            # cython semantics, this is __rsub__
+            return (-other).__add__(self)
         else:  # pragma: no cover
             return NotImplemented
 
@@ -512,6 +521,9 @@ cdef class _BaseOffset:
         elif is_integer_object(other):
             return type(self)(n=other * self.n, normalize=self.normalize,
                               **self.kwds)
+        elif not isinstance(self, BaseOffset):
+            # cython semantics, this is __rmul__
+            return other.__mul__(self)
         return NotImplemented
 
     def __neg__(self):
@@ -661,8 +673,8 @@ cdef class _BaseOffset:
 
     # ------------------------------------------------------------------
 
-    # Staticmethod so we can call from _Tick.__init__, will be unnecessary
-    #  once BaseOffset is a cdef class and is inherited by _Tick
+    # Staticmethod so we can call from Tick.__init__, will be unnecessary
+    #  once BaseOffset is a cdef class and is inherited by Tick
     @staticmethod
     def _validate_n(n):
         """
@@ -762,23 +774,7 @@ cdef class _BaseOffset:
         return self.n == 1
 
 
-class BaseOffset(_BaseOffset):
-    # Here we add __rfoo__ methods that don't play well with cdef classes
-    def __rmul__(self, other):
-        return self.__mul__(other)
-
-    def __radd__(self, other):
-        return self.__add__(other)
-
-    def __rsub__(self, other):
-        return (-self).__add__(other)
-
-
-cdef class _Tick(_BaseOffset):
-    """
-    dummy class to mix into tseries.offsets.Tick so that in tslibs.period we
-    can do isinstance checks on _Tick and avoid importing tseries.offsets
-    """
+cdef class Tick(BaseOffset):
 
     # ensure that reversed-ops with numpy scalars return NotImplemented
     __array_priority__ = 1000
@@ -797,13 +793,25 @@ cdef class _Tick(_BaseOffset):
                 "Tick offset with `normalize=True` are not allowed."
             )
 
+    @classmethod
+    def _from_name(cls, suffix=None):
+        # default _from_name calls cls with no args
+        if suffix:
+            raise ValueError(f"Bad freq suffix {suffix}")
+        return cls()
+
+    def _repr_attrs(self) -> str:
+        # Since cdef classes have no __dict__, we need to override
+        return ""
+
     @property
     def delta(self):
-        return self.n * self._inc
+        from .timedeltas import Timedelta
+        return self.n * Timedelta(self._nanos_inc)
 
     @property
     def nanos(self) -> int64_t:
-        return self.delta.value
+        return self.n * self._nanos_inc
 
     def is_on_offset(self, dt) -> bool:
         return True
@@ -841,13 +849,62 @@ cdef class _Tick(_BaseOffset):
         return self.delta.__gt__(other)
 
     def __truediv__(self, other):
-        if not isinstance(self, _Tick):
+        if not isinstance(self, Tick):
             # cython semantics mean the args are sometimes swapped
             result = other.delta.__rtruediv__(self)
         else:
             result = self.delta.__truediv__(other)
         return _wrap_timedelta_result(result)
 
+    def __add__(self, other):
+        if not isinstance(self, Tick):
+            # cython semantics; this is __radd__
+            return other.__add__(self)
+
+        if isinstance(other, Tick):
+            if type(self) == type(other):
+                return type(self)(self.n + other.n)
+            else:
+                return delta_to_tick(self.delta + other.delta)
+        try:
+            return self.apply(other)
+        except ApplyTypeError:
+            # Includes pd.Period
+            return NotImplemented
+        except OverflowError as err:
+            raise OverflowError(
+                f"the add operation between {self} and {other} will overflow"
+            ) from err
+
+    def apply(self, other):
+        # Timestamp can handle tz and nano sec, thus no need to use apply_wraps
+        if isinstance(other, ABCTimestamp):
+
+            # GH#15126
+            # in order to avoid a recursive
+            # call of __add__ and __radd__ if there is
+            # an exception, when we call using the + operator,
+            # we directly call the known method
+            result = other.__add__(self)
+            if result is NotImplemented:
+                raise OverflowError
+            return result
+        elif other is NaT:
+            return NaT
+        elif is_datetime64_object(other) or PyDate_Check(other):
+            # PyDate_Check includes date, datetime
+            return as_timestamp(other) + self
+
+        if PyDelta_Check(other):
+            return other + self.delta
+        elif isinstance(other, type(self)):
+            # TODO: this is reached in tests that specifically call apply,
+            #  but should not be reached "naturally" because __add__ should
+            #  catch this case first.
+            return type(self)(self.n + other.n)
+
+        raise ApplyTypeError(f"Unhandled type: {type(other).__name__}")
+
     # --------------------------------------------------------------------
     # Pickle Methods
 
@@ -859,6 +916,67 @@ cdef class _Tick(_BaseOffset):
         self.normalize = False
 
 
+cdef class Day(Tick):
+    _nanos_inc = 24 * 3600 * 1_000_000_000
+    _prefix = "D"
+
+
+cdef class Hour(Tick):
+    _nanos_inc = 3600 * 1_000_000_000
+    _prefix = "H"
+
+
+cdef class Minute(Tick):
+    _nanos_inc = 60 * 1_000_000_000
+    _prefix = "T"
+
+
+cdef class Second(Tick):
+    _nanos_inc = 1_000_000_000
+    _prefix = "S"
+
+
+cdef class Milli(Tick):
+    _nanos_inc = 1_000_000
+    _prefix = "L"
+
+
+cdef class Micro(Tick):
+    _nanos_inc = 1000
+    _prefix = "U"
+
+
+cdef class Nano(Tick):
+    _nanos_inc = 1
+    _prefix = "N"
+
+
+def delta_to_tick(delta: timedelta) -> Tick:
+    if delta.microseconds == 0 and getattr(delta, "nanoseconds", 0) == 0:
+        # nanoseconds only for pd.Timedelta
+        if delta.seconds == 0:
+            return Day(delta.days)
+        else:
+            seconds = delta.days * 86400 + delta.seconds
+            if seconds % 3600 == 0:
+                return Hour(seconds / 3600)
+            elif seconds % 60 == 0:
+                return Minute(seconds / 60)
+            else:
+                return Second(seconds)
+    else:
+        nanos = delta_to_nanoseconds(delta)
+        if nanos % 1_000_000 == 0:
+            return Milli(nanos // 1_000_000)
+        elif nanos % 1000 == 0:
+            return Micro(nanos // 1000)
+        else:  # pragma: no cover
+            return Nano(nanos)
+
+
+# --------------------------------------------------------------------
+
+
 class BusinessMixin:
     """
     Mixin to business types to provide related functions.

pandas/core/arrays/period.py

@@ -12,6 +12,7 @@
     period as libperiod,
 )
 from pandas._libs.tslibs.fields import isleapyear_arr
+from pandas._libs.tslibs.offsets import Tick, delta_to_tick
 from pandas._libs.tslibs.period import (
     DIFFERENT_FREQ,
     IncompatibleFrequency,
@@ -45,7 +46,7 @@
 import pandas.core.common as com
 
 from pandas.tseries import frequencies
-from pandas.tseries.offsets import DateOffset, Tick, delta_to_tick
+from pandas.tseries.offsets import DateOffset
 
 
 def _field_accessor(name: str, alias: int, docstring=None):

pandas/tests/tseries/offsets/test_ticks.py

@@ -7,6 +7,8 @@
 import numpy as np
 import pytest
 
+from pandas._libs.tslibs.offsets import delta_to_tick
+
 from pandas import Timedelta, Timestamp
 import pandas._testing as tm
 
@@ -33,11 +35,11 @@ def test_apply_ticks():
 def test_delta_to_tick():
     delta = timedelta(3)
 
-    tick = offsets.delta_to_tick(delta)
+    tick = delta_to_tick(delta)
     assert tick == offsets.Day(3)
 
     td = Timedelta(nanoseconds=5)
-    tick = offsets.delta_to_tick(td)
+    tick = delta_to_tick(td)
     assert tick == Nano(5)
 
 
@@ -234,7 +236,7 @@ def test_tick_division(cls):
         assert not isinstance(result, cls)
         assert result.delta == off.delta / 1000
 
-    if cls._inc < Timedelta(seconds=1):
+    if cls._nanos_inc < Timedelta(seconds=1).value:
         # Case where we end up with a bigger class
         result = off / 0.001
         assert isinstance(result, offsets.Tick)