Intuitive Rust-based channel concurrency using the actor/handle pattern

Install

$ pip install fechan

About

The fechan package ("Fe" = Iron = Rust + "chan" = channels) was designed to be intuitive. The fact that it is written in Rust does give it a measurable performance boost, it is ~1.5x faster than Python's built-in threading + queue libraries, but at the end of the day OS threads perform (more or less) the same regardless of the laguage used to spawn them.

The real benefit to using fechan comes from its intuitive API. All of the manual queue.Queue() / threading.Thread() / thread.join() operations required with Python's built-in threading + queue libraries are replaced by a simple "send + close + collect" pattern in fechan.

That's it, that's the whole API.

Example

Consider a typical Python concurrency workflow using Python's threading + queue libraries:

import threading
import queue

def some_cpu_or_io_func(x):
    """
    Some placeholder function for CPU bound / IO bound work
    """
    return x * x

def thread_worker(fn, args, q):
    try:
        q.put(fn(*args))
    except Exception as e:
        q.put(str(e))

queue_results = queue.Queue()
threads = []

for i in range(100):
    t = threading.Thread(target = thread_worker, args = (some_cpu_or_io_func, (i, ), queue_results))
    t.start()
    threads.append(t)

for t in threads:
    t.join()

results = [queue_results.get() for _ in range(100)]

We can compare that to the much more concise fechan workflow:

from fechan import create_channel

def some_cpu_or_io_func(x):
    """
    A placeholder function for CPU bound / IO bound work
    """
    return x * x

# The entire "send + close + collect" API:
actor, handle = create_channel()
for i in range(100):
    handle.send(some_cpu_or_io_func, (i, ))
handle.close()
results = actor.collect_results()

Roadmap

Work in progress...