From 6e3e96e8821398a4ed43288a955ceb9861ed4437 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Mon, 10 Jul 2023 10:32:58 +0200
Subject: [PATCH 01/31] DEPR: deprecate codes T and L in
 to_abbrevs/_abbrev_to_attrnames

---
 pandas/_libs/tslibs/dtypes.pyx                | 17 ++++++++++
 .../tests/indexes/period/test_resolution.py   | 12 +++++--
 .../tseries/frequencies/test_freq_code.py     | 33 ++++++++++++++++---
 3 files changed, 56 insertions(+), 6 deletions(-)

diff --git a/pandas/_libs/tslibs/dtypes.pyx b/pandas/_libs/tslibs/dtypes.pyx
index 19f4c83e6cecf..c09343b68c6d2 100644
--- a/pandas/_libs/tslibs/dtypes.pyx
+++ b/pandas/_libs/tslibs/dtypes.pyx
@@ -1,6 +1,9 @@
 # period frequency constants corresponding to scikits timeseries
 # originals
 from enum import Enum
+import warnings
+
+from pandas.util._exceptions import find_stack_level
 
 from pandas._libs.tslibs.np_datetime cimport (
     NPY_DATETIMEUNIT,
@@ -274,6 +277,13 @@ class Resolution(Enum):
         """
         try:
             attr_name = _abbrev_to_attrnames[freq]
+            if freq in {"T", "L"}:
+                warnings.warn(
+                    f"Code freq={freq} is deprecated "
+                    "and will be removed in a future version.",
+                    FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
         except KeyError:
             # For quarterly and yearly resolutions, we need to chop off
             #  a month string.
@@ -284,6 +294,13 @@ class Resolution(Enum):
                 # i.e. we want e.g. "Q-DEC", not "Q-INVALID"
                 raise
             attr_name = _abbrev_to_attrnames[split_freq[0]]
+            if split_freq[0] in {"T", "L"}:
+                warnings.warn(
+                    f"Code freq={split_freq[0]} is deprecated "
+                    "and will be removed in a future version.",
+                    FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
 
         return cls.from_attrname(attr_name)
 
diff --git a/pandas/tests/indexes/period/test_resolution.py b/pandas/tests/indexes/period/test_resolution.py
index 7ecbde75cfa47..9ea7c1cdb39f3 100644
--- a/pandas/tests/indexes/period/test_resolution.py
+++ b/pandas/tests/indexes/period/test_resolution.py
@@ -1,6 +1,7 @@
 import pytest
 
 import pandas as pd
+import pandas._testing as tm
 
 
 class TestResolution:
@@ -19,5 +20,12 @@ class TestResolution:
         ],
     )
     def test_resolution(self, freq, expected):
-        idx = pd.period_range(start="2013-04-01", periods=30, freq=freq)
-        assert idx.resolution == expected
+        msg = f"Code freq={freq} is deprecated and will be removed in a future version."
+
+        if freq in {"T", "L"}:
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                idx = pd.period_range(start="2013-04-01", periods=30, freq=freq)
+                assert idx.resolution == expected
+        else:
+            idx = pd.period_range(start="2013-04-01", periods=30, freq=freq)
+            assert idx.resolution == expected
diff --git a/pandas/tests/tseries/frequencies/test_freq_code.py b/pandas/tests/tseries/frequencies/test_freq_code.py
index e961fdc295c96..5fadbc7a5b985 100644
--- a/pandas/tests/tseries/frequencies/test_freq_code.py
+++ b/pandas/tests/tseries/frequencies/test_freq_code.py
@@ -8,6 +8,8 @@
 )
 from pandas._libs.tslibs.dtypes import _attrname_to_abbrevs
 
+import pandas._testing as tm
+
 
 @pytest.mark.parametrize(
     "freqstr,exp_freqstr",
@@ -38,14 +40,28 @@ def test_get_to_timestamp_base(freqstr, exp_freqstr):
     ],
 )
 def test_get_attrname_from_abbrev(freqstr, expected):
-    assert Resolution.get_reso_from_freqstr(freqstr).attrname == expected
+    msg = f"Code freq={freqstr} is deprecated and will be removed in a future version."
+
+    if freqstr in {"T", "L"}:
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert Resolution.get_reso_from_freqstr(freqstr).attrname == expected
+    else:
+        assert Resolution.get_reso_from_freqstr(freqstr).attrname == expected
 
 
 @pytest.mark.parametrize("freq", ["D", "H", "T", "S", "L", "U", "N"])
 def test_get_freq_roundtrip2(freq):
-    obj = Resolution.get_reso_from_freqstr(freq)
-    result = _attrname_to_abbrevs[obj.attrname]
-    assert freq == result
+    msg = f"Code freq={freq} is deprecated and will be removed in a future version."
+
+    if freq in {"T", "L"}:
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            obj = Resolution.get_reso_from_freqstr(freq)
+            result = _attrname_to_abbrevs[obj.attrname]
+            assert freq == result
+    else:
+        obj = Resolution.get_reso_from_freqstr(freq)
+        result = _attrname_to_abbrevs[obj.attrname]
+        assert freq == result
 
 
 @pytest.mark.parametrize(
@@ -95,3 +111,12 @@ def test_compatibility(freqstr, expected):
     ts_np = np.datetime64("2021-01-01T08:00:00.00")
     do = to_offset(freqstr)
     assert ts_np + do == np.datetime64(expected)
+
+
+@pytest.mark.parametrize("freq", ["T", "L"])
+def test_to_datetime_mixed_offsets_with_utcFalse_deprecated(freq):
+    # GH 52536
+    msg = f"Code freq={freq} is deprecated and will be removed in a future version."
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        Resolution.get_reso_from_freqstr(freq)

From fe886638b8b785aeaa430fe3dbf8bd764b5cfc4c Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Wed, 12 Jul 2023 18:08:41 +0200
Subject: [PATCH 02/31] replace T/L with min/ms in _prefix, period_code_map,
 _attrname_to_abbrevs and fix tests

---
 pandas/_libs/tslibs/dtypes.pyx               | 12 ++--
 pandas/_libs/tslibs/offsets.pyx              | 16 ++---
 pandas/tests/arithmetic/test_period.py       |  2 +-
 pandas/tests/arrays/test_datetimelike.py     |  4 +-
 pandas/tests/resample/test_datetime_index.py | 64 +++++++++++---------
 pandas/tests/tseries/offsets/test_offsets.py |  2 +-
 pandas/tests/tslibs/test_period_asfreq.py    | 22 +++----
 pandas/tests/tslibs/test_to_offset.py        |  8 +--
 8 files changed, 68 insertions(+), 62 deletions(-)

diff --git a/pandas/_libs/tslibs/dtypes.pyx b/pandas/_libs/tslibs/dtypes.pyx
index c09343b68c6d2..7b27810e56c69 100644
--- a/pandas/_libs/tslibs/dtypes.pyx
+++ b/pandas/_libs/tslibs/dtypes.pyx
@@ -144,9 +144,9 @@ _period_code_map = {
     "B": PeriodDtypeCode.B,        # Business days
     "D": PeriodDtypeCode.D,        # Daily
     "H": PeriodDtypeCode.H,        # Hourly
-    "T": PeriodDtypeCode.T,        # Minutely
+    "min": PeriodDtypeCode.T,        # Minutely
     "S": PeriodDtypeCode.S,        # Secondly
-    "L": PeriodDtypeCode.L,       # Millisecondly
+    "ms": PeriodDtypeCode.L,       # Millisecondly
     "U": PeriodDtypeCode.U,       # Microsecondly
     "N": PeriodDtypeCode.N,       # Nanosecondly
 }
@@ -177,9 +177,9 @@ _attrname_to_abbrevs = {
     "month": "M",
     "day": "D",
     "hour": "H",
-    "minute": "T",
+    "minute": "min",
     "second": "S",
-    "millisecond": "L",
+    "millisecond": "ms",
     "microsecond": "U",
     "nanosecond": "N",
 }
@@ -284,6 +284,7 @@ class Resolution(Enum):
                     FutureWarning,
                     stacklevel=find_stack_level(),
                 )
+                freq = freq.replace("T", "min").replace("L", "ms")
         except KeyError:
             # For quarterly and yearly resolutions, we need to chop off
             #  a month string.
@@ -293,7 +294,6 @@ class Resolution(Enum):
             if split_freq[1] not in _month_names:
                 # i.e. we want e.g. "Q-DEC", not "Q-INVALID"
                 raise
-            attr_name = _abbrev_to_attrnames[split_freq[0]]
             if split_freq[0] in {"T", "L"}:
                 warnings.warn(
                     f"Code freq={split_freq[0]} is deprecated "
@@ -301,6 +301,8 @@ class Resolution(Enum):
                     FutureWarning,
                     stacklevel=find_stack_level(),
                 )
+                split_freq[0] = split_freq[0].replace("T", "min").replace("L", "ms")
+            attr_name = _abbrev_to_attrnames[split_freq[0]]
 
         return cls.from_attrname(attr_name)
 
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index 84b102bd4a262..85d985c7b888c 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -1104,7 +1104,7 @@ cdef class Hour(Tick):
 
 cdef class Minute(Tick):
     _nanos_inc = 60 * 1_000_000_000
-    _prefix = "T"
+    _prefix = "min"
     _period_dtype_code = PeriodDtypeCode.T
     _creso = NPY_DATETIMEUNIT.NPY_FR_m
 
@@ -1118,7 +1118,7 @@ cdef class Second(Tick):
 
 cdef class Milli(Tick):
     _nanos_inc = 1_000_000
-    _prefix = "L"
+    _prefix = "ms"
     _period_dtype_code = PeriodDtypeCode.L
     _creso = NPY_DATETIMEUNIT.NPY_FR_ms
 
@@ -4262,11 +4262,11 @@ prefix_mapping = {
         SemiMonthBegin,  # 'SMS'
         Week,  # 'W'
         Second,  # 'S'
-        Minute,  # 'T'
+        Minute,  # 'min'
         Micro,  # 'U'
         QuarterEnd,  # 'Q'
         QuarterBegin,  # 'QS'
-        Milli,  # 'L'
+        Milli,  # 'ms'
         Hour,  # 'H'
         Day,  # 'D'
         WeekOfMonth,  # 'WOM'
@@ -4293,9 +4293,9 @@ _lite_rule_alias = {
     "BAS": "BAS-JAN",  # BYearBegin(month=1),
     "BYS": "BAS-JAN",
 
-    "Min": "T",
-    "min": "T",
-    "ms": "L",
+    "Min": "min",
+    "min": "min",
+    "ms": "ms",
     "us": "U",
     "ns": "N",
 }
@@ -4417,7 +4417,7 @@ cpdef to_offset(freq):
                 if not stride:
                     stride = 1
 
-                if prefix in {"D", "H", "T", "S", "L", "U", "N"}:
+                if prefix in {"D", "H", "min", "S", "ms", "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
diff --git a/pandas/tests/arithmetic/test_period.py b/pandas/tests/arithmetic/test_period.py
index 7a079ae7795e6..792d5a0ab916d 100644
--- a/pandas/tests/arithmetic/test_period.py
+++ b/pandas/tests/arithmetic/test_period.py
@@ -1048,7 +1048,7 @@ def test_parr_add_timedeltalike_minute_gt1(self, three_days, box_with_array):
         with pytest.raises(TypeError, match=msg):
             other - rng
 
-    @pytest.mark.parametrize("freqstr", ["5ns", "5us", "5ms", "5s", "5T", "5h", "5d"])
+    @pytest.mark.parametrize("freqstr", ["5ns", "5us", "5ms", "5s", "5min", "5h", "5d"])
     def test_parr_add_timedeltalike_tick_gt1(self, three_days, freqstr, box_with_array):
         # GH#23031 adding a time-delta-like offset to a PeriodArray that has
         # tick-like frequency with n != 1
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 9e402af931199..11a04cdc1a088 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -615,13 +615,13 @@ def test_round(self, arr1d):
         # GH#24064
         dti = self.index_cls(arr1d)
 
-        result = dti.round(freq="2T")
+        result = dti.round(freq="2min")
         expected = dti - pd.Timedelta(minutes=1)
         expected = expected._with_freq(None)
         tm.assert_index_equal(result, expected)
 
         dta = dti._data
-        result = dta.round(freq="2T")
+        result = dta.round(freq="2min")
         expected = expected._data._with_freq(None)
         tm.assert_datetime_array_equal(result, expected)
 
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 3c6f75bdcfc46..fb20f7540a667 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -83,7 +83,7 @@ def test_custom_grouper(index, unit):
     arr = [1] + [5] * 2592
     idx = dti[0:-1:5]
     idx = idx.append(dti[-1:])
-    idx = DatetimeIndex(idx, freq="5T").as_unit(unit)
+    idx = DatetimeIndex(idx, freq="5min").as_unit(unit)
     expect = Series(arr, index=idx)
 
     # GH2763 - return input dtype if we can
@@ -139,21 +139,21 @@ def test_resample_integerarray(unit):
     # GH 25580, resample on IntegerArray
     ts = Series(
         range(9),
-        index=date_range("1/1/2000", periods=9, freq="T").as_unit(unit),
+        index=date_range("1/1/2000", periods=9, freq="min").as_unit(unit),
         dtype="Int64",
     )
-    result = ts.resample("3T").sum()
+    result = ts.resample("3min").sum()
     expected = Series(
         [3, 12, 21],
-        index=date_range("1/1/2000", periods=3, freq="3T").as_unit(unit),
+        index=date_range("1/1/2000", periods=3, freq="3min").as_unit(unit),
         dtype="Int64",
     )
     tm.assert_series_equal(result, expected)
 
-    result = ts.resample("3T").mean()
+    result = ts.resample("3min").mean()
     expected = Series(
         [1, 4, 7],
-        index=date_range("1/1/2000", periods=3, freq="3T").as_unit(unit),
+        index=date_range("1/1/2000", periods=3, freq="3min").as_unit(unit),
         dtype="Float64",
     )
     tm.assert_series_equal(result, expected)
@@ -507,10 +507,10 @@ def test_resample_extra_index_point(unit):
 
 
 def test_upsample_with_limit(unit):
-    rng = date_range("1/1/2000", periods=3, freq="5t").as_unit(unit)
+    rng = date_range("1/1/2000", periods=3, freq="5min").as_unit(unit)
     ts = Series(np.random.randn(len(rng)), rng)
 
-    result = ts.resample("t").ffill(limit=2)
+    result = ts.resample("min").ffill(limit=2)
     expected = ts.reindex(result.index, method="ffill", limit=2)
     tm.assert_series_equal(result, expected)
 
@@ -559,10 +559,10 @@ def test_resample_ohlc_result(unit):
     index = index.union(date_range("4-15-2000", "5-15-2000", freq="h").as_unit(unit))
     s = Series(range(len(index)), index=index)
 
-    a = s.loc[:"4-15-2000"].resample("30T").ohlc()
+    a = s.loc[:"4-15-2000"].resample("30min").ohlc()
     assert isinstance(a, DataFrame)
 
-    b = s.loc[:"4-14-2000"].resample("30T").ohlc()
+    b = s.loc[:"4-14-2000"].resample("30min").ohlc()
     assert isinstance(b, DataFrame)
 
 
@@ -739,7 +739,7 @@ def test_resample_axis1(unit):
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.parametrize("freq", ["t", "5t", "15t", "30t", "4h", "12h"])
+@pytest.mark.parametrize("freq", ["min", "5min", "15min", "30min", "4h", "12h"])
 def test_resample_anchored_ticks(freq, unit):
     # If a fixed delta (5 minute, 4 hour) evenly divides a day, we should
     # "anchor" the origin at midnight so we get regular intervals rather
@@ -992,7 +992,7 @@ def _create_series(values, timestamps, freq="D"):
 
 
 def test_resample_daily_anchored(unit):
-    rng = date_range("1/1/2000 0:00:00", periods=10000, freq="T").as_unit(unit)
+    rng = date_range("1/1/2000 0:00:00", periods=10000, freq="min").as_unit(unit)
     ts = Series(np.random.randn(len(rng)), index=rng)
     ts[:2] = np.nan  # so results are the same
 
@@ -1176,25 +1176,25 @@ def test_resample_anchored_multiday(label, sec):
     #
     # See: https://github.com/pandas-dev/pandas/issues/8683
 
-    index1 = date_range("2014-10-14 23:06:23.206", periods=3, freq="400L")
-    index2 = date_range("2014-10-15 23:00:00", periods=2, freq="2200L")
+    index1 = date_range("2014-10-14 23:06:23.206", periods=3, freq="400ms")
+    index2 = date_range("2014-10-15 23:00:00", periods=2, freq="2200ms")
     index = index1.union(index2)
 
     s = Series(np.random.randn(5), index=index)
 
     # Ensure left closing works
-    result = s.resample("2200L", label=label).mean()
+    result = s.resample("2200ms", label=label).mean()
     assert result.index[-1] == Timestamp(f"2014-10-15 23:00:{sec}00")
 
 
 def test_corner_cases(unit):
     # miscellaneous test coverage
 
-    rng = date_range("1/1/2000", periods=12, freq="t").as_unit(unit)
+    rng = date_range("1/1/2000", periods=12, freq="min").as_unit(unit)
     ts = Series(np.random.randn(len(rng)), index=rng)
 
-    result = ts.resample("5t", closed="right", label="left").mean()
-    ex_index = date_range("1999-12-31 23:55", periods=4, freq="5t").as_unit(unit)
+    result = ts.resample("5min", closed="right", label="left").mean()
+    ex_index = date_range("1999-12-31 23:55", periods=4, freq="5min").as_unit(unit)
     tm.assert_index_equal(result.index, ex_index)
 
 
@@ -1264,12 +1264,12 @@ def test_resample_median_bug_1688(dtype):
         dtype=dtype,
     )
 
-    result = df.resample("T").apply(lambda x: x.mean())
-    exp = df.asfreq("T")
+    result = df.resample("min").apply(lambda x: x.mean())
+    exp = df.asfreq("min")
     tm.assert_frame_equal(result, exp)
 
-    result = df.resample("T").median()
-    exp = df.asfreq("T")
+    result = df.resample("min").median()
+    exp = df.asfreq("min")
     tm.assert_frame_equal(result, exp)
 
 
@@ -1316,12 +1316,12 @@ def test_resample_consistency(unit):
     # GH 6418
     # resample with bfill / limit / reindex consistency
 
-    i30 = date_range("2002-02-02", periods=4, freq="30T").as_unit(unit)
+    i30 = date_range("2002-02-02", periods=4, freq="30min").as_unit(unit)
     s = Series(np.arange(4.0), index=i30)
     s.iloc[2] = np.NaN
 
     # Upsample by factor 3 with reindex() and resample() methods:
-    i10 = date_range(i30[0], i30[-1], freq="10T").as_unit(unit)
+    i10 = date_range(i30[0], i30[-1], freq="10min").as_unit(unit)
 
     s10 = s.reindex(index=i10, method="bfill")
     s10_2 = s.reindex(index=i10, method="bfill", limit=2)
@@ -1455,11 +1455,13 @@ def test_resample_group_info(n, k, unit):
     # use a fixed seed to always have the same uniques
     prng = np.random.RandomState(1234)
 
-    dr = date_range(start="2015-08-27", periods=n // 10, freq="T").as_unit(unit)
+    dr = date_range(start="2015-08-27", periods=n // 10, freq="min").as_unit(unit)
     ts = Series(prng.randint(0, n // k, n).astype("int64"), index=prng.choice(dr, n))
 
-    left = ts.resample("30T").nunique()
-    ix = date_range(start=ts.index.min(), end=ts.index.max(), freq="30T").as_unit(unit)
+    left = ts.resample("30min").nunique()
+    ix = date_range(start=ts.index.min(), end=ts.index.max(), freq="30min").as_unit(
+        unit
+    )
 
     vals = ts.values
     bins = np.searchsorted(ix.values, ts.index, side="right")
@@ -1478,11 +1480,13 @@ def test_resample_group_info(n, k, unit):
 
 def test_resample_size(unit):
     n = 10000
-    dr = date_range("2015-09-19", periods=n, freq="T").as_unit(unit)
+    dr = date_range("2015-09-19", periods=n, freq="min").as_unit(unit)
     ts = Series(np.random.randn(n), index=np.random.choice(dr, n))
 
-    left = ts.resample("7T").size()
-    ix = date_range(start=left.index.min(), end=ts.index.max(), freq="7T").as_unit(unit)
+    left = ts.resample("7min").size()
+    ix = date_range(start=left.index.min(), end=ts.index.max(), freq="7min").as_unit(
+        unit
+    )
 
     bins = np.searchsorted(ix.values, ts.index.values, side="right")
     val = np.bincount(bins, minlength=len(ix) + 1)[1:].astype("int64", copy=False)
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index 5139331bebaf7..eacefca1e218d 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -811,7 +811,7 @@ def test_alias_equality(self):
             assert k == v.copy()
 
     def test_rule_code(self):
-        lst = ["M", "MS", "BM", "BMS", "D", "B", "H", "T", "S", "L", "U"]
+        lst = ["M", "MS", "BM", "BMS", "D", "B", "H", "min", "S", "ms", "U"]
         for k in lst:
             assert k == _get_offset(k).rule_code
             # should be cached - this is kind of an internals test...
diff --git a/pandas/tests/tslibs/test_period_asfreq.py b/pandas/tests/tslibs/test_period_asfreq.py
index 7c9047b3e7c60..71d121553dc9e 100644
--- a/pandas/tests/tslibs/test_period_asfreq.py
+++ b/pandas/tests/tslibs/test_period_asfreq.py
@@ -25,25 +25,25 @@ def get_freq_code(freqstr: str) -> int:
     "freq1,freq2,expected",
     [
         ("D", "H", 24),
-        ("D", "T", 1440),
+        ("D", "min", 1440),
         ("D", "S", 86400),
-        ("D", "L", 86400000),
+        ("D", "ms", 86400000),
         ("D", "U", 86400000000),
         ("D", "N", 86400000000000),
-        ("H", "T", 60),
+        ("H", "min", 60),
         ("H", "S", 3600),
-        ("H", "L", 3600000),
+        ("H", "ms", 3600000),
         ("H", "U", 3600000000),
         ("H", "N", 3600000000000),
-        ("T", "S", 60),
-        ("T", "L", 60000),
-        ("T", "U", 60000000),
-        ("T", "N", 60000000000),
-        ("S", "L", 1000),
+        ("min", "S", 60),
+        ("min", "ms", 60000),
+        ("min", "U", 60000000),
+        ("min", "N", 60000000000),
+        ("S", "ms", 1000),
         ("S", "U", 1000000),
         ("S", "N", 1000000000),
-        ("L", "U", 1000),
-        ("L", "N", 1000000),
+        ("ms", "U", 1000),
+        ("ms", "N", 1000000),
         ("U", "N", 1000),
     ],
 )
diff --git a/pandas/tests/tslibs/test_to_offset.py b/pandas/tests/tslibs/test_to_offset.py
index 27ddbb82f49a9..160619f1ad416 100644
--- a/pandas/tests/tslibs/test_to_offset.py
+++ b/pandas/tests/tslibs/test_to_offset.py
@@ -21,10 +21,10 @@
         ("2h 20.5min", offsets.Second(8430)),
         ("1.5min", offsets.Second(90)),
         ("0.5S", offsets.Milli(500)),
-        ("15l500u", offsets.Micro(15500)),
-        ("10s75L", offsets.Milli(10075)),
+        ("15ms500u", offsets.Micro(15500)),
+        ("10s75ms", offsets.Milli(10075)),
+        ("1s0.25ms", offsets.Micro(1000250)),
         ("1s0.25ms", offsets.Micro(1000250)),
-        ("1s0.25L", offsets.Micro(1000250)),
         ("2800N", offsets.Nano(2800)),
         ("2SM", offsets.SemiMonthEnd(2)),
         ("2SM-16", offsets.SemiMonthEnd(2, day_of_month=16)),
@@ -119,7 +119,7 @@ def test_to_offset_whitespace(freqstr, expected):
 
 
 @pytest.mark.parametrize(
-    "freqstr,expected", [("00H 00T 01S", 1), ("-00H 03T 14S", -194)]
+    "freqstr,expected", [("00H 00min 01S", 1), ("-00H 03min 14S", -194)]
 )
 def test_to_offset_leading_zero(freqstr, expected):
     result = to_offset(freqstr)

From 1e79480c28af86097f1cf4f72b5530129ead3ec3 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Fri, 14 Jul 2023 12:21:52 +0200
Subject: [PATCH 03/31] correct def get_freq for tseries, fix tests

---
 .../tests/tseries/frequencies/test_freq_code.py  | 16 ++++++++--------
 .../tests/tseries/frequencies/test_inference.py  |  8 ++++----
 .../tests/tseries/offsets/test_business_month.py |  2 +-
 pandas/tests/tseries/offsets/test_index.py       |  2 +-
 pandas/tseries/frequencies.py                    |  4 ++--
 5 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/pandas/tests/tseries/frequencies/test_freq_code.py b/pandas/tests/tseries/frequencies/test_freq_code.py
index 5fadbc7a5b985..7f246eca77def 100644
--- a/pandas/tests/tseries/frequencies/test_freq_code.py
+++ b/pandas/tests/tseries/frequencies/test_freq_code.py
@@ -13,7 +13,7 @@
 
 @pytest.mark.parametrize(
     "freqstr,exp_freqstr",
-    [("D", "D"), ("W", "D"), ("M", "D"), ("S", "S"), ("T", "S"), ("H", "S")],
+    [("D", "D"), ("W", "D"), ("M", "D"), ("S", "S"), ("min", "S"), ("H", "S")],
 )
 def test_get_to_timestamp_base(freqstr, exp_freqstr):
     off = to_offset(freqstr)
@@ -32,9 +32,9 @@ def test_get_to_timestamp_base(freqstr, exp_freqstr):
         ("M", "month"),
         ("D", "day"),
         ("H", "hour"),
-        ("T", "minute"),
+        ("min", "minute"),
         ("S", "second"),
-        ("L", "millisecond"),
+        ("ms", "millisecond"),
         ("U", "microsecond"),
         ("N", "nanosecond"),
     ],
@@ -49,7 +49,7 @@ def test_get_attrname_from_abbrev(freqstr, expected):
         assert Resolution.get_reso_from_freqstr(freqstr).attrname == expected
 
 
-@pytest.mark.parametrize("freq", ["D", "H", "T", "S", "L", "U", "N"])
+@pytest.mark.parametrize("freq", ["D", "H", "min", "S", "ms", "U", "N"])
 def test_get_freq_roundtrip2(freq):
     msg = f"Code freq={freq} is deprecated and will be removed in a future version."
 
@@ -67,12 +67,12 @@ def test_get_freq_roundtrip2(freq):
 @pytest.mark.parametrize(
     "args,expected",
     [
-        ((1.5, "T"), (90, "S")),
-        ((62.4, "T"), (3744, "S")),
+        ((1.5, "min"), (90, "S")),
+        ((62.4, "min"), (3744, "S")),
         ((1.04, "H"), (3744, "S")),
         ((1, "D"), (1, "D")),
         ((0.342931, "H"), (1234551600, "U")),
-        ((1.2345, "D"), (106660800, "L")),
+        ((1.2345, "D"), (106660800, "ms")),
     ],
 )
 def test_resolution_bumping(args, expected):
@@ -114,7 +114,7 @@ def test_compatibility(freqstr, expected):
 
 
 @pytest.mark.parametrize("freq", ["T", "L"])
-def test_to_datetime_mixed_offsets_with_utcFalse_deprecated(freq):
+def test_units_t_l_deprecated_from__attrname_to_abbrevs(freq):
     # GH 52536
     msg = f"Code freq={freq} is deprecated and will be removed in a future version."
 
diff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py
index d811b2cf12c19..337bc7374a9f4 100644
--- a/pandas/tests/tseries/frequencies/test_inference.py
+++ b/pandas/tests/tseries/frequencies/test_inference.py
@@ -254,7 +254,7 @@ def test_infer_freq_tz_series(tz_naive_fixture):
     ],
 )
 @pytest.mark.parametrize(
-    "freq", ["H", "3H", "10T", "3601S", "3600001L", "3600000001U", "3600000000001N"]
+    "freq", ["H", "3H", "10min", "3601S", "3600001ms", "3600000001U", "3600000000001N"]
 )
 def test_infer_freq_tz_transition(tz_naive_fixture, date_pair, freq):
     # see gh-8772
@@ -437,7 +437,7 @@ def test_series_inconvertible_string():
         frequencies.infer_freq(Series(["foo", "bar"]))
 
 
-@pytest.mark.parametrize("freq", [None, "L"])
+@pytest.mark.parametrize("freq", [None, "ms"])
 def test_series_period_index(freq):
     # see gh-6407
     #
@@ -449,7 +449,7 @@ def test_series_period_index(freq):
         frequencies.infer_freq(s)
 
 
-@pytest.mark.parametrize("freq", ["M", "L", "S"])
+@pytest.mark.parametrize("freq", ["M", "ms", "S"])
 def test_series_datetime_index(freq):
     s = Series(date_range("20130101", periods=10, freq=freq))
     inferred = frequencies.infer_freq(s)
@@ -535,7 +535,7 @@ def test_infer_freq_non_nano():
     arr2 = arr.view("m8[ms]")
     tda = TimedeltaArray._simple_new(arr2, dtype=arr2.dtype)
     res2 = frequencies.infer_freq(tda)
-    assert res2 == "L"
+    assert res2 == "ms"
 
 
 def test_infer_freq_non_nano_tzaware(tz_aware_fixture):
diff --git a/pandas/tests/tseries/offsets/test_business_month.py b/pandas/tests/tseries/offsets/test_business_month.py
index 9f7fb990d238a..a14451e60aa89 100644
--- a/pandas/tests/tseries/offsets/test_business_month.py
+++ b/pandas/tests/tseries/offsets/test_business_month.py
@@ -31,7 +31,7 @@
 )
 def test_apply_index(cls, n):
     offset = cls(n=n)
-    rng = pd.date_range(start="1/1/2000", periods=100000, freq="T")
+    rng = pd.date_range(start="1/1/2000", periods=100000, freq="min")
     ser = pd.Series(rng)
 
     res = rng + offset
diff --git a/pandas/tests/tseries/offsets/test_index.py b/pandas/tests/tseries/offsets/test_index.py
index ad3478b319898..7a62944556d11 100644
--- a/pandas/tests/tseries/offsets/test_index.py
+++ b/pandas/tests/tseries/offsets/test_index.py
@@ -44,7 +44,7 @@
 )
 def test_apply_index(cls, n):
     offset = cls(n=n)
-    rng = date_range(start="1/1/2000", periods=100000, freq="T")
+    rng = date_range(start="1/1/2000", periods=100000, freq="min")
     ser = Series(rng)
 
     res = rng + offset
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index caa34a067ac69..61b9b84f0317b 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -271,13 +271,13 @@ def get_freq(self) -> str | None:
             return _maybe_add_count("H", delta / pph)
         elif _is_multiple(delta, ppm):
             # Minutes
-            return _maybe_add_count("T", delta / ppm)
+            return _maybe_add_count("min", delta / ppm)
         elif _is_multiple(delta, pps):
             # Seconds
             return _maybe_add_count("S", delta / pps)
         elif _is_multiple(delta, (pps // 1000)):
             # Milliseconds
-            return _maybe_add_count("L", delta / (pps // 1000))
+            return _maybe_add_count("ms", delta / (pps // 1000))
         elif _is_multiple(delta, (pps // 1_000_000)):
             # Microseconds
             return _maybe_add_count("U", delta / (pps // 1_000_000))

From f7fd2a129143dc99cfb42c0f8827126ba908e749 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Fri, 14 Jul 2023 16:28:53 +0200
Subject: [PATCH 04/31] replace T, L in _offset_to_period_map, is_subperiod,
 is_superperiod, fix tests

---
 pandas/tests/resample/test_period_index.py |  2 +-
 pandas/tseries/frequencies.py              | 42 +++++++++++-----------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index 20b997bdca873..38d7593a862ad 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -425,7 +425,7 @@ def test_cant_fill_missing_dups(self):
     @pytest.mark.parametrize("freq", ["5min"])
     @pytest.mark.parametrize("kind", ["period", None, "timestamp"])
     def test_resample_5minute(self, freq, kind):
-        rng = period_range("1/1/2000", "1/5/2000", freq="T")
+        rng = period_range("1/1/2000", "1/5/2000", freq="min")
         ts = Series(np.random.randn(len(rng)), index=rng)
         expected = ts.to_timestamp().resample(freq).mean()
         if kind != "timestamp":
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 61b9b84f0317b..c8ea24cbea044 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -68,7 +68,7 @@
     "MS": "M",
     "D": "D",
     "B": "B",
-    "T": "T",
+    "min": "min",
     "S": "S",
     "L": "L",
     "U": "U",
@@ -483,23 +483,23 @@ def is_subperiod(source, target) -> bool:
             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"}
+        return source in {"D", "C", "B", "M", "H", "min", "S", "L", "U", "N"}
     elif _is_quarterly(target):
-        return source in {"D", "C", "B", "M", "H", "T", "S", "L", "U", "N"}
+        return source in {"D", "C", "B", "M", "H", "min", "S", "L", "U", "N"}
     elif _is_monthly(target):
-        return source in {"D", "C", "B", "H", "T", "S", "L", "U", "N"}
+        return source in {"D", "C", "B", "H", "min", "S", "L", "U", "N"}
     elif _is_weekly(target):
-        return source in {target, "D", "C", "B", "H", "T", "S", "L", "U", "N"}
+        return source in {target, "D", "C", "B", "H", "min", "S", "L", "U", "N"}
     elif target == "B":
-        return source in {"B", "H", "T", "S", "L", "U", "N"}
+        return source in {"B", "H", "min", "S", "L", "U", "N"}
     elif target == "C":
-        return source in {"C", "H", "T", "S", "L", "U", "N"}
+        return source in {"C", "H", "min", "S", "L", "U", "N"}
     elif target == "D":
-        return source in {"D", "H", "T", "S", "L", "U", "N"}
+        return source in {"D", "H", "min", "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"}
+        return source in {"H", "min", "S", "L", "U", "N"}
+    elif target == "min":
+        return source in {"min", "S", "L", "U", "N"}
     elif target == "S":
         return source in {"S", "L", "U", "N"}
     elif target == "L":
@@ -541,23 +541,23 @@ def is_superperiod(source, target) -> bool:
             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"}
+        return target in {"D", "C", "B", "M", "H", "min", "S", "L", "U", "N"}
     elif _is_quarterly(source):
-        return target in {"D", "C", "B", "M", "H", "T", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "M", "H", "min", "S", "L", "U", "N"}
     elif _is_monthly(source):
-        return target in {"D", "C", "B", "H", "T", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "L", "U", "N"}
     elif _is_weekly(source):
-        return target in {source, "D", "C", "B", "H", "T", "S", "L", "U", "N"}
+        return target in {source, "D", "C", "B", "H", "min", "S", "L", "U", "N"}
     elif source == "B":
-        return target in {"D", "C", "B", "H", "T", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "L", "U", "N"}
     elif source == "C":
-        return target in {"D", "C", "B", "H", "T", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "L", "U", "N"}
     elif source == "D":
-        return target in {"D", "C", "B", "H", "T", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "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"}
+        return target in {"H", "min", "S", "L", "U", "N"}
+    elif source == "min":
+        return target in {"min", "S", "L", "U", "N"}
     elif source == "S":
         return target in {"S", "L", "U", "N"}
     elif source == "L":

From 98e8a39f6a3141fe0eef889c64d53b49e8f4fb1a Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Mon, 17 Jul 2023 13:10:53 +0200
Subject: [PATCH 05/31] correct def to_timedelta, def _round_temporally and fix
 tests

---
 pandas/core/arrays/arrow/array.py             |  4 ++--
 pandas/core/tools/timedeltas.py               |  4 ++++
 pandas/tests/copy_view/test_methods.py        |  4 ++--
 pandas/tests/extension/test_arrow.py          |  2 +-
 pandas/tests/frame/methods/test_asfreq.py     |  2 +-
 pandas/tests/frame/methods/test_equals.py     |  4 ++--
 pandas/tests/frame/methods/test_join.py       |  4 ++--
 pandas/tests/frame/methods/test_shift.py      |  4 ++--
 .../tests/frame/methods/test_to_timestamp.py  |  6 ++---
 pandas/tests/frame/test_constructors.py       |  2 +-
 pandas/tests/generic/test_frame.py            |  2 +-
 pandas/tests/generic/test_series.py           |  6 ++---
 .../tests/groupby/aggregate/test_aggregate.py | 14 +++++------
 pandas/tests/groupby/aggregate/test_cython.py |  2 +-
 pandas/tests/groupby/test_categorical.py      |  4 ++--
 pandas/tests/groupby/test_counting.py         |  2 +-
 pandas/tests/groupby/test_groupby.py          |  4 ++--
 pandas/tests/groupby/test_quantile.py         |  2 +-
 pandas/tests/groupby/test_timegrouper.py      |  2 +-
 pandas/tests/indexes/conftest.py              |  2 +-
 .../datetimelike_/test_drop_duplicates.py     |  1 +
 .../indexes/datetimes/methods/test_shift.py   |  2 +-
 .../datetimes/methods/test_to_period.py       |  6 ++---
 .../indexes/datetimes/test_constructors.py    |  2 +-
 .../indexes/datetimes/test_date_range.py      |  6 ++---
 pandas/tests/indexes/datetimes/test_ops.py    |  4 ++--
 .../indexes/datetimes/test_partial_slicing.py |  4 ++--
 .../indexes/datetimes/test_scalar_compat.py   |  8 +++----
 pandas/tests/indexes/datetimes/test_setops.py |  4 ++--
 .../tests/indexes/datetimes/test_timezones.py | 24 +++++++++----------
 .../tests/indexes/period/test_constructors.py |  4 ++--
 .../tests/indexes/period/test_resolution.py   | 15 ++++--------
 pandas/tests/indexes/period/test_setops.py    | 14 +++++------
 pandas/tests/indexes/period/test_tools.py     |  4 ++--
 .../indexes/timedeltas/methods/test_shift.py  |  6 ++---
 .../indexes/timedeltas/test_scalar_compat.py  |  4 ++--
 .../timedeltas/test_timedelta_range.py        |  4 ++--
 pandas/tests/resample/test_base.py            |  4 ++--
 pandas/tests/resample/test_period_index.py    |  2 +-
 39 files changed, 96 insertions(+), 98 deletions(-)

diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 284044dfadfef..c6c4a3a2f361a 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -2466,9 +2466,9 @@ def _round_temporally(
             "W": "week",
             "D": "day",
             "H": "hour",
-            "T": "minute",
+            "min": "minute",
             "S": "second",
-            "L": "millisecond",
+            "ms": "millisecond",
             "U": "microsecond",
             "N": "nanosecond",
         }
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index 95946f0a159fd..2f88403493711 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -180,6 +180,10 @@ def to_timedelta(
             FutureWarning,
             stacklevel=find_stack_level(),
         )
+        if unit.lower() == "t":
+            unit = unit.replace(unit, "min")
+        else:
+            unit = unit.replace(unit, "ms")
 
     if unit is not None:
         unit = parse_timedelta_unit(unit)
diff --git a/pandas/tests/copy_view/test_methods.py b/pandas/tests/copy_view/test_methods.py
index 9e7ae9942ea90..3508c81bf8688 100644
--- a/pandas/tests/copy_view/test_methods.py
+++ b/pandas/tests/copy_view/test_methods.py
@@ -1499,10 +1499,10 @@ def test_where_mask_noop_on_single_column(using_copy_on_write, dtype, val, func)
 def test_asfreq_noop(using_copy_on_write):
     df = DataFrame(
         {"a": [0.0, None, 2.0, 3.0]},
-        index=date_range("1/1/2000", periods=4, freq="T"),
+        index=date_range("1/1/2000", periods=4, freq="min"),
     )
     df_orig = df.copy()
-    df2 = df.asfreq(freq="T")
+    df2 = df.asfreq(freq="min")
 
     if using_copy_on_write:
         assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
diff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py
index 56e35d30ad83c..b4bc90a3b65cd 100644
--- a/pandas/tests/extension/test_arrow.py
+++ b/pandas/tests/extension/test_arrow.py
@@ -2623,7 +2623,7 @@ def test_dt_roundlike_unsupported_freq(method):
 @pytest.mark.xfail(
     pa_version_under7p0, reason="Methods not supported for pyarrow < 7.0"
 )
-@pytest.mark.parametrize("freq", ["D", "H", "T", "S", "L", "U", "N"])
+@pytest.mark.parametrize("freq", ["D", "H", "min", "S", "ms", "U", "N"])
 @pytest.mark.parametrize("method", ["ceil", "floor", "round"])
 def test_dt_ceil_year_floor(freq, method):
     ser = pd.Series(
diff --git a/pandas/tests/frame/methods/test_asfreq.py b/pandas/tests/frame/methods/test_asfreq.py
index a36f0d11fcfb4..2a17a09b6de62 100644
--- a/pandas/tests/frame/methods/test_asfreq.py
+++ b/pandas/tests/frame/methods/test_asfreq.py
@@ -74,7 +74,7 @@ def test_tz_aware_asfreq_smoke(self, tz, frame_or_series):
         obj = frame_or_series(np.random.randn(len(dr)), index=dr)
 
         # it works!
-        obj.asfreq("T")
+        obj.asfreq("min")
 
     def test_asfreq_normalize(self, frame_or_series):
         rng = date_range("1/1/2000 09:30", periods=20)
diff --git a/pandas/tests/frame/methods/test_equals.py b/pandas/tests/frame/methods/test_equals.py
index beec3e965d542..da6e9fbb89293 100644
--- a/pandas/tests/frame/methods/test_equals.py
+++ b/pandas/tests/frame/methods/test_equals.py
@@ -33,7 +33,7 @@ def test_equals(self):
         index = np.random.random(10)
         df1 = DataFrame(np.random.random(10), index=index, columns=["floats"])
         df1["text"] = "the sky is so blue. we could use more chocolate.".split()
-        df1["start"] = date_range("2000-1-1", periods=10, freq="T")
+        df1["start"] = date_range("2000-1-1", periods=10, freq="min")
         df1["end"] = date_range("2000-1-1", periods=10, freq="D")
         df1["diff"] = df1["end"] - df1["start"]
         # Explicitly cast to object, to avoid implicit cast when setting np.nan
@@ -64,7 +64,7 @@ def test_equals(self):
         assert not df1.equals(different)
 
         # DatetimeIndex
-        index = date_range("2000-1-1", periods=10, freq="T")
+        index = date_range("2000-1-1", periods=10, freq="min")
         df1 = df1.set_index(index)
         df2 = df1.copy()
         assert df1.equals(df2)
diff --git a/pandas/tests/frame/methods/test_join.py b/pandas/tests/frame/methods/test_join.py
index 98f3926968ad0..2d4ac1d4a4444 100644
--- a/pandas/tests/frame/methods/test_join.py
+++ b/pandas/tests/frame/methods/test_join.py
@@ -553,13 +553,13 @@ def test_frame_join_tzaware(self):
         test1 = DataFrame(
             np.zeros((6, 3)),
             index=date_range(
-                "2012-11-15 00:00:00", periods=6, freq="100L", tz="US/Central"
+                "2012-11-15 00:00:00", periods=6, freq="100ms", tz="US/Central"
             ),
         )
         test2 = DataFrame(
             np.zeros((3, 3)),
             index=date_range(
-                "2012-11-15 00:00:00", periods=3, freq="250L", tz="US/Central"
+                "2012-11-15 00:00:00", periods=3, freq="250ms", tz="US/Central"
             ),
             columns=range(3, 6),
         )
diff --git a/pandas/tests/frame/methods/test_shift.py b/pandas/tests/frame/methods/test_shift.py
index ebbb7ca13646f..c9db39a3d87a4 100644
--- a/pandas/tests/frame/methods/test_shift.py
+++ b/pandas/tests/frame/methods/test_shift.py
@@ -73,8 +73,8 @@ def test_shift_mismatched_freq(self, frame_or_series):
             np.random.randn(5), index=date_range("1/1/2000", periods=5, freq="H")
         )
 
-        result = ts.shift(1, freq="5T")
-        exp_index = ts.index.shift(1, freq="5T")
+        result = ts.shift(1, freq="5min")
+        exp_index = ts.index.shift(1, freq="5min")
         tm.assert_index_equal(result.index, exp_index)
 
         # GH#1063, multiple of same base
diff --git a/pandas/tests/frame/methods/test_to_timestamp.py b/pandas/tests/frame/methods/test_to_timestamp.py
index fea070a3c0b38..ee097885f4d28 100644
--- a/pandas/tests/frame/methods/test_to_timestamp.py
+++ b/pandas/tests/frame/methods/test_to_timestamp.py
@@ -99,7 +99,7 @@ def test_to_timestamp_columns(self):
         tm.assert_index_equal(result.columns, exp_index)
 
         delta = timedelta(hours=23, minutes=59)
-        result = df.to_timestamp("T", "end", axis=1)
+        result = df.to_timestamp("min", "end", axis=1)
         exp_index = _get_with_delta(delta)
         exp_index = exp_index + Timedelta(1, "m") - Timedelta(1, "ns")
         tm.assert_index_equal(result.columns, exp_index)
@@ -110,8 +110,8 @@ def test_to_timestamp_columns(self):
         exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
         tm.assert_index_equal(result.columns, exp_index)
 
-        result1 = df.to_timestamp("5t", axis=1)
-        result2 = df.to_timestamp("t", axis=1)
+        result1 = df.to_timestamp("5min", axis=1)
+        result2 = df.to_timestamp("min", axis=1)
         expected = date_range("2001-01-01", "2009-01-01", freq="AS")
         assert isinstance(result1.columns, DatetimeIndex)
         assert isinstance(result2.columns, DatetimeIndex)
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 3fbc6558b5c15..e4c2baaa54a48 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -2882,7 +2882,7 @@ def test_frame_datetime64_mixed_index_ctor_1681(self):
 
     def test_frame_timeseries_column(self):
         # GH19157
-        dr = date_range(start="20130101T10:00:00", periods=3, freq="T", tz="US/Eastern")
+        dr = date_range(start="20130101T10:00:00", periods=3, freq="min", tz="US/Eastern")
         result = DataFrame(dr, columns=["timestamps"])
         expected = DataFrame(
             {
diff --git a/pandas/tests/generic/test_frame.py b/pandas/tests/generic/test_frame.py
index 79f055909fdea..e0e5e0ad47e75 100644
--- a/pandas/tests/generic/test_frame.py
+++ b/pandas/tests/generic/test_frame.py
@@ -87,7 +87,7 @@ def test_metadata_propagation_indiv_resample(self):
             np.random.randn(1000, 2),
             index=date_range("20130101", periods=1000, freq="s"),
         )
-        result = df.resample("1T")
+        result = df.resample("1min")
         tm.assert_metadata_equivalent(df, result)
 
     def test_metadata_propagation_indiv(self, monkeypatch):
diff --git a/pandas/tests/generic/test_series.py b/pandas/tests/generic/test_series.py
index ee0a7fb77f336..2e255705333b4 100644
--- a/pandas/tests/generic/test_series.py
+++ b/pandas/tests/generic/test_series.py
@@ -111,13 +111,13 @@ def test_metadata_propagation_indiv_resample(self):
             index=date_range("20130101", periods=1000, freq="s"),
             name="foo",
         )
-        result = ts.resample("1T").mean()
+        result = ts.resample("1min").mean()
         tm.assert_metadata_equivalent(ts, result)
 
-        result = ts.resample("1T").min()
+        result = ts.resample("1min").min()
         tm.assert_metadata_equivalent(ts, result)
 
-        result = ts.resample("1T").apply(lambda x: x.sum())
+        result = ts.resample("1min").apply(lambda x: x.sum())
         tm.assert_metadata_equivalent(ts, result)
 
     def test_metadata_propagation_indiv(self, monkeypatch):
diff --git a/pandas/tests/groupby/aggregate/test_aggregate.py b/pandas/tests/groupby/aggregate/test_aggregate.py
index 2875e1ae80501..34d9a1d883685 100644
--- a/pandas/tests/groupby/aggregate/test_aggregate.py
+++ b/pandas/tests/groupby/aggregate/test_aggregate.py
@@ -363,13 +363,13 @@ def test_agg_multiple_functions_same_name():
         index=pd.date_range("1/1/2012", freq="S", periods=1000),
         columns=["A", "B", "C"],
     )
-    result = df.resample("3T").agg(
+    result = df.resample("3min").agg(
         {"A": [partial(np.quantile, q=0.9999), partial(np.quantile, q=0.1111)]}
     )
-    expected_index = pd.date_range("1/1/2012", freq="3T", periods=6)
+    expected_index = pd.date_range("1/1/2012", freq="3min", periods=6)
     expected_columns = MultiIndex.from_tuples([("A", "quantile"), ("A", "quantile")])
     expected_values = np.array(
-        [df.resample("3T").A.quantile(q=q).values for q in [0.9999, 0.1111]]
+        [df.resample("3min").A.quantile(q=q).values for q in [0.9999, 0.1111]]
     ).T
     expected = DataFrame(
         expected_values, columns=expected_columns, index=expected_index
@@ -385,10 +385,10 @@ def test_agg_multiple_functions_same_name_with_ohlc_present():
         index=pd.date_range("1/1/2012", freq="S", periods=1000, name="dti"),
         columns=Index(["A", "B", "C"], name="alpha"),
     )
-    result = df.resample("3T").agg(
+    result = df.resample("3min").agg(
         {"A": ["ohlc", partial(np.quantile, q=0.9999), partial(np.quantile, q=0.1111)]}
     )
-    expected_index = pd.date_range("1/1/2012", freq="3T", periods=6, name="dti")
+    expected_index = pd.date_range("1/1/2012", freq="3min", periods=6, name="dti")
     expected_columns = MultiIndex.from_tuples(
         [
             ("A", "ohlc", "open"),
@@ -401,9 +401,9 @@ def test_agg_multiple_functions_same_name_with_ohlc_present():
         names=["alpha", None, None],
     )
     non_ohlc_expected_values = np.array(
-        [df.resample("3T").A.quantile(q=q).values for q in [0.9999, 0.1111]]
+        [df.resample("3min").A.quantile(q=q).values for q in [0.9999, 0.1111]]
     ).T
-    expected_values = np.hstack([df.resample("3T").A.ohlc(), non_ohlc_expected_values])
+    expected_values = np.hstack([df.resample("3min").A.ohlc(), non_ohlc_expected_values])
     expected = DataFrame(
         expected_values, columns=expected_columns, index=expected_index
     )
diff --git a/pandas/tests/groupby/aggregate/test_cython.py b/pandas/tests/groupby/aggregate/test_cython.py
index 873e3e73c7cf5..26e59c17246f5 100644
--- a/pandas/tests/groupby/aggregate/test_cython.py
+++ b/pandas/tests/groupby/aggregate/test_cython.py
@@ -114,7 +114,7 @@ def test_cython_agg_nothing_to_agg_with_dates():
         {
             "a": np.random.randint(0, 5, 50),
             "b": ["foo", "bar"] * 25,
-            "dates": pd.date_range("now", periods=50, freq="T"),
+            "dates": pd.date_range("now", periods=50, freq="min"),
         }
     )
     msg = "Cannot use numeric_only=True with SeriesGroupBy.mean and non-numeric dtypes"
diff --git a/pandas/tests/groupby/test_categorical.py b/pandas/tests/groupby/test_categorical.py
index 3ab62bb7656b7..9c33518a33a2f 100644
--- a/pandas/tests/groupby/test_categorical.py
+++ b/pandas/tests/groupby/test_categorical.py
@@ -1137,7 +1137,7 @@ def test_groupby_multiindex_categorical_datetime():
         {
             "key1": Categorical(list("abcbabcba")),
             "key2": Categorical(
-                list(pd.date_range("2018-06-01 00", freq="1T", periods=3)) * 3
+                list(pd.date_range("2018-06-01 00", freq="1min", periods=3)) * 3
             ),
             "values": np.arange(9),
         }
@@ -1147,7 +1147,7 @@ def test_groupby_multiindex_categorical_datetime():
     idx = MultiIndex.from_product(
         [
             Categorical(["a", "b", "c"]),
-            Categorical(pd.date_range("2018-06-01 00", freq="1T", periods=3)),
+            Categorical(pd.date_range("2018-06-01 00", freq="1min", periods=3)),
         ],
         names=["key1", "key2"],
     )
diff --git a/pandas/tests/groupby/test_counting.py b/pandas/tests/groupby/test_counting.py
index 97e4e8a852429..c97d352c5b75e 100644
--- a/pandas/tests/groupby/test_counting.py
+++ b/pandas/tests/groupby/test_counting.py
@@ -266,7 +266,7 @@ def test_groupby_timedelta_cython_count():
 
 def test_count():
     n = 1 << 15
-    dr = date_range("2015-08-30", periods=n // 10, freq="T")
+    dr = date_range("2015-08-30", periods=n // 10, freq="min")
 
     df = DataFrame(
         {
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index ca3fec8a99555..4070fefbefc95 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -3110,12 +3110,12 @@ def test_groupby_with_Time_Grouper():
 
     expected_output = DataFrame(
         {
-            "time2": date_range("2016-08-31 22:08:00", periods=13, freq="1T"),
+            "time2": date_range("2016-08-31 22:08:00", periods=13, freq="1min"),
             "quant": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
             "quant2": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
         }
     )
 
-    df = test_data.groupby(Grouper(key="time2", freq="1T")).count().reset_index()
+    df = test_data.groupby(Grouper(key="time2", freq="1min")).count().reset_index()
 
     tm.assert_frame_equal(df, expected_output)
diff --git a/pandas/tests/groupby/test_quantile.py b/pandas/tests/groupby/test_quantile.py
index 7bf168944a1ac..85f3ddb152874 100644
--- a/pandas/tests/groupby/test_quantile.py
+++ b/pandas/tests/groupby/test_quantile.py
@@ -420,7 +420,7 @@ def test_timestamp_groupby_quantile():
     df = DataFrame(
         {
             "timestamp": pd.date_range(
-                start="2020-04-19 00:00:00", freq="1T", periods=100, tz="UTC"
+                start="2020-04-19 00:00:00", freq="1min", periods=100, tz="UTC"
             ).floor("1H"),
             "category": list(range(1, 101)),
             "value": list(range(101, 201)),
diff --git a/pandas/tests/groupby/test_timegrouper.py b/pandas/tests/groupby/test_timegrouper.py
index 60c35064d9aa7..fd3c98251bcb4 100644
--- a/pandas/tests/groupby/test_timegrouper.py
+++ b/pandas/tests/groupby/test_timegrouper.py
@@ -755,7 +755,7 @@ def test_timezone_info(self):
 
     def test_datetime_count(self):
         df = DataFrame(
-            {"a": [1, 2, 3] * 2, "dates": date_range("now", periods=6, freq="T")}
+            {"a": [1, 2, 3] * 2, "dates": date_range("now", periods=6, freq="min")}
         )
         result = df.groupby("a").dates.count()
         expected = Series([2, 2, 2], index=Index([1, 2, 3], name="a"), name="dates")
diff --git a/pandas/tests/indexes/conftest.py b/pandas/tests/indexes/conftest.py
index 458a37c994091..683efa013e0b6 100644
--- a/pandas/tests/indexes/conftest.py
+++ b/pandas/tests/indexes/conftest.py
@@ -25,7 +25,7 @@ def sort(request):
     return request.param
 
 
-@pytest.fixture(params=["D", "3D", "-3D", "H", "2H", "-2H", "T", "2T", "S", "-3S"])
+@pytest.fixture(params=["D", "3D", "-3D", "H", "2H", "-2H", "min", "2min", "S", "-3S"])
 def freq_sample(request):
     """
     Valid values for 'freq' parameter used to create date_range and
diff --git a/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py b/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py
index e5da06cb005f6..f2cd7b48680e3 100644
--- a/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py
+++ b/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py
@@ -14,6 +14,7 @@
 class DropDuplicates:
     def test_drop_duplicates_metadata(self, idx):
         # GH#10115
+        print("11111111  = ", idx)
         result = idx.drop_duplicates()
         tm.assert_index_equal(idx, result)
         assert idx.freq == result.freq
diff --git a/pandas/tests/indexes/datetimes/methods/test_shift.py b/pandas/tests/indexes/datetimes/methods/test_shift.py
index 65bdfc9053e5e..e8661fafc3bb7 100644
--- a/pandas/tests/indexes/datetimes/methods/test_shift.py
+++ b/pandas/tests/indexes/datetimes/methods/test_shift.py
@@ -96,7 +96,7 @@ def test_dti_shift_localized(self, tzstr):
         dr = date_range("2011/1/1", "2012/1/1", freq="W-FRI")
         dr_tz = dr.tz_localize(tzstr)
 
-        result = dr_tz.shift(1, "10T")
+        result = dr_tz.shift(1, "10min")
         assert result.tz == dr_tz.tz
 
     def test_dti_shift_across_dst(self):
diff --git a/pandas/tests/indexes/datetimes/methods/test_to_period.py b/pandas/tests/indexes/datetimes/methods/test_to_period.py
index 6c41b76aa113c..b9bf1783fdb39 100644
--- a/pandas/tests/indexes/datetimes/methods/test_to_period.py
+++ b/pandas/tests/indexes/datetimes/methods/test_to_period.py
@@ -126,10 +126,10 @@ def test_to_period_millisecond(self):
 
         with tm.assert_produces_warning(UserWarning):
             # warning that timezone info will be lost
-            period = index.to_period(freq="L")
+            period = index.to_period(freq="ms")
         assert 2 == len(period)
-        assert period[0] == Period("2007-01-01 10:11:12.123Z", "L")
-        assert period[1] == Period("2007-01-01 10:11:13.789Z", "L")
+        assert period[0] == Period("2007-01-01 10:11:12.123Z", "ms")
+        assert period[1] == Period("2007-01-01 10:11:13.789Z", "ms")
 
     def test_to_period_microsecond(self):
         index = DatetimeIndex(
diff --git a/pandas/tests/indexes/datetimes/test_constructors.py b/pandas/tests/indexes/datetimes/test_constructors.py
index 6d18a292061b9..f384281a14b1b 100644
--- a/pandas/tests/indexes/datetimes/test_constructors.py
+++ b/pandas/tests/indexes/datetimes/test_constructors.py
@@ -1034,7 +1034,7 @@ def test_constructor_int64_nocopy(self):
         assert (index.asi8[50:100] != -1).all()
 
     @pytest.mark.parametrize(
-        "freq", ["M", "Q", "A", "D", "B", "BH", "T", "S", "L", "U", "H", "N", "C"]
+        "freq", ["M", "Q", "A", "D", "B", "BH", "min", "S", "ms", "U", "H", "N", "C"]
     )
     def test_from_freq_recreate_from_data(self, freq):
         org = date_range(start="2001/02/01 09:00", freq=freq, periods=1)
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index 2e2e33e2fb366..0882e4696b62e 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -123,7 +123,7 @@ def test_date_range_timestamp_equiv_preserve_frequency(self):
 
 
 class TestDateRanges:
-    @pytest.mark.parametrize("freq", ["N", "U", "L", "T", "S", "H", "D"])
+    @pytest.mark.parametrize("freq", ["N", "U", "ms", "min", "S", "H", "D"])
     def test_date_range_edges(self, freq):
         # GH#13672
         td = Timedelta(f"1{freq}")
@@ -761,13 +761,13 @@ def test_freq_divides_end_in_nanos(self):
         expected_1 = DatetimeIndex(
             ["2005-01-12 10:00:00", "2005-01-12 15:45:00"],
             dtype="datetime64[ns]",
-            freq="345T",
+            freq="345min",
             tz=None,
         )
         expected_2 = DatetimeIndex(
             ["2005-01-13 10:00:00", "2005-01-13 15:45:00"],
             dtype="datetime64[ns]",
-            freq="345T",
+            freq="345min",
             tz=None,
         )
         tm.assert_index_equal(result_1, expected_1)
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index d6ef4198fad2e..5375f22ca6338 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -25,9 +25,9 @@ class TestDatetimeIndexOps:
             ("M", "day"),
             ("D", "day"),
             ("H", "hour"),
-            ("T", "minute"),
+            ("min", "minute"),
             ("S", "second"),
-            ("L", "millisecond"),
+            ("ms", "millisecond"),
             ("U", "microsecond"),
         ],
     )
diff --git a/pandas/tests/indexes/datetimes/test_partial_slicing.py b/pandas/tests/indexes/datetimes/test_partial_slicing.py
index 28c9c07a9c9ef..a84dc95d15307 100644
--- a/pandas/tests/indexes/datetimes/test_partial_slicing.py
+++ b/pandas/tests/indexes/datetimes/test_partial_slicing.py
@@ -201,7 +201,7 @@ def test_partial_slice_daily(self):
             s["2004-12-31 00"]
 
     def test_partial_slice_hourly(self):
-        rng = date_range(freq="T", start=datetime(2005, 1, 1, 20, 0, 0), periods=500)
+        rng = date_range(freq="min", start=datetime(2005, 1, 1, 20, 0, 0), periods=500)
         s = Series(np.arange(len(rng)), index=rng)
 
         result = s["2005-1-1"]
@@ -333,7 +333,7 @@ def test_partial_slicing_with_multiindex(self):
                 "TICKER": ["ABC", "MNP", "XYZ", "XYZ"],
                 "val": [1, 2, 3, 4],
             },
-            index=date_range("2013-06-19 09:30:00", periods=4, freq="5T"),
+            index=date_range("2013-06-19 09:30:00", periods=4, freq="5min"),
         )
         df_multi = df.set_index(["ACCOUNT", "TICKER"], append=True)
 
diff --git a/pandas/tests/indexes/datetimes/test_scalar_compat.py b/pandas/tests/indexes/datetimes/test_scalar_compat.py
index f07a9dce5f6ae..a7af91925a4dc 100644
--- a/pandas/tests/indexes/datetimes/test_scalar_compat.py
+++ b/pandas/tests/indexes/datetimes/test_scalar_compat.py
@@ -175,7 +175,7 @@ def test_no_rounding_occurs(self, tz_naive_fixture):
             ]
         )
 
-        tm.assert_index_equal(rng.round(freq="2T"), expected_rng)
+        tm.assert_index_equal(rng.round(freq="2min"), expected_rng)
 
     @pytest.mark.parametrize(
         "test_input, rounder, freq, expected",
@@ -196,8 +196,8 @@ def test_no_rounding_occurs(self, tz_naive_fixture):
             ),
             (["1823-01-01 00:00:01"], "floor", "1s", ["1823-01-01 00:00:01"]),
             (["1823-01-01 00:00:01"], "ceil", "1s", ["1823-01-01 00:00:01"]),
-            (["2018-01-01 00:15:00"], "ceil", "15T", ["2018-01-01 00:15:00"]),
-            (["2018-01-01 00:15:00"], "floor", "15T", ["2018-01-01 00:15:00"]),
+            (["2018-01-01 00:15:00"], "ceil", "15min", ["2018-01-01 00:15:00"]),
+            (["2018-01-01 00:15:00"], "floor", "15min", ["2018-01-01 00:15:00"]),
             (["1823-01-01 03:00:00"], "ceil", "3H", ["1823-01-01 03:00:00"]),
             (["1823-01-01 03:00:00"], "floor", "3H", ["1823-01-01 03:00:00"]),
             (
@@ -333,7 +333,7 @@ def test_hour(self):
         tm.assert_index_equal(r1, r2)
 
     def test_minute(self):
-        dr = date_range(start=Timestamp("2000-02-27"), periods=5, freq="T")
+        dr = date_range(start=Timestamp("2000-02-27"), periods=5, freq="min")
         r1 = pd.Index([x.to_julian_date() for x in dr])
         r2 = dr.to_julian_date()
         assert isinstance(r2, pd.Index) and r2.dtype == np.float64
diff --git a/pandas/tests/indexes/datetimes/test_setops.py b/pandas/tests/indexes/datetimes/test_setops.py
index 124eb29b7789e..56d926f059acb 100644
--- a/pandas/tests/indexes/datetimes/test_setops.py
+++ b/pandas/tests/indexes/datetimes/test_setops.py
@@ -269,7 +269,7 @@ def test_intersection(self, tz, sort):
 
     # parametrize over both anchored and non-anchored freqs, as they
     #  have different code paths
-    @pytest.mark.parametrize("freq", ["T", "B"])
+    @pytest.mark.parametrize("freq", ["min", "B"])
     def test_intersection_empty(self, tz_aware_fixture, freq):
         # empty same freq GH2129
         tz = tz_aware_fixture
@@ -283,7 +283,7 @@ def test_intersection_empty(self, tz_aware_fixture, freq):
         assert result.freq == rng.freq
 
         # no overlap GH#33604
-        check_freq = freq != "T"  # We don't preserve freq on non-anchored offsets
+        check_freq = freq != "min"  # We don't preserve freq on non-anchored offsets
         result = rng[:3].intersection(rng[-3:])
         tm.assert_index_equal(result, rng[:0])
         if check_freq:
diff --git a/pandas/tests/indexes/datetimes/test_timezones.py b/pandas/tests/indexes/datetimes/test_timezones.py
index 6f3c83b999e94..05a69fb2a25e2 100644
--- a/pandas/tests/indexes/datetimes/test_timezones.py
+++ b/pandas/tests/indexes/datetimes/test_timezones.py
@@ -192,7 +192,7 @@ def test_dti_tz_convert_hour_overflow_dst_timestamps(self, tz):
         expected = Index([9, 9, 9], dtype=np.int32)
         tm.assert_index_equal(ut.hour, expected)
 
-    @pytest.mark.parametrize("freq, n", [("H", 1), ("T", 60), ("S", 3600)])
+    @pytest.mark.parametrize("freq, n", [("H", 1), ("min", 60), ("S", 3600)])
     def test_dti_tz_convert_trans_pos_plus_1__bug(self, freq, n):
         # Regression test for tslib.tz_convert(vals, tz1, tz2).
         # See https://github.com/pandas-dev/pandas/issues/4496 for details.
@@ -204,7 +204,7 @@ def test_dti_tz_convert_trans_pos_plus_1__bug(self, freq, n):
         tm.assert_index_equal(idx.hour, Index(expected, dtype=np.int32))
 
     def test_dti_tz_convert_dst(self):
-        for freq, n in [("H", 1), ("T", 60), ("S", 3600)]:
+        for freq, n in [("H", 1), ("min", 60), ("S", 3600)]:
             # Start DST
             idx = date_range(
                 "2014-03-08 23:00", "2014-03-09 09:00", freq=freq, tz="UTC"
@@ -281,8 +281,8 @@ def test_tz_convert_roundtrip(self, tz_aware_fixture):
         idx3 = date_range(start="2014-01-01", end="2014-03-01", freq="H", tz="UTC")
         exp3 = date_range(start="2014-01-01", end="2014-03-01", freq="H")
 
-        idx4 = date_range(start="2014-08-01", end="2014-10-31", freq="T", tz="UTC")
-        exp4 = date_range(start="2014-08-01", end="2014-10-31", freq="T")
+        idx4 = date_range(start="2014-08-01", end="2014-10-31", freq="min", tz="UTC")
+        exp4 = date_range(start="2014-08-01", end="2014-10-31", freq="min")
 
         for idx, expected in [(idx1, exp1), (idx2, exp2), (idx3, exp3), (idx4, exp4)]:
             converted = idx.tz_convert(tz)
@@ -440,11 +440,11 @@ def test_dti_tz_localize_pass_dates_to_utc(self, tzstr):
     @pytest.mark.parametrize("prefix", ["", "dateutil/"])
     def test_dti_tz_localize(self, prefix):
         tzstr = prefix + "US/Eastern"
-        dti = date_range(start="1/1/2005", end="1/1/2005 0:00:30.256", freq="L")
+        dti = date_range(start="1/1/2005", end="1/1/2005 0:00:30.256", freq="ms")
         dti2 = dti.tz_localize(tzstr)
 
         dti_utc = date_range(
-            start="1/1/2005 05:00", end="1/1/2005 5:00:30.256", freq="L", tz="utc"
+            start="1/1/2005 05:00", end="1/1/2005 5:00:30.256", freq="ms", tz="utc"
         )
 
         tm.assert_numpy_array_equal(dti2.values, dti_utc.values)
@@ -452,11 +452,11 @@ def test_dti_tz_localize(self, prefix):
         dti3 = dti2.tz_convert(prefix + "US/Pacific")
         tm.assert_numpy_array_equal(dti3.values, dti_utc.values)
 
-        dti = date_range(start="11/6/2011 1:59", end="11/6/2011 2:00", freq="L")
+        dti = date_range(start="11/6/2011 1:59", end="11/6/2011 2:00", freq="ms")
         with pytest.raises(pytz.AmbiguousTimeError, match="Cannot infer dst time"):
             dti.tz_localize(tzstr)
 
-        dti = date_range(start="3/13/2011 1:59", end="3/13/2011 2:00", freq="L")
+        dti = date_range(start="3/13/2011 1:59", end="3/13/2011 2:00", freq="ms")
         with pytest.raises(pytz.NonExistentTimeError, match="2011-03-13 02:00:00"):
             dti.tz_localize(tzstr)
 
@@ -474,14 +474,14 @@ def test_dti_tz_localize_utc_conversion(self, tz):
         #  1) check for DST ambiguities
         #  2) convert to UTC
 
-        rng = date_range("3/10/2012", "3/11/2012", freq="30T")
+        rng = date_range("3/10/2012", "3/11/2012", freq="30min")
 
         converted = rng.tz_localize(tz)
         expected_naive = rng + pd.offsets.Hour(5)
         tm.assert_numpy_array_equal(converted.asi8, expected_naive.asi8)
 
         # DST ambiguity, this should fail
-        rng = date_range("3/11/2012", "3/12/2012", freq="30T")
+        rng = date_range("3/11/2012", "3/12/2012", freq="30min")
         # Is this really how it should fail??
         with pytest.raises(pytz.NonExistentTimeError, match="2012-03-11 02:00:00"):
             rng.tz_localize(tz)
@@ -490,7 +490,7 @@ def test_dti_tz_localize_roundtrip(self, tz_aware_fixture):
         # note: this tz tests that a tz-naive index can be localized
         # and de-localized successfully, when there are no DST transitions
         # in the range.
-        idx = date_range(start="2014-06-01", end="2014-08-30", freq="15T")
+        idx = date_range(start="2014-06-01", end="2014-08-30", freq="15min")
         tz = tz_aware_fixture
         localized = idx.tz_localize(tz)
         # can't localize a tz-aware object
@@ -879,7 +879,7 @@ def test_dti_tz_conversion_freq(self, tz_naive_fixture):
         # GH25241
         t3 = DatetimeIndex(["2019-01-01 10:00"], freq="H")
         assert t3.tz_localize(tz=tz_naive_fixture).freq == t3.freq
-        t4 = DatetimeIndex(["2019-01-02 12:00"], tz="UTC", freq="T")
+        t4 = DatetimeIndex(["2019-01-02 12:00"], tz="UTC", freq="min")
         assert t4.tz_convert(tz="UTC").freq == t4.freq
 
     def test_drop_dst_boundary(self):
diff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py
index 5593ed018eb0f..5c558f12dbc1c 100644
--- a/pandas/tests/indexes/period/test_constructors.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -401,7 +401,7 @@ def test_constructor_freq_mult(self):
         with pytest.raises(ValueError, match=msg):
             period_range("2011-01", periods=3, freq="0M")
 
-    @pytest.mark.parametrize("freq", ["A", "M", "D", "T", "S"])
+    @pytest.mark.parametrize("freq", ["A", "M", "D", "min", "S"])
     @pytest.mark.parametrize("mult", [1, 2, 3, 4, 5])
     def test_constructor_freq_mult_dti_compat(self, mult, freq):
         freqstr = str(mult) + freq
@@ -489,7 +489,7 @@ def test_constructor(self):
             Period("2006-12-31", ("w", 1))
 
     @pytest.mark.parametrize(
-        "freq", ["M", "Q", "A", "D", "B", "T", "S", "L", "U", "N", "H"]
+        "freq", ["M", "Q", "A", "D", "B", "min", "S", "ms", "U", "N", "H"]
     )
     def test_recreate_from_data(self, freq):
         org = period_range(start="2001/04/01", freq=freq, periods=1)
diff --git a/pandas/tests/indexes/period/test_resolution.py b/pandas/tests/indexes/period/test_resolution.py
index 9ea7c1cdb39f3..e700d27d4a80e 100644
--- a/pandas/tests/indexes/period/test_resolution.py
+++ b/pandas/tests/indexes/period/test_resolution.py
@@ -13,19 +13,12 @@ class TestResolution:
             ("M", "month"),
             ("D", "day"),
             ("H", "hour"),
-            ("T", "minute"),
+            ("min", "minute"),
             ("S", "second"),
-            ("L", "millisecond"),
+            ("ms", "millisecond"),
             ("U", "microsecond"),
         ],
     )
     def test_resolution(self, freq, expected):
-        msg = f"Code freq={freq} is deprecated and will be removed in a future version."
-
-        if freq in {"T", "L"}:
-            with tm.assert_produces_warning(FutureWarning, match=msg):
-                idx = pd.period_range(start="2013-04-01", periods=30, freq=freq)
-                assert idx.resolution == expected
-        else:
-            idx = pd.period_range(start="2013-04-01", periods=30, freq=freq)
-            assert idx.resolution == expected
+        idx = pd.period_range(start="2013-04-01", periods=30, freq=freq)
+        assert idx.resolution == expected
diff --git a/pandas/tests/indexes/period/test_setops.py b/pandas/tests/indexes/period/test_setops.py
index 22182416c79fd..f5727ce80d6ef 100644
--- a/pandas/tests/indexes/period/test_setops.py
+++ b/pandas/tests/indexes/period/test_setops.py
@@ -61,10 +61,10 @@ def test_union(self, sort):
         )
 
         rng5 = PeriodIndex(
-            ["2000-01-01 09:01", "2000-01-01 09:03", "2000-01-01 09:05"], freq="T"
+            ["2000-01-01 09:01", "2000-01-01 09:03", "2000-01-01 09:05"], freq="min"
         )
         other5 = PeriodIndex(
-            ["2000-01-01 09:01", "2000-01-01 09:05", "2000-01-01 09:08"], freq="T"
+            ["2000-01-01 09:01", "2000-01-01 09:05", "2000-01-01 09:08"], freq="min"
         )
         expected5 = PeriodIndex(
             [
@@ -73,7 +73,7 @@ def test_union(self, sort):
                 "2000-01-01 09:05",
                 "2000-01-01 09:08",
             ],
-            freq="T",
+            freq="min",
         )
 
         rng6 = period_range("2000-01-01", freq="M", periods=7)
@@ -239,7 +239,7 @@ def test_intersection_cases(self, sort):
             assert result.freq == "D"
 
         # empty same freq
-        rng = date_range("6/1/2000", "6/15/2000", freq="T")
+        rng = date_range("6/1/2000", "6/15/2000", freq="min")
         result = rng[0:0].intersection(rng)
         assert len(result) == 0
 
@@ -273,10 +273,10 @@ def test_difference(self, sort):
         expected4 = rng4
 
         rng5 = PeriodIndex(
-            ["2000-01-01 09:03", "2000-01-01 09:01", "2000-01-01 09:05"], freq="T"
+            ["2000-01-01 09:03", "2000-01-01 09:01", "2000-01-01 09:05"], freq="min"
         )
-        other5 = PeriodIndex(["2000-01-01 09:01", "2000-01-01 09:05"], freq="T")
-        expected5 = PeriodIndex(["2000-01-01 09:03"], freq="T")
+        other5 = PeriodIndex(["2000-01-01 09:01", "2000-01-01 09:05"], freq="min")
+        expected5 = PeriodIndex(["2000-01-01 09:03"], freq="min")
 
         period_rng = [
             "2000-02-01",
diff --git a/pandas/tests/indexes/period/test_tools.py b/pandas/tests/indexes/period/test_tools.py
index 41b76d6aced23..9ab49df3b5d9d 100644
--- a/pandas/tests/indexes/period/test_tools.py
+++ b/pandas/tests/indexes/period/test_tools.py
@@ -21,9 +21,9 @@ class TestPeriodRepresentation:
             ("D", "1970-01-01"),
             ("B", "1970-01-01"),
             ("H", "1970-01-01"),
-            ("T", "1970-01-01"),
+            ("min", "1970-01-01"),
             ("S", "1970-01-01"),
-            ("L", "1970-01-01"),
+            ("ms", "1970-01-01"),
             ("U", "1970-01-01"),
             ("N", "1970-01-01"),
             ("M", "1970-01"),
diff --git a/pandas/tests/indexes/timedeltas/methods/test_shift.py b/pandas/tests/indexes/timedeltas/methods/test_shift.py
index f49af73f9f499..e33b8de3e6594 100644
--- a/pandas/tests/indexes/timedeltas/methods/test_shift.py
+++ b/pandas/tests/indexes/timedeltas/methods/test_shift.py
@@ -29,11 +29,11 @@ def test_tdi_shift_hours(self):
     def test_tdi_shift_minutes(self):
         # GH#9903
         idx = TimedeltaIndex(["5 hours", "6 hours", "9 hours"], name="xxx")
-        tm.assert_index_equal(idx.shift(0, freq="T"), idx)
+        tm.assert_index_equal(idx.shift(0, freq="min"), idx)
         exp = TimedeltaIndex(["05:03:00", "06:03:00", "9:03:00"], name="xxx")
-        tm.assert_index_equal(idx.shift(3, freq="T"), exp)
+        tm.assert_index_equal(idx.shift(3, freq="min"), exp)
         exp = TimedeltaIndex(["04:57:00", "05:57:00", "8:57:00"], name="xxx")
-        tm.assert_index_equal(idx.shift(-3, freq="T"), exp)
+        tm.assert_index_equal(idx.shift(-3, freq="min"), exp)
 
     def test_tdi_shift_int(self):
         # GH#8083
diff --git a/pandas/tests/indexes/timedeltas/test_scalar_compat.py b/pandas/tests/indexes/timedeltas/test_scalar_compat.py
index 9f470b40d1f58..7bb6f12acd67d 100644
--- a/pandas/tests/indexes/timedeltas/test_scalar_compat.py
+++ b/pandas/tests/indexes/timedeltas/test_scalar_compat.py
@@ -107,7 +107,7 @@ def test_round(self):
             ("N", t1, t2),
             ("U", t1, t2),
             (
-                "L",
+                "ms",
                 t1a,
                 TimedeltaIndex(
                     ["-1 days +00:00:00", "-2 days +23:58:58", "-2 days +23:57:56"]
@@ -120,7 +120,7 @@ def test_round(self):
                     ["-1 days +00:00:00", "-2 days +23:58:58", "-2 days +23:57:56"]
                 ),
             ),
-            ("12T", t1c, TimedeltaIndex(["-1 days", "-1 days", "-1 days"])),
+            ("12min", t1c, TimedeltaIndex(["-1 days", "-1 days", "-1 days"])),
             ("H", t1c, TimedeltaIndex(["-1 days", "-1 days", "-1 days"])),
             ("d", t1c, TimedeltaIndex([-1, -1, -1], unit="D")),
         ]:
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta_range.py b/pandas/tests/indexes/timedeltas/test_timedelta_range.py
index 72bdc6da47d94..8cc2baaba044d 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta_range.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta_range.py
@@ -51,7 +51,7 @@ def test_timedelta_range(self):
             ("l", "millisecond"),
         ],
     )
-    def test_timedelta_units_T_L_deprecated(self, depr_unit, unit):
+    def test_timedelta_units_t_l_deprecated(self, depr_unit, unit):
         depr_msg = f"Unit '{depr_unit}' is deprecated."
 
         expected = to_timedelta(np.arange(5), unit=unit)
@@ -60,7 +60,7 @@ def test_timedelta_units_T_L_deprecated(self, depr_unit, unit):
             tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
-        "periods, freq", [(3, "2D"), (5, "D"), (6, "19H12T"), (7, "16H"), (9, "12H")]
+        "periods, freq", [(3, "2D"), (5, "D"), (6, "19H12min"), (7, "16H"), (9, "12H")]
     )
     def test_linspace_behavior(self, periods, freq):
         # GH 20976
diff --git a/pandas/tests/resample/test_base.py b/pandas/tests/resample/test_base.py
index e57d938f060df..6c8722e31a930 100644
--- a/pandas/tests/resample/test_base.py
+++ b/pandas/tests/resample/test_base.py
@@ -82,8 +82,8 @@ def test_asfreq_fill_value(series, create_index):
 def test_resample_interpolate(frame):
     # GH#12925
     df = frame
-    result = df.resample("1T").asfreq().interpolate()
-    expected = df.resample("1T").interpolate()
+    result = df.resample("1min").asfreq().interpolate()
+    expected = df.resample("1min").interpolate()
     tm.assert_frame_equal(result, expected)
 
 
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index 38d7593a862ad..827d6278d2b93 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -492,7 +492,7 @@ def test_resample_tz_localized(self):
 
         # #2245
         idx = date_range(
-            "2001-09-20 15:59", "2001-09-20 16:00", freq="T", tz="Australia/Sydney"
+            "2001-09-20 15:59", "2001-09-20 16:00", freq="min", tz="Australia/Sydney"
         )
         s = Series([1, 2], index=idx)
 

From 93bbd08f1f1e157ec1120a1ed7c7b700c08b72d3 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Fri, 21 Jul 2023 10:42:51 +0200
Subject: [PATCH 06/31] correct def resolution_string, get_reso_from_freqstr
 and fix tests

---
 pandas/_libs/tslibs/dtypes.pyx             | 2 +-
 pandas/_libs/tslibs/timedeltas.pyx         | 4 ++--
 pandas/tests/resample/test_resample_api.py | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/pandas/_libs/tslibs/dtypes.pyx b/pandas/_libs/tslibs/dtypes.pyx
index 7b27810e56c69..f9559249a084d 100644
--- a/pandas/_libs/tslibs/dtypes.pyx
+++ b/pandas/_libs/tslibs/dtypes.pyx
@@ -276,7 +276,6 @@ class Resolution(Enum):
         True
         """
         try:
-            attr_name = _abbrev_to_attrnames[freq]
             if freq in {"T", "L"}:
                 warnings.warn(
                     f"Code freq={freq} is deprecated "
@@ -285,6 +284,7 @@ class Resolution(Enum):
                     stacklevel=find_stack_level(),
                 )
                 freq = freq.replace("T", "min").replace("L", "ms")
+            attr_name = _abbrev_to_attrnames[freq]
         except KeyError:
             # For quarterly and yearly resolutions, we need to chop off
             #  a month string.
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 28aeb854638b6..c00865270f6fb 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1470,11 +1470,11 @@ cdef class _Timedelta(timedelta):
         elif self._us:
             return "U"
         elif self._ms:
-            return "L"
+            return "ms"
         elif self._s:
             return "S"
         elif self._m:
-            return "T"
+            return "min"
         elif self._h:
             return "H"
         else:
diff --git a/pandas/tests/resample/test_resample_api.py b/pandas/tests/resample/test_resample_api.py
index 6aa59d8b3d164..9f4bb8160ad13 100644
--- a/pandas/tests/resample/test_resample_api.py
+++ b/pandas/tests/resample/test_resample_api.py
@@ -346,7 +346,7 @@ def test_agg_consistency():
         columns=["A", "B", "C"],
     )
 
-    r = df.resample("3T")
+    r = df.resample("3min")
 
     msg = r"Column\(s\) \['r1', 'r2'\] do not exist"
     with pytest.raises(KeyError, match=msg):
@@ -361,7 +361,7 @@ def test_agg_consistency_int_str_column_mix():
         columns=[1, "a"],
     )
 
-    r = df.resample("3T")
+    r = df.resample("3min")
 
     msg = r"Column\(s\) \[2, 'b'\] do not exist"
     with pytest.raises(KeyError, match=msg):
@@ -643,7 +643,7 @@ def test_try_aggregate_non_existing_column():
     # Error as we don't have 'z' column
     msg = r"Column\(s\) \['z'\] do not exist"
     with pytest.raises(KeyError, match=msg):
-        df.resample("30T").agg({"x": ["mean"], "y": ["median"], "z": ["sum"]})
+        df.resample("30min").agg({"x": ["mean"], "y": ["median"], "z": ["sum"]})
 
 
 def test_agg_list_like_func_with_args():

From 51c62a1744dd589cf731c9fc2dd3b09ecd7bf12b Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Fri, 21 Jul 2023 11:00:43 +0200
Subject: [PATCH 07/31] fix tests

---
 pandas/tests/resample/test_period_index.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index 827d6278d2b93..ec4ef39b95a78 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -316,7 +316,7 @@ def test_with_local_timezone_dateutil(self):
 
     def test_resample_nonexistent_time_bin_edge(self):
         # GH 19375
-        index = date_range("2017-03-12", "2017-03-12 1:45:00", freq="15T")
+        index = date_range("2017-03-12", "2017-03-12 1:45:00", freq="15min")
         s = Series(np.zeros(len(index)), index=index)
         expected = s.tz_localize("US/Pacific")
         expected.index = pd.DatetimeIndex(expected.index, freq="900S")

From 898f81127ac8064f711ee82fbff8a430ab0958b7 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Sun, 23 Jul 2023 21:17:26 +0200
Subject: [PATCH 08/31] correct def _maybe_coerce_freq , is_subperiod,
 is_superperiod, and _offset_to_period_map and fix tests

---
 pandas/tests/frame/test_constructors.py       |  4 +-
 .../tests/groupby/aggregate/test_aggregate.py |  4 +-
 .../datetimelike_/test_drop_duplicates.py     |  3 +-
 .../tests/indexes/period/test_constructors.py |  2 +-
 .../tests/indexes/period/test_resolution.py   |  1 -
 pandas/tests/io/formats/test_format.py        |  2 +-
 .../tests/io/generate_legacy_storage_files.py |  2 +-
 .../tests/io/json/test_json_table_schema.py   |  6 +-
 pandas/tests/io/pytables/test_select.py       |  4 +-
 pandas/tests/plotting/test_converter.py       |  2 +-
 pandas/tests/plotting/test_datetimelike.py    | 36 ++++++------
 pandas/tests/resample/test_period_index.py    | 15 +++--
 .../tests/resample/test_resampler_grouper.py  |  4 +-
 pandas/tests/resample/test_time_grouper.py    |  4 +-
 pandas/tests/resample/test_timedelta.py       | 18 +++---
 pandas/tests/reshape/concat/test_datetimes.py |  2 +-
 pandas/tests/scalar/period/test_asfreq.py     | 12 ++--
 pandas/tests/scalar/period/test_period.py     | 34 +++++------
 .../tests/scalar/timedelta/test_timedelta.py  | 10 ++--
 .../tests/scalar/timestamp/test_unary_ops.py  |  8 +--
 .../series/accessors/test_dt_accessor.py      |  8 +--
 pandas/tests/series/indexing/test_datetime.py |  2 +-
 .../tseries/frequencies/test_inference.py     |  4 +-
 pandas/tests/window/test_rolling.py           |  8 ++-
 pandas/tseries/frequencies.py                 | 56 ++++++++++---------
 25 files changed, 129 insertions(+), 122 deletions(-)

diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 37690530c063a..b72d8bb273423 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -2882,7 +2882,9 @@ def test_frame_datetime64_mixed_index_ctor_1681(self):
 
     def test_frame_timeseries_column(self):
         # GH19157
-        dr = date_range(start="20130101T10:00:00", periods=3, freq="min", tz="US/Eastern")
+        dr = date_range(
+            start="20130101T10:00:00", periods=3, freq="min", tz="US/Eastern"
+        )
         result = DataFrame(dr, columns=["timestamps"])
         expected = DataFrame(
             {
diff --git a/pandas/tests/groupby/aggregate/test_aggregate.py b/pandas/tests/groupby/aggregate/test_aggregate.py
index 2e849d9a640fa..83edbc05a4246 100644
--- a/pandas/tests/groupby/aggregate/test_aggregate.py
+++ b/pandas/tests/groupby/aggregate/test_aggregate.py
@@ -403,7 +403,9 @@ def test_agg_multiple_functions_same_name_with_ohlc_present():
     non_ohlc_expected_values = np.array(
         [df.resample("3min").A.quantile(q=q).values for q in [0.9999, 0.1111]]
     ).T
-    expected_values = np.hstack([df.resample("3min").A.ohlc(), non_ohlc_expected_values])
+    expected_values = np.hstack(
+        [df.resample("3min").A.ohlc(), non_ohlc_expected_values]
+    )
     expected = DataFrame(
         expected_values, columns=expected_columns, index=expected_index
     )
diff --git a/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py b/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py
index f2cd7b48680e3..6f629ad822bc5 100644
--- a/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py
+++ b/pandas/tests/indexes/datetimelike_/test_drop_duplicates.py
@@ -14,7 +14,6 @@
 class DropDuplicates:
     def test_drop_duplicates_metadata(self, idx):
         # GH#10115
-        print("11111111  = ", idx)
         result = idx.drop_duplicates()
         tm.assert_index_equal(idx, result)
         assert idx.freq == result.freq
@@ -69,7 +68,7 @@ def test_drop_duplicates(self, keep, expected, index, idx):
 
 
 class TestDropDuplicatesPeriodIndex(DropDuplicates):
-    @pytest.fixture(params=["D", "3D", "H", "2H", "T", "2T", "S", "3S"])
+    @pytest.fixture(params=["D", "3D", "H", "2H", "min", "2min", "S", "3S"])
     def freq(self, request):
         return request.param
 
diff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py
index 3a768894ccaaf..22b6280c84c94 100644
--- a/pandas/tests/indexes/period/test_constructors.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -139,7 +139,7 @@ def test_constructor_corner(self):
 
     def test_constructor_with_without_freq(self):
         # GH53687
-        start = Period("2002-01-01 00:00", freq="30T")
+        start = Period("2002-01-01 00:00", freq="30min")
         exp = period_range(start=start, periods=5, freq=start.freq)
         result = period_range(start=start, periods=5)
         tm.assert_index_equal(exp, result)
diff --git a/pandas/tests/indexes/period/test_resolution.py b/pandas/tests/indexes/period/test_resolution.py
index e700d27d4a80e..09af879ee811e 100644
--- a/pandas/tests/indexes/period/test_resolution.py
+++ b/pandas/tests/indexes/period/test_resolution.py
@@ -1,7 +1,6 @@
 import pytest
 
 import pandas as pd
-import pandas._testing as tm
 
 
 class TestResolution:
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 92ced33ab338a..5a5e7e45ee7af 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -3333,7 +3333,7 @@ def test_period_custom(self):
         # GH#46252 custom formatting directives %l (ms) and %u (us)
 
         # 3 digits
-        per = pd.period_range("2003-01-01 12:01:01.123", periods=2, freq="l")
+        per = pd.period_range("2003-01-01 12:01:01.123", periods=2, freq="ms")
         formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
         assert formatted[0] == "03 12:01:01 (ms=123 us=123000 ns=123000000)"
         assert formatted[1] == "03 12:01:01 (ms=124 us=124000 ns=124000000)"
diff --git a/pandas/tests/io/generate_legacy_storage_files.py b/pandas/tests/io/generate_legacy_storage_files.py
index 974a2174cb03b..9643cf3258e64 100644
--- a/pandas/tests/io/generate_legacy_storage_files.py
+++ b/pandas/tests/io/generate_legacy_storage_files.py
@@ -142,7 +142,7 @@ def create_data():
         "period": period_range("2013-01-01", freq="M", periods=10),
         "float": Index(np.arange(10, dtype=np.float64)),
         "uint": Index(np.arange(10, dtype=np.uint64)),
-        "timedelta": timedelta_range("00:00:00", freq="30T", periods=10),
+        "timedelta": timedelta_range("00:00:00", freq="30min", periods=10),
     }
 
     index["range"] = RangeIndex(10)
diff --git a/pandas/tests/io/json/test_json_table_schema.py b/pandas/tests/io/json/test_json_table_schema.py
index 25b0e4a9f1de9..447e7c535b7a4 100644
--- a/pandas/tests/io/json/test_json_table_schema.py
+++ b/pandas/tests/io/json/test_json_table_schema.py
@@ -32,7 +32,7 @@ def df_schema():
             "A": [1, 2, 3, 4],
             "B": ["a", "b", "c", "c"],
             "C": pd.date_range("2016-01-01", freq="d", periods=4),
-            "D": pd.timedelta_range("1H", periods=4, freq="T"),
+            "D": pd.timedelta_range("1H", periods=4, freq="min"),
         },
         index=pd.Index(range(4), name="idx"),
     )
@@ -45,7 +45,7 @@ def df_table():
             "A": [1, 2, 3, 4],
             "B": ["a", "b", "c", "c"],
             "C": pd.date_range("2016-01-01", freq="d", periods=4),
-            "D": pd.timedelta_range("1H", periods=4, freq="T"),
+            "D": pd.timedelta_range("1H", periods=4, freq="min"),
             "E": pd.Series(pd.Categorical(["a", "b", "c", "c"])),
             "F": pd.Series(pd.Categorical(["a", "b", "c", "c"], ordered=True)),
             "G": [1.0, 2.0, 3, 4.0],
@@ -695,7 +695,7 @@ def test_read_json_table_orient(self, index_nm, vals, recwarn):
     @pytest.mark.parametrize("index_nm", [None, "idx", "index"])
     @pytest.mark.parametrize(
         "vals",
-        [{"timedeltas": pd.timedelta_range("1H", periods=4, freq="T")}],
+        [{"timedeltas": pd.timedelta_range("1H", periods=4, freq="min")}],
     )
     def test_read_json_table_orient_raises(self, index_nm, vals, recwarn):
         df = DataFrame(vals, index=pd.Index(range(4), name=index_nm))
diff --git a/pandas/tests/io/pytables/test_select.py b/pandas/tests/io/pytables/test_select.py
index 8d9e0b9f5ffec..9c3390cae9002 100644
--- a/pandas/tests/io/pytables/test_select.py
+++ b/pandas/tests/io/pytables/test_select.py
@@ -60,7 +60,7 @@ def test_select_columns_in_where(setup_path):
 def test_select_with_dups(setup_path):
     # single dtypes
     df = DataFrame(np.random.randn(10, 4), columns=["A", "A", "B", "B"])
-    df.index = date_range("20130101 9:30", periods=10, freq="T")
+    df.index = date_range("20130101 9:30", periods=10, freq="min")
 
     with ensure_clean_store(setup_path) as store:
         store.append("df", df)
@@ -87,7 +87,7 @@ def test_select_with_dups(setup_path):
         ],
         axis=1,
     )
-    df.index = date_range("20130101 9:30", periods=10, freq="T")
+    df.index = date_range("20130101 9:30", periods=10, freq="min")
 
     with ensure_clean_store(setup_path) as store:
         store.append("df", df)
diff --git a/pandas/tests/plotting/test_converter.py b/pandas/tests/plotting/test_converter.py
index cadd4c4589964..c99afa240e9de 100644
--- a/pandas/tests/plotting/test_converter.py
+++ b/pandas/tests/plotting/test_converter.py
@@ -255,7 +255,7 @@ def test_time_formatter(self, time, format_expected):
         result = converter.TimeFormatter(None)(time)
         assert result == format_expected
 
-    @pytest.mark.parametrize("freq", ("B", "L", "S"))
+    @pytest.mark.parametrize("freq", ("B", "ms", "S"))
     def test_dateindex_conversion(self, freq, dtc):
         rtol = 10**-9
         dateindex = tm.makeDateIndex(k=10, freq=freq)
diff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py
index af8bcd943765e..2f8634bd0f741 100644
--- a/pandas/tests/plotting/test_datetimelike.py
+++ b/pandas/tests/plotting/test_datetimelike.py
@@ -81,7 +81,7 @@ def test_frame_inferred(self):
 
     def test_frame_inferred_n_gt_1(self):
         # N > 1
-        idx = date_range("2008-1-1 00:15:00", freq="15T", periods=10)
+        idx = date_range("2008-1-1 00:15:00", freq="15min", periods=10)
         idx = DatetimeIndex(idx.values, freq=None)
         df = DataFrame(np.random.randn(len(idx), 3), index=idx)
         _check_plot_works(df.plot)
@@ -109,7 +109,7 @@ def test_nonnumeric_exclude_error(self):
         with pytest.raises(TypeError, match=msg):
             df["A"].plot()
 
-    @pytest.mark.parametrize("freq", ["S", "T", "H", "D", "W", "M", "Q", "A"])
+    @pytest.mark.parametrize("freq", ["S", "min", "H", "D", "W", "M", "Q", "A"])
     def test_tsplot_period(self, freq):
         idx = period_range("12/31/1999", freq=freq, periods=100)
         ser = Series(np.random.randn(len(idx)), idx)
@@ -117,7 +117,7 @@ def test_tsplot_period(self, freq):
         _check_plot_works(ser.plot, ax=ax)
 
     @pytest.mark.parametrize(
-        "freq", ["S", "T", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
     )
     def test_tsplot_datetime(self, freq):
         idx = date_range("12/31/1999", freq=freq, periods=100)
@@ -179,14 +179,14 @@ def check_format_of_first_point(ax, expected_string):
         daily.plot(ax=ax)
         check_format_of_first_point(ax, "t = 2014-01-01  y = 1.000000")
 
-    @pytest.mark.parametrize("freq", ["S", "T", "H", "D", "W", "M", "Q", "A"])
+    @pytest.mark.parametrize("freq", ["S", "min", "H", "D", "W", "M", "Q", "A"])
     def test_line_plot_period_series(self, freq):
         idx = period_range("12/31/1999", freq=freq, periods=100)
         ser = Series(np.random.randn(len(idx)), idx)
         _check_plot_works(ser.plot, ser.index.freq)
 
     @pytest.mark.parametrize(
-        "frqncy", ["1S", "3S", "5T", "7H", "4D", "8W", "11M", "3A"]
+        "frqncy", ["1S", "3S", "5min", "7H", "4D", "8W", "11M", "3A"]
     )
     def test_line_plot_period_mlt_series(self, frqncy):
         # test period index line plot for series with multiples (`mlt`) of the
@@ -196,21 +196,21 @@ def test_line_plot_period_mlt_series(self, frqncy):
         _check_plot_works(s.plot, s.index.freq.rule_code)
 
     @pytest.mark.parametrize(
-        "freq", ["S", "T", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
     )
     def test_line_plot_datetime_series(self, freq):
         idx = date_range("12/31/1999", freq=freq, periods=100)
         ser = Series(np.random.randn(len(idx)), idx)
         _check_plot_works(ser.plot, ser.index.freq.rule_code)
 
-    @pytest.mark.parametrize("freq", ["S", "T", "H", "D", "W", "M", "Q", "A"])
+    @pytest.mark.parametrize("freq", ["S", "min", "H", "D", "W", "M", "Q", "A"])
     def test_line_plot_period_frame(self, freq):
         idx = date_range("12/31/1999", freq=freq, periods=100)
         df = DataFrame(np.random.randn(len(idx), 3), index=idx, columns=["A", "B", "C"])
         _check_plot_works(df.plot, df.index.freq)
 
     @pytest.mark.parametrize(
-        "frqncy", ["1S", "3S", "5T", "7H", "4D", "8W", "11M", "3A"]
+        "frqncy", ["1S", "3S", "5min", "7H", "4D", "8W", "11M", "3A"]
     )
     def test_line_plot_period_mlt_frame(self, frqncy):
         # test period index line plot for DataFrames with multiples (`mlt`)
@@ -222,7 +222,7 @@ def test_line_plot_period_mlt_frame(self, frqncy):
         _check_plot_works(df.plot, freq)
 
     @pytest.mark.parametrize(
-        "freq", ["S", "T", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
     )
     def test_line_plot_datetime_frame(self, freq):
         idx = date_range("12/31/1999", freq=freq, periods=100)
@@ -231,7 +231,7 @@ def test_line_plot_datetime_frame(self, freq):
         _check_plot_works(df.plot, freq)
 
     @pytest.mark.parametrize(
-        "freq", ["S", "T", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
     )
     def test_line_plot_inferred_freq(self, freq):
         idx = date_range("12/31/1999", freq=freq, periods=100)
@@ -268,7 +268,7 @@ def test_plot_multiple_inferred_freq(self):
     def test_uhf(self):
         import pandas.plotting._matplotlib.converter as conv
 
-        idx = date_range("2012-6-22 21:59:51.960928", freq="L", periods=500)
+        idx = date_range("2012-6-22 21:59:51.960928", freq="ms", periods=500)
         df = DataFrame(np.random.randn(len(idx), 2), index=idx)
 
         _, ax = mpl.pyplot.subplots()
@@ -769,7 +769,7 @@ def test_mixed_freq_alignment(self):
         ts_data = np.random.randn(12)
 
         ts = Series(ts_data, index=ts_ind)
-        ts2 = ts.asfreq("T").interpolate()
+        ts2 = ts.asfreq("min").interpolate()
 
         _, ax = mpl.pyplot.subplots()
         ax = ts.plot(ax=ax)
@@ -792,7 +792,7 @@ def test_mixed_freq_lf_first(self):
         mpl.pyplot.close(ax.get_figure())
 
     def test_mixed_freq_lf_first_hourly(self):
-        idxh = date_range("1/1/1999", periods=240, freq="T")
+        idxh = date_range("1/1/1999", periods=240, freq="min")
         idxl = date_range("1/1/1999", periods=4, freq="H")
         high = Series(np.random.randn(len(idxh)), idxh)
         low = Series(np.random.randn(len(idxl)), idxl)
@@ -800,7 +800,7 @@ def test_mixed_freq_lf_first_hourly(self):
         low.plot(ax=ax)
         high.plot(ax=ax)
         for line in ax.get_lines():
-            assert PeriodIndex(data=line.get_xdata()).freq == "T"
+            assert PeriodIndex(data=line.get_xdata()).freq == "min"
 
     def test_mixed_freq_irreg_period(self):
         ts = tm.makeTimeSeries()
@@ -990,7 +990,7 @@ def test_from_resampling_area_line_mixed_high_to_low(self, kind1, kind2):
     def test_mixed_freq_second_millisecond(self):
         # GH 7772, GH 7760
         idxh = date_range("2014-07-01 09:00", freq="S", periods=50)
-        idxl = date_range("2014-07-01 09:00", freq="100L", periods=500)
+        idxl = date_range("2014-07-01 09:00", freq="100ms", periods=500)
         high = Series(np.random.randn(len(idxh)), idxh)
         low = Series(np.random.randn(len(idxl)), idxl)
         # high to low
@@ -999,12 +999,12 @@ def test_mixed_freq_second_millisecond(self):
         low.plot(ax=ax)
         assert len(ax.get_lines()) == 2
         for line in ax.get_lines():
-            assert PeriodIndex(data=line.get_xdata()).freq == "L"
+            assert PeriodIndex(data=line.get_xdata()).freq == "ms"
 
     def test_mixed_freq_second_millisecond_low_to_high(self):
         # GH 7772, GH 7760
         idxh = date_range("2014-07-01 09:00", freq="S", periods=50)
-        idxl = date_range("2014-07-01 09:00", freq="100L", periods=500)
+        idxl = date_range("2014-07-01 09:00", freq="100ms", periods=500)
         high = Series(np.random.randn(len(idxh)), idxh)
         low = Series(np.random.randn(len(idxl)), idxl)
         # low to high
@@ -1013,7 +1013,7 @@ def test_mixed_freq_second_millisecond_low_to_high(self):
         high.plot(ax=ax)
         assert len(ax.get_lines()) == 2
         for line in ax.get_lines():
-            assert PeriodIndex(data=line.get_xdata()).freq == "L"
+            assert PeriodIndex(data=line.get_xdata()).freq == "ms"
 
     def test_irreg_dtypes(self):
         # date
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index ec4ef39b95a78..a0b5df0e985a3 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -210,13 +210,13 @@ def test_resample_basic(self):
         )
         s[10:30] = np.nan
         index = PeriodIndex(
-            [Period("2013-01-01 00:00", "T"), Period("2013-01-01 00:01", "T")],
+            [Period("2013-01-01 00:00", "min"), Period("2013-01-01 00:01", "min")],
             name="idx",
         )
         expected = Series([34.5, 79.5], index=index)
-        result = s.to_period().resample("T", kind="period").mean()
+        result = s.to_period().resample("min", kind="period").mean()
         tm.assert_series_equal(result, expected)
-        result2 = s.resample("T", kind="period").mean()
+        result2 = s.resample("min", kind="period").mean()
         tm.assert_series_equal(result2, expected)
 
     @pytest.mark.parametrize(
@@ -341,10 +341,13 @@ def test_resample_nonexistent_time_bin_edge(self):
     def test_resample_ambiguous_time_bin_edge(self):
         # GH 10117
         idx = date_range(
-            "2014-10-25 22:00:00", "2014-10-26 00:30:00", freq="30T", tz="Europe/London"
+            "2014-10-25 22:00:00",
+            "2014-10-26 00:30:00",
+            freq="30min",
+            tz="Europe/London",
         )
         expected = Series(np.zeros(len(idx)), index=idx)
-        result = expected.resample("30T").mean()
+        result = expected.resample("30min").mean()
         tm.assert_series_equal(result, expected)
 
     def test_fill_method_and_how_upsample(self):
@@ -640,7 +643,7 @@ def test_default_right_closed_label(self, from_freq, to_freq):
 
     @pytest.mark.parametrize(
         "from_freq, to_freq",
-        [("D", "MS"), ("Q", "AS"), ("M", "QS"), ("H", "D"), ("T", "H")],
+        [("D", "MS"), ("Q", "AS"), ("M", "QS"), ("H", "D"), ("min", "H")],
     )
     def test_default_left_closed_label(self, from_freq, to_freq):
         idx = date_range(start="8/15/2012", periods=100, freq=from_freq)
diff --git a/pandas/tests/resample/test_resampler_grouper.py b/pandas/tests/resample/test_resampler_grouper.py
index 23b4f4bcf01d1..59f3bad02f6fa 100644
--- a/pandas/tests/resample/test_resampler_grouper.py
+++ b/pandas/tests/resample/test_resampler_grouper.py
@@ -178,7 +178,7 @@ def test_groupby_with_origin():
 def test_nearest():
     # GH 17496
     # Resample nearest
-    index = date_range("1/1/2000", periods=3, freq="T")
+    index = date_range("1/1/2000", periods=3, freq="min")
     result = Series(range(3), index=index).resample("20s").nearest()
 
     expected = Series(
@@ -313,7 +313,7 @@ def weighted_quantile(series, weights, q):
         cutoff = cumsum.iloc[-1] * q
         return series[cumsum >= cutoff].iloc[0]
 
-    times = date_range("2017-6-23 18:00", periods=8, freq="15T", tz="UTC")
+    times = date_range("2017-6-23 18:00", periods=8, freq="15min", tz="UTC")
     data = Series([1.0, 1, 1, 1, 1, 2, 2, 0], index=times)
     weights = Series([160.0, 91, 65, 43, 24, 10, 1, 0], index=times)
 
diff --git a/pandas/tests/resample/test_time_grouper.py b/pandas/tests/resample/test_time_grouper.py
index 2cd47296d5cab..c98e2169910f3 100644
--- a/pandas/tests/resample/test_time_grouper.py
+++ b/pandas/tests/resample/test_time_grouper.py
@@ -302,10 +302,10 @@ def test_repr():
 )
 def test_upsample_sum(method, method_args, expected_values):
     s = Series(1, index=date_range("2017", periods=2, freq="H"))
-    resampled = s.resample("30T")
+    resampled = s.resample("30min")
     index = pd.DatetimeIndex(
         ["2017-01-01T00:00:00", "2017-01-01T00:30:00", "2017-01-01T01:00:00"],
-        freq="30T",
+        freq="30min",
     )
     result = methodcaller(method, **method_args)(resampled)
     expected = Series(expected_values, index=index)
diff --git a/pandas/tests/resample/test_timedelta.py b/pandas/tests/resample/test_timedelta.py
index d87e6ca2f69b9..f34f954fd4fac 100644
--- a/pandas/tests/resample/test_timedelta.py
+++ b/pandas/tests/resample/test_timedelta.py
@@ -14,10 +14,10 @@
 
 def test_asfreq_bug():
     df = DataFrame(data=[1, 3], index=[timedelta(), timedelta(minutes=3)])
-    result = df.resample("1T").asfreq()
+    result = df.resample("1min").asfreq()
     expected = DataFrame(
         data=[1, np.nan, np.nan, 3],
-        index=timedelta_range("0 day", periods=4, freq="1T"),
+        index=timedelta_range("0 day", periods=4, freq="1min"),
     )
     tm.assert_frame_equal(result, expected)
 
@@ -35,12 +35,12 @@ def test_resample_with_nat():
 
 def test_resample_as_freq_with_subperiod():
     # GH 13022
-    index = timedelta_range("00:00:00", "00:10:00", freq="5T")
+    index = timedelta_range("00:00:00", "00:10:00", freq="5min")
     df = DataFrame(data={"value": [1, 5, 10]}, index=index)
-    result = df.resample("2T").asfreq()
+    result = df.resample("2min").asfreq()
     expected_data = {"value": [1, np.nan, np.nan, np.nan, np.nan, 10]}
     expected = DataFrame(
-        data=expected_data, index=timedelta_range("00:00:00", "00:10:00", freq="2T")
+        data=expected_data, index=timedelta_range("00:00:00", "00:10:00", freq="2min")
     )
     tm.assert_frame_equal(result, expected)
 
@@ -71,9 +71,9 @@ def test_resample_single_period_timedelta():
 
 def test_resample_timedelta_idempotency():
     # GH 12072
-    index = timedelta_range("0", periods=9, freq="10L")
+    index = timedelta_range("0", periods=9, freq="10ms")
     series = Series(range(9), index=index)
-    result = series.resample("10L").mean()
+    result = series.resample("10ms").mean()
     expected = series.astype(float)
     tm.assert_series_equal(result, expected)
 
@@ -196,11 +196,11 @@ def test_resample_closed_right():
     # GH#45414
     idx = pd.Index([pd.Timedelta(seconds=120 + i * 30) for i in range(10)])
     ser = Series(range(10), index=idx)
-    result = ser.resample("T", closed="right", label="right").sum()
+    result = ser.resample("min", closed="right", label="right").sum()
     expected = Series(
         [0, 3, 7, 11, 15, 9],
         index=pd.TimedeltaIndex(
-            [pd.Timedelta(seconds=120 + i * 60) for i in range(6)], freq="T"
+            [pd.Timedelta(seconds=120 + i * 60) for i in range(6)], freq="min"
         ),
     )
     tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/reshape/concat/test_datetimes.py b/pandas/tests/reshape/concat/test_datetimes.py
index a06fc5eede55c..2f50a19189987 100644
--- a/pandas/tests/reshape/concat/test_datetimes.py
+++ b/pandas/tests/reshape/concat/test_datetimes.py
@@ -112,7 +112,7 @@ def test_concat_datetime_timezone(self):
     def test_concat_datetimeindex_freq(self):
         # GH 3232
         # Monotonic index result
-        dr = date_range("01-Jan-2013", periods=100, freq="50L", tz="UTC")
+        dr = date_range("01-Jan-2013", periods=100, freq="50ms", tz="UTC")
         data = list(range(100))
         expected = DataFrame(data, index=dr)
         result = concat([expected[:50], expected[50:]])
diff --git a/pandas/tests/scalar/period/test_asfreq.py b/pandas/tests/scalar/period/test_asfreq.py
index e652c63d46f18..c4929da79dfac 100644
--- a/pandas/tests/scalar/period/test_asfreq.py
+++ b/pandas/tests/scalar/period/test_asfreq.py
@@ -44,13 +44,13 @@ def test_to_timestamp_out_of_bounds(self):
 
     def test_asfreq_corner(self):
         val = Period(freq="A", year=2007)
-        result1 = val.asfreq("5t")
-        result2 = val.asfreq("t")
-        expected = Period("2007-12-31 23:59", freq="t")
+        result1 = val.asfreq("5min")
+        result2 = val.asfreq("min")
+        expected = Period("2007-12-31 23:59", freq="min")
         assert result1.ordinal == expected.ordinal
-        assert result1.freqstr == "5T"
+        assert result1.freqstr == "5min"
         assert result2.ordinal == expected.ordinal
-        assert result2.freqstr == "T"
+        assert result2.freqstr == "min"
 
     def test_conv_annual(self):
         # frequency conversion tests: from Annual Frequency
@@ -107,8 +107,6 @@ def test_conv_annual(self):
         assert ival_A.asfreq("H", "E") == ival_A_to_H_end
         assert ival_A.asfreq("min", "S") == ival_A_to_T_start
         assert ival_A.asfreq("min", "E") == ival_A_to_T_end
-        assert ival_A.asfreq("T", "S") == ival_A_to_T_start
-        assert ival_A.asfreq("T", "E") == ival_A_to_T_end
         assert ival_A.asfreq("S", "S") == ival_A_to_S_start
         assert ival_A.asfreq("S", "E") == ival_A_to_S_end
 
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index 1e8c2bce1d90d..1ed7852b39c6f 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -100,10 +100,10 @@ def test_construction(self):
         assert i1 == i3
 
         i1 = Period("2007-01-01 09:00:00.001")
-        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="L")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="ms")
         assert i1 == expected
 
-        expected = Period("2007-01-01 09:00:00.001", freq="L")
+        expected = Period("2007-01-01 09:00:00.001", freq="ms")
         assert i1 == expected
 
         i1 = Period("2007-01-01 09:00:00.00101")
@@ -276,10 +276,10 @@ def test_period_constructor_offsets(self):
         assert i1 == i5
 
         i1 = Period("2007-01-01 09:00:00.001")
-        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="L")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="ms")
         assert i1 == expected
 
-        expected = Period("2007-01-01 09:00:00.001", freq="L")
+        expected = Period("2007-01-01 09:00:00.001", freq="ms")
         assert i1 == expected
 
         i1 = Period("2007-01-01 09:00:00.00101")
@@ -340,13 +340,13 @@ def test_constructor_infer_freq(self):
         assert p.freq == "H"
 
         p = Period("2007-01-01 07:10")
-        assert p.freq == "T"
+        assert p.freq == "min"
 
         p = Period("2007-01-01 07:10:15")
         assert p.freq == "S"
 
         p = Period("2007-01-01 07:10:15.123")
-        assert p.freq == "L"
+        assert p.freq == "ms"
 
         # We see that there are 6 digits after the decimal, so get microsecond
         #  even though they are all zeros.
@@ -655,10 +655,10 @@ def _ex(p):
         result = p.to_timestamp("3H", how="end")
         assert result == expected
 
-        result = p.to_timestamp("T", how="end")
+        result = p.to_timestamp("min", how="end")
         expected = Timestamp(1986, 1, 1) - Timedelta(1, "ns")
         assert result == expected
-        result = p.to_timestamp("2T", how="end")
+        result = p.to_timestamp("2min", how="end")
         assert result == expected
 
         result = p.to_timestamp(how="end")
@@ -668,7 +668,7 @@ def _ex(p):
         expected = datetime(1985, 1, 1)
         result = p.to_timestamp("H", how="start")
         assert result == expected
-        result = p.to_timestamp("T", how="start")
+        result = p.to_timestamp("min", how="start")
         assert result == expected
         result = p.to_timestamp("S", how="start")
         assert result == expected
@@ -720,10 +720,10 @@ def test_to_timestamp_microsecond(self, ts, expected, freq):
             ),
             ("2000-12-15 13:45:26.123456789", "U", "2000-12-15 13:45:26.123456", "U"),
             ("2000-12-15 13:45:26.123456", None, "2000-12-15 13:45:26.123456", "U"),
-            ("2000-12-15 13:45:26.123456789", "L", "2000-12-15 13:45:26.123", "L"),
-            ("2000-12-15 13:45:26.123", None, "2000-12-15 13:45:26.123", "L"),
+            ("2000-12-15 13:45:26.123456789", "ms", "2000-12-15 13:45:26.123", "ms"),
+            ("2000-12-15 13:45:26.123", None, "2000-12-15 13:45:26.123", "ms"),
             ("2000-12-15 13:45:26", "S", "2000-12-15 13:45:26", "S"),
-            ("2000-12-15 13:45:26", "T", "2000-12-15 13:45", "T"),
+            ("2000-12-15 13:45:26", "min", "2000-12-15 13:45", "min"),
             ("2000-12-15 13:45:26", "H", "2000-12-15 13:00", "H"),
             ("2000-12-15", "Y", "2000", "A-DEC"),
             ("2000-12-15", "Q", "2000Q4", "Q-DEC"),
@@ -788,7 +788,7 @@ def test_quarterly_negative_ordinals(self):
     def test_freq_str(self):
         i1 = Period("1982", freq="Min")
         assert i1.freq == offsets.Minute()
-        assert i1.freqstr == "T"
+        assert i1.freqstr == "min"
 
     def test_period_deprecated_freq(self):
         cases = {
@@ -796,9 +796,9 @@ def test_period_deprecated_freq(self):
             "B": ["BUS", "BUSINESS", "BUSINESSLY", "WEEKDAY", "bus"],
             "D": ["DAY", "DLY", "DAILY", "Day", "Dly", "Daily"],
             "H": ["HR", "HOUR", "HRLY", "HOURLY", "hr", "Hour", "HRly"],
-            "T": ["minute", "MINUTE", "MINUTELY", "minutely"],
+            "min": ["minute", "MINUTE", "MINUTELY", "minutely"],
             "S": ["sec", "SEC", "SECOND", "SECONDLY", "second"],
-            "L": ["MILLISECOND", "MILLISECONDLY", "millisecond"],
+            "ms": ["MILLISECOND", "MILLISECONDLY", "millisecond"],
             "U": ["MICROSECOND", "MICROSECONDLY", "microsecond"],
             "N": ["NANOSECOND", "NANOSECONDLY", "nanosecond"],
         }
@@ -848,7 +848,7 @@ def test_inner_bounds_start_and_end_time(self, bound, offset, period_property):
         assert getattr(period, period_property).floor("S") == expected
 
     def test_start_time(self):
-        freq_lst = ["A", "Q", "M", "D", "H", "T", "S"]
+        freq_lst = ["A", "Q", "M", "D", "H", "min", "S"]
         xp = datetime(2012, 1, 1)
         for f in freq_lst:
             p = Period("2012", freq=f)
@@ -1571,7 +1571,7 @@ def test_small_year_parsing():
 
 
 def test_negone_ordinals():
-    freqs = ["A", "M", "Q", "D", "H", "T", "S"]
+    freqs = ["A", "M", "Q", "D", "H", "min", "S"]
 
     period = Period(ordinal=-1, freq="D")
     for freq in freqs:
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index 701cfdf157d26..a43c96abbb0c1 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -657,15 +657,15 @@ def test_to_numpy_alias(self):
                 Timedelta("-1 days 02:34:56.789123000"),
             ),
             (
-                "L",
+                "ms",
                 Timedelta("1 days 02:34:56.789000000"),
                 Timedelta("-1 days 02:34:56.789000000"),
             ),
             ("S", Timedelta("1 days 02:34:57"), Timedelta("-1 days 02:34:57")),
             ("2S", Timedelta("1 days 02:34:56"), Timedelta("-1 days 02:34:56")),
             ("5S", Timedelta("1 days 02:34:55"), Timedelta("-1 days 02:34:55")),
-            ("T", Timedelta("1 days 02:35:00"), Timedelta("-1 days 02:35:00")),
-            ("12T", Timedelta("1 days 02:36:00"), Timedelta("-1 days 02:36:00")),
+            ("min", Timedelta("1 days 02:35:00"), Timedelta("-1 days 02:35:00")),
+            ("12min", Timedelta("1 days 02:36:00"), Timedelta("-1 days 02:36:00")),
             ("H", Timedelta("1 days 03:00:00"), Timedelta("-1 days 03:00:00")),
             ("d", Timedelta("1 days"), Timedelta("-1 days")),
         ],
@@ -986,9 +986,9 @@ def test_total_seconds_precision(self):
     def test_resolution_string(self):
         assert Timedelta(days=1).resolution_string == "D"
         assert Timedelta(days=1, hours=6).resolution_string == "H"
-        assert Timedelta(days=1, minutes=6).resolution_string == "T"
+        assert Timedelta(days=1, minutes=6).resolution_string == "min"
         assert Timedelta(days=1, seconds=6).resolution_string == "S"
-        assert Timedelta(days=1, milliseconds=6).resolution_string == "L"
+        assert Timedelta(days=1, milliseconds=6).resolution_string == "ms"
         assert Timedelta(days=1, microseconds=6).resolution_string == "U"
         assert Timedelta(days=1, nanoseconds=6).resolution_string == "N"
 
diff --git a/pandas/tests/scalar/timestamp/test_unary_ops.py b/pandas/tests/scalar/timestamp/test_unary_ops.py
index 0a43db87674af..c62062d2c3992 100644
--- a/pandas/tests/scalar/timestamp/test_unary_ops.py
+++ b/pandas/tests/scalar/timestamp/test_unary_ops.py
@@ -137,10 +137,10 @@ def test_ceil_floor_edge(self, test_input, rounder, freq, expected):
         "test_input, freq, expected",
         [
             ("2018-01-01 00:02:06", "2s", "2018-01-01 00:02:06"),
-            ("2018-01-01 00:02:00", "2T", "2018-01-01 00:02:00"),
-            ("2018-01-01 00:04:00", "4T", "2018-01-01 00:04:00"),
-            ("2018-01-01 00:15:00", "15T", "2018-01-01 00:15:00"),
-            ("2018-01-01 00:20:00", "20T", "2018-01-01 00:20:00"),
+            ("2018-01-01 00:02:00", "2min", "2018-01-01 00:02:00"),
+            ("2018-01-01 00:04:00", "4min", "2018-01-01 00:04:00"),
+            ("2018-01-01 00:15:00", "15min", "2018-01-01 00:15:00"),
+            ("2018-01-01 00:20:00", "20min", "2018-01-01 00:20:00"),
             ("2018-01-01 03:00:00", "3H", "2018-01-01 03:00:00"),
         ],
     )
diff --git a/pandas/tests/series/accessors/test_dt_accessor.py b/pandas/tests/series/accessors/test_dt_accessor.py
index 5cdeee20f3435..3c10c1200b450 100644
--- a/pandas/tests/series/accessors/test_dt_accessor.py
+++ b/pandas/tests/series/accessors/test_dt_accessor.py
@@ -253,7 +253,7 @@ def test_dt_accessor_limited_display_api(self):
         tm.assert_almost_equal(results, sorted(set(ok_for_dt + ok_for_dt_methods)))
 
         # tzaware
-        ser = Series(date_range("2015-01-01", "2016-01-01", freq="T"), name="xxx")
+        ser = Series(date_range("2015-01-01", "2016-01-01", freq="min"), name="xxx")
         ser = ser.dt.tz_localize("UTC").dt.tz_convert("America/Chicago")
         results = get_dir(ser)
         tm.assert_almost_equal(results, sorted(set(ok_for_dt + ok_for_dt_methods)))
@@ -270,11 +270,11 @@ def test_dt_accessor_limited_display_api(self):
     def test_dt_accessor_ambiguous_freq_conversions(self):
         # GH#11295
         # ambiguous time error on the conversions
-        ser = Series(date_range("2015-01-01", "2016-01-01", freq="T"), name="xxx")
+        ser = Series(date_range("2015-01-01", "2016-01-01", freq="min"), name="xxx")
         ser = ser.dt.tz_localize("UTC").dt.tz_convert("America/Chicago")
 
         exp_values = date_range(
-            "2015-01-01", "2016-01-01", freq="T", tz="UTC"
+            "2015-01-01", "2016-01-01", freq="min", tz="UTC"
         ).tz_convert("America/Chicago")
         # freq not preserved by tz_localize above
         exp_values = exp_values._with_freq(None)
@@ -611,7 +611,7 @@ def test_strftime_period_hours(self):
         tm.assert_series_equal(result, expected)
 
     def test_strftime_period_minutes(self):
-        ser = Series(period_range("20130101", periods=4, freq="L"))
+        ser = Series(period_range("20130101", periods=4, freq="ms"))
         result = ser.dt.strftime("%Y/%m/%d %H:%M:%S.%l")
         expected = Series(
             [
diff --git a/pandas/tests/series/indexing/test_datetime.py b/pandas/tests/series/indexing/test_datetime.py
index 072607c29fd4c..4cd0aa0686ba9 100644
--- a/pandas/tests/series/indexing/test_datetime.py
+++ b/pandas/tests/series/indexing/test_datetime.py
@@ -351,7 +351,7 @@ def test_indexing_over_size_cutoff_period_index(monkeypatch):
     monkeypatch.setattr(libindex, "_SIZE_CUTOFF", 1000)
 
     n = 1100
-    idx = period_range("1/1/2000", freq="T", periods=n)
+    idx = period_range("1/1/2000", freq="min", periods=n)
     assert idx._engine.over_size_threshold
 
     s = Series(np.random.randn(len(idx)), index=idx)
diff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py
index 337bc7374a9f4..3c68c9fd4ef93 100644
--- a/pandas/tests/tseries/frequencies/test_inference.py
+++ b/pandas/tests/tseries/frequencies/test_inference.py
@@ -39,11 +39,11 @@
     params=[
         (timedelta(1), "D"),
         (timedelta(hours=1), "H"),
-        (timedelta(minutes=1), "T"),
+        (timedelta(minutes=1), "min"),
         (timedelta(seconds=1), "S"),
         (np.timedelta64(1, "ns"), "N"),
         (timedelta(microseconds=1), "U"),
-        (timedelta(microseconds=1000), "L"),
+        (timedelta(microseconds=1000), "ms"),
     ]
 )
 def base_delta_code_pair(request):
diff --git a/pandas/tests/window/test_rolling.py b/pandas/tests/window/test_rolling.py
index 381272ff691fe..47acee811d8b0 100644
--- a/pandas/tests/window/test_rolling.py
+++ b/pandas/tests/window/test_rolling.py
@@ -1152,11 +1152,13 @@ def test_rolling_on_df_transposed():
     ("index", "window"),
     [
         (
-            period_range(start="2020-01-01 08:00", end="2020-01-01 08:08", freq="T"),
-            "2T",
+            period_range(start="2020-01-01 08:00", end="2020-01-01 08:08", freq="min"),
+            "2min",
         ),
         (
-            period_range(start="2020-01-01 08:00", end="2020-01-01 12:00", freq="30T"),
+            period_range(
+                start="2020-01-01 08:00", end="2020-01-01 12:00", freq="30min"
+            ),
             "1h",
         ),
     ],
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index c8ea24cbea044..0b3b915bb7700 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -70,7 +70,7 @@
     "B": "B",
     "min": "min",
     "S": "S",
-    "L": "L",
+    "ms": "ms",
     "U": "U",
     "N": "N",
     "H": "H",
@@ -472,7 +472,6 @@ def is_subperiod(source, target) -> bool:
     -------
     bool
     """
-
     if target is None or source is None:
         return False
     source = _maybe_coerce_freq(source)
@@ -483,27 +482,27 @@ def is_subperiod(source, target) -> bool:
             return _quarter_months_conform(
                 get_rule_month(source), get_rule_month(target)
             )
-        return source in {"D", "C", "B", "M", "H", "min", "S", "L", "U", "N"}
+        return source in {"D", "C", "B", "M", "H", "min", "S", "ms", "U", "N"}
     elif _is_quarterly(target):
-        return source in {"D", "C", "B", "M", "H", "min", "S", "L", "U", "N"}
+        return source in {"D", "C", "B", "M", "H", "min", "S", "ms", "U", "N"}
     elif _is_monthly(target):
-        return source in {"D", "C", "B", "H", "min", "S", "L", "U", "N"}
+        return source in {"D", "C", "B", "H", "min", "S", "ms", "U", "N"}
     elif _is_weekly(target):
-        return source in {target, "D", "C", "B", "H", "min", "S", "L", "U", "N"}
+        return source in {target, "D", "C", "B", "H", "min", "S", "ms", "U", "N"}
     elif target == "B":
-        return source in {"B", "H", "min", "S", "L", "U", "N"}
+        return source in {"B", "H", "min", "S", "ms", "U", "N"}
     elif target == "C":
-        return source in {"C", "H", "min", "S", "L", "U", "N"}
+        return source in {"C", "H", "min", "S", "ms", "U", "N"}
     elif target == "D":
-        return source in {"D", "H", "min", "S", "L", "U", "N"}
+        return source in {"D", "H", "min", "S", "ms", "U", "N"}
     elif target == "H":
-        return source in {"H", "min", "S", "L", "U", "N"}
+        return source in {"H", "min", "S", "ms", "U", "N"}
     elif target == "min":
-        return source in {"min", "S", "L", "U", "N"}
+        return source in {"min", "S", "ms", "U", "N"}
     elif target == "S":
-        return source in {"S", "L", "U", "N"}
-    elif target == "L":
-        return source in {"L", "U", "N"}
+        return source in {"S", "ms", "U", "N"}
+    elif target == "ms":
+        return source in {"ms", "U", "N"}
     elif target == "U":
         return source in {"U", "N"}
     elif target == "N":
@@ -541,27 +540,27 @@ def is_superperiod(source, target) -> bool:
             smonth = get_rule_month(source)
             tmonth = get_rule_month(target)
             return _quarter_months_conform(smonth, tmonth)
-        return target in {"D", "C", "B", "M", "H", "min", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "M", "H", "min", "S", "ms", "U", "N"}
     elif _is_quarterly(source):
-        return target in {"D", "C", "B", "M", "H", "min", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "M", "H", "min", "S", "ms", "U", "N"}
     elif _is_monthly(source):
-        return target in {"D", "C", "B", "H", "min", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "ms", "U", "N"}
     elif _is_weekly(source):
-        return target in {source, "D", "C", "B", "H", "min", "S", "L", "U", "N"}
+        return target in {source, "D", "C", "B", "H", "min", "S", "ms", "U", "N"}
     elif source == "B":
-        return target in {"D", "C", "B", "H", "min", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "ms", "U", "N"}
     elif source == "C":
-        return target in {"D", "C", "B", "H", "min", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "ms", "U", "N"}
     elif source == "D":
-        return target in {"D", "C", "B", "H", "min", "S", "L", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "ms", "U", "N"}
     elif source == "H":
-        return target in {"H", "min", "S", "L", "U", "N"}
+        return target in {"H", "min", "S", "ms", "U", "N"}
     elif source == "min":
-        return target in {"min", "S", "L", "U", "N"}
+        return target in {"min", "S", "ms", "U", "N"}
     elif source == "S":
-        return target in {"S", "L", "U", "N"}
-    elif source == "L":
-        return target in {"L", "U", "N"}
+        return target in {"S", "ms", "U", "N"}
+    elif source == "ms":
+        return target in {"ms", "U", "N"}
     elif source == "U":
         return target in {"U", "N"}
     elif source == "N":
@@ -586,7 +585,10 @@ def _maybe_coerce_freq(code) -> str:
     assert code is not None
     if isinstance(code, DateOffset):
         code = code.rule_code
-    return code.upper()
+    if code in {"min", "ms"}:
+        return code
+    else:
+        return code.upper()
 
 
 def _quarter_months_conform(source: str, target: str) -> bool:

From 1d30c07e6de76f8fc86f0c545ee3b8fa0d68ab0d Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Tue, 25 Jul 2023 11:34:16 +0200
Subject: [PATCH 09/31] fix a test for plotting

---
 pandas/plotting/_matplotlib/converter.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pandas/plotting/_matplotlib/converter.py b/pandas/plotting/_matplotlib/converter.py
index cd7823ba15e44..33aeaa6d81406 100644
--- a/pandas/plotting/_matplotlib/converter.py
+++ b/pandas/plotting/_matplotlib/converter.py
@@ -412,7 +412,7 @@ def __call__(self):
             )
 
         interval = self._get_interval()
-        freq = f"{interval}L"
+        freq = f"{interval}ms"
         tz = self.tz.tzname(None)
         st = dmin.replace(tzinfo=None)
         ed = dmin.replace(tzinfo=None)

From 7171237d00d2dfceeb0c894ef224a8677f9f6fb4 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Tue, 25 Jul 2023 18:57:58 +0200
Subject: [PATCH 10/31] fix tests

---
 pandas/tests/indexes/datetimes/test_formats.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pandas/tests/indexes/datetimes/test_formats.py b/pandas/tests/indexes/datetimes/test_formats.py
index cb3e0179bf46c..502cb0407bfcd 100644
--- a/pandas/tests/indexes/datetimes/test_formats.py
+++ b/pandas/tests/indexes/datetimes/test_formats.py
@@ -73,17 +73,17 @@ def test_dti_repr_short(self):
         [
             (
                 ["2012-01-01 00:00:00"],
-                "60T",
+                "60min",
                 (
                     "DatetimeIndex(['2012-01-01 00:00:00'], "
-                    "dtype='datetime64[ns]', freq='60T')"
+                    "dtype='datetime64[ns]', freq='60min')"
                 ),
             ),
             (
                 ["2012-01-01 00:00:00", "2012-01-01 01:00:00"],
-                "60T",
+                "60min",
                 "DatetimeIndex(['2012-01-01 00:00:00', '2012-01-01 01:00:00'], "
-                "dtype='datetime64[ns]', freq='60T')",
+                "dtype='datetime64[ns]', freq='60min')",
             ),
             (
                 ["2012-01-01"],

From 29dcd8d118421a5845125899901aabbc1910b379 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Tue, 25 Jul 2023 21:22:17 +0200
Subject: [PATCH 11/31] fix failures in asv benchmarks

---
 asv_bench/benchmarks/arithmetic.py              |  6 +++---
 asv_bench/benchmarks/eval.py                    |  2 +-
 asv_bench/benchmarks/gil.py                     |  2 +-
 asv_bench/benchmarks/index_cached_properties.py |  6 +++---
 asv_bench/benchmarks/index_object.py            |  2 +-
 asv_bench/benchmarks/io/json.py                 |  2 +-
 asv_bench/benchmarks/join_merge.py              |  4 ++--
 asv_bench/benchmarks/sparse.py                  |  2 +-
 asv_bench/benchmarks/timeseries.py              | 14 +++++++-------
 asv_bench/benchmarks/tslibs/timestamp.py        |  4 ++--
 pandas/core/tools/timedeltas.py                 |  4 ++--
 11 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/asv_bench/benchmarks/arithmetic.py b/asv_bench/benchmarks/arithmetic.py
index 4fd9740f184c8..49543c166d047 100644
--- a/asv_bench/benchmarks/arithmetic.py
+++ b/asv_bench/benchmarks/arithmetic.py
@@ -262,7 +262,7 @@ class Timeseries:
     def setup(self, tz):
         N = 10**6
         halfway = (N // 2) - 1
-        self.s = Series(date_range("20010101", periods=N, freq="T", tz=tz))
+        self.s = Series(date_range("20010101", periods=N, freq="min", tz=tz))
         self.ts = self.s[halfway]
 
         self.s2 = Series(date_range("20010101", periods=N, freq="s", tz=tz))
@@ -460,7 +460,7 @@ class OffsetArrayArithmetic:
 
     def setup(self, offset):
         N = 10000
-        rng = date_range(start="1/1/2000", periods=N, freq="T")
+        rng = date_range(start="1/1/2000", periods=N, freq="min")
         self.rng = rng
         self.ser = Series(rng)
 
@@ -479,7 +479,7 @@ class ApplyIndex:
 
     def setup(self, offset):
         N = 10000
-        rng = date_range(start="1/1/2000", periods=N, freq="T")
+        rng = date_range(start="1/1/2000", periods=N, freq="min")
         self.rng = rng
 
     def time_apply_index(self, offset):
diff --git a/asv_bench/benchmarks/eval.py b/asv_bench/benchmarks/eval.py
index 8a3d224c59a09..656d16a910a9f 100644
--- a/asv_bench/benchmarks/eval.py
+++ b/asv_bench/benchmarks/eval.py
@@ -44,7 +44,7 @@ class Query:
     def setup(self):
         N = 10**6
         halfway = (N // 2) - 1
-        index = pd.date_range("20010101", periods=N, freq="T")
+        index = pd.date_range("20010101", periods=N, freq="min")
         s = pd.Series(index)
         self.ts = s.iloc[halfway]
         self.df = pd.DataFrame({"a": np.random.randn(N), "dates": index}, index=index)
diff --git a/asv_bench/benchmarks/gil.py b/asv_bench/benchmarks/gil.py
index 4d5c31d2dddf8..4993ffd2c47d0 100644
--- a/asv_bench/benchmarks/gil.py
+++ b/asv_bench/benchmarks/gil.py
@@ -178,7 +178,7 @@ def time_kth_smallest(self):
 class ParallelDatetimeFields:
     def setup(self):
         N = 10**6
-        self.dti = date_range("1900-01-01", periods=N, freq="T")
+        self.dti = date_range("1900-01-01", periods=N, freq="min")
         self.period = self.dti.to_period("D")
 
     def time_datetime_field_year(self):
diff --git a/asv_bench/benchmarks/index_cached_properties.py b/asv_bench/benchmarks/index_cached_properties.py
index b3d8de39a858a..d21bbe15c4cc8 100644
--- a/asv_bench/benchmarks/index_cached_properties.py
+++ b/asv_bench/benchmarks/index_cached_properties.py
@@ -25,14 +25,14 @@ def setup(self, index_type):
         N = 10**5
         if index_type == "MultiIndex":
             self.idx = pd.MultiIndex.from_product(
-                [pd.date_range("1/1/2000", freq="T", periods=N // 2), ["a", "b"]]
+                [pd.date_range("1/1/2000", freq="min", periods=N // 2), ["a", "b"]]
             )
         elif index_type == "DatetimeIndex":
-            self.idx = pd.date_range("1/1/2000", freq="T", periods=N)
+            self.idx = pd.date_range("1/1/2000", freq="min", periods=N)
         elif index_type == "Int64Index":
             self.idx = pd.Index(range(N), dtype="int64")
         elif index_type == "PeriodIndex":
-            self.idx = pd.period_range("1/1/2000", freq="T", periods=N)
+            self.idx = pd.period_range("1/1/2000", freq="min", periods=N)
         elif index_type == "RangeIndex":
             self.idx = pd.RangeIndex(start=0, stop=N)
         elif index_type == "IntervalIndex":
diff --git a/asv_bench/benchmarks/index_object.py b/asv_bench/benchmarks/index_object.py
index bdc8a6a7aa1df..2d8014570466e 100644
--- a/asv_bench/benchmarks/index_object.py
+++ b/asv_bench/benchmarks/index_object.py
@@ -25,7 +25,7 @@ class SetOperations:
 
     def setup(self, index_structure, dtype, method):
         N = 10**5
-        dates_left = date_range("1/1/2000", periods=N, freq="T")
+        dates_left = date_range("1/1/2000", periods=N, freq="min")
         fmt = "%Y-%m-%d %H:%M:%S"
         date_str_left = Index(dates_left.strftime(fmt))
         int_left = Index(np.arange(N))
diff --git a/asv_bench/benchmarks/io/json.py b/asv_bench/benchmarks/io/json.py
index 9eaffddd8b87f..bebf6ee993aba 100644
--- a/asv_bench/benchmarks/io/json.py
+++ b/asv_bench/benchmarks/io/json.py
@@ -290,7 +290,7 @@ def time_float_longint_str_lines(self):
 class ToJSONMem:
     def setup_cache(self):
         df = DataFrame([[1]])
-        df2 = DataFrame(range(8), date_range("1/1/2000", periods=8, freq="T"))
+        df2 = DataFrame(range(8), date_range("1/1/2000", periods=8, freq="min"))
         frames = {"int": df, "float": df.astype(float), "datetime": df2}
 
         return frames
diff --git a/asv_bench/benchmarks/join_merge.py b/asv_bench/benchmarks/join_merge.py
index 4f325335829af..54bcdb0fa2843 100644
--- a/asv_bench/benchmarks/join_merge.py
+++ b/asv_bench/benchmarks/join_merge.py
@@ -212,7 +212,7 @@ class JoinNonUnique:
     # outer join of non-unique
     # GH 6329
     def setup(self):
-        date_index = date_range("01-Jan-2013", "23-Jan-2013", freq="T")
+        date_index = date_range("01-Jan-2013", "23-Jan-2013", freq="min")
         daily_dates = date_index.to_period("D").to_timestamp("S", "S")
         self.fracofday = date_index.values - daily_dates.values
         self.fracofday = self.fracofday.astype("timedelta64[ns]")
@@ -338,7 +338,7 @@ class MergeDatetime:
     def setup(self, units, tz):
         unit_left, unit_right = units
         N = 10_000
-        keys = Series(date_range("2012-01-01", freq="T", periods=N, tz=tz))
+        keys = Series(date_range("2012-01-01", freq="min", periods=N, tz=tz))
         self.left = DataFrame(
             {
                 "key": keys.sample(N * 10, replace=True).dt.as_unit(unit_left),
diff --git a/asv_bench/benchmarks/sparse.py b/asv_bench/benchmarks/sparse.py
index c8a9a9e6e9176..22a5511e4c678 100644
--- a/asv_bench/benchmarks/sparse.py
+++ b/asv_bench/benchmarks/sparse.py
@@ -22,7 +22,7 @@ class SparseSeriesToFrame:
     def setup(self):
         K = 50
         N = 50001
-        rng = date_range("1/1/2000", periods=N, freq="T")
+        rng = date_range("1/1/2000", periods=N, freq="min")
         self.series = {}
         for i in range(1, K):
             data = np.random.randn(N)[:-i]
diff --git a/asv_bench/benchmarks/timeseries.py b/asv_bench/benchmarks/timeseries.py
index 1253fefde2d5f..be25c042b128a 100644
--- a/asv_bench/benchmarks/timeseries.py
+++ b/asv_bench/benchmarks/timeseries.py
@@ -116,7 +116,7 @@ def time_infer_freq(self, freq):
 class TimeDatetimeConverter:
     def setup(self):
         N = 100000
-        self.rng = date_range(start="1/1/2000", periods=N, freq="T")
+        self.rng = date_range(start="1/1/2000", periods=N, freq="min")
 
     def time_convert(self):
         DatetimeConverter.convert(self.rng, None, None)
@@ -129,9 +129,9 @@ class Iteration:
     def setup(self, time_index):
         N = 10**6
         if time_index is timedelta_range:
-            self.idx = time_index(start=0, freq="T", periods=N)
+            self.idx = time_index(start=0, freq="min", periods=N)
         else:
-            self.idx = time_index(start="20140101", freq="T", periods=N)
+            self.idx = time_index(start="20140101", freq="min", periods=N)
         self.exit = 10000
 
     def time_iter(self, time_index):
@@ -149,7 +149,7 @@ class ResampleDataFrame:
     param_names = ["method"]
 
     def setup(self, method):
-        rng = date_range(start="20130101", periods=100000, freq="50L")
+        rng = date_range(start="20130101", periods=100000, freq="50ms")
         df = DataFrame(np.random.randn(100000, 2), index=rng)
         self.resample = getattr(df.resample("1s"), method)
 
@@ -163,8 +163,8 @@ class ResampleSeries:
 
     def setup(self, index, freq, method):
         indexes = {
-            "period": period_range(start="1/1/2000", end="1/1/2001", freq="T"),
-            "datetime": date_range(start="1/1/2000", end="1/1/2001", freq="T"),
+            "period": period_range(start="1/1/2000", end="1/1/2001", freq="min"),
+            "datetime": date_range(start="1/1/2000", end="1/1/2001", freq="min"),
         }
         idx = indexes[index]
         ts = Series(np.random.randn(len(idx)), index=idx)
@@ -270,7 +270,7 @@ class DatetimeAccessor:
 
     def setup(self, tz):
         N = 100000
-        self.series = Series(date_range(start="1/1/2000", periods=N, freq="T", tz=tz))
+        self.series = Series(date_range(start="1/1/2000", periods=N, freq="min", tz=tz))
 
     def time_dt_accessor(self, tz):
         self.series.dt
diff --git a/asv_bench/benchmarks/tslibs/timestamp.py b/asv_bench/benchmarks/tslibs/timestamp.py
index d7706a39dfae5..082220ee0dff2 100644
--- a/asv_bench/benchmarks/tslibs/timestamp.py
+++ b/asv_bench/benchmarks/tslibs/timestamp.py
@@ -136,10 +136,10 @@ def time_to_julian_date(self, tz):
         self.ts.to_julian_date()
 
     def time_floor(self, tz):
-        self.ts.floor("5T")
+        self.ts.floor("5min")
 
     def time_ceil(self, tz):
-        self.ts.ceil("5T")
+        self.ts.ceil("5min")
 
 
 class TimestampAcrossDst:
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index 2f88403493711..c1a6ad469b403 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -181,9 +181,9 @@ def to_timedelta(
             stacklevel=find_stack_level(),
         )
         if unit.lower() == "t":
-            unit = unit.replace(unit, "min")
+            unit = unit.replace(unit, "min")  # type: ignore[assignment]
         else:
-            unit = unit.replace(unit, "ms")
+            unit = unit.replace(unit, "ms")  # type: ignore[assignment]
 
     if unit is not None:
         unit = parse_timedelta_unit(unit)

From 317718a306c646aad69538eab53cabd853eb21ab Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Thu, 27 Jul 2023 09:05:29 +0200
Subject: [PATCH 12/31]  correct docstrings

---
 pandas/_libs/tslibs/nattype.pyx    | 32 ++++++++++++++--------------
 pandas/_libs/tslibs/timestamps.pyx | 34 +++++++++++++++---------------
 pandas/core/arrays/datetimelike.py |  2 +-
 pandas/core/generic.py             | 12 +++++------
 pandas/core/groupby/groupby.py     |  8 +++----
 5 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/pandas/_libs/tslibs/nattype.pyx b/pandas/_libs/tslibs/nattype.pyx
index 09e38e3a979b2..9ec4fb8a1c835 100644
--- a/pandas/_libs/tslibs/nattype.pyx
+++ b/pandas/_libs/tslibs/nattype.pyx
@@ -996,23 +996,23 @@ timedelta}, default 'raise'
         >>> ts.round(freq='H') # hour
         Timestamp('2020-03-14 16:00:00')
 
-        >>> ts.round(freq='T') # minute
+        >>> ts.round(freq='min') # minute
         Timestamp('2020-03-14 15:33:00')
 
         >>> ts.round(freq='S') # seconds
         Timestamp('2020-03-14 15:32:52')
 
-        >>> ts.round(freq='L') # milliseconds
+        >>> ts.round(freq='ms') # milliseconds
         Timestamp('2020-03-14 15:32:52.193000')
 
-        ``freq`` can also be a multiple of a single unit, like '5T' (i.e.  5 minutes):
+        ``freq`` can also be a multiple of a single unit, like '5min' (i.e.  5 minutes):
 
-        >>> ts.round(freq='5T')
+        >>> ts.round(freq='5min')
         Timestamp('2020-03-14 15:35:00')
 
-        or a combination of multiple units, like '1H30T' (i.e. 1 hour and 30 minutes):
+        or a combination of multiple units, like '1H30min' (i.e. 1 hour and 30 minutes):
 
-        >>> ts.round(freq='1H30T')
+        >>> ts.round(freq='1H30min')
         Timestamp('2020-03-14 15:00:00')
 
         Analogous for ``pd.NaT``:
@@ -1085,7 +1085,7 @@ timedelta}, default 'raise'
         >>> ts.floor(freq='H') # hour
         Timestamp('2020-03-14 15:00:00')
 
-        >>> ts.floor(freq='T') # minute
+        >>> ts.floor(freq='min') # minute
         Timestamp('2020-03-14 15:32:00')
 
         >>> ts.floor(freq='S') # seconds
@@ -1094,14 +1094,14 @@ timedelta}, default 'raise'
         >>> ts.floor(freq='N') # nanoseconds
         Timestamp('2020-03-14 15:32:52.192548651')
 
-        ``freq`` can also be a multiple of a single unit, like '5T' (i.e.  5 minutes):
+        ``freq`` can also be a multiple of a single unit, like '5min' (i.e.  5 minutes):
 
-        >>> ts.floor(freq='5T')
+        >>> ts.floor(freq='5min')
         Timestamp('2020-03-14 15:30:00')
 
-        or a combination of multiple units, like '1H30T' (i.e. 1 hour and 30 minutes):
+        or a combination of multiple units, like '1H30min' (i.e. 1 hour and 30 minutes):
 
-        >>> ts.floor(freq='1H30T')
+        >>> ts.floor(freq='1H30min')
         Timestamp('2020-03-14 15:00:00')
 
         Analogous for ``pd.NaT``:
@@ -1174,7 +1174,7 @@ timedelta}, default 'raise'
         >>> ts.ceil(freq='H') # hour
         Timestamp('2020-03-14 16:00:00')
 
-        >>> ts.ceil(freq='T') # minute
+        >>> ts.ceil(freq='min') # minute
         Timestamp('2020-03-14 15:33:00')
 
         >>> ts.ceil(freq='S') # seconds
@@ -1183,14 +1183,14 @@ timedelta}, default 'raise'
         >>> ts.ceil(freq='U') # microseconds
         Timestamp('2020-03-14 15:32:52.192549')
 
-        ``freq`` can also be a multiple of a single unit, like '5T' (i.e.  5 minutes):
+        ``freq`` can also be a multiple of a single unit, like '5min' (i.e.  5 minutes):
 
-        >>> ts.ceil(freq='5T')
+        >>> ts.ceil(freq='5min')
         Timestamp('2020-03-14 15:35:00')
 
-        or a combination of multiple units, like '1H30T' (i.e. 1 hour and 30 minutes):
+        or a combination of multiple units, like '1H30min' (i.e. 1 hour and 30 minutes):
 
-        >>> ts.ceil(freq='1H30T')
+        >>> ts.ceil(freq='1H30min')
         Timestamp('2020-03-14 16:30:00')
 
         Analogous for ``pd.NaT``:
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index 844fc8f0ed187..794ef2a5a9112 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -994,7 +994,7 @@ cdef class _Timestamp(ABCTimestamp):
 
         Parameters
         ----------
-        sep : str, default 'T'
+        sep : str, default 'min'
             String used as the separator between the date and time.
 
         timespec : str, default 'auto'
@@ -1997,23 +1997,23 @@ timedelta}, default 'raise'
         >>> ts.round(freq='H') # hour
         Timestamp('2020-03-14 16:00:00')
 
-        >>> ts.round(freq='T') # minute
+        >>> ts.round(freq='min') # minute
         Timestamp('2020-03-14 15:33:00')
 
         >>> ts.round(freq='S') # seconds
         Timestamp('2020-03-14 15:32:52')
 
-        >>> ts.round(freq='L') # milliseconds
+        >>> ts.round(freq='ms') # milliseconds
         Timestamp('2020-03-14 15:32:52.193000')
 
-        ``freq`` can also be a multiple of a single unit, like '5T' (i.e.  5 minutes):
+        ``freq`` can also be a multiple of a single unit, like '5min' (i.e.  5 minutes):
 
-        >>> ts.round(freq='5T')
+        >>> ts.round(freq='5min')
         Timestamp('2020-03-14 15:35:00')
 
-        or a combination of multiple units, like '1H30T' (i.e. 1 hour and 30 minutes):
+        or a combination of multiple units, like '1H30min' (i.e. 1 hour and 30 minutes):
 
-        >>> ts.round(freq='1H30T')
+        >>> ts.round(freq='1H30min')
         Timestamp('2020-03-14 15:00:00')
 
         Analogous for ``pd.NaT``:
@@ -2088,7 +2088,7 @@ timedelta}, default 'raise'
         >>> ts.floor(freq='H') # hour
         Timestamp('2020-03-14 15:00:00')
 
-        >>> ts.floor(freq='T') # minute
+        >>> ts.floor(freq='min') # minute
         Timestamp('2020-03-14 15:32:00')
 
         >>> ts.floor(freq='S') # seconds
@@ -2097,14 +2097,14 @@ timedelta}, default 'raise'
         >>> ts.floor(freq='N') # nanoseconds
         Timestamp('2020-03-14 15:32:52.192548651')
 
-        ``freq`` can also be a multiple of a single unit, like '5T' (i.e.  5 minutes):
+        ``freq`` can also be a multiple of a single unit, like '5min' (i.e.  5 minutes):
 
-        >>> ts.floor(freq='5T')
+        >>> ts.floor(freq='5min')
         Timestamp('2020-03-14 15:30:00')
 
-        or a combination of multiple units, like '1H30T' (i.e. 1 hour and 30 minutes):
+        or a combination of multiple units, like '1H30min' (i.e. 1 hour and 30 minutes):
 
-        >>> ts.floor(freq='1H30T')
+        >>> ts.floor(freq='1H30min')
         Timestamp('2020-03-14 15:00:00')
 
         Analogous for ``pd.NaT``:
@@ -2177,7 +2177,7 @@ timedelta}, default 'raise'
         >>> ts.ceil(freq='H') # hour
         Timestamp('2020-03-14 16:00:00')
 
-        >>> ts.ceil(freq='T') # minute
+        >>> ts.ceil(freq='min') # minute
         Timestamp('2020-03-14 15:33:00')
 
         >>> ts.ceil(freq='S') # seconds
@@ -2186,14 +2186,14 @@ timedelta}, default 'raise'
         >>> ts.ceil(freq='U') # microseconds
         Timestamp('2020-03-14 15:32:52.192549')
 
-        ``freq`` can also be a multiple of a single unit, like '5T' (i.e.  5 minutes):
+        ``freq`` can also be a multiple of a single unit, like '5min' (i.e.  5 minutes):
 
-        >>> ts.ceil(freq='5T')
+        >>> ts.ceil(freq='5min')
         Timestamp('2020-03-14 15:35:00')
 
-        or a combination of multiple units, like '1H30T' (i.e. 1 hour and 30 minutes):
+        or a combination of multiple units, like '1H30min' (i.e. 1 hour and 30 minutes):
 
-        >>> ts.ceil(freq='1H30T')
+        >>> ts.ceil(freq='1H30min')
         Timestamp('2020-03-14 16:30:00')
 
         Analogous for ``pd.NaT``:
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index e11878dace88e..b4945b0ec1770 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -1808,7 +1808,7 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
     >>> rng
     DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
                    '2018-01-01 12:01:00'],
-                  dtype='datetime64[ns]', freq='T')
+                  dtype='datetime64[ns]', freq='min')
     """
 
 _round_example = """>>> rng.round('H')
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 9d09665b15be9..3bba8e32c228e 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -8707,7 +8707,7 @@ def asfreq(
         --------
         Start by creating a series with 4 one minute timestamps.
 
-        >>> index = pd.date_range('1/1/2000', periods=4, freq='T')
+        >>> index = pd.date_range('1/1/2000', periods=4, freq='min')
         >>> series = pd.Series([0.0, None, 2.0, 3.0], index=index)
         >>> df = pd.DataFrame({{'s': series}})
         >>> df
@@ -9019,7 +9019,7 @@ def resample(
         --------
         Start by creating a series with 9 one minute timestamps.
 
-        >>> index = pd.date_range('1/1/2000', periods=9, freq='T')
+        >>> index = pd.date_range('1/1/2000', periods=9, freq='min')
         >>> series = pd.Series(range(9), index=index)
         >>> series
         2000-01-01 00:00:00    0
@@ -9036,7 +9036,7 @@ def resample(
         Downsample the series into 3 minute bins and sum the values
         of the timestamps falling into a bin.
 
-        >>> series.resample('3T').sum()
+        >>> series.resample('3min').sum()
         2000-01-01 00:00:00     3
         2000-01-01 00:03:00    12
         2000-01-01 00:06:00    21
@@ -9052,7 +9052,7 @@ def resample(
         To include this value close the right side of the bin interval as
         illustrated in the example below this one.
 
-        >>> series.resample('3T', label='right').sum()
+        >>> series.resample('3min', label='right').sum()
         2000-01-01 00:03:00     3
         2000-01-01 00:06:00    12
         2000-01-01 00:09:00    21
@@ -9061,7 +9061,7 @@ def resample(
         Downsample the series into 3 minute bins as above, but close the right
         side of the bin interval.
 
-        >>> series.resample('3T', label='right', closed='right').sum()
+        >>> series.resample('3min', label='right', closed='right').sum()
         2000-01-01 00:00:00     0
         2000-01-01 00:03:00     6
         2000-01-01 00:06:00    15
@@ -9105,7 +9105,7 @@ def resample(
         >>> def custom_resampler(arraylike):
         ...     return np.sum(arraylike) + 5
         ...
-        >>> series.resample('3T').apply(custom_resampler)
+        >>> series.resample('3min').apply(custom_resampler)
         2000-01-01 00:00:00     8
         2000-01-01 00:03:00    17
         2000-01-01 00:06:00    26
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 8d8302826462e..a64e1966ac238 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -3519,7 +3519,7 @@ def resample(self, rule, *args, **kwargs):
 
         Examples
         --------
-        >>> idx = pd.date_range('1/1/2000', periods=4, freq='T')
+        >>> idx = pd.date_range('1/1/2000', periods=4, freq='min')
         >>> df = pd.DataFrame(data=4 * [range(2)],
         ...                   index=idx,
         ...                   columns=['a', 'b'])
@@ -3534,7 +3534,7 @@ def resample(self, rule, *args, **kwargs):
         Downsample the DataFrame into 3 minute bins and sum the values of
         the timestamps falling into a bin.
 
-        >>> df.groupby('a').resample('3T').sum()
+        >>> df.groupby('a').resample('3min').sum()
                                  a  b
         a
         0   2000-01-01 00:00:00  0  2
@@ -3566,7 +3566,7 @@ def resample(self, rule, *args, **kwargs):
         Downsample the series into 3 minute bins as above, but close the right
         side of the bin interval.
 
-        >>> df.groupby('a').resample('3T', closed='right').sum()
+        >>> df.groupby('a').resample('3min', closed='right').sum()
                                  a  b
         a
         0   1999-12-31 23:57:00  0  1
@@ -3577,7 +3577,7 @@ def resample(self, rule, *args, **kwargs):
         the bin interval, but label each bin using the right edge instead of
         the left.
 
-        >>> df.groupby('a').resample('3T', closed='right', label='right').sum()
+        >>> df.groupby('a').resample('3min', closed='right', label='right').sum()
                                  a  b
         a
         0   2000-01-01 00:00:00  0  1

From 99a0cf9c73f73ea0598e836bd5f0a9a9170f15c6 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Fri, 28 Jul 2023 10:45:48 +0200
Subject: [PATCH 13/31] deprecate abbrevs U, N add dict depr_abbrevs and fix
 tests

---
 pandas/_libs/tslibs/dtypes.pxd                |  1 +
 pandas/_libs/tslibs/dtypes.pyi                |  1 +
 pandas/_libs/tslibs/dtypes.pyx                | 23 ++++++++++++++----
 pandas/_libs/tslibs/offsets.pyx               | 10 ++++----
 pandas/_libs/tslibs/timedeltas.pyx            |  4 ++--
 pandas/core/arrays/arrow/array.py             |  4 ++--
 pandas/core/tools/timedeltas.py               | 14 +++++------
 .../datetimes/methods/test_to_period.py       |  6 ++---
 .../indexes/datetimes/test_constructors.py    |  2 +-
 .../tests/indexes/period/test_constructors.py | 14 +++++------
 pandas/tests/scalar/period/test_period.py     | 24 +++++++++----------
 .../tests/scalar/timedelta/test_timedelta.py  |  4 ----
 12 files changed, 59 insertions(+), 48 deletions(-)

diff --git a/pandas/_libs/tslibs/dtypes.pxd b/pandas/_libs/tslibs/dtypes.pxd
index a8dd88c763c14..37c149343e40f 100644
--- a/pandas/_libs/tslibs/dtypes.pxd
+++ b/pandas/_libs/tslibs/dtypes.pxd
@@ -11,6 +11,7 @@ cpdef int64_t periods_per_second(NPY_DATETIMEUNIT reso) except? -1
 cpdef NPY_DATETIMEUNIT get_supported_reso(NPY_DATETIMEUNIT reso)
 cpdef bint is_supported_unit(NPY_DATETIMEUNIT reso)
 
+cdef dict c_DEPR_ABBREVS
 cdef dict attrname_to_abbrevs
 cdef dict npy_unit_to_attrname
 cdef dict attrname_to_npy_unit
diff --git a/pandas/_libs/tslibs/dtypes.pyi b/pandas/_libs/tslibs/dtypes.pyi
index bea3e18273318..c61e6905a45e3 100644
--- a/pandas/_libs/tslibs/dtypes.pyi
+++ b/pandas/_libs/tslibs/dtypes.pyi
@@ -4,6 +4,7 @@ from enum import Enum
 #  are imported in tests.
 _attrname_to_abbrevs: dict[str, str]
 _period_code_map: dict[str, int]
+DEPR_ABBREVS: dict[str, str]
 
 def periods_per_day(reso: int) -> int: ...
 def periods_per_second(reso: int) -> int: ...
diff --git a/pandas/_libs/tslibs/dtypes.pyx b/pandas/_libs/tslibs/dtypes.pyx
index f9559249a084d..a1018677307ed 100644
--- a/pandas/_libs/tslibs/dtypes.pyx
+++ b/pandas/_libs/tslibs/dtypes.pyx
@@ -147,8 +147,8 @@ _period_code_map = {
     "min": PeriodDtypeCode.T,        # Minutely
     "S": PeriodDtypeCode.S,        # Secondly
     "ms": PeriodDtypeCode.L,       # Millisecondly
-    "U": PeriodDtypeCode.U,       # Microsecondly
-    "N": PeriodDtypeCode.N,       # Nanosecondly
+    "us": PeriodDtypeCode.U,       # Microsecondly
+    "ns": PeriodDtypeCode.N,       # Nanosecondly
 }
 
 _reverse_period_code_map = {
@@ -180,12 +180,25 @@ _attrname_to_abbrevs = {
     "minute": "min",
     "second": "S",
     "millisecond": "ms",
-    "microsecond": "U",
-    "nanosecond": "N",
+    "microsecond": "us",
+    "nanosecond": "ns",
 }
 cdef dict attrname_to_abbrevs = _attrname_to_abbrevs
 cdef dict _abbrev_to_attrnames = {v: k for k, v in attrname_to_abbrevs.items()}
 
+# Map deprecated resolution abbreviations to correct resolution abbreviations
+DEPR_ABBREVS: dict[str, str]= {
+    "T": "min",
+    "t": "min",
+    "L": "ms",
+    "l": "ms",
+    "U": "us",
+    "u": "us",
+    "N": "ns",
+    "n": "ns",
+}
+cdef dict c_DEPR_ABBREVS = DEPR_ABBREVS
+
 
 class FreqGroup(Enum):
     # Mirrors c_FreqGroup in the .pxd file
@@ -276,7 +289,7 @@ class Resolution(Enum):
         True
         """
         try:
-            if freq in {"T", "L"}:
+            if freq in DEPR_ABBREVS:
                 warnings.warn(
                     f"Code freq={freq} is deprecated "
                     "and will be removed in a future version.",
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index 85d985c7b888c..e522b8873d5d8 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -1125,14 +1125,14 @@ cdef class Milli(Tick):
 
 cdef class Micro(Tick):
     _nanos_inc = 1000
-    _prefix = "U"
+    _prefix = "us"
     _period_dtype_code = PeriodDtypeCode.U
     _creso = NPY_DATETIMEUNIT.NPY_FR_us
 
 
 cdef class Nano(Tick):
     _nanos_inc = 1
-    _prefix = "N"
+    _prefix = "ns"
     _period_dtype_code = PeriodDtypeCode.N
     _creso = NPY_DATETIMEUNIT.NPY_FR_ns
 
@@ -4296,8 +4296,8 @@ _lite_rule_alias = {
     "Min": "min",
     "min": "min",
     "ms": "ms",
-    "us": "U",
-    "ns": "N",
+    "us": "us",
+    "ns": "ns",
 }
 
 _dont_uppercase = {"MS", "ms"}
@@ -4417,7 +4417,7 @@ cpdef to_offset(freq):
                 if not stride:
                     stride = 1
 
-                if prefix in {"D", "H", "min", "S", "ms", "U", "N"}:
+                if prefix in {"D", "H", "min", "S", "ms", "us", "ns"}:
                     # 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
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 90bf763e3dbb3..1b8dfe99f7ffc 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1466,9 +1466,9 @@ cdef class _Timedelta(timedelta):
         """
         self._ensure_components()
         if self._ns:
-            return "N"
+            return "ns"
         elif self._us:
-            return "U"
+            return "us"
         elif self._ms:
             return "ms"
         elif self._s:
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 5042c82a1153d..d9ac3b6d541c6 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -2476,8 +2476,8 @@ def _round_temporally(
             "min": "minute",
             "S": "second",
             "ms": "millisecond",
-            "U": "microsecond",
-            "N": "nanosecond",
+            "us": "microsecond",
+            "ns": "nanosecond",
         }
         unit = pa_supported_unit.get(offset._prefix, None)
         if unit is None:
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index c1a6ad469b403..cf2cfdccfbf3f 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -16,6 +16,7 @@
     NaT,
     NaTType,
 )
+from pandas._libs.tslibs.dtypes import DEPR_ABBREVS
 from pandas._libs.tslibs.timedeltas import (
     Timedelta,
     parse_timedelta_unit,
@@ -121,7 +122,8 @@ def to_timedelta(
         Must not be specified when `arg` context strings and ``errors="raise"``.
 
         .. deprecated:: 2.1.0
-            Units 'T' and 'L' are deprecated and will be removed in a future version.
+            Units 'T', 'L', 'U' and 'N' are deprecated and will be removed
+            in a future version.
 
     errors : {'ignore', 'raise', 'coerce'}, default 'raise'
         - If 'raise', then invalid parsing will raise an exception.
@@ -174,16 +176,14 @@ def to_timedelta(
     TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'],
                    dtype='timedelta64[ns]', freq=None)
     """
-    if unit in {"T", "t", "L", "l"}:
+    if unit in DEPR_ABBREVS:
         warnings.warn(
-            f"Unit '{unit}' is deprecated and will be removed in a future version.",
+            f"Unit '{unit}' is deprecated and will be removed in a future version. "
+            f", please use '{DEPR_ABBREVS.get(unit)}' instead of '{unit}'.",
             FutureWarning,
             stacklevel=find_stack_level(),
         )
-        if unit.lower() == "t":
-            unit = unit.replace(unit, "min")  # type: ignore[assignment]
-        else:
-            unit = unit.replace(unit, "ms")  # type: ignore[assignment]
+        unit = DEPR_ABBREVS.get(unit)  # type: ignore[assignment]
 
     if unit is not None:
         unit = parse_timedelta_unit(unit)
diff --git a/pandas/tests/indexes/datetimes/methods/test_to_period.py b/pandas/tests/indexes/datetimes/methods/test_to_period.py
index 06b3d33b67a5b..654c9e07562ec 100644
--- a/pandas/tests/indexes/datetimes/methods/test_to_period.py
+++ b/pandas/tests/indexes/datetimes/methods/test_to_period.py
@@ -142,10 +142,10 @@ def test_to_period_microsecond(self):
 
         with tm.assert_produces_warning(UserWarning):
             # warning that timezone info will be lost
-            period = index.to_period(freq="U")
+            period = index.to_period(freq="us")
         assert 2 == len(period)
-        assert period[0] == Period("2007-01-01 10:11:12.123456Z", "U")
-        assert period[1] == Period("2007-01-01 10:11:13.789123Z", "U")
+        assert period[0] == Period("2007-01-01 10:11:12.123456Z", "us")
+        assert period[1] == Period("2007-01-01 10:11:13.789123Z", "us")
 
     @pytest.mark.parametrize(
         "tz",
diff --git a/pandas/tests/indexes/datetimes/test_constructors.py b/pandas/tests/indexes/datetimes/test_constructors.py
index f384281a14b1b..41922cae14fdc 100644
--- a/pandas/tests/indexes/datetimes/test_constructors.py
+++ b/pandas/tests/indexes/datetimes/test_constructors.py
@@ -1034,7 +1034,7 @@ def test_constructor_int64_nocopy(self):
         assert (index.asi8[50:100] != -1).all()
 
     @pytest.mark.parametrize(
-        "freq", ["M", "Q", "A", "D", "B", "BH", "min", "S", "ms", "U", "H", "N", "C"]
+        "freq", ["M", "Q", "A", "D", "B", "BH", "min", "S", "ms", "us", "H", "ns", "C"]
     )
     def test_from_freq_recreate_from_data(self, freq):
         org = date_range(start="2001/02/01 09:00", freq=freq, periods=1)
diff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py
index de2a18f126134..50e5a261974b2 100644
--- a/pandas/tests/indexes/period/test_constructors.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -110,16 +110,16 @@ def test_constructor_U(self):
 
     def test_constructor_nano(self):
         idx = period_range(
-            start=Period(ordinal=1, freq="N"), end=Period(ordinal=4, freq="N"), freq="N"
+            start=Period(ordinal=1, freq="ns"), end=Period(ordinal=4, freq="ns"), freq="ns"
         )
         exp = PeriodIndex(
             [
-                Period(ordinal=1, freq="N"),
-                Period(ordinal=2, freq="N"),
-                Period(ordinal=3, freq="N"),
-                Period(ordinal=4, freq="N"),
+                Period(ordinal=1, freq="ns"),
+                Period(ordinal=2, freq="ns"),
+                Period(ordinal=3, freq="ns"),
+                Period(ordinal=4, freq="ns"),
             ],
-            freq="N",
+            freq="ns",
         )
         tm.assert_index_equal(idx, exp)
 
@@ -506,7 +506,7 @@ def test_constructor(self):
             Period("2006-12-31", ("w", 1))
 
     @pytest.mark.parametrize(
-        "freq", ["M", "Q", "A", "D", "B", "min", "S", "ms", "U", "N", "H"]
+        "freq", ["M", "Q", "A", "D", "B", "min", "S", "ms", "us", "ns", "H"]
     )
     @pytest.mark.filterwarnings(
         r"ignore:Period with BDay freq is deprecated:FutureWarning"
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index ea358cd8f57e4..0acc704ff7a29 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -109,10 +109,10 @@ def test_construction(self):
         assert i1 == expected
 
         i1 = Period("2007-01-01 09:00:00.00101")
-        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="U")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="us")
         assert i1 == expected
 
-        expected = Period("2007-01-01 09:00:00.00101", freq="U")
+        expected = Period("2007-01-01 09:00:00.00101", freq="us")
         assert i1 == expected
 
         msg = "Must supply freq for ordinal value"
@@ -289,10 +289,10 @@ def test_period_constructor_offsets(self):
         assert i1 == expected
 
         i1 = Period("2007-01-01 09:00:00.00101")
-        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="U")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="us")
         assert i1 == expected
 
-        expected = Period("2007-01-01 09:00:00.00101", freq="U")
+        expected = Period("2007-01-01 09:00:00.00101", freq="us")
         assert i1 == expected
 
     def test_invalid_arguments(self):
@@ -357,10 +357,10 @@ def test_constructor_infer_freq(self):
         # We see that there are 6 digits after the decimal, so get microsecond
         #  even though they are all zeros.
         p = Period("2007-01-01 07:10:15.123000")
-        assert p.freq == "U"
+        assert p.freq == "us"
 
         p = Period("2007-01-01 07:10:15.123400")
-        assert p.freq == "U"
+        assert p.freq == "us"
 
     def test_multiples(self):
         result1 = Period("1989", freq="2A")
@@ -724,12 +724,12 @@ def test_to_timestamp_microsecond(self, ts, expected, freq):
             ("2000-12-15", None, "2000-12-15", "D"),
             (
                 "2000-12-15 13:45:26.123456789",
-                "N",
+                "ns",
                 "2000-12-15 13:45:26.123456789",
-                "N",
+                "ns",
             ),
-            ("2000-12-15 13:45:26.123456789", "U", "2000-12-15 13:45:26.123456", "U"),
-            ("2000-12-15 13:45:26.123456", None, "2000-12-15 13:45:26.123456", "U"),
+            ("2000-12-15 13:45:26.123456789", "us", "2000-12-15 13:45:26.123456", "us"),
+            ("2000-12-15 13:45:26.123456", None, "2000-12-15 13:45:26.123456", "us"),
             ("2000-12-15 13:45:26.123456789", "ms", "2000-12-15 13:45:26.123", "ms"),
             ("2000-12-15 13:45:26.123", None, "2000-12-15 13:45:26.123", "ms"),
             ("2000-12-15 13:45:26", "S", "2000-12-15 13:45:26", "S"),
@@ -815,8 +815,8 @@ def test_period_deprecated_freq(self):
             "min": ["minute", "MINUTE", "MINUTELY", "minutely"],
             "S": ["sec", "SEC", "SECOND", "SECONDLY", "second"],
             "ms": ["MILLISECOND", "MILLISECONDLY", "millisecond"],
-            "U": ["MICROSECOND", "MICROSECONDLY", "microsecond"],
-            "N": ["NANOSECOND", "NANOSECONDLY", "nanosecond"],
+            "us": ["MICROSECOND", "MICROSECONDLY", "microsecond"],
+            "ns": ["NANOSECOND", "NANOSECONDLY", "nanosecond"],
         }
 
         msg = INVALID_FREQ_ERR_MSG
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index a43c96abbb0c1..341533d53fe03 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -540,13 +540,11 @@ def test_nat_converters(self):
                 "microsecond",
                 "micro",
                 "micros",
-                "u",
                 "US",
                 "Microseconds",
                 "Microsecond",
                 "Micro",
                 "Micros",
-                "U",
             ]
         ]
         + [
@@ -557,13 +555,11 @@ def test_nat_converters(self):
                 "nanosecond",
                 "nano",
                 "nanos",
-                "n",
                 "NS",
                 "Nanoseconds",
                 "Nanosecond",
                 "Nano",
                 "Nanos",
-                "N",
             ]
         ],
     )

From a13a041e47d38f77feec994fb7582babf63c5502 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Mon, 31 Jul 2023 12:37:58 +0200
Subject: [PATCH 14/31] correct get_freq and fix tests

---
 pandas/tests/dtypes/test_common.py            |  4 +--
 pandas/tests/dtypes/test_dtypes.py            | 10 +++----
 pandas/tests/extension/test_arrow.py          |  2 +-
 .../indexes/datetimes/test_date_range.py      |  2 +-
 .../tests/indexes/datetimes/test_datetime.py  |  4 +--
 pandas/tests/indexes/datetimes/test_ops.py    |  2 +-
 .../tests/indexes/period/test_resolution.py   |  2 +-
 pandas/tests/indexes/period/test_tools.py     |  4 +--
 .../indexes/timedeltas/test_scalar_compat.py  |  4 +--
 pandas/tests/io/formats/test_format.py        |  8 ++---
 pandas/tests/io/test_parquet.py               |  2 +-
 pandas/tests/resample/test_datetime_index.py  |  4 +--
 pandas/tests/resample/test_timedelta.py       |  2 +-
 pandas/tests/scalar/period/test_asfreq.py     |  2 +-
 .../tests/scalar/timedelta/test_timedelta.py  |  8 ++---
 .../series/accessors/test_dt_accessor.py      |  2 +-
 .../tseries/frequencies/test_freq_code.py     | 30 +++++--------------
 .../tseries/frequencies/test_inference.py     |  6 ++--
 pandas/tests/tseries/offsets/test_offsets.py  |  2 +-
 pandas/tests/tslibs/test_period_asfreq.py     | 22 +++++++-------
 pandas/tests/tslibs/test_to_offset.py         |  4 +--
 pandas/tseries/frequencies.py                 |  4 +--
 22 files changed, 58 insertions(+), 72 deletions(-)

diff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py
index d0a34cedb7dbe..e76d80022a5b8 100644
--- a/pandas/tests/dtypes/test_common.py
+++ b/pandas/tests/dtypes/test_common.py
@@ -93,10 +93,10 @@ def test_categorical_dtype(self):
         [
             "period[D]",
             "period[3M]",
-            "period[U]",
+            "period[us]",
             "Period[D]",
             "Period[3M]",
-            "Period[U]",
+            "Period[us]",
         ],
     )
     def test_period_dtype(self, dtype):
diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py
index f57093c29b733..d760dab75400d 100644
--- a/pandas/tests/dtypes/test_dtypes.py
+++ b/pandas/tests/dtypes/test_dtypes.py
@@ -467,8 +467,8 @@ def test_identity(self):
         assert PeriodDtype("period[3D]") == PeriodDtype("period[3D]")
         assert PeriodDtype("period[3D]") is not PeriodDtype("period[3D]")
 
-        assert PeriodDtype("period[1S1U]") == PeriodDtype("period[1000001U]")
-        assert PeriodDtype("period[1S1U]") is not PeriodDtype("period[1000001U]")
+        assert PeriodDtype("period[1S1us]") == PeriodDtype("period[1000001us]")
+        assert PeriodDtype("period[1S1us]") is not PeriodDtype("period[1000001us]")
 
     def test_compat(self, dtype):
         assert not is_datetime64_ns_dtype(dtype)
@@ -505,9 +505,9 @@ def test_is_dtype(self, dtype):
         assert PeriodDtype.is_dtype("period[D]")
         assert PeriodDtype.is_dtype("period[3D]")
         assert PeriodDtype.is_dtype(PeriodDtype("3D"))
-        assert PeriodDtype.is_dtype("period[U]")
+        assert PeriodDtype.is_dtype("period[us]")
         assert PeriodDtype.is_dtype("period[S]")
-        assert PeriodDtype.is_dtype(PeriodDtype("U"))
+        assert PeriodDtype.is_dtype(PeriodDtype("us"))
         assert PeriodDtype.is_dtype(PeriodDtype("S"))
 
         assert not PeriodDtype.is_dtype("D")
@@ -728,7 +728,7 @@ def test_is_dtype(self, dtype):
 
         assert not IntervalDtype.is_dtype("D")
         assert not IntervalDtype.is_dtype("3D")
-        assert not IntervalDtype.is_dtype("U")
+        assert not IntervalDtype.is_dtype("us")
         assert not IntervalDtype.is_dtype("S")
         assert not IntervalDtype.is_dtype("foo")
         assert not IntervalDtype.is_dtype("IntervalA")
diff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py
index dfecd6da5abb9..1a0319a66cd97 100644
--- a/pandas/tests/extension/test_arrow.py
+++ b/pandas/tests/extension/test_arrow.py
@@ -2662,7 +2662,7 @@ def test_dt_roundlike_unsupported_freq(method):
 @pytest.mark.xfail(
     pa_version_under7p0, reason="Methods not supported for pyarrow < 7.0"
 )
-@pytest.mark.parametrize("freq", ["D", "H", "min", "S", "ms", "U", "N"])
+@pytest.mark.parametrize("freq", ["D", "H", "min", "S", "ms", "us", "ns"])
 @pytest.mark.parametrize("method", ["ceil", "floor", "round"])
 def test_dt_ceil_year_floor(freq, method):
     ser = pd.Series(
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index 0882e4696b62e..96f67dde14fbb 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -123,7 +123,7 @@ def test_date_range_timestamp_equiv_preserve_frequency(self):
 
 
 class TestDateRanges:
-    @pytest.mark.parametrize("freq", ["N", "U", "ms", "min", "S", "H", "D"])
+    @pytest.mark.parametrize("freq", ["ns", "us", "ms", "min", "S", "H", "D"])
     def test_date_range_edges(self, freq):
         # GH#13672
         td = Timedelta(f"1{freq}")
diff --git a/pandas/tests/indexes/datetimes/test_datetime.py b/pandas/tests/indexes/datetimes/test_datetime.py
index af1a94391a353..095a77b84b1f6 100644
--- a/pandas/tests/indexes/datetimes/test_datetime.py
+++ b/pandas/tests/indexes/datetimes/test_datetime.py
@@ -145,8 +145,8 @@ def test_groupby_function_tuple_1677(self):
         assert isinstance(result.index[0], tuple)
 
     def assert_index_parameters(self, index):
-        assert index.freq == "40960N"
-        assert index.inferred_freq == "40960N"
+        assert index.freq == "40960ns"
+        assert index.inferred_freq == "40960ns"
 
     def test_ns_index(self):
         nsamples = 400
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index 5375f22ca6338..a01d3b80924fd 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -28,7 +28,7 @@ class TestDatetimeIndexOps:
             ("min", "minute"),
             ("S", "second"),
             ("ms", "millisecond"),
-            ("U", "microsecond"),
+            ("us", "microsecond"),
         ],
     )
     def test_resolution(self, request, tz_naive_fixture, freq, expected):
diff --git a/pandas/tests/indexes/period/test_resolution.py b/pandas/tests/indexes/period/test_resolution.py
index 09af879ee811e..36f8a1c1bd285 100644
--- a/pandas/tests/indexes/period/test_resolution.py
+++ b/pandas/tests/indexes/period/test_resolution.py
@@ -15,7 +15,7 @@ class TestResolution:
             ("min", "minute"),
             ("S", "second"),
             ("ms", "millisecond"),
-            ("U", "microsecond"),
+            ("us", "microsecond"),
         ],
     )
     def test_resolution(self, freq, expected):
diff --git a/pandas/tests/indexes/period/test_tools.py b/pandas/tests/indexes/period/test_tools.py
index 9a409cc94303d..19f7b9a1b70e2 100644
--- a/pandas/tests/indexes/period/test_tools.py
+++ b/pandas/tests/indexes/period/test_tools.py
@@ -24,8 +24,8 @@ class TestPeriodRepresentation:
             ("min", "1970-01-01"),
             ("S", "1970-01-01"),
             ("ms", "1970-01-01"),
-            ("U", "1970-01-01"),
-            ("N", "1970-01-01"),
+            ("us", "1970-01-01"),
+            ("ns", "1970-01-01"),
             ("M", "1970-01"),
             ("A", 1970),
         ],
diff --git a/pandas/tests/indexes/timedeltas/test_scalar_compat.py b/pandas/tests/indexes/timedeltas/test_scalar_compat.py
index 7bb6f12acd67d..21e6ba9dd3e9b 100644
--- a/pandas/tests/indexes/timedeltas/test_scalar_compat.py
+++ b/pandas/tests/indexes/timedeltas/test_scalar_compat.py
@@ -104,8 +104,8 @@ def test_round(self):
 
         # note that negative times round DOWN! so don't give whole numbers
         for freq, s1, s2 in [
-            ("N", t1, t2),
-            ("U", t1, t2),
+            ("ns", t1, t2),
+            ("us", t1, t2),
             (
                 "ms",
                 t1a,
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 5a5e7e45ee7af..a794e72407b0d 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -3272,7 +3272,7 @@ def test_dates_display(self):
         assert result[1].strip() == "NaT"
         assert result[4].strip() == "2013-01-01 09:00:00.000004"
 
-        x = Series(date_range("20130101 09:00:00", periods=5, freq="N"))
+        x = Series(date_range("20130101 09:00:00", periods=5, freq="ns"))
         x.iloc[1] = np.nan
         result = fmt.Datetime64Formatter(x).get_result()
         assert result[0].strip() == "2013-01-01 09:00:00.000000000"
@@ -3323,7 +3323,7 @@ def test_period_format_and_strftime_default(self):
         assert per.strftime(None)[1] is np.nan  # ...except for NaTs
 
         # Same test with nanoseconds freq
-        per = pd.period_range("2003-01-01 12:01:01.123456789", periods=2, freq="n")
+        per = pd.period_range("2003-01-01 12:01:01.123456789", periods=2, freq="ns")
         formatted = per.format()
         assert (formatted == per.strftime(None)).all()
         assert formatted[0] == "2003-01-01 12:01:01.123456789"
@@ -3339,13 +3339,13 @@ def test_period_custom(self):
         assert formatted[1] == "03 12:01:01 (ms=124 us=124000 ns=124000000)"
 
         # 6 digits
-        per = pd.period_range("2003-01-01 12:01:01.123456", periods=2, freq="u")
+        per = pd.period_range("2003-01-01 12:01:01.123456", periods=2, freq="us")
         formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
         assert formatted[0] == "03 12:01:01 (ms=123 us=123456 ns=123456000)"
         assert formatted[1] == "03 12:01:01 (ms=123 us=123457 ns=123457000)"
 
         # 9 digits
-        per = pd.period_range("2003-01-01 12:01:01.123456789", periods=2, freq="n")
+        per = pd.period_range("2003-01-01 12:01:01.123456789", periods=2, freq="ns")
         formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
         assert formatted[0] == "03 12:01:01 (ms=123 us=123456 ns=123456789)"
         assert formatted[1] == "03 12:01:01 (ms=123 us=123456 ns=123456790)"
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index 0d8afbf220b0c..831a4476dd75a 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -943,7 +943,7 @@ def test_timestamp_nanoseconds(self, pa):
             ver = "2.6"
         else:
             ver = "2.0"
-        df = pd.DataFrame({"a": pd.date_range("2017-01-01", freq="1n", periods=10)})
+        df = pd.DataFrame({"a": pd.date_range("2017-01-01", freq="1ns", periods=10)})
         check_round_trip(df, pa, write_kwargs={"version": ver})
 
     def test_timezone_aware_index(self, request, pa, timezone_aware_date_list):
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 0f5380f22f83b..1fa1531ceca6c 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -1134,12 +1134,12 @@ def test_nanosecond_resample_error():
     # Resampling using pd.tseries.offsets.Nano as period
     start = 1443707890427
     exp_start = 1443707890400
-    indx = date_range(start=pd.to_datetime(start), periods=10, freq="100n")
+    indx = date_range(start=pd.to_datetime(start), periods=10, freq="100ns")
     ts = Series(range(len(indx)), index=indx)
     r = ts.resample(pd.tseries.offsets.Nano(100))
     result = r.agg("mean")
 
-    exp_indx = date_range(start=pd.to_datetime(exp_start), periods=10, freq="100n")
+    exp_indx = date_range(start=pd.to_datetime(exp_start), periods=10, freq="100ns")
     exp = Series(range(len(exp_indx)), index=exp_indx, dtype=float)
 
     tm.assert_series_equal(result, exp)
diff --git a/pandas/tests/resample/test_timedelta.py b/pandas/tests/resample/test_timedelta.py
index f34f954fd4fac..6a9f7a3b2a4ac 100644
--- a/pandas/tests/resample/test_timedelta.py
+++ b/pandas/tests/resample/test_timedelta.py
@@ -155,7 +155,7 @@ def test_resample_with_timedelta_yields_no_empty_groups(duplicates):
     # GH 10603
     df = DataFrame(
         np.random.normal(size=(10000, 4)),
-        index=timedelta_range(start="0s", periods=10000, freq="3906250n"),
+        index=timedelta_range(start="0s", periods=10000, freq="3906250ns"),
     )
     if duplicates:
         # case with non-unique columns
diff --git a/pandas/tests/scalar/period/test_asfreq.py b/pandas/tests/scalar/period/test_asfreq.py
index 166b884d7e46d..51b9b0ec8d2a0 100644
--- a/pandas/tests/scalar/period/test_asfreq.py
+++ b/pandas/tests/scalar/period/test_asfreq.py
@@ -684,7 +684,7 @@ def test_conv_secondly(self):
     def test_conv_microsecond(self):
         # GH#31475 Avoid floating point errors dropping the start_time to
         #  before the beginning of the Period
-        per = Period("2020-01-30 15:57:27.576166", freq="U")
+        per = Period("2020-01-30 15:57:27.576166", freq="us")
         assert per.ordinal == 1580399847576166
 
         start = per.start_time
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index 341533d53fe03..1261270bb8d7b 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -643,12 +643,12 @@ def test_to_numpy_alias(self):
         [
             # This first case has s1, s2 being the same as t1,t2 below
             (
-                "N",
+                "ns",
                 Timedelta("1 days 02:34:56.789123456"),
                 Timedelta("-1 days 02:34:56.789123456"),
             ),
             (
-                "U",
+                "us",
                 Timedelta("1 days 02:34:56.789123000"),
                 Timedelta("-1 days 02:34:56.789123000"),
             ),
@@ -985,8 +985,8 @@ def test_resolution_string(self):
         assert Timedelta(days=1, minutes=6).resolution_string == "min"
         assert Timedelta(days=1, seconds=6).resolution_string == "S"
         assert Timedelta(days=1, milliseconds=6).resolution_string == "ms"
-        assert Timedelta(days=1, microseconds=6).resolution_string == "U"
-        assert Timedelta(days=1, nanoseconds=6).resolution_string == "N"
+        assert Timedelta(days=1, microseconds=6).resolution_string == "us"
+        assert Timedelta(days=1, nanoseconds=6).resolution_string == "ns"
 
     def test_resolution_deprecated(self):
         # GH#21344
diff --git a/pandas/tests/series/accessors/test_dt_accessor.py b/pandas/tests/series/accessors/test_dt_accessor.py
index 3c10c1200b450..f84bd5c60eaa2 100644
--- a/pandas/tests/series/accessors/test_dt_accessor.py
+++ b/pandas/tests/series/accessors/test_dt_accessor.py
@@ -385,7 +385,7 @@ def test_dt_round_tz_nonexistent(self, method, ts_str, freq):
         with pytest.raises(pytz.NonExistentTimeError, match="2018-03-11 02:00:00"):
             getattr(ser.dt, method)(freq, nonexistent="raise")
 
-    @pytest.mark.parametrize("freq", ["ns", "U", "1000U"])
+    @pytest.mark.parametrize("freq", ["ns", "us", "1000us"])
     def test_dt_round_nonnano_higher_resolution_no_op(self, freq):
         # GH 52761
         ser = Series(
diff --git a/pandas/tests/tseries/frequencies/test_freq_code.py b/pandas/tests/tseries/frequencies/test_freq_code.py
index 7f246eca77def..5a90a7776b056 100644
--- a/pandas/tests/tseries/frequencies/test_freq_code.py
+++ b/pandas/tests/tseries/frequencies/test_freq_code.py
@@ -35,33 +35,19 @@ def test_get_to_timestamp_base(freqstr, exp_freqstr):
         ("min", "minute"),
         ("S", "second"),
         ("ms", "millisecond"),
-        ("U", "microsecond"),
-        ("N", "nanosecond"),
+        ("us", "microsecond"),
+        ("ns", "nanosecond"),
     ],
 )
 def test_get_attrname_from_abbrev(freqstr, expected):
-    msg = f"Code freq={freqstr} is deprecated and will be removed in a future version."
+    assert Resolution.get_reso_from_freqstr(freqstr).attrname == expected
 
-    if freqstr in {"T", "L"}:
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            assert Resolution.get_reso_from_freqstr(freqstr).attrname == expected
-    else:
-        assert Resolution.get_reso_from_freqstr(freqstr).attrname == expected
 
-
-@pytest.mark.parametrize("freq", ["D", "H", "min", "S", "ms", "U", "N"])
+@pytest.mark.parametrize("freq", ["D", "H", "min", "S", "ms", "us", "ns"])
 def test_get_freq_roundtrip2(freq):
-    msg = f"Code freq={freq} is deprecated and will be removed in a future version."
-
-    if freq in {"T", "L"}:
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            obj = Resolution.get_reso_from_freqstr(freq)
-            result = _attrname_to_abbrevs[obj.attrname]
-            assert freq == result
-    else:
-        obj = Resolution.get_reso_from_freqstr(freq)
-        result = _attrname_to_abbrevs[obj.attrname]
-        assert freq == result
+    obj = Resolution.get_reso_from_freqstr(freq)
+    result = _attrname_to_abbrevs[obj.attrname]
+    assert freq == result
 
 
 @pytest.mark.parametrize(
@@ -71,7 +57,7 @@ def test_get_freq_roundtrip2(freq):
         ((62.4, "min"), (3744, "S")),
         ((1.04, "H"), (3744, "S")),
         ((1, "D"), (1, "D")),
-        ((0.342931, "H"), (1234551600, "U")),
+        ((0.342931, "H"), (1234551600, "us")),
         ((1.2345, "D"), (106660800, "ms")),
     ],
 )
diff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py
index 3c68c9fd4ef93..f2b5a13b7478c 100644
--- a/pandas/tests/tseries/frequencies/test_inference.py
+++ b/pandas/tests/tseries/frequencies/test_inference.py
@@ -41,8 +41,8 @@
         (timedelta(hours=1), "H"),
         (timedelta(minutes=1), "min"),
         (timedelta(seconds=1), "S"),
-        (np.timedelta64(1, "ns"), "N"),
-        (timedelta(microseconds=1), "U"),
+        (np.timedelta64(1, "ns"), "ns"),
+        (timedelta(microseconds=1), "us"),
         (timedelta(microseconds=1000), "ms"),
     ]
 )
@@ -254,7 +254,7 @@ def test_infer_freq_tz_series(tz_naive_fixture):
     ],
 )
 @pytest.mark.parametrize(
-    "freq", ["H", "3H", "10min", "3601S", "3600001ms", "3600000001U", "3600000000001N"]
+    "freq", ["H", "3H", "10min", "3601S", "3600001ms", "3600000001us", "3600000000001ns"]
 )
 def test_infer_freq_tz_transition(tz_naive_fixture, date_pair, freq):
     # see gh-8772
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index eacefca1e218d..56d35790191e2 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -811,7 +811,7 @@ def test_alias_equality(self):
             assert k == v.copy()
 
     def test_rule_code(self):
-        lst = ["M", "MS", "BM", "BMS", "D", "B", "H", "min", "S", "ms", "U"]
+        lst = ["M", "MS", "BM", "BMS", "D", "B", "H", "min", "S", "ms", "us"]
         for k in lst:
             assert k == _get_offset(k).rule_code
             # should be cached - this is kind of an internals test...
diff --git a/pandas/tests/tslibs/test_period_asfreq.py b/pandas/tests/tslibs/test_period_asfreq.py
index 71d121553dc9e..37231da4fc02d 100644
--- a/pandas/tests/tslibs/test_period_asfreq.py
+++ b/pandas/tests/tslibs/test_period_asfreq.py
@@ -28,23 +28,23 @@ def get_freq_code(freqstr: str) -> int:
         ("D", "min", 1440),
         ("D", "S", 86400),
         ("D", "ms", 86400000),
-        ("D", "U", 86400000000),
-        ("D", "N", 86400000000000),
+        ("D", "us", 86400000000),
+        ("D", "ns", 86400000000000),
         ("H", "min", 60),
         ("H", "S", 3600),
         ("H", "ms", 3600000),
-        ("H", "U", 3600000000),
-        ("H", "N", 3600000000000),
+        ("H", "us", 3600000000),
+        ("H", "ns", 3600000000000),
         ("min", "S", 60),
         ("min", "ms", 60000),
-        ("min", "U", 60000000),
-        ("min", "N", 60000000000),
+        ("min", "us", 60000000),
+        ("min", "ns", 60000000000),
         ("S", "ms", 1000),
-        ("S", "U", 1000000),
-        ("S", "N", 1000000000),
-        ("ms", "U", 1000),
-        ("ms", "N", 1000000),
-        ("U", "N", 1000),
+        ("S", "us", 1000000),
+        ("S", "ns", 1000000000),
+        ("ms", "us", 1000),
+        ("ms", "ns", 1000000),
+        ("us", "ns", 1000),
     ],
 )
 def test_intra_day_conversion_factors(freq1, freq2, expected):
diff --git a/pandas/tests/tslibs/test_to_offset.py b/pandas/tests/tslibs/test_to_offset.py
index 160619f1ad416..edb006b27d3a7 100644
--- a/pandas/tests/tslibs/test_to_offset.py
+++ b/pandas/tests/tslibs/test_to_offset.py
@@ -21,11 +21,11 @@
         ("2h 20.5min", offsets.Second(8430)),
         ("1.5min", offsets.Second(90)),
         ("0.5S", offsets.Milli(500)),
-        ("15ms500u", offsets.Micro(15500)),
+        ("15ms500us", offsets.Micro(15500)),
         ("10s75ms", offsets.Milli(10075)),
         ("1s0.25ms", offsets.Micro(1000250)),
         ("1s0.25ms", offsets.Micro(1000250)),
-        ("2800N", offsets.Nano(2800)),
+        ("2800ns", offsets.Nano(2800)),
         ("2SM", offsets.SemiMonthEnd(2)),
         ("2SM-16", offsets.SemiMonthEnd(2, day_of_month=16)),
         ("2SMS-14", offsets.SemiMonthBegin(2, day_of_month=14)),
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 0b3b915bb7700..36a9d3e8ea58f 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -280,10 +280,10 @@ def get_freq(self) -> str | None:
             return _maybe_add_count("ms", delta / (pps // 1000))
         elif _is_multiple(delta, (pps // 1_000_000)):
             # Microseconds
-            return _maybe_add_count("U", delta / (pps // 1_000_000))
+            return _maybe_add_count("us", delta / (pps // 1_000_000))
         else:
             # Nanoseconds
-            return _maybe_add_count("N", delta)
+            return _maybe_add_count("ns", delta)
 
     @cache_readonly
     def day_deltas(self) -> list[int]:

From 7bd61888c52562f625d3e531c6c521e8992f6eae Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Mon, 31 Jul 2023 22:15:36 +0200
Subject: [PATCH 15/31] correct is_superperiod, is_subperiod,
 _maybe_coerce_freq and fix tests

---
 .../tests/indexes/period/test_constructors.py |  4 +-
 .../tseries/frequencies/test_inference.py     |  3 +-
 pandas/tseries/frequencies.py                 | 66 +++++++++----------
 3 files changed, 38 insertions(+), 35 deletions(-)

diff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py
index 50e5a261974b2..1e6de936f8278 100644
--- a/pandas/tests/indexes/period/test_constructors.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -110,7 +110,9 @@ def test_constructor_U(self):
 
     def test_constructor_nano(self):
         idx = period_range(
-            start=Period(ordinal=1, freq="ns"), end=Period(ordinal=4, freq="ns"), freq="ns"
+            start=Period(ordinal=1, freq="ns"),
+            end=Period(ordinal=4, freq="ns"),
+            freq="ns",
         )
         exp = PeriodIndex(
             [
diff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py
index f2b5a13b7478c..24c2ed3852710 100644
--- a/pandas/tests/tseries/frequencies/test_inference.py
+++ b/pandas/tests/tseries/frequencies/test_inference.py
@@ -254,7 +254,8 @@ def test_infer_freq_tz_series(tz_naive_fixture):
     ],
 )
 @pytest.mark.parametrize(
-    "freq", ["H", "3H", "10min", "3601S", "3600001ms", "3600000001us", "3600000000001ns"]
+    "freq",
+    ["H", "3H", "10min", "3601S", "3600001ms", "3600000001us", "3600000000001ns"],
 )
 def test_infer_freq_tz_transition(tz_naive_fixture, date_pair, freq):
     # see gh-8772
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 36a9d3e8ea58f..8fc0815bd8312 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -71,8 +71,8 @@
     "min": "min",
     "S": "S",
     "ms": "ms",
-    "U": "U",
-    "N": "N",
+    "us": "us",
+    "ns": "ns",
     "H": "H",
     "Q": "Q",
     "A": "A",
@@ -482,31 +482,31 @@ def is_subperiod(source, target) -> bool:
             return _quarter_months_conform(
                 get_rule_month(source), get_rule_month(target)
             )
-        return source in {"D", "C", "B", "M", "H", "min", "S", "ms", "U", "N"}
+        return source in {"D", "C", "B", "M", "H", "min", "S", "ms", "us", "ns"}
     elif _is_quarterly(target):
-        return source in {"D", "C", "B", "M", "H", "min", "S", "ms", "U", "N"}
+        return source in {"D", "C", "B", "M", "H", "min", "S", "ms", "us", "ns"}
     elif _is_monthly(target):
-        return source in {"D", "C", "B", "H", "min", "S", "ms", "U", "N"}
+        return source in {"D", "C", "B", "H", "min", "S", "ms", "us", "ns"}
     elif _is_weekly(target):
-        return source in {target, "D", "C", "B", "H", "min", "S", "ms", "U", "N"}
+        return source in {target, "D", "C", "B", "H", "min", "S", "ms", "us", "ns"}
     elif target == "B":
-        return source in {"B", "H", "min", "S", "ms", "U", "N"}
+        return source in {"B", "H", "min", "S", "ms", "us", "ns"}
     elif target == "C":
-        return source in {"C", "H", "min", "S", "ms", "U", "N"}
+        return source in {"C", "H", "min", "S", "ms", "us", "ns"}
     elif target == "D":
-        return source in {"D", "H", "min", "S", "ms", "U", "N"}
+        return source in {"D", "H", "min", "S", "ms", "us", "ns"}
     elif target == "H":
-        return source in {"H", "min", "S", "ms", "U", "N"}
+        return source in {"H", "min", "S", "ms", "us", "ns"}
     elif target == "min":
-        return source in {"min", "S", "ms", "U", "N"}
+        return source in {"min", "S", "ms", "us", "ns"}
     elif target == "S":
-        return source in {"S", "ms", "U", "N"}
+        return source in {"S", "ms", "us", "ns"}
     elif target == "ms":
-        return source in {"ms", "U", "N"}
-    elif target == "U":
-        return source in {"U", "N"}
-    elif target == "N":
-        return source in {"N"}
+        return source in {"ms", "us", "ns"}
+    elif target == "us":
+        return source in {"us", "ns"}
+    elif target == "ns":
+        return source in {"ns"}
     else:
         return False
 
@@ -540,31 +540,31 @@ def is_superperiod(source, target) -> bool:
             smonth = get_rule_month(source)
             tmonth = get_rule_month(target)
             return _quarter_months_conform(smonth, tmonth)
-        return target in {"D", "C", "B", "M", "H", "min", "S", "ms", "U", "N"}
+        return target in {"D", "C", "B", "M", "H", "min", "S", "ms", "us", "ns"}
     elif _is_quarterly(source):
-        return target in {"D", "C", "B", "M", "H", "min", "S", "ms", "U", "N"}
+        return target in {"D", "C", "B", "M", "H", "min", "S", "ms", "us", "ns"}
     elif _is_monthly(source):
-        return target in {"D", "C", "B", "H", "min", "S", "ms", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "ms", "us", "ns"}
     elif _is_weekly(source):
-        return target in {source, "D", "C", "B", "H", "min", "S", "ms", "U", "N"}
+        return target in {source, "D", "C", "B", "H", "min", "S", "ms", "us", "ns"}
     elif source == "B":
-        return target in {"D", "C", "B", "H", "min", "S", "ms", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "ms", "us", "ns"}
     elif source == "C":
-        return target in {"D", "C", "B", "H", "min", "S", "ms", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "ms", "us", "ns"}
     elif source == "D":
-        return target in {"D", "C", "B", "H", "min", "S", "ms", "U", "N"}
+        return target in {"D", "C", "B", "H", "min", "S", "ms", "us", "ns"}
     elif source == "H":
-        return target in {"H", "min", "S", "ms", "U", "N"}
+        return target in {"H", "min", "S", "ms", "us", "ns"}
     elif source == "min":
-        return target in {"min", "S", "ms", "U", "N"}
+        return target in {"min", "S", "ms", "us", "ns"}
     elif source == "S":
-        return target in {"S", "ms", "U", "N"}
+        return target in {"S", "ms", "us", "ns"}
     elif source == "ms":
-        return target in {"ms", "U", "N"}
-    elif source == "U":
-        return target in {"U", "N"}
-    elif source == "N":
-        return target in {"N"}
+        return target in {"ms", "us", "ns"}
+    elif source == "us":
+        return target in {"us", "ns"}
+    elif source == "ns":
+        return target in {"ns"}
     else:
         return False
 
@@ -585,7 +585,7 @@ def _maybe_coerce_freq(code) -> str:
     assert code is not None
     if isinstance(code, DateOffset):
         code = code.rule_code
-    if code in {"min", "ms"}:
+    if code in {"min", "ms", "us", "ns"}:
         return code
     else:
         return code.upper()

From 77949c4f0ca4fc20b57278e2d5345d6bdf673a9e Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Tue, 1 Aug 2023 11:47:00 +0200
Subject: [PATCH 16/31]  correct __eq__ for PeriodDtype

---
 pandas/core/dtypes/dtypes.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index 0d3e955696d81..22054ff634a0a 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -912,6 +912,10 @@ def __setstate__(self, state) -> None:
         self._unit = state["unit"]
 
 
+def _capitalize_first_letter(s):
+    return s[:1].upper() + s[1:]
+
+
 @register_extension_dtype
 class PeriodDtype(PeriodDtypeBase, PandasExtensionDtype):
     """
@@ -1054,7 +1058,7 @@ def na_value(self) -> NaTType:
 
     def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):
-            return other in [self.name, self.name.title()]
+            return other in [self.name, _capitalize_first_letter(self.name)]
 
         return super().__eq__(other)
 

From a24c0ec726801f070d9f577dd6436ec59e565636 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Tue, 1 Aug 2023 14:26:16 +0200
Subject: [PATCH 17/31] update docstrings

---
 asv_bench/benchmarks/timeseries.py |  2 +-
 doc/source/whatsnew/v0.15.0.rst    |  2 +-
 pandas/_libs/tslibs/nattype.pyx    |  4 ++--
 pandas/_libs/tslibs/offsets.pyx    |  8 ++++----
 pandas/_libs/tslibs/timestamps.pyx |  4 ++--
 pandas/core/arrays/datetimes.py    |  2 +-
 pandas/core/generic.py             | 24 ++++++++++++------------
 pandas/core/groupby/grouper.py     | 12 ++++++------
 pandas/core/resample.py            | 28 ++++++++++++++--------------
 9 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/asv_bench/benchmarks/timeseries.py b/asv_bench/benchmarks/timeseries.py
index be25c042b128a..8c78a9c1723df 100644
--- a/asv_bench/benchmarks/timeseries.py
+++ b/asv_bench/benchmarks/timeseries.py
@@ -178,7 +178,7 @@ class ResampleDatetetime64:
     # GH 7754
     def setup(self):
         rng3 = date_range(
-            start="2000-01-01 00:00:00", end="2000-01-01 10:00:00", freq="555000U"
+            start="2000-01-01 00:00:00", end="2000-01-01 10:00:00", freq="555000us"
         )
         self.dt_ts = Series(5, rng3, dtype="datetime64[ns]")
 
diff --git a/doc/source/whatsnew/v0.15.0.rst b/doc/source/whatsnew/v0.15.0.rst
index 6b962cbb49c74..89eebafc75eb0 100644
--- a/doc/source/whatsnew/v0.15.0.rst
+++ b/doc/source/whatsnew/v0.15.0.rst
@@ -185,7 +185,7 @@ Constructing a ``TimedeltaIndex`` with a regular range
 .. ipython:: python
 
    pd.timedelta_range('1 days', periods=5, freq='D')
-   pd.timedelta_range(start='1 days', end='2 days', freq='30T')
+   pd.timedelta_range(start='1 days', end='2 days', freq='30min')
 
 You can now use a ``TimedeltaIndex`` as the index of a pandas object
 
diff --git a/pandas/_libs/tslibs/nattype.pyx b/pandas/_libs/tslibs/nattype.pyx
index 9ec4fb8a1c835..921b6b79cef4c 100644
--- a/pandas/_libs/tslibs/nattype.pyx
+++ b/pandas/_libs/tslibs/nattype.pyx
@@ -1091,7 +1091,7 @@ timedelta}, default 'raise'
         >>> ts.floor(freq='S') # seconds
         Timestamp('2020-03-14 15:32:52')
 
-        >>> ts.floor(freq='N') # nanoseconds
+        >>> ts.floor(freq='ns') # nanoseconds
         Timestamp('2020-03-14 15:32:52.192548651')
 
         ``freq`` can also be a multiple of a single unit, like '5min' (i.e.  5 minutes):
@@ -1180,7 +1180,7 @@ timedelta}, default 'raise'
         >>> ts.ceil(freq='S') # seconds
         Timestamp('2020-03-14 15:32:53')
 
-        >>> ts.ceil(freq='U') # microseconds
+        >>> ts.ceil(freq='us') # microseconds
         Timestamp('2020-03-14 15:32:52.192549')
 
         ``freq`` can also be a multiple of a single unit, like '5min' (i.e.  5 minutes):
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index e522b8873d5d8..039e30d837bc5 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -621,10 +621,10 @@ cdef class BaseOffset:
         '2BH'
 
         >>> pd.offsets.Nano().freqstr
-        'N'
+        'ns'
 
         >>> pd.offsets.Nano(-3).freqstr
-        '-3N'
+        '-3ns'
         """
         try:
             code = self.rule_code
@@ -4257,13 +4257,13 @@ prefix_mapping = {
         CustomBusinessHour,  # 'CBH'
         MonthEnd,  # 'M'
         MonthBegin,  # 'MS'
-        Nano,  # 'N'
+        Nano,  # 'ns'
         SemiMonthEnd,  # 'SM'
         SemiMonthBegin,  # 'SMS'
         Week,  # 'W'
         Second,  # 'S'
         Minute,  # 'min'
-        Micro,  # 'U'
+        Micro,  # 'us'
         QuarterEnd,  # 'Q'
         QuarterBegin,  # 'QS'
         Milli,  # 'ms'
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index 794ef2a5a9112..a0749674b8481 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -2094,7 +2094,7 @@ timedelta}, default 'raise'
         >>> ts.floor(freq='S') # seconds
         Timestamp('2020-03-14 15:32:52')
 
-        >>> ts.floor(freq='N') # nanoseconds
+        >>> ts.floor(freq='ns') # nanoseconds
         Timestamp('2020-03-14 15:32:52.192548651')
 
         ``freq`` can also be a multiple of a single unit, like '5min' (i.e.  5 minutes):
@@ -2183,7 +2183,7 @@ timedelta}, default 'raise'
         >>> ts.ceil(freq='S') # seconds
         Timestamp('2020-03-14 15:32:53')
 
-        >>> ts.ceil(freq='U') # microseconds
+        >>> ts.ceil(freq='us') # microseconds
         Timestamp('2020-03-14 15:32:52.192549')
 
         ``freq`` can also be a multiple of a single unit, like '5min' (i.e.  5 minutes):
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 8ad51e4a90027..dd2d7c0060392 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -1589,7 +1589,7 @@ def isocalendar(self) -> DataFrame:
         Examples
         --------
         >>> datetime_series = pd.Series(
-        ...     pd.date_range("2000-01-01", periods=3, freq="T")
+        ...     pd.date_range("2000-01-01", periods=3, freq="min")
         ... )
         >>> datetime_series
         0   2000-01-01 00:00:00
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 7a971cd35f352..c66c542c6f3d3 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -9033,7 +9033,7 @@ def resample(
         2000-01-01 00:06:00    6
         2000-01-01 00:07:00    7
         2000-01-01 00:08:00    8
-        Freq: T, dtype: int64
+        Freq: min, dtype: int64
 
         Downsample the series into 3 minute bins and sum the values
         of the timestamps falling into a bin.
@@ -9042,7 +9042,7 @@ def resample(
         2000-01-01 00:00:00     3
         2000-01-01 00:03:00    12
         2000-01-01 00:06:00    21
-        Freq: 3T, dtype: int64
+        Freq: 3min, dtype: int64
 
         Downsample the series into 3 minute bins as above, but label each
         bin using the right edge instead of the left. Please note that the
@@ -9058,7 +9058,7 @@ def resample(
         2000-01-01 00:03:00     3
         2000-01-01 00:06:00    12
         2000-01-01 00:09:00    21
-        Freq: 3T, dtype: int64
+        Freq: 3min, dtype: int64
 
         Downsample the series into 3 minute bins as above, but close the right
         side of the bin interval.
@@ -9068,7 +9068,7 @@ def resample(
         2000-01-01 00:03:00     6
         2000-01-01 00:06:00    15
         2000-01-01 00:09:00    15
-        Freq: 3T, dtype: int64
+        Freq: 3min, dtype: int64
 
         Upsample the series into 30 second bins.
 
@@ -9111,7 +9111,7 @@ def resample(
         2000-01-01 00:00:00     8
         2000-01-01 00:03:00    17
         2000-01-01 00:06:00    26
-        Freq: 3T, dtype: int64
+        Freq: 3min, dtype: int64
 
         For a Series with a PeriodIndex, the keyword `convention` can be
         used to control whether to use the start or end of `rule`.
@@ -9231,7 +9231,7 @@ def resample(
         2000-10-02 00:12:00    18
         2000-10-02 00:19:00    21
         2000-10-02 00:26:00    24
-        Freq: 7T, dtype: int64
+        Freq: 7min, dtype: int64
 
         >>> ts.resample('17min').sum()
         2000-10-01 23:14:00     0
@@ -9239,7 +9239,7 @@ def resample(
         2000-10-01 23:48:00    21
         2000-10-02 00:05:00    54
         2000-10-02 00:22:00    24
-        Freq: 17T, dtype: int64
+        Freq: 17min, dtype: int64
 
         >>> ts.resample('17min', origin='epoch').sum()
         2000-10-01 23:18:00     0
@@ -9247,7 +9247,7 @@ def resample(
         2000-10-01 23:52:00    27
         2000-10-02 00:09:00    39
         2000-10-02 00:26:00    24
-        Freq: 17T, dtype: int64
+        Freq: 17min, dtype: int64
 
         >>> ts.resample('17W', origin='2000-01-01').sum()
         2000-01-02      0
@@ -9264,14 +9264,14 @@ def resample(
         2000-10-01 23:47:00    21
         2000-10-02 00:04:00    54
         2000-10-02 00:21:00    24
-        Freq: 17T, dtype: int64
+        Freq: 17min, dtype: int64
 
         >>> ts.resample('17min', offset='23h30min').sum()
         2000-10-01 23:30:00     9
         2000-10-01 23:47:00    21
         2000-10-02 00:04:00    54
         2000-10-02 00:21:00    24
-        Freq: 17T, dtype: int64
+        Freq: 17min, dtype: int64
 
         If you want to take the largest Timestamp as the end of the bins:
 
@@ -9280,7 +9280,7 @@ def resample(
         2000-10-01 23:52:00    18
         2000-10-02 00:09:00    27
         2000-10-02 00:26:00    63
-        Freq: 17T, dtype: int64
+        Freq: 17min, dtype: int64
 
         In contrast with the `start_day`, you can use `end_day` to take the ceiling
         midnight of the largest Timestamp as the end of the bins and drop the bins
@@ -9291,7 +9291,7 @@ def resample(
         2000-10-01 23:55:00    15
         2000-10-02 00:12:00    45
         2000-10-02 00:29:00    45
-        Freq: 17T, dtype: int64
+        Freq: 17min, dtype: int64
         """
         from pandas.core.resample import get_resampler
 
diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index 4201887e13178..9239a2bedac2e 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -188,7 +188,7 @@ class Grouper:
     2000-10-02 00:12:00    18
     2000-10-02 00:19:00    21
     2000-10-02 00:26:00    24
-    Freq: 7T, dtype: int64
+    Freq: 7min, dtype: int64
 
     >>> ts.groupby(pd.Grouper(freq='17min')).sum()
     2000-10-01 23:14:00     0
@@ -196,7 +196,7 @@ class Grouper:
     2000-10-01 23:48:00    21
     2000-10-02 00:05:00    54
     2000-10-02 00:22:00    24
-    Freq: 17T, dtype: int64
+    Freq: 17min, dtype: int64
 
     >>> ts.groupby(pd.Grouper(freq='17min', origin='epoch')).sum()
     2000-10-01 23:18:00     0
@@ -204,7 +204,7 @@ class Grouper:
     2000-10-01 23:52:00    27
     2000-10-02 00:09:00    39
     2000-10-02 00:26:00    24
-    Freq: 17T, dtype: int64
+    Freq: 17min, dtype: int64
 
     >>> ts.groupby(pd.Grouper(freq='17W', origin='2000-01-01')).sum()
     2000-01-02      0
@@ -221,14 +221,14 @@ class Grouper:
     2000-10-01 23:47:00    21
     2000-10-02 00:04:00    54
     2000-10-02 00:21:00    24
-    Freq: 17T, dtype: int64
+    Freq: 17min, dtype: int64
 
     >>> ts.groupby(pd.Grouper(freq='17min', offset='23h30min')).sum()
     2000-10-01 23:30:00     9
     2000-10-01 23:47:00    21
     2000-10-02 00:04:00    54
     2000-10-02 00:21:00    24
-    Freq: 17T, dtype: int64
+    Freq: 17min, dtype: int64
 
     To replace the use of the deprecated `base` argument, you can now use `offset`,
     in this example it is equivalent to have `base=2`:
@@ -239,7 +239,7 @@ class Grouper:
     2000-10-01 23:50:00    36
     2000-10-02 00:07:00    39
     2000-10-02 00:24:00    24
-    Freq: 17T, dtype: int64
+    Freq: 17min, dtype: int64
     """
 
     sort: bool
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 53d587cdde182..f75260773ce31 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -605,7 +605,7 @@ def nearest(self, limit: int | None = None):
         2018-01-01 00:30:00    2
         2018-01-01 00:45:00    2
         2018-01-01 01:00:00    2
-        Freq: 15T, dtype: int64
+        Freq: 15min, dtype: int64
 
         Limit the number of upsampled values imputed by the nearest:
 
@@ -615,7 +615,7 @@ def nearest(self, limit: int | None = None):
         2018-01-01 00:30:00    NaN
         2018-01-01 00:45:00    2.0
         2018-01-01 01:00:00    2.0
-        Freq: 15T, dtype: float64
+        Freq: 15min, dtype: float64
         """
         return self._upsample("nearest", limit=limit)
 
@@ -674,7 +674,7 @@ def bfill(self, limit: int | None = None):
         2018-01-01 01:00:00    2
         2018-01-01 01:30:00    3
         2018-01-01 02:00:00    3
-        Freq: 30T, dtype: int64
+        Freq: 30min, dtype: int64
 
         >>> s.resample('15min').bfill(limit=2)
         2018-01-01 00:00:00    1.0
@@ -686,7 +686,7 @@ def bfill(self, limit: int | None = None):
         2018-01-01 01:30:00    3.0
         2018-01-01 01:45:00    3.0
         2018-01-01 02:00:00    3.0
-        Freq: 15T, dtype: float64
+        Freq: 15min, dtype: float64
 
         Resampling a DataFrame that has missing values:
 
@@ -787,7 +787,7 @@ def fillna(self, method, limit: int | None = None):
         2018-01-01 01:00:00    2.0
         2018-01-01 01:30:00    NaN
         2018-01-01 02:00:00    3.0
-        Freq: 30T, dtype: float64
+        Freq: 30min, dtype: float64
 
         >>> s.resample('30min').fillna("backfill")
         2018-01-01 00:00:00    1
@@ -795,7 +795,7 @@ def fillna(self, method, limit: int | None = None):
         2018-01-01 01:00:00    2
         2018-01-01 01:30:00    3
         2018-01-01 02:00:00    3
-        Freq: 30T, dtype: int64
+        Freq: 30min, dtype: int64
 
         >>> s.resample('15min').fillna("backfill", limit=2)
         2018-01-01 00:00:00    1.0
@@ -807,7 +807,7 @@ def fillna(self, method, limit: int | None = None):
         2018-01-01 01:30:00    3.0
         2018-01-01 01:45:00    3.0
         2018-01-01 02:00:00    3.0
-        Freq: 15T, dtype: float64
+        Freq: 15min, dtype: float64
 
         >>> s.resample('30min').fillna("pad")
         2018-01-01 00:00:00    1
@@ -815,7 +815,7 @@ def fillna(self, method, limit: int | None = None):
         2018-01-01 01:00:00    2
         2018-01-01 01:30:00    2
         2018-01-01 02:00:00    3
-        Freq: 30T, dtype: int64
+        Freq: 30min, dtype: int64
 
         >>> s.resample('30min').fillna("nearest")
         2018-01-01 00:00:00    1
@@ -823,7 +823,7 @@ def fillna(self, method, limit: int | None = None):
         2018-01-01 01:00:00    2
         2018-01-01 01:30:00    3
         2018-01-01 02:00:00    3
-        Freq: 30T, dtype: int64
+        Freq: 30min, dtype: int64
 
         Missing values present before the upsampling are not affected.
 
@@ -841,7 +841,7 @@ def fillna(self, method, limit: int | None = None):
         2018-01-01 01:00:00    NaN
         2018-01-01 01:30:00    3.0
         2018-01-01 02:00:00    3.0
-        Freq: 30T, dtype: float64
+        Freq: 30min, dtype: float64
 
         >>> sm.resample('30min').fillna('pad')
         2018-01-01 00:00:00    1.0
@@ -849,7 +849,7 @@ def fillna(self, method, limit: int | None = None):
         2018-01-01 01:00:00    NaN
         2018-01-01 01:30:00    NaN
         2018-01-01 02:00:00    3.0
-        Freq: 30T, dtype: float64
+        Freq: 30min, dtype: float64
 
         >>> sm.resample('30min').fillna('nearest')
         2018-01-01 00:00:00    1.0
@@ -857,7 +857,7 @@ def fillna(self, method, limit: int | None = None):
         2018-01-01 01:00:00    NaN
         2018-01-01 01:30:00    3.0
         2018-01-01 02:00:00    3.0
-        Freq: 30T, dtype: float64
+        Freq: 30min, dtype: float64
 
         DataFrame resampling is done column-wise. All the same options are
         available.
@@ -1032,7 +1032,7 @@ def interpolate(
         2023-03-01 07:00:03.000    1.0
         2023-03-01 07:00:03.500    2.0
         2023-03-01 07:00:04.000    3.0
-        Freq: 500L, dtype: float64
+        Freq: 500ms, dtype: float64
 
         Internal reindexing with ``as_freq()`` prior to interpolation leads to
         an interpolated timeseries on the basis the reindexed timestamps (anchors).
@@ -1051,7 +1051,7 @@ def interpolate(
         2023-03-01 07:00:03.200    2.6
         2023-03-01 07:00:03.600    2.8
         2023-03-01 07:00:04.000    3.0
-        Freq: 400L, dtype: float64
+        Freq: 400ms, dtype: float64
 
         Note that the series erroneously increases between two anchors
         ``07:00:00`` and ``07:00:02``.

From 733d68b424536c6d6d5c9aed72db84705afaa7a0 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Tue, 1 Aug 2023 14:44:11 +0200
Subject: [PATCH 18/31] correct whatsnew and user_guide

---
 doc/source/user_guide/scale.rst | 4 ++--
 doc/source/whatsnew/v0.13.0.rst | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/source/user_guide/scale.rst b/doc/source/user_guide/scale.rst
index b66ddcd33a684..7df281d15b55f 100644
--- a/doc/source/user_guide/scale.rst
+++ b/doc/source/user_guide/scale.rst
@@ -63,7 +63,7 @@ That can be generated by the following code snippet:
        return df
 
    timeseries = [
-       make_timeseries(freq="1T", seed=i).rename(columns=lambda x: f"{x}_{i}")
+       make_timeseries(freq="1min", seed=i).rename(columns=lambda x: f"{x}_{i}")
        for i in range(10)
    ]
    ts_wide = pd.concat(timeseries, axis=1)
@@ -196,7 +196,7 @@ files. Each file in the directory represents a different year of the entire data
    pathlib.Path("data/timeseries").mkdir(exist_ok=True)
 
    for i, (start, end) in enumerate(zip(starts, ends)):
-       ts = make_timeseries(start=start, end=end, freq="1T", seed=i)
+       ts = make_timeseries(start=start, end=end, freq="1min", seed=i)
        ts.to_parquet(f"data/timeseries/ts-{i:0>2d}.parquet")
 
 
diff --git a/doc/source/whatsnew/v0.13.0.rst b/doc/source/whatsnew/v0.13.0.rst
index 2e086f560bd53..1a2e9e7d2ae16 100644
--- a/doc/source/whatsnew/v0.13.0.rst
+++ b/doc/source/whatsnew/v0.13.0.rst
@@ -643,7 +643,7 @@ Enhancements
 
   .. ipython:: python
 
-     pd.date_range('2013-01-01', periods=5, freq='5N')
+     pd.date_range('2013-01-01', periods=5, freq='5ns')
 
   or with frequency as offset
 

From beeac14b2f140f1b6e6f0c89695c922906214589 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Tue, 1 Aug 2023 15:22:45 +0200
Subject: [PATCH 19/31] correct tables of Offset/Period aliases in user_guide

---
 doc/source/user_guide/timedeltas.rst |  2 +-
 doc/source/user_guide/timeseries.rst | 42 ++++++++++++++--------------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/doc/source/user_guide/timedeltas.rst b/doc/source/user_guide/timedeltas.rst
index a6eb96f91a4bf..cd567f8442671 100644
--- a/doc/source/user_guide/timedeltas.rst
+++ b/doc/source/user_guide/timedeltas.rst
@@ -390,7 +390,7 @@ The ``freq`` parameter can passed a variety of :ref:`frequency aliases <timeseri
 
 .. ipython:: python
 
-   pd.timedelta_range(start="1 days", end="2 days", freq="30T")
+   pd.timedelta_range(start="1 days", end="2 days", freq="30min")
 
    pd.timedelta_range(start="1 days", periods=5, freq="2D5H")
 
diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index bc6a3926188f1..de2c71a7c4f39 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -603,7 +603,7 @@ would include matching times on an included date:
    dft = pd.DataFrame(
        np.random.randn(100000, 1),
        columns=["A"],
-       index=pd.date_range("20130101", periods=100000, freq="T"),
+       index=pd.date_range("20130101", periods=100000, freq="min"),
    )
    dft
    dft.loc["2013"]
@@ -905,11 +905,11 @@ into ``freq`` keyword arguments. The available date offsets and associated frequ
     :class:`~pandas.tseries.offsets.CustomBusinessHour`, ``'CBH'``, "custom business hour"
     :class:`~pandas.tseries.offsets.Day`, ``'D'``, "one absolute day"
     :class:`~pandas.tseries.offsets.Hour`, ``'H'``, "one hour"
-    :class:`~pandas.tseries.offsets.Minute`, ``'T'`` or ``'min'``,"one minute"
+    :class:`~pandas.tseries.offsets.Minute`, ``'min'``,"one minute"
     :class:`~pandas.tseries.offsets.Second`, ``'S'``, "one second"
-    :class:`~pandas.tseries.offsets.Milli`, ``'L'`` or ``'ms'``, "one millisecond"
-    :class:`~pandas.tseries.offsets.Micro`, ``'U'`` or ``'us'``, "one microsecond"
-    :class:`~pandas.tseries.offsets.Nano`, ``'N'``, "one nanosecond"
+    :class:`~pandas.tseries.offsets.Milli`, ``'ms'``, "one millisecond"
+    :class:`~pandas.tseries.offsets.Micro`, ``'us'``, "one microsecond"
+    :class:`~pandas.tseries.offsets.Nano`, ``'ns'``, "one nanosecond"
 
 ``DateOffsets`` additionally have :meth:`rollforward` and :meth:`rollback`
 methods for moving a date forward or backward respectively to a valid offset
@@ -1264,11 +1264,11 @@ frequencies. We will refer to these aliases as *offset aliases*.
     "BAS, BYS", "business year start frequency"
     "BH", "business hour frequency"
     "H", "hourly frequency"
-    "T, min", "minutely frequency"
+    "min", "minutely frequency"
     "S", "secondly frequency"
-    "L, ms", "milliseconds"
-    "U, us", "microseconds"
-    "N", "nanoseconds"
+    "ms", "milliseconds"
+    "us", "microseconds"
+    "ns", "nanoseconds"
 
 .. note::
 
@@ -1318,11 +1318,11 @@ frequencies. We will refer to these aliases as *period aliases*.
     "Q", "quarterly frequency"
     "A, Y", "yearly frequency"
     "H", "hourly frequency"
-    "T, min", "minutely frequency"
+    "min", "minutely frequency"
     "S", "secondly frequency"
-    "L, ms", "milliseconds"
-    "U, us", "microseconds"
-    "N", "nanoseconds"
+    "ms", "milliseconds"
+    "us", "microseconds"
+    "ns", "nanoseconds"
 
 
 Combining aliases
@@ -1343,7 +1343,7 @@ You can combine together day and intraday offsets:
 
    pd.date_range(start, periods=10, freq="2h20min")
 
-   pd.date_range(start, periods=10, freq="1D10U")
+   pd.date_range(start, periods=10, freq="1D10us")
 
 Anchored offsets
 ~~~~~~~~~~~~~~~~
@@ -1725,11 +1725,11 @@ For upsampling, you can specify a way to upsample and the ``limit`` parameter to
 
    # from secondly to every 250 milliseconds
 
-   ts[:2].resample("250L").asfreq()
+   ts[:2].resample("250ms").asfreq()
 
-   ts[:2].resample("250L").ffill()
+   ts[:2].resample("250ms").ffill()
 
-   ts[:2].resample("250L").ffill(limit=2)
+   ts[:2].resample("250ms").ffill(limit=2)
 
 Sparse resampling
 ~~~~~~~~~~~~~~~~~
@@ -1752,7 +1752,7 @@ If we want to resample to the full range of the series:
 
 .. ipython:: python
 
-    ts.resample("3T").sum()
+    ts.resample("3min").sum()
 
 We can instead only resample those groups where we have points as follows:
 
@@ -1766,7 +1766,7 @@ We can instead only resample those groups where we have points as follows:
         freq = to_offset(freq)
         return pd.Timestamp((t.value // freq.delta.value) * freq.delta.value)
 
-    ts.groupby(partial(round, freq="3T")).sum()
+    ts.groupby(partial(round, freq="3min")).sum()
 
 .. _timeseries.aggregate:
 
@@ -1786,7 +1786,7 @@ Resampling a ``DataFrame``, the default will be to act on all columns with the s
        index=pd.date_range("1/1/2012", freq="S", periods=1000),
        columns=["A", "B", "C"],
    )
-   r = df.resample("3T")
+   r = df.resample("3min")
    r.mean()
 
 We can select a specific column or columns using standard getitem.
@@ -2155,7 +2155,7 @@ Passing a string representing a lower frequency than ``PeriodIndex`` returns par
    dfp = pd.DataFrame(
        np.random.randn(600, 1),
        columns=["A"],
-       index=pd.period_range("2013-01-01 9:00", periods=600, freq="T"),
+       index=pd.period_range("2013-01-01 9:00", periods=600, freq="min"),
    )
    dfp
    dfp.loc["2013-01-01 10H"]

From a3e352231160ce1e190632d9324c90426b4964b4 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Tue, 1 Aug 2023 19:09:16 +0200
Subject: [PATCH 20/31] correct warning message, add the warning to some tests

---
 pandas/_libs/tslibs/dtypes.pyi                |  4 +-
 pandas/_libs/tslibs/dtypes.pyx                | 15 +++---
 pandas/_libs/tslibs/timedeltas.pyx            |  6 +--
 pandas/core/dtypes/dtypes.py                  |  8 ++-
 pandas/core/tools/timedeltas.py               |  4 +-
 .../timedeltas/test_timedelta_range.py        |  6 ++-
 .../tests/scalar/timedelta/test_timedelta.py  | 53 +++++++++++--------
 .../tseries/frequencies/test_freq_code.py     |  2 +-
 pandas/util/__init__.py                       |  4 ++
 9 files changed, 61 insertions(+), 41 deletions(-)

diff --git a/pandas/_libs/tslibs/dtypes.pyi b/pandas/_libs/tslibs/dtypes.pyi
index c61e6905a45e3..9974d2e648398 100644
--- a/pandas/_libs/tslibs/dtypes.pyi
+++ b/pandas/_libs/tslibs/dtypes.pyi
@@ -1,10 +1,12 @@
 from enum import Enum
 
+from pandas._libs.tslibs.timedeltas import UnitChoices
+
 # These are not public API, but are exposed in the .pyi file because they
 #  are imported in tests.
 _attrname_to_abbrevs: dict[str, str]
 _period_code_map: dict[str, int]
-DEPR_ABBREVS: dict[str, str]
+DEPR_ABBREVS: dict[str, UnitChoices]
 
 def periods_per_day(reso: int) -> int: ...
 def periods_per_second(reso: int) -> int: ...
diff --git a/pandas/_libs/tslibs/dtypes.pyx b/pandas/_libs/tslibs/dtypes.pyx
index a1018677307ed..2f6a0388d9ebf 100644
--- a/pandas/_libs/tslibs/dtypes.pyx
+++ b/pandas/_libs/tslibs/dtypes.pyx
@@ -291,12 +291,12 @@ class Resolution(Enum):
         try:
             if freq in DEPR_ABBREVS:
                 warnings.warn(
-                    f"Code freq={freq} is deprecated "
-                    "and will be removed in a future version.",
+                    f"Code freq={freq} is deprecated and will be removed in a future "
+                    f"version. Please use {DEPR_ABBREVS.get(freq)} instead of {freq}.",
                     FutureWarning,
                     stacklevel=find_stack_level(),
                 )
-                freq = freq.replace("T", "min").replace("L", "ms")
+                freq = DEPR_ABBREVS[freq]
             attr_name = _abbrev_to_attrnames[freq]
         except KeyError:
             # For quarterly and yearly resolutions, we need to chop off
@@ -307,14 +307,15 @@ class Resolution(Enum):
             if split_freq[1] not in _month_names:
                 # i.e. we want e.g. "Q-DEC", not "Q-INVALID"
                 raise
-            if split_freq[0] in {"T", "L"}:
+            if split_freq[0] in DEPR_ABBREVS:
                 warnings.warn(
-                    f"Code freq={split_freq[0]} is deprecated "
-                    "and will be removed in a future version.",
+                    f"Code freq={split_freq[0]} is deprecated and will be removed in "
+                    f"a future version. Please use {DEPR_ABBREVS.get(split_freq[0])} "
+                    f"instead of {split_freq[0]}.",
                     FutureWarning,
                     stacklevel=find_stack_level(),
                 )
-                split_freq[0] = split_freq[0].replace("T", "min").replace("L", "ms")
+                split_freq[0] = DEPR_ABBREVS[split_freq[0]]
             attr_name = _abbrev_to_attrnames[split_freq[0]]
 
         return cls.from_attrname(attr_name)
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 1b8dfe99f7ffc..5769b565ea6ae 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1450,11 +1450,11 @@ cdef class _Timedelta(timedelta):
         --------
         >>> td = pd.Timedelta('1 days 2 min 3 us 42 ns')
         >>> td.resolution_string
-        'N'
+        'ns'
 
         >>> td = pd.Timedelta('1 days 2 min 3 us')
         >>> td.resolution_string
-        'U'
+        'us'
 
         >>> td = pd.Timedelta('2 min 3 s')
         >>> td.resolution_string
@@ -1462,7 +1462,7 @@ cdef class _Timedelta(timedelta):
 
         >>> td = pd.Timedelta(36, unit='us')
         >>> td.resolution_string
-        'U'
+        'us'
         """
         self._ensure_components()
         if self._ns:
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index 22054ff634a0a..1bb091e73c101 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -61,6 +61,8 @@
     is_list_like,
 )
 
+from pandas.util import capitalize_first_letter
+
 if not pa_version_under7p0:
     import pyarrow as pa
 
@@ -912,10 +914,6 @@ def __setstate__(self, state) -> None:
         self._unit = state["unit"]
 
 
-def _capitalize_first_letter(s):
-    return s[:1].upper() + s[1:]
-
-
 @register_extension_dtype
 class PeriodDtype(PeriodDtypeBase, PandasExtensionDtype):
     """
@@ -1058,7 +1056,7 @@ def na_value(self) -> NaTType:
 
     def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):
-            return other in [self.name, _capitalize_first_letter(self.name)]
+            return other in [self.name, capitalize_first_letter(self.name)]
 
         return super().__eq__(other)
 
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index cf2cfdccfbf3f..2ae17cefc7ba9 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -179,11 +179,11 @@ def to_timedelta(
     if unit in DEPR_ABBREVS:
         warnings.warn(
             f"Unit '{unit}' is deprecated and will be removed in a future version. "
-            f", please use '{DEPR_ABBREVS.get(unit)}' instead of '{unit}'.",
+            f"Please use '{DEPR_ABBREVS.get(unit)}' instead of '{unit}'.",
             FutureWarning,
             stacklevel=find_stack_level(),
         )
-        unit = DEPR_ABBREVS.get(unit)  # type: ignore[assignment]
+        unit = DEPR_ABBREVS.get(unit)
 
     if unit is not None:
         unit = parse_timedelta_unit(unit)
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta_range.py b/pandas/tests/indexes/timedeltas/test_timedelta_range.py
index 8cc2baaba044d..73868ed179b96 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta_range.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta_range.py
@@ -49,9 +49,13 @@ def test_timedelta_range(self):
             ("t", "minute"),
             ("L", "millisecond"),
             ("l", "millisecond"),
+            ("U", "microsecond"),
+            ("u", "microsecond"),
+            ("N", "nanosecond"),
+            ("n", "nanosecond"),
         ],
     )
-    def test_timedelta_units_t_l_deprecated(self, depr_unit, unit):
+    def test_timedelta_units_t_l_u_n_deprecated(self, depr_unit, unit):
         depr_msg = f"Unit '{depr_unit}' is deprecated."
 
         expected = to_timedelta(np.arange(5), unit=unit)
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index 1261270bb8d7b..07d2e92a0c9d7 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -540,11 +540,13 @@ def test_nat_converters(self):
                 "microsecond",
                 "micro",
                 "micros",
+                "u",
                 "US",
                 "Microseconds",
                 "Microsecond",
                 "Micro",
                 "Micros",
+                "U",
             ]
         ]
         + [
@@ -555,11 +557,13 @@ def test_nat_converters(self):
                 "nanosecond",
                 "nano",
                 "nanos",
+                "n",
                 "NS",
                 "Nanoseconds",
                 "Nanosecond",
                 "Nano",
                 "Nanos",
+                "N",
             ]
         ],
     )
@@ -572,28 +576,35 @@ def test_unit_parser(self, unit, np_unit, wrapper):
             dtype="m8[ns]",
         )
         # TODO(2.0): the desired output dtype may have non-nano resolution
-        result = to_timedelta(wrapper(range(5)), unit=unit)
-        tm.assert_index_equal(result, expected)
-        result = TimedeltaIndex(wrapper(range(5)), unit=unit)
-        tm.assert_index_equal(result, expected)
-
-        str_repr = [f"{x}{unit}" for x in np.arange(5)]
-        result = to_timedelta(wrapper(str_repr))
-        tm.assert_index_equal(result, expected)
-        result = to_timedelta(wrapper(str_repr))
-        tm.assert_index_equal(result, expected)
-
-        # scalar
-        expected = Timedelta(np.timedelta64(2, np_unit).astype("timedelta64[ns]"))
-        result = to_timedelta(2, unit=unit)
-        assert result == expected
-        result = Timedelta(2, unit=unit)
-        assert result == expected
+        msg = f"Unit '{unit}' is deprecated and will be removed in a future version."
 
-        result = to_timedelta(f"2{unit}")
-        assert result == expected
-        result = Timedelta(f"2{unit}")
-        assert result == expected
+        if (unit, np_unit) in (("u", "us"), ("U", "us"), ("n", "ns"), ("N", "ns")):
+            warn = FutureWarning
+        else:
+            warn = None
+        with tm.assert_produces_warning(warn, match=msg):
+            result = to_timedelta(wrapper(range(5)), unit=unit)
+            tm.assert_index_equal(result, expected)
+            result = TimedeltaIndex(wrapper(range(5)), unit=unit)
+            tm.assert_index_equal(result, expected)
+
+            str_repr = [f"{x}{unit}" for x in np.arange(5)]
+            result = to_timedelta(wrapper(str_repr))
+            tm.assert_index_equal(result, expected)
+            result = to_timedelta(wrapper(str_repr))
+            tm.assert_index_equal(result, expected)
+
+            # scalar
+            expected = Timedelta(np.timedelta64(2, np_unit).astype("timedelta64[ns]"))
+            result = to_timedelta(2, unit=unit)
+            assert result == expected
+            result = Timedelta(2, unit=unit)
+            assert result == expected
+
+            result = to_timedelta(f"2{unit}")
+            assert result == expected
+            result = Timedelta(f"2{unit}")
+            assert result == expected
 
     @pytest.mark.parametrize("unit", ["Y", "y", "M"])
     def test_unit_m_y_raises(self, unit):
diff --git a/pandas/tests/tseries/frequencies/test_freq_code.py b/pandas/tests/tseries/frequencies/test_freq_code.py
index 5a90a7776b056..a10bfc924b762 100644
--- a/pandas/tests/tseries/frequencies/test_freq_code.py
+++ b/pandas/tests/tseries/frequencies/test_freq_code.py
@@ -99,7 +99,7 @@ def test_compatibility(freqstr, expected):
     assert ts_np + do == np.datetime64(expected)
 
 
-@pytest.mark.parametrize("freq", ["T", "L"])
+@pytest.mark.parametrize("freq", ["T", "L", "N", "U"])
 def test_units_t_l_deprecated_from__attrname_to_abbrevs(freq):
     # GH 52536
     msg = f"Code freq={freq} is deprecated and will be removed in a future version."
diff --git a/pandas/util/__init__.py b/pandas/util/__init__.py
index 8fe928ed6c5cf..82b3aa56c653c 100644
--- a/pandas/util/__init__.py
+++ b/pandas/util/__init__.py
@@ -23,3 +23,7 @@ def __getattr__(key: str):
         return cache_readonly
 
     raise AttributeError(f"module 'pandas.util' has no attribute '{key}'")
+
+
+def capitalize_first_letter(s):
+    return s[:1].upper() + s[1:]

From c61b0fbce48224ab619a80ada65e3065c0cb12a4 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Tue, 1 Aug 2023 22:48:14 +0200
Subject: [PATCH 21/31] add the futurewarning to def asfreq, fix tests

---
 pandas/_libs/tslibs/period.pyx            | 13 +++++++++++++
 pandas/core/arrays/timedeltas.py          |  8 ++++----
 pandas/tests/scalar/period/test_asfreq.py |  4 ++++
 3 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index c37e9cd7ef1f3..6f03f9a523db6 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -1,4 +1,7 @@
 import re
+import warnings
+
+from pandas.util._exceptions import find_stack_level
 
 cimport numpy as cnp
 from cpython.object cimport (
@@ -38,6 +41,8 @@ from libc.time cimport (
     tm,
 )
 
+from pandas._libs.tslibs.dtypes cimport c_DEPR_ABBREVS
+
 # import datetime C API
 import_datetime()
 
@@ -1935,6 +1940,14 @@ cdef class _Period(PeriodMixin):
         >>> period.asfreq('H')
         Period('2023-01-01 23:00', 'H')
         """
+        if freq in c_DEPR_ABBREVS:
+            warnings.warn(
+                f"Code freq={freq} is deprecated and will be removed in a future "
+                f"version. Please use {c_DEPR_ABBREVS.get(freq)} instead of {freq}.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+            freq = c_DEPR_ABBREVS[freq]
         freq = self._maybe_convert_freq(freq)
         how = validate_end_alias(how)
         base1 = self._dtype._dtype_code
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index a81609e1bb618..569f677fc814d 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -888,7 +888,7 @@ def to_pytimedelta(self) -> npt.NDArray[np.object_]:
     --------
     For Series:
 
-    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='U'))
+    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='us'))
     >>> ser
     0   0 days 00:00:00.000001
     1   0 days 00:00:00.000002
@@ -902,7 +902,7 @@ def to_pytimedelta(self) -> npt.NDArray[np.object_]:
 
     For TimedeltaIndex:
 
-    >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='U')
+    >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='us')
     >>> tdelta_idx
     TimedeltaIndex(['0 days 00:00:00.000001', '0 days 00:00:00.000002',
                     '0 days 00:00:00.000003'],
@@ -923,7 +923,7 @@ def to_pytimedelta(self) -> npt.NDArray[np.object_]:
     --------
     For Series:
 
-    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='N'))
+    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='ns'))
     >>> ser
     0   0 days 00:00:00.000000001
     1   0 days 00:00:00.000000002
@@ -937,7 +937,7 @@ def to_pytimedelta(self) -> npt.NDArray[np.object_]:
 
     For TimedeltaIndex:
 
-    >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='N')
+    >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='ns')
     >>> tdelta_idx
     TimedeltaIndex(['0 days 00:00:00.000000001', '0 days 00:00:00.000000002',
                     '0 days 00:00:00.000000003'],
diff --git a/pandas/tests/scalar/period/test_asfreq.py b/pandas/tests/scalar/period/test_asfreq.py
index 51b9b0ec8d2a0..14184adce6273 100644
--- a/pandas/tests/scalar/period/test_asfreq.py
+++ b/pandas/tests/scalar/period/test_asfreq.py
@@ -115,6 +115,10 @@ def test_conv_annual(self):
         assert ival_A.asfreq("H", "E") == ival_A_to_H_end
         assert ival_A.asfreq("min", "S") == ival_A_to_T_start
         assert ival_A.asfreq("min", "E") == ival_A_to_T_end
+        msg = "Code freq=T is deprecated and will be removed in a future version."
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert ival_A.asfreq("T", "S") == ival_A_to_T_start
+            assert ival_A.asfreq("T", "E") == ival_A_to_T_end
         assert ival_A.asfreq("S", "S") == ival_A_to_S_start
         assert ival_A.asfreq("S", "E") == ival_A_to_S_end
 

From c2f45ba4f434c7662744cfb80ac21105dbcce8af Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Wed, 2 Aug 2023 16:13:59 +0200
Subject: [PATCH 22/31] add the futurewarning to to_offset, correct warning
 message and add tests

---
 pandas/_libs/tslibs/dtypes.pyx                 | 11 ++++++-----
 pandas/_libs/tslibs/offsets.pyx                | 17 ++++++++++++++++-
 pandas/_libs/tslibs/period.pyx                 | 13 -------------
 pandas/tests/arrays/test_datetimes.py          | 18 ++++++++++++++++++
 pandas/tests/resample/test_period_index.py     | 18 ++++++++++++++++++
 pandas/tests/scalar/period/test_asfreq.py      |  2 +-
 .../tseries/frequencies/test_freq_code.py      |  4 ++--
 pandas/tests/tslibs/test_to_offset.py          |  8 ++++----
 8 files changed, 65 insertions(+), 26 deletions(-)

diff --git a/pandas/_libs/tslibs/dtypes.pyx b/pandas/_libs/tslibs/dtypes.pyx
index 2f6a0388d9ebf..189e436435109 100644
--- a/pandas/_libs/tslibs/dtypes.pyx
+++ b/pandas/_libs/tslibs/dtypes.pyx
@@ -291,8 +291,9 @@ class Resolution(Enum):
         try:
             if freq in DEPR_ABBREVS:
                 warnings.warn(
-                    f"Code freq={freq} is deprecated and will be removed in a future "
-                    f"version. Please use {DEPR_ABBREVS.get(freq)} instead of {freq}.",
+                    f"\'{freq}\' is deprecated and will be removed in a future "
+                    f"version. Please use \'{DEPR_ABBREVS.get(freq)}\' "
+                    "instead of \'{freq}\'.",
                     FutureWarning,
                     stacklevel=find_stack_level(),
                 )
@@ -309,9 +310,9 @@ class Resolution(Enum):
                 raise
             if split_freq[0] in DEPR_ABBREVS:
                 warnings.warn(
-                    f"Code freq={split_freq[0]} is deprecated and will be removed in "
-                    f"a future version. Please use {DEPR_ABBREVS.get(split_freq[0])} "
-                    f"instead of {split_freq[0]}.",
+                    f"\'{split_freq[0]}\' is deprecated and will be removed in a "
+                    f"future version. Please use \'{DEPR_ABBREVS.get(split_freq[0])}\' "
+                    f"instead of \'{split_freq[0]}\'.",
                     FutureWarning,
                     stacklevel=find_stack_level(),
                 )
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index 039e30d837bc5..e9c4c3d8d643e 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -1,5 +1,8 @@
 import re
 import time
+import warnings
+
+from pandas.util._exceptions import find_stack_level
 
 cimport cython
 from cpython.datetime cimport (
@@ -50,7 +53,10 @@ from pandas._libs.tslibs.ccalendar cimport (
     get_lastbday,
 )
 from pandas._libs.tslibs.conversion cimport localize_pydatetime
-from pandas._libs.tslibs.dtypes cimport periods_per_day
+from pandas._libs.tslibs.dtypes cimport (
+    c_DEPR_ABBREVS,
+    periods_per_day,
+)
 from pandas._libs.tslibs.nattype cimport (
     NPY_NAT,
     c_NaT as NaT,
@@ -4417,6 +4423,15 @@ cpdef to_offset(freq):
                 if not stride:
                     stride = 1
 
+                if prefix in c_DEPR_ABBREVS:
+                    warnings.warn(
+                        f"\'{prefix}\' is deprecated and will be removed in a "
+                        f"future version. Please use \'{c_DEPR_ABBREVS.get(prefix)}\' "
+                        f"instead of \'{prefix}\'.",
+                        FutureWarning,
+                        stacklevel=find_stack_level(),
+                    )
+                    prefix = c_DEPR_ABBREVS[prefix]
                 if prefix in {"D", "H", "min", "S", "ms", "us", "ns"}:
                     # For these prefixes, we have something like "3H" or
                     #  "2.5T", so we can construct a Timedelta with the
diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index 6f03f9a523db6..c37e9cd7ef1f3 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -1,7 +1,4 @@
 import re
-import warnings
-
-from pandas.util._exceptions import find_stack_level
 
 cimport numpy as cnp
 from cpython.object cimport (
@@ -41,8 +38,6 @@ from libc.time cimport (
     tm,
 )
 
-from pandas._libs.tslibs.dtypes cimport c_DEPR_ABBREVS
-
 # import datetime C API
 import_datetime()
 
@@ -1940,14 +1935,6 @@ cdef class _Period(PeriodMixin):
         >>> period.asfreq('H')
         Period('2023-01-01 23:00', 'H')
         """
-        if freq in c_DEPR_ABBREVS:
-            warnings.warn(
-                f"Code freq={freq} is deprecated and will be removed in a future "
-                f"version. Please use {c_DEPR_ABBREVS.get(freq)} instead of {freq}.",
-                FutureWarning,
-                stacklevel=find_stack_level(),
-            )
-            freq = c_DEPR_ABBREVS[freq]
         freq = self._maybe_convert_freq(freq)
         how = validate_end_alias(how)
         base1 = self._dtype._dtype_code
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index 8e38a8c741b8d..0c7fdfd368d7c 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -758,3 +758,21 @@ def test_factorize_sort_without_freq():
     tda = dta - dta[0]
     with pytest.raises(NotImplementedError, match=msg):
         tda.factorize(sort=True)
+
+
+@pytest.mark.parametrize(
+    "freq,freq_depr",
+    [
+        ("min", "T"),
+        ("ms", "L"),
+        ("ns", "N"),
+        ("us", "U"),
+    ],
+)
+def test_frequencies_t_l_u_n_deprecated(freq, freq_depr):
+    msg = f"'{freq_depr}' is deprecated and will be removed in a future version."
+
+    expected = pd.date_range("1/1/2000", periods=4, freq=freq)
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = pd.date_range("1/1/2000", periods=4, freq=freq_depr)
+    tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index d1db9de211b7f..879eaceb93371 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -896,3 +896,21 @@ def test_sum_min_count(self):
             [3.0, np.nan], index=PeriodIndex(["2018Q1", "2018Q2"], freq="Q-DEC")
         )
         tm.assert_series_equal(result, expected)
+
+    def test_resample_t_l_deprecated(self):
+        msg_t = "'T' is deprecated and will be removed in a future version."
+        msg_l = "'L' is deprecated and will be removed in a future version."
+
+        with tm.assert_produces_warning(FutureWarning, match=msg_l):
+            rng_l = period_range(
+                "2020-01-01 00:00:00 00:00", "2020-01-01 00:00:00 00:01", freq="L"
+            )
+        ser = Series(np.arange(len(rng_l)), index=rng_l)
+
+        rng = period_range(
+            "2020-01-01 00:00:00 00:00", "2020-01-01 00:00:00 00:01", freq="min"
+        )
+        expected = Series([29999.5, 60000.0], index=rng)
+        with tm.assert_produces_warning(FutureWarning, match=msg_t):
+            result = ser.resample("T").mean()
+        tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/scalar/period/test_asfreq.py b/pandas/tests/scalar/period/test_asfreq.py
index 14184adce6273..1eab3305980c5 100644
--- a/pandas/tests/scalar/period/test_asfreq.py
+++ b/pandas/tests/scalar/period/test_asfreq.py
@@ -115,7 +115,7 @@ def test_conv_annual(self):
         assert ival_A.asfreq("H", "E") == ival_A_to_H_end
         assert ival_A.asfreq("min", "S") == ival_A_to_T_start
         assert ival_A.asfreq("min", "E") == ival_A_to_T_end
-        msg = "Code freq=T is deprecated and will be removed in a future version."
+        msg = "'T' is deprecated and will be removed in a future version."
         with tm.assert_produces_warning(FutureWarning, match=msg):
             assert ival_A.asfreq("T", "S") == ival_A_to_T_start
             assert ival_A.asfreq("T", "E") == ival_A_to_T_end
diff --git a/pandas/tests/tseries/frequencies/test_freq_code.py b/pandas/tests/tseries/frequencies/test_freq_code.py
index a10bfc924b762..51c2a1fd79009 100644
--- a/pandas/tests/tseries/frequencies/test_freq_code.py
+++ b/pandas/tests/tseries/frequencies/test_freq_code.py
@@ -71,7 +71,7 @@ def test_resolution_bumping(args, expected):
 @pytest.mark.parametrize(
     "args",
     [
-        (0.5, "N"),
+        (0.5, "ns"),
         # Too much precision in the input can prevent.
         (0.3429324798798269273987982, "H"),
     ],
@@ -102,7 +102,7 @@ def test_compatibility(freqstr, expected):
 @pytest.mark.parametrize("freq", ["T", "L", "N", "U"])
 def test_units_t_l_deprecated_from__attrname_to_abbrevs(freq):
     # GH 52536
-    msg = f"Code freq={freq} is deprecated and will be removed in a future version."
+    msg = f"'{freq}' is deprecated and will be removed in a future version."
 
     with tm.assert_produces_warning(FutureWarning, match=msg):
         Resolution.get_reso_from_freqstr(freq)
diff --git a/pandas/tests/tslibs/test_to_offset.py b/pandas/tests/tslibs/test_to_offset.py
index edb006b27d3a7..6d7fd717f0394 100644
--- a/pandas/tests/tslibs/test_to_offset.py
+++ b/pandas/tests/tslibs/test_to_offset.py
@@ -49,10 +49,10 @@ def test_to_offset_negative(freqstr, expected):
     "freqstr",
     [
         "2h20m",
-        "U1",
-        "-U",
-        "3U1",
-        "-2-3U",
+        "us1",
+        "-us",
+        "3us1",
+        "-2-3us",
         "-2D:3H",
         "1.5.0S",
         "2SMS-15-15",

From 73405bfe4e7e41fd53dea2c9e2cf362208da8e1b Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Wed, 2 Aug 2023 18:06:43 +0200
Subject: [PATCH 23/31] add the warning to parse_timedelta_unit, remove t, l,
 u, n from timedelta_abbrevs and correct whatsnew

---
 doc/source/whatsnew/v0.13.0.rst       | 11 +++++++++--
 doc/source/whatsnew/v0.15.0.rst       | 24 +++++++++++++++++++++++-
 pandas/_libs/tslibs/timedeltas.pyx    | 24 ++++++++++++++++--------
 pandas/tests/arrays/test_datetimes.py |  2 +-
 4 files changed, 49 insertions(+), 12 deletions(-)

diff --git a/doc/source/whatsnew/v0.13.0.rst b/doc/source/whatsnew/v0.13.0.rst
index 1a2e9e7d2ae16..de0c05d948304 100644
--- a/doc/source/whatsnew/v0.13.0.rst
+++ b/doc/source/whatsnew/v0.13.0.rst
@@ -641,9 +641,16 @@ Enhancements
   Period conversions in the range of seconds and below were reworked and extended
   up to nanoseconds. Periods in the nanosecond range are now available.
 
-  .. ipython:: python
+  .. code-block:: python
 
-     pd.date_range('2013-01-01', periods=5, freq='5ns')
+     In [79]: pd.date_range('2013-01-01', periods=5, freq='5N')
+     Out[79]:
+     DatetimeIndex([          '2013-01-01 00:00:00',
+                    '2013-01-01 00:00:00.000000005',
+                    '2013-01-01 00:00:00.000000010',
+                    '2013-01-01 00:00:00.000000015',
+                    '2013-01-01 00:00:00.000000020'],
+                   dtype='datetime64[ns]', freq='5N')
 
   or with frequency as offset
 
diff --git a/doc/source/whatsnew/v0.15.0.rst b/doc/source/whatsnew/v0.15.0.rst
index 89eebafc75eb0..dffb4c7b9ff9e 100644
--- a/doc/source/whatsnew/v0.15.0.rst
+++ b/doc/source/whatsnew/v0.15.0.rst
@@ -185,7 +185,29 @@ Constructing a ``TimedeltaIndex`` with a regular range
 .. ipython:: python
 
    pd.timedelta_range('1 days', periods=5, freq='D')
-   pd.timedelta_range(start='1 days', end='2 days', freq='30min')
+
+.. code-block:: python
+
+   In [20]: pd.timedelta_range(start='1 days', end='2 days', freq='30T')
+   Out[20]:
+   TimedeltaIndex(['1 days 00:00:00', '1 days 00:30:00', '1 days 01:00:00',
+                   '1 days 01:30:00', '1 days 02:00:00', '1 days 02:30:00',
+                   '1 days 03:00:00', '1 days 03:30:00', '1 days 04:00:00',
+                   '1 days 04:30:00', '1 days 05:00:00', '1 days 05:30:00',
+                   '1 days 06:00:00', '1 days 06:30:00', '1 days 07:00:00',
+                   '1 days 07:30:00', '1 days 08:00:00', '1 days 08:30:00',
+                   '1 days 09:00:00', '1 days 09:30:00', '1 days 10:00:00',
+                   '1 days 10:30:00', '1 days 11:00:00', '1 days 11:30:00',
+                   '1 days 12:00:00', '1 days 12:30:00', '1 days 13:00:00',
+                   '1 days 13:30:00', '1 days 14:00:00', '1 days 14:30:00',
+                   '1 days 15:00:00', '1 days 15:30:00', '1 days 16:00:00',
+                   '1 days 16:30:00', '1 days 17:00:00', '1 days 17:30:00',
+                   '1 days 18:00:00', '1 days 18:30:00', '1 days 19:00:00',
+                   '1 days 19:30:00', '1 days 20:00:00', '1 days 20:30:00',
+                   '1 days 21:00:00', '1 days 21:30:00', '1 days 22:00:00',
+                   '1 days 22:30:00', '1 days 23:00:00', '1 days 23:30:00',
+                   '2 days 00:00:00'],
+                  dtype='timedelta64[ns]', freq='30T')
 
 You can now use a ``TimedeltaIndex`` as the index of a pandas object
 
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 5769b565ea6ae..4df394e32697a 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1,6 +1,8 @@
 import collections
 import warnings
 
+from pandas.util._exceptions import find_stack_level
+
 cimport cython
 from cpython.object cimport (
     Py_EQ,
@@ -41,6 +43,7 @@ from pandas._libs.tslibs.conversion cimport (
     precision_from_unit,
 )
 from pandas._libs.tslibs.dtypes cimport (
+    c_DEPR_ABBREVS,
     get_supported_reso,
     is_supported_unit,
     npy_unit_to_abbrev,
@@ -124,7 +127,6 @@ cdef dict timedelta_abbrevs = {
     "minute": "m",
     "min": "m",
     "minutes": "m",
-    "t": "m",
     "s": "s",
     "seconds": "s",
     "sec": "s",
@@ -134,20 +136,17 @@ cdef dict timedelta_abbrevs = {
     "millisecond": "ms",
     "milli": "ms",
     "millis": "ms",
-    "l": "ms",
     "us": "us",
     "microseconds": "us",
     "microsecond": "us",
     "µs": "us",
     "micro": "us",
     "micros": "us",
-    "u": "us",
     "ns": "ns",
     "nanoseconds": "ns",
     "nano": "ns",
     "nanos": "ns",
     "nanosecond": "ns",
-    "n": "ns",
 }
 
 _no_input = object()
@@ -725,6 +724,15 @@ cpdef inline str parse_timedelta_unit(str unit):
         return "ns"
     elif unit == "M":
         return unit
+    elif unit in c_DEPR_ABBREVS:
+        warnings.warn(
+            f"\'{unit}\' is deprecated and will be removed in a "
+            f"future version. Please use \'{c_DEPR_ABBREVS.get(unit)}\' "
+            f"instead of \'{unit}\'.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+        unit = c_DEPR_ABBREVS[unit]
     try:
         return timedelta_abbrevs[unit.lower()]
     except KeyError:
@@ -1435,11 +1443,11 @@ cdef class _Timedelta(timedelta):
 
         * Days:         'D'
         * Hours:        'H'
-        * Minutes:      'T'
+        * Minutes:      'min'
         * Seconds:      'S'
-        * Milliseconds: 'L'
-        * Microseconds: 'U'
-        * Nanoseconds:  'N'
+        * Milliseconds: 'ms'
+        * Microseconds: 'us'
+        * Nanoseconds:  'ns'
 
         Returns
         -------
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index 0c7fdfd368d7c..163ef8002474b 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -765,8 +765,8 @@ def test_factorize_sort_without_freq():
     [
         ("min", "T"),
         ("ms", "L"),
-        ("ns", "N"),
         ("us", "U"),
+        ("ns", "N"),
     ],
 )
 def test_frequencies_t_l_u_n_deprecated(freq, freq_depr):

From b2ab23810433e42f9d510ef5346134d1a5d69372 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Wed, 2 Aug 2023 19:46:43 +0200
Subject: [PATCH 24/31] correct docstrings, update user_guide for timeseries
 and add tests

---
 doc/source/user_guide/timeseries.rst       | 10 ++++++++++
 pandas/_libs/tslibs/timedeltas.pyx         | 13 +++++++++----
 pandas/core/tools/timedeltas.py            |  3 ++-
 pandas/tests/arrays/test_datetimes.py      |  1 +
 pandas/tests/resample/test_period_index.py |  1 +
 pandas/tests/tslibs/test_timedeltas.py     | 19 +++++++++++++++++++
 6 files changed, 42 insertions(+), 5 deletions(-)

diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index de2c71a7c4f39..01e5e08d7c197 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -1270,6 +1270,11 @@ frequencies. We will refer to these aliases as *offset aliases*.
     "us", "microseconds"
     "ns", "nanoseconds"
 
+.. warning::
+
+   Aliases ``T``, ``L``, ``U``, and ``N`` are deprecated in favour of the aliases
+   ``min``, ``ms``, ``us``, and ``ns``.
+
 .. note::
 
     When using the offset aliases above, it should be noted that functions
@@ -1324,6 +1329,11 @@ frequencies. We will refer to these aliases as *period aliases*.
     "us", "microseconds"
     "ns", "nanoseconds"
 
+.. warning::
+
+   Aliases ``T``, ``L``, ``U``, and ``N`` are deprecated in favour of the aliases
+   ``min``, ``ms``, ``us``, and ``ns``.
+
 
 Combining aliases
 ~~~~~~~~~~~~~~~~~
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 4df394e32697a..77db4f3055a77 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1714,15 +1714,20 @@ class Timedelta(_Timedelta):
 
         Possible values:
 
-        * 'W', 'D', 'T', 'S', 'L', 'U', or 'N'
-        * 'days' or 'day'
+        * 'W', 'D', or 'S'
+        * 'days', or 'day'
         * 'hours', 'hour', 'hr', or 'h'
         * 'minutes', 'minute', 'min', or 'm'
         * 'seconds', 'second', or 'sec'
-        * 'milliseconds', 'millisecond', 'millis', or 'milli'
-        * 'microseconds', 'microsecond', 'micros', or 'micro'
+        * 'milliseconds', 'millisecond', 'millis', 'milli', or 'ms'
+        * 'microseconds', 'microsecond', 'micros', 'micro', or 'us'
         * 'nanoseconds', 'nanosecond', 'nanos', 'nano', or 'ns'.
 
+        .. note::
+
+            Values `T`, `L`, `U`, and `N` are deprecated in favour of the values
+            `min`, `ms`, `us`, and `ns`.
+
     **kwargs
         Available kwargs: {days, seconds, microseconds,
         milliseconds, minutes, hours, weeks}.
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index 2ae17cefc7ba9..1462cbd3baafa 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -123,7 +123,8 @@ def to_timedelta(
 
         .. deprecated:: 2.1.0
             Units 'T', 'L', 'U' and 'N' are deprecated and will be removed
-            in a future version.
+            in a future version. Please use 'min', 'ms', 'us', and 'ns' instead of
+            'T', 'L', 'U' and 'N'.
 
     errors : {'ignore', 'raise', 'coerce'}, default 'raise'
         - If 'raise', then invalid parsing will raise an exception.
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index 163ef8002474b..9748cbc678aa7 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -770,6 +770,7 @@ def test_factorize_sort_without_freq():
     ],
 )
 def test_frequencies_t_l_u_n_deprecated(freq, freq_depr):
+    # GH 52536
     msg = f"'{freq_depr}' is deprecated and will be removed in a future version."
 
     expected = pd.date_range("1/1/2000", periods=4, freq=freq)
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index 879eaceb93371..074302f12f64f 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -898,6 +898,7 @@ def test_sum_min_count(self):
         tm.assert_series_equal(result, expected)
 
     def test_resample_t_l_deprecated(self):
+        # GH 52536
         msg_t = "'T' is deprecated and will be removed in a future version."
         msg_l = "'L' is deprecated and will be removed in a future version."
 
diff --git a/pandas/tests/tslibs/test_timedeltas.py b/pandas/tests/tslibs/test_timedeltas.py
index 4784a6d0d600d..09676befdc5bc 100644
--- a/pandas/tests/tslibs/test_timedeltas.py
+++ b/pandas/tests/tslibs/test_timedeltas.py
@@ -147,3 +147,22 @@ def test_ints_to_pytimedelta_unsupported(unit):
     msg = "Only resolutions 's', 'ms', 'us', 'ns' are supported"
     with pytest.raises(NotImplementedError, match=msg):
         ints_to_pytimedelta(arr, box=True)
+
+
+@pytest.mark.parametrize(
+    "unit,unit_depr",
+    [
+        ("min", "T"),
+        ("ms", "L"),
+        ("ns", "N"),
+        ("us", "U"),
+    ],
+)
+def test_units_t_l_u_n_deprecated(unit, unit_depr):
+    # GH 52536
+    msg = f"'{unit_depr}' is deprecated and will be removed in a future version."
+
+    expected = Timedelta(1, unit=unit)
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = Timedelta(1, unit=unit_depr)
+    tm.assert_equal(result, expected)

From 4775471f9292c6ae9eef0963cd22b406a31181f2 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Wed, 2 Aug 2023 20:49:50 +0200
Subject: [PATCH 25/31] update whatsnew/v2.1.0.rst

---
 doc/source/whatsnew/v2.1.0.rst | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 6c91c4b512f41..9bc4a7b1fc210 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -505,6 +505,9 @@ Other Deprecations
 - Deprecated parameter ``obj`` in :meth:`GroupBy.get_group` (:issue:`53545`)
 - Deprecated positional indexing on :class:`Series` with :meth:`Series.__getitem__` and :meth:`Series.__setitem__`, in a future version ``ser[item]`` will *always* interpret ``item`` as a label, not a position (:issue:`50617`)
 - Deprecated replacing builtin and NumPy functions in ``.agg``, ``.apply``, and ``.transform``; use the corresponding string alias (e.g. ``"sum"`` for ``sum`` or ``np.sum``) instead (:issue:`53425`)
+- Deprecated strings ``T``, ``L``, ``U``, and ``N`` denoting aliases for time series frequencies. Please use ``min``, ``ms``, ``us``, and ``ns`` instead of ``T``, ``L``, ``U``, and ``N`` (:issue:`52536`)
+- Deprecated strings ``T``, ``L``, ``U``, and ``N`` denoting resolutions in :meth:`Timedelta.resolution_string`. Please use ``min``, ``ms``, ``us``, and ``ns`` instead of ``T``, ``L``, ``U``, and ``N`` (:issue:`52536`)
+- Deprecated strings ``T``, ``L``, ``U``, and ``N`` denoting units in :class:`Timedelta`. Please use ``min``, ``ms``, ``us``, and ``ns`` instead of ``T``, ``L``, ``U``, and ``N`` (:issue:`52536`)
 - Deprecated strings ``T``, ``t``, ``L`` and ``l`` denoting units in :func:`to_timedelta` (:issue:`52536`)
 - Deprecated the "method" and "limit" keywords in ``ExtensionArray.fillna``, implement and use ``pad_or_backfill`` instead (:issue:`53621`)
 - Deprecated the "method" and "limit" keywords on :meth:`Series.fillna`, :meth:`DataFrame.fillna`, :meth:`SeriesGroupBy.fillna`, :meth:`DataFrameGroupBy.fillna`, and :meth:`Resampler.fillna`, use ``obj.bfill()`` or ``obj.ffill()`` instead (:issue:`53394`)

From c3ed691169520f28fa65d16e92054f9ee6bdcdb4 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Thu, 3 Aug 2023 10:52:14 +0200
Subject: [PATCH 26/31] remove warning from to_timedelta, correct tests

---
 doc/source/user_guide/timeseries.rst          |  4 ++--
 pandas/_libs/tslibs/timedeltas.pyx            |  2 +-
 pandas/core/tools/timedeltas.py               | 12 -----------
 .../timedeltas/test_timedelta_range.py        |  4 +++-
 .../tests/scalar/timedelta/test_timedelta.py  | 21 ++++++++++++++++++-
 pandas/tests/tslibs/test_timedeltas.py        | 19 -----------------
 6 files changed, 26 insertions(+), 36 deletions(-)

diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index 01e5e08d7c197..a33fd50c55d0c 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -1270,7 +1270,7 @@ frequencies. We will refer to these aliases as *offset aliases*.
     "us", "microseconds"
     "ns", "nanoseconds"
 
-.. warning::
+.. deprecated:: 2.1.0
 
    Aliases ``T``, ``L``, ``U``, and ``N`` are deprecated in favour of the aliases
    ``min``, ``ms``, ``us``, and ``ns``.
@@ -1329,7 +1329,7 @@ frequencies. We will refer to these aliases as *period aliases*.
     "us", "microseconds"
     "ns", "nanoseconds"
 
-.. warning::
+.. deprecated:: 2.1.0
 
    Aliases ``T``, ``L``, ``U``, and ``N`` are deprecated in favour of the aliases
    ``min``, ``ms``, ``us``, and ``ns``.
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 77db4f3055a77..be7a06184de8a 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1723,7 +1723,7 @@ class Timedelta(_Timedelta):
         * 'microseconds', 'microsecond', 'micros', 'micro', or 'us'
         * 'nanoseconds', 'nanosecond', 'nanos', 'nano', or 'ns'.
 
-        .. note::
+        .. deprecated:: 2.1.0
 
             Values `T`, `L`, `U`, and `N` are deprecated in favour of the values
             `min`, `ms`, `us`, and `ns`.
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index 1462cbd3baafa..f3323b1ebb118 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -7,7 +7,6 @@
     TYPE_CHECKING,
     overload,
 )
-import warnings
 
 import numpy as np
 
@@ -16,12 +15,10 @@
     NaT,
     NaTType,
 )
-from pandas._libs.tslibs.dtypes import DEPR_ABBREVS
 from pandas._libs.tslibs.timedeltas import (
     Timedelta,
     parse_timedelta_unit,
 )
-from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import is_list_like
 from pandas.core.dtypes.generic import (
@@ -177,15 +174,6 @@ def to_timedelta(
     TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'],
                    dtype='timedelta64[ns]', freq=None)
     """
-    if unit in DEPR_ABBREVS:
-        warnings.warn(
-            f"Unit '{unit}' is deprecated and will be removed in a future version. "
-            f"Please use '{DEPR_ABBREVS.get(unit)}' instead of '{unit}'.",
-            FutureWarning,
-            stacklevel=find_stack_level(),
-        )
-        unit = DEPR_ABBREVS.get(unit)
-
     if unit is not None:
         unit = parse_timedelta_unit(unit)
 
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta_range.py b/pandas/tests/indexes/timedeltas/test_timedelta_range.py
index 73868ed179b96..d5d2f22b49da3 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta_range.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta_range.py
@@ -56,7 +56,9 @@ def test_timedelta_range(self):
         ],
     )
     def test_timedelta_units_t_l_u_n_deprecated(self, depr_unit, unit):
-        depr_msg = f"Unit '{depr_unit}' is deprecated."
+        depr_msg = (
+            f"'{depr_unit}' is deprecated and will be removed in a future version."
+        )
 
         expected = to_timedelta(np.arange(5), unit=unit)
         with tm.assert_produces_warning(FutureWarning, match=depr_msg):
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index 07d2e92a0c9d7..a1fb758ca8d21 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -576,7 +576,7 @@ def test_unit_parser(self, unit, np_unit, wrapper):
             dtype="m8[ns]",
         )
         # TODO(2.0): the desired output dtype may have non-nano resolution
-        msg = f"Unit '{unit}' is deprecated and will be removed in a future version."
+        msg = f"'{unit}' is deprecated and will be removed in a future version."
 
         if (unit, np_unit) in (("u", "us"), ("U", "us"), ("n", "ns"), ("N", "ns")):
             warn = FutureWarning
@@ -1039,3 +1039,22 @@ def test_timedelta_attribute_precision():
     result += td.nanoseconds
     expected = td._value
     assert result == expected
+
+
+@pytest.mark.parametrize(
+    "unit,unit_depr",
+    [
+        ("min", "T"),
+        ("ms", "L"),
+        ("ns", "N"),
+        ("us", "U"),
+    ],
+)
+def test_units_t_l_u_n_deprecated(unit, unit_depr):
+    # GH 52536
+    msg = f"'{unit_depr}' is deprecated and will be removed in a future version."
+
+    expected = Timedelta(1, unit=unit)
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = Timedelta(1, unit=unit_depr)
+    tm.assert_equal(result, expected)
diff --git a/pandas/tests/tslibs/test_timedeltas.py b/pandas/tests/tslibs/test_timedeltas.py
index 09676befdc5bc..4784a6d0d600d 100644
--- a/pandas/tests/tslibs/test_timedeltas.py
+++ b/pandas/tests/tslibs/test_timedeltas.py
@@ -147,22 +147,3 @@ def test_ints_to_pytimedelta_unsupported(unit):
     msg = "Only resolutions 's', 'ms', 'us', 'ns' are supported"
     with pytest.raises(NotImplementedError, match=msg):
         ints_to_pytimedelta(arr, box=True)
-
-
-@pytest.mark.parametrize(
-    "unit,unit_depr",
-    [
-        ("min", "T"),
-        ("ms", "L"),
-        ("ns", "N"),
-        ("us", "U"),
-    ],
-)
-def test_units_t_l_u_n_deprecated(unit, unit_depr):
-    # GH 52536
-    msg = f"'{unit_depr}' is deprecated and will be removed in a future version."
-
-    expected = Timedelta(1, unit=unit)
-    with tm.assert_produces_warning(FutureWarning, match=msg):
-        result = Timedelta(1, unit=unit_depr)
-    tm.assert_equal(result, expected)

From 828b7d0e032d9f940b87593e7bd3b7da2c4a33f7 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Fri, 4 Aug 2023 11:23:00 +0200
Subject: [PATCH 27/31] deprecate alias A in Timedelta and offsets in favour of
 Y, fix tests [skip ci]

---
 pandas/_libs/tslibs/dtypes.pyx                |  30 +++---
 pandas/_libs/tslibs/offsets.pyx               |  30 +++---
 pandas/core/arrays/arrow/array.py             |   4 +-
 pandas/core/resample.py                       |   2 +-
 pandas/tests/arithmetic/test_datetime64.py    |   6 +-
 pandas/tests/arithmetic/test_period.py        |  28 ++---
 .../tests/arrays/period/test_arrow_compat.py  |   2 +-
 .../tests/arrays/period/test_constructors.py  |   4 +-
 pandas/tests/arrays/test_array.py             |   2 +-
 pandas/tests/base/test_conversion.py          |   4 +-
 pandas/tests/extension/test_categorical.py    |   2 +-
 pandas/tests/frame/methods/test_set_index.py  |   4 +-
 .../tests/frame/methods/test_to_timestamp.py  |  22 ++--
 pandas/tests/frame/test_repr_info.py          |   2 +-
 .../indexes/datetimelike_/test_sort_values.py |   8 +-
 .../datetimes/methods/test_to_period.py       |   4 +-
 .../indexes/datetimes/test_constructors.py    |  14 +--
 .../indexes/datetimes/test_date_range.py      |  33 +++---
 .../period/methods/test_to_timestamp.py       |  10 +-
 .../tests/indexes/period/test_constructors.py |  10 +-
 pandas/tests/indexes/period/test_formats.py   |  12 +--
 pandas/tests/indexes/period/test_indexing.py  |   6 +-
 .../indexes/period/test_partial_slicing.py    |   4 +-
 pandas/tests/indexes/period/test_period.py    |  26 ++---
 .../tests/indexes/period/test_resolution.py   |   2 +-
 pandas/tests/indexes/test_base.py             |   2 +-
 pandas/tests/indexing/test_loc.py             |  14 +--
 .../tests/io/json/test_json_table_schema.py   |   6 +-
 pandas/tests/plotting/test_datetimelike.py    |  40 +++----
 pandas/tests/resample/test_datetime_index.py  |  14 +--
 pandas/tests/resample/test_period_index.py    |  54 +++++-----
 pandas/tests/resample/test_time_grouper.py    |   8 +-
 pandas/tests/reshape/concat/test_concat.py    |   4 +-
 pandas/tests/scalar/period/test_asfreq.py     | 102 +++++++++---------
 pandas/tests/scalar/period/test_period.py     |  54 +++++-----
 pandas/tests/series/test_arithmetic.py        |   4 +-
 pandas/tests/series/test_repr.py              |   2 +-
 .../tseries/frequencies/test_inference.py     |  32 +++---
 pandas/tests/tslibs/test_libfrequencies.py    |   2 -
 pandas/tests/tslibs/test_parsing.py           |   6 +-
 pandas/tseries/frequencies.py                 |  20 ++--
 41 files changed, 312 insertions(+), 323 deletions(-)

diff --git a/pandas/_libs/tslibs/dtypes.pyx b/pandas/_libs/tslibs/dtypes.pyx
index 189e436435109..7f1b8cc552839 100644
--- a/pandas/_libs/tslibs/dtypes.pyx
+++ b/pandas/_libs/tslibs/dtypes.pyx
@@ -103,18 +103,18 @@ cdef class PeriodDtypeBase:
 _period_code_map = {
     # Annual freqs with various fiscal year ends.
     # eg, 2005 for A-FEB runs Mar 1, 2004 to Feb 28, 2005
-    "A-DEC": PeriodDtypeCode.A_DEC,  # Annual - December year end
-    "A-JAN": PeriodDtypeCode.A_JAN,  # Annual - January year end
-    "A-FEB": PeriodDtypeCode.A_FEB,  # Annual - February year end
-    "A-MAR": PeriodDtypeCode.A_MAR,  # Annual - March year end
-    "A-APR": PeriodDtypeCode.A_APR,  # Annual - April year end
-    "A-MAY": PeriodDtypeCode.A_MAY,  # Annual - May year end
-    "A-JUN": PeriodDtypeCode.A_JUN,  # Annual - June year end
-    "A-JUL": PeriodDtypeCode.A_JUL,  # Annual - July year end
-    "A-AUG": PeriodDtypeCode.A_AUG,  # Annual - August year end
-    "A-SEP": PeriodDtypeCode.A_SEP,  # Annual - September year end
-    "A-OCT": PeriodDtypeCode.A_OCT,  # Annual - October year end
-    "A-NOV": PeriodDtypeCode.A_NOV,  # Annual - November year end
+    "Y-DEC": PeriodDtypeCode.A_DEC,  # Annual - December year end
+    "Y-JAN": PeriodDtypeCode.A_JAN,  # Annual - January year end
+    "Y-FEB": PeriodDtypeCode.A_FEB,  # Annual - February year end
+    "Y-MAR": PeriodDtypeCode.A_MAR,  # Annual - March year end
+    "Y-APR": PeriodDtypeCode.A_APR,  # Annual - April year end
+    "Y-MAY": PeriodDtypeCode.A_MAY,  # Annual - May year end
+    "Y-JUN": PeriodDtypeCode.A_JUN,  # Annual - June year end
+    "Y-JUL": PeriodDtypeCode.A_JUL,  # Annual - July year end
+    "Y-AUG": PeriodDtypeCode.A_AUG,  # Annual - August year end
+    "Y-SEP": PeriodDtypeCode.A_SEP,  # Annual - September year end
+    "Y-OCT": PeriodDtypeCode.A_OCT,  # Annual - October year end
+    "Y-NOV": PeriodDtypeCode.A_NOV,  # Annual - November year end
 
     # Quarterly frequencies with various fiscal year ends.
     # eg, Q42005 for Q-OCT runs Aug 1, 2005 to Oct 31, 2005
@@ -161,7 +161,7 @@ _period_code_map.update({"Y" + key[1:]: _period_code_map[key]
 
 _period_code_map.update({
     "Q": 2000,   # Quarterly - December year end (default quarterly)
-    "A": PeriodDtypeCode.A,   # Annual
+    "Y": PeriodDtypeCode.A,   # Annual
     "W": 4000,   # Weekly
     "C": 5000,   # Custom Business Day
 })
@@ -172,7 +172,7 @@ cdef set _month_names = {
 
 # Map attribute-name resolutions to resolution abbreviations
 _attrname_to_abbrevs = {
-    "year": "A",
+    "year": "Y",
     "quarter": "Q",
     "month": "M",
     "day": "D",
@@ -188,6 +188,8 @@ cdef dict _abbrev_to_attrnames = {v: k for k, v in attrname_to_abbrevs.items()}
 
 # Map deprecated resolution abbreviations to correct resolution abbreviations
 DEPR_ABBREVS: dict[str, str]= {
+    "A": "Y",
+    "a": "y",
     "T": "min",
     "t": "min",
     "L": "ms",
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index e9c4c3d8d643e..1858c231dc28b 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -2245,7 +2245,7 @@ cdef class BYearEnd(YearOffset):
     normalize : bool, default False
         Normalize start/end dates to midnight before generating date range.
     month : int, default 12
-        A specific integer for the month of the year.
+        class BYearEnd specific integer for the month of the year.
 
     See Also
     --------
@@ -2269,7 +2269,7 @@ cdef class BYearEnd(YearOffset):
 
     _outputName = "BusinessYearEnd"
     _default_month = 12
-    _prefix = "BA"
+    _prefix = "BY"
     _day_opt = "business_end"
 
 
@@ -2308,7 +2308,7 @@ cdef class BYearBegin(YearOffset):
 
     _outputName = "BusinessYearBegin"
     _default_month = 1
-    _prefix = "BAS"
+    _prefix = "BYS"
     _day_opt = "business_start"
 
 
@@ -2353,7 +2353,7 @@ cdef class YearEnd(YearOffset):
     """
 
     _default_month = 12
-    _prefix = "A"
+    _prefix = "Y"
     _day_opt = "end"
 
     cdef readonly:
@@ -2407,7 +2407,7 @@ cdef class YearBegin(YearOffset):
     """
 
     _default_month = 1
-    _prefix = "AS"
+    _prefix = "YS"
     _day_opt = "start"
 
 
@@ -4247,10 +4247,10 @@ CDay = CustomBusinessDay
 prefix_mapping = {
     offset._prefix: offset
     for offset in [
-        YearBegin,  # 'AS'
-        YearEnd,  # 'A'
-        BYearBegin,  # 'BAS'
-        BYearEnd,  # 'BA'
+        YearBegin,  # 'YS'
+        YearEnd,  # 'Y'
+        BYearBegin,  # 'BYS'
+        BYearEnd,  # 'BY'
         BusinessDay,  # 'B'
         BusinessMonthBegin,  # 'BMS'
         BusinessMonthEnd,  # 'BM'
@@ -4290,14 +4290,10 @@ _lite_rule_alias = {
     "W": "W-SUN",
     "Q": "Q-DEC",
 
-    "A": "A-DEC",      # YearEnd(month=12),
-    "Y": "A-DEC",
-    "AS": "AS-JAN",    # YearBegin(month=1),
-    "YS": "AS-JAN",
-    "BA": "BA-DEC",    # BYearEnd(month=12),
-    "BY": "BA-DEC",
-    "BAS": "BAS-JAN",  # BYearBegin(month=1),
-    "BYS": "BAS-JAN",
+    "Y": "Y-DEC",      # YearEnd(month=12),
+    "YS": "YS-JAN",    # YearBegin(month=1),
+    "BY": "BY-DEC",    # BYearEnd(month=12),
+    "BYS": "BYS-JAN",  # BYearBegin(month=1),
 
     "Min": "min",
     "min": "min",
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 85857293d76b2..a6e6e271da3ae 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -2480,8 +2480,8 @@ def _round_temporally(
         if offset is None:
             raise ValueError(f"Must specify a valid frequency: {freq}")
         pa_supported_unit = {
-            "A": "year",
-            "AS": "year",
+            "Y": "year",
+            "YS": "year",
             "Q": "quarter",
             "QS": "quarter",
             "M": "month",
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index f75260773ce31..0e1347c22dfbe 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -2045,7 +2045,7 @@ def __init__(
 
         freq = to_offset(freq)
 
-        end_types = {"M", "A", "Q", "BM", "BA", "BQ", "W"}
+        end_types = {"M", "Y", "Q", "BM", "BY", "BQ", "W"}
         rule = freq.rule_code
         if rule in end_types or ("-" in rule and rule[: rule.find("-")] in end_types):
             if closed is None:
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index e6c743c76a2c1..c29e4acd77bff 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -1599,7 +1599,7 @@ def test_dt64arr_add_sub_offset_array(
                     Timestamp("2016-04-01"),
                     Timestamp("2017-04-01"),
                 ],
-                "AS-APR",
+                "YS-APR",
             ),
             (
                 "__sub__",
@@ -1621,7 +1621,7 @@ def test_dt64arr_add_sub_offset_array(
                     Timestamp("2015-10-01"),
                     Timestamp("2016-10-01"),
                 ],
-                "AS-OCT",
+                "YS-OCT",
             ),
         ],
     )
@@ -1630,7 +1630,7 @@ def test_dti_add_sub_nonzero_mth_offset(
     ):
         # GH 26258
         tz = tz_aware_fixture
-        date = date_range(start="01 Jan 2014", end="01 Jan 2017", freq="AS", tz=tz)
+        date = date_range(start="01 Jan 2014", end="01 Jan 2017", freq="YS", tz=tz)
         date = tm.box_expected(date, box_with_array, False)
         mth = getattr(date, op)
         result = mth(offset)
diff --git a/pandas/tests/arithmetic/test_period.py b/pandas/tests/arithmetic/test_period.py
index 792d5a0ab916d..d98fad44fc6f5 100644
--- a/pandas/tests/arithmetic/test_period.py
+++ b/pandas/tests/arithmetic/test_period.py
@@ -286,14 +286,14 @@ def test_parr_cmp_pi_mismatched_freq(self, freq, box_with_array):
 
         msg = rf"Invalid comparison between dtype=period\[{freq}\] and Period"
         with pytest.raises(TypeError, match=msg):
-            base <= Period("2011", freq="A")
+            base <= Period("2011", freq="Y")
 
         with pytest.raises(TypeError, match=msg):
-            Period("2011", freq="A") >= base
+            Period("2011", freq="Y") >= base
 
         # TODO: Could parametrize over boxes for idx?
-        idx = PeriodIndex(["2011", "2012", "2013", "2014"], freq="A")
-        rev_msg = r"Invalid comparison between dtype=period\[A-DEC\] and PeriodArray"
+        idx = PeriodIndex(["2011", "2012", "2013", "2014"], freq="Y")
+        rev_msg = r"Invalid comparison between dtype=period\[Y-DEC\] and PeriodArray"
         idx_msg = rev_msg if box_with_array in [tm.to_array, pd.array] else msg
         with pytest.raises(TypeError, match=idx_msg):
             base <= idx
@@ -405,18 +405,18 @@ def test_cmp_series_period_series_mixed_freq(self):
         # GH#13200
         base = Series(
             [
-                Period("2011", freq="A"),
+                Period("2011", freq="Y"),
                 Period("2011-02", freq="M"),
-                Period("2013", freq="A"),
+                Period("2013", freq="Y"),
                 Period("2011-04", freq="M"),
             ]
         )
 
         ser = Series(
             [
-                Period("2012", freq="A"),
+                Period("2012", freq="Y"),
                 Period("2011-01", freq="M"),
-                Period("2013", freq="A"),
+                Period("2013", freq="Y"),
                 Period("2011-05", freq="M"),
             ]
         )
@@ -934,9 +934,9 @@ def test_pi_add_sub_int_array_freqn_gt1(self):
     def test_pi_sub_isub_offset(self):
         # offset
         # DateOffset
-        rng = period_range("2014", "2024", freq="A")
+        rng = period_range("2014", "2024", freq="Y")
         result = rng - pd.offsets.YearEnd(5)
-        expected = period_range("2009", "2019", freq="A")
+        expected = period_range("2009", "2019", freq="Y")
         tm.assert_index_equal(result, expected)
         rng -= pd.offsets.YearEnd(5)
         tm.assert_index_equal(rng, expected)
@@ -1176,17 +1176,17 @@ def test_pi_sub_isub_timedeltalike_hourly(self, two_hours):
     def test_add_iadd_timedeltalike_annual(self):
         # offset
         # DateOffset
-        rng = period_range("2014", "2024", freq="A")
+        rng = period_range("2014", "2024", freq="Y")
         result = rng + pd.offsets.YearEnd(5)
-        expected = period_range("2019", "2029", freq="A")
+        expected = period_range("2019", "2029", freq="Y")
         tm.assert_index_equal(result, expected)
         rng += pd.offsets.YearEnd(5)
         tm.assert_index_equal(rng, expected)
 
     def test_pi_add_sub_timedeltalike_freq_mismatch_annual(self, mismatched_freq):
         other = mismatched_freq
-        rng = period_range("2014", "2024", freq="A")
-        msg = "Input has different freq(=.+)? from Period.*?\\(freq=A-DEC\\)"
+        rng = period_range("2014", "2024", freq="Y")
+        msg = "Input has different freq(=.+)? from Period.*?\\(freq=Y-DEC\\)"
         with pytest.raises(IncompatibleFrequency, match=msg):
             rng + other
         with pytest.raises(IncompatibleFrequency, match=msg):
diff --git a/pandas/tests/arrays/period/test_arrow_compat.py b/pandas/tests/arrays/period/test_arrow_compat.py
index 903fc3177aa84..6c04d7c603d4c 100644
--- a/pandas/tests/arrays/period/test_arrow_compat.py
+++ b/pandas/tests/arrays/period/test_arrow_compat.py
@@ -33,7 +33,7 @@ def test_arrow_extension_type():
     "data, freq",
     [
         (pd.date_range("2017", periods=3), "D"),
-        (pd.date_range("2017", periods=3, freq="A"), "A-DEC"),
+        (pd.date_range("2017", periods=3, freq="Y"), "Y-DEC"),
     ],
 )
 def test_arrow_array(data, freq):
diff --git a/pandas/tests/arrays/period/test_constructors.py b/pandas/tests/arrays/period/test_constructors.py
index ecc9ee745bad8..b360bbd5d32d1 100644
--- a/pandas/tests/arrays/period/test_constructors.py
+++ b/pandas/tests/arrays/period/test_constructors.py
@@ -71,11 +71,11 @@ def test_from_datetime64_freq_2M(freq):
     "data, freq, msg",
     [
         (
-            [pd.Period("2017", "D"), pd.Period("2017", "A")],
+            [pd.Period("2017", "D"), pd.Period("2017", "Y")],
             None,
             "Input has different freq",
         ),
-        ([pd.Period("2017", "D")], "A", "Input has different freq"),
+        ([pd.Period("2017", "D")], "Y", "Input has different freq"),
     ],
 )
 def test_period_array_raises(data, freq, msg):
diff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py
index b8b5e3588d48f..ec7ac0d98abc7 100644
--- a/pandas/tests/arrays/test_array.py
+++ b/pandas/tests/arrays/test_array.py
@@ -344,7 +344,7 @@ def test_array_inference(data, expected):
     "data",
     [
         # mix of frequencies
-        [pd.Period("2000", "D"), pd.Period("2001", "A")],
+        [pd.Period("2000", "D"), pd.Period("2001", "Y")],
         # mix of closed
         [pd.Interval(0, 1, closed="left"), pd.Interval(1, 2, closed="right")],
         # Mix of timezones
diff --git a/pandas/tests/base/test_conversion.py b/pandas/tests/base/test_conversion.py
index 0e618ea20bf67..9566d0d7158cd 100644
--- a/pandas/tests/base/test_conversion.py
+++ b/pandas/tests/base/test_conversion.py
@@ -192,9 +192,9 @@ def test_iter_box(self):
             "datetime64[ns, US/Central]",
         ),
         (
-            pd.PeriodIndex([2018, 2019], freq="A"),
+            pd.PeriodIndex([2018, 2019], freq="Y"),
             PeriodArray,
-            pd.core.dtypes.dtypes.PeriodDtype("A-DEC"),
+            pd.core.dtypes.dtypes.PeriodDtype("Y-DEC"),
         ),
         (pd.IntervalIndex.from_breaks([0, 1, 2]), IntervalArray, "interval"),
         (
diff --git a/pandas/tests/extension/test_categorical.py b/pandas/tests/extension/test_categorical.py
index 1e17bd6bf8b69..8a1863877733d 100644
--- a/pandas/tests/extension/test_categorical.py
+++ b/pandas/tests/extension/test_categorical.py
@@ -206,7 +206,7 @@ def test_cast_nan_to_int(self, cls, values):
         [
             pd.Series(["2019", "2020"], dtype="datetime64[ns, UTC]"),
             pd.Series([0, 0], dtype="timedelta64[ns]"),
-            pd.Series([pd.Period("2019"), pd.Period("2020")], dtype="period[A-DEC]"),
+            pd.Series([pd.Period("2019"), pd.Period("2020")], dtype="period[Y-DEC]"),
             pd.Series([pd.Interval(0, 1), pd.Interval(1, 2)], dtype="interval"),
             pd.Series([1, np.nan], dtype="Int64"),
         ],
diff --git a/pandas/tests/frame/methods/test_set_index.py b/pandas/tests/frame/methods/test_set_index.py
index 5984e591dd6c1..f755ef0c2763d 100644
--- a/pandas/tests/frame/methods/test_set_index.py
+++ b/pandas/tests/frame/methods/test_set_index.py
@@ -493,7 +493,7 @@ def test_set_index_period(self):
         idx1 = idx1.append(idx1)
         idx2 = period_range("2013-01-01 09:00", periods=2, freq="H")
         idx2 = idx2.append(idx2).append(idx2)
-        idx3 = period_range("2005", periods=6, freq="A")
+        idx3 = period_range("2005", periods=6, freq="Y")
 
         df = df.set_index(idx1)
         df = df.set_index(idx2, append=True)
@@ -694,7 +694,7 @@ def test_set_index_periodindex(self):
         # GH#6631
         df = DataFrame(np.random.default_rng(2).random(6))
         idx1 = period_range("2011/01/01", periods=6, freq="M")
-        idx2 = period_range("2013", periods=6, freq="A")
+        idx2 = period_range("2013", periods=6, freq="Y")
 
         df = df.set_index(idx1)
         tm.assert_index_equal(df.index, idx1)
diff --git a/pandas/tests/frame/methods/test_to_timestamp.py b/pandas/tests/frame/methods/test_to_timestamp.py
index e72b576fca833..9d8b19d94c1ca 100644
--- a/pandas/tests/frame/methods/test_to_timestamp.py
+++ b/pandas/tests/frame/methods/test_to_timestamp.py
@@ -16,7 +16,7 @@
 import pandas._testing as tm
 
 
-def _get_with_delta(delta, freq="A-DEC"):
+def _get_with_delta(delta, freq="Y-DEC"):
     return date_range(
         to_datetime("1/1/2001") + delta,
         to_datetime("12/31/2009") + delta,
@@ -27,7 +27,7 @@ def _get_with_delta(delta, freq="A-DEC"):
 class TestToTimestamp:
     def test_to_timestamp(self, frame_or_series):
         K = 5
-        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        index = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
         obj = DataFrame(
             np.random.default_rng(2).standard_normal((len(index), K)),
             index=index,
@@ -36,7 +36,7 @@ def test_to_timestamp(self, frame_or_series):
         obj["mix"] = "a"
         obj = tm.get_obj(obj, frame_or_series)
 
-        exp_index = date_range("1/1/2001", end="12/31/2009", freq="A-DEC")
+        exp_index = date_range("1/1/2001", end="12/31/2009", freq="Y-DEC")
         exp_index = exp_index + Timedelta(1, "D") - Timedelta(1, "ns")
         result = obj.to_timestamp("D", "end")
         tm.assert_index_equal(result.index, exp_index)
@@ -44,7 +44,7 @@ def test_to_timestamp(self, frame_or_series):
         if frame_or_series is Series:
             assert result.name == "A"
 
-        exp_index = date_range("1/1/2001", end="1/1/2009", freq="AS-JAN")
+        exp_index = date_range("1/1/2001", end="1/1/2009", freq="YS-JAN")
         result = obj.to_timestamp("D", "start")
         tm.assert_index_equal(result.index, exp_index)
 
@@ -71,7 +71,7 @@ def test_to_timestamp(self, frame_or_series):
 
     def test_to_timestamp_columns(self):
         K = 5
-        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        index = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
         df = DataFrame(
             np.random.default_rng(2).standard_normal((len(index), K)),
             index=index,
@@ -82,13 +82,13 @@ def test_to_timestamp_columns(self):
         # columns
         df = df.T
 
-        exp_index = date_range("1/1/2001", end="12/31/2009", freq="A-DEC")
+        exp_index = date_range("1/1/2001", end="12/31/2009", freq="Y-DEC")
         exp_index = exp_index + Timedelta(1, "D") - Timedelta(1, "ns")
         result = df.to_timestamp("D", "end", axis=1)
         tm.assert_index_equal(result.columns, exp_index)
         tm.assert_numpy_array_equal(result.values, df.values)
 
-        exp_index = date_range("1/1/2001", end="1/1/2009", freq="AS-JAN")
+        exp_index = date_range("1/1/2001", end="1/1/2009", freq="YS-JAN")
         result = df.to_timestamp("D", "start", axis=1)
         tm.assert_index_equal(result.columns, exp_index)
 
@@ -112,17 +112,17 @@ def test_to_timestamp_columns(self):
 
         result1 = df.to_timestamp("5min", axis=1)
         result2 = df.to_timestamp("min", axis=1)
-        expected = date_range("2001-01-01", "2009-01-01", freq="AS")
+        expected = date_range("2001-01-01", "2009-01-01", freq="YS")
         assert isinstance(result1.columns, DatetimeIndex)
         assert isinstance(result2.columns, DatetimeIndex)
         tm.assert_numpy_array_equal(result1.columns.asi8, expected.asi8)
         tm.assert_numpy_array_equal(result2.columns.asi8, expected.asi8)
         # PeriodIndex.to_timestamp always use 'infer'
-        assert result1.columns.freqstr == "AS-JAN"
-        assert result2.columns.freqstr == "AS-JAN"
+        assert result1.columns.freqstr == "YS-JAN"
+        assert result2.columns.freqstr == "YS-JAN"
 
     def test_to_timestamp_invalid_axis(self):
-        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        index = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
         obj = DataFrame(
             np.random.default_rng(2).standard_normal((len(index), 5)), index=index
         )
diff --git a/pandas/tests/frame/test_repr_info.py b/pandas/tests/frame/test_repr_info.py
index 0c9e5e01fa644..d9c86242770fd 100644
--- a/pandas/tests/frame/test_repr_info.py
+++ b/pandas/tests/frame/test_repr_info.py
@@ -339,7 +339,7 @@ def test_repr_np_nat_with_object(self, arg, box, expected):
         assert result == expected
 
     def test_frame_datetime64_pre1900_repr(self):
-        df = DataFrame({"year": date_range("1/1/1700", periods=50, freq="A-DEC")})
+        df = DataFrame({"year": date_range("1/1/1700", periods=50, freq="Y-DEC")})
         # it works!
         repr(df)
 
diff --git a/pandas/tests/indexes/datetimelike_/test_sort_values.py b/pandas/tests/indexes/datetimelike_/test_sort_values.py
index ab1c15f003d4d..cf919bfa29d10 100644
--- a/pandas/tests/indexes/datetimelike_/test_sort_values.py
+++ b/pandas/tests/indexes/datetimelike_/test_sort_values.py
@@ -127,7 +127,7 @@ def test_sort_values_with_freq_periodindex(self, freq):
     @pytest.mark.parametrize(
         "idx",
         [
-            PeriodIndex(["2011", "2012", "2013"], name="pidx", freq="A"),
+            PeriodIndex(["2011", "2012", "2013"], name="pidx", freq="Y"),
             Index([2011, 2012, 2013], name="idx"),  # for compatibility check
         ],
     )
@@ -275,10 +275,10 @@ def test_sort_values_without_freq_datetimeindex(
             ),
             (
                 PeriodIndex(
-                    ["2011", "2013", "2015", "2012", "2011"], name="pidx", freq="A"
+                    ["2011", "2013", "2015", "2012", "2011"], name="pidx", freq="Y"
                 ),
                 PeriodIndex(
-                    ["2011", "2011", "2012", "2013", "2015"], name="pidx", freq="A"
+                    ["2011", "2011", "2012", "2013", "2015"], name="pidx", freq="Y"
                 ),
             ),
             (
@@ -308,7 +308,7 @@ def test_sort_values_without_freq_periodindex_nat(self):
 
 def test_order_stability_compat():
     # GH#35922. sort_values is stable both for normal and datetime-like Index
-    pidx = PeriodIndex(["2011", "2013", "2015", "2012", "2011"], name="pidx", freq="A")
+    pidx = PeriodIndex(["2011", "2013", "2015", "2012", "2011"], name="pidx", freq="Y")
     iidx = Index([2011, 2013, 2015, 2012, 2011], name="idx")
     ordered1, indexer1 = pidx.sort_values(return_indexer=True, ascending=False)
     ordered2, indexer2 = iidx.sort_values(return_indexer=True, ascending=False)
diff --git a/pandas/tests/indexes/datetimes/methods/test_to_period.py b/pandas/tests/indexes/datetimes/methods/test_to_period.py
index 654c9e07562ec..f226a4c841ce4 100644
--- a/pandas/tests/indexes/datetimes/methods/test_to_period.py
+++ b/pandas/tests/indexes/datetimes/methods/test_to_period.py
@@ -58,11 +58,11 @@ def test_to_period_quarterlyish(self, off):
         prng = rng.to_period()
         assert prng.freq == "Q-DEC"
 
-    @pytest.mark.parametrize("off", ["BA", "AS", "BAS"])
+    @pytest.mark.parametrize("off", ["BY", "YS", "BYS"])
     def test_to_period_annualish(self, off):
         rng = date_range("01-Jan-2012", periods=8, freq=off)
         prng = rng.to_period()
-        assert prng.freq == "A-DEC"
+        assert prng.freq == "Y-DEC"
 
     def test_to_period_monthish(self):
         offsets = ["MS", "BM"]
diff --git a/pandas/tests/indexes/datetimes/test_constructors.py b/pandas/tests/indexes/datetimes/test_constructors.py
index dd0c4ff1a0a16..db418f6be2ec2 100644
--- a/pandas/tests/indexes/datetimes/test_constructors.py
+++ b/pandas/tests/indexes/datetimes/test_constructors.py
@@ -648,7 +648,7 @@ def test_constructor_coverage(self):
         with pytest.raises(ValueError, match=msg):
             date_range(periods=10, freq="D")
 
-    @pytest.mark.parametrize("freq", ["AS", "W-SUN"])
+    @pytest.mark.parametrize("freq", ["YS", "W-SUN"])
     def test_constructor_datetime64_tzformat(self, freq):
         # see GH#6572: ISO 8601 format results in stdlib timezone object
         idx = date_range(
@@ -753,7 +753,7 @@ def test_constructor_invalid_dtype_raises(self, dtype):
             DatetimeIndex([1, 2], dtype=dtype)
 
     def test_constructor_name(self):
-        idx = date_range(start="2000-01-01", periods=1, freq="A", name="TEST")
+        idx = date_range(start="2000-01-01", periods=1, freq="Y", name="TEST")
         assert idx.name == "TEST"
 
     def test_000constructor_resolution(self):
@@ -978,11 +978,11 @@ def test_dti_constructor_years_only(self, tz_naive_fixture):
         rng2 = date_range("2014", "2015", freq="MS", tz=tz)
         expected2 = date_range("2014-01-01", "2015-01-01", freq="MS", tz=tz)
 
-        rng3 = date_range("2014", "2020", freq="A", tz=tz)
-        expected3 = date_range("2014-12-31", "2019-12-31", freq="A", tz=tz)
+        rng3 = date_range("2014", "2020", freq="Y", tz=tz)
+        expected3 = date_range("2014-12-31", "2019-12-31", freq="Y", tz=tz)
 
-        rng4 = date_range("2014", "2020", freq="AS", tz=tz)
-        expected4 = date_range("2014-01-01", "2020-01-01", freq="AS", tz=tz)
+        rng4 = date_range("2014", "2020", freq="YS", tz=tz)
+        expected4 = date_range("2014-01-01", "2020-01-01", freq="YS", tz=tz)
 
         for rng, expected in [
             (rng1, expected1),
@@ -1036,7 +1036,7 @@ def test_constructor_int64_nocopy(self):
         assert (index.asi8[50:100] != -1).all()
 
     @pytest.mark.parametrize(
-        "freq", ["M", "Q", "A", "D", "B", "BH", "min", "S", "ms", "us", "H", "ns", "C"]
+        "freq", ["M", "Q", "Y", "D", "B", "BH", "min", "S", "ms", "us", "H", "ns", "C"]
     )
     def test_from_freq_recreate_from_data(self, freq):
         org = date_range(start="2001/02/01 09:00", freq=freq, periods=1)
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index 96f67dde14fbb..9f9b04dfa334e 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -242,40 +242,37 @@ def test_date_range_gen_error(self):
         rng = date_range("1/1/2000 00:00", "1/1/2000 00:18", freq="5min")
         assert len(rng) == 4
 
-    @pytest.mark.parametrize("freq", ["AS", "YS"])
-    def test_begin_year_alias(self, freq):
+    def test_begin_year_alias(self):
         # see gh-9313
-        rng = date_range("1/1/2013", "7/1/2017", freq=freq)
+        rng = date_range("1/1/2013", "7/1/2017", freq="YS")
         exp = DatetimeIndex(
             ["2013-01-01", "2014-01-01", "2015-01-01", "2016-01-01", "2017-01-01"],
-            freq=freq,
+            freq="YS",
         )
         tm.assert_index_equal(rng, exp)
 
-    @pytest.mark.parametrize("freq", ["A", "Y"])
-    def test_end_year_alias(self, freq):
+    def test_end_year_alias(self):
         # see gh-9313
-        rng = date_range("1/1/2013", "7/1/2017", freq=freq)
+        rng = date_range("1/1/2013", "7/1/2017", freq="Y")
         exp = DatetimeIndex(
-            ["2013-12-31", "2014-12-31", "2015-12-31", "2016-12-31"], freq=freq
+            ["2013-12-31", "2014-12-31", "2015-12-31", "2016-12-31"], freq="Y"
         )
         tm.assert_index_equal(rng, exp)
 
-    @pytest.mark.parametrize("freq", ["BA", "BY"])
-    def test_business_end_year_alias(self, freq):
+    def test_business_end_year_alias(self):
         # see gh-9313
-        rng = date_range("1/1/2013", "7/1/2017", freq=freq)
+        rng = date_range("1/1/2013", "7/1/2017", freq="BY")
         exp = DatetimeIndex(
-            ["2013-12-31", "2014-12-31", "2015-12-31", "2016-12-30"], freq=freq
+            ["2013-12-31", "2014-12-31", "2015-12-31", "2016-12-30"], freq="BY"
         )
         tm.assert_index_equal(rng, exp)
 
     def test_date_range_negative_freq(self):
         # GH 11018
-        rng = date_range("2011-12-31", freq="-2A", periods=3)
-        exp = DatetimeIndex(["2011-12-31", "2009-12-31", "2007-12-31"], freq="-2A")
+        rng = date_range("2011-12-31", freq="-2Y", periods=3)
+        exp = DatetimeIndex(["2011-12-31", "2009-12-31", "2007-12-31"], freq="-2Y")
         tm.assert_index_equal(rng, exp)
-        assert rng.freq == "-2A"
+        assert rng.freq == "-2Y"
 
         rng = date_range("2011-01-31", freq="-2M", periods=3)
         exp = DatetimeIndex(["2011-01-31", "2010-11-30", "2010-09-30"], freq="-2M")
@@ -638,7 +635,7 @@ def test_range_tz_dateutil(self):
         assert dr[0] == start
         assert dr[2] == end
 
-    @pytest.mark.parametrize("freq", ["1D", "3D", "2M", "7W", "3H", "A"])
+    @pytest.mark.parametrize("freq", ["1D", "3D", "2M", "7W", "3H", "Y"])
     def test_range_closed(self, freq, inclusive_endpoints_fixture):
         begin = datetime(2011, 1, 1)
         end = datetime(2014, 1, 1)
@@ -653,7 +650,7 @@ def test_range_closed(self, freq, inclusive_endpoints_fixture):
 
         tm.assert_index_equal(expected_range, result_range)
 
-    @pytest.mark.parametrize("freq", ["1D", "3D", "2M", "7W", "3H", "A"])
+    @pytest.mark.parametrize("freq", ["1D", "3D", "2M", "7W", "3H", "Y"])
     def test_range_closed_with_tz_aware_start_end(
         self, freq, inclusive_endpoints_fixture
     ):
@@ -674,7 +671,7 @@ def test_range_closed_with_tz_aware_start_end(
 
         tm.assert_index_equal(expected_range, result_range)
 
-    @pytest.mark.parametrize("freq", ["1D", "3D", "2M", "7W", "3H", "A"])
+    @pytest.mark.parametrize("freq", ["1D", "3D", "2M", "7W", "3H", "Y"])
     def test_range_with_tz_closed_with_tz_aware_start_end(
         self, freq, inclusive_endpoints_fixture
     ):
diff --git a/pandas/tests/indexes/period/methods/test_to_timestamp.py b/pandas/tests/indexes/period/methods/test_to_timestamp.py
index 8bb0c3518c835..17f5955a55856 100644
--- a/pandas/tests/indexes/period/methods/test_to_timestamp.py
+++ b/pandas/tests/indexes/period/methods/test_to_timestamp.py
@@ -47,9 +47,9 @@ def test_to_timestamp_non_contiguous(self):
         tm.assert_datetime_array_equal(result, expected, check_freq=False)
 
     def test_to_timestamp_freq(self):
-        idx = period_range("2017", periods=12, freq="A-DEC")
+        idx = period_range("2017", periods=12, freq="Y-DEC")
         result = idx.to_timestamp()
-        expected = date_range("2017", periods=12, freq="AS-JAN")
+        expected = date_range("2017", periods=12, freq="YS-JAN")
         tm.assert_index_equal(result, expected)
 
     def test_to_timestamp_pi_nat(self):
@@ -72,12 +72,12 @@ def test_to_timestamp_pi_nat(self):
         tm.assert_index_equal(result3, exp)
         assert result3.freqstr == "3M"
 
-        msg = "Frequency must be positive, because it represents span: -2A"
+        msg = "Frequency must be positive, because it represents span: -2Y"
         with pytest.raises(ValueError, match=msg):
-            result.to_period(freq="-2A")
+            result.to_period(freq="-2Y")
 
     def test_to_timestamp_preserve_name(self):
-        index = period_range(freq="A", start="1/1/2001", end="12/1/2009", name="foo")
+        index = period_range(freq="Y", start="1/1/2001", end="12/1/2009", name="foo")
         assert index.name == "foo"
 
         conv = index.to_timestamp("D")
diff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py
index 1e6de936f8278..dac96b4ccc45c 100644
--- a/pandas/tests/indexes/period/test_constructors.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -166,7 +166,7 @@ def test_constructor_fromarraylike(self):
 
         msg = "'Period' object is not iterable"
         with pytest.raises(TypeError, match=msg):
-            PeriodIndex(data=Period("2007", freq="A"))
+            PeriodIndex(data=Period("2007", freq="Y"))
 
         result = PeriodIndex(iter(idx))
         tm.assert_index_equal(result, idx)
@@ -415,7 +415,7 @@ def test_constructor_freq_mult(self):
         with pytest.raises(ValueError, match=msg):
             period_range("2011-01", periods=3, freq="0M")
 
-    @pytest.mark.parametrize("freq", ["A", "M", "D", "min", "S"])
+    @pytest.mark.parametrize("freq", ["Y", "M", "D", "min", "S"])
     @pytest.mark.parametrize("mult", [1, 2, 3, 4, 5])
     def test_constructor_freq_mult_dti_compat(self, mult, freq):
         freqstr = str(mult) + freq
@@ -435,7 +435,7 @@ def test_constructor_freq_combined(self):
             tm.assert_index_equal(pidx, expected)
 
     def test_constructor(self):
-        pi = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        pi = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
         assert len(pi) == 9
 
         pi = period_range(freq="Q", start="1/1/2001", end="12/1/2009")
@@ -508,7 +508,7 @@ def test_constructor(self):
             Period("2006-12-31", ("w", 1))
 
     @pytest.mark.parametrize(
-        "freq", ["M", "Q", "A", "D", "B", "min", "S", "ms", "us", "ns", "H"]
+        "freq", ["M", "Q", "Y", "D", "B", "min", "S", "ms", "us", "ns", "H"]
     )
     @pytest.mark.filterwarnings(
         r"ignore:Period with BDay freq is deprecated:FutureWarning"
@@ -521,7 +521,7 @@ def test_recreate_from_data(self, freq):
 
     def test_map_with_string_constructor(self):
         raw = [2005, 2007, 2009]
-        index = PeriodIndex(raw, freq="A")
+        index = PeriodIndex(raw, freq="Y")
 
         expected = Index([str(num) for num in raw])
         res = index.map(str)
diff --git a/pandas/tests/indexes/period/test_formats.py b/pandas/tests/indexes/period/test_formats.py
index 87bbb96377a79..67deeccff4e2a 100644
--- a/pandas/tests/indexes/period/test_formats.py
+++ b/pandas/tests/indexes/period/test_formats.py
@@ -55,7 +55,7 @@ def test_representation(self, method):
         idx2 = PeriodIndex(["2011-01-01"], freq="D")
         idx3 = PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")
         idx4 = PeriodIndex(["2011-01-01", "2011-01-02", "2011-01-03"], freq="D")
-        idx5 = PeriodIndex(["2011", "2012", "2013"], freq="A")
+        idx5 = PeriodIndex(["2011", "2012", "2013"], freq="Y")
         idx6 = PeriodIndex(["2011-01-01 09:00", "2012-02-01 10:00", "NaT"], freq="H")
         idx7 = pd.period_range("2013Q1", periods=1, freq="Q")
         idx8 = pd.period_range("2013Q1", periods=2, freq="Q")
@@ -73,7 +73,7 @@ def test_representation(self, method):
             "dtype='period[D]')"
         )
 
-        exp5 = "PeriodIndex(['2011', '2012', '2013'], dtype='period[A-DEC]')"
+        exp5 = "PeriodIndex(['2011', '2012', '2013'], dtype='period[Y-DEC]')"
 
         exp6 = (
             "PeriodIndex(['2011-01-01 09:00', '2012-02-01 10:00', 'NaT'], "
@@ -101,7 +101,7 @@ def test_representation_to_series(self):
         idx2 = PeriodIndex(["2011-01-01"], freq="D")
         idx3 = PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")
         idx4 = PeriodIndex(["2011-01-01", "2011-01-02", "2011-01-03"], freq="D")
-        idx5 = PeriodIndex(["2011", "2012", "2013"], freq="A")
+        idx5 = PeriodIndex(["2011", "2012", "2013"], freq="Y")
         idx6 = PeriodIndex(["2011-01-01 09:00", "2012-02-01 10:00", "NaT"], freq="H")
 
         idx7 = pd.period_range("2013Q1", periods=1, freq="Q")
@@ -125,7 +125,7 @@ def test_representation_to_series(self):
         exp5 = """0    2011
 1    2012
 2    2013
-dtype: period[A-DEC]"""
+dtype: period[Y-DEC]"""
 
         exp6 = """0    2011-01-01 09:00
 1    2012-02-01 10:00
@@ -157,7 +157,7 @@ def test_summary(self):
         idx2 = PeriodIndex(["2011-01-01"], freq="D")
         idx3 = PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")
         idx4 = PeriodIndex(["2011-01-01", "2011-01-02", "2011-01-03"], freq="D")
-        idx5 = PeriodIndex(["2011", "2012", "2013"], freq="A")
+        idx5 = PeriodIndex(["2011", "2012", "2013"], freq="Y")
         idx6 = PeriodIndex(["2011-01-01 09:00", "2012-02-01 10:00", "NaT"], freq="H")
 
         idx7 = pd.period_range("2013Q1", periods=1, freq="Q")
@@ -177,7 +177,7 @@ def test_summary(self):
 Freq: D"""
 
         exp5 = """PeriodIndex: 3 entries, 2011 to 2013
-Freq: A-DEC"""
+Freq: Y-DEC"""
 
         exp6 = """PeriodIndex: 3 entries, 2011-01-01 09:00 to NaT
 Freq: H"""
diff --git a/pandas/tests/indexes/period/test_indexing.py b/pandas/tests/indexes/period/test_indexing.py
index c0c6f3c977ceb..791e2feb680b6 100644
--- a/pandas/tests/indexes/period/test_indexing.py
+++ b/pandas/tests/indexes/period/test_indexing.py
@@ -238,9 +238,9 @@ def test_getitem_day(self, idx_range):
 
 class TestGetLoc:
     def test_get_loc_msg(self):
-        idx = period_range("2000-1-1", freq="A", periods=10)
-        bad_period = Period("2012", "A")
-        with pytest.raises(KeyError, match=r"^Period\('2012', 'A-DEC'\)$"):
+        idx = period_range("2000-1-1", freq="Y", periods=10)
+        bad_period = Period("2012", "Y")
+        with pytest.raises(KeyError, match=r"^Period\('2012', 'Y-DEC'\)$"):
             idx.get_loc(bad_period)
 
         try:
diff --git a/pandas/tests/indexes/period/test_partial_slicing.py b/pandas/tests/indexes/period/test_partial_slicing.py
index e52866abbe234..a4be0c9329e84 100644
--- a/pandas/tests/indexes/period/test_partial_slicing.py
+++ b/pandas/tests/indexes/period/test_partial_slicing.py
@@ -14,7 +14,7 @@
 class TestPeriodIndex:
     def test_getitem_periodindex_duplicates_string_slice(self, using_copy_on_write):
         # monotonic
-        idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq="A-JUN")
+        idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq="Y-JUN")
         ts = Series(np.random.default_rng(2).standard_normal(len(idx)), index=idx)
         original = ts.copy()
 
@@ -28,7 +28,7 @@ def test_getitem_periodindex_duplicates_string_slice(self, using_copy_on_write):
             assert (ts[1:3] == 1).all()
 
         # not monotonic
-        idx = PeriodIndex([2000, 2007, 2007, 2009, 2007], freq="A-JUN")
+        idx = PeriodIndex([2000, 2007, 2007, 2009, 2007], freq="Y-JUN")
         ts = Series(np.random.default_rng(2).standard_normal(len(idx)), index=idx)
 
         result = ts["2007"]
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index 6d8ae1793d5ec..0e12457293ae3 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -18,7 +18,7 @@
 
 class TestPeriodIndex:
     def test_make_time_series(self):
-        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        index = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
         series = Series(1, index=index)
         assert isinstance(series, Series)
 
@@ -67,7 +67,7 @@ def test_values(self):
         tm.assert_numpy_array_equal(idx.asi8, exp)
 
     def test_period_index_length(self):
-        pi = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        pi = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
         assert len(pi) == 9
 
         pi = period_range(freq="Q", start="1/1/2001", end="12/1/2009")
@@ -157,7 +157,7 @@ def test_period_index_length(self):
     @pytest.mark.parametrize(
         "periodindex",
         [
-            period_range(freq="A", start="1/1/2001", end="12/1/2005"),
+            period_range(freq="Y", start="1/1/2001", end="12/1/2005"),
             period_range(freq="Q", start="1/1/2001", end="12/1/2002"),
             period_range(freq="M", start="1/1/2001", end="1/1/2002"),
             period_range(freq="D", start="12/1/2001", end="6/1/2001"),
@@ -187,7 +187,7 @@ def test_fields(self, periodindex, field):
             assert getattr(x, field) == val
 
     def test_is_(self):
-        create_index = lambda: period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        create_index = lambda: period_range(freq="Y", start="1/1/2001", end="12/1/2009")
         index = create_index()
         assert index.is_(index)
         assert not index.is_(create_index())
@@ -199,23 +199,23 @@ def test_is_(self):
         assert ind2.is_(index)
         assert not index.is_(index[:])
         assert not index.is_(index.asfreq("M"))
-        assert not index.is_(index.asfreq("A"))
+        assert not index.is_(index.asfreq("Y"))
 
         assert not index.is_(index - 2)
         assert not index.is_(index - 0)
 
     def test_index_unique(self):
-        idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq="A-JUN")
-        expected = PeriodIndex([2000, 2007, 2009], freq="A-JUN")
+        idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq="Y-JUN")
+        expected = PeriodIndex([2000, 2007, 2009], freq="Y-JUN")
         tm.assert_index_equal(idx.unique(), expected)
         assert idx.nunique() == 3
 
     def test_negative_ordinals(self):
-        Period(ordinal=-1000, freq="A")
-        Period(ordinal=0, freq="A")
+        Period(ordinal=-1000, freq="Y")
+        Period(ordinal=0, freq="Y")
 
-        idx1 = PeriodIndex(ordinal=[-1, 0, 1], freq="A")
-        idx2 = PeriodIndex(ordinal=np.array([-1, 0, 1]), freq="A")
+        idx1 = PeriodIndex(ordinal=[-1, 0, 1], freq="Y")
+        idx2 = PeriodIndex(ordinal=np.array([-1, 0, 1]), freq="Y")
         tm.assert_index_equal(idx1, idx2)
 
     def test_pindex_fieldaccessor_nat(self):
@@ -267,14 +267,14 @@ def test_with_multi_index(self):
     def test_map(self):
         # test_map_dictlike generally tests
 
-        index = PeriodIndex([2005, 2007, 2009], freq="A")
+        index = PeriodIndex([2005, 2007, 2009], freq="Y")
         result = index.map(lambda x: x.ordinal)
         exp = Index([x.ordinal for x in index])
         tm.assert_index_equal(result, exp)
 
     def test_format_empty(self):
         # GH35712
-        empty_idx = PeriodIndex([], freq="A")
+        empty_idx = PeriodIndex([], freq="Y")
         assert empty_idx.format() == []
         assert empty_idx.format(name=True) == [""]
 
diff --git a/pandas/tests/indexes/period/test_resolution.py b/pandas/tests/indexes/period/test_resolution.py
index 36f8a1c1bd285..dc70ee53abd2d 100644
--- a/pandas/tests/indexes/period/test_resolution.py
+++ b/pandas/tests/indexes/period/test_resolution.py
@@ -7,7 +7,7 @@ class TestResolution:
     @pytest.mark.parametrize(
         "freq,expected",
         [
-            ("A", "year"),
+            ("Y", "year"),
             ("Q", "quarter"),
             ("M", "month"),
             ("D", "day"),
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 19711ba6329d4..20458b26f2adb 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -977,7 +977,7 @@ def test_str_attribute(self, method):
             Index(range(5)),
             tm.makeDateIndex(10),
             MultiIndex.from_tuples([("foo", "1"), ("bar", "3")]),
-            period_range(start="2000", end="2010", freq="A"),
+            period_range(start="2000", end="2010", freq="Y"),
         ],
     )
     def test_str_attribute_raises(self, index):
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index 28d235812de27..ba4ca09d2051d 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -260,19 +260,19 @@ def test_loc_npstr(self):
     @pytest.mark.parametrize(
         "msg, key",
         [
-            (r"Period\('2019', 'A-DEC'\), 'foo', 'bar'", (Period(2019), "foo", "bar")),
-            (r"Period\('2019', 'A-DEC'\), 'y1', 'bar'", (Period(2019), "y1", "bar")),
-            (r"Period\('2019', 'A-DEC'\), 'foo', 'z1'", (Period(2019), "foo", "z1")),
+            (r"Period\('2019', 'Y-DEC'\), 'foo', 'bar'", (Period(2019), "foo", "bar")),
+            (r"Period\('2019', 'Y-DEC'\), 'y1', 'bar'", (Period(2019), "y1", "bar")),
+            (r"Period\('2019', 'Y-DEC'\), 'foo', 'z1'", (Period(2019), "foo", "z1")),
             (
-                r"Period\('2018', 'A-DEC'\), Period\('2016', 'A-DEC'\), 'bar'",
+                r"Period\('2018', 'Y-DEC'\), Period\('2016', 'Y-DEC'\), 'bar'",
                 (Period(2018), Period(2016), "bar"),
             ),
-            (r"Period\('2018', 'A-DEC'\), 'foo', 'y1'", (Period(2018), "foo", "y1")),
+            (r"Period\('2018', 'Y-DEC'\), 'foo', 'y1'", (Period(2018), "foo", "y1")),
             (
-                r"Period\('2017', 'A-DEC'\), 'foo', Period\('2015', 'A-DEC'\)",
+                r"Period\('2017', 'Y-DEC'\), 'foo', Period\('2015', 'Y-DEC'\)",
                 (Period(2017), "foo", Period(2015)),
             ),
-            (r"Period\('2017', 'A-DEC'\), 'z1', 'bar'", (Period(2017), "z1", "bar")),
+            (r"Period\('2017', 'Y-DEC'\), 'z1', 'bar'", (Period(2017), "z1", "bar")),
         ],
     )
     def test_contains_raise_error_if_period_index_is_in_multi_index(self, msg, key):
diff --git a/pandas/tests/io/json/test_json_table_schema.py b/pandas/tests/io/json/test_json_table_schema.py
index fc2edc7559a48..d7a4dfca90b5e 100644
--- a/pandas/tests/io/json/test_json_table_schema.py
+++ b/pandas/tests/io/json/test_json_table_schema.py
@@ -150,7 +150,7 @@ def test_as_json_table_type_bool_data(self, bool_type):
             pd.to_datetime(["2016"], utc=True),
             pd.Series(pd.to_datetime(["2016"])),
             pd.Series(pd.to_datetime(["2016"], utc=True)),
-            pd.period_range("2016", freq="A", periods=3),
+            pd.period_range("2016", freq="Y", periods=3),
         ],
     )
     def test_as_json_table_type_date_data(self, date_data):
@@ -480,9 +480,9 @@ def test_convert_pandas_type_to_json_field_datetime(
         assert result == expected
 
     def test_convert_pandas_type_to_json_period_range(self):
-        arr = pd.period_range("2016", freq="A-DEC", periods=4)
+        arr = pd.period_range("2016", freq="Y-DEC", periods=4)
         result = convert_pandas_type_to_json_field(arr)
-        expected = {"name": "values", "type": "datetime", "freq": "A-DEC"}
+        expected = {"name": "values", "type": "datetime", "freq": "Y-DEC"}
         assert result == expected
 
     @pytest.mark.parametrize("kind", [pd.Categorical, pd.CategoricalIndex])
diff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py
index 0a432161adb08..d84b8e675c98c 100644
--- a/pandas/tests/plotting/test_datetimelike.py
+++ b/pandas/tests/plotting/test_datetimelike.py
@@ -102,8 +102,8 @@ def test_is_error_nozeroindex(self):
         _check_plot_works(a.plot, yerr=a)
 
     def test_nonnumeric_exclude(self):
-        idx = date_range("1/1/1987", freq="A", periods=3)
-        df = DataFrame({"A": ["x", "y", "z"], "B": [1, 2, 3]}, idx)
+        idx = date_range("1/1/1987", freq="Y", periods=3)
+        df = DataFrame({"Y": ["x", "y", "z"], "B": [1, 2, 3]}, idx)
 
         fig, ax = mpl.pyplot.subplots()
         df.plot(ax=ax)  # it works
@@ -111,13 +111,13 @@ def test_nonnumeric_exclude(self):
         mpl.pyplot.close(fig)
 
     def test_nonnumeric_exclude_error(self):
-        idx = date_range("1/1/1987", freq="A", periods=3)
-        df = DataFrame({"A": ["x", "y", "z"], "B": [1, 2, 3]}, idx)
+        idx = date_range("1/1/1987", freq="Y", periods=3)
+        df = DataFrame({"Y": ["x", "y", "z"], "B": [1, 2, 3]}, idx)
         msg = "no numeric data to plot"
         with pytest.raises(TypeError, match=msg):
-            df["A"].plot()
+            df["Y"].plot()
 
-    @pytest.mark.parametrize("freq", ["S", "min", "H", "D", "W", "M", "Q", "A"])
+    @pytest.mark.parametrize("freq", ["S", "min", "H", "D", "W", "M", "Q", "Y"])
     def test_tsplot_period(self, freq):
         idx = period_range("12/31/1999", freq=freq, periods=100)
         ser = Series(np.random.default_rng(2).standard_normal(len(idx)), idx)
@@ -125,7 +125,7 @@ def test_tsplot_period(self, freq):
         _check_plot_works(ser.plot, ax=ax)
 
     @pytest.mark.parametrize(
-        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "Y", "1B30Min"]
     )
     def test_tsplot_datetime(self, freq):
         idx = date_range("12/31/1999", freq=freq, periods=100)
@@ -165,8 +165,8 @@ def test_get_datevalue(self):
         from pandas.plotting._matplotlib.converter import get_datevalue
 
         assert get_datevalue(None, "D") is None
-        assert get_datevalue(1987, "A") == 1987
-        assert get_datevalue(Period(1987, "A"), "M") == Period("1987-12", "M").ordinal
+        assert get_datevalue(1987, "Y") == 1987
+        assert get_datevalue(Period(1987, "Y"), "M") == Period("1987-12", "M").ordinal
         assert get_datevalue("1/1/1987", "D") == Period("1987-1-1", "D").ordinal
 
     def test_ts_plot_format_coord(self):
@@ -176,7 +176,7 @@ def check_format_of_first_point(ax, expected_string):
             first_y = first_line.get_ydata()[0]
             assert expected_string == ax.format_coord(first_x, first_y)
 
-        annual = Series(1, index=date_range("2014-01-01", periods=3, freq="A-DEC"))
+        annual = Series(1, index=date_range("2014-01-01", periods=3, freq="Y-DEC"))
         _, ax = mpl.pyplot.subplots()
         annual.plot(ax=ax)
         check_format_of_first_point(ax, "t = 2014  y = 1.000000")
@@ -187,14 +187,14 @@ def check_format_of_first_point(ax, expected_string):
         daily.plot(ax=ax)
         check_format_of_first_point(ax, "t = 2014-01-01  y = 1.000000")
 
-    @pytest.mark.parametrize("freq", ["S", "min", "H", "D", "W", "M", "Q", "A"])
+    @pytest.mark.parametrize("freq", ["S", "min", "H", "D", "W", "M", "Q", "Y"])
     def test_line_plot_period_series(self, freq):
         idx = period_range("12/31/1999", freq=freq, periods=100)
         ser = Series(np.random.default_rng(2).standard_normal(len(idx)), idx)
         _check_plot_works(ser.plot, ser.index.freq)
 
     @pytest.mark.parametrize(
-        "frqncy", ["1S", "3S", "5min", "7H", "4D", "8W", "11M", "3A"]
+        "frqncy", ["1S", "3S", "5min", "7H", "4D", "8W", "11M", "3Y"]
     )
     def test_line_plot_period_mlt_series(self, frqncy):
         # test period index line plot for series with multiples (`mlt`) of the
@@ -204,14 +204,14 @@ def test_line_plot_period_mlt_series(self, frqncy):
         _check_plot_works(s.plot, s.index.freq.rule_code)
 
     @pytest.mark.parametrize(
-        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "Y", "1B30Min"]
     )
     def test_line_plot_datetime_series(self, freq):
         idx = date_range("12/31/1999", freq=freq, periods=100)
         ser = Series(np.random.default_rng(2).standard_normal(len(idx)), idx)
         _check_plot_works(ser.plot, ser.index.freq.rule_code)
 
-    @pytest.mark.parametrize("freq", ["S", "min", "H", "D", "W", "M", "Q", "A"])
+    @pytest.mark.parametrize("freq", ["S", "min", "H", "D", "W", "M", "Q", "Y"])
     def test_line_plot_period_frame(self, freq):
         idx = date_range("12/31/1999", freq=freq, periods=100)
         df = DataFrame(
@@ -222,7 +222,7 @@ def test_line_plot_period_frame(self, freq):
         _check_plot_works(df.plot, df.index.freq)
 
     @pytest.mark.parametrize(
-        "frqncy", ["1S", "3S", "5min", "7H", "4D", "8W", "11M", "3A"]
+        "frqncy", ["1S", "3S", "5min", "7H", "4D", "8W", "11M", "3Y"]
     )
     def test_line_plot_period_mlt_frame(self, frqncy):
         # test period index line plot for DataFrames with multiples (`mlt`)
@@ -239,7 +239,7 @@ def test_line_plot_period_mlt_frame(self, frqncy):
 
     @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
     @pytest.mark.parametrize(
-        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "Y", "1B30Min"]
     )
     def test_line_plot_datetime_frame(self, freq):
         idx = date_range("12/31/1999", freq=freq, periods=100)
@@ -252,7 +252,7 @@ def test_line_plot_datetime_frame(self, freq):
         _check_plot_works(df.plot, freq)
 
     @pytest.mark.parametrize(
-        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "A", "1B30Min"]
+        "freq", ["S", "min", "H", "D", "W", "M", "Q-DEC", "Y", "1B30Min"]
     )
     def test_line_plot_inferred_freq(self, freq):
         idx = date_range("12/31/1999", freq=freq, periods=100)
@@ -438,7 +438,7 @@ def test_get_finder(self):
         assert conv.get_finder(to_offset("D")) == conv._daily_finder
         assert conv.get_finder(to_offset("M")) == conv._monthly_finder
         assert conv.get_finder(to_offset("Q")) == conv._quarterly_finder
-        assert conv.get_finder(to_offset("A")) == conv._annual_finder
+        assert conv.get_finder(to_offset("Y")) == conv._annual_finder
         assert conv.get_finder(to_offset("W")) == conv._daily_finder
 
     def test_finder_daily(self):
@@ -521,10 +521,10 @@ def test_finder_monthly_long(self):
 
     def test_finder_annual(self):
         xp = [1987, 1988, 1990, 1990, 1995, 2020, 2070, 2170]
-        xp = [Period(x, freq="A").ordinal for x in xp]
+        xp = [Period(x, freq="Y").ordinal for x in xp]
         rs = []
         for nyears in [5, 10, 19, 49, 99, 199, 599, 1001]:
-            rng = period_range("1987", periods=nyears, freq="A")
+            rng = period_range("1987", periods=nyears, freq="Y")
             ser = Series(np.random.default_rng(2).standard_normal(len(rng)), rng)
             _, ax = mpl.pyplot.subplots()
             ser.plot(ax=ax)
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index c504f99b9df74..ed3eff7ef38a7 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -435,7 +435,7 @@ def test_resample_frame_basic_cy_funcs(f, unit):
     g._cython_agg_general(f, alt=None, numeric_only=True)
 
 
-@pytest.mark.parametrize("freq", ["A", "M"])
+@pytest.mark.parametrize("freq", ["Y", "M"])
 def test_resample_frame_basic_M_A(freq, unit):
     df = tm.makeTimeDataFrame()
     df.index = df.index.as_unit(unit)
@@ -668,8 +668,8 @@ def test_resample_reresample(unit):
 @pytest.mark.parametrize(
     "freq, expected_kwargs",
     [
-        ["A-DEC", {"start": "1990", "end": "2000", "freq": "a-dec"}],
-        ["A-JUN", {"start": "1990", "end": "2000", "freq": "a-jun"}],
+        ["Y-DEC", {"start": "1990", "end": "2000", "freq": "y-dec"}],
+        ["Y-JUN", {"start": "1990", "end": "2000", "freq": "y-jun"}],
         ["M", {"start": "1990-01", "end": "2000-01", "freq": "M"}],
     ],
 )
@@ -1199,7 +1199,7 @@ def test_resample_anchored_intraday(simple_date_range_series, unit):
     assert len(resampled) == 1
 
 
-@pytest.mark.parametrize("freq", ["MS", "BMS", "QS-MAR", "AS-DEC", "AS-JUN"])
+@pytest.mark.parametrize("freq", ["MS", "BMS", "QS-MAR", "YS-DEC", "YS-JUN"])
 def test_resample_anchored_monthstart(simple_date_range_series, freq, unit):
     ts = simple_date_range_series("1/1/2000", "12/31/2002")
     ts.index = ts.index.as_unit(unit)
@@ -1240,7 +1240,7 @@ def test_corner_cases_period(simple_period_range_series):
     # miscellaneous test coverage
     len0pts = simple_period_range_series("2007-01", "2010-05", freq="M")[:0]
     # it works
-    result = len0pts.resample("A-DEC").mean()
+    result = len0pts.resample("Y-DEC").mean()
     assert len(result) == 0
 
 
@@ -1347,7 +1347,7 @@ def test_resample_unequal_times(unit):
     df = DataFrame({"close": 1}, index=bad_ind)
 
     # it works!
-    df.resample("AS").sum()
+    df.resample("YS").sum()
 
 
 def test_resample_consistency(unit):
@@ -2011,7 +2011,7 @@ def test_long_rule_non_nano():
                 "1900-12-31",
             ]
         ).astype("datetime64[s]"),
-        freq="200A-DEC",
+        freq="200Y-DEC",
     )
     expected = Series([1.0, 3.0, 6.5, 4.0, 3.0, 6.5, 4.0, 3.0, 6.5], index=expected_idx)
     tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index 074302f12f64f..8ed73f02a51a4 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -107,7 +107,7 @@ def test_selection(self, index, freq, kind, kwargs):
     def test_annual_upsample_cases(
         self, targ, conv, meth, month, simple_period_range_series
     ):
-        ts = simple_period_range_series("1/1/1990", "12/31/1991", freq=f"A-{month}")
+        ts = simple_period_range_series("1/1/1990", "12/31/1991", freq=f"Y-{month}")
         warn = FutureWarning if targ == "B" else None
         msg = r"PeriodDtype\[B\] is deprecated"
         with tm.assert_produces_warning(warn, match=msg):
@@ -118,20 +118,20 @@ def test_annual_upsample_cases(
 
     def test_basic_downsample(self, simple_period_range_series):
         ts = simple_period_range_series("1/1/1990", "6/30/1995", freq="M")
-        result = ts.resample("a-dec").mean()
+        result = ts.resample("y-dec").mean()
 
         expected = ts.groupby(ts.index.year).mean()
-        expected.index = period_range("1/1/1990", "6/30/1995", freq="a-dec")
+        expected.index = period_range("1/1/1990", "6/30/1995", freq="y-dec")
         tm.assert_series_equal(result, expected)
 
         # this is ok
-        tm.assert_series_equal(ts.resample("a-dec").mean(), result)
-        tm.assert_series_equal(ts.resample("a").mean(), result)
+        tm.assert_series_equal(ts.resample("y-dec").mean(), result)
+        tm.assert_series_equal(ts.resample("y").mean(), result)
 
     @pytest.mark.parametrize(
         "rule,expected_error_msg",
         [
-            ("a-dec", "<YearEnd: month=12>"),
+            ("y-dec", "<YearEnd: month=12>"),
             ("q-mar", "<QuarterEnd: startingMonth=3>"),
             ("M", "<MonthEnd>"),
             ("w-thu", "<Week: weekday=3>"),
@@ -150,7 +150,7 @@ def test_not_subperiod(self, simple_period_range_series, rule, expected_error_ms
     @pytest.mark.parametrize("freq", ["D", "2D"])
     def test_basic_upsample(self, freq, simple_period_range_series):
         ts = simple_period_range_series("1/1/1990", "6/30/1995", freq="M")
-        result = ts.resample("a-dec").mean()
+        result = ts.resample("y-dec").mean()
 
         resampled = result.resample(freq, convention="end").ffill()
         expected = result.to_timestamp(freq, how="end")
@@ -158,7 +158,7 @@ def test_basic_upsample(self, freq, simple_period_range_series):
         tm.assert_series_equal(resampled, expected)
 
     def test_upsample_with_limit(self):
-        rng = period_range("1/1/2000", periods=5, freq="A")
+        rng = period_range("1/1/2000", periods=5, freq="Y")
         ts = Series(np.random.default_rng(2).standard_normal(len(rng)), rng)
 
         result = ts.resample("M", convention="end").ffill(limit=2)
@@ -166,13 +166,13 @@ def test_upsample_with_limit(self):
         tm.assert_series_equal(result, expected)
 
     def test_annual_upsample(self, simple_period_range_series):
-        ts = simple_period_range_series("1/1/1990", "12/31/1995", freq="A-DEC")
+        ts = simple_period_range_series("1/1/1990", "12/31/1995", freq="Y-DEC")
         df = DataFrame({"a": ts})
         rdf = df.resample("D").ffill()
         exp = df["a"].resample("D").ffill()
         tm.assert_series_equal(rdf["a"], exp)
 
-        rng = period_range("2000", "2003", freq="A-DEC")
+        rng = period_range("2000", "2003", freq="Y-DEC")
         ts = Series([1, 2, 3, 4], index=rng)
 
         result = ts.resample("M").ffill()
@@ -387,13 +387,13 @@ def test_weekly_upsample(self, day, target, convention, simple_period_range_seri
     def test_resample_to_timestamps(self, simple_period_range_series):
         ts = simple_period_range_series("1/1/1990", "12/31/1995", freq="M")
 
-        result = ts.resample("A-DEC", kind="timestamp").mean()
-        expected = ts.to_timestamp(how="start").resample("A-DEC").mean()
+        result = ts.resample("Y-DEC", kind="timestamp").mean()
+        expected = ts.to_timestamp(how="start").resample("Y-DEC").mean()
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("month", MONTHS)
     def test_resample_to_quarterly(self, simple_period_range_series, month):
-        ts = simple_period_range_series("1990", "1992", freq=f"A-{month}")
+        ts = simple_period_range_series("1990", "1992", freq=f"Y-{month}")
         quar_ts = ts.resample(f"Q-{month}").ffill()
 
         stamps = ts.to_timestamp("D", how="start")
@@ -411,7 +411,7 @@ def test_resample_to_quarterly(self, simple_period_range_series, month):
     @pytest.mark.parametrize("how", ["start", "end"])
     def test_resample_to_quarterly_start_end(self, simple_period_range_series, how):
         # conforms, but different month
-        ts = simple_period_range_series("1990", "1992", freq="A-JUN")
+        ts = simple_period_range_series("1990", "1992", freq="Y-JUN")
         result = ts.resample("Q-MAR", convention=how).ffill()
         expected = ts.asfreq("Q-MAR", how=how)
         expected = expected.reindex(result.index, method="ffill")
@@ -422,21 +422,21 @@ def test_resample_to_quarterly_start_end(self, simple_period_range_series, how):
         tm.assert_series_equal(result, expected)
 
     def test_resample_fill_missing(self):
-        rng = PeriodIndex([2000, 2005, 2007, 2009], freq="A")
+        rng = PeriodIndex([2000, 2005, 2007, 2009], freq="Y")
 
         s = Series(np.random.default_rng(2).standard_normal(4), index=rng)
 
         stamps = s.to_timestamp()
-        filled = s.resample("A").ffill()
-        expected = stamps.resample("A").ffill().to_period("A")
+        filled = s.resample("Y").ffill()
+        expected = stamps.resample("Y").ffill().to_period("Y")
         tm.assert_series_equal(filled, expected)
 
     def test_cant_fill_missing_dups(self):
-        rng = PeriodIndex([2000, 2005, 2005, 2007, 2007], freq="A")
+        rng = PeriodIndex([2000, 2005, 2005, 2007, 2007], freq="Y")
         s = Series(np.random.default_rng(2).standard_normal(5), index=rng)
         msg = "Reindexing only valid with uniquely valued Index objects"
         with pytest.raises(InvalidIndexError, match=msg):
-            s.resample("A").ffill()
+            s.resample("Y").ffill()
 
     @pytest.mark.parametrize("freq", ["5min"])
     @pytest.mark.parametrize("kind", ["period", None, "timestamp"])
@@ -533,13 +533,13 @@ def test_resample_tz_localized(self):
         ts["second"] = np.cumsum(np.random.default_rng(2).standard_normal(len(rng)))
         expected = DataFrame(
             {
-                "first": ts.resample("A").sum()["first"],
-                "second": ts.resample("A").mean()["second"],
+                "first": ts.resample("Y").sum()["first"],
+                "second": ts.resample("Y").mean()["second"],
             },
             columns=["first", "second"],
         )
         result = (
-            ts.resample("A")
+            ts.resample("Y")
             .agg({"first": "sum", "second": "mean"})
             .reindex(columns=["first", "second"])
         )
@@ -569,8 +569,8 @@ def test_quarterly_resampling(self):
         rng = period_range("2000Q1", periods=10, freq="Q-DEC")
         ts = Series(np.arange(10), index=rng)
 
-        result = ts.resample("A").mean()
-        exp = ts.to_timestamp().resample("A").mean().to_period()
+        result = ts.resample("Y").mean()
+        exp = ts.to_timestamp().resample("Y").mean().to_period()
         tm.assert_series_equal(result, exp)
 
     def test_resample_weekly_bug_1726(self):
@@ -643,7 +643,7 @@ def test_monthly_convention_span(self):
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
-        "from_freq, to_freq", [("D", "M"), ("Q", "A"), ("M", "Q"), ("D", "W")]
+        "from_freq, to_freq", [("D", "M"), ("Q", "Y"), ("M", "Q"), ("D", "W")]
     )
     def test_default_right_closed_label(self, from_freq, to_freq):
         idx = date_range(start="8/15/2012", periods=100, freq=from_freq)
@@ -656,7 +656,7 @@ def test_default_right_closed_label(self, from_freq, to_freq):
 
     @pytest.mark.parametrize(
         "from_freq, to_freq",
-        [("D", "MS"), ("Q", "AS"), ("M", "QS"), ("H", "D"), ("min", "H")],
+        [("D", "MS"), ("Q", "YS"), ("M", "QS"), ("H", "D"), ("min", "H")],
     )
     def test_default_left_closed_label(self, from_freq, to_freq):
         idx = date_range(start="8/15/2012", periods=100, freq=from_freq)
@@ -672,7 +672,7 @@ def test_all_values_single_bin(self):
         index = period_range(start="2012-01-01", end="2012-12-31", freq="M")
         s = Series(np.random.default_rng(2).standard_normal(len(index)), index=index)
 
-        result = s.resample("A").mean()
+        result = s.resample("Y").mean()
         tm.assert_almost_equal(result.iloc[0], s.mean())
 
     def test_evenly_divisible_with_no_extra_bins(self):
diff --git a/pandas/tests/resample/test_time_grouper.py b/pandas/tests/resample/test_time_grouper.py
index d7fdbc4fe5f08..bbe66d1f554eb 100644
--- a/pandas/tests/resample/test_time_grouper.py
+++ b/pandas/tests/resample/test_time_grouper.py
@@ -24,7 +24,7 @@ def test_series():
 
 
 def test_apply(test_series):
-    grouper = Grouper(freq="A", label="right", closed="right")
+    grouper = Grouper(freq="Y", label="right", closed="right")
 
     grouped = test_series.groupby(grouper)
 
@@ -44,18 +44,18 @@ def test_count(test_series):
 
     expected = test_series.groupby(lambda x: x.year).count()
 
-    grouper = Grouper(freq="A", label="right", closed="right")
+    grouper = Grouper(freq="Y", label="right", closed="right")
     result = test_series.groupby(grouper).count()
     expected.index = result.index
     tm.assert_series_equal(result, expected)
 
-    result = test_series.resample("A").count()
+    result = test_series.resample("Y").count()
     expected.index = result.index
     tm.assert_series_equal(result, expected)
 
 
 def test_numpy_reduction(test_series):
-    result = test_series.resample("A", closed="right").prod()
+    result = test_series.resample("Y", closed="right").prod()
 
     msg = "using SeriesGroupBy.prod"
     with tm.assert_produces_warning(FutureWarning, match=msg):
diff --git a/pandas/tests/reshape/concat/test_concat.py b/pandas/tests/reshape/concat/test_concat.py
index 4491023125fb2..86cb250adf432 100644
--- a/pandas/tests/reshape/concat/test_concat.py
+++ b/pandas/tests/reshape/concat/test_concat.py
@@ -37,8 +37,8 @@
 class TestConcatenate:
     def test_append_concat(self):
         # GH#1815
-        d1 = date_range("12/31/1990", "12/31/1999", freq="A-DEC")
-        d2 = date_range("12/31/2000", "12/31/2009", freq="A-DEC")
+        d1 = date_range("12/31/1990", "12/31/1999", freq="Y-DEC")
+        d2 = date_range("12/31/2000", "12/31/2009", freq="Y-DEC")
 
         s1 = Series(np.random.default_rng(2).standard_normal(10), d1)
         s2 = Series(np.random.default_rng(2).standard_normal(10), d2)
diff --git a/pandas/tests/scalar/period/test_asfreq.py b/pandas/tests/scalar/period/test_asfreq.py
index 1eab3305980c5..b5ad122323f04 100644
--- a/pandas/tests/scalar/period/test_asfreq.py
+++ b/pandas/tests/scalar/period/test_asfreq.py
@@ -18,7 +18,7 @@ class TestFreqConversion:
     """Test frequency conversion of date objects"""
 
     @pytest.mark.filterwarnings("ignore:Period with BDay:FutureWarning")
-    @pytest.mark.parametrize("freq", ["A", "Q", "M", "W", "B", "D"])
+    @pytest.mark.parametrize("freq", ["Y", "Q", "M", "W", "B", "D"])
     def test_asfreq_near_zero(self, freq):
         # GH#19643, GH#19650
         per = Period("0001-01-01", freq=freq)
@@ -49,7 +49,7 @@ def test_to_timestamp_out_of_bounds(self):
                 per.to_timestamp()
 
     def test_asfreq_corner(self):
-        val = Period(freq="A", year=2007)
+        val = Period(freq="Y", year=2007)
         result1 = val.asfreq("5min")
         result2 = val.asfreq("min")
         expected = Period("2007-12-31 23:59", freq="min")
@@ -61,11 +61,11 @@ def test_asfreq_corner(self):
     def test_conv_annual(self):
         # frequency conversion tests: from Annual Frequency
 
-        ival_A = Period(freq="A", year=2007)
+        ival_A = Period(freq="Y", year=2007)
 
-        ival_AJAN = Period(freq="A-JAN", year=2007)
-        ival_AJUN = Period(freq="A-JUN", year=2007)
-        ival_ANOV = Period(freq="A-NOV", year=2007)
+        ival_AJAN = Period(freq="Y-JAN", year=2007)
+        ival_AJUN = Period(freq="Y-JUN", year=2007)
+        ival_ANOV = Period(freq="Y-NOV", year=2007)
 
         ival_A_to_Q_start = Period(freq="Q", year=2007, quarter=1)
         ival_A_to_Q_end = Period(freq="Q", year=2007, quarter=4)
@@ -131,7 +131,7 @@ def test_conv_annual(self):
         assert ival_ANOV.asfreq("D", "S") == ival_ANOV_to_D_start
         assert ival_ANOV.asfreq("D", "E") == ival_ANOV_to_D_end
 
-        assert ival_A.asfreq("A") == ival_A
+        assert ival_A.asfreq("Y") == ival_A
 
     def test_conv_quarterly(self):
         # frequency conversion tests: from Quarterly Frequency
@@ -142,7 +142,7 @@ def test_conv_quarterly(self):
         ival_QEJAN = Period(freq="Q-JAN", year=2007, quarter=1)
         ival_QEJUN = Period(freq="Q-JUN", year=2007, quarter=1)
 
-        ival_Q_to_A = Period(freq="A", year=2007)
+        ival_Q_to_A = Period(freq="Y", year=2007)
         ival_Q_to_M_start = Period(freq="M", year=2007, month=1)
         ival_Q_to_M_end = Period(freq="M", year=2007, month=3)
         ival_Q_to_W_start = Period(freq="W", year=2007, month=1, day=1)
@@ -173,8 +173,8 @@ def test_conv_quarterly(self):
         ival_QEJUN_to_D_start = Period(freq="D", year=2006, month=7, day=1)
         ival_QEJUN_to_D_end = Period(freq="D", year=2006, month=9, day=30)
 
-        assert ival_Q.asfreq("A") == ival_Q_to_A
-        assert ival_Q_end_of_year.asfreq("A") == ival_Q_to_A
+        assert ival_Q.asfreq("Y") == ival_Q_to_A
+        assert ival_Q_end_of_year.asfreq("Y") == ival_Q_to_A
 
         assert ival_Q.asfreq("M", "S") == ival_Q_to_M_start
         assert ival_Q.asfreq("M", "E") == ival_Q_to_M_end
@@ -205,7 +205,7 @@ def test_conv_monthly(self):
         ival_M = Period(freq="M", year=2007, month=1)
         ival_M_end_of_year = Period(freq="M", year=2007, month=12)
         ival_M_end_of_quarter = Period(freq="M", year=2007, month=3)
-        ival_M_to_A = Period(freq="A", year=2007)
+        ival_M_to_A = Period(freq="Y", year=2007)
         ival_M_to_Q = Period(freq="Q", year=2007, quarter=1)
         ival_M_to_W_start = Period(freq="W", year=2007, month=1, day=1)
         ival_M_to_W_end = Period(freq="W", year=2007, month=1, day=31)
@@ -229,8 +229,8 @@ def test_conv_monthly(self):
             freq="S", year=2007, month=1, day=31, hour=23, minute=59, second=59
         )
 
-        assert ival_M.asfreq("A") == ival_M_to_A
-        assert ival_M_end_of_year.asfreq("A") == ival_M_to_A
+        assert ival_M.asfreq("Y") == ival_M_to_A
+        assert ival_M_end_of_year.asfreq("Y") == ival_M_to_A
         assert ival_M.asfreq("Q") == ival_M_to_Q
         assert ival_M_end_of_quarter.asfreq("Q") == ival_M_to_Q
 
@@ -280,14 +280,14 @@ def test_conv_weekly(self):
         ival_W_end_of_year = Period(freq="W", year=2007, month=12, day=31)
         ival_W_end_of_quarter = Period(freq="W", year=2007, month=3, day=31)
         ival_W_end_of_month = Period(freq="W", year=2007, month=1, day=31)
-        ival_W_to_A = Period(freq="A", year=2007)
+        ival_W_to_A = Period(freq="Y", year=2007)
         ival_W_to_Q = Period(freq="Q", year=2007, quarter=1)
         ival_W_to_M = Period(freq="M", year=2007, month=1)
 
         if Period(freq="D", year=2007, month=12, day=31).weekday == 6:
-            ival_W_to_A_end_of_year = Period(freq="A", year=2007)
+            ival_W_to_A_end_of_year = Period(freq="Y", year=2007)
         else:
-            ival_W_to_A_end_of_year = Period(freq="A", year=2008)
+            ival_W_to_A_end_of_year = Period(freq="Y", year=2008)
 
         if Period(freq="D", year=2007, month=3, day=31).weekday == 6:
             ival_W_to_Q_end_of_quarter = Period(freq="Q", year=2007, quarter=1)
@@ -319,8 +319,8 @@ def test_conv_weekly(self):
             freq="S", year=2007, month=1, day=7, hour=23, minute=59, second=59
         )
 
-        assert ival_W.asfreq("A") == ival_W_to_A
-        assert ival_W_end_of_year.asfreq("A") == ival_W_to_A_end_of_year
+        assert ival_W.asfreq("Y") == ival_W_to_A
+        assert ival_W_end_of_year.asfreq("Y") == ival_W_to_A_end_of_year
 
         assert ival_W.asfreq("Q") == ival_W_to_Q
         assert ival_W_end_of_quarter.asfreq("Q") == ival_W_to_Q_end_of_quarter
@@ -392,7 +392,7 @@ def test_conv_business(self):
             ival_B_end_of_month = Period(freq="B", year=2007, month=1, day=31)
             ival_B_end_of_week = Period(freq="B", year=2007, month=1, day=5)
 
-        ival_B_to_A = Period(freq="A", year=2007)
+        ival_B_to_A = Period(freq="Y", year=2007)
         ival_B_to_Q = Period(freq="Q", year=2007, quarter=1)
         ival_B_to_M = Period(freq="M", year=2007, month=1)
         ival_B_to_W = Period(freq="W", year=2007, month=1, day=7)
@@ -412,8 +412,8 @@ def test_conv_business(self):
             freq="S", year=2007, month=1, day=1, hour=23, minute=59, second=59
         )
 
-        assert ival_B.asfreq("A") == ival_B_to_A
-        assert ival_B_end_of_year.asfreq("A") == ival_B_to_A
+        assert ival_B.asfreq("Y") == ival_B_to_A
+        assert ival_B_end_of_year.asfreq("Y") == ival_B_to_A
         assert ival_B.asfreq("Q") == ival_B_to_Q
         assert ival_B_end_of_quarter.asfreq("Q") == ival_B_to_Q
         assert ival_B.asfreq("M") == ival_B_to_M
@@ -450,11 +450,11 @@ def test_conv_daily(self):
             ival_B_friday = Period(freq="B", year=2007, month=1, day=5)
             ival_B_monday = Period(freq="B", year=2007, month=1, day=8)
 
-        ival_D_to_A = Period(freq="A", year=2007)
+        ival_D_to_A = Period(freq="Y", year=2007)
 
-        ival_Deoq_to_AJAN = Period(freq="A-JAN", year=2008)
-        ival_Deoq_to_AJUN = Period(freq="A-JUN", year=2007)
-        ival_Deoq_to_ADEC = Period(freq="A-DEC", year=2007)
+        ival_Deoq_to_AJAN = Period(freq="Y-JAN", year=2008)
+        ival_Deoq_to_AJUN = Period(freq="Y-JUN", year=2007)
+        ival_Deoq_to_ADEC = Period(freq="Y-DEC", year=2007)
 
         ival_D_to_QEJAN = Period(freq="Q-JAN", year=2007, quarter=4)
         ival_D_to_QEJUN = Period(freq="Q-JUN", year=2007, quarter=3)
@@ -478,13 +478,13 @@ def test_conv_daily(self):
             freq="S", year=2007, month=1, day=1, hour=23, minute=59, second=59
         )
 
-        assert ival_D.asfreq("A") == ival_D_to_A
+        assert ival_D.asfreq("Y") == ival_D_to_A
 
-        assert ival_D_end_of_quarter.asfreq("A-JAN") == ival_Deoq_to_AJAN
-        assert ival_D_end_of_quarter.asfreq("A-JUN") == ival_Deoq_to_AJUN
-        assert ival_D_end_of_quarter.asfreq("A-DEC") == ival_Deoq_to_ADEC
+        assert ival_D_end_of_quarter.asfreq("Y-JAN") == ival_Deoq_to_AJAN
+        assert ival_D_end_of_quarter.asfreq("Y-JUN") == ival_Deoq_to_AJUN
+        assert ival_D_end_of_quarter.asfreq("Y-DEC") == ival_Deoq_to_ADEC
 
-        assert ival_D_end_of_year.asfreq("A") == ival_D_to_A
+        assert ival_D_end_of_year.asfreq("Y") == ival_D_to_A
         assert ival_D_end_of_quarter.asfreq("Q") == ival_D_to_QEDEC
         assert ival_D.asfreq("Q-JAN") == ival_D_to_QEJAN
         assert ival_D.asfreq("Q-JUN") == ival_D_to_QEJUN
@@ -521,7 +521,7 @@ def test_conv_hourly(self):
         ival_H_end_of_day = Period(freq="H", year=2007, month=1, day=1, hour=23)
         ival_H_end_of_bus = Period(freq="H", year=2007, month=1, day=1, hour=23)
 
-        ival_H_to_A = Period(freq="A", year=2007)
+        ival_H_to_A = Period(freq="Y", year=2007)
         ival_H_to_Q = Period(freq="Q", year=2007, quarter=1)
         ival_H_to_M = Period(freq="M", year=2007, month=1)
         ival_H_to_W = Period(freq="W", year=2007, month=1, day=7)
@@ -542,8 +542,8 @@ def test_conv_hourly(self):
             freq="S", year=2007, month=1, day=1, hour=0, minute=59, second=59
         )
 
-        assert ival_H.asfreq("A") == ival_H_to_A
-        assert ival_H_end_of_year.asfreq("A") == ival_H_to_A
+        assert ival_H.asfreq("Y") == ival_H_to_A
+        assert ival_H_end_of_year.asfreq("Y") == ival_H_to_A
         assert ival_H.asfreq("Q") == ival_H_to_Q
         assert ival_H_end_of_quarter.asfreq("Q") == ival_H_to_Q
         assert ival_H.asfreq("M") == ival_H_to_M
@@ -589,7 +589,7 @@ def test_conv_minutely(self):
             freq="Min", year=2007, month=1, day=1, hour=0, minute=59
         )
 
-        ival_T_to_A = Period(freq="A", year=2007)
+        ival_T_to_A = Period(freq="Y", year=2007)
         ival_T_to_Q = Period(freq="Q", year=2007, quarter=1)
         ival_T_to_M = Period(freq="M", year=2007, month=1)
         ival_T_to_W = Period(freq="W", year=2007, month=1, day=7)
@@ -605,8 +605,8 @@ def test_conv_minutely(self):
             freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=59
         )
 
-        assert ival_T.asfreq("A") == ival_T_to_A
-        assert ival_T_end_of_year.asfreq("A") == ival_T_to_A
+        assert ival_T.asfreq("Y") == ival_T_to_A
+        assert ival_T_end_of_year.asfreq("Y") == ival_T_to_A
         assert ival_T.asfreq("Q") == ival_T_to_Q
         assert ival_T_end_of_quarter.asfreq("Q") == ival_T_to_Q
         assert ival_T.asfreq("M") == ival_T_to_M
@@ -655,7 +655,7 @@ def test_conv_secondly(self):
             freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=59
         )
 
-        ival_S_to_A = Period(freq="A", year=2007)
+        ival_S_to_A = Period(freq="Y", year=2007)
         ival_S_to_Q = Period(freq="Q", year=2007, quarter=1)
         ival_S_to_M = Period(freq="M", year=2007, month=1)
         ival_S_to_W = Period(freq="W", year=2007, month=1, day=7)
@@ -665,8 +665,8 @@ def test_conv_secondly(self):
         ival_S_to_H = Period(freq="H", year=2007, month=1, day=1, hour=0)
         ival_S_to_T = Period(freq="Min", year=2007, month=1, day=1, hour=0, minute=0)
 
-        assert ival_S.asfreq("A") == ival_S_to_A
-        assert ival_S_end_of_year.asfreq("A") == ival_S_to_A
+        assert ival_S.asfreq("Y") == ival_S_to_A
+        assert ival_S_end_of_year.asfreq("Y") == ival_S_to_A
         assert ival_S.asfreq("Q") == ival_S_to_Q
         assert ival_S_end_of_quarter.asfreq("Q") == ival_S_to_Q
         assert ival_S.asfreq("M") == ival_S_to_M
@@ -705,44 +705,44 @@ def test_conv_microsecond(self):
 
     def test_asfreq_mult(self):
         # normal freq to mult freq
-        p = Period(freq="A", year=2007)
+        p = Period(freq="Y", year=2007)
         # ordinal will not change
-        for freq in ["3A", offsets.YearEnd(3)]:
+        for freq in ["3Y", offsets.YearEnd(3)]:
             result = p.asfreq(freq)
-            expected = Period("2007", freq="3A")
+            expected = Period("2007", freq="3Y")
 
             assert result == expected
             assert result.ordinal == expected.ordinal
             assert result.freq == expected.freq
         # ordinal will not change
-        for freq in ["3A", offsets.YearEnd(3)]:
+        for freq in ["3Y", offsets.YearEnd(3)]:
             result = p.asfreq(freq, how="S")
-            expected = Period("2007", freq="3A")
+            expected = Period("2007", freq="3Y")
 
             assert result == expected
             assert result.ordinal == expected.ordinal
             assert result.freq == expected.freq
 
         # mult freq to normal freq
-        p = Period(freq="3A", year=2007)
+        p = Period(freq="3Y", year=2007)
         # ordinal will change because how=E is the default
-        for freq in ["A", offsets.YearEnd()]:
+        for freq in ["Y", offsets.YearEnd()]:
             result = p.asfreq(freq)
-            expected = Period("2009", freq="A")
+            expected = Period("2009", freq="Y")
 
             assert result == expected
             assert result.ordinal == expected.ordinal
             assert result.freq == expected.freq
         # ordinal will not change
-        for freq in ["A", offsets.YearEnd()]:
+        for freq in ["Y", offsets.YearEnd()]:
             result = p.asfreq(freq, how="S")
-            expected = Period("2007", freq="A")
+            expected = Period("2007", freq="Y")
 
             assert result == expected
             assert result.ordinal == expected.ordinal
             assert result.freq == expected.freq
 
-        p = Period(freq="A", year=2007)
+        p = Period(freq="Y", year=2007)
         for freq in ["2M", offsets.MonthEnd(2)]:
             result = p.asfreq(freq)
             expected = Period("2007-12", freq="2M")
@@ -758,7 +758,7 @@ def test_asfreq_mult(self):
             assert result.ordinal == expected.ordinal
             assert result.freq == expected.freq
 
-        p = Period(freq="3A", year=2007)
+        p = Period(freq="3Y", year=2007)
         for freq in ["2M", offsets.MonthEnd(2)]:
             result = p.asfreq(freq)
             expected = Period("2009-12", freq="2M")
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index 0acc704ff7a29..f38e594873dd3 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -61,9 +61,9 @@ def test_construction(self):
 
         assert i1 == i2
 
-        i1 = Period("2005", freq="A")
+        i1 = Period("2005", freq="Y")
         i2 = Period("2005")
-        i3 = Period("2005", freq="a")
+        i3 = Period("2005", freq="y")
 
         assert i1 == i2
         assert i1 == i3
@@ -227,7 +227,7 @@ def test_period_constructor_offsets(self):
         assert Period("1/1/2005", freq=offsets.MonthEnd()) == Period(
             "1/1/2005", freq="M"
         )
-        assert Period("2005", freq=offsets.YearEnd()) == Period("2005", freq="A")
+        assert Period("2005", freq=offsets.YearEnd()) == Period("2005", freq="Y")
         assert Period("2005", freq=offsets.MonthEnd()) == Period("2005", freq="M")
         with tm.assert_produces_warning(FutureWarning, match=bday_msg):
             assert Period("3/10/12", freq=offsets.BusinessDay()) == Period(
@@ -318,13 +318,13 @@ def test_invalid_arguments(self):
 
         msg = '^Given date string "-2000" not likely a datetime$'
         with pytest.raises(ValueError, match=msg):
-            Period("-2000", "A")
+            Period("-2000", "Y")
         msg = "day is out of range for month"
         with pytest.raises(DateParseError, match=msg):
-            Period("0", "A")
+            Period("0", "Y")
         msg = "Unknown datetime string format, unable to parse"
         with pytest.raises(DateParseError, match=msg):
-            Period("1/1/-2000", "A")
+            Period("1/1/-2000", "Y")
 
     def test_constructor_corner(self):
         expected = Period("2007-01", freq="2M")
@@ -334,8 +334,8 @@ def test_constructor_corner(self):
 
         p = Period("2007-01-01", freq="D")
 
-        result = Period(p, freq="A")
-        exp = Period("2007", freq="A")
+        result = Period(p, freq="Y")
+        exp = Period("2007", freq="Y")
         assert result == exp
 
     def test_constructor_infer_freq(self):
@@ -363,11 +363,11 @@ def test_constructor_infer_freq(self):
         assert p.freq == "us"
 
     def test_multiples(self):
-        result1 = Period("1989", freq="2A")
-        result2 = Period("1989", freq="A")
+        result1 = Period("1989", freq="2Y")
+        result2 = Period("1989", freq="Y")
         assert result1.ordinal == result2.ordinal
-        assert result1.freqstr == "2A-DEC"
-        assert result2.freqstr == "A-DEC"
+        assert result1.freqstr == "2Y-DEC"
+        assert result2.freqstr == "Y-DEC"
         assert result1.freq == offsets.YearEnd(2)
         assert result2.freq == offsets.YearEnd()
 
@@ -393,7 +393,7 @@ def test_period_cons_quarterly(self, month):
     @pytest.mark.parametrize("month", MONTHS)
     def test_period_cons_annual(self, month):
         # bugs in scikits.timeseries
-        freq = f"A-{month}"
+        freq = f"Y-{month}"
         exp = Period("1989", freq=freq)
         stamp = exp.to_timestamp("D", how="end") + timedelta(days=30)
         p = Period(stamp, freq=freq)
@@ -431,7 +431,7 @@ def test_period_from_ordinal(self):
         assert p == res
         assert isinstance(res, Period)
 
-    @pytest.mark.parametrize("freq", ["A", "M", "D", "H"])
+    @pytest.mark.parametrize("freq", ["Y", "M", "D", "H"])
     def test_construct_from_nat_string_and_freq(self, freq):
         per = Period("NaT", freq=freq)
         assert per is NaT
@@ -624,7 +624,7 @@ def test_to_timestamp_mult(self):
         "ignore:Period with BDay freq is deprecated:FutureWarning"
     )
     def test_to_timestamp(self):
-        p = Period("1982", freq="A")
+        p = Period("1982", freq="Y")
         start_ts = p.to_timestamp(how="S")
         aliases = ["s", "StarT", "BEGIn"]
         for a in aliases:
@@ -638,7 +638,7 @@ def test_to_timestamp(self):
             assert end_ts == p.to_timestamp("D", how=a)
             assert end_ts == p.to_timestamp("3D", how=a)
 
-        from_lst = ["A", "Q", "M", "W", "B", "D", "H", "Min", "S"]
+        from_lst = ["Y", "Q", "M", "W", "B", "D", "H", "Min", "S"]
 
         def _ex(p):
             if p.freq == "B":
@@ -656,7 +656,7 @@ def _ex(p):
 
         # Frequency other than daily
 
-        p = Period("1985", freq="A")
+        p = Period("1985", freq="Y")
 
         result = p.to_timestamp("H", how="end")
         expected = Timestamp(1986, 1, 1) - Timedelta(1, "ns")
@@ -735,7 +735,7 @@ def test_to_timestamp_microsecond(self, ts, expected, freq):
             ("2000-12-15 13:45:26", "S", "2000-12-15 13:45:26", "S"),
             ("2000-12-15 13:45:26", "min", "2000-12-15 13:45", "min"),
             ("2000-12-15 13:45:26", "H", "2000-12-15 13:00", "H"),
-            ("2000-12-15", "Y", "2000", "A-DEC"),
+            ("2000-12-15", "Y", "2000", "Y-DEC"),
             ("2000-12-15", "Q", "2000Q4", "Q-DEC"),
             ("2000-12-15", "M", "2000-12", "M"),
             ("2000-12-15", "W", "2000-12-11/2000-12-17", "W-SUN"),
@@ -766,7 +766,7 @@ def test_strftime(self):
 class TestPeriodProperties:
     """Test properties such as year, month, weekday, etc...."""
 
-    @pytest.mark.parametrize("freq", ["A", "M", "D", "H"])
+    @pytest.mark.parametrize("freq", ["Y", "M", "D", "H"])
     def test_is_leap_year(self, freq):
         # GH 13727
         p = Period("2000-01-01 00:00:00", freq=freq)
@@ -864,7 +864,7 @@ def test_inner_bounds_start_and_end_time(self, bound, offset, period_property):
         assert getattr(period, period_property).floor("S") == expected
 
     def test_start_time(self):
-        freq_lst = ["A", "Q", "M", "D", "H", "min", "S"]
+        freq_lst = ["Y", "Q", "M", "D", "H", "min", "S"]
         xp = datetime(2012, 1, 1)
         for f in freq_lst:
             p = Period("2012", freq=f)
@@ -874,7 +874,7 @@ def test_start_time(self):
         assert Period("2012", freq="W").start_time == datetime(2011, 12, 26)
 
     def test_end_time(self):
-        p = Period("2012", freq="A")
+        p = Period("2012", freq="Y")
 
         def _ex(*args):
             return Timestamp(Timestamp(datetime(*args)).as_unit("ns")._value - 1)
@@ -939,7 +939,7 @@ def _ex(*args):
 
     def test_properties_annually(self):
         # Test properties on Periods with annually frequency.
-        a_date = Period(freq="A", year=2007)
+        a_date = Period(freq="Y", year=2007)
         assert a_date.year == 2007
 
     def test_properties_quarterly(self):
@@ -1199,11 +1199,11 @@ def test_add_sub_td64_nat(self, unit):
             nat - per
 
     def test_sub_delta(self):
-        left, right = Period("2011", freq="A"), Period("2007", freq="A")
+        left, right = Period("2011", freq="Y"), Period("2007", freq="Y")
         result = left - right
         assert result == 4 * right.freq
 
-        msg = r"Input has different freq=M from Period\(freq=A-DEC\)"
+        msg = r"Input has different freq=M from Period\(freq=Y-DEC\)"
         with pytest.raises(IncompatibleFrequency, match=msg):
             left - Period("2007-01", freq="M")
 
@@ -1319,7 +1319,7 @@ def test_sub_n_gt_1_offsets(self, offset, kwd_name, n, normalize):
 
     def test_add_offset(self):
         # freq is DateOffset
-        for freq in ["A", "2A", "3A"]:
+        for freq in ["Y", "2Y", "3Y"]:
             p = Period("2011", freq=freq)
             exp = Period("2013", freq=freq)
             assert p + offsets.YearEnd(2) == exp
@@ -1470,7 +1470,7 @@ def test_sub_offset(self):
             ]
         )
 
-        for freq in ["A", "2A", "3A"]:
+        for freq in ["Y", "2Y", "3Y"]:
             p = Period("2011", freq=freq)
             assert p - offsets.YearEnd(2) == Period("2009", freq=freq)
 
@@ -1592,7 +1592,7 @@ def test_small_year_parsing():
 
 
 def test_negone_ordinals():
-    freqs = ["A", "M", "Q", "D", "H", "min", "S"]
+    freqs = ["Y", "M", "Q", "D", "H", "min", "S"]
 
     period = Period(ordinal=-1, freq="D")
     for freq in freqs:
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 80fd2fd7c0a06..8c906148aaaeb 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -154,7 +154,7 @@ class TestSeriesArithmetic:
     # Some of these may end up in tests/arithmetic, but are not yet sorted
 
     def test_add_series_with_period_index(self):
-        rng = pd.period_range("1/1/2000", "1/1/2010", freq="A")
+        rng = pd.period_range("1/1/2000", "1/1/2010", freq="Y")
         ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
 
         result = ts + ts[::2]
@@ -165,7 +165,7 @@ def test_add_series_with_period_index(self):
         result = ts + _permute(ts[::2])
         tm.assert_series_equal(result, expected)
 
-        msg = "Input has different freq=D from Period\\(freq=A-DEC\\)"
+        msg = "Input has different freq=D from Period\\(freq=Y-DEC\\)"
         with pytest.raises(IncompatibleFrequency, match=msg):
             ts + ts.asfreq("D", how="end")
 
diff --git a/pandas/tests/series/test_repr.py b/pandas/tests/series/test_repr.py
index 4c92b5694c43b..697f7edd71b66 100644
--- a/pandas/tests/series/test_repr.py
+++ b/pandas/tests/series/test_repr.py
@@ -247,7 +247,7 @@ def test_index_repr_in_frame_with_nan(self):
         assert repr(s) == exp
 
     def test_format_pre_1900_dates(self):
-        rng = date_range("1/1/1850", "1/1/1950", freq="A-DEC")
+        rng = date_range("1/1/1850", "1/1/1950", freq="Y-DEC")
         rng.format()
         ts = Series(1, index=rng)
         repr(ts)
diff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py
index 24c2ed3852710..5f10e8a568a9b 100644
--- a/pandas/tests/tseries/frequencies/test_inference.py
+++ b/pandas/tests/tseries/frequencies/test_inference.py
@@ -52,7 +52,7 @@ def base_delta_code_pair(request):
 
 freqs = (
     [f"Q-{month}" for month in MONTHS]
-    + [f"{annual}-{month}" for annual in ["A", "BA"] for month in MONTHS]
+    + [f"{annual}-{month}" for annual in ["Y", "BY"] for month in MONTHS]
     + ["M", "BM", "BMS"]
     + [f"WOM-{count}{day}" for count in range(1, 5) for day in DAYS]
     + [f"W-{day}" for day in DAYS]
@@ -167,7 +167,7 @@ def test_monthly_ambiguous():
 
 def test_annual_ambiguous():
     rng = DatetimeIndex(["1/31/2000", "1/31/2001", "1/31/2002"])
-    assert rng.inferred_freq == "A-JAN"
+    assert rng.inferred_freq == "Y-JAN"
 
 
 @pytest.mark.parametrize("count", range(1, 5))
@@ -215,7 +215,7 @@ def test_infer_freq_index(freq, expected):
     "expected,dates",
     list(
         {
-            "AS-JAN": ["2009-01-01", "2010-01-01", "2011-01-01", "2012-01-01"],
+            "YS-JAN": ["2009-01-01", "2010-01-01", "2011-01-01", "2012-01-01"],
             "Q-OCT": ["2009-01-31", "2009-04-30", "2009-07-31", "2009-10-31"],
             "M": ["2010-11-30", "2010-12-31", "2011-01-31", "2011-02-28"],
             "W-SAT": ["2010-12-25", "2011-01-01", "2011-01-08", "2011-01-15"],
@@ -359,7 +359,7 @@ def test_not_monotonic():
     rng = DatetimeIndex(["1/31/2000", "1/31/2001", "1/31/2002"])
     rng = rng[::-1]
 
-    assert rng.inferred_freq == "-1A-JAN"
+    assert rng.inferred_freq == "-1Y-JAN"
 
 
 def test_non_datetime_index2():
@@ -479,18 +479,18 @@ def test_series_datetime_index(freq):
         "Q@JAN",
         "Q@FEB",
         "Q@MAR",
-        "A@JAN",
-        "A@FEB",
-        "A@MAR",
-        "A@APR",
-        "A@MAY",
-        "A@JUN",
-        "A@JUL",
-        "A@AUG",
-        "A@SEP",
-        "A@OCT",
-        "A@NOV",
-        "A@DEC",
+        "Y@JAN",
+        "Y@FEB",
+        "Y@MAR",
+        "Y@APR",
+        "Y@MAY",
+        "Y@JUN",
+        "Y@JUL",
+        "Y@AUG",
+        "Y@SEP",
+        "Y@OCT",
+        "Y@NOV",
+        "Y@DEC",
         "Y@JAN",
         "WOM@1MON",
         "WOM@2MON",
diff --git a/pandas/tests/tslibs/test_libfrequencies.py b/pandas/tests/tslibs/test_libfrequencies.py
index 83f28f6b5dc01..effd3b4b8b4e5 100644
--- a/pandas/tests/tslibs/test_libfrequencies.py
+++ b/pandas/tests/tslibs/test_libfrequencies.py
@@ -16,10 +16,8 @@
         (offsets.QuarterEnd(startingMonth=12).freqstr, "DEC"),
         ("Q-JAN", "JAN"),
         (offsets.QuarterEnd(startingMonth=1).freqstr, "JAN"),
-        ("A-DEC", "DEC"),
         ("Y-DEC", "DEC"),
         (offsets.YearEnd().freqstr, "DEC"),
-        ("A-MAY", "MAY"),
         ("Y-MAY", "MAY"),
         (offsets.YearEnd(month=5).freqstr, "MAY"),
     ],
diff --git a/pandas/tests/tslibs/test_parsing.py b/pandas/tests/tslibs/test_parsing.py
index 2c8a6827a3bf1..f31f2c0ab55cc 100644
--- a/pandas/tests/tslibs/test_parsing.py
+++ b/pandas/tests/tslibs/test_parsing.py
@@ -138,8 +138,8 @@ def test_parsers_quarterly_with_freq_error(date_str, kwargs, msg):
     "date_str,freq,expected",
     [
         ("2013Q2", None, datetime(2013, 4, 1)),
-        ("2013Q2", "A-APR", datetime(2012, 8, 1)),
-        ("2013-Q2", "A-DEC", datetime(2013, 4, 1)),
+        ("2013Q2", "Y-APR", datetime(2012, 8, 1)),
+        ("2013-Q2", "Y-DEC", datetime(2013, 4, 1)),
     ],
 )
 def test_parsers_quarterly_with_freq(date_str, freq, expected):
@@ -148,7 +148,7 @@ def test_parsers_quarterly_with_freq(date_str, freq, expected):
 
 
 @pytest.mark.parametrize(
-    "date_str", ["2Q 2005", "2Q-200A", "2Q-200", "22Q2005", "2Q200.", "6Q-20"]
+    "date_str", ["2Q 2005", "2Q-200Y", "2Q-200", "22Q2005", "2Q200.", "6Q-20"]
 )
 def test_parsers_quarter_invalid(date_str):
     if date_str == "6Q-20":
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 8fc0815bd8312..821abbd51d5d6 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -62,9 +62,6 @@
     "BQS": "Q",
     "QS": "Q",
     "BQ": "Q",
-    "BA": "A",
-    "AS": "A",
-    "BAS": "A",
     "MS": "M",
     "D": "D",
     "B": "B",
@@ -75,23 +72,22 @@
     "ns": "ns",
     "H": "H",
     "Q": "Q",
-    "A": "A",
     "W": "W",
     "M": "M",
-    "Y": "A",
-    "BY": "A",
-    "YS": "A",
-    "BYS": "A",
+    "Y": "Y",
+    "BY": "Y",
+    "YS": "Y",
+    "BYS": "Y",
 }
 
-_need_suffix = ["QS", "BQ", "BQS", "YS", "AS", "BY", "BA", "BYS", "BAS"]
+_need_suffix = ["QS", "BQ", "BQS", "YS", "BY", "BYS"]
 
 for _prefix in _need_suffix:
     for _m in MONTHS:
         key = f"{_prefix}-{_m}"
         _offset_to_period_map[key] = _offset_to_period_map[_prefix]
 
-for _prefix in ["A", "Q"]:
+for _prefix in ["Y", "Q"]:
     for _m in MONTHS:
         _alias = f"{_prefix}-{_m}"
         _offset_to_period_map[_alias] = _alias
@@ -370,7 +366,7 @@ def _get_annual_rule(self) -> str | None:
         if pos_check is None:
             return None
         else:
-            return {"cs": "AS", "bs": "BAS", "ce": "A", "be": "BA"}.get(pos_check)
+            return {"cs": "YS", "bs": "BYS", "ce": "Y", "be": "BY"}.get(pos_check)
 
     def _get_quarterly_rule(self) -> str | None:
         if len(self.mdiffs) > 1:
@@ -599,7 +595,7 @@ def _quarter_months_conform(source: str, target: str) -> bool:
 
 def _is_annual(rule: str) -> bool:
     rule = rule.upper()
-    return rule == "A" or rule.startswith("A-")
+    return rule == "Y" or rule.startswith("Y-")
 
 
 def _is_quarterly(rule: str) -> bool:

From e97ab5381939946fd7bb617b45712d2430e8bb10 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Fri, 4 Aug 2023 13:58:16 +0200
Subject: [PATCH 28/31] fix tests [skip ci]

---
 pandas/tests/arrays/test_period.py                 |  4 ++--
 pandas/tests/dtypes/test_common.py                 |  2 +-
 pandas/tests/frame/methods/test_asfreq.py          |  2 +-
 pandas/tests/frame/methods/test_join.py            |  2 +-
 pandas/tests/frame/methods/test_reindex.py         |  2 +-
 pandas/tests/frame/test_arithmetic.py              |  2 +-
 pandas/tests/frame/test_reductions.py              |  4 ++--
 pandas/tests/groupby/test_grouping.py              |  2 +-
 pandas/tests/groupby/test_timegrouper.py           |  4 ++--
 pandas/tests/indexes/datetimes/test_misc.py        |  2 +-
 pandas/tests/indexes/datetimes/test_ops.py         |  4 ++--
 pandas/tests/indexes/period/methods/test_asfreq.py | 14 +++++++-------
 pandas/tests/indexes/period/methods/test_astype.py |  2 +-
 .../tests/indexes/period/methods/test_is_full.py   | 10 +++++-----
 pandas/tests/indexes/period/methods/test_shift.py  | 10 +++++-----
 pandas/tests/indexes/period/test_period_range.py   |  2 +-
 pandas/tests/indexes/period/test_pickle.py         |  2 +-
 pandas/tests/indexes/period/test_setops.py         | 12 ++++++------
 pandas/tests/indexes/period/test_tools.py          |  4 ++--
 pandas/tests/internals/test_internals.py           |  4 ++--
 pandas/tests/resample/test_base.py                 |  2 +-
 pandas/tests/reshape/test_pivot.py                 | 10 +++++-----
 pandas/tests/series/methods/test_align.py          |  2 +-
 pandas/tests/series/test_constructors.py           |  2 +-
 pandas/tests/tseries/frequencies/test_freq_code.py |  2 +-
 pandas/tests/tseries/offsets/test_offsets.py       |  4 ++--
 pandas/tests/tslibs/test_conversion.py             |  2 +-
 pandas/tests/tslibs/test_period_asfreq.py          |  2 +-
 28 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/pandas/tests/arrays/test_period.py b/pandas/tests/arrays/test_period.py
index d1e954bc2ebe2..43a80a92573c5 100644
--- a/pandas/tests/arrays/test_period.py
+++ b/pandas/tests/arrays/test_period.py
@@ -82,9 +82,9 @@ def test_setitem(key, value, expected):
 def test_setitem_raises_incompatible_freq():
     arr = PeriodArray(np.arange(3), dtype="period[D]")
     with pytest.raises(IncompatibleFrequency, match="freq"):
-        arr[0] = pd.Period("2000", freq="A")
+        arr[0] = pd.Period("2000", freq="Y")
 
-    other = PeriodArray._from_sequence(["2000", "2001"], dtype="period[A]")
+    other = PeriodArray._from_sequence(["2000", "2001"], dtype="period[Y]")
     with pytest.raises(IncompatibleFrequency, match="freq"):
         arr[[0, 1]] = other
 
diff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py
index e76d80022a5b8..440020d09c876 100644
--- a/pandas/tests/dtypes/test_common.py
+++ b/pandas/tests/dtypes/test_common.py
@@ -274,7 +274,7 @@ def test_is_period_dtype():
         assert not com.is_period_dtype(pd.Period("2017-01-01"))
 
         assert com.is_period_dtype(PeriodDtype(freq="D"))
-        assert com.is_period_dtype(pd.PeriodIndex([], freq="A"))
+        assert com.is_period_dtype(pd.PeriodIndex([], freq="Y"))
 
 
 def test_is_interval_dtype():
diff --git a/pandas/tests/frame/methods/test_asfreq.py b/pandas/tests/frame/methods/test_asfreq.py
index 80ddcf2c33af2..785d5f5b64e82 100644
--- a/pandas/tests/frame/methods/test_asfreq.py
+++ b/pandas/tests/frame/methods/test_asfreq.py
@@ -104,7 +104,7 @@ def test_asfreq_keep_index_name(self, frame_or_series):
         assert index_name == obj.asfreq("10D").index.name
 
     def test_asfreq_ts(self, frame_or_series):
-        index = period_range(freq="A", start="1/1/2001", end="12/31/2010")
+        index = period_range(freq="Y", start="1/1/2001", end="12/31/2010")
         obj = DataFrame(
             np.random.default_rng(2).standard_normal((len(index), 3)), index=index
         )
diff --git a/pandas/tests/frame/methods/test_join.py b/pandas/tests/frame/methods/test_join.py
index 2d4ac1d4a4444..d9796a5b25c63 100644
--- a/pandas/tests/frame/methods/test_join.py
+++ b/pandas/tests/frame/methods/test_join.py
@@ -22,7 +22,7 @@ def frame_with_period_index():
     return DataFrame(
         data=np.arange(20).reshape(4, 5),
         columns=list("abcde"),
-        index=period_range(start="2000", freq="A", periods=4),
+        index=period_range(start="2000", freq="Y", periods=4),
     )
 
 
diff --git a/pandas/tests/frame/methods/test_reindex.py b/pandas/tests/frame/methods/test_reindex.py
index 7f38def847c45..9eaf15d839b46 100644
--- a/pandas/tests/frame/methods/test_reindex.py
+++ b/pandas/tests/frame/methods/test_reindex.py
@@ -36,7 +36,7 @@ def test_dti_set_index_reindex_datetimeindex(self):
         # GH#6631
         df = DataFrame(np.random.default_rng(2).random(6))
         idx1 = date_range("2011/01/01", periods=6, freq="M", tz="US/Eastern")
-        idx2 = date_range("2013", periods=6, freq="A", tz="Asia/Tokyo")
+        idx2 = date_range("2013", periods=6, freq="Y", tz="Asia/Tokyo")
 
         df = df.set_index(idx1)
         tm.assert_index_equal(df.index, idx1)
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 0394241955e9b..387db4bc035c9 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -1230,7 +1230,7 @@ def test_frame_add_tz_mismatch_converts_to_utc(self):
         assert result.index.tz is timezone.utc
 
     def test_align_frame(self):
-        rng = pd.period_range("1/1/2000", "1/1/2010", freq="A")
+        rng = pd.period_range("1/1/2000", "1/1/2010", freq="Y")
         ts = DataFrame(
             np.random.default_rng(2).standard_normal((len(rng), 3)), index=rng
         )
diff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py
index 77ea6885792b4..ede888e0b81e2 100644
--- a/pandas/tests/frame/test_reductions.py
+++ b/pandas/tests/frame/test_reductions.py
@@ -911,7 +911,7 @@ def test_mean_datetimelike(self):
                 "A": np.arange(3),
                 "B": date_range("2016-01-01", periods=3),
                 "C": pd.timedelta_range("1D", periods=3),
-                "D": pd.period_range("2016", periods=3, freq="A"),
+                "D": pd.period_range("2016", periods=3, freq="Y"),
             }
         )
         result = df.mean(numeric_only=True)
@@ -936,7 +936,7 @@ def test_mean_datetimelike_numeric_only_false(self):
         tm.assert_series_equal(result, expected)
 
         # mean of period is not allowed
-        df["D"] = pd.period_range("2016", periods=3, freq="A")
+        df["D"] = pd.period_range("2016", periods=3, freq="Y")
 
         with pytest.raises(TypeError, match="mean is not implemented for Period"):
             df.mean(numeric_only=False)
diff --git a/pandas/tests/groupby/test_grouping.py b/pandas/tests/groupby/test_grouping.py
index 48441de0389a2..661b8e05bffc9 100644
--- a/pandas/tests/groupby/test_grouping.py
+++ b/pandas/tests/groupby/test_grouping.py
@@ -687,7 +687,7 @@ def test_list_grouper_with_nat(self):
         # GH 14715
         df = DataFrame({"date": date_range("1/1/2011", periods=365, freq="D")})
         df.iloc[-1] = pd.NaT
-        grouper = Grouper(key="date", freq="AS")
+        grouper = Grouper(key="date", freq="YS")
 
         # Grouper in a list grouping
         result = df.groupby([grouper])
diff --git a/pandas/tests/groupby/test_timegrouper.py b/pandas/tests/groupby/test_timegrouper.py
index fa69e7da2a466..fabc45c8c3520 100644
--- a/pandas/tests/groupby/test_timegrouper.py
+++ b/pandas/tests/groupby/test_timegrouper.py
@@ -195,7 +195,7 @@ def test_timegrouper_with_reg_groups(self):
             ).set_index(["Date", "Buyer"])
 
             msg = "The default value of numeric_only"
-            result = df.groupby([Grouper(freq="A"), "Buyer"]).sum(numeric_only=True)
+            result = df.groupby([Grouper(freq="1Y"), "Buyer"]).sum(numeric_only=True)
             tm.assert_frame_equal(result, expected)
 
             expected = DataFrame(
@@ -336,7 +336,7 @@ def test_timegrouper_with_reg_groups(self):
             result = df.groupby([Grouper(freq="1M", key="Date")]).sum(numeric_only=True)
             tm.assert_frame_equal(result, expected)
 
-    @pytest.mark.parametrize("freq", ["D", "M", "A", "Q-APR"])
+    @pytest.mark.parametrize("freq", ["D", "M", "Y", "Q-APR"])
     def test_timegrouper_with_reg_groups_freq(self, freq):
         # GH 6764 multiple grouping with/without sort
         df = DataFrame(
diff --git a/pandas/tests/indexes/datetimes/test_misc.py b/pandas/tests/indexes/datetimes/test_misc.py
index 139190962895d..0058a5a99918d 100644
--- a/pandas/tests/indexes/datetimes/test_misc.py
+++ b/pandas/tests/indexes/datetimes/test_misc.py
@@ -146,7 +146,7 @@ def test_datetimeindex_accessors5(self):
         qsfeb = to_offset("QS-FEB")
         bq = to_offset("BQ")
         bqs_apr = to_offset("BQS-APR")
-        as_nov = to_offset("AS-NOV")
+        as_nov = to_offset("YS-NOV")
 
         tests = [
             (freq_m.is_month_start(Timestamp("2013-06-01")), 1),
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index a01d3b80924fd..ff2a1266f3ac4 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -20,7 +20,7 @@ class TestDatetimeIndexOps:
     @pytest.mark.parametrize(
         "freq,expected",
         [
-            ("A", "day"),
+            ("Y", "day"),
             ("Q", "day"),
             ("M", "day"),
             ("D", "day"),
@@ -33,7 +33,7 @@ class TestDatetimeIndexOps:
     )
     def test_resolution(self, request, tz_naive_fixture, freq, expected):
         tz = tz_naive_fixture
-        if freq == "A" and not IS64 and isinstance(tz, tzlocal):
+        if freq == "Y" and not IS64 and isinstance(tz, tzlocal):
             request.node.add_marker(
                 pytest.mark.xfail(reason="OverflowError inside tzlocal past 2038")
             )
diff --git a/pandas/tests/indexes/period/methods/test_asfreq.py b/pandas/tests/indexes/period/methods/test_asfreq.py
index 4f5cfbade4d84..29a1535dfa1ae 100644
--- a/pandas/tests/indexes/period/methods/test_asfreq.py
+++ b/pandas/tests/indexes/period/methods/test_asfreq.py
@@ -10,7 +10,7 @@
 
 class TestPeriodIndex:
     def test_asfreq(self):
-        pi1 = period_range(freq="A", start="1/1/2001", end="1/1/2001")
+        pi1 = period_range(freq="Y", start="1/1/2001", end="1/1/2001")
         pi2 = period_range(freq="Q", start="1/1/2001", end="1/1/2001")
         pi3 = period_range(freq="M", start="1/1/2001", end="1/1/2001")
         pi4 = period_range(freq="D", start="1/1/2001", end="1/1/2001")
@@ -26,42 +26,42 @@ def test_asfreq(self):
         assert pi1.asfreq("Min", "S") == pi6
         assert pi1.asfreq("S", "S") == pi7
 
-        assert pi2.asfreq("A", "S") == pi1
+        assert pi2.asfreq("Y", "S") == pi1
         assert pi2.asfreq("M", "S") == pi3
         assert pi2.asfreq("D", "S") == pi4
         assert pi2.asfreq("H", "S") == pi5
         assert pi2.asfreq("Min", "S") == pi6
         assert pi2.asfreq("S", "S") == pi7
 
-        assert pi3.asfreq("A", "S") == pi1
+        assert pi3.asfreq("Y", "S") == pi1
         assert pi3.asfreq("Q", "S") == pi2
         assert pi3.asfreq("D", "S") == pi4
         assert pi3.asfreq("H", "S") == pi5
         assert pi3.asfreq("Min", "S") == pi6
         assert pi3.asfreq("S", "S") == pi7
 
-        assert pi4.asfreq("A", "S") == pi1
+        assert pi4.asfreq("Y", "S") == pi1
         assert pi4.asfreq("Q", "S") == pi2
         assert pi4.asfreq("M", "S") == pi3
         assert pi4.asfreq("H", "S") == pi5
         assert pi4.asfreq("Min", "S") == pi6
         assert pi4.asfreq("S", "S") == pi7
 
-        assert pi5.asfreq("A", "S") == pi1
+        assert pi5.asfreq("Y", "S") == pi1
         assert pi5.asfreq("Q", "S") == pi2
         assert pi5.asfreq("M", "S") == pi3
         assert pi5.asfreq("D", "S") == pi4
         assert pi5.asfreq("Min", "S") == pi6
         assert pi5.asfreq("S", "S") == pi7
 
-        assert pi6.asfreq("A", "S") == pi1
+        assert pi6.asfreq("Y", "S") == pi1
         assert pi6.asfreq("Q", "S") == pi2
         assert pi6.asfreq("M", "S") == pi3
         assert pi6.asfreq("D", "S") == pi4
         assert pi6.asfreq("H", "S") == pi5
         assert pi6.asfreq("S", "S") == pi7
 
-        assert pi7.asfreq("A", "S") == pi1
+        assert pi7.asfreq("Y", "S") == pi1
         assert pi7.asfreq("Q", "S") == pi2
         assert pi7.asfreq("M", "S") == pi3
         assert pi7.asfreq("D", "S") == pi4
diff --git a/pandas/tests/indexes/period/methods/test_astype.py b/pandas/tests/indexes/period/methods/test_astype.py
index 2a605d136175e..c62e76da28254 100644
--- a/pandas/tests/indexes/period/methods/test_astype.py
+++ b/pandas/tests/indexes/period/methods/test_astype.py
@@ -44,7 +44,7 @@ def test_astype_conversion(self):
         expected = Index([str(x) for x in idx], name="idx")
         tm.assert_index_equal(result, expected)
 
-        idx = period_range("1990", "2009", freq="A", name="idx")
+        idx = period_range("1990", "2009", freq="Y", name="idx")
         result = idx.astype("i8")
         tm.assert_index_equal(result, Index(idx.asi8, name="idx"))
         tm.assert_numpy_array_equal(result.values, idx.asi8)
diff --git a/pandas/tests/indexes/period/methods/test_is_full.py b/pandas/tests/indexes/period/methods/test_is_full.py
index 490f199a59ed7..b4105bedbe21d 100644
--- a/pandas/tests/indexes/period/methods/test_is_full.py
+++ b/pandas/tests/indexes/period/methods/test_is_full.py
@@ -4,19 +4,19 @@
 
 
 def test_is_full():
-    index = PeriodIndex([2005, 2007, 2009], freq="A")
+    index = PeriodIndex([2005, 2007, 2009], freq="Y")
     assert not index.is_full
 
-    index = PeriodIndex([2005, 2006, 2007], freq="A")
+    index = PeriodIndex([2005, 2006, 2007], freq="Y")
     assert index.is_full
 
-    index = PeriodIndex([2005, 2005, 2007], freq="A")
+    index = PeriodIndex([2005, 2005, 2007], freq="Y")
     assert not index.is_full
 
-    index = PeriodIndex([2005, 2005, 2006], freq="A")
+    index = PeriodIndex([2005, 2005, 2006], freq="Y")
     assert index.is_full
 
-    index = PeriodIndex([2006, 2005, 2005], freq="A")
+    index = PeriodIndex([2006, 2005, 2005], freq="Y")
     with pytest.raises(ValueError, match="Index is not monotonic"):
         index.is_full
 
diff --git a/pandas/tests/indexes/period/methods/test_shift.py b/pandas/tests/indexes/period/methods/test_shift.py
index 48dc5f0e64d08..d649dd3da0864 100644
--- a/pandas/tests/indexes/period/methods/test_shift.py
+++ b/pandas/tests/indexes/period/methods/test_shift.py
@@ -29,16 +29,16 @@ def test_pi_shift_ndarray(self):
         tm.assert_index_equal(result, expected)
 
     def test_shift(self):
-        pi1 = period_range(freq="A", start="1/1/2001", end="12/1/2009")
-        pi2 = period_range(freq="A", start="1/1/2002", end="12/1/2010")
+        pi1 = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
+        pi2 = period_range(freq="Y", start="1/1/2002", end="12/1/2010")
 
         tm.assert_index_equal(pi1.shift(0), pi1)
 
         assert len(pi1) == len(pi2)
         tm.assert_index_equal(pi1.shift(1), pi2)
 
-        pi1 = period_range(freq="A", start="1/1/2001", end="12/1/2009")
-        pi2 = period_range(freq="A", start="1/1/2000", end="12/1/2008")
+        pi1 = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
+        pi2 = period_range(freq="Y", start="1/1/2000", end="12/1/2008")
         assert len(pi1) == len(pi2)
         tm.assert_index_equal(pi1.shift(-1), pi2)
 
@@ -117,6 +117,6 @@ def test_shift_gh8083(self):
 
     def test_shift_periods(self):
         # GH #22458 : argument 'n' was deprecated in favor of 'periods'
-        idx = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        idx = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
         tm.assert_index_equal(idx.shift(periods=0), idx)
         tm.assert_index_equal(idx.shift(0), idx)
diff --git a/pandas/tests/indexes/period/test_period_range.py b/pandas/tests/indexes/period/test_period_range.py
index c94ddf57c0ee1..c3623d83e8d48 100644
--- a/pandas/tests/indexes/period/test_period_range.py
+++ b/pandas/tests/indexes/period/test_period_range.py
@@ -20,7 +20,7 @@ def test_required_arguments(self):
         with pytest.raises(ValueError, match=msg):
             period_range("2011-1-1", "2012-1-1", "B")
 
-    @pytest.mark.parametrize("freq", ["D", "W", "M", "Q", "A"])
+    @pytest.mark.parametrize("freq", ["D", "W", "M", "Q", "Y"])
     def test_construction_from_string(self, freq):
         # non-empty
         expected = date_range(
diff --git a/pandas/tests/indexes/period/test_pickle.py b/pandas/tests/indexes/period/test_pickle.py
index 82f906d1e361f..218e69024a202 100644
--- a/pandas/tests/indexes/period/test_pickle.py
+++ b/pandas/tests/indexes/period/test_pickle.py
@@ -12,7 +12,7 @@
 
 
 class TestPickle:
-    @pytest.mark.parametrize("freq", ["D", "M", "A"])
+    @pytest.mark.parametrize("freq", ["D", "M", "Y"])
     def test_pickle_round_trip(self, freq):
         idx = PeriodIndex(["2016-05-16", "NaT", NaT, np.NaN], freq=freq)
         result = tm.round_trip_pickle(idx)
diff --git a/pandas/tests/indexes/period/test_setops.py b/pandas/tests/indexes/period/test_setops.py
index dd05210e417b0..9610db5f0336b 100644
--- a/pandas/tests/indexes/period/test_setops.py
+++ b/pandas/tests/indexes/period/test_setops.py
@@ -81,8 +81,8 @@ def test_union(self, sort):
         other6 = period_range("2000-04-01", freq="M", periods=7)
         expected6 = period_range("2000-01-01", freq="M", periods=10)
 
-        rng7 = period_range("2003-01-01", freq="A", periods=5)
-        other7 = period_range("1998-01-01", freq="A", periods=8)
+        rng7 = period_range("2003-01-01", freq="Y", periods=5)
+        other7 = period_range("1998-01-01", freq="Y", periods=8)
         expected7 = PeriodIndex(
             [
                 "2003",
@@ -96,7 +96,7 @@ def test_union(self, sort):
                 "2001",
                 "2002",
             ],
-            freq="A",
+            freq="Y",
         )
 
         rng8 = PeriodIndex(
@@ -293,9 +293,9 @@ def test_difference(self, sort):
         expected6 = PeriodIndex(["2000-02-01", "2000-01-01", "2000-03-01"], freq="M")
 
         period_rng = ["2003", "2007", "2006", "2005", "2004"]
-        rng7 = PeriodIndex(period_rng, freq="A")
-        other7 = period_range("1998-01-01", freq="A", periods=8)
-        expected7 = PeriodIndex(["2007", "2006"], freq="A")
+        rng7 = PeriodIndex(period_rng, freq="Y")
+        other7 = period_range("1998-01-01", freq="Y", periods=8)
+        expected7 = PeriodIndex(["2007", "2006"], freq="Y")
 
         for rng, other, expected in [
             (rng1, other1, expected1),
diff --git a/pandas/tests/indexes/period/test_tools.py b/pandas/tests/indexes/period/test_tools.py
index 19f7b9a1b70e2..e3be4aac92b3f 100644
--- a/pandas/tests/indexes/period/test_tools.py
+++ b/pandas/tests/indexes/period/test_tools.py
@@ -27,7 +27,7 @@ class TestPeriodRepresentation:
             ("us", "1970-01-01"),
             ("ns", "1970-01-01"),
             ("M", "1970-01"),
-            ("A", 1970),
+            ("Y", 1970),
         ],
     )
     @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
@@ -43,7 +43,7 @@ def test_freq(self, freq, base_date):
 
 class TestPeriodIndexConversion:
     def test_tolist(self):
-        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        index = period_range(freq="Y", start="1/1/2001", end="12/1/2009")
         rs = index.tolist()
         for x in rs:
             assert isinstance(x, Period)
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 97d9f13bd9e9e..63f6417dbad5f 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -1335,13 +1335,13 @@ def test_interval_can_hold_element(self, dtype, element):
         assert not blk._can_hold_element(elem)
 
     def test_period_can_hold_element_emptylist(self):
-        pi = period_range("2016", periods=3, freq="A")
+        pi = period_range("2016", periods=3, freq="Y")
         blk = new_block(pi._data.reshape(1, 3), BlockPlacement([1]), ndim=2)
 
         assert blk._can_hold_element([])
 
     def test_period_can_hold_element(self, element):
-        pi = period_range("2016", periods=3, freq="A")
+        pi = period_range("2016", periods=3, freq="Y")
 
         elem = element(pi)
         self.check_series_setitem(elem, pi, True)
diff --git a/pandas/tests/resample/test_base.py b/pandas/tests/resample/test_base.py
index c39268f3b9477..edf2ef1049464 100644
--- a/pandas/tests/resample/test_base.py
+++ b/pandas/tests/resample/test_base.py
@@ -96,7 +96,7 @@ def test_raises_on_non_datetimelike_index():
         "but got an instance of 'RangeIndex'"
     )
     with pytest.raises(TypeError, match=msg):
-        xp.resample("A")
+        xp.resample("Y")
 
 
 @all_ts
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 18cace98f04d6..79ac2dd0dcdbd 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -441,10 +441,10 @@ def test_pivot_no_values(self):
         tm.assert_frame_equal(res, exp)
 
         res = df.pivot_table(
-            index=Grouper(freq="A"), columns=Grouper(key="dt", freq="M")
+            index=Grouper(freq="Y"), columns=Grouper(key="dt", freq="M")
         )
         exp = DataFrame(
-            [3], index=pd.DatetimeIndex(["2011-12-31"], freq="A"), columns=exp_columns
+            [3], index=pd.DatetimeIndex(["2011-12-31"], freq="Y"), columns=exp_columns
         )
         tm.assert_frame_equal(res, exp)
 
@@ -1269,7 +1269,7 @@ def test_pivot_timegrouper(self, using_array_manager):
 
         expected = DataFrame(
             np.array([10, 18, 3], dtype="int64").reshape(1, 3),
-            index=pd.DatetimeIndex([datetime(2013, 12, 31)], freq="A"),
+            index=pd.DatetimeIndex([datetime(2013, 12, 31)], freq="Y"),
             columns="Carl Joe Mark".split(),
         )
         expected.index.name = "Date"
@@ -1277,7 +1277,7 @@ def test_pivot_timegrouper(self, using_array_manager):
 
         result = pivot_table(
             df,
-            index=Grouper(freq="A"),
+            index=Grouper(freq="Y"),
             columns="Buyer",
             values="Quantity",
             aggfunc="sum",
@@ -1287,7 +1287,7 @@ def test_pivot_timegrouper(self, using_array_manager):
         result = pivot_table(
             df,
             index="Buyer",
-            columns=Grouper(freq="A"),
+            columns=Grouper(freq="Y"),
             values="Quantity",
             aggfunc="sum",
         )
diff --git a/pandas/tests/series/methods/test_align.py b/pandas/tests/series/methods/test_align.py
index 82261be61f9d1..f2786e8ace6a1 100644
--- a/pandas/tests/series/methods/test_align.py
+++ b/pandas/tests/series/methods/test_align.py
@@ -202,7 +202,7 @@ def test_align_dt64tzindex_mismatched_tzs():
 
 
 def test_align_periodindex(join_type):
-    rng = period_range("1/1/2000", "1/1/2010", freq="A")
+    rng = period_range("1/1/2000", "1/1/2010", freq="Y")
     ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
 
     # TODO: assert something?
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 717dfcebfd1fd..fc09bb5e3d122 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -1303,7 +1303,7 @@ def test_construct_from_ints_including_iNaT_scalar_period_dtype(self):
         assert isna(series[2])
 
     def test_constructor_period_incompatible_frequency(self):
-        data = [Period("2000", "D"), Period("2001", "A")]
+        data = [Period("2000", "D"), Period("2001", "Y")]
         result = Series(data)
         assert result.dtype == object
         assert result.tolist() == data
diff --git a/pandas/tests/tseries/frequencies/test_freq_code.py b/pandas/tests/tseries/frequencies/test_freq_code.py
index 51c2a1fd79009..296e89e4d576f 100644
--- a/pandas/tests/tseries/frequencies/test_freq_code.py
+++ b/pandas/tests/tseries/frequencies/test_freq_code.py
@@ -27,7 +27,7 @@ def test_get_to_timestamp_base(freqstr, exp_freqstr):
 @pytest.mark.parametrize(
     "freqstr,expected",
     [
-        ("A", "year"),
+        ("Y", "year"),
         ("Q", "quarter"),
         ("M", "month"),
         ("D", "day"),
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index 56d35790191e2..3aaae7cc2d974 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -839,7 +839,7 @@ def test_rule_code(self):
             "NOV",
             "DEC",
         ]
-        base_lst = ["A", "AS", "BA", "BAS", "Q", "QS", "BQ", "BQS"]
+        base_lst = ["Y", "YS", "BY", "BYS", "Q", "QS", "BQ", "BQS"]
         for base in base_lst:
             for v in suffix_lst:
                 alias = "-".join([base, v])
@@ -858,7 +858,7 @@ def test_freq_offsets():
 class TestReprNames:
     def test_str_for_named_is_name(self):
         # look at all the amazing combinations!
-        month_prefixes = ["A", "AS", "BA", "BAS", "Q", "BQ", "BQS", "QS"]
+        month_prefixes = ["Y", "YS", "BY", "BYS", "Q", "BQ", "BQS", "QS"]
         names = [
             prefix + "-" + month
             for prefix in month_prefixes
diff --git a/pandas/tests/tslibs/test_conversion.py b/pandas/tests/tslibs/test_conversion.py
index c1ab0ba0b5e6f..d0f8923f3ad89 100644
--- a/pandas/tests/tslibs/test_conversion.py
+++ b/pandas/tests/tslibs/test_conversion.py
@@ -73,7 +73,7 @@ def test_tz_convert_single_matches_tz_convert_hourly(tz_aware_fixture):
     _compare_local_to_utc(tz_didx, naive_didx)
 
 
-@pytest.mark.parametrize("freq", ["D", "A"])
+@pytest.mark.parametrize("freq", ["D", "Y"])
 def test_tz_convert_single_matches_tz_convert(tz_aware_fixture, freq):
     tz = tz_aware_fixture
     tz_didx = date_range("2018-01-01", "2020-01-01", freq=freq, tz=tz)
diff --git a/pandas/tests/tslibs/test_period_asfreq.py b/pandas/tests/tslibs/test_period_asfreq.py
index 37231da4fc02d..96f19ac52c264 100644
--- a/pandas/tests/tslibs/test_period_asfreq.py
+++ b/pandas/tests/tslibs/test_period_asfreq.py
@@ -54,7 +54,7 @@ def test_intra_day_conversion_factors(freq1, freq2, expected):
 
 
 @pytest.mark.parametrize(
-    "freq,expected", [("A", 0), ("M", 0), ("W", 1), ("D", 0), ("B", 0)]
+    "freq,expected", [("Y", 0), ("M", 0), ("W", 1), ("D", 0), ("B", 0)]
 )
 def test_period_ordinal_start_values(freq, expected):
     # information for Jan. 1, 1970.

From 21894d98aa1fb8c9cb2c0bcc5c6fca38dd0fde64 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Mon, 7 Aug 2023 09:45:34 +0200
Subject: [PATCH 29/31] fix tests and correct docs

---
 pandas/_libs/tslibs/parsing.pyx    |  2 +-
 pandas/_libs/tslibs/timestamps.pyx |  2 +-
 pandas/core/arrays/datetimes.py    |  2 +-
 pandas/core/arrays/period.py       | 18 +++++++++---------
 pandas/core/dtypes/common.py       |  2 +-
 pandas/core/frame.py               |  2 +-
 pandas/core/generic.py             |  4 ++--
 pandas/core/indexes/datetimes.py   |  4 ++--
 pandas/core/series.py              | 10 +++++-----
 9 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/pandas/_libs/tslibs/parsing.pyx b/pandas/_libs/tslibs/parsing.pyx
index 3643c840a50a6..389870d885b7c 100644
--- a/pandas/_libs/tslibs/parsing.pyx
+++ b/pandas/_libs/tslibs/parsing.pyx
@@ -1208,7 +1208,7 @@ cpdef str get_rule_month(str source):
     >>> get_rule_month('D')
     'DEC'
 
-    >>> get_rule_month('A-JAN')
+    >>> get_rule_month('Y-JAN')
     'JAN'
     """
     source = source.upper()
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index a0749674b8481..5ae90cb4af83a 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -1261,7 +1261,7 @@ cdef class _Timestamp(ABCTimestamp):
         >>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
         >>> # Year end frequency
         >>> ts.to_period(freq='Y')
-        Period('2020', 'A-DEC')
+        Period('2020', 'Y-DEC')
 
         >>> # Month end frequency
         >>> ts.to_period(freq='M')
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index dd2d7c0060392..de603f2bb366d 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -2038,7 +2038,7 @@ def isocalendar(self) -> DataFrame:
         >>> idx = pd.date_range("2012-01-01", "2015-01-01", freq="Y")
         >>> idx
         DatetimeIndex(['2012-12-31', '2013-12-31', '2014-12-31'],
-                      dtype='datetime64[ns]', freq='A-DEC')
+                      dtype='datetime64[ns]', freq='Y-DEC')
         >>> idx.is_leap_year
         array([ True, False, False])
 
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 4df4375c5d701..54fabf3984e70 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -539,7 +539,7 @@ def __arrow_array__(self, type=None):
 
         >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y")
         >>> idx
-        PeriodIndex(['2023', '2024', '2025'], dtype='period[A-DEC]')
+        PeriodIndex(['2023', '2024', '2025'], dtype='period[Y-DEC]')
         >>> idx.dayofyear
         Index([365, 366, 365], dtype='int64')
         """,
@@ -703,10 +703,10 @@ def asfreq(self, freq=None, how: str = "E") -> Self:
 
         Examples
         --------
-        >>> pidx = pd.period_range('2010-01-01', '2015-01-01', freq='A')
+        >>> pidx = pd.period_range('2010-01-01', '2015-01-01', freq='Y')
         >>> pidx
         PeriodIndex(['2010', '2011', '2012', '2013', '2014', '2015'],
-        dtype='period[A-DEC]')
+        dtype='period[Y-DEC]')
 
         >>> pidx.asfreq('M')
         PeriodIndex(['2010-12', '2011-12', '2012-12', '2013-12', '2014-12',
@@ -1019,18 +1019,18 @@ def period_array(
 
     Examples
     --------
-    >>> period_array([pd.Period('2017', freq='A'),
-    ...               pd.Period('2018', freq='A')])
+    >>> period_array([pd.Period('2017', freq='Y'),
+    ...               pd.Period('2018', freq='Y')])
     <PeriodArray>
     ['2017', '2018']
-    Length: 2, dtype: period[A-DEC]
+    Length: 2, dtype: period[Y-DEC]
 
-    >>> period_array([pd.Period('2017', freq='A'),
-    ...               pd.Period('2018', freq='A'),
+    >>> period_array([pd.Period('2017', freq='Y'),
+    ...               pd.Period('2018', freq='Y'),
     ...               pd.NaT])
     <PeriodArray>
     ['2017', '2018', 'NaT']
-    Length: 3, dtype: period[A-DEC]
+    Length: 3, dtype: period[Y-DEC]
 
     Integers that look like years are handled
 
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index a39dafc64c42b..dc6cc47e6b254 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -402,7 +402,7 @@ def is_period_dtype(arr_or_dtype) -> bool:
     False
     >>> is_period_dtype(pd.Period("2017-01-01"))
     False
-    >>> is_period_dtype(pd.PeriodIndex([], freq="A"))
+    >>> is_period_dtype(pd.PeriodIndex([], freq="Y"))
     True
     """
     warnings.warn(
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 331b06b42e7dc..ddbb2d608b172 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -11859,7 +11859,7 @@ def to_period(
         For the yearly frequency
 
         >>> idx.to_period("Y")
-        PeriodIndex(['2001', '2002', '2003'], dtype='period[A-DEC]')
+        PeriodIndex(['2001', '2002', '2003'], dtype='period[Y-DEC]')
         """
         new_obj = self.copy(deep=copy and not using_copy_on_write())
 
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index fc4f34a953805..0660ed5cc3cb7 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -9120,12 +9120,12 @@ def resample(
         assigned to the first quarter of the period.
 
         >>> s = pd.Series([1, 2], index=pd.period_range('2012-01-01',
-        ...                                             freq='A',
+        ...                                             freq='Y',
         ...                                             periods=2))
         >>> s
         2012    1
         2013    2
-        Freq: A-DEC, dtype: int64
+        Freq: Y-DEC, dtype: int64
         >>> s.resample('Q', convention='start').asfreq()
         2012Q1    1.0
         2012Q2    NaN
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index c07ca760cbc8e..a9e9951b70b03 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -997,11 +997,11 @@ def date_range(
 
     **Specify a unit**
 
-    >>> pd.date_range(start="2017-01-01", periods=10, freq="100AS", unit="s")
+    >>> pd.date_range(start="2017-01-01", periods=10, freq="100YS", unit="s")
     DatetimeIndex(['2017-01-01', '2117-01-01', '2217-01-01', '2317-01-01',
                    '2417-01-01', '2517-01-01', '2617-01-01', '2717-01-01',
                    '2817-01-01', '2917-01-01'],
-                  dtype='datetime64[s]', freq='100AS-JAN')
+                  dtype='datetime64[s]', freq='100YS-JAN')
     """
     if freq is None and com.any_none(periods, start, end):
         freq = "D"
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 4677dc2274a52..34b93fc2602f1 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -5639,7 +5639,7 @@ def to_timestamp(
         2023    1
         2024    2
         2025    3
-        Freq: A-DEC, dtype: int64
+        Freq: Y-DEC, dtype: int64
 
         The resulting frequency of the Timestamps is `YearBegin`
 
@@ -5648,7 +5648,7 @@ def to_timestamp(
         2023-01-01    1
         2024-01-01    2
         2025-01-01    3
-        Freq: AS-JAN, dtype: int64
+        Freq: YS-JAN, dtype: int64
 
         Using `freq` which is the offset that the Timestamps will have
 
@@ -5658,7 +5658,7 @@ def to_timestamp(
         2023-01-31    1
         2024-01-31    2
         2025-01-31    3
-        Freq: A-JAN, dtype: int64
+        Freq: Y-JAN, dtype: int64
         """
         if not isinstance(self.index, PeriodIndex):
             raise TypeError(f"unsupported Type {type(self.index).__name__}")
@@ -5693,12 +5693,12 @@ def to_period(self, freq: str | None = None, copy: bool | None = None) -> Series
         2023    1
         2024    2
         2025    3
-        Freq: A-DEC, dtype: int64
+        Freq: Y-DEC, dtype: int64
 
         Viewing the index
 
         >>> s.index
-        PeriodIndex(['2023', '2024', '2025'], dtype='period[A-DEC]')
+        PeriodIndex(['2023', '2024', '2025'], dtype='period[Y-DEC]')
         """
         if not isinstance(self.index, DatetimeIndex):
             raise TypeError(f"unsupported Type {type(self.index).__name__}")

From 4365e23ad7436077e7199b0e137f855ab93c0204 Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Mon, 7 Aug 2023 13:45:54 +0200
Subject: [PATCH 30/31] fix tests and correct user_guide/io.rst

---
 doc/source/user_guide/io.rst                   | 13 +++++++++----
 pandas/tests/arrays/categorical/test_astype.py |  2 +-
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index 006ab5c49e24c..efc55d4499a3c 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -2330,10 +2330,15 @@ A few notes on the generated table schema:
   same behavior of being converted to UTC. In addition, periods will contain
   and additional field ``freq`` with the period's frequency, e.g. ``'A-DEC'``.
 
-  .. ipython:: python
-
-     s_per = pd.Series(1, index=pd.period_range("2016", freq="A-DEC", periods=4))
-     build_table_schema(s_per)
+  .. code-block:: python
+
+     In [293]: s_per = pd.Series(1, index=pd.period_range("2016", freq="A-DEC", periods=4))
+     In [294]: build_table_schema(s_per)
+     Out[294]:
+     {'fields': [{'name': 'index', 'type': 'datetime', 'freq': 'A-DEC'},
+       {'name': 'values', 'type': 'integer'}],
+      'primaryKey': ['index'],
+      'pandas_version': '1.4.0'}
 
 * Categoricals use the ``any`` type and an ``enum`` constraint listing
   the set of possible values. Additionally, an ``ordered`` field is included:
diff --git a/pandas/tests/arrays/categorical/test_astype.py b/pandas/tests/arrays/categorical/test_astype.py
index d2f9f6dffab49..7fba150c9113f 100644
--- a/pandas/tests/arrays/categorical/test_astype.py
+++ b/pandas/tests/arrays/categorical/test_astype.py
@@ -32,7 +32,7 @@ def test_astype_nan_to_int(self, cls, values):
         [
             array(["2019", "2020"], dtype="datetime64[ns, UTC]"),
             array([0, 0], dtype="timedelta64[ns]"),
-            array([Period("2019"), Period("2020")], dtype="period[A-DEC]"),
+            array([Period("2019"), Period("2020")], dtype="period[Y-DEC]"),
             array([Interval(0, 1), Interval(1, 2)], dtype="interval"),
             array([1, np.nan], dtype="Int64"),
         ],

From 705305ecff121cea9cb14da76c104d77949373ef Mon Sep 17 00:00:00 2001
From: Natalia Mokeeva <natalia.mokeeva.de@gmail.com>
Date: Tue, 8 Aug 2023 13:39:47 +0200
Subject: [PATCH 31/31] correct user_guide

---
 pandas/_libs/tslibs/offsets.pyx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index 7e1cc8e2752d9..61b716800e21b 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -2245,7 +2245,7 @@ cdef class BYearEnd(YearOffset):
     normalize : bool, default False
         Normalize start/end dates to midnight before generating date range.
     month : int, default 12
-        class BYearEnd specific integer for the month of the year.
+        A specific integer for the month of the year.
 
     See Also
     --------