Skip to main content

dagex - Python Edition

A pure Rust DAG executor with Python bindings for building and executing complex computational workflows.

🚀 Quick Start

pip install dagex

📖 Overview

dagex provides a powerful yet simple API for building directed acyclic graphs (DAGs) of computational tasks. Key features:

  • Automatic dependency resolution based on data flow
  • Parallel execution of independent nodes
  • Branching for creating independent subgraphs
  • Variants for parameter sweeps and A/B testing
  • Mermaid diagrams for visualizing your pipeline

Python Parallel Execution & the GIL

Python's Global Interpreter Lock (GIL) means that pure Python computations cannot achieve true parallelism. However, dagex enables true parallel execution when your node functions perform operations that release the GIL, such as:

  • I/O operations: File reads/writes, network calls, database queries
  • NumPy/SciPy operations: Most numerical computations in these libraries release the GIL
  • C extensions: Custom C/Rust extensions that release the GIL
  • Sleep/wait operations: Simulating blocking operations

The examples in this package use time.sleep() to demonstrate parallelization benefits, as sleep operations release the GIL and allow other threads to run concurrently.

🎯 Basic Example

import dagex

def generate(_inputs):
    return {"n": 7}

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")])

# Execute
dag = g.build()
print(dag.to_mermaid())  # Visualize
context = dag.execute(parallel=False)
print('Result:', context.get('out'))  # Result: 14

📚 Examples

All examples can be run directly:

python3 examples/py/01_minimal_pipeline.py
python3 examples/py/02_parallel_vs_sequential.py
python3 examples/py/03_branch_and_merge.py
python3 examples/py/04_variants_sweep.py
python3 examples/py/05_output_access.py
python3 examples/py/06_graphdata_large_payload_arc_or_shared_data.py

Example 01: Minimal Pipeline

The simplest possible DAG: generator → transformer → aggregator.

Description: Shows a basic 3-node pipeline where each node depends on the previous one. Demonstrates the fundamental dataflow concept.

Syntax:

import dagex

graph = dagex.Graph()

# Add nodes to the pipeline
graph.add(
    generate,                    # Python callable
    label="Generator",
    inputs=None,                 # No inputs (source node)
    outputs=[("number", "x")]    # Output mapping: impl → broadcast
)

graph.add(
    double,
    label="Doubler",
    inputs=[("x", "x")],         # Input mapping: broadcast → impl
    outputs=[("result", "y")]
)

# Build and execute
dag = graph.build()
context = dag.execute(parallel=False)  # Sequential
context = dag.execute(parallel=True)   # Parallel

Mermaid Diagram:

graph TD
0["Generator"]
1["Doubler"]
2["AddFive"]
0 -->|x → x| 1
1 -->|y → y| 2

Performance (Sequential):

⏱️  Runtime: 302.202ms
💾 Memory: Current: 0.05 KB, Peak: 0.05 KB

Performance (Parallel):

⏱️  Runtime: 304.032ms
💾 Memory: Current: 0.07 KB, Peak: 0.07 KB

Output:

Sequential execution:
Final output: 25
Time: 302.202ms
Parallel execution:
Final output: 25
Time: 304.032ms
✅ Pipeline completed successfully!
(Started with 10, doubled to 20, added 5 = 25)

Example 02: Parallel vs Sequential Execution

Demonstrates the power of parallel execution for independent tasks.

Description: Shows three independent tasks (A, B, C) that each simulate I/O-bound work. When executed sequentially, tasks run one after another. When executed in parallel, independent tasks run simultaneously, demonstrating significant speedup.

Syntax:

import dagex

# Add independent tasks
graph.add(task_a, label="TaskA", inputs=[("input", "input")], outputs=[("result_a", "a")])
graph.add(task_b, label="TaskB", inputs=[("input", "input")], outputs=[("result_b", "b")])
graph.add(task_c, label="TaskC", inputs=[("input", "input")], outputs=[("result_c", "c")])

# Build and execute
dag = graph.build()

# Sequential vs parallel
context_seq = dag.execute(parallel=False)
context_par = dag.execute(parallel=True, max_threads=4)

Mermaid Diagram:

graph TD
0["Source"]
1["TaskA"]
2["TaskB"]
3["TaskC"]
0 -->|input → input| 1
0 -->|input → input| 2
0 -->|input → input| 3

Performance (Sequential):

⏱️  Runtime: 453.869ms
💾 Memory: Current: 0.04 KB, Peak: 0.04 KB

Performance (Parallel):

⏱️  Runtime: 150.673ms
💾 Memory: Current: 0.25 KB, Peak: 1.16 KB

Output:

Sequential results:
TaskA: 110
TaskB: 120
TaskC: 130
Time: 453.869ms
Parallel results:
TaskA: 110
TaskB: 120
TaskC: 130
Time: 150.673ms
⚡ Speedup: 3.01x faster with parallel execution!

Example 03: Branch and Merge

Fan-out (branching) and fan-in (merging) patterns for complex workflows.

Description: Demonstrates creating independent branches that process data in parallel, then merging their outputs. Each branch contains its own subgraph that can have multiple nodes.

Syntax:

import dagex

# Create branches
branch_a = dagex.Graph()
branch_a.add(path_a_func, label="PathA (+10)", ...)
branch_a_id = graph.branch(branch_a)

branch_b = dagex.Graph()
branch_b.add(path_b_func, label="PathB (+20)", ...)
branch_b_id = graph.branch(branch_b)

# Merge branches
graph.merge(
    merge_func,
    label="Merge",
    branch_inputs=[
        (branch_a_id, "result", "from_a"),
        (branch_b_id, "result", "from_b"),
    ],
    outputs=[("combined", "final")]
)

Mermaid Diagram:

graph TD
0["Source"]
1["PathA (+10)"]
2["PathB (+20)"]
3["Combine"]
4["PathA (+10)"]
5["PathB (+20)"]
0 -->|x → x| 1
0 -->|x → x| 2
4 -->|a → a| 3
2 -->|b → b| 3
5 -->|b → b| 3
1 -->|a → a| 3
0 -->|x → x| 4
0 -->|x → x| 5
style 1 fill:#e1f5ff
style 2 fill:#e1f5ff

Performance (Sequential):

⏱️  Runtime: 602.807ms
💾 Memory: Current: 0.35 KB, Peak: 0.35 KB

Performance (Parallel):

⏱️  Runtime: 152.378ms
💾 Memory: Current: 0.62 KB, Peak: 1.37 KB

Output:

📊 Execution flow:
Source: 50
PathA: 50 + 10 = 60
PathB: 50 + 20 = 70
Combine: 60 + 70 = 130
Sequential execution:
Final output: 130
Time: 602.807ms
Parallel execution:
Final output: 130
Time: 152.378ms
✅ Branch and merge completed successfully!

Example 04: Variants (Parameter Sweep)

Run multiple variants in parallel—perfect for hyperparameter tuning or A/B testing.

Description: Demonstrates running multiple nodes with the same structure but different parameters. All variants execute at the same level in the DAG, enabling efficient parallel exploration of parameter spaces.

Syntax:

import dagex

# Create variant functions with different parameters
def make_multiplier(factor):
    def multiplier(inputs):
        value = inputs.get("x", 0)
        return {"result": value * factor}
    return multiplier

# Create multiple variants
factors = [2, 3, 5, 7]
variant_funcs = [make_multiplier(f) for f in factors]

# Add all variants at once
graph.variants(
    variant_funcs,
    label="Multiplier",
    inputs=[("x", "x")],
    outputs=[("result", "results")]
)

Mermaid Diagram:

graph TD
0["DataSource"]
1["Multiplier (v0)"]
2["Multiplier (v1)"]
3["Multiplier (v2)"]
4["Multiplier (v3)"]
0 -->|x → x| 1
0 -->|x → x| 2
0 -->|x → x| 3
0 -->|x → x| 4
style 1 fill:#e1f5ff
style 2 fill:#e1f5ff
style 3 fill:#e1f5ff
style 4 fill:#e1f5ff
style 1 fill:#ffe1e1
style 2 fill:#e1ffe1
style 3 fill:#ffe1ff
style 4 fill:#ffffe1

Performance (Sequential):

⏱️  Runtime: 605.985ms
💾 Memory: Current: 0.05 KB, Peak: 0.05 KB

Performance (Parallel):

⏱️  Runtime: 153.865ms
💾 Memory: Current: 0.48 KB, Peak: 1.53 KB

Output:

📊 Base value: 10
Sequential execution:
Time: 605.985ms
Parallel execution:
Time: 153.865ms
Detailed variant outputs:
Variant 0 (×2): 20
Variant 1 (×3): 30
Variant 2 (×5): 50
Variant 3 (×7): 70
✅ All 4 variants executed successfully!

Example 05: Output Access

Access intermediate results and branch outputs, not just final values.

Description: Demonstrates how to access different levels of output: final context outputs, individual node outputs, and branch-specific outputs. Uses execute_detailed() instead of execute() to get comprehensive execution information.

Syntax:

import dagex

# Execute with detailed output
result = dag.execute_detailed(parallel=True, max_threads=4)

# Access different output levels:
# 1. Final context outputs
final_output = result.context.get("output")

# 2. Per-node outputs
for node_id, outputs in result.node_outputs.items():
    print(f"Node {node_id}: {len(outputs)} outputs")

# 3. Branch-specific outputs
for branch_id, outputs in result.branch_outputs.items():
    print(f"Branch {branch_id}: {outputs}")

Mermaid Diagram:

graph TD
0["Source"]
1["ProcessorA"]
2["ProcessorB"]
3["Combine"]
4["ProcessorA"]
5["ProcessorB"]
0 -->|input → input| 1
0 -->|input → input| 2
4 -->|a → a| 3
5 -->|b → b| 3
1 -->|a → a| 3
2 -->|b → b| 3
0 -->|input → input| 4
0 -->|input → input| 5
style 1 fill:#e1f5ff
style 2 fill:#e1f5ff

Performance (Sequential):

⏱️  Runtime: 603.634ms
💾 Memory: Current: 0.43 KB, Peak: 0.43 KB

Performance (Parallel):

⏱️  Runtime: 150.890ms
💾 Memory: Current: 0.70 KB, Peak: 1.55 KB

Output:

📊 Accessing outputs:
Sequential execution:
Time: 603.634ms
Parallel execution:
Time: 150.890ms
Final context outputs:
output: 351
Execution flow:
Source: 100
ProcessorA (branch A): 100 × 2 = 200
ProcessorB (branch B): 100 + 50 = 150
Combine: 200 + 150 + 1 = 351
✅ Successfully accessed outputs!

Example 06: Zero-Copy Data Sharing

Large data is automatically wrapped in Arc for efficient sharing without copying.

Description: Demonstrates efficient memory handling for large datasets. GraphData automatically wraps large vectors (int_vec, float_vec) in Arc, enabling multiple nodes to read the same data without duplication.

Syntax:

import dagex
import numpy as np

# Create large data
def create_large_data(_inputs):
    # Large numpy array - efficiently shared
    large_array = list(range(1_000_000))
    return {"large_data": large_array}

graph.add(create_large_data, label="CreateLargeData", ...)

# Multiple consumers access the same data - minimal copying
graph.add(consumer_a, label="ConsumerA", ...)
graph.add(consumer_b, label="ConsumerB", ...)
graph.add(consumer_c, label="ConsumerC", ...)

Mermaid Diagram:

graph TD
0["CreateLargeData"]
1["ConsumerA"]
2["ConsumerB"]
3["ConsumerC"]
0 -->|data → data| 1
0 -->|data → data| 2
0 -->|data → data| 3

Performance (Sequential):

⏱️  Runtime: 597.179ms
💾 Memory: Current: 39054.78 KB, Peak: 39062.48 KB

Performance (Parallel):

⏱️  Runtime: 542.189ms
💾 Memory: Current: 39054.81 KB, Peak: 39062.76 KB

Output:

📊 Consumer outputs (each processes different segments):
ConsumerA (first 1000):  sum = 499500
ConsumerB (next 1000):   sum = 1499500
ConsumerC (next 1000):   sum = 2499500
Sequential execution:
Time: 597.179ms
Parallel execution:
Time: 542.189ms
✅ Reference-based data sharing successful!
Memory benefit: Data shared by reference, not copied

🔧 Python API

Building a Graph

import dagex

# Create graph
cache = dagex.MemoryCache(namespace="pipeline-a", max_entries=2048)
graph = dagex.Graph(cache_backend=cache)

# Add a node
graph.add(
    function,                       # Python callable
    label="NodeLabel",              # Optional label
    inputs=[("broadcast", "impl")], # Input mapping
    outputs=[("impl", "broadcast")] # Output mapping
)

# Create branches
branch_graph = dagex.Graph()
# ... add nodes to branch_graph ...
branch_id = graph.branch(branch_graph)

# Merge branches
graph.merge(
    merge_function,
    label="Merge",
    branch_inputs=[
        (branch_id_a, "out_a", "in_a"),
        (branch_id_b, "out_b", "in_b")
    ],
    outputs=[("result", "final")]
)

# Add variants
graph.variants(
    [func1, func2, func3],
    label="Variants",
    inputs=[("input", "x")],
    outputs=[("output", "results")]
)

# Build and execute (cache can also be passed to build()/execute())
dag = graph.build(cache_backend=cache)
context = dag.execute(parallel=False)
context = dag.execute(parallel=True, max_threads=4)

Data Types

Python values are automatically converted to GraphData:

# Return Python dictionaries from node functions
def my_node(inputs):
    value = inputs.get("x", 0)  # Access inputs
    return {
        "int_val": 42,
        "float_val": 3.14,
        "str_val": "hello",
        "list_val": [1, 2, 3],
        "nested": {"a": 1, "b": 2}
    }

Execution

# Simple execution
context = dag.execute(parallel=False)  # Sequential
context = dag.execute(parallel=True, max_threads=4)  # Parallel

# Access results
result = context.get("output_name")

# Detailed execution
report = dag.execute(parallel=True, max_threads=4, detailed=True)
final_context = report["context"]
cache_stats = report["cache_stats"]
node_cache = report["node_cache"]   # per-node hit/miss/invalidation/incompatibility categories

# Invalidation
cache.clear_namespace("pipeline-a")
cache.clear_node(node_id=3, version="caf-v1")

📄 License

MIT License

🔗 Links

Metadata

Release files for dagex 2026.23

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for dagex 2026.23
File Size Uploaded Provenance Actions
dagex-2026.23.tar.gz 106.9 kB Without provenance Details for dagex-2026.23.tar.gz

Built distributions (wheels)

Table of built distributions (wheels) for dagex 2026.23
File Actions
dagex-2026.23-cp312-none-win_amd64.whl CPython 3.12 none Windows x86-64 Details for dagex-2026.23-cp312-none-win_amd64.whl
dagex-2026.23-cp312-cp312-manylinux_2_34_x86_64.whl CPython 3.12 CPython 3.12 Linux glibc 2.34+ x86-64 Details for dagex-2026.23-cp312-cp312-manylinux_2_34_x86_64.whl
dagex-2026.23-cp312-cp312-macosx_11_0_arm64.whl CPython 3.12 CPython 3.12 macOS 11.0+ ARM64 Details for dagex-2026.23-cp312-cp312-macosx_11_0_arm64.whl
dagex-2026.23-cp311-none-win_amd64.whl CPython 3.11 none Windows x86-64 Details for dagex-2026.23-cp311-none-win_amd64.whl
dagex-2026.23-cp311-cp311-manylinux_2_34_x86_64.whl CPython 3.11 CPython 3.11 Linux glibc 2.34+ x86-64 Details for dagex-2026.23-cp311-cp311-manylinux_2_34_x86_64.whl
dagex-2026.23-cp311-cp311-macosx_11_0_arm64.whl CPython 3.11 CPython 3.11 macOS 11.0+ ARM64 Details for dagex-2026.23-cp311-cp311-macosx_11_0_arm64.whl
dagex-2026.23-cp310-none-win_amd64.whl CPython 3.10 none Windows x86-64 Details for dagex-2026.23-cp310-none-win_amd64.whl
dagex-2026.23-cp310-cp310-manylinux_2_34_x86_64.whl CPython 3.10 CPython 3.10 Linux glibc 2.34+ x86-64 Details for dagex-2026.23-cp310-cp310-manylinux_2_34_x86_64.whl
dagex-2026.23-cp310-cp310-macosx_11_0_arm64.whl CPython 3.10 CPython 3.10 macOS 11.0+ ARM64 Details for dagex-2026.23-cp310-cp310-macosx_11_0_arm64.whl
dagex-2026.23-cp39-none-win_amd64.whl CPython 3.9 none Windows x86-64 Details for dagex-2026.23-cp39-none-win_amd64.whl
dagex-2026.23-cp39-cp39-manylinux_2_34_x86_64.whl CPython 3.9 CPython 3.9 Linux glibc 2.34+ x86-64 Details for dagex-2026.23-cp39-cp39-manylinux_2_34_x86_64.whl
dagex-2026.23-cp39-cp39-macosx_11_0_arm64.whl CPython 3.9 CPython 3.9 macOS 11.0+ ARM64 Details for dagex-2026.23-cp39-cp39-macosx_11_0_arm64.whl
dagex-2026.23-cp38-none-win_amd64.whl CPython 3.8 none Windows x86-64 Details for dagex-2026.23-cp38-none-win_amd64.whl
dagex-2026.23-cp38-cp38-manylinux_2_34_x86_64.whl CPython 3.8 CPython 3.8 Linux glibc 2.34+ x86-64 Details for dagex-2026.23-cp38-cp38-manylinux_2_34_x86_64.whl
dagex-2026.23-cp38-cp38-macosx_11_0_arm64.whl CPython 3.8 CPython 3.8 macOS 11.0+ ARM64 Details for dagex-2026.23-cp38-cp38-macosx_11_0_arm64.whl

Total release size: 7.0 MB

Release files / dagex-2026.23.tar.gz

Download URL dagex-2026.23.tar.gz
Size 106.9 kB
Tags Source
SHA-256 checksum
How to use checksums
bf95904244e332c82d83fa46cdcd237dcf61788058e09f9b8df8a202c4d44cba
BLAKE2b-256 checksum
How to use checksums
4833ebd475bf10126686fd690ffb2f3a82dca54d52d0ef91d1a61c555e49281b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp312-none-win_amd64.whl

Download URL dagex-2026.23-cp312-none-win_amd64.whl
Size 390.6 kB
Tags CPython 3.12 Windows x86-64
SHA-256 checksum
How to use checksums
c7f5e8286491868315f80e4daa8ba2f0ffae77459075c60ab22e1a595e547758
BLAKE2b-256 checksum
How to use checksums
b8ac25db5894b5c1b7f838bcf75e943d6c3d08f8fc9f11d7c69bce76eaaa8d49
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp312-cp312-manylinux_2_34_x86_64.whl

Download URL dagex-2026.23-cp312-cp312-manylinux_2_34_x86_64.whl
Size 554.3 kB
Tags CPython 3.12 Linux glibc 2.34+ x86-64
SHA-256 checksum
How to use checksums
bfe0e1e5231f6cf194ce7f8a7cf4354b5e0baee2cc029312332652c428d76812
BLAKE2b-256 checksum
How to use checksums
5950e4fe2221be718708f1c9a02308d8fd3cee255731fd31e121c694493e2c1c
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp312-cp312-macosx_11_0_arm64.whl

Download URL dagex-2026.23-cp312-cp312-macosx_11_0_arm64.whl
Size 426.5 kB
Tags CPython 3.12 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
f6bc865fe98e3bae71d26df9963e79cec1ff67c047abe3aec48487823b68a3f3
BLAKE2b-256 checksum
How to use checksums
f31562fba688a1ca6479cb5e8462814edf0538ef32ad1dc25ea95d9a07725ea4
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp311-none-win_amd64.whl

Download URL dagex-2026.23-cp311-none-win_amd64.whl
Size 390.2 kB
Tags CPython 3.11 Windows x86-64
SHA-256 checksum
How to use checksums
b7b737e24f0ac9f00ff22e3695ed7c1ce461f84f190277933cff3d2f20134d02
BLAKE2b-256 checksum
How to use checksums
a718e1c31315b7e3012b686c97827d8edf2d28a9c2f7e4a8503ab63175763490
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp311-cp311-manylinux_2_34_x86_64.whl

Download URL dagex-2026.23-cp311-cp311-manylinux_2_34_x86_64.whl
Size 554.6 kB
Tags CPython 3.11 Linux glibc 2.34+ x86-64
SHA-256 checksum
How to use checksums
19b201176d73ce3a4a965d8a15ebe6d2d9ffec64d96c6c91bbd65d97650ed0b4
BLAKE2b-256 checksum
How to use checksums
c98e60f097b19f3db9a00724f12f3226d4b8b042c58bee17410c0b294c5dc7f9
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp311-cp311-macosx_11_0_arm64.whl

Download URL dagex-2026.23-cp311-cp311-macosx_11_0_arm64.whl
Size 426.6 kB
Tags CPython 3.11 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
96e2b4bb9c0f0ae3bcce65a43f573b75c508186747cefb4479329f7390133c84
BLAKE2b-256 checksum
How to use checksums
845f5de70f9ee52098c4042d3791e824caccbfb1bd1a45fe67148acdceeb0a03
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp310-none-win_amd64.whl

Download URL dagex-2026.23-cp310-none-win_amd64.whl
Size 390.2 kB
Tags CPython 3.10 Windows x86-64
SHA-256 checksum
How to use checksums
47e42f2b487dab1b1a20ebd4ee668e9fe9d6b32985b08477d7857953e6d44279
BLAKE2b-256 checksum
How to use checksums
e78d7c6495da55c81a961ebd57418fd57bf0489294d331427389e0a579bc1275
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp310-cp310-manylinux_2_34_x86_64.whl

Download URL dagex-2026.23-cp310-cp310-manylinux_2_34_x86_64.whl
Size 554.6 kB
Tags CPython 3.10 Linux glibc 2.34+ x86-64
SHA-256 checksum
How to use checksums
9e3dee023226cbf756777f3d14ce0e1da9272258fb16ff19cd396f441e3c305c
BLAKE2b-256 checksum
How to use checksums
9022ebe9dd4df886b1786b7cbb5042a73ad8f95ed0f14af9594eb34b184d2ac6
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp310-cp310-macosx_11_0_arm64.whl

Download URL dagex-2026.23-cp310-cp310-macosx_11_0_arm64.whl
Size 426.6 kB
Tags CPython 3.10 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
200c16151a0fd5b046cea4f6bb20c6b6140496fae7f36e8fb50aa4fa5fb96cf4
BLAKE2b-256 checksum
How to use checksums
dba59fd577b7a83993023b20d048a00a602f12258b857af758f8f4b4b705c8ec
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp39-none-win_amd64.whl

Download URL dagex-2026.23-cp39-none-win_amd64.whl
Size 390.5 kB
Tags CPython 3.9 Windows x86-64
SHA-256 checksum
How to use checksums
ade4924a7ca306c83f87548a0756896f57e46d0174ceacc03c0f6c415e710715
BLAKE2b-256 checksum
How to use checksums
61b4a0b0c652ff9f6ae4b72b3dfa34925029138fc91598ff5916840721e38b47
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp39-cp39-manylinux_2_34_x86_64.whl

Download URL dagex-2026.23-cp39-cp39-manylinux_2_34_x86_64.whl
Size 554.9 kB
Tags CPython 3.9 Linux glibc 2.34+ x86-64
SHA-256 checksum
How to use checksums
f81b9f20fbdc839d8d2730d4edc25902d1f9667162d5098a77ea71b3703932a6
BLAKE2b-256 checksum
How to use checksums
e8b7d8deb0b4fcd5b5ab1161bab86e7157c85ab9196471bcffdf86a4b31d7f8b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp39-cp39-macosx_11_0_arm64.whl

Download URL dagex-2026.23-cp39-cp39-macosx_11_0_arm64.whl
Size 426.8 kB
Tags CPython 3.9 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
bf0e22d713249807392d6f18842bf1a28c7f70e4993687032d15739c501afbbc
BLAKE2b-256 checksum
How to use checksums
dcfcc4284dddb3ca735e88029d1425e6415653a8519e70c6fdba9de54a1b0966
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp38-none-win_amd64.whl

Download URL dagex-2026.23-cp38-none-win_amd64.whl
Size 390.2 kB
Tags CPython 3.8 Windows x86-64
SHA-256 checksum
How to use checksums
8b9407bf6f73f4d1429783dbd4a1ce43c0289848bc535b54a0880a070619a32d
BLAKE2b-256 checksum
How to use checksums
a6241d17cad51e97cd2fc8f518816345f36e41715fbf26157822330cb20d6e30
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp38-cp38-manylinux_2_34_x86_64.whl

Download URL dagex-2026.23-cp38-cp38-manylinux_2_34_x86_64.whl
Size 555.4 kB
Tags CPython 3.8 Linux glibc 2.34+ x86-64
SHA-256 checksum
How to use checksums
76041e4c22e176d636a4838d2476e25625b64c248cc0f1830092cec1622ff3f6
BLAKE2b-256 checksum
How to use checksums
4333614391ad7667422dcba8462442373991f28c4eb5a3471b320a1bf180cce1
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Release files / dagex-2026.23-cp38-cp38-macosx_11_0_arm64.whl

Download URL dagex-2026.23-cp38-cp38-macosx_11_0_arm64.whl
Size 426.8 kB
Tags CPython 3.8 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
dbf58d89563300d1c3408317b84200fff66fd83fa1c5fc62195fa7654919faaf
BLAKE2b-256 checksum
How to use checksums
8937134b8c3cb9eb4a776294f0613c331bc3eff9e90875a0eb8226d9ec1f87a9
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.10.20

Security for dagex 2026.23

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page