updating

.github/workflows/pytest.yml

@@ -8,6 +8,10 @@ on:
 
   pull_request:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   linux:
     name: (${{ matrix.python-version }}, ${{ matrix.os }})

chainladder/__init__.py

@@ -197,7 +197,7 @@ def get_option(
         """
         Get the option value for the specified option.
 
-        .. deprecated:: 0.9.3
+        .. deprecated:: 0.10.0
             The ``option`` parameter is deprecated; use ``pat`` instead.
 
         Parameters
@@ -226,7 +226,7 @@ def set_option(
         """
         Set the option value for the specified option.
 
-        .. deprecated:: 0.9.3
+        .. deprecated:: 0.10.0
             The ``option`` parameter is deprecated; use ``pat`` instead.
 
         Parameters
@@ -283,7 +283,7 @@ def reset_option(
         Restores the default value for the specified option. Restores default values for
         all options if pat is None.
 
-        .. deprecated:: 0.9.3
+        .. deprecated:: 0.10.0
             The ``option`` parameter is deprecated; use ``pat`` instead.
 
         Parameters

chainladder/core/base.py

@@ -608,6 +608,8 @@ def subtriangles(self):
         return [k for k, v in vars(self).items() if isinstance(v, TriangleBase)]
 
     def __array__(self):
+        if self.array_backend == "sparse":
+            return self.values.todense()
         return self.values
 
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):

chainladder/core/dunders.py

@@ -110,8 +110,6 @@ def _prep_index(self, x, y):
             raise ValueError('Index broadcasting is ambiguous between ' + str(x_labels) + ' and ' + str(y_labels))
 
     def _prep_columns(self, x, y):
-        x_backend, y_backend = x.array_backend, y.array_backend
-
         if len(x.columns) == 1 and len(y.columns) > 1:
             x.vdims = y.vdims
         elif len(y.columns) == 1 and len(x.columns) > 1:
@@ -140,13 +138,7 @@ def _prep_columns(self, x, y):
             # Ensure both triangles have the same column order
             x = x[new_x_cols]
             y = y[new_x_cols]
-
-        # Reset backends only if they've changed
-        if x.array_backend != x_backend:
-            x = x.set_backend(x_backend, inplace=True)
-        if y.array_backend != y_backend:
-            y = y.set_backend(y_backend, inplace=True)
-
+
         return x, y
 
     def _prep_origin_development(self, obj, other):
@@ -290,6 +282,16 @@ def __rsub__(self, other):
     def __len__(self):
         return self.shape[0]
 
+    # A Triangle is a 4-D container, not a 1-D sequence. Without this, Python
+    # falls back to the legacy iteration protocol (repeatedly calling
+    # __getitem__(0), __getitem__(1), ...), which treats the integer as a
+    # column label and raises. That also makes libraries such as pandas
+    # misclassify a Triangle as a sequence (see is_sequence) and attempt to
+    # iterate it when formatting a Triangle stored in a DataFrame cell,
+    # crashing the display. Declaring the type non-iterable makes pandas fall
+    # back to str(triangle) and render the summary instead (GH #142).
+    __iter__ = None
+
     def __neg__(self):
         obj = self.copy()
         obj.values = -obj.values

chainladder/core/pandas.py

@@ -601,33 +601,100 @@ def drop(
         self,
         labels: str | int | list | None = None,
         axis: Literal["index", "columns", "origin", "development"] | int = 1,
+        index: str | int | list | None = None,
+        columns: str | int | list | None = None,
+        origin: str | int | list | None = None,
+        development: str | int | list | None = None,
     ) -> Triangle:
         """Drop specified labels from rows or columns.
 
-        Remove rows or columns by specifying label names and corresponding axis,
-        or by specifying directly index or column names.
+        Remove labels by specifying label names and corresponding axis, or by
+        specifying directly ``index``, ``columns``, ``origin``, or
+        ``development`` names.
 
         Parameters
         -----------
 
         labels:  str | int | list | None
-            Index or column labels to drop.
+            Index or column labels to drop. A single label or list-like.
 
-        axis: {0 or ‘index’, 1 or ‘columns’}, default 1
-            Whether to drop labels from the index (0 or ‘index’)
-            or columns (1 or ‘columns’).
+        axis: {0 or ‘index’, 1 or ‘columns’, 2 or 'origin', 3 or 'development'}, default 1
+            The axis to drop ``labels`` from.
+
+        index: str | int | list | None
+            Alternative to ``axis=0``. Equivalent to ``labels, axis=0``.
+
+        columns: str | int | list | None
+            Alternative to ``axis=1``. Equivalent to ``labels, axis=1``.
+
+        origin: str | int | list | None
+            Alternative to ``axis=2``. Equivalent to ``labels, axis=2``.
+
+        development: str | int | list | None
+            Alternative to ``axis=3``. Equivalent to ``labels, axis=3``.
 
         Returns
         -------
         Triangle
 
+        Examples
+        --------
+
+        Drop a single column with the ``labels``/``axis`` form or the
+        ``columns`` alternative; the two are equivalent.
+
+        .. testsetup::
+
+            import chainladder as cl
+
+        .. testcode::
+
+            tri = cl.load_sample('clrd')
+            print(tri.columns.tolist())
+            print(tri.drop(columns='CumPaidLoss').columns.tolist())
+
+        .. testoutput::
+
+            ['IncurLoss', 'CumPaidLoss', 'BulkLoss', 'EarnedPremDIR', 'EarnedPremCeded', 'EarnedPremNet']
+            ['IncurLoss', 'BulkLoss', 'EarnedPremDIR', 'EarnedPremCeded', 'EarnedPremNet']
+
+        A list of labels can be dropped from an axis as well.
+
+        .. testcode::
+
+            print(tri.drop(columns=['CumPaidLoss', 'IncurLoss']).columns.tolist())
+
+        .. testoutput::
+
+            ['BulkLoss', 'EarnedPremDIR', 'EarnedPremCeded', 'EarnedPremNet']
+
         """
-        axis = self._get_axis(axis)
-        labels = [labels] if type(labels) is str else list(labels)
-        if axis == 1:
-            return self[[item for item in self.columns if item not in labels]]
+        alternatives = {0: index, 1: columns, 2: origin, 3: development}
+        if any(value is not None for value in alternatives.values()):
+            if labels is not None:
+                raise ValueError(
+                    "Cannot specify both 'labels' and any of 'index', "
+                    "'columns', 'origin', or 'development'."
+                )
+            to_drop = {
+                ax: value for ax, value in alternatives.items() if value is not None
+            }
         else:
-            raise NotImplementedError("Triangle.drop() only implemented for column axis.")
+            to_drop = {self._get_axis(axis): labels}
+        result = self
+        for ax, ax_labels in to_drop.items():
+            ax_labels = (
+                [ax_labels] if np.isscalar(ax_labels) else list(ax_labels)
+            )
+            if ax == 1:
+                result = result[
+                    [item for item in result.columns if item not in ax_labels]
+                ]
+            else:
+                raise NotImplementedError(
+                    "Triangle.drop() only implemented for column axis."
+                )
+        return result
 
     @property
     def T(self) -> DataFrame: # noqa: N802

chainladder/core/slice.py

@@ -541,20 +541,25 @@ def __setitem__(
             i = np.where(self.vdims == key)[0][0]
             # Case sparse backend.
             if self.array_backend == "sparse":
-                # Cast value to sparse backend.
-                value = cast("Triangle", value)
-                after = cast("COO", value.values)
+                # Unwrap a Triangle-valued assignment to its raw array. A raw
+                # COO array can also be passed directly, mirroring the numpy
+                # branch below.
+                if isinstance(value, TriangleSlicer):
+                    value = cast("Triangle", value)
+                    after = cast("COO", value.values)
+                else:
+                    after = cast("COO", value)
 
-                # Drop existing data where key matches, reassign coordinates.
-                before = self.drop(key).values
-                before = cast("COO", before)
-                bc = before.coords[1, :]
-                before.coords[1] = np.where(bc >= i, bc + 1, bc,)
+                # Filter out existing data at the target column directly from
+                # self.values' own coordinates.
+                before = cast("COO", self.values)
+                keep = before.coords[1, :] != i
 
                 # Append assigned data and new coordinates.
-                after.coords[1] = i
-                coords = np.concatenate((before.coords, after.coords), axis=1)
-                data = np.concatenate((before.data, after.data))
+                after_coords = after.coords.copy()
+                after_coords[1] = i
+                coords = np.concatenate((before.coords[:, keep], after_coords), axis=1)
+                data = np.concatenate((before.data[keep], after.data))
 
                 # Create new sparse matrix with updated coords and data, assign to backend array.
                 self.values = xp.COO(
@@ -577,7 +582,7 @@ def __setitem__(
                 value = self.iloc[:, 0] * 0 + value
             try:
                 self.values = xp.concatenate((self.values, value.values), axis=1)
-            except (ValueError, AttributeError):
+            except (ValueError, AttributeError, AssertionError):
                 # For misaligned triangle support.
                 conc = (self.values, (self.iloc[:, 0] * 0 + cast("Triangle", value)).values)
                 self.values = xp.concatenate(conc, axis=1)

chainladder/core/tests/test_display.py

@@ -8,6 +8,7 @@
 import sys
 
 
+from collections.abc import Iterable
 from chainladder.core.display import TriangleDisplay
 from lxml import etree, html as lxml_html
 from unittest import mock
@@ -259,6 +260,49 @@ def test_repr_format_semi_annual(prism: Triangle) -> None:
     assert any("H1" in str(i) or "H2" in str(i) for i in df.index)
 
 
+def test_triangle_not_iterable(raa: Triangle) -> None:
+    """
+    A Triangle is a 4-D container, not a 1-D sequence, so it must not be
+    iterable (GH #142). This prevents pandas from misclassifying it as a
+    sequence and iterating it while formatting a DataFrame cell.
+
+    Parameters
+    ----------
+    raa: Triangle
+        The raa sample data set.
+
+    Returns
+    -------
+    None
+
+    """
+    assert not isinstance(raa, Iterable)
+    with pytest.raises(TypeError):
+        iter(raa)
+
+
+def test_triangle_in_dataframe_cell_display(clrd: Triangle) -> None:
+    """
+    Storing a Triangle in a DataFrame cell and displaying the DataFrame must
+    not crash (GH #142).
+
+    Parameters
+    ----------
+    clrd: Triangle
+        The clrd sample data set.
+
+    Returns
+    -------
+    None
+
+    """
+    df = pd.DataFrame(data=[["clrd", clrd]], columns=["name", "cl_triangle"])
+    # Both the text and HTML representations previously raised because pandas
+    # iterated the Triangle stored in the cell.
+    assert isinstance(repr(df), str)
+    assert isinstance(df._repr_html_(), str)
+
+
 def test_heatmap_multi_raises(clrd: Triangle) -> None:
     """
     Heatmap only works on a single-dimension triangle. Raise a ValueError if multidimensional.

chainladder/core/tests/test_slicing.py

@@ -116,7 +116,19 @@ def test_loc_ellipsis(clrd):
 
 def test_missing_first_lag(raa):
     x = raa.copy()
-    x.values[:, :, :, 0] = 0
+
+    def set_missing(values) -> None:
+        """
+        Sets the missing values for the first lag.
+        """
+        values[:, :, :, 0] = 0
+
+    if x.array_backend == "sparse":
+        # Sparse COO arrays don't support in-place item assignment.
+        with pytest.raises(TypeError, match="sparse backend"):
+            set_missing(x.values)
+        return
+    set_missing(x.values)
     x = x.sum(0)
     assert x.link_ratio.shape == (1, 1, 9, 9)
 
@@ -434,7 +446,8 @@ def test_setitem_virtual_column_numpy_backend(raa: Triangle) -> None:
     None
     """
     tri = raa.copy()
-    assert tri.array_backend == "numpy"
+    if tri.array_backend == "sparse":
+        pytest.skip("Test is specific to the numpy backend.")
     tri["double"] = lambda x: x["values"] * 2
     assert "double" in tri.columns
     assert tri["double"] == tri["values"] * 2
@@ -454,7 +467,8 @@ def test_setitem_value_backend_conversion(raa: Triangle) -> None:
     None
     """
     tri = raa.copy()
-    value = (tri["values"] * 2).set_backend("sparse")
+    other_backend = "numpy" if tri.array_backend == "sparse" else "sparse"
+    value = (tri["values"] * 2).set_backend(other_backend)
     assert tri.array_backend != value.array_backend
     tri["values"] = value
     assert tri.array_backend == raa.array_backend
@@ -475,15 +489,14 @@ def test_setitem_existing_column_triangle_value(raa: Triangle) -> None:
     None
     """
     tri = raa.copy()
-    assert tri.array_backend != "sparse"
     value = tri["values"] * 2
     tri["values"] = value
     assert tri["values"] == raa["values"] * 2
 
 
 def test_setitem_existing_column_array_value(raa: Triangle) -> None:
     """
-    Reassign an existing column to a raw array value on a non-sparse backend.
+    Reassign an existing column to a raw array value.
 
     Parameters
     ----------
@@ -495,7 +508,6 @@ def test_setitem_existing_column_array_value(raa: Triangle) -> None:
     None
     """
     tri = raa.copy()
-    assert tri.array_backend != "sparse"
     value = (tri["values"] * 3).values
     assert not isinstance(value, type(tri))
     tri["values"] = value
@@ -534,7 +546,8 @@ def test_setitem_new_column_misaligned_triangle(raa: Triangle) -> None:
     tri["misaligned"] = misaligned
     # Check the shape, new column should be added.
     assert tri.shape == (1, 2, 10, 10)
-    new_col = tri["misaligned"]
+    new_col = tri["misaligned"].set_backend("numpy")
+    misaligned = misaligned.set_backend("numpy")
     # Origin periods 1985 and prior should be nan.
     assert np.isnan(new_col.values[0, 0, :5, :]).all()
     # Origin periods 1986 and beyond should match.