Welcome to the Volnux wiki!

Introduction

Simplify complex process automation with a flexible, high-performance framework.

This library tackles the challenges of building reliable, scalable workflows by providing a clear separation between coordination and execution. It uses a declarative DSL, Pointy-Lang, to model your pipelines while managing the underlying complexity of concurrency, state, and task dependencies.

Build resilient automation that can handle anything from simple data processing to distributed, event-driven systems.

Features

• Pointy-Lang DSL: Define task dependencies, conditional logic, and parallel execution using an intuitive, graph-based syntax.
• Hybrid Concurrency: Leverage asyncio for non-blocking I/O and multiprocessing for true parallel execution of CPU-bound tasks.
• Distributed Processing: Supports remote task execution and manages state across multiple processes with minimal overhead.
• Extensible Architecture: Easily integrate custom event logic, task executors, and signals to fit any use case.

┌─────────────────────────────────────────────────────────────────┐
│                    ExecutionCoordinator                          │
│  • Lifecycle management (setup, run, error handling, cleanup)   │
│  • Timeout enforcement                                           │
│  • Result processing                                             │
│  • State management                                              │
└────────────────┬────────────────────────────────────────────────┘
                 │
                 │ dispatch execution context
                 │ (state + task profiles)
                 ▼
┌─────────────────────────────────────────────────────────────────┐
│                       Flow Engine                                │
│  • setup_execution_flow() determines flow type                  │
└────────┬────────────────────────────┬────────────────────────────┘
         │                            │
         │ is_multitask()?           │
         ▼                            ▼
┌─────────────────┐          ┌─────────────────┐
│  ParallelFlow   │          │   SingleFlow    │
│                 │          │                 │
│ • Multiple      │          │ • Single event  │
│   events        │          │   execution     │
│ • Concurrent    │          │                 │
│   execution     │          │                 │
└────────┬────────┘          └────────┬────────┘
         │                            │
         │ both submit to             │
         ▼                            ▼
┌─────────────────────────────────────────────────────────────────┐
│                   Executor Interface                             │
│                (concurrent.futures.Executor)                     │
└───┬─────────────┬─────────────┬─────────────┬───────────────────┘
    │             │             │             │
    ▼             ▼             ▼             ▼
┌─────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────────┐
│ Default │ │  Thread  │ │ Process  │ │ Remote Executors │
│Executor │ │   Pool   │ │   Pool   │ │ (gRPC, RPC, etc) │
│         │ │          │ │          │ │                  │
│ Same    │ │ Thread-  │ │ Process- │ │ Distributed      │
│ thread  │ │ based    │ │ based    │ │ execution        │
└─────────┘ └──────────┘ └────┬─────┘ └──────────────────┘
                               │
                               │ managed by
                               ▼
                    ┌──────────────────────────┐
                    │  VolnuxPoolManager       │
                    │  (Singleton)             │
                    │                          │
                    │  • Lifecycle management  │
                    │  • Context tracking      │
                    │  • Worker cap (fork bomb │
                    │    prevention)           │
                    │  • Multi-backend support │
                    └──────────────────────────┘