forked from goodboy/tractor
1
0
Fork 0

Further tweaks, add non-scary snippet

readme_pump
Tyler Goodlet 2020-12-09 13:01:57 -05:00
parent 0a5a4d8487
commit 90c987d0ae
1 changed files with 32 additions and 12 deletions

View File

@ -8,28 +8,35 @@ The Python async-native multi-core system *you always wanted*.
.. _actor model: https://en.wikipedia.org/wiki/Actor_model .. _actor model: https://en.wikipedia.org/wiki/Actor_model
.. _trio: https://github.com/python-trio/trio .. _trio: https://github.com/python-trio/trio
.. _multiprocessing: https://en.wikipedia.org/wiki/Multiprocessing .. _multi-processing: https://en.wikipedia.org/wiki/Multiprocessing
.. _trionic: https://trio.readthedocs.io/en/latest/design.html#high-level-design-principles .. _trionic: https://trio.readthedocs.io/en/latest/design.html#high-level-design-principles
.. _async sandwich: https://trio.readthedocs.io/en/latest/tutorial.html#async-sandwich .. _async sandwich: https://trio.readthedocs.io/en/latest/tutorial.html#async-sandwich
.. _structured concurrent: https://trio.discourse.group/t/concise-definition-of-structured-concurrency/228 .. _structured concurrent: https://trio.discourse.group/t/concise-definition-of-structured-concurrency/228
``tractor`` is a `structured concurrent`_ "`actor model`_" built on trio_ and multiprocessing_. ``tractor`` is a `structured concurrent`_ "`actor model`_" built on trio_ and multi-processing_.
It is an attempt to pair trionic_ `structured concurrency`_ with It is an attempt to pair trionic_ `structured concurrency`_ with
distributed Python. You can think of it as a ``trio`` *-across-processes* distributed Python. You can think of it as a ``trio``
or simply as a replacement for the stdlib's `multiprocessing` but built *-across-processes* or simply as an opinionated replacement for the
on async primitives for IPC. stdlib's ``multiprocessing`` but built on async programming primitives
from the ground up.
``tractor``'s nurseries lets you spawn ``trio`` *"actors"*: new Python Don't be scared off by this description. ``tractor`` **is just ``trio``**
but with nurseries for process management and cancel-able IPC.
If you understand how to work with ``trio``, ``tractor`` will give you
the parallelism you've been missing.
``tractor``'s nurseries let you spawn ``trio`` *"actors"*: new Python
processes which each run a ``trio`` scheduled task tree (also known as processes which each run a ``trio`` scheduled task tree (also known as
an `async sandwich`_). That is, each "*Actor*" is a new process plus an `async sandwich`_ - a call to ``trio.run()``). That is, each
a `trio` runtime. "*Actor*" is a new process plus a ``trio`` runtime.
Processes communicate by exchanging asynchronous messages_ and avoid "Actors" communicate by exchanging asynchronous messages_ and avoid
sharing state. The intention of this model is to allow for highly sharing state. The intention of this model is to allow for highly
distributed software that, through the adherence to *structured distributed software that, through the adherence to *structured
concurrency*, results in systems which fail in predicatable ways. concurrency*, results in systems which fail in predictable and
recoverable ways.
The first step to grok ``tractor`` is to get the basics of ``trio`` down. The first step to grok ``tractor`` is to get the basics of ``trio`` down.
A great place to start is the `trio docs`_ and this `blog post`_. A great place to start is the `trio docs`_ and this `blog post`_.
@ -54,13 +61,26 @@ No PyPi release yet!
Alluring Features Alluring Features
----------------- -----------------
- **It's just** ``trio``, but with SC applied to processes (aka "actors")
- Infinitely nesteable process trees - Infinitely nesteable process trees
- A built-in API for inter-process streaming - Built-in API for inter-process streaming
- A (first ever?) "native" multi-core debugger for Python using `pdb++`_ - A (first ever?) "native" multi-core debugger for Python using `pdb++`_
- (Soon to land) `asyncio` support allowing for "infected" actors where - (Soon to land) ``asyncio`` support allowing for "infected" actors where
`trio` drives the `asyncio` scheduler via the astounding "`guest mode`_" `trio` drives the `asyncio` scheduler via the astounding "`guest mode`_"
The example you're probably after...
------------------------------------
It seems the initial query from most new users is "how do I make a worker
pool thing?".
``tractor`` is built to handle any SC process tree you can
imagine; the "worker pool" pattern is a trivial special case:
# TODO: workerpool example
Feel like saying hi? Feel like saying hi?
-------------------- --------------------
This project is very much coupled to the ongoing development of This project is very much coupled to the ongoing development of