# NOTE: enable printing timestamp for additional data
import sys
import futurist
import eventlet
def delayed_func():


    print("started")


    eventlet.sleep(3)


    print("done")
#print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
e = futurist.SynchronousExecutor()
fut = e.submit(delayed_func)
eventlet.sleep(1)
print("Hello")
eventlet.sleep(1)
e.shutdown()
#print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))

started
done
Hello

# NOTE: enable printing timestamp for additional data
import sys
import futurist
import eventlet
def delayed_func():


    print("started")


    eventlet.sleep(3)


    print("done")
#print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
e = futurist.GreenThreadPoolExecutor()
fut = e.submit(delayed_func)
eventlet.sleep(1)
print("Hello")
eventlet.sleep(1)
e.shutdown()
#print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))

started
Hello
done

import time
import futurist
def delayed_func():


    time.sleep(0.1)


    return "hello"
e = futurist.ThreadPoolExecutor()
fut = e.submit(delayed_func)
print(fut.result())
e.shutdown()

hello

import time
import futurist
def delayed_func():


    time.sleep(0.1)


    return "hello"
e = futurist.ProcessPoolExecutor()
fut = e.submit(delayed_func)
print(fut.result())
e.shutdown()

hello

import futurist
from futurist import periodics
import time
import threading
@periodics.periodic(1)
def every_one(started_at):


    print("1: %s" % (time.time() - started_at))
@periodics.periodic(2)
def every_two(started_at):


    print("2: %s" % (time.time() - started_at))
@periodics.periodic(4)
def every_four(started_at):


    print("4: %s" % (time.time() - started_at))
@periodics.periodic(6)
def every_six(started_at):


    print("6: %s" % (time.time() - started_at))
started_at = time.time()
callables = [


    # The function to run + any automatically provided positional and


    # keyword arguments to provide to it everytime it is activated.


    (every_one, (started_at,), {}),


    (every_two, (started_at,), {}),


    (every_four, (started_at,), {}),


    (every_six, (started_at,), {}),
]
w = periodics.PeriodicWorker(callables)
# In this example we will run the periodic functions using a thread, it
# is also possible to just call the w.start() method directly if you do
# not mind blocking up the current program.
t = threading.Thread(target=w.start)
t.daemon = True
t.start()
# Run for 10 seconds and then stop.
while (time.time() - started_at) <= 10:


    time.sleep(0.1)
w.stop()
w.wait()
t.join()

import futurist
from futurist import periodics
import time
import threading
@periodics.periodic(1)
def every_one(started_at):


    print("1: %s" % (time.time() - started_at))


    time.sleep(0.5)
@periodics.periodic(2)
def every_two(started_at):


    print("2: %s" % (time.time() - started_at))


    time.sleep(1)
@periodics.periodic(4)
def every_four(started_at):


    print("4: %s" % (time.time() - started_at))


    time.sleep(2)
@periodics.periodic(6)
def every_six(started_at):


    print("6: %s" % (time.time() - started_at))


    time.sleep(3)
started_at = time.time()
callables = [


    # The function to run + any automatically provided positional and


    # keyword arguments to provide to it everytime it is activated.


    (every_one, (started_at,), {}),


    (every_two, (started_at,), {}),


    (every_four, (started_at,), {}),


    (every_six, (started_at,), {}),
]
# To avoid getting blocked up by slow periodic functions we can also
# provide a executor pool to make sure that slow functions only block
# up a thread (or green thread), instead of blocking other periodic
# functions that need to be scheduled to run.
executor_factory = lambda: futurist.ThreadPoolExecutor(max_workers=2)
w = periodics.PeriodicWorker(callables, executor_factory=executor_factory)
# In this example we will run the periodic functions using a thread, it
# is also possible to just call the w.start() method directly if you do
# not mind blocking up the current program.
t = threading.Thread(target=w.start)
t.daemon = True
t.start()
# Run for 10 seconds and then stop.
while (time.time() - started_at) <= 10:


    time.sleep(0.1)
w.stop()
w.wait()
t.join()

import futurist
from futurist import periodics
import time
import threading
@periodics.periodic(1)
def run_only_once(started_at):


    print("1: %s" % (time.time() - started_at))


    raise periodics.NeverAgain("No need to run again after first run !!")
@periodics.periodic(1)
def keep_running(started_at):


    print("2: %s" % (time.time() - started_at))
started_at = time.time()
callables = [


    # The function to run + any automatically provided positional and


    # keyword arguments to provide to it everytime it is activated.


    (run_only_once, (started_at,), {}),


    (keep_running, (started_at,), {}),
]
w = periodics.PeriodicWorker(callables)
# In this example we will run the periodic functions using a thread, it
# is also possible to just call the w.start() method directly if you do
# not mind blocking up the current program.
t = threading.Thread(target=w.start)
t.daemon = True
t.start()
# Run for 10 seconds and then stop.
while (time.time() - started_at) <= 10:


    time.sleep(0.1)
w.stop()
w.wait()
t.join()

import futurist
from futurist import periodics
import time
import threading
@periodics.periodic(1)
def run_only_once(started_at):


    print("1: %s" % (time.time() - started_at))


    raise periodics.NeverAgain("No need to run again after first run !!")
@periodics.periodic(2)
def run_for_some_time(started_at):


    print("2: %s" % (time.time() - started_at))


    if (time.time() - started_at) > 5:


        raise periodics.NeverAgain("No need to run again !!")
started_at = time.time()
callables = [


    # The function to run + any automatically provided positional and


    # keyword arguments to provide to it everytime it is activated.


    (run_only_once, (started_at,), {}),


    (run_for_some_time, (started_at,), {}),
]
w = periodics.PeriodicWorker(callables)
# In this example we will run the periodic functions using a thread, it
# is also possible to just call the w.start() method directly if you do
# not mind blocking up the current program.
t = threading.Thread(target=w.start, kwargs={'auto_stop_when_empty': True})
t.daemon = True
t.start()
# Run for 10 seconds and then check to find out that it had
# already stooped.
while (time.time() - started_at) <= 10:


    time.sleep(0.1)
print(w.pformat())
t.join()

__init__(max_workers=1000, check_and_reject=None)

Initializes a green thread pool executor.

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.

property statistics

ExecutorStatistics about the executors executions.

submit(fn, *args, **kwargs)

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

__init__(max_workers=None)

Initializes a new ProcessPoolExecutor instance.

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).

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

Synchronous executor constructor.

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.

property statistics

ExecutorStatistics about the executors executions.

submit(fn, *args, **kwargs)

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

__init__(max_workers=None, check_and_reject=None)

Initializes a thread pool executor.

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.

property statistics

ExecutorStatistics about the executors executions.

submit(fn, *args, **kwargs)

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

add_done_callback(fn)

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

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.

result(timeout=None)

Return the result of the call that the future represents.

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.

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.

__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).

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).

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).

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

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.

property average_runtime

The average runtime of all submissions executed.

property cancelled

How many submissions were cancelled before executing.

property executed

How many submissions were executed (failed or not).

property failures

How many submissions ended up raising exceptions.

property runtime

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