Fix RenderedStatement pickle and JSON serialization bugs

Replace unpicklable closures (format_func, lambda) with picklable callable
classes (CellFormatter, PreformattedValue), and handle ElementCatalog objects
in to_dict() so json.dumps() succeeds when dimension_metadata is present.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: dgunning

edgar/xbrl/rendering.py

@@ -183,6 +183,51 @@ class StatementCell:
     def get_formatted_value(self) -> str:
         return self.formatter(self.value)
 
+
+class CellFormatter:
+    """Picklable callable that replaces the format_func closure in render_statement().
+
+    Stores all parameters needed by ``_format_value_for_display_as_string``
+    as instance attributes so pickle can serialize it.
+    """
+    __slots__ = ('item', 'period_key', 'is_monetary_statement',
+                 'dominant_scale', 'shares_scale', 'comparison_info',
+                 'currency_symbol')
+
+    def __init__(self, item, period_key, is_monetary_statement,
+                 dominant_scale, shares_scale, comparison_info,
+                 currency_symbol):
+        self.item = item
+        self.period_key = period_key
+        self.is_monetary_statement = is_monetary_statement
+        self.dominant_scale = dominant_scale
+        self.shares_scale = shares_scale
+        self.comparison_info = comparison_info
+        self.currency_symbol = currency_symbol
+
+    def __call__(self, value):
+        return _format_value_for_display_as_string(
+            value, self.item, self.period_key,
+            self.is_monetary_statement, self.dominant_scale,
+            self.shares_scale, self.comparison_info, self.currency_symbol
+        )
+
+
+class PreformattedValue:
+    """Picklable callable that returns a pre-computed formatted string.
+
+    Used by ``RenderedStatement.from_dict()`` to replace the unpicklable
+    lambda that was previously used.
+    """
+    __slots__ = ('formatted',)
+
+    def __init__(self, formatted):
+        self.formatted = formatted
+
+    def __call__(self, value):
+        return self.formatted
+
+
 @dataclass
 class StatementRow:
     """A row in a financial statement."""
@@ -236,6 +281,8 @@ def to_dict(self) -> Dict[str, Any]:
         """
         from datetime import date as _date
 
+        from edgar.xbrl.models import ElementCatalog
+
         def _json_safe(obj):
             """Recursively convert non-JSON-safe types to primitives."""
             if isinstance(obj, dict):
@@ -246,6 +293,8 @@ def _json_safe(obj):
                 return obj.isoformat()
             if isinstance(obj, _date):
                 return obj.isoformat()
+            if isinstance(obj, ElementCatalog):
+                return {"name": obj.name, "labels": obj.labels}
             return obj
 
         def _period_to_dict(p: PeriodData) -> Dict[str, Any]:
@@ -337,7 +386,7 @@ def from_dict(cls, data: Dict[str, Any]) -> 'RenderedStatement':
                     value=cd.get('value'),
                     style=cd.get('style', {}),
                     comparison=cd.get('comparison'),
-                    formatter=lambda v, fv=fmt_val: fv,
+                    formatter=PreformattedValue(fmt_val),
                 )
                 cells.append(cell)
 
@@ -1826,13 +1875,11 @@ def render_statement(
                     if currency_measure:
                         cell_currency_symbol = get_currency_symbol(currency_measure)
 
-            def format_func(value, item=current_item, pk=current_period_key,
-                            _currency=cell_currency_symbol):
-                return _format_value_for_display_as_string(
-                    value, item, pk,
-                    is_monetary_statement, dominant_scale, shares_scale,
-                    comparison_info, _currency
-                )
+            format_func = CellFormatter(
+                current_item, current_period_key,
+                is_monetary_statement, dominant_scale, shares_scale,
+                comparison_info, cell_currency_symbol
+            )
 
             # Create a cell and add it to the row
             cell = StatementCell(

tests/test_rendered_statement_serialization.py

@@ -2,6 +2,7 @@
 Tests for RenderedStatement.to_dict() / from_dict() serialization.
 """
 import json
+import pickle
 
 import pytest
 
@@ -434,3 +435,73 @@ def test_complete_round_trip(self, render_fn, expected_title, expected_type):
                 assert rest_cell.style == orig_cell.style
                 # Compare via JSON normalization (tuples become lists in JSON)
                 assert json.loads(json.dumps(rest_cell.comparison)) == json.loads(json.dumps(orig_cell.comparison))
+
+
+class TestPickleSerialization:
+    """Tests for pickle round-trip of RenderedStatement."""
+
+    def test_pickle_balance_sheet(self):
+        """Balance sheet survives pickle round-trip with correct formatted values."""
+        rendered = _render_balance_sheet()
+        data = pickle.dumps(rendered)
+        restored = pickle.loads(data)
+
+        assert restored.title == rendered.title
+        assert len(restored.rows) == len(rendered.rows)
+        for orig_row, rest_row in zip(rendered.rows, restored.rows):
+            for orig_cell, rest_cell in zip(orig_row.cells, rest_row.cells):
+                assert rest_cell.get_formatted_value() == orig_cell.get_formatted_value()
+
+    def test_pickle_income_statement(self):
+        """Income statement survives pickle round-trip."""
+        rendered = _render_income_statement()
+        data = pickle.dumps(rendered)
+        restored = pickle.loads(data)
+
+        assert restored.title == rendered.title
+        assert restored.statement_type == rendered.statement_type
+        for orig_row, rest_row in zip(rendered.rows, restored.rows):
+            for orig_cell, rest_cell in zip(orig_row.cells, rest_row.cells):
+                assert rest_cell.value == orig_cell.value
+                assert rest_cell.get_formatted_value() == orig_cell.get_formatted_value()
+
+    def test_pickle_from_dict_round_trip(self):
+        """RenderedStatement restored via from_dict() is also picklable."""
+        rendered = _render_balance_sheet()
+        restored_from_dict = RenderedStatement.from_dict(rendered.to_dict())
+        data = pickle.dumps(restored_from_dict)
+        restored = pickle.loads(data)
+
+        for orig_row, rest_row in zip(restored_from_dict.rows, restored.rows):
+            for orig_cell, rest_cell in zip(orig_row.cells, rest_row.cells):
+                assert rest_cell.get_formatted_value() == orig_cell.get_formatted_value()
+
+
+class TestElementCatalogSerialization:
+    """Tests for to_dict() when metadata contains ElementCatalog objects."""
+
+    def test_element_catalog_in_metadata(self):
+        """ElementCatalog objects in row metadata are converted to JSON-safe dicts."""
+        from edgar.xbrl.models import ElementCatalog
+
+        rendered = _render_balance_sheet()
+        # Inject an ElementCatalog into row metadata (simulates dimension_metadata)
+        elem = ElementCatalog(
+            name="us-gaap_ProductMember",
+            data_type="domainItemType",
+            period_type="duration",
+            labels={"standard": "Product"},
+        )
+        rendered.rows[0].metadata["dimension_metadata"] = [
+            {"member_element": elem, "dimension_element": elem}
+        ]
+
+        d = rendered.to_dict()
+        # Must be JSON-serializable
+        serialized = json.dumps(d)
+        assert isinstance(serialized, str)
+
+        # Verify the ElementCatalog was converted to a dict with name and labels
+        dim_meta = d["rows"][0]["metadata"]["dimension_metadata"][0]
+        assert dim_meta["member_element"] == {"name": "us-gaap_ProductMember", "labels": {"standard": "Product"}}
+        assert dim_meta["dimension_element"] == {"name": "us-gaap_ProductMember", "labels": {"standard": "Product"}}