CFTimeIndex calendar in repr

doc/whats-new.rst

@@ -82,6 +82,9 @@ New Features
   :py:func:`xarray.decode_cf`) that allows to disable/enable the decoding of timedeltas
   independently of time decoding (:issue:`1621`)
   `Aureliana Barghini <https://github.com/aurghs>`
+- Add ``calendar`` as a new property for ``CFTimeIndex`` and show in ``calendar`` and
+  ``length`` in  ``CFTimeIndex.__repr__`` (:issue:`2416`, :pull:`4092`)
+  `Aaron Spring <https://github.com/aaronspring>`
 
 Bug fixes
 ~~~~~~~~~

xarray/coding/cftimeindex.py

@@ -50,6 +50,7 @@
 from xarray.core.utils import is_scalar
 
 from ..core.common import _contains_cftime_datetimes
+from ..core.formatting import format_array_flat
 from .times import _STANDARD_CALENDARS, cftime_to_nptime, infer_calendar_name
 
 
@@ -259,6 +260,66 @@ def __new__(cls, data, name=None):
         result._cache = {}
         return result
 
+    def __repr__(self):
+        """
+        Return a string representation for this object.
+
+        copied from pandas.io.printing.py
+        expect for attrs.append(("calendar", self.calendar))
+        """
+        klass_name = type(self).__name__
+        len_item = 19  # length of one item in repr
+        # shorten repr for more than 100 items
+        max_width = (19 + 1) * 100 if len(self) <= 100 else 22 * len_item
+        datastr = format_array_flat(self.values, max_width)
+
+        def join_every_second(s, sep=" ", join=", "):
+            # to formatting.py
+            """Join every second item after split(sep)."""
+            ss = s.split(sep)
+            sj = [x + " " + y for x, y in zip(ss[0::2], ss[1::2])]
+            return join.join(sj)
+
+        linebreak_spaces = " " * len(klass_name)
+        linebreak_add = linebreak_spaces + " "
+
+        def insert_linebreak_after_three(s, sep=",", linebreak=" "):
+            """Linebreak after three items split(sep)."""
+            s_sep = s.split(sep)
+            for i in range(len(s_sep)):
+                if i % 3 == 0 and i != 0:
+                    s_sep[i] = f"\n{linebreak}{s_sep[i]}"
+            return sep.join(s_sep)
+
+        if datastr:
+            if len(self) <= 3:
+                datastr = join_every_second(datastr)
+            else:
+                sepstr = "..."
+                if sepstr in datastr:
+                    firststr, laststr = datastr.split(f" {sepstr} ")
+                    firststr = insert_linebreak_after_three(
+                        join_every_second(firststr), linebreak=linebreak_add)
+                    laststr = insert_linebreak_after_three(
+                        join_every_second(laststr), linebreak=linebreak_add)
+                    datastr = f"{firststr},\n{linebreak_spaces}  {sepstr}\n{linebreak_spaces}  {laststr}"
+                else:
+                    datastr = insert_linebreak_after_three(
+                        join_every_second(datastr), linebreak=linebreak_add
+                    )
+
+        attrs = {
+            "dtype": f"'{self.dtype}'",
+            "length": f"{len(self)}",
+            "calendar": f"'{self.calendar}'",
+        }
+        attrs_str = [f"{k}={v}" for k, v in attrs.items()]
+        prepr = f",{' '}".join(attrs_str)
+        if len(self) <= 3:
+            return f"{klass_name}([{datastr}], {prepr})"
+        else:
+            return f"{klass_name}([{datastr}],\n{linebreak_spaces} {prepr})"
+
     def _partial_date_slice(self, resolution, parsed):
         """Adapted from
         pandas.tseries.index.DatetimeIndex._partial_date_slice
@@ -581,6 +642,12 @@ def asi8(self):
             ]
         )
 
+    @property
+    def calendar(self):
+        from .times import infer_calendar_name
+
+        return infer_calendar_name(self)
+
     def _round_via_method(self, freq, method):
         """Round dates using a specified method."""
         from .cftime_offsets import CFTIME_TICKS, to_offset

xarray/tests/test_cftimeindex.py

@@ -884,6 +884,109 @@ def test_cftimeindex_shift_invalid_freq():
         index.shift(1, 1)
 
 
+@requires_cftime
+@pytest.mark.parametrize(
+    ("calendar", "expected"),
+    [
+        ("noleap", "noleap"),
+        ("365_day", "noleap"),
+        ("360_day", "360_day"),
+        ("julian", "julian"),
+        ("gregorian", "gregorian"),
+        ("proleptic_gregorian", "proleptic_gregorian"),
+    ],
+)
+def test_cftimeindex_calendar_property(calendar, expected):
+    index = xr.cftime_range(start="2000", periods=3, calendar=calendar)
+    assert index.calendar == expected
+
+
+@requires_cftime
+@pytest.mark.parametrize(
+    ("calendar", "expected"),
+    [
+        ("noleap", "noleap"),
+        ("365_day", "noleap"),
+        ("360_day", "360_day"),
+        ("julian", "julian"),
+        ("gregorian", "gregorian"),
+        ("proleptic_gregorian", "proleptic_gregorian"),
+    ],
+)
+def test_cftimeindex_calendar_repr(calendar, expected):
+    """Test that cftimeindex has calendar property in repr."""
+    index = xr.cftime_range(start="2000", periods=3, calendar=calendar)
+    repr_str = index.__repr__()
+    assert f" calendar='{expected}'" in repr_str
+    assert "2000-01-01 00:00:00, 2000-01-02 00:00:00" in repr_str
+
+
+@requires_cftime
+@pytest.mark.parametrize("periods", [2, 40])
+def test_cftimeindex_periods_repr(periods):
+    """Test that cftimeindex has periods property in repr."""
+    index = xr.cftime_range(start="2000", periods=periods)
+    repr_str = index.__repr__()
+    assert f" length={periods}" in repr_str
+
+
+@requires_cftime
+@pytest.mark.parametrize("periods", [2, 3, 4, 100, 101])
+def test_cftimeindex_repr_formatting(periods):
+    """Test that cftimeindex.__repr__ is formatted as pd.Index.__repr__."""
+    index = xr.cftime_range(start="2000", periods=periods)
+    repr_str = index.__repr__()
+    print(repr_str)
+    # check for commata
+    assert "2000-01-01 00:00:00, 2000-01-02 00:00:00" in repr_str
+    if periods <= 3:
+        assert "\n" not in repr_str
+        "CFTimeIndex([2000-01-01 00:00:00, 2000-01-02 00:00:00, 2000-01-03 00:00:00], dtype='object', calendar='standard')" == repr_str
+    else:
+        # check for linebreak
+        assert ", 2000-01-03 00:00:00,\n" in repr_str
+        # check for times have same indent
+        lines = repr_str.split("\n")
+        firststr = "2000"
+        assert lines[0].find(firststr) == lines[1].find(firststr)
+        # check for attrs line has one less indent than times
+        assert lines[-1].find("dtype") + 1 == lines[0].find(firststr)
+    # check for ... separation dots
+    if periods > 100:
+        assert "..." in repr_str
+
+
+@requires_cftime
+@pytest.mark.parametrize("periods", [22, 50, 100])
+def test_cftimeindex_repr_101_shorter(periods):
+    index_101 = xr.cftime_range(start="2000", periods=101)
+    index_periods = xr.cftime_range(start="2000", periods=periods)
+    index_101_repr_str = index_101.__repr__()
+    index_periods_repr_str = index_periods.__repr__()
+    assert len(index_101_repr_str) < len(index_periods_repr_str)
+
+
+@requires_cftime
+@pytest.mark.parametrize("periods", [3, 4, 100, 101])
+def test_cftimeindex_repr_compare_pandasIndex(periods):
+    cfindex = xr.cftime_range(start="2000", periods=periods)
+    pdindex = pd.Index(cfindex)
+    cfindex_repr_str = cfindex.__repr__()
+    pdindex_repr_str = pdindex.__repr__()
+    pdindex_repr_str = pdindex_repr_str.replace("Index", "CFTimeIndex")
+    pdindex_repr_str = pdindex_repr_str.replace(f"\n{' '*7}", f"\n{' '*13}")
+    if periods > 3:
+        pdindex_repr_str = pdindex_repr_str.replace("dtype", f"{' '*6}dtype")
+    if periods <= 100:
+        lengthstr = f"length={periods}, "
+    else:
+        lengthstr = ""
+    pdindex_repr_str = pdindex_repr_str.replace(
+        ")", f", {lengthstr}calendar='gregorian')"
+    )
+    assert pdindex_repr_str == cfindex_repr_str
+
+
 @requires_cftime
 def test_parse_array_of_cftime_strings():
     from cftime import DatetimeNoLeap