dagex 2026.15__cp310-cp310-manylinux_2_34_x86_64.whl

dagex/__init__.py

@@ -0,0 +1,5 @@
+from .dagex import *
+
+__doc__ = dagex.__doc__
+if hasattr(dagex, "__all__"):
+    __all__ = dagex.__all__

dagex-2026.15.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.1
+Name: dagex
+Version: 2026.15
+Summary: A pure Rust DAG executor supporting implicit node connections, branching, and config sweeps
+Keywords: dag,graph,execution,pipeline,workflow
+Home-Page: https://github.com/briday1/dagex
+Author: briday1 <your-email@example.com>
+Author-email: briday1 <your-email@example.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Source Code, https://github.com/briday1/dagex
+
+Real run (captured from `/Users/brian.day/git/graph-sp/.venv/bin/python examples/py/python_demo.py`):
+
+```
+======================================================================
+```
+Creating graph...
+Adding source node...
+Adding processor node...
+Adding formatter node...
+
+````markdown
+Mermaid (example):
+
+```
+graph TD
+    0["Source"]
+    1["Processor"]
+    2["Formatter"]
+    0 -->|data → input| 1
+    1 -->|final → value| 2
+```
+```bash
+pip install dagex
+```
+
+Quick overview:
+
+- Build a graph by adding functions (callables)
+- Inputs/outputs are mapped by names (broadcast → function param)
+- Branching and variants are supported
+- Use `to_mermaid()` to visualize the DAG
+- Execution returns a context-like mapping with results
+
+---
+
+## Minimal Python example
+
+```python
+import dagex
+
+# Data source
+def generate(_):
+    return {"n": 7}
+
+# Processor
+def double(inputs):
+    v = inputs.get("x", 0)
+    return {"y": v * 2}
+
+# Build graph
+g = dagex.Graph()
+g.add(generate, label="Source", inputs=None, outputs=[("n", "x")])
+g.add(double, label="Double", inputs=[("x", "x")], outputs=[("y", "out")])
+
+# Visualize and run
+dag = g.build()
+print('\nMermaid:\n', dag.to_mermaid())
+context = dag.execute(parallel=False)
+print('Result:', context.get('out'))
+```
+
+Expected output:
+
+```
+Result: 14
+```
+
+---
+
+## Branching & Merging (Python)
+
+```python
+import dagex
+
+# source
+def src(_):
+    return {"base": 50}
+
+# branch functions
+def add10(inputs):
+    return {"result": inputs.get("x", 0) + 10}
+
+def add20(inputs):
+    return {"result": inputs.get("x", 0) + 20}
+
+# graph
+g = dagex.Graph()
+g.add(src, label='Source', inputs=None, outputs=[('base', 'x')])
+
+b1 = dagex.Graph()
+b1.add(add10, label='A', inputs=[('x','x')], outputs=[('result','result')])
+
+b2 = dagex.Graph()
+b2.add(add20, label='B', inputs=[('x','x')], outputs=[('result','result')])
+
+id1 = g.branch(b1)
+id2 = g.branch(b2)
+
+# merge maps branch-specific result -> local names
+g.merge(lambda inputs: {"combined": inputs.get('from_a', 0) + inputs.get('from_b', 0)},
+        label='Merge',
+        inputs=[(id1, 'result', 'from_a'), (id2, 'result', 'from_b')],
+        outputs=[('combined', 'final')])
+
+dag = g.build()
+print(dag.to_mermaid())
+res = dag.execute(parallel=True)
+print('Final:', res.get('final'))
+```
+
+Expected output:
+
+```
+Final: 130
+```
+
+---
+
+## Variants (parameter sweep)
+
+```python
+import dagex
+
+# Source
+def src(_):
+    return {"base": 10}
+
+# Variant function builder (captures factor)
+def make_mul(factor):
+    def mul(inputs):
+        v = inputs.get('x', 0)
+        return {'result': v * factor}
+    return mul
+
+g = dagex.Graph()
+g.add(src, label='Source', inputs=None, outputs=[('base','x')])
+
+factors = [2,3,5]
+funcs = [make_mul(f) for f in factors]
+# wrap callables appropriately; the Python binding accepts callables directly
+g.variants(funcs, label='Multiply', inputs=[('x','x')], outputs=[('result','final')])
+
+dag = g.build()
+print(dag.to_mermaid())
+ctx = dag.execute(parallel=True)
+print('Final:', ctx.get('final'))
+```
+
+---
+
+## Notes & Tips
+
+- The Python API mirrors the Rust API closely. When in doubt, consult the Rust README for conceptual diagrams.
+- For large data, prefer providing structures that can be shared (e.g. numpy arrays wrapped appropriately) to avoid copies.
+- Use `dag.execute(parallel=True, max_threads=4)` to limit thread usage.
+
+---
+
+## Where to get help
+
+- Docs: https://docs.rs/dagex
+- Issues / PRs: https://github.com/briday1/graph-sp
+
+---
+
+<p align="center">Built with ❤️ — enjoy composing DAGs!</p>
+

dagex-2026.15.dist-info/RECORD

@@ -0,0 +1,5 @@
+dagex-2026.15.dist-info/METADATA,sha256=3CplVIlzUvAQCfDX_icaJ8xALGduNUaFZ4oIobJzBAs,4011
+dagex-2026.15.dist-info/WHEEL,sha256=4JO83XJFOmStWS-Qj5BwhHXFb7Bp_IDsmgflwVQvPn4,108
+dagex/__init__.py,sha256=uHbe0OdI2RMIcYORKDaI9JvEPcs3Iqxzy3Z5gpiCOiM,103
+dagex/dagex.cpython-310-x86_64-linux-gnu.so,sha256=Ll_WGmd1PGUhUrRCV-hoLMyLuvrB7foIu5fRGNcsAsg,862608
+dagex-2026.15.dist-info/RECORD,,

dagex-2026.15.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.2.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_34_x86_64