kaiju-scheduler is a simple asynchronous tasks scheduler / executor for asyncio functions. It adds a bit of extra such as retries, timeouts, execution policies etc.

With pip and python 3.8+:

pip3 install kaiju-scheduler

See the user guide for more info.

Initialize a scheduler and schedule your procedure for periodic execution. Then start the scheduler.

from kaiju_scheduler import Scheduler

async def call_async_procedure(*args, **kws):
    ...

async def main():
    scheduler = Scheduler()
    scheduler.schedule_task(call_async_procedure, interval_s=10, args=(1, 2), kws={'value': True})
    await scheduler.start()
    ...
    await scheduler.stop()

Alternatively you can use the scheduler contextually.

async def main():
    async with Scheduler() as scheduler:
        scheduler.schedule_task(call_async_procedure, interval_s=10, args=(1, 2), kws={'value': True})

Scheduler.schedule_task returns a task object which you can enable / disable or supress the task execution in your code temporarily using task.suspend context. You can also access the previous call results from task.result attribute.

class Cache:

    def __init__(self, scheduler: Scheduler):
        self._scheduler = scheduler
        self._cache_task = self._scheduler.schedule_task(
            self.cache_all, interval_s=600, policy=scheduler.ExecPolicy.WAIT)

    async def cache_all(self):
        ...

    async def reconfigure_cache(self):
        async with self._cache_task.suspend():
            "Do something while the caching is suspended"

You can specify retries for common types of errors such as IOError or ConnectionError using retries parameter. The scheduler will try to retry the call on such type of error.

scheduler.schedule_task(call_async_procedure, interval_s=300, retries=3, retry_interval_s=1)

There are various policies considering task execution. See the reference for more info on that.

There's also a simple 'server' for handling asyncio tasks inside Python. It extends the standard loop functionality with retries, timeouts and impose some rate limit and prevent the loop from growing infinitely.

The server returns an asyncio.Task object which can be awaited independently. The idea is that any error is not raised but instead returned inside of the result. This allows for more convenient handling of errors while using this in streams, queues and server applications.

See the reference for more info on server functions.

from kaiju_scheduler import Server


async def call_something(arg1: int, arg2: int):
    return arg1 + arg2


async def main():
    async with Server() as server:
        task = await server.call(call_something, [1, 2])
        await task