darksidecat / aiopriman

library for managing asyncio synchronization primitives

Aiopriman

Attention! the project is at the initial stage of development, so there may be changes that break backward compatibility

This package provides the ability to manage asyncio synchronization primitives. Allows you to create storages of primitives, provides convenient means for accessing them using context managers, factories, creation and access to synchronization primitives by key.

Designed to solve the problem of managing dynamically created synchronization primitives for different resources.

Primitives are stored in memory only when needed.

Install

pip install aiopriman

Usage Examples

Working with a specific type of Manager, storage data must be specified as a parameter

import asyncio
import logging

from aiopriman.manager import LockManager, SemaphoreManager
from aiopriman.storage import StorageData


async def run_lock(storage, name):
    logging.debug(f"START Lock {name}")
    async with LockManager(storage_data=storage, key="test") as lock:
        logging.debug(f"HERE LOCKED {name}: {lock}")
        await asyncio.sleep(3)


async def run_sem(storage, name):
    logging.debug(f"START Sem {name}")
    async with SemaphoreManager(storage_data=storage,  key="test", value=2) as sem:
        logging.debug(f"HERE SEM LOCKED {name}: {sem}")
        await asyncio.sleep(3)


async def main_run(*args):
    await asyncio.gather(*args)


if __name__ == '__main__':
    logging.basicConfig(
        level=logging.DEBUG,
        format='%(levelname)s:%(name)s:(%(filename)s).%(funcName)s(%(lineno)d):%(message)s'
    )

    tasks = []
    storage_data = StorageData()
    for i in range(1, 10):
        tasks.append(run_lock(storage_data, i))
        tasks.append(run_sem(storage_data, i))

    asyncio.run(
        main_run(
           *tasks
        )
    )

aiopriman's Issues

Standard asyncio Synchronization Primitives

• Lock
• Event
• Condition
• Semaphore
• BoundedSemaphore

Semaphore can be released more times than acquired

release()
Release a semaphore, incrementing the internal counter by one. Can wake up a task waiting to acquire the semaphore.

Unlike BoundedSemaphore, Semaphore allows making more release() calls than acquire() calls.

https://docs.python.org/3/library/asyncio-sync.html#asyncio.Semaphore.release

Fixed. Semaphore is removed from storage too early. Find better solution

There are cases when a semaphore is removed from storage too early

I add tests for these cases, but need investigation for finding solution to prevent this

Add decorator for locking functions