pyutils.parallelize package
===========================

This package contains code related to parallelization including some
utilities (:file:`thread_utils.py`) and a frameworks for simple
parallelization (everything else).

Submodules
----------

pyutils.parallelize.deferred\_operand module
--------------------------------------------

.. automodule:: pyutils.parallelize.deferred_operand
   :members:
   :undoc-members:
   :exclude-members: __repr__,
                     and_,
                     bool,
                     delitem,
                     getitem,
                     invert,
                     is_,
                     is_not,
                     lshift,
                     matmul,
                     mod,
                     neg,
                     or_,
                     pos,
                     rshift,
                     setitem,
                     truth,
                     xor
   :show-inheritance:

pyutils.parallelize.executors module
------------------------------------

.. automodule:: pyutils.parallelize.executors
   :members:
   :undoc-members:
   :show-inheritance:

pyutils.parallelize.parallelize module
--------------------------------------

.. automodule:: pyutils.parallelize.parallelize
   :members:
   :undoc-members:
   :show-inheritance:

pyutils.parallelize.smart\_future module
----------------------------------------

Defines a SmartFuture class that is part of the parallelization
framework.  A SmartFuture is a kind of Future (i.e. a representation
of the result of asynchronous processing that may know its value or
not depending on whether the asynchronous operation has completed).
Whereas normal Python Futures must be waited on or resolved manually,
a SmartFuture automatically waits for its result to be known as soon
as it is utilized in an expression that demands its value.

Also contains some utilility code for waiting for one/many futures.

.. automodule:: pyutils.parallelize.smart_future
   :members:
   :undoc-members:
   :show-inheritance:

pyutils.parallelize.thread\_utils module
----------------------------------------

.. automodule:: pyutils.parallelize.thread_utils
   :members:
   :undoc-members:
   :show-inheritance:

Module contents
---------------

This module contains a framework for easy Python parallelization.  To
see an example of how it is used, look at examples/wordle/...

This module also contains some utilities that deal with parallelization.

.. automodule:: pyutils.parallelize
   :members:
   :undoc-members:
   :show-inheritance: