add to to_offset a boolean argument is_period IV [skip ci]

Author: natmokval

Diff for: pandas/_libs/tslibs/offsets.pxd

@@ -1,7 +1,7 @@
 from numpy cimport int64_t
 
 
-cpdef to_offset(object obj)
+cpdef to_offset(object obj, bint is_period)
 cdef bint is_offset_object(object obj)
 cdef bint is_tick_object(object obj)
 

Diff for: pandas/_libs/tslibs/offsets.pyx

@@ -410,7 +410,7 @@ cdef class BaseOffset:
             try:
                 # GH#23524 if to_offset fails, we are dealing with an
                 #  incomparable type so == is False and != is True
-                other = to_offset(other)
+                other = to_offset_eq(other)
             except ValueError:
                 # e.g. "infer"
                 return False
@@ -990,7 +990,7 @@ cdef class Tick(SingleConstructorOffset):
             try:
                 # GH#23524 if to_offset fails, we are dealing with an
                 #  incomparable type so == is False and != is True
-                other = to_offset(other)
+                other = to_offset_eq(other)
             except ValueError:
                 # e.g. "infer"
                 return False
@@ -4157,7 +4157,7 @@ def _get_offset(name: str) -> BaseOffset:
     return _offset_map[name]
 
 
-cpdef to_offset(freq, is_period=None):
+cpdef to_offset(freq, bint is_period):
     """
     Return DateOffset object from string or datetime.timedelta object.
 
@@ -4271,6 +4271,72 @@ cpdef to_offset(freq, is_period=None):
     return delta
 
 
+cpdef to_offset_eq(freq):
+    if freq is None:
+        return None
+
+    if isinstance(freq, BaseOffset):
+        return freq
+
+    if isinstance(freq, tuple):
+        raise TypeError(
+            f"to_offset does not support tuples {freq}, pass as a string instead"
+        )
+
+    elif PyDelta_Check(freq):
+        return delta_to_tick(freq)
+
+    elif isinstance(freq, str):
+        delta = None
+        stride_sign = None
+
+        try:
+            split = opattern.split(freq)
+            if split[-1] != "" and not split[-1].isspace():
+                # the last element must be blank
+                raise ValueError("last element must be blank")
+
+            tups = zip(split[0::4], split[1::4], split[2::4])
+            for n, (sep, stride, name) in enumerate(tups):
+                if sep != "" and not sep.isspace():
+                    raise ValueError("separator must be spaces")
+                prefix = _lite_rule_alias.get(name) or name
+                if stride_sign is None:
+                    stride_sign = -1 if stride.startswith("-") else 1
+                if not stride:
+                    stride = 1
+
+                if prefix in {"D", "H", "T", "S", "L", "U", "N"}:
+                    # For these prefixes, we have something like "3H" or
+                    #  "2.5T", so we can construct a Timedelta with the
+                    #  matching unit and get our offset from delta_to_tick
+                    td = Timedelta(1, unit=prefix)
+                    off = delta_to_tick(td)
+                    offset = off * float(stride)
+                    if n != 0:
+                        # If n==0, then stride_sign is already incorporated
+                        #  into the offset
+                        offset *= stride_sign
+                else:
+                    stride = int(stride)
+                    offset = _get_offset(name)
+                    offset = offset * int(np.fabs(stride) * stride_sign)
+
+                if delta is None:
+                    delta = offset
+                else:
+                    delta = delta + offset
+        except (ValueError, TypeError) as err:
+            raise ValueError(INVALID_FREQ_ERR_MSG.format(freq)) from err
+    else:
+        delta = None
+
+    if delta is None:
+        raise ValueError(INVALID_FREQ_ERR_MSG.format(freq))
+
+    return delta
+
+
 # ----------------------------------------------------------------------
 # RelativeDelta Arithmetic
 

Diff for: pandas/_libs/tslibs/period.pyx

@@ -1470,7 +1470,7 @@ def from_ordinals(const int64_t[:] values, freq):
         int64_t[::1] result = np.empty(len(values), dtype="i8")
         int64_t val
 
-    freq = to_offset(freq)
+    freq = to_offset(freq, True)
     if not isinstance(freq, BaseOffset):
         raise ValueError("freq not specified and cannot be inferred")
 
@@ -1689,7 +1689,7 @@ cdef class _Period(PeriodMixin):
             dtype = PeriodDtypeBase(freq)
             freq = dtype._freqstr
 
-        freq = to_offset(freq)
+        freq = to_offset(freq, True)
 
         if freq.n <= 0:
             raise ValueError("Frequency must be positive, because it "
@@ -2672,7 +2672,7 @@ class Period(_Period):
                 if freq is None and ordinal != NPY_NAT:
                     # Skip NaT, since it doesn't have a resolution
                     freq = attrname_to_abbrevs[reso]
-                    freq = to_offset(freq)
+                    freq = to_offset(freq, True)
 
         elif PyDateTime_Check(value):
             dt = value
@@ -2753,7 +2753,7 @@ cdef _parse_weekly_str(value, BaseOffset freq):
     if freq is None:
         day_name = end.day_name()[:3].upper()
         freqstr = f"W-{day_name}"
-        freq = to_offset(freqstr)
+        freq = to_offset(freqstr, True)
         # We _should_ have freq.is_on_offset(end)
 
     return end, freq

Diff for: pandas/_libs/tslibs/timestamps.pyx

@@ -1671,11 +1671,11 @@ class Timestamp(_Timestamp):
 
         return create_timestamp_from_ts(ts.value, ts.dts, ts.tzinfo, ts.fold, ts.creso)
 
-    def _round(self, freq, mode, ambiguous="raise", nonexistent="raise"):
+    def _round(self, freq, is_period, mode, ambiguous="raise", nonexistent="raise"):
         cdef:
             int64_t nanos
 
-        freq = to_offset(freq)
+        freq = to_offset(freq, is_period)
         freq.nanos  # raises on non-fixed freq
         nanos = delta_to_nanoseconds(freq, self._creso)
         if nanos == 0: