trim comments to the load-bearing lines

Author: ayaangazali

swarms/structs/graph_workflow.py

@@ -813,9 +813,8 @@ def __init__(
         self.type = type
         self.agent = agent
         self.metadata = metadata or {}
-        # Per-node retry policy. None means "use the workflow default",
-        # resolved at run time so a workflow-level policy can be set after
-        # the nodes were added.
+        # None means "use the workflow default", resolved at run time so the
+        # default can be set after the nodes were added.
         self.retry = retry
 
         if not self.id:
@@ -917,9 +916,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:
@@ -997,9 +995,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(
@@ -1088,8 +1085,7 @@ def __init__(
 
         # Checkpoint configuration
         self.checkpoint_dir = checkpoint_dir
-        # Default policy for nodes that don't carry their own. None means no
-        # retrying, which is the historical behaviour.
+        # None means no retrying, the historical behaviour.
         self.retry_policy = retry_policy
         if on_node_failure not in (
             "skip_downstream",
@@ -1101,8 +1097,7 @@ def __init__(
                 f"'propagate_error', got {on_node_failure!r}"
             )
         self.on_node_failure = on_node_failure
-        # node_id -> error string, populated per run. Lets a caller inspect
-        # failures without substring-matching every output for '[ERROR]'.
+        # node_id -> error, so callers need not grep outputs for '[ERROR]'.
         self.failed_nodes: Dict[str, str] = {}
 
         # Private optimization attributes
@@ -1278,10 +1273,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:
@@ -2188,9 +2181,8 @@ def _handle_node_failure(
         if self.on_node_failure == "propagate_error":
             return f"[ERROR] Agent {agent_name} failed: {exc}"
 
-        # skip_downstream: the node produced nothing, so dependents are
-        # pruned rather than being handed an error string that reads like an
-        # answer.
+        # skip_downstream: dependents are pruned rather than handed an error
+        # string that reads like an answer.
         skipped.add(node_id)
         logger.warning(
             f"Node {node_id} failed; skipping its dependents "
@@ -2232,8 +2224,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
@@ -2270,10 +2261,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
@@ -2493,8 +2482,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()
                 self.failed_nodes = {}
 
@@ -2573,10 +2561,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 or skipped_nodes:
                         eligible_layer = []
                         for entry in layer:
@@ -3631,11 +3617,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: