Move frequencies functions to cython

pandas/_libs/tslibs/frequencies.pxd

@@ -1,4 +1,10 @@
 # -*- coding: utf-8 -*-
 # cython: profile=False
 
+cpdef object get_rule_month(object source, object default=*)
+
 cpdef get_freq_code(freqstr)
+cpdef object get_freq(object freq)
+cpdef str get_base_alias(freqstr)
+cpdef int get_to_timestamp_base(int base)
+cpdef str get_freq_str(base, mult=*)

pandas/_libs/tslibs/frequencies.pyx

@@ -6,9 +6,12 @@ cimport cython
 
 import numpy as np
 cimport numpy as np
+from numpy cimport int64_t
 np.import_array()
 
-from util cimport is_integer_object
+from util cimport is_integer_object, is_string_object
+
+from ccalendar import MONTH_NUMBERS
 
 # ----------------------------------------------------------------------
 # Constants
@@ -23,6 +26,22 @@ _INVALID_FREQ_ERROR = "Invalid frequency: {0}"
 # ---------------------------------------------------------------------
 # Period codes
 
+
+class FreqGroup(object):
+    FR_ANN = 1000
+    FR_QTR = 2000
+    FR_MTH = 3000
+    FR_WK = 4000
+    FR_BUS = 5000
+    FR_DAY = 6000
+    FR_HR = 7000
+    FR_MIN = 8000
+    FR_SEC = 9000
+    FR_MS = 10000
+    FR_US = 11000
+    FR_NS = 12000
+
+
 # period frequency constants corresponding to scikits timeseries
 # originals
 _period_code_map = {
@@ -203,3 +222,284 @@ cpdef _period_str_to_code(freqstr):
         return _period_code_map[freqstr]
     except KeyError:
         raise ValueError(_INVALID_FREQ_ERROR.format(freqstr))
+
+
+cpdef str get_freq_str(base, mult=1):
+    """
+    Return the summary string associated with this offset code, possibly
+    adjusted by a multiplier.
+
+    Parameters
+    ----------
+    base : int (member of FreqGroup)
+
+    Returns
+    -------
+    freq_str : str
+
+    Examples
+    --------
+    >>> get_freq_str(1000)
+    'A-DEC'
+
+    >>> get_freq_str(2000, 2)
+    '2Q-DEC'
+
+    >>> get_freq_str("foo")
+    """
+    code = _reverse_period_code_map.get(base)
+    if mult == 1:
+        return code
+    return str(mult) + code
+
+
+cpdef str get_base_alias(freqstr):
+    """
+    Returns the base frequency alias, e.g., '5D' -> 'D'
+    """
+    return _base_and_stride(freqstr)[0]
+
+
+cpdef int get_to_timestamp_base(int base):
+    """
+    Return frequency code group used for base of to_timestamp against
+    frequency code.
+
+    Parameters
+    ----------
+    base : int (member of FreqGroup)
+
+    Returns
+    -------
+    base : int
+
+    Example
+    -------
+    # Return day freq code against longer freq than day
+    >>> get_to_timestamp_base(get_freq_code('D')[0])
+    6000
+    >>> get_to_timestamp_base(get_freq_code('W')[0])
+    6000
+    >>> get_to_timestamp_base(get_freq_code('M')[0])
+    6000
+
+    # Return second freq code against hour between second
+    >>> get_to_timestamp_base(get_freq_code('H')[0])
+    9000
+    >>> get_to_timestamp_base(get_freq_code('S')[0])
+    9000
+    """
+    if base < FreqGroup.FR_BUS:
+        return FreqGroup.FR_DAY
+    if FreqGroup.FR_HR <= base <= FreqGroup.FR_SEC:
+        return FreqGroup.FR_SEC
+    return base
+
+
+cpdef object get_freq(object freq):
+    """
+    Return frequency code of given frequency str.
+    If input is not string, return input as it is.
+
+    Example
+    -------
+    >>> get_freq('A')
+    1000
+
+    >>> get_freq('3A')
+    1000
+    """
+    if is_string_object(freq):
+        base, mult = get_freq_code(freq)
+        freq = base
+    return freq
+
+
+# ----------------------------------------------------------------------
+# Frequency comparison
+
+cpdef bint is_subperiod(source, target):
+    """
+    Returns True if downsampling is possible between source and target
+    frequencies
+
+    Parameters
+    ----------
+    source : string or DateOffset
+        Frequency converting from
+    target : string or DateOffset
+        Frequency converting to
+
+    Returns
+    -------
+    is_subperiod : boolean
+    """
+
+    if target is None or source is None:
+        return False
+    source = _maybe_coerce_freq(source)
+    target = _maybe_coerce_freq(target)
+
+    if _is_annual(target):
+        if _is_quarterly(source):
+            return _quarter_months_conform(get_rule_month(source),
+                                           get_rule_month(target))
+        return source in {'D', 'C', 'B', 'M', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif _is_quarterly(target):
+        return source in {'D', 'C', 'B', 'M', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif _is_monthly(target):
+        return source in {'D', 'C', 'B', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif _is_weekly(target):
+        return source in {target, 'D', 'C', 'B', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif target == 'B':
+        return source in {'B', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif target == 'C':
+        return source in {'C', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif target == 'D':
+        return source in {'D', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif target == 'H':
+        return source in {'H', 'T', 'S', 'L', 'U', 'N'}
+    elif target == 'T':
+        return source in {'T', 'S', 'L', 'U', 'N'}
+    elif target == 'S':
+        return source in {'S', 'L', 'U', 'N'}
+    elif target == 'L':
+        return source in {'L', 'U', 'N'}
+    elif target == 'U':
+        return source in {'U', 'N'}
+    elif target == 'N':
+        return source in {'N'}
+
+
+cpdef bint is_superperiod(source, target):
+    """
+    Returns True if upsampling is possible between source and target
+    frequencies
+
+    Parameters
+    ----------
+    source : string
+        Frequency converting from
+    target : string
+        Frequency converting to
+
+    Returns
+    -------
+    is_superperiod : boolean
+    """
+    if target is None or source is None:
+        return False
+    source = _maybe_coerce_freq(source)
+    target = _maybe_coerce_freq(target)
+
+    if _is_annual(source):
+        if _is_annual(target):
+            return get_rule_month(source) == get_rule_month(target)
+
+        if _is_quarterly(target):
+            smonth = get_rule_month(source)
+            tmonth = get_rule_month(target)
+            return _quarter_months_conform(smonth, tmonth)
+        return target in {'D', 'C', 'B', 'M', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif _is_quarterly(source):
+        return target in {'D', 'C', 'B', 'M', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif _is_monthly(source):
+        return target in {'D', 'C', 'B', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif _is_weekly(source):
+        return target in {source, 'D', 'C', 'B', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif source == 'B':
+        return target in {'D', 'C', 'B', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif source == 'C':
+        return target in {'D', 'C', 'B', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif source == 'D':
+        return target in {'D', 'C', 'B', 'H', 'T', 'S', 'L', 'U', 'N'}
+    elif source == 'H':
+        return target in {'H', 'T', 'S', 'L', 'U', 'N'}
+    elif source == 'T':
+        return target in {'T', 'S', 'L', 'U', 'N'}
+    elif source == 'S':
+        return target in {'S', 'L', 'U', 'N'}
+    elif source == 'L':
+        return target in {'L', 'U', 'N'}
+    elif source == 'U':
+        return target in {'U', 'N'}
+    elif source == 'N':
+        return target in {'N'}
+
+
+cdef str _maybe_coerce_freq(code):
+    """ we might need to coerce a code to a rule_code
+    and uppercase it
+
+    Parameters
+    ----------
+    source : string or DateOffset
+        Frequency converting from
+
+    Returns
+    -------
+    code : string
+    """
+    assert code is not None
+    if getattr(code, '_typ', None) == 'dateoffset':
+        # i.e. isinstance(code, ABCDateOffset):
+        code = code.rule_code
+    return code.upper()
+
+
+cdef bint _quarter_months_conform(str source, str target):
+    snum = MONTH_NUMBERS[source]
+    tnum = MONTH_NUMBERS[target]
+    return snum % 3 == tnum % 3
+
+
+cdef bint _is_annual(str rule):
+    rule = rule.upper()
+    return rule == 'A' or rule.startswith('A-')
+
+
+cdef bint _is_quarterly(str rule):
+    rule = rule.upper()
+    return rule == 'Q' or rule.startswith('Q-') or rule.startswith('BQ')
+
+
+cdef bint _is_monthly(str rule):
+    rule = rule.upper()
+    return rule == 'M' or rule == 'BM'
+
+
+cdef bint _is_weekly(str rule):
+    rule = rule.upper()
+    return rule == 'W' or rule.startswith('W-')
+
+
+# ----------------------------------------------------------------------
+
+cpdef object get_rule_month(object source, object default='DEC'):
+    """
+    Return starting month of given freq, default is December.
+
+    Parameters
+    ----------
+    source : object
+    default : object (default "DEC")
+
+    Returns
+    -------
+    rule_month: object (usually string)
+
+    Example
+    -------
+    >>> get_rule_month('D')
+    'DEC'
+
+    >>> get_rule_month('A-JAN')
+    'JAN'
+    """
+    if hasattr(source, 'freqstr'):
+        source = source.freqstr
+    source = source.upper()
+    if '-' not in source:
+        return default
+    else:
+        return source.split('-')[1]

pandas/_libs/tslibs/period.pyx

@@ -28,14 +28,16 @@ cimport util
 from util cimport is_period_object, is_string_object, INT32_MIN
 
 from pandas._libs.missing cimport is_null_datetimelike
+
 from timestamps import Timestamp
 from timezones cimport is_utc, is_tzlocal, get_utcoffset, get_dst_info
 from timedeltas cimport delta_to_nanoseconds
 
 from ccalendar import MONTH_NUMBERS
-from parsing import (parse_time_string, NAT_SENTINEL,
-                     _get_rule_month)
-from frequencies cimport get_freq_code
+from frequencies cimport (get_freq_code, get_base_alias,
+                          get_to_timestamp_base, get_freq_str,
+                          get_rule_month)
+from parsing import parse_time_string, NAT_SENTINEL
 from resolution import resolution, Resolution
 from nattype import nat_strings, NaT, iNaT
 from nattype cimport _nat_scalar_rules, NPY_NAT
@@ -572,7 +574,7 @@ cdef class _Period(object):
 
         if isinstance(freq, (int, tuple)):
             code, stride = get_freq_code(freq)
-            freq = frequencies._get_freq_str(code, stride)
+            freq = get_freq_str(code, stride)
 
         freq = frequencies.to_offset(freq)
 
@@ -630,7 +632,7 @@ cdef class _Period(object):
             raise IncompatibleFrequency(msg.format(self.freqstr))
         elif isinstance(other, offsets.DateOffset):
             freqstr = other.rule_code
-            base = frequencies.get_base_alias(freqstr)
+            base = get_base_alias(freqstr)
             if base == self.freq.rule_code:
                 ordinal = self.ordinal + other.n
                 return Period(ordinal=ordinal, freq=self.freq)
@@ -756,7 +758,7 @@ cdef class _Period(object):
 
         if freq is None:
             base, mult = get_freq_code(self.freq)
-            freq = frequencies.get_to_timestamp_base(base)
+            freq = get_to_timestamp_base(base)
 
         base, mult = get_freq_code(freq)
         val = self.asfreq(freq, how)
@@ -1149,7 +1151,7 @@ def _quarter_to_myear(year, quarter, freq):
         if quarter <= 0 or quarter > 4:
             raise ValueError('Quarter must be 1 <= q <= 4')
 
-        mnum = MONTH_NUMBERS[_get_rule_month(freq)] + 1
+        mnum = MONTH_NUMBERS[get_rule_month(freq)] + 1
         month = (mnum + (quarter - 1) * 3) % 12 + 1
         if month > mnum:
             year -= 1

pandas/_libs/tslibs/resolution.pyx

@@ -23,7 +23,7 @@ from timezones cimport (is_utc, is_tzlocal,
                         maybe_get_tz, get_dst_info, get_utcoffset)
 from fields import build_field_sarray
 from conversion import tz_convert
-from ccalendar import DAYS, MONTH_ALIASES, int_to_weekday
+from ccalendar import MONTH_ALIASES, int_to_weekday
 
 from pandas._libs.properties import cache_readonly
 from pandas._libs.tslib import Timestamp