# API Reference

## Executors

class futurist.GreenThreadPoolExecutor(max_workers=1000, check_and_reject=None)

  Executor that uses a green thread pool to execute calls asynchronously.

  See: https://docs.python.org/dev/library/concurrent.futures.html and http://eventlet.net/doc/modules/greenpool.html for information on how this works.

  It gathers statistics about the submissions executed for post-analysis…

  __init__(max_workers=1000, check_and_reject=None)

    Initializes a green thread pool executor.

    Parameters:

      - max_workers (int) – maximum number of workers that can be simulatenously active at the same time, further submitted work will be queued up when this limit is reached.

      - check_and_reject (callback) – a callback function that will be provided two position arguments, the first argument will be this executor instance, and the second will be the number of currently queued work items in this executors backlog; the callback should raise a `RejectedSubmission` exception if it wants to have this submission rejected.

  property alive

    Accessor to determine if the executor is alive/active.

  shutdown(wait=True)

    Clean-up the resources associated with the Executor.

    It is safe to call this method several times. Otherwise, no other methods can be called after this one.

    Parameters:

      - wait – If True then shutdown will not return until all running futures have finished executing and the resources used by the executor have been reclaimed.

      - cancel_futures – If True then shutdown will cancel all pending futures. Futures that are completed or running will not be cancelled.

  property statistics

    `ExecutorStatistics` about the executors executions.

  submit(fn, *args, **kwargs)

    Submit some work to be executed (and gather statistics).

    Parameters:

      - args (list) – non-keyworded arguments

      - kwargs (dictionary) – key-value arguments

class futurist.ProcessPoolExecutor(max_workers=None)

  Executor that uses a process pool to execute calls asynchronously.

  It gathers statistics about the submissions executed for post-analysis…

  See: https://docs.python.org/dev/library/concurrent.futures.html

  __init__(max_workers=None)

    Initializes a new ProcessPoolExecutor instance.

    Parameters:

      - max_workers – The maximum number of processes that can be used to execute the given calls. If None or not given then as many worker processes will be created as the machine has processors.

      - mp_context – A multiprocessing context to launch the workers created using the multiprocessing.get_context(‘start method’) API. This object should provide SimpleQueue, Queue and Process.

      - initializer – A callable used to initialize worker processes.

      - initargs – A tuple of arguments to pass to the initializer.

      - max_tasks_per_child – The maximum number of tasks a worker process can complete before it will exit and be replaced with a fresh worker process. The default of None means worker process will live as long as the executor. Requires a non-‘fork’ mp_context start method. When given, we default to using ‘spawn’ if no mp_context is supplied.

  property alive

    Accessor to determine if the executor is alive/active.

  property statistics

    `ExecutorStatistics` about the executors executions.

  submit(fn, *args, **kwargs)

    Submit some work to be executed (and gather statistics).

class futurist.SynchronousExecutor(green=False, run_work_func=<function SynchronousExecutor.<lambda>>)

  Executor that uses the caller to execute calls synchronously.

  This provides an interface to a caller that looks like an executor but will execute the calls inside the caller thread instead of executing it in a external process/thread for when this type of functionality is useful to provide…

  It gathers statistics about the submissions executed for post-analysis…

  __init__(green=False, run_work_func=<function SynchronousExecutor.<lambda>>)

    Synchronous executor constructor.

    Parameters:

      - green (bool) – when enabled this forces the usage of greened lock classes and green futures (so that the internals of this object operate correctly under eventlet)

      - run_work_func – callable that takes a single work item and runs it (typically in a blocking manner)

      - run_work_func – callable

  property alive

    Accessor to determine if the executor is alive/active.

  restart()

    Restarts this executor (iff previously shutoff/shutdown).

    NOTE(harlowja): clears any previously gathered statistics.

  shutdown(wait=True)

    Clean-up the resources associated with the Executor.

    It is safe to call this method several times. Otherwise, no other methods can be called after this one.

    Parameters:

      - wait – If True then shutdown will not return until all running futures have finished executing and the resources used by the executor have been reclaimed.

      - cancel_futures – If True then shutdown will cancel all pending futures. Futures that are completed or running will not be cancelled.

  property statistics

    `ExecutorStatistics` about the executors executions.

  submit(fn, *args, **kwargs)

    Submit some work to be executed (and gather statistics).

class futurist.ThreadPoolExecutor(max_workers=None, check_and_reject=None)

  Executor that uses a thread pool to execute calls asynchronously.

  It gathers statistics about the submissions executed for post-analysis…

  Note that this executor never shrinks its thread pool, which will cause the pool to eventually reach its maximum capacity defined by max_workers. Check `DynamicThreadPoolExecutor` for an alternative.

  See: https://docs.python.org/dev/library/concurrent.futures.html

  __init__(max_workers=None, check_and_reject=None)

    Initializes a thread pool executor.

    Parameters:

      - max_workers (int) – maximum number of workers that can be simultaneously active at the same time, further submitted work will be queued up when this limit is reached.

      - check_and_reject (callback) – a callback function that will be provided two position arguments, the first argument will be this executor instance, and the second will be the number of currently queued work items in this executors backlog; the callback should raise a `RejectedSubmission` exception if it wants to have this submission rejected.

  property alive

    Accessor to determine if the executor is alive/active.

  get_num_idle_workers()

    Get the number of currently idle threads.

    A thread is idle if it’s waiting for new tasks from the queue.

    This method is required to obtain the shutdown lock it provides an accurate count.

  property num_workers

    The current number of worker threads.

  property queue_size

    The current size of the queue.

    This value represents the number of tasks that are waiting for a free worker thread.

  shutdown(wait=True)

    Clean-up the resources associated with the Executor.

    It is safe to call this method several times. Otherwise, no other methods can be called after this one.

    Parameters:

      - wait – If True then shutdown will not return until all running futures have finished executing and the resources used by the executor have been reclaimed.

      - cancel_futures – If True then shutdown will cancel all pending futures. Futures that are completed or running will not be cancelled.

  property statistics

    `ExecutorStatistics` about the executors executions.

  submit(fn, *args, **kwargs)

    Submit some work to be executed (and gather statistics).

class futurist.DynamicThreadPoolExecutor(max_workers=None, check_and_reject=None, min_workers=1, grow_threshold=0.8, shrink_threshold=0.4)

  Executor that creates or removes threads on demand.

  As new work is scheduled on the executor, it will try to keep the proportion of busy threads within the provided range (between 40% and 80% by default). A busy thread is a thread that is not waiting on the task queue.

  Each time a task is submitted, the executor makes a decision whether to grow or shrink the pool. It takes the proportion of the number of busy threads to the total number of threads and compares it to shrink_threshold and grow_threshold.

  Initially, the pool is empty, so submitting a task always result in one new thread. Since min_workers must be greater than zero, at least one thread will always be available after this point.

  Once the proportion of busy threads reaches grow_threshold (e.g. 4 out of 5 with the default grow_threshold of 0.8), a new thread is created when a task is submitted. If on submitting a task a proportion of busy threads is below shrink_threshold (e.g. only 2 out of 5), one idle thread is stopped.

  The values of grow_threshold and shrink_threshold are different to prevent the number of threads from oscilating on reaching grow_threshold.

  If threads are not created often in your application, the number of idle threads may stay high for a long time. To avoid it, you can call `maintain()` periodically to keep the number of threads within the thresholds.

  __init__(max_workers=None, check_and_reject=None, min_workers=1, grow_threshold=0.8, shrink_threshold=0.4)

    Initializes a thread pool executor.

    Parameters:

      - max_workers (int) – maximum number of workers that can be simultaneously active at the same time, further submitted work will be queued up when this limit is reached.

      - check_and_reject (callback) – a callback function that will be provided two position arguments, the first argument will be this executor instance, and the second will be the number of currently queued work items in this executors backlog; the callback should raise a `RejectedSubmission` exception if it wants to have this submission rejected.

      - min_workers – the minimum number of workers that can be reached when shrinking the pool. Note that the pool always starts at zero workers and will be smaller than min_workers until enough workers are created. At least one thread is required.

      - grow_threshold (float) – minimum proportion of busy threads to total threads for the pool to grow.

      - shrink_threshold (float) – maximum proportion of busy threads to total threads for the pool to shrink.

  maintain()

    Keep the number of threads within the expected range.

    If too many idle threads are running, they are deleted. Additionally, deleted workers are joined to free up resources.

  shutdown(wait=True)

    Clean-up the resources associated with the Executor.

    It is safe to call this method several times. Otherwise, no other methods can be called after this one.

    Parameters:

      - wait – If True then shutdown will not return until all running futures have finished executing and the resources used by the executor have been reclaimed.

      - cancel_futures – If True then shutdown will cancel all pending futures. Futures that are completed or running will not be cancelled.

## Futures

class futurist.Future

  Represents the result of an asynchronous computation.

  add_done_callback(fn)

    Attaches a callable that will be called when the future finishes.

    Parameters:

      fn – A callable that will be called with this future as its only argument when the future completes or is cancelled. The callable will always be called by a thread in the same process in which it was added. If the future has already completed or been cancelled then the callable will be called immediately. These callables are called in the order that they were added.

  cancel()

    Cancel the future if possible.

    Returns True if the future was cancelled, False otherwise. A future cannot be cancelled if it is running or has already completed.

  cancelled()

    Return True if the future was cancelled.

  done()

    Return True if the future was cancelled or finished executing.

  exception(timeout=None)

    Return the exception raised by the call that the future represents.

    Parameters:

      timeout – The number of seconds to wait for the exception if the future isn’t done. If None, then there is no limit on the wait time.

    Returns:

      The exception raised by the call that the future represents or None if the call completed without raising.

    Raises:

      - CancelledError – If the future was cancelled.

      - TimeoutError – If the future didn’t finish executing before the given timeout.

  result(timeout=None)

    Return the result of the call that the future represents.

    Parameters:

      timeout – The number of seconds to wait for the result if the future isn’t done. If None, then there is no limit on the wait time.

    Returns:

      The result of the call that the future represents.

    Raises:

      - CancelledError – If the future was cancelled.

      - TimeoutError – If the future didn’t finish executing before the given timeout.

      - Exception – If the call raised then that exception will be raised.

  running()

    Return True if the future is currently executing.

  set_exception(exception)

    Sets the result of the future as being the given exception.

    Should only be used by Executor implementations and unit tests.

  set_result(result)

    Sets the return value of work associated with the future.

    Should only be used by Executor implementations and unit tests.

  set_running_or_notify_cancel()

    Mark the future as running or process any cancel notifications.

    Should only be used by Executor implementations and unit tests.

    If the future has been cancelled (cancel() was called and returned True) then any threads waiting on the future completing (though calls to as_completed() or wait()) are notified and False is returned.

    If the future was not cancelled then it is put in the running state (future calls to running() will return True) and True is returned.

    This method should be called by Executor implementations before executing the work associated with this future. If this method returns False then the work should not be executed.

    Returns:

      False if the Future was cancelled, True otherwise.

    Raises:

      RuntimeError – if this method was already called or if set_result() or set_exception() was called.

class futurist.GreenFuture

  Represents the result of an asynchronous computation.

## Periodics

class futurist.periodics.PeriodicWorker(callables, log=None, executor_factory=None, cond_cls=<class 'threading.Condition'>, event_cls=<class 'threading.Event'>, schedule_strategy='last_started', now_func=<built-in function monotonic>, on_failure=None)

  Calls a collection of callables periodically (sleeping as needed…).

  NOTE(harlowja): typically the `start()` method is executed in a background thread so that the periodic callables are executed in the background/asynchronously (using the defined periods to determine when each is called).

  BUILT_IN_STRATEGIES = {'aligned_last_finished': (<function _aligned_last_finished_strategy>, <function _now_plus_periodicity>), 'aligned_last_finished_jitter': (<function _aligned_last_finished_strategy>, <function _now_plus_periodicity>), 'last_finished': (<function _last_finished_strategy>, <function _now_plus_periodicity>), 'last_finished_jitter': (<function _last_finished_strategy>, <function _now_plus_periodicity>), 'last_started': (<function _last_started_strategy>, <function _now_plus_periodicity>), 'last_started_jitter': (<function _last_started_strategy>, <function _now_plus_periodicity>)}

    Built in scheduling strategies (used to determine when next to run a periodic callable).

    The first element is the strategy to use after the initial start and the second element is the strategy to use for the initial start.

    These are made somewhat pluggable so that we can easily add-on different types later (perhaps one that uses a cron-style syntax for example).

  DEFAULT_JITTER = Fraction(1, 20)

    Default jitter percentage the built-in strategies (that have jitter support) will use.

  MAX_LOOP_IDLE = 30

    Max amount of time to wait when running (forces a wakeup when elapsed).

  __init__(callables, log=None, executor_factory=None, cond_cls=<class 'threading.Condition'>, event_cls=<class 'threading.Event'>, schedule_strategy='last_started', now_func=<built-in function monotonic>, on_failure=None)

    Creates a new worker using the given periodic callables.

    Parameters:

      - callables (iterable) – a iterable of tuple objects previously decorated with the `periodic()` decorator, each item in the iterable is expected to be in the format of `(cb, args, kwargs)` where `cb` is the decorated function and `args` and `kwargs` are any positional and keyword arguments to send into the callback when it is activated (both `args` and `kwargs` may be provided as none to avoid using them)

      - log (logger) – logger to use when creating a new worker (defaults to the module logger if none provided), it is currently only used to report callback failures (if they occur)

      - executor_factory (ExecutorFactory or any callable) – factory callable that can be used to generate executor objects that will be used to run the periodic callables (if none is provided one will be created that uses the `SynchronousExecutor` class)

      - cond_cls (callable) – callable object that can produce `threading.Condition` (or compatible/equivalent) objects

      - event_cls (callable) – callable object that can produce `threading.Event` (or compatible/equivalent) objects

      - schedule_strategy (string) – string to select one of the built-in strategies that can return the next time a callable should run

      - now_func (callable) – callable that can return the current time offset from some point (used in calculating elapsed times and next times to run); preferably this is monotonically increasing

      - on_failure (callable) – callable that will be called whenever a periodic function fails with an error, it will be provided four positional arguments and one keyword argument, the first positional argument being the callable that failed, the second being the type of activity under which it failed (`IMMEDIATE` or `PERIODIC`), the third being the spacing that the callable runs at and the fourth `exc_info` tuple of the failure. The keyword argument `traceback` will also be provided that may be be a string that caused the failure (this is required for executors which run out of process, as those can not currently transfer stack frames across process boundaries); if no callable is provided then a default failure logging function will be used instead (do note that any user provided callable should not raise exceptions on being called)

  __len__()

    How many callables/periodic work units are currently active.

  add(cb, *args, **kwargs)

    Adds a new periodic callback to the current worker.

    Returns a `Watcher` if added successfully or the value `None` if not (or raises a `ValueError` if the callback is not correctly formed and/or decorated).

    Parameters:

      cb (callable) – a callable object/method/function previously decorated with the `periodic()` decorator

  classmethod create(objects, exclude_hidden=True, log=None, executor_factory=None, cond_cls=<class 'threading.Condition'>, event_cls=<class 'threading.Event'>, schedule_strategy='last_started', now_func=<built-in function monotonic>, on_failure=None, args=(), kwargs={})

    Automatically creates a worker by analyzing object(s) methods.

    Only picks up methods that have been tagged/decorated with the `periodic()` decorator (does not match against private or protected methods unless explicitly requested to).

    Parameters:

      - objects (iterable) – the objects to introspect for decorated members

      - exclude_hidden (bool) – exclude hidden members (ones that start with an underscore)

      - log (logger) – logger to use when creating a new worker (defaults to the module logger if none provided), it is currently only used to report callback failures (if they occur)

      - executor_factory (ExecutorFactory or any callable) – factory callable that can be used to generate executor objects that will be used to run the periodic callables (if none is provided one will be created that uses the `SynchronousExecutor` class)

      - cond_cls (callable) – callable object that can produce `threading.Condition` (or compatible/equivalent) objects

      - event_cls (callable) – callable object that can produce `threading.Event` (or compatible/equivalent) objects

      - schedule_strategy (string) – string to select one of the built-in strategies that can return the next time a callable should run

      - now_func (callable) – callable that can return the current time offset from some point (used in calculating elapsed times and next times to run); preferably this is monotonically increasing

      - on_failure (callable) – callable that will be called whenever a periodic function fails with an error, it will be provided four positional arguments and one keyword argument, the first positional argument being the callable that failed, the second being the type of activity under which it failed (`IMMEDIATE` or `PERIODIC`), the third being the spacing that the callable runs at and the fourth `exc_info` tuple of the failure. The keyword argument `traceback` will also be provided that may be be a string that caused the failure (this is required for executors which run out of process, as those can not currently transfer stack frames across process boundaries); if no callable is provided then a default failure logging function will be used instead (do note that any user provided callable should not raise exceptions on being called)

      - args (tuple) – positional arguments to be passed to all callables

      - kwargs (dict) – keyword arguments to be passed to all callables

  iter_watchers()

    Iterator/generator over all the currently maintained watchers.

  reset()

    Resets the workers internal state.

  start(allow_empty=False, auto_stop_when_empty=False)

    Starts running (will not return until `stop()` is called).

    Parameters:

      - allow_empty (bool) – instead of running with no callbacks raise when this worker has no contained callables (this can be set to true and `add()` can be used to add new callables on demand), note that when enabled and no callbacks exist this will block and sleep (until either stopped or callbacks are added)

      - auto_stop_when_empty (bool) – when the provided periodic functions have all exited and this is false then the thread responsible for executing those methods will just spin/idle waiting for a new periodic function to be added; switching it to true will make this idling not happen (and instead when no more periodic work exists then the calling thread will just return).

  stop()

    Sets the tombstone (this stops any further executions).

  wait(timeout=None)

    Waits for the `start()` method to gracefully exit.

    An optional timeout can be provided, which will cause the method to return within the specified timeout. If the timeout is reached, the returned value will be False.

    Parameters:

      timeout (float/int) – Maximum number of seconds that the `wait()` method should block for

futurist.periodics.periodic(spacing, run_immediately=False, enabled=True)

  Tags a method/function as wanting/able to execute periodically.

  Parameters:

    - spacing (float/int) – how often to run the decorated function (required)

    - run_immediately (boolean) – option to specify whether to run immediately or wait until the spacing provided has elapsed before running for the first time

    - enabled (boolean) – whether the task is enabled to run

class futurist.periodics.Watcher(metrics, work)

  A read-only object representing a periodic callback’s activities.

  property average_elapsed

    Avg. amount of time the periodic callback has ran for.

    This may raise a `ZeroDivisionError` if there has been no runs.

  property average_elapsed_waiting

    Avg. amount of time the periodic callback has waited to run for.

    This may raise a `ZeroDivisionError` if there has been no runs.

  property elapsed

    Total amount of time the periodic callback has ran for.

  property elapsed_waiting

    Total amount of time the periodic callback has waited to run for.

  property failures

    How many times the periodic callback ran unsuccessfully.

  property requested_stop

    If the work unit being ran has requested to be stopped.

  property runs

    How many times the periodic callback has been ran.

  property successes

    How many times the periodic callback ran successfully.

  property work

    Read-only named work tuple this object watches.

## Miscellaneous

class futurist.ExecutorStatistics(failures=0, executed=0, runtime=0.0, cancelled=0)

  Holds immutable information about a executors executions.

  property average_runtime

    The average runtime of all submissions executed.

    Returns:

      average runtime of all submissions executed

    Return type:

      number

    Raises:

      ZeroDivisionError when no executions have occurred.

  property cancelled

    How many submissions were cancelled before executing.

    Returns:

      how many submissions were cancelled before executing

    Return type:

      number

  property executed

    How many submissions were executed (failed or not).

    Returns:

      how many submissions were executed

    Return type:

      number

  property failures

    How many submissions ended up raising exceptions.

    Returns:

      how many submissions ended up raising exceptions

    Return type:

      number

  property runtime

    Total runtime of all submissions executed (failed or not).

    Returns:

      total runtime of all submissions executed

    Return type:

      number

## Exceptions

class futurist.RejectedSubmission

  Exception raised when a submitted call is rejected (for some reason).

## Waiters

futurist.waiters.wait_for_any(fs, timeout=None)

  Wait for one (any) of the futures to complete.

  Works correctly with both green and non-green futures (but not both together, since this can’t be guaranteed to avoid dead-lock due to how the waiting implementations are different when green threads are being used).

  Returns pair (done futures, not done futures).

futurist.waiters.wait_for_all(fs, timeout=None)

  Wait for all of the futures to complete.

  Works correctly with both green and non-green futures (but not both together, since this can’t be guaranteed to avoid dead-lock due to how the waiting implementations are different when green threads are being used).

  Returns pair (done futures, not done futures).

class futurist.waiters.DoneAndNotDoneFutures(done, not_done)

  Named tuple returned from `wait_for*` calls.

this page last updated: 2026-03-26 12:00:55

Except where otherwise noted, this document is licensed under Creative Commons Attribution 3.0 License. See all OpenStack Legal Documents.

found an error? report a bug