Multi-Path Flow Distribution system using a Capacity-Weighte

The problem

Distributing tasks across multiple paths is difficult when some paths have more capacity than others. Standard systems often overload some routes while others remain underused.

What it does

It automatically assigns tasks to the best available path based on its remaining capacity. It tracks the current load of each path and directs traffic to the least busy option.

Why it matters

It ensures a balanced flow of work by matching demand with the specific limits of each available path.

Validation

It was run inside an isolated container with no network access. This is the exact command and the real output it produced — captured process output, not written by a model.

$ python3 cwlc_distribution.py
Routing request to Path-A (Load: 1/10)
Routing request to Path-B (Load: 1/20)
Routing request to Path-C (Load: 1/5)
Routing request to Path-B (Load: 2/20)
Routing request to Path-A (Load: 2/10)
Routing request to Path-B (Load: 3/20)
Routing request to Path-B (Load: 4/20)
Routing request to Path-A (Load: 3/10)
Routing request to Path-B (Load: 5/20)
Routing request to Path-C (Load: 2/5)
Routing request to Path-B (Load: 6/20)
Routing request to Path-A (Load: 4/10)
Routing request to Path-B (Load: 7/20)
Routing request to Path-B (Load: 8/20)
Routing request to Path-A (Load: 5/10)

A screenshot of that run.

A clean run proves this does what is shown above, in a CPU-only sandbox. It is a small research demo — not a production tool, and nothing here was published anywhere.

The code

All of it — 33 lines, one file, standard library only.

# CWLC Multi-Path Flow Distribution Simulator

class Path:
    def __init__(self, name, capacity):
        self.name = name
        self.capacity = capacity
        self.current_load = 0
        self.last_updated = 0  # For future timestamp-based optimizations

    def calculate_score(self):
        return self.current_load / self.capacity


class CWLCRouter:
    def __init__(self, paths):
        self.paths = paths

    def select_path(self):
        return min(self.paths, key=lambda p: p.calculate_score())

    def distribute_flow(self, num_requests=10):
        for _ in range(num_requests):
            selected = self.select_path()
            selected.current_load += 1
            print(f"Routing request to {selected.name} (Load: {selected.current_load}/{selected.capacity})")

if __name__ == "__main__":
    # Initialize with sample paths
    paths = [Path(name="Path-A", capacity=10),
              Path(name="Path-B", capacity=20),
              Path(name="Path-C", capacity=5)]
    router = CWLCRouter(paths)
    router.distribute_flow(15)