Version 0.4

Webber v0.4 — IterPromise, Callbacks, Metrics, Topology, Dashboard

This release introduces runtime observability, dynamic fan-out, and DAG persistence — making Webber viable for production workflows that need monitoring, templating, and flexible parallelism.

IterPromise — Dynamic Fan-Out

Spawn N parallel child tasks at runtime from a parent node's list output. The DAG graph is never mutated — fan-out is an executor-internal detail (collapse model):

      What you define                              DAG.execute()
      ───────────────                          ──────────────────────
    ┌─────────────────┐                      ┌───────────────────────┐
    │     source      │                      │        source         │
    │ "abc".split('') │                      │ returns ['a','b','c'] │
    └────────┬────────┘                      └──────────┬────────────┘
             │                                          │
             │  IterPromise(source)                ┌────┼────┐  fan-out
             │                                     │    │    │
        ┌────┴─────┐                            [a]▼ [b]▼ [c]▼
        │  worker  │                             ┌───┐┌───┐┌───┐
        │ str.upper│                             │"A"││"B"││"C"│  (parallel)
        └────┬─────┘                             └─┬─┘└─┬─┘└─┬─┘
             │                                     └────┼────┘
             │  Promise(worker)                         │  aggregate
             ▼                                          ▼
       ┌───────────┐                             ┌─────────────┐
       │ collector │                             │  collector  │
       │   print   │                             │["A","B","C"]│
       └───────────┘                             └─────────────┘
      3 nodes in graph                     3 nodes in graph (unchanged)

from webber import IterPromise

source = dag.add_node(lambda: ["a", "b", "c"])
worker = dag.add_node(str.upper, IterPromise(source))
collector = dag.add_node(print, Promise(worker))  # receives ["A", "B", "C"]

• Multi-source zip: IterPromise(source_a, source_b, zip=True)
• Resilient mode: IterPromise(source, partial=True) — failed sub-tasks become None
• Sub-tasks execute in parallel via the existing ThreadPoolExecutor

Progress Callbacks

DAGCallbacks dataclass with 6 hook points for real-time execution observation. Zero overhead when unset.

Execution Metrics

DAGMetrics dataclass with per-task perf_counter timing, completion tracking, and summary statistics via executor.metrics.

Topology Export/Import

Save and restore DAG structure as JSON with callable registry. Supports explicit dict and module-based auto-resolution.

Execution Dashboard

Post-execution Vis.js browser visualization with node status coloring, timing sidebar, and summary stats.

Bug Fixes & Quality

• Bare except clauses, comparison anti-patterns, dead code cleanup
• 471 tests, no latency regression
• 6 new code examples

---

We're actively seeking support! Reach out to https://github.com/WebberTeam or @jfathi

Version 0.3 - Ready for Production

Major release and improvements!* 🎉
We're actively seeking support! Reach out to https://github.com/WebberTeam or @jfathi.

Version 0.3 finally delivers on Webber's promise to be embarrassingly parallel and real-time. Thanks to improvements identified with Claude, latency between tasks has been reduced from tenths of seconds to sub-millisecond latency for most operations.

• Performance Optimizations: O(1) callable lookups using internal cache, improved edge condition handling.

• Thread-Safe Logging: Task execution now uses thread-safe stdout with automatic timestamps and task name prefixes.

• Visualization Dashboard Overhaul: Complete redesign of the browser visualization with:

  • Modern dark/light theme toggle
  • Physics toggle and zoom controls
  • Graph statistics and color-coded legends

• Comprehensive Test Suite: 370 tests covering core operations, edge cases, concurrency, QueueDAG, and performance benchmarks.

• Documentation:

  • Regenerated pdoc API documentation
  • Updated examples for QueueDAG and error handling

• Bugfixes:

  • Promise resolution for callables in DAG scope
  • Matplotlib preload race condition with threading Event synchronization
  • Edge case handling in update_nodes and filter_edges

Additional Notes:

• Visualization requires vis-network.js (loaded from CDN by default)

version 0.2

Major release and improvements!* 🎉
We're actively seeking support! Reach out to @WebberTeam or @jfathi.

New Features:

• QueueDAG: Introducing experimental support for a DAG model where all nodes are executed in parallel, but their outputs are linked and processed in sequence.

• relabel_node: Simple function to update the label, or name of a single node in a DAGs scope. Very useful when working with lambda functions.

• Promises now support use of callables and UUIDs as unique keys.

• Updates to docstrings, documentation site, and code examples.

Bugfixes:

• add_edge: Edge case where nodes were preemptively created even if edge was not. Squashed and conditional-tree simplified.

• filter_nodes: Now returns list of dotdicts based on lambda filter, as expected

• Bugfix for visualizing Promises as arguments

Additional Notes:

• Support for QueueDAG, update_nodes, and update_edges is still experimental and should not be used in production contexts.

version 0.1.2

Major Release Candidate - Version 0.1.2

Wheel files reference version 0.1.2, whereas compressed directories use binaries for v0.2.

Major Updates

• Node and edge getter functions implemented
• Update functions for nodes and edges implemented
• Edge removal implemented
• Filter functions for nodes and edges implemented, experimental support
• Interactive visualizations for Jupyter notebooks + small browser improvements
• Significant documentation updates

Minor Updates

• Complex XComs fully deprecated
• Reduce load-times by moving viz import

version 0.1.1

First major upgrades since 2022! 🎉
We're actively seeking support! Reach out to @WebberTeam or @jfathi.

New Features

Conditional Edges: DAGs can now continue execution along a node-path in case of a parent node's failure! Edge conditions are documented as in the enum webber.Condition, as Success, Failure, or AnyCase. Default edge condition is Success. See: webber.Condition

Retry Nodes: Nodes can now be re-executed multiple times in case of failure. See: DAG.retry_node(n)

Skip Nodes: DAGs can now skip over nodes and continue onto their child/dependent nodes. Before executing, skipped nodes can be pre-registered as either successful or failed executions, enabling diverse opportunities for DAG testing in tandem with conditional execution. See: DAG.skip_node(n)

Trace Exceptions: Trace printouts disabled by default, can be enabled at DAG execution time: DAG.execute(print_exc=True)

Critical Node Paths: Critical Node Paths: DAGs can be reduced to a set of specified nodes and their dependencies. Capability still under development. See: DAG.critical_path(n)

Other Improvements

• Use UUID4 to limit repeating GUIDs.
• Complex xcoms deprecated in favor of Promise model.
• Improved doc-strings, bug squashes.

Known Bugs and Gaps

• STDOUT logging is not guaranteed to correlate to correct node at 3+ concurrent operations.

Project Backlog

• Get/Update Functions for Nodes and Edges
• Introductory Jupyter notebooks and documentation
• Expanded support for Jupyter Notebook visualizations
• Edge and Node filtering with Lambda Functions (e.g.: lambda e: e.Condition == condition.OnSuccess).

version 0.1-alpha

Initial release - first major upgrades since 2022:

Conditional Edges: DAGs can now continue execution along a node-path in case of a parent node's failure! Edge conditions are documented as in the enum webber.Condition, as OnSuccess, OnFailure, or AnyCase. Default edge condition is OnSuccess.

Retry and Skip: Nodes can now be re-executed multiple times in case of failure, or skipped over entirely. Currently, skips are registered as a successful node execution.

Trace Exceptions: Trace printouts disabled by default, can be enabled at DAG execution time: DAG.execute(print_exc=True)

Other Improvements:

• Use UUID4 to limit repeating GUIDs.
• Complex xcoms deprecated in favor of Promise model.

Known bugs and Gaps:

• STDOUT logging is not guaranteed to correlate to correct node at 3+ concurrent operations.
• Visualizations for Jupyter Notebooks are largely unsupported at this time.

Under Development:

• Additional documentation, visualization improvements forthcoming in v0.1.1
• Critical Node Paths: DAGs can be reduced to a set of specified nodes and their dependencies.

Project Backlog:

• Support for Jupyter Notebook visualizations
• Get/Update Functions for Nodes and Edges
• Edge and Node filtering with Lambda Functions (e.g.: lambda e: e.Condition == condition.OnSuccess).

Actively seeking support! Reach out to @jfathi. {:)