dsp-graph 0.1.5__tar.gz

dsp_graph-0.1.5/PKG-INFO

@@ -0,0 +1,239 @@
+Metadata-Version: 2.3
+Name: dsp-graph
+Version: 0.1.5
+Summary: A Python DSL for defining DSP signal graphs with C++ compilation and optimization
+Keywords: dsp,audio,signal-processing,codegen,c++,pydantic,graph
+Author: Shakeeb Alireza
+Author-email: Shakeeb Alireza <shakfu@users.noreply.github.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Other Audience
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Dist: pydantic>=2.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/shakfu/dsp-graph
+Project-URL: Repository, https://github.com/shakfu/dsp-graph
+Project-URL: Changelog, https://github.com/shakfu/dsp-graph/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/shakfu/dsp-graph/issues
+Description-Content-Type: text/markdown
+
+# dsp-graph
+
+A Python DSL for defining DSP signal graphs, compiling them to standalone C++, and optimizing the result.
+
+Define audio processing graphs using Pydantic models, validate them, compile to C++, and serialize to/from JSON. Zero runtime dependencies beyond Pydantic.
+
+## Install
+
+```bash
+pip install dsp-graph
+```
+
+For development:
+
+```bash
+git clone https://github.com/shakfu/dsp-graph.git
+cd dsp-graph
+make install-dev
+```
+
+## Quick Start
+
+```python
+from dsp_graph import (
+    AudioInput, AudioOutput, BinOp, Graph, History, Param,
+    compile_graph, validate_graph,
+)
+
+graph = Graph(
+    name="onepole",
+    inputs=[AudioInput(id="in1")],
+    outputs=[AudioOutput(id="out1", source="result")],
+    params=[Param(name="coeff", min=0.0, max=0.999, default=0.5)],
+    nodes=[
+        BinOp(id="inv_coeff", op="sub", a=1.0, b="coeff"),
+        BinOp(id="dry", op="mul", a="in1", b="inv_coeff"),
+        History(id="prev", init=0.0, input="result"),
+        BinOp(id="wet", op="mul", a="prev", b="coeff"),
+        BinOp(id="result", op="add", a="dry", b="wet"),
+    ],
+)
+
+errors = validate_graph(graph)
+assert errors == []
+
+code = compile_graph(graph)  # standalone C++ string
+print(graph.model_dump_json(indent=2))
+```
+
+## Node Types (34)
+
+### Arithmetic / Math
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `BinOp` | `add`, `sub`, `mul`, `div`, `min`, `max`, `mod`, `pow` | `a`, `b` | Binary arithmetic |
+| `UnaryOp` | `sin`, `cos`, `tanh`, `exp`, `log`, `abs`, `sqrt`, `neg`, `floor`, `ceil`, `round`, `sign`, `atan`, `asin`, `acos` | `a` | Unary math functions |
+| `Clamp` | `clamp` | `a`, `lo`, `hi` | Saturate to `[lo, hi]` |
+| `Constant` | `constant` | `value` | Literal float value |
+| `Compare` | `gt`, `lt`, `gte`, `lte`, `eq` | `a`, `b` | Comparison (returns 0.0 or 1.0) |
+| `Select` | `select` | `cond`, `a`, `b` | Conditional: `a` if `cond > 0`, else `b` |
+| `Wrap` | `wrap` | `a`, `lo`, `hi` | Wrap value into range |
+| `Fold` | `fold` | `a`, `lo`, `hi` | Fold (reflect) value into range |
+| `Mix` | `mix` | `a`, `b`, `t` | Linear interpolation: `a + (b - a) * t` |
+
+### Delay
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `DelayLine` | `delay` | `max_samples` | Circular buffer declaration |
+| `DelayRead` | `delay_read` | `delay`, `tap`, `interp` | Read from delay line (none/linear/cubic) |
+| `DelayWrite` | `delay_write` | `delay`, `value` | Write to delay line |
+| `History` | `history` | `input`, `init` | Single-sample delay (z^-1 feedback) |
+
+### Buffer / Table
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `Buffer` | `buffer` | `size` | Random-access data buffer |
+| `BufRead` | `buf_read` | `buffer`, `index`, `interp` | Read from buffer (none/linear/cubic, clamped) |
+| `BufWrite` | `buf_write` | `buffer`, `index`, `value` | Write to buffer at index |
+| `BufSize` | `buf_size` | `buffer` | Returns buffer length as float |
+
+### Filters
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `Biquad` | `biquad` | `a`, `b0`, `b1`, `b2`, `a1`, `a2` | Generic biquad (user supplies coefficients) |
+| `SVF` | `svf` | `a`, `freq`, `q`, `mode` | State-variable filter (lp/hp/bp/notch) |
+| `OnePole` | `onepole` | `a`, `coeff` | One-pole lowpass |
+| `DCBlock` | `dcblock` | `a` | DC blocking filter |
+| `Allpass` | `allpass` | `a`, `coeff` | First-order allpass |
+
+### Oscillators / Sources
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `Phasor` | `phasor` | `freq` | Ramp oscillator 0..1 |
+| `SinOsc` | `sinosc` | `freq` | Sine oscillator |
+| `TriOsc` | `triosc` | `freq` | Triangle wave |
+| `SawOsc` | `sawosc` | `freq` | Bipolar saw (-1..1) |
+| `PulseOsc` | `pulseosc` | `freq`, `width` | Pulse/square with variable duty cycle |
+| `Noise` | `noise` | -- | White noise source |
+
+### State / Timing
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `Delta` | `delta` | `a` | Sample-to-sample difference |
+| `Change` | `change` | `a` | 1.0 if value changed, else 0.0 |
+| `SampleHold` | `sample_hold` | `a`, `trig` | Latch on any zero crossing |
+| `Latch` | `latch` | `a`, `trig` | Latch on rising edge only |
+| `Accum` | `accum` | `incr`, `reset` | Running sum, resets when `reset > 0` |
+| `Counter` | `counter` | `trig`, `max` | Integer counter, wraps at max |
+
+## C++ Compilation
+
+`compile_graph()` generates a single self-contained `.cpp` file with:
+
+- A state struct (`{Name}State`)
+- `create(sr)` / `destroy(self)` / `reset(self)` lifecycle
+- `perform(self, ins, outs, n)` sample-processing loop
+- Param introspection: `num_params`, `param_name`, `param_min`, `param_max`, `set_param`, `get_param`
+- Buffer introspection: `num_buffers`, `buffer_name`, `buffer_size`, `get_buffer`, `set_buffer`
+
+```python
+from dsp_graph import compile_graph, compile_graph_to_file
+
+code = compile_graph(graph)           # returns C++ string
+path = compile_graph_to_file(graph, "build/")  # writes build/{name}.cpp
+```
+
+## gen-dsp Integration
+
+dsp-graph graphs can be compiled into buildable audio plugin projects via [gen-dsp](https://github.com/shakfu/gen-dsp), which supports 11 platforms: ChucK, CLAP, AudioUnit, VST3, LV2, SuperCollider, VCV Rack, Daisy, and more.
+
+`compile_for_gen_dsp()` generates the three files needed to drop into any gen-dsp platform backend:
+
+```python
+from dsp_graph import compile_for_gen_dsp
+
+# Generates: test_synth.cpp, _ext_chuck.cpp, manifest.json
+compile_for_gen_dsp(graph, "build/", platform="chuck")
+```
+
+The adapter replaces gen-dsp's genlib-side code while reusing its platform-side code unchanged. The generated `manifest.json` is compatible with `gen_dsp.core.manifest.Manifest`.
+
+For a fully assembled project (requires gen-dsp installed):
+
+```python
+from dsp_graph.gen_dsp_adapter import assemble_project
+
+# Copies platform templates + generates adapter + manifest
+assemble_project(graph, "build/chuck_project", platform="chuck")
+```
+
+## Optimization
+
+```python
+from dsp_graph import optimize_graph, constant_fold, eliminate_cse, eliminate_dead_nodes
+
+optimized = optimize_graph(graph)  # constant folding + CSE + dead node elimination
+```
+
+- **Constant folding**: pure nodes with all-constant inputs are replaced by `Constant` nodes
+- **Common subexpression elimination**: duplicate pure nodes with identical inputs are merged
+- **Dead node elimination**: nodes not reachable from any output are removed (respects side-effecting writers for delay lines and buffers)
+- **Loop-invariant code motion**: param-only expressions are hoisted before the sample loop
+- **SIMD hints**: `__restrict` on I/O pointers; vectorization pragmas for pure-only graphs
+
+## Validation
+
+`validate_graph()` checks:
+
+1. Unique node IDs (no collisions with inputs or params)
+2. All string references resolve to existing IDs
+3. Output sources reference existing nodes
+4. DelayRead/DelayWrite reference existing DelayLine nodes
+5. BufRead/BufWrite/BufSize reference existing Buffer nodes
+6. No pure cycles (cycles must pass through History or delay)
+
+## Visualization
+
+```python
+from dsp_graph import graph_to_dot, graph_to_dot_file
+
+dot_str = graph_to_dot(graph)                  # DOT string
+dot_path = graph_to_dot_file(graph, "build/")  # writes .dot, renders .pdf if `dot` is on PATH
+```
+
+## Examples
+
+See `examples/` for complete working graphs:
+
+- `stereo_gain.py` -- stateless stereo gain
+- `onepole.py` -- one-pole lowpass with History feedback
+- `fbdelay.py` -- feedback delay with dry/wet mix
+- `wavetable.py` -- wavetable oscillator using Buffer + Phasor + BufRead
+
+## Development
+
+```bash
+make install-dev  # install with dev deps
+make test         # run tests
+make lint         # ruff check
+make typecheck    # mypy --strict
+make qa           # all of the above
+```

dsp_graph-0.1.5/README.md

@@ -0,0 +1,208 @@
+# dsp-graph
+
+A Python DSL for defining DSP signal graphs, compiling them to standalone C++, and optimizing the result.
+
+Define audio processing graphs using Pydantic models, validate them, compile to C++, and serialize to/from JSON. Zero runtime dependencies beyond Pydantic.
+
+## Install
+
+```bash
+pip install dsp-graph
+```
+
+For development:
+
+```bash
+git clone https://github.com/shakfu/dsp-graph.git
+cd dsp-graph
+make install-dev
+```
+
+## Quick Start
+
+```python
+from dsp_graph import (
+    AudioInput, AudioOutput, BinOp, Graph, History, Param,
+    compile_graph, validate_graph,
+)
+
+graph = Graph(
+    name="onepole",
+    inputs=[AudioInput(id="in1")],
+    outputs=[AudioOutput(id="out1", source="result")],
+    params=[Param(name="coeff", min=0.0, max=0.999, default=0.5)],
+    nodes=[
+        BinOp(id="inv_coeff", op="sub", a=1.0, b="coeff"),
+        BinOp(id="dry", op="mul", a="in1", b="inv_coeff"),
+        History(id="prev", init=0.0, input="result"),
+        BinOp(id="wet", op="mul", a="prev", b="coeff"),
+        BinOp(id="result", op="add", a="dry", b="wet"),
+    ],
+)
+
+errors = validate_graph(graph)
+assert errors == []
+
+code = compile_graph(graph)  # standalone C++ string
+print(graph.model_dump_json(indent=2))
+```
+
+## Node Types (34)
+
+### Arithmetic / Math
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `BinOp` | `add`, `sub`, `mul`, `div`, `min`, `max`, `mod`, `pow` | `a`, `b` | Binary arithmetic |
+| `UnaryOp` | `sin`, `cos`, `tanh`, `exp`, `log`, `abs`, `sqrt`, `neg`, `floor`, `ceil`, `round`, `sign`, `atan`, `asin`, `acos` | `a` | Unary math functions |
+| `Clamp` | `clamp` | `a`, `lo`, `hi` | Saturate to `[lo, hi]` |
+| `Constant` | `constant` | `value` | Literal float value |
+| `Compare` | `gt`, `lt`, `gte`, `lte`, `eq` | `a`, `b` | Comparison (returns 0.0 or 1.0) |
+| `Select` | `select` | `cond`, `a`, `b` | Conditional: `a` if `cond > 0`, else `b` |
+| `Wrap` | `wrap` | `a`, `lo`, `hi` | Wrap value into range |
+| `Fold` | `fold` | `a`, `lo`, `hi` | Fold (reflect) value into range |
+| `Mix` | `mix` | `a`, `b`, `t` | Linear interpolation: `a + (b - a) * t` |
+
+### Delay
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `DelayLine` | `delay` | `max_samples` | Circular buffer declaration |
+| `DelayRead` | `delay_read` | `delay`, `tap`, `interp` | Read from delay line (none/linear/cubic) |
+| `DelayWrite` | `delay_write` | `delay`, `value` | Write to delay line |
+| `History` | `history` | `input`, `init` | Single-sample delay (z^-1 feedback) |
+
+### Buffer / Table
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `Buffer` | `buffer` | `size` | Random-access data buffer |
+| `BufRead` | `buf_read` | `buffer`, `index`, `interp` | Read from buffer (none/linear/cubic, clamped) |
+| `BufWrite` | `buf_write` | `buffer`, `index`, `value` | Write to buffer at index |
+| `BufSize` | `buf_size` | `buffer` | Returns buffer length as float |
+
+### Filters
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `Biquad` | `biquad` | `a`, `b0`, `b1`, `b2`, `a1`, `a2` | Generic biquad (user supplies coefficients) |
+| `SVF` | `svf` | `a`, `freq`, `q`, `mode` | State-variable filter (lp/hp/bp/notch) |
+| `OnePole` | `onepole` | `a`, `coeff` | One-pole lowpass |
+| `DCBlock` | `dcblock` | `a` | DC blocking filter |
+| `Allpass` | `allpass` | `a`, `coeff` | First-order allpass |
+
+### Oscillators / Sources
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `Phasor` | `phasor` | `freq` | Ramp oscillator 0..1 |
+| `SinOsc` | `sinosc` | `freq` | Sine oscillator |
+| `TriOsc` | `triosc` | `freq` | Triangle wave |
+| `SawOsc` | `sawosc` | `freq` | Bipolar saw (-1..1) |
+| `PulseOsc` | `pulseosc` | `freq`, `width` | Pulse/square with variable duty cycle |
+| `Noise` | `noise` | -- | White noise source |
+
+### State / Timing
+
+| Node | `op` | Fields | Purpose |
+|------|------|--------|---------|
+| `Delta` | `delta` | `a` | Sample-to-sample difference |
+| `Change` | `change` | `a` | 1.0 if value changed, else 0.0 |
+| `SampleHold` | `sample_hold` | `a`, `trig` | Latch on any zero crossing |
+| `Latch` | `latch` | `a`, `trig` | Latch on rising edge only |
+| `Accum` | `accum` | `incr`, `reset` | Running sum, resets when `reset > 0` |
+| `Counter` | `counter` | `trig`, `max` | Integer counter, wraps at max |
+
+## C++ Compilation
+
+`compile_graph()` generates a single self-contained `.cpp` file with:
+
+- A state struct (`{Name}State`)
+- `create(sr)` / `destroy(self)` / `reset(self)` lifecycle
+- `perform(self, ins, outs, n)` sample-processing loop
+- Param introspection: `num_params`, `param_name`, `param_min`, `param_max`, `set_param`, `get_param`
+- Buffer introspection: `num_buffers`, `buffer_name`, `buffer_size`, `get_buffer`, `set_buffer`
+
+```python
+from dsp_graph import compile_graph, compile_graph_to_file
+
+code = compile_graph(graph)           # returns C++ string
+path = compile_graph_to_file(graph, "build/")  # writes build/{name}.cpp
+```
+
+## gen-dsp Integration
+
+dsp-graph graphs can be compiled into buildable audio plugin projects via [gen-dsp](https://github.com/shakfu/gen-dsp), which supports 11 platforms: ChucK, CLAP, AudioUnit, VST3, LV2, SuperCollider, VCV Rack, Daisy, and more.
+
+`compile_for_gen_dsp()` generates the three files needed to drop into any gen-dsp platform backend:
+
+```python
+from dsp_graph import compile_for_gen_dsp
+
+# Generates: test_synth.cpp, _ext_chuck.cpp, manifest.json
+compile_for_gen_dsp(graph, "build/", platform="chuck")
+```
+
+The adapter replaces gen-dsp's genlib-side code while reusing its platform-side code unchanged. The generated `manifest.json` is compatible with `gen_dsp.core.manifest.Manifest`.
+
+For a fully assembled project (requires gen-dsp installed):
+
+```python
+from dsp_graph.gen_dsp_adapter import assemble_project
+
+# Copies platform templates + generates adapter + manifest
+assemble_project(graph, "build/chuck_project", platform="chuck")
+```
+
+## Optimization
+
+```python
+from dsp_graph import optimize_graph, constant_fold, eliminate_cse, eliminate_dead_nodes
+
+optimized = optimize_graph(graph)  # constant folding + CSE + dead node elimination
+```
+
+- **Constant folding**: pure nodes with all-constant inputs are replaced by `Constant` nodes
+- **Common subexpression elimination**: duplicate pure nodes with identical inputs are merged
+- **Dead node elimination**: nodes not reachable from any output are removed (respects side-effecting writers for delay lines and buffers)
+- **Loop-invariant code motion**: param-only expressions are hoisted before the sample loop
+- **SIMD hints**: `__restrict` on I/O pointers; vectorization pragmas for pure-only graphs
+
+## Validation
+
+`validate_graph()` checks:
+
+1. Unique node IDs (no collisions with inputs or params)
+2. All string references resolve to existing IDs
+3. Output sources reference existing nodes
+4. DelayRead/DelayWrite reference existing DelayLine nodes
+5. BufRead/BufWrite/BufSize reference existing Buffer nodes
+6. No pure cycles (cycles must pass through History or delay)
+
+## Visualization
+
+```python
+from dsp_graph import graph_to_dot, graph_to_dot_file
+
+dot_str = graph_to_dot(graph)                  # DOT string
+dot_path = graph_to_dot_file(graph, "build/")  # writes .dot, renders .pdf if `dot` is on PATH
+```
+
+## Examples
+
+See `examples/` for complete working graphs:
+
+- `stereo_gain.py` -- stateless stereo gain
+- `onepole.py` -- one-pole lowpass with History feedback
+- `fbdelay.py` -- feedback delay with dry/wet mix
+- `wavetable.py` -- wavetable oscillator using Buffer + Phasor + BufRead
+
+## Development
+
+```bash
+make install-dev  # install with dev deps
+make test         # run tests
+make lint         # ruff check
+make typecheck    # mypy --strict
+make qa           # all of the above
+```

dsp_graph-0.1.5/pyproject.toml

@@ -0,0 +1,68 @@
+[project]
+name = "dsp-graph"
+version = "0.1.5"
+description = "A Python DSL for defining DSP signal graphs with C++ compilation and optimization"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    { name = "Shakeeb Alireza", email = "shakfu@users.noreply.github.com" }
+]
+keywords = ["dsp", "audio", "signal-processing", "codegen", "c++", "pydantic", "graph"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Other Audience",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Multimedia :: Sound/Audio",
+    "Topic :: Software Development :: Code Generators",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "pydantic>=2.0",
+]
+
+[dependency-groups]
+dev = [
+    "gen-dsp>=0.1.6",
+    "mypy>=1.19.1",
+    "pytest>=9.0.2",
+    "pytest-cov>=7.0.0",
+    "ruff>=0.15.0",
+    "twine>=6.2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/shakfu/dsp-graph"
+Repository = "https://github.com/shakfu/dsp-graph"
+Changelog = "https://github.com/shakfu/dsp-graph/blob/main/CHANGELOG.md"
+Issues = "https://github.com/shakfu/dsp-graph/issues"
+
+[build-system]
+requires = ["uv_build>=0.10.2,<0.11.0"]
+build-backend = "uv_build"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=dsp_graph --cov-report term-missing:skip-covered"
+
+[tool.mypy]
+strict = true
+packages = ["dsp_graph"]
+mypy_path = "src"
+plugins = ["pydantic.mypy"]
+
+[tool.ruff]
+src = ["src"]
+line-length = 99
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]

dsp_graph-0.1.5/src/dsp_graph/__init__.py

@@ -0,0 +1,118 @@
+"""Define DSP signal graphs as Pydantic models, compile to C++, and optimize.
+
+Provides 34 node types (arithmetic, filters, oscillators, delays, buffers,
+state/timing), graph validation, topological sort, Graphviz visualization,
+and a multi-pass optimizing compiler targeting standalone C++. Optional
+gen-dsp integration generates adapter code for 10+ audio plugin platforms.
+"""
+
+from dsp_graph.compile import compile_graph, compile_graph_to_file
+from dsp_graph.gen_dsp_adapter import (
+    compile_for_gen_dsp,
+    generate_adapter_cpp,
+    generate_manifest,
+)
+from dsp_graph.models import (
+    SVF,
+    Accum,
+    Allpass,
+    AudioInput,
+    AudioOutput,
+    BinOp,
+    Biquad,
+    Buffer,
+    BufRead,
+    BufSize,
+    BufWrite,
+    Change,
+    Clamp,
+    Compare,
+    Constant,
+    Counter,
+    DCBlock,
+    DelayLine,
+    DelayRead,
+    DelayWrite,
+    Delta,
+    Fold,
+    Graph,
+    History,
+    Latch,
+    Mix,
+    Node,
+    Noise,
+    OnePole,
+    Param,
+    Phasor,
+    PulseOsc,
+    Ref,
+    SampleHold,
+    SawOsc,
+    Select,
+    SinOsc,
+    TriOsc,
+    UnaryOp,
+    Wrap,
+)
+from dsp_graph.optimize import constant_fold, eliminate_cse, eliminate_dead_nodes, optimize_graph
+from dsp_graph.toposort import toposort
+from dsp_graph.validate import validate_graph
+from dsp_graph.visualize import graph_to_dot, graph_to_dot_file
+
+__version__ = "0.1.5"
+
+__all__ = [
+    "Accum",
+    "Allpass",
+    "AudioInput",
+    "AudioOutput",
+    "BinOp",
+    "Biquad",
+    "BufRead",
+    "BufSize",
+    "BufWrite",
+    "Buffer",
+    "Change",
+    "Clamp",
+    "Compare",
+    "Constant",
+    "Counter",
+    "DCBlock",
+    "DelayLine",
+    "DelayRead",
+    "DelayWrite",
+    "Delta",
+    "Fold",
+    "Graph",
+    "History",
+    "Latch",
+    "Mix",
+    "Node",
+    "Noise",
+    "OnePole",
+    "Param",
+    "Phasor",
+    "PulseOsc",
+    "Ref",
+    "SVF",
+    "SampleHold",
+    "SawOsc",
+    "Select",
+    "SinOsc",
+    "TriOsc",
+    "UnaryOp",
+    "Wrap",
+    "compile_for_gen_dsp",
+    "compile_graph",
+    "compile_graph_to_file",
+    "constant_fold",
+    "eliminate_cse",
+    "eliminate_dead_nodes",
+    "generate_adapter_cpp",
+    "generate_manifest",
+    "graph_to_dot",
+    "graph_to_dot_file",
+    "optimize_graph",
+    "toposort",
+    "validate_graph",
+]

dsp_graph-0.1.5/src/dsp_graph/_deps.py

@@ -0,0 +1,37 @@
+"""Shared dependency helpers for graph analysis."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+from dsp_graph.models import Graph, History
+
+
+def is_feedback_edge(node: object, field_name: str) -> bool:
+    """Return True if a field on this node is a feedback edge (not a data dependency)."""
+    # History.input is written at end of sample -- reads previous value
+    if isinstance(node, History) and field_name == "input":
+        return True
+    # DelayRead reads from the delay line written by DelayWrite -- implicit feedback
+    # DelayWrite.value IS a data dependency (need the value this sample)
+    # But DelayRead.delay and DelayWrite.delay reference a DelayLine, not a data flow
+    return False
+
+
+def build_forward_deps(graph: Graph) -> dict[str, set[str]]:
+    """Build forward dependency map: {node_id: set of node_ids it depends on}.
+
+    Excludes feedback edges (History.input) and non-node references
+    (audio inputs, param names).
+    """
+    node_ids = {node.id for node in graph.nodes}
+    deps: dict[str, set[str]] = defaultdict(set)
+    for node in graph.nodes:
+        nid = node.id
+        for field_name, value in node.__dict__.items():
+            if field_name in ("id", "op"):
+                continue
+            if isinstance(value, str) and value in node_ids:
+                if not is_feedback_edge(node, field_name):
+                    deps[nid].add(value)
+    return deps