diff --git a/pandas/_libs/tslibs/__init__.py b/pandas/_libs/tslibs/__init__.py
index 6dbb4ce7bc974..6f173a4542bb0 100644
--- a/pandas/_libs/tslibs/__init__.py
+++ b/pandas/_libs/tslibs/__init__.py
@@ -18,7 +18,7 @@
     "to_offset",
 ]
 
-from . import dtypes  # type: ignore
+from . import dtypes
 from .conversion import localize_pydatetime
 from .nattype import NaT, NaTType, iNaT, is_null_datetimelike, nat_strings
 from .np_datetime import OutOfBoundsDatetime
diff --git a/pandas/_libs/tslibs/frequencies.pxd b/pandas/_libs/tslibs/frequencies.pxd
index 098944c965df0..896eec77ef4fe 100644
--- a/pandas/_libs/tslibs/frequencies.pxd
+++ b/pandas/_libs/tslibs/frequencies.pxd
@@ -1,5 +1,3 @@
 cdef dict attrname_to_abbrevs
 
-cpdef get_freq_code(freqstr)
 cpdef int get_to_timestamp_base(int base)
-cpdef str get_freq_str(base, mult=*)
diff --git a/pandas/_libs/tslibs/frequencies.pyx b/pandas/_libs/tslibs/frequencies.pyx
index 9ff34ef0b6f89..6e525500ec37a 100644
--- a/pandas/_libs/tslibs/frequencies.pyx
+++ b/pandas/_libs/tslibs/frequencies.pyx
@@ -1,18 +1,5 @@
-cimport numpy as cnp
-cnp.import_array()
 
-from pandas._libs.tslibs.util cimport is_integer_object
-
-from pandas._libs.tslibs.offsets cimport is_offset_object
-from pandas._libs.tslibs.offsets import (
-    INVALID_FREQ_ERR_MSG,
-    _dont_uppercase,
-    _lite_rule_alias,
-    base_and_stride,
-    opattern,
-)
-
-from .dtypes import FreqGroup, _period_code_map, _reverse_period_code_map
+from .dtypes import FreqGroup
 
 # ---------------------------------------------------------------------
 # Period codes
@@ -36,131 +23,22 @@ cdef dict attrname_to_abbrevs = _attrname_to_abbrevs
 
 # ----------------------------------------------------------------------
 
-def get_freq_group(freq) -> int:
+# TODO: this is now identical to the version in libperiod
+def get_freq_group(freq: int) -> int:
     """
     Return frequency code group of given frequency str or offset.
 
     Examples
     --------
-    >>> get_freq_group('W-MON')
+    >>> get_freq_group(4001)
     4000
 
-    >>> get_freq_group('W-FRI')
+    >>> get_freq_group(4006)
     4000
     """
-    if is_offset_object(freq):
-        freq = freq.rule_code
-
-    if isinstance(freq, str):
-        freq = attrname_to_abbrevs.get(freq, freq)
-        base, mult = get_freq_code(freq)
-        freq = base
-    elif isinstance(freq, int):
-        pass
-    else:
-        raise ValueError('input must be str, offset or int')
     return (freq // 1000) * 1000
 
 
-cpdef get_freq_code(freqstr):
-    """
-    Return freq str or tuple to freq code and stride (mult)
-
-    Parameters
-    ----------
-    freqstr : str or tuple
-
-    Returns
-    -------
-    return : tuple of base frequency code and stride (mult)
-
-    Raises
-    ------
-    TypeError : if passed a tuple witth incorrect types
-
-    Examples
-    --------
-    >>> get_freq_code('3D')
-    (6000, 3)
-
-    >>> get_freq_code('D')
-    (6000, 1)
-
-    >>> get_freq_code(('D', 3))
-    (6000, 3)
-    """
-    if is_offset_object(freqstr):
-        freqstr = (freqstr.rule_code, freqstr.n)
-
-    if isinstance(freqstr, tuple):
-        if is_integer_object(freqstr[0]) and is_integer_object(freqstr[1]):
-            # e.g., freqstr = (2000, 1)
-            return freqstr
-        elif is_integer_object(freqstr[0]):
-            # Note: passing freqstr[1] below will raise TypeError if that
-            #  is not a str
-            code = _period_str_to_code(freqstr[1])
-            stride = freqstr[0]
-            return code, stride
-        else:
-            # e.g., freqstr = ('T', 5)
-            code = _period_str_to_code(freqstr[0])
-            stride = freqstr[1]
-            return code, stride
-
-    if is_integer_object(freqstr):
-        return freqstr, 1
-
-    base, stride = base_and_stride(freqstr)
-    code = _period_str_to_code(base)
-
-    return code, stride
-
-
-cpdef _period_str_to_code(str freqstr):
-    freqstr = _lite_rule_alias.get(freqstr, freqstr)
-
-    if freqstr not in _dont_uppercase:
-        lower = freqstr.lower()
-        freqstr = _lite_rule_alias.get(lower, freqstr)
-
-    if freqstr not in _dont_uppercase:
-        freqstr = freqstr.upper()
-    try:
-        return _period_code_map[freqstr]
-    except KeyError:
-        raise ValueError(INVALID_FREQ_ERR_MSG.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 int get_to_timestamp_base(int base):
     """
     Return frequency code group used for base of to_timestamp against
diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index c06f34e37ec49..47ebf139ed496 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -75,8 +75,6 @@ from pandas._libs.tslibs.dtypes cimport (
 
 from pandas._libs.tslibs.frequencies cimport (
     attrname_to_abbrevs,
-    get_freq_code,
-    get_freq_str,
     get_to_timestamp_base,
 )
 from pandas._libs.tslibs.parsing cimport get_rule_month
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 8eb1bdadf9156..90513e355e732 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -11,8 +11,8 @@
     Timestamp,
     conversion,
     fields,
-    frequencies as libfrequencies,
     iNaT,
+    offsets as liboffsets,
     resolution as libresolution,
     timezones,
     to_offset,
@@ -1106,7 +1106,7 @@ def to_period(self, freq=None):
 
             #  https://github.com/pandas-dev/pandas/issues/33358
             if res is None:
-                base, stride = libfrequencies.base_and_stride(freq)
+                base, stride = liboffsets.base_and_stride(freq)
                 res = f"{stride}{base}"
 
             freq = res
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 43dfd94b49215..49cb78340d104 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -503,7 +503,7 @@ def get_loc(self, key, method=None, tolerance=None):
 
             reso = Resolution.from_attrname(reso)
             grp = reso.freq_group
-            freqn = get_freq_group(self.freq)
+            freqn = get_freq_group(self.dtype.dtype_code)
 
             # _get_string_slice will handle cases where grp < freqn
             assert grp >= freqn
@@ -579,7 +579,7 @@ def _parsed_string_to_bounds(self, reso: Resolution, parsed: datetime):
     def _validate_partial_date_slice(self, reso: Resolution):
         assert isinstance(reso, Resolution), (type(reso), reso)
         grp = reso.freq_group
-        freqn = get_freq_group(self.freq)
+        freqn = get_freq_group(self.dtype.dtype_code)
 
         if not grp < freqn:
             # TODO: we used to also check for
diff --git a/pandas/plotting/_matplotlib/timeseries.py b/pandas/plotting/_matplotlib/timeseries.py
index a9cca32271b9f..99fc730e818c4 100644
--- a/pandas/plotting/_matplotlib/timeseries.py
+++ b/pandas/plotting/_matplotlib/timeseries.py
@@ -6,7 +6,8 @@
 import numpy as np
 
 from pandas._libs.tslibs import Period, to_offset
-from pandas._libs.tslibs.frequencies import FreqGroup, base_and_stride
+from pandas._libs.tslibs.frequencies import FreqGroup
+from pandas._libs.tslibs.offsets import base_and_stride
 from pandas._typing import FrameOrSeriesUnion
 
 from pandas.core.dtypes.generic import (
diff --git a/pandas/tests/indexes/datetimes/test_scalar_compat.py b/pandas/tests/indexes/datetimes/test_scalar_compat.py
index 23dedf6f86a09..0d39e034905d2 100644
--- a/pandas/tests/indexes/datetimes/test_scalar_compat.py
+++ b/pandas/tests/indexes/datetimes/test_scalar_compat.py
@@ -7,6 +7,7 @@
 import pytest
 
 from pandas._libs.tslibs import OutOfBoundsDatetime, to_offset
+from pandas._libs.tslibs.offsets import INVALID_FREQ_ERR_MSG
 
 import pandas as pd
 from pandas import DatetimeIndex, Timestamp, date_range
@@ -118,7 +119,7 @@ def test_round(self, tz_naive_fixture):
         tm.assert_index_equal(rng.round(freq="H"), expected_rng)
         assert elt.round(freq="H") == expected_elt
 
-        msg = pd._libs.tslibs.frequencies.INVALID_FREQ_ERR_MSG
+        msg = INVALID_FREQ_ERR_MSG
         with pytest.raises(ValueError, match=msg):
             rng.round(freq="foo")
         with pytest.raises(ValueError, match=msg):
diff --git a/pandas/tests/indexes/datetimes/test_to_period.py b/pandas/tests/indexes/datetimes/test_to_period.py
index d82fc1ef6743b..51cc6af2eed08 100644
--- a/pandas/tests/indexes/datetimes/test_to_period.py
+++ b/pandas/tests/indexes/datetimes/test_to_period.py
@@ -6,7 +6,7 @@
 import pytz
 
 from pandas._libs.tslibs.ccalendar import MONTHS
-from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
 
 from pandas import (
     DatetimeIndex,
diff --git a/pandas/tests/indexes/timedeltas/test_scalar_compat.py b/pandas/tests/indexes/timedeltas/test_scalar_compat.py
index 1b86cd1df5a7a..16c19b8d00380 100644
--- a/pandas/tests/indexes/timedeltas/test_scalar_compat.py
+++ b/pandas/tests/indexes/timedeltas/test_scalar_compat.py
@@ -5,6 +5,8 @@
 import numpy as np
 import pytest
 
+from pandas._libs.tslibs.offsets import INVALID_FREQ_ERR_MSG
+
 import pandas as pd
 from pandas import Index, Series, Timedelta, TimedeltaIndex, timedelta_range
 import pandas._testing as tm
@@ -58,7 +60,7 @@ def test_tdi_round(self):
         tm.assert_index_equal(td.round(freq="H"), expected_rng)
         assert elt.round(freq="H") == expected_elt
 
-        msg = pd._libs.tslibs.frequencies.INVALID_FREQ_ERR_MSG
+        msg = INVALID_FREQ_ERR_MSG
         with pytest.raises(ValueError, match=msg):
             td.round(freq="foo")
         with pytest.raises(ValueError, match=msg):
diff --git a/pandas/tests/scalar/period/test_asfreq.py b/pandas/tests/scalar/period/test_asfreq.py
index b9f637c178d53..56281521deb90 100644
--- a/pandas/tests/scalar/period/test_asfreq.py
+++ b/pandas/tests/scalar/period/test_asfreq.py
@@ -1,6 +1,7 @@
 import pytest
 
-from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG, _period_code_map
+from pandas._libs.tslibs.dtypes import _period_code_map
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
 from pandas.errors import OutOfBoundsDatetime
 
 from pandas import Period, Timestamp, offsets
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index 3e769b577582a..702899f163e06 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -6,9 +6,8 @@
 
 from pandas._libs.tslibs import iNaT, period as libperiod
 from pandas._libs.tslibs.ccalendar import DAYS, MONTHS
-from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
 from pandas._libs.tslibs.parsing import DateParseError
-from pandas._libs.tslibs.period import IncompatibleFrequency
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG, IncompatibleFrequency
 from pandas._libs.tslibs.timezones import dateutil_gettz, maybe_get_tz
 from pandas.compat.numpy import np_datetime64_compat
 
diff --git a/pandas/tests/scalar/timestamp/test_unary_ops.py b/pandas/tests/scalar/timestamp/test_unary_ops.py
index 388ff4ea039be..8641bbd0a66f2 100644
--- a/pandas/tests/scalar/timestamp/test_unary_ops.py
+++ b/pandas/tests/scalar/timestamp/test_unary_ops.py
@@ -6,7 +6,7 @@
 from pytz import utc
 
 from pandas._libs.tslibs import NaT, Timestamp, conversion, to_offset
-from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
 import pandas.util._test_decorators as td
 
 import pandas._testing as tm
diff --git a/pandas/tests/tseries/frequencies/test_freq_code.py b/pandas/tests/tseries/frequencies/test_freq_code.py
index f0ff449d902d0..189a0cc2171ad 100644
--- a/pandas/tests/tseries/frequencies/test_freq_code.py
+++ b/pandas/tests/tseries/frequencies/test_freq_code.py
@@ -1,80 +1,7 @@
 import pytest
 
-from pandas._libs.tslibs import Resolution, offsets, to_offset
-from pandas._libs.tslibs.frequencies import (
-    FreqGroup,
-    _attrname_to_abbrevs,
-    _period_code_map,
-    get_freq_code,
-    get_freq_group,
-    get_to_timestamp_base,
-)
-
-
-@pytest.fixture(params=list(_period_code_map.items()))
-def period_code_item(request):
-    return request.param
-
-
-@pytest.mark.parametrize(
-    "freqstr,expected",
-    [
-        ("A", 1000),
-        ("3A", 1000),
-        ("-1A", 1000),
-        ("Y", 1000),
-        ("3Y", 1000),
-        ("-1Y", 1000),
-        ("W", 4000),
-        ("W-MON", 4001),
-        ("W-FRI", 4005),
-    ],
-)
-def test_freq_code(freqstr, expected):
-    assert get_freq_code(freqstr)[0] == expected
-
-
-def test_freq_code_match(period_code_item):
-    freqstr, code = period_code_item
-    assert get_freq_code(freqstr)[0] == code
-
-
-@pytest.mark.parametrize(
-    "freqstr,expected",
-    [
-        ("A", 1000),
-        ("3A", 1000),
-        ("-1A", 1000),
-        ("A-JAN", 1000),
-        ("A-MAY", 1000),
-        ("Y", 1000),
-        ("3Y", 1000),
-        ("-1Y", 1000),
-        ("Y-JAN", 1000),
-        ("Y-MAY", 1000),
-        (offsets.YearEnd(), 1000),
-        (offsets.YearEnd(month=1), 1000),
-        (offsets.YearEnd(month=5), 1000),
-        ("W", 4000),
-        ("W-MON", 4000),
-        ("W-FRI", 4000),
-        (offsets.Week(), 4000),
-        (offsets.Week(weekday=1), 4000),
-        (offsets.Week(weekday=5), 4000),
-        ("T", FreqGroup.FR_MIN),
-    ],
-)
-def test_freq_group(freqstr, expected):
-    assert get_freq_group(freqstr) == expected
-
-
-def test_freq_group_match(period_code_item):
-    freqstr, code = period_code_item
-
-    str_group = get_freq_group(freqstr)
-    code_group = get_freq_group(code)
-
-    assert str_group == code_group == code // 1000 * 1000
+from pandas._libs.tslibs import Resolution, to_offset
+from pandas._libs.tslibs.frequencies import _attrname_to_abbrevs, get_to_timestamp_base
 
 
 @pytest.mark.parametrize(
@@ -82,9 +9,9 @@ def test_freq_group_match(period_code_item):
     [("D", "D"), ("W", "D"), ("M", "D"), ("S", "S"), ("T", "S"), ("H", "S")],
 )
 def test_get_to_timestamp_base(freqstr, exp_freqstr):
-    tsb = get_to_timestamp_base
-
-    assert tsb(get_freq_code(freqstr)[0]) == get_freq_code(exp_freqstr)[0]
+    left_code = to_offset(freqstr)._period_dtype_code
+    exp_code = to_offset(exp_freqstr)._period_dtype_code
+    assert get_to_timestamp_base(left_code) == exp_code
 
 
 @pytest.mark.parametrize(
@@ -144,43 +71,3 @@ def test_cat(args):
 
     with pytest.raises(ValueError, match=msg):
         to_offset(str(args[0]) + args[1])
-
-
-@pytest.mark.parametrize(
-    "freq_input,expected",
-    [
-        # Frequency string.
-        ("A", (get_freq_code("A")[0], 1)),
-        ("3D", (get_freq_code("D")[0], 3)),
-        ("-2M", (get_freq_code("M")[0], -2)),
-        # Tuple.
-        (("D", 1), (get_freq_code("D")[0], 1)),
-        (("A", 3), (get_freq_code("A")[0], 3)),
-        (("M", -2), (get_freq_code("M")[0], -2)),
-        ((5, "T"), (FreqGroup.FR_MIN, 5)),
-        # Numeric Tuple.
-        ((1000, 1), (1000, 1)),
-        # Offsets.
-        (offsets.Day(), (get_freq_code("D")[0], 1)),
-        (offsets.Day(3), (get_freq_code("D")[0], 3)),
-        (offsets.Day(-2), (get_freq_code("D")[0], -2)),
-        (offsets.MonthEnd(), (get_freq_code("M")[0], 1)),
-        (offsets.MonthEnd(3), (get_freq_code("M")[0], 3)),
-        (offsets.MonthEnd(-2), (get_freq_code("M")[0], -2)),
-        (offsets.Week(), (get_freq_code("W")[0], 1)),
-        (offsets.Week(3), (get_freq_code("W")[0], 3)),
-        (offsets.Week(-2), (get_freq_code("W")[0], -2)),
-        (offsets.Hour(), (FreqGroup.FR_HR, 1)),
-        # Monday is weekday=0.
-        (offsets.Week(weekday=1), (get_freq_code("W-TUE")[0], 1)),
-        (offsets.Week(3, weekday=0), (get_freq_code("W-MON")[0], 3)),
-        (offsets.Week(-2, weekday=4), (get_freq_code("W-FRI")[0], -2)),
-    ],
-)
-def test_get_freq_code(freq_input, expected):
-    assert get_freq_code(freq_input) == expected
-
-
-def test_get_code_invalid():
-    with pytest.raises(ValueError, match="Invalid frequency"):
-        get_freq_code((5, "baz"))
diff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py
index c32ad5087ab9e..95edd038dab9b 100644
--- a/pandas/tests/tseries/frequencies/test_inference.py
+++ b/pandas/tests/tseries/frequencies/test_inference.py
@@ -4,7 +4,7 @@
 import pytest
 
 from pandas._libs.tslibs.ccalendar import DAYS, MONTHS
-from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
 from pandas.compat import is_platform_windows
 
 from pandas import DatetimeIndex, Index, Series, Timestamp, date_range, period_range
diff --git a/pandas/tests/tseries/offsets/test_fiscal.py b/pandas/tests/tseries/offsets/test_fiscal.py
index f0ce104a68e29..7713be67a7e05 100644
--- a/pandas/tests/tseries/offsets/test_fiscal.py
+++ b/pandas/tests/tseries/offsets/test_fiscal.py
@@ -6,7 +6,7 @@
 from dateutil.relativedelta import relativedelta
 import pytest
 
-from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
 
 from pandas import Timestamp
 import pandas._testing as tm
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index e3a89d9ed57a6..784c04f225630 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -11,13 +11,9 @@
     conversion,
     timezones,
 )
-from pandas._libs.tslibs.frequencies import (
-    INVALID_FREQ_ERR_MSG,
-    get_freq_code,
-    get_freq_str,
-)
 import pandas._libs.tslibs.offsets as liboffsets
 from pandas._libs.tslibs.offsets import ApplyTypeError, _get_offset, _offset_map
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
 import pandas.compat as compat
 from pandas.compat.numpy import np_datetime64_compat
 from pandas.errors import PerformanceWarning
@@ -4112,13 +4108,6 @@ def test_rule_code(self):
                 assert alias == _get_offset(alias).rule_code
                 assert alias == (_get_offset(alias) * 5).rule_code
 
-        lst = ["M", "D", "B", "H", "T", "S", "L", "U"]
-        for k in lst:
-            code, stride = get_freq_code("3" + k)
-            assert isinstance(code, int)
-            assert stride == 3
-            assert k == get_freq_str(code)
-
 
 def test_dateoffset_misc():
     oset = offsets.DateOffset(months=2, days=4)
diff --git a/pandas/tests/tslibs/test_libfrequencies.py b/pandas/tests/tslibs/test_libfrequencies.py
index feaaaf6adca6f..993f2f4c8ef10 100644
--- a/pandas/tests/tslibs/test_libfrequencies.py
+++ b/pandas/tests/tslibs/test_libfrequencies.py
@@ -1,6 +1,5 @@
 import pytest
 
-from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG, _period_str_to_code
 from pandas._libs.tslibs.parsing import get_rule_month
 
 from pandas.tseries import offsets
@@ -28,51 +27,3 @@
 def test_get_rule_month(obj, expected):
     result = get_rule_month(obj)
     assert result == expected
-
-
-@pytest.mark.parametrize(
-    "obj,expected",
-    [
-        ("A", 1000),
-        ("A-DEC", 1000),
-        ("A-JAN", 1001),
-        ("Y", 1000),
-        ("Y-DEC", 1000),
-        ("Y-JAN", 1001),
-        ("Q", 2000),
-        ("Q-DEC", 2000),
-        ("Q-FEB", 2002),
-        ("W", 4000),
-        ("W-SUN", 4000),
-        ("W-FRI", 4005),
-        ("Min", 8000),
-        ("ms", 10000),
-        ("US", 11000),
-        ("NS", 12000),
-    ],
-)
-def test_period_str_to_code(obj, expected):
-    assert _period_str_to_code(obj) == expected
-
-
-@pytest.mark.parametrize(
-    "freq,expected,aliases",
-    [
-        ("D", 6000, ["DAY", "DLY", "DAILY"]),
-        ("M", 3000, ["MTH", "MONTH", "MONTHLY"]),
-        ("N", 12000, ["NANOSECOND", "NANOSECONDLY"]),
-        ("H", 7000, ["HR", "HOUR", "HRLY", "HOURLY"]),
-        ("T", 8000, ["minute", "MINUTE", "MINUTELY"]),
-        ("L", 10000, ["MILLISECOND", "MILLISECONDLY"]),
-        ("U", 11000, ["MICROSECOND", "MICROSECONDLY"]),
-        ("S", 9000, ["sec", "SEC", "SECOND", "SECONDLY"]),
-        ("B", 5000, ["BUS", "BUSINESS", "BUSINESSLY", "WEEKDAY"]),
-    ],
-)
-def test_assert_aliases_deprecated(freq, expected, aliases):
-    assert isinstance(aliases, list)
-    assert _period_str_to_code(freq) == expected
-
-    for alias in aliases:
-        with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
-            _period_str_to_code(alias)
diff --git a/pandas/tests/tslibs/test_period_asfreq.py b/pandas/tests/tslibs/test_period_asfreq.py
index 7205c3cc676cf..63298b657e341 100644
--- a/pandas/tests/tslibs/test_period_asfreq.py
+++ b/pandas/tests/tslibs/test_period_asfreq.py
@@ -1,9 +1,15 @@
 import pytest
 
-from pandas._libs.tslibs.frequencies import get_freq_code
+from pandas._libs.tslibs import to_offset
 from pandas._libs.tslibs.period import period_asfreq, period_ordinal
 
 
+def get_freq_code(freqstr: str) -> int:
+    off = to_offset(freqstr)
+    code = off._period_dtype_code
+    return code
+
+
 @pytest.mark.parametrize(
     "freq1,freq2,expected",
     [
@@ -32,8 +38,7 @@
 )
 def test_intra_day_conversion_factors(freq1, freq2, expected):
     assert (
-        period_asfreq(1, get_freq_code(freq1)[0], get_freq_code(freq2)[0], False)
-        == expected
+        period_asfreq(1, get_freq_code(freq1), get_freq_code(freq2), False) == expected
     )
 
 
@@ -42,7 +47,7 @@ def test_intra_day_conversion_factors(freq1, freq2, expected):
 )
 def test_period_ordinal_start_values(freq, expected):
     # information for Jan. 1, 1970.
-    assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq_code(freq)[0]) == expected
+    assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq_code(freq)) == expected
 
 
 @pytest.mark.parametrize(
@@ -55,7 +60,7 @@ def test_period_ordinal_start_values(freq, expected):
     ],
 )
 def test_period_ordinal_week(dt, expected):
-    args = dt + (get_freq_code("W")[0],)
+    args = dt + (get_freq_code("W"),)
     assert period_ordinal(*args) == expected
 
 
@@ -77,5 +82,6 @@ def test_period_ordinal_week(dt, expected):
     ],
 )
 def test_period_ordinal_business_day(day, expected):
-    args = (2013, 10, day, 0, 0, 0, 0, 0, get_freq_code("B")[0])
+    # 5000 is PeriodDtypeCode for BusinessDay
+    args = (2013, 10, day, 0, 0, 0, 0, 0, 5000)
     assert period_ordinal(*args) == expected