refactor: fix SonarCloud maintainability issues in diagram package

- Use pytest.approx for float comparisons in _split_length tests
- Rename unused variables to _ in _prepare_svg tests
- Remove unused 'getter' parameter from _extract_transitions_from_state
  and _extract_all_transitions
- Reduce cognitive complexity of _create_edges (30→~10) by extracting
  _create_single_edge, _resolve_edge_endpoints, and _build_edge_label
- Reduce cognitive complexity of _render_states (17→~12) by extracting
  _place_extra_nodes static method

Author: fgmacedo

statemachine/contrib/diagram/extract.py

@@ -101,7 +101,7 @@ def _extract_state(
     )
 
 
-def _extract_transitions_from_state(state: "State", getter) -> List[DiagramTransition]:
+def _extract_transitions_from_state(state: "State") -> List[DiagramTransition]:
     """Extract transitions from a single state (non-recursive)."""
     result: List[DiagramTransition] = []
     for transition in state.transitions:
@@ -122,17 +122,17 @@ def _extract_transitions_from_state(state: "State", getter) -> List[DiagramTrans
     return result
 
 
-def _extract_all_transitions(states, getter) -> List[DiagramTransition]:
+def _extract_all_transitions(states) -> List[DiagramTransition]:
     """Recursively extract transitions from all states."""
     result: List[DiagramTransition] = []
     for state in states:
-        result.extend(_extract_transitions_from_state(state, getter))
+        result.extend(_extract_transitions_from_state(state))
         if state.states:
-            result.extend(_extract_all_transitions(state.states, getter))
+            result.extend(_extract_all_transitions(state.states))
         for history_state in getattr(state, "history", []):
-            result.extend(_extract_transitions_from_state(history_state, getter))
+            result.extend(_extract_transitions_from_state(history_state))
             if history_state.states:  # pragma: no cover
-                result.extend(_extract_all_transitions(history_state.states, getter))
+                result.extend(_extract_all_transitions(history_state.states))
     return result
 
 
@@ -242,7 +242,7 @@ class itself thanks to the metaclass.  Active-state highlighting is only
     for state in machine.states:
         states.append(_extract_state(state, machine, getter, active_values))
 
-    transitions = _extract_all_transitions(machine.states, getter)
+    transitions = _extract_all_transitions(machine.states)
 
     compound_ids = _collect_compound_ids(states)
     bidir_ids = _collect_bidirectional_compound_ids(transitions, compound_ids)

statemachine/contrib/diagram/renderers/dot.py

@@ -162,15 +162,9 @@ def _render_states(
                 atomic_subgraph.add_node(self._create_atomic_node(state))
                 has_atomic = True
 
-        # Anchor nodes from the parent compound are co-located with real states
-        # when possible. If there are no atomic states at this level (e.g. a
-        # parallel state with only compound children), add them directly to the
-        # parent graph to avoid creating an empty cluster that wastes space.
-        if extra_nodes:
-            target = atomic_subgraph if has_atomic else parent_graph
-            for node in extra_nodes:
-                target.add_node(node)
-            has_atomic = has_atomic or (target is atomic_subgraph)
+        has_atomic = self._place_extra_nodes(
+            extra_nodes, atomic_subgraph, parent_graph, has_atomic
+        )
 
         if has_atomic:
             parent_graph.add_subgraph(atomic_subgraph)
@@ -180,6 +174,28 @@ def _render_states(
             if not state.children:
                 self._add_transitions_for_state(state, transitions, parent_graph)
 
+    @staticmethod
+    def _place_extra_nodes(
+        extra_nodes: Optional[List[pydot.Node]],
+        atomic_subgraph: pydot.Subgraph,
+        parent_graph: "pydot.Dot | pydot.Subgraph",
+        has_atomic: bool,
+    ) -> bool:
+        """Place anchor nodes from the parent compound into the graph.
+
+        Co-locates them with real states when possible. If there are no atomic
+        states at this level (e.g. a parallel state with only compound children),
+        adds them directly to the parent graph to avoid an empty cluster.
+
+        Returns the updated ``has_atomic`` flag.
+        """
+        if not extra_nodes:
+            return has_atomic
+        target = atomic_subgraph if has_atomic else parent_graph
+        for node in extra_nodes:
+            target.add_node(node)
+        return has_atomic or (target is atomic_subgraph)
+
     def _render_initial_arrow(
         self,
         initial_state: DiagramState,
@@ -438,65 +454,78 @@ def _create_edges(self, transition: DiagramTransition) -> List[pydot.Edge]:
         cond = ", ".join(transition.guards)
         cond_html = f"<br/>[{_escape_html(cond)}]" if cond else ""
 
-        edges = []
-        for i, target_id in enumerate(target_ids):
-            extra: Dict[str, str] = {}
-            source_is_compound = transition.source in self._compound_ids
-            target_is_compound = target_id is not None and target_id in self._compound_ids
+        return [
+            self._create_single_edge(transition, target_id, i, cond_html)
+            for i, target_id in enumerate(target_ids)
+        ]
 
-            if source_is_compound:
-                extra["ltail"] = f"cluster_{transition.source}"
-            if target_is_compound:
-                extra["lhead"] = f"cluster_{target_id}"
-
-            has_substates = source_is_compound or target_is_compound
-            event_text = _escape_html(transition.event) if i == 0 else ""
-
-            if target_id is not None:
-                dst = self._state_node_id(target_id)
-            else:
-                dst = self._state_node_id(transition.source)
-
-            src = self._state_node_id(transition.source)
-
-            # For compound states in bidirectional pairs, route outgoing edges
-            # through _anchor_out and incoming through _anchor_in so Graphviz
-            # places them at different physical positions inside the cluster.
-            if source_is_compound and transition.source in self._compound_bidir_ids:
-                src = self._compound_edge_anchor(transition.source, "out")
-                extra["ltail"] = f"cluster_{transition.source}"
-            if target_is_compound and target_id in self._compound_bidir_ids:
-                dst = self._compound_edge_anchor(target_id, "in")
-                extra["lhead"] = f"cluster_{target_id}"
-
-            if event_text or (cond_html and i == 0):
-                label_content = f"{event_text}{cond_html}" if i == 0 else ""
-                font_size = self.config.transition_font_size
-                html_label = (
-                    f'<<table border="0" cellborder="0" cellspacing="0" cellpadding="0">'
-                    f'<tr><td cellpadding="4">'
-                    f'<font point-size="{font_size}">{label_content}</font>'
-                    f"</td></tr>"
-                    f'<tr><td cellpadding="1"></td></tr>'
-                    f"</table>>"
-                )
-            else:
-                html_label = ""
-
-            # With dedicated anchor nodes placed inside compound clusters,
-            # the midpoint of anchor→dst falls outside the cluster boundary,
-            # so the standard label position is correct along the visible edge.
-            # Use label for all edges (xlabel causes floating/displaced labels).
-            label_key = "label"
-
-            edges.append(
-                pydot.Edge(
-                    src,
-                    dst,
-                    **{label_key: html_label},
-                    minlen=2 if has_substates else 1,
-                    **extra,
-                )
-            )
+    def _create_single_edge(
+        self,
+        transition: DiagramTransition,
+        target_id: Optional[str],
+        index: int,
+        cond_html: str,
+    ) -> pydot.Edge:
+        """Create a single pydot.Edge for one target of a transition."""
+        src, dst, extra = self._resolve_edge_endpoints(transition, target_id)
+        has_substates = bool(extra)
+        html_label = self._build_edge_label(transition.event, cond_html, index)
+
+        return pydot.Edge(
+            src,
+            dst,
+            label=html_label,
+            minlen=2 if has_substates else 1,
+            **extra,
+        )
 
-        return edges
+    def _resolve_edge_endpoints(
+        self,
+        transition: DiagramTransition,
+        target_id: Optional[str],
+    ) -> "tuple[str, str, Dict[str, str]]":
+        """Resolve source/destination node IDs and cluster attributes for an edge."""
+        extra: Dict[str, str] = {}
+        source_is_compound = transition.source in self._compound_ids
+        target_is_compound = target_id is not None and target_id in self._compound_ids
+
+        if source_is_compound:
+            extra["ltail"] = f"cluster_{transition.source}"
+        if target_is_compound:
+            extra["lhead"] = f"cluster_{target_id}"
+
+        dst = (
+            self._state_node_id(target_id)
+            if target_id is not None
+            else self._state_node_id(transition.source)
+        )
+        src = self._state_node_id(transition.source)
+
+        # For compound states in bidirectional pairs, route outgoing edges
+        # through _anchor_out and incoming through _anchor_in so Graphviz
+        # places them at different physical positions inside the cluster.
+        if source_is_compound and transition.source in self._compound_bidir_ids:
+            src = self._compound_edge_anchor(transition.source, "out")
+            extra["ltail"] = f"cluster_{transition.source}"
+        if target_is_compound and target_id in self._compound_bidir_ids:
+            dst = self._compound_edge_anchor(target_id, "in")
+            extra["lhead"] = f"cluster_{target_id}"
+
+        return src, dst, extra
+
+    def _build_edge_label(self, event: str, cond_html: str, index: int) -> str:
+        """Build the HTML label for a transition edge."""
+        event_text = _escape_html(event) if index == 0 else ""
+        if not event_text and not (cond_html and index == 0):
+            return ""
+
+        label_content = f"{event_text}{cond_html}" if index == 0 else ""
+        font_size = self.config.transition_font_size
+        return (
+            f'<<table border="0" cellborder="0" cellspacing="0" cellpadding="0">'
+            f'<tr><td cellpadding="4">'
+            f'<font point-size="{font_size}">{label_content}</font>'
+            f"</td></tr>"
+            f'<tr><td cellpadding="1"></td></tr>'
+            f"</table>>"
+        )

tests/test_contrib_diagram.py

@@ -700,28 +700,28 @@ def test_split_pt(self):
         from statemachine.contrib.diagram.sphinx_ext import _split_length
 
         value, unit = _split_length("702pt")
-        assert value == 702.0
+        assert value == pytest.approx(702.0)
         assert unit == "pt"
 
     def test_split_px(self):
         from statemachine.contrib.diagram.sphinx_ext import _split_length
 
         value, unit = _split_length("100px")
-        assert value == 100.0
+        assert value == pytest.approx(100.0)
         assert unit == "px"
 
     def test_split_float(self):
         from statemachine.contrib.diagram.sphinx_ext import _split_length
 
         value, unit = _split_length("12.5em")
-        assert value == 12.5
+        assert value == pytest.approx(12.5)
         assert unit == "em"
 
     def test_split_no_match(self):
         from statemachine.contrib.diagram.sphinx_ext import _split_length
 
         value, unit = _split_length("auto")
-        assert value == 0.0
+        assert value == pytest.approx(0.0)
         assert unit == "auto"
 
 
@@ -774,7 +774,7 @@ def test_strips_xml_prologue(self):
             b"<circle/></svg>"
         )
         directive = self._make_directive()
-        svg_tag, w, h = directive._prepare_svg(svg_bytes)
+        svg_tag, _, _ = directive._prepare_svg(svg_bytes)
 
         assert not svg_tag.startswith("<?xml")
         assert svg_tag.startswith("<svg")
@@ -800,7 +800,7 @@ def test_removes_fixed_dimensions(self):
     def test_handles_no_dimensions(self):
         svg_bytes = b'<svg viewBox="0 0 100 50"><rect/></svg>'
         directive = self._make_directive()
-        svg_tag, w, h = directive._prepare_svg(svg_bytes)
+        _, w, h = directive._prepare_svg(svg_bytes)
 
         assert w == ""
         assert h == ""