trim comments to the load-bearing lines

Author: ayaangazali

swarms/structs/graph_workflow.py

@@ -841,9 +841,8 @@ def __init__(
         self.target = target
         self.metadata = metadata or {}
         self.condition = condition
-        # Resolved once, so fires() never has to probe by catching TypeError —
-        # a predicate that raises TypeError internally would otherwise be
-        # called a second time with a different signature.
+        # Resolved once: probing by catching TypeError would call a predicate
+        # that raises TypeError internally a second time.
         self._condition_wants_context = _accepts_two_args(condition)
 
     def fires(self, output: Any, outputs: Dict[str, Any]) -> bool:
@@ -921,9 +920,8 @@ def from_nodes(
             tgt = target_node
 
         # Put all kwargs into metadata dict
-        # condition is a real constructor argument, not free-form metadata —
-        # leaving it in kwargs would bury the predicate in the visualization
-        # labels and silently drop the routing behaviour.
+        # A real argument, not metadata: left in kwargs it lands in the
+        # visualization labels and the routing is dropped.
         condition = kwargs.pop("condition", None)
         metadata = kwargs if kwargs else None
         return cls(
@@ -1184,10 +1182,8 @@ def compile(self) -> None:
                 for node_id, parents in pred.items()
             }
 
-            # Index inbound edges per target so the run loop can evaluate
-            # routing without scanning self.edges once per node. _has_conditions
-            # lets a graph with no conditions skip the gating pass entirely,
-            # keeping the existing execution path free of added work.
+            # Indexed so the run loop does not scan self.edges per node;
+            # _has_conditions lets an unconditional graph skip gating entirely.
             inbound: Dict[str, List["Edge"]] = {}
             has_conditions = False
             for edge in self.edges:
@@ -2038,8 +2034,7 @@ def _node_is_eligible(
             if edge.source in skipped:
                 continue
             if edge.source not in prev_outputs:
-                # Predecessor hasn't run yet (first layer of a later loop, or
-                # a cycle edge). Don't let an unevaluated edge prune the node.
+                # Unevaluated edge (later loop, cycle): must not prune.
                 return True
             if edge.fires(prev_outputs[edge.source], prev_outputs):
                 return True
@@ -2076,10 +2071,8 @@ def _build_prompt(
 
         try:
             preds = self._get_predecessors(node_id)
-            # Keep the id paired with its own output. Filtering the outputs
-            # while zipping against the unfiltered predecessor tuple shifted
-            # the labels, so a node with a skipped or missing predecessor
-            # attributed each output to the wrong agent.
+            # Filtering outputs while zipping against the unfiltered
+            # predecessor tuple shifted every label by one.
             pred_outputs = [
                 (pred, prev_outputs[pred])
                 for pred in preds
@@ -2299,8 +2292,7 @@ def _get_executor() -> ContextThreadPoolExecutor:
 
                 execution_results = {}
                 prev_outputs = {}
-                # Reset per loop: a node skipped on one iteration may well be
-                # the one that runs on the next, once upstream output changes.
+                # Reset per loop: a skipped node may run on the next one.
                 skipped_nodes: Set[str] = set()
 
                 # Derive a deterministic key for this task so checkpoints
@@ -2378,10 +2370,8 @@ def _get_executor() -> ContextThreadPoolExecutor:
                             f"with {len(layer)} nodes: {[n[0] for n in layer]}"
                         )
 
-                    # Conditional routing: drop nodes this layer whose inbound
-                    # edges all declined to fire. Entry points and nodes in
-                    # graphs without conditions are never gated, so an
-                    # unconditional graph takes the same path it always did.
+                    # Drop nodes whose inbound edges all declined to fire.
+                    # Entry points and unconditional graphs are never gated.
                     if self._has_conditions:
                         eligible_layer = []
                         for entry in layer:
@@ -3423,11 +3413,8 @@ def node_to_dict(node: Node) -> Dict[str, Any]:
                 return node_data
 
             def edge_to_dict(edge: Edge) -> Dict[str, Any]:
-                # A predicate is a Python callable and cannot round-trip
-                # through JSON. Flag it in the payload and warn, so a
-                # deserialized graph is never silently missing its routing:
-                # loading this JSON gives an unconditional graph, where every
-                # branch fires.
+                # A callable cannot round-trip through JSON, so flag it:
+                # loading this back gives an unconditional graph.
                 d = {
                     "source": edge.source,
                     "target": edge.target,

tests/structs/test_graph_workflow.py

@@ -1313,9 +1313,6 @@ def test_compile_calls_validate_and_reports_errors():
     pytest.main([__file__, "-v"])
 
 
-# ---------------------------------------------------------------------------
-# Conditional edges (#1756)
-# ---------------------------------------------------------------------------
 
 
 class _StubAgent:
@@ -1371,7 +1368,6 @@ def test_conditional_edge_runs_only_the_matching_branch():
 
     assert escalate.calls == 1
     assert routine.calls == 0
-    # A skipped node is absent from results, not present with empty output.
     assert "routine" not in results
     assert results["escalate"] == "paged oncall"
 
@@ -1490,7 +1486,6 @@ def boom(output):
 
     results = wf.run(task="go")
 
-    # The run completes; the unproven edge simply does not route.
     assert target.calls == 0
     assert set(results) == {"start"}
 
@@ -1532,7 +1527,6 @@ def test_prompt_labels_stay_aligned_when_a_predecessor_is_missing():
     wf.set_end_points(["c"])
     wf.compile()
 
-    # Only the second predecessor produced output.
     prompt = wf._build_prompt(
         "c", "task", {"b": "B-OUTPUT"}, layer_idx=1
     )