fifolock
A flexible low-level tool to make synchronisation primitives in asyncio Python
Decision gist · record as of 2026-08-14
No, unless you have an existing codebase already using it. The package is abandoned (last release 2019-05-02, no commits since), and asyncio now includes built-in primitives that cover most common use cases. If you need custom lock semantics, consider maintaining a fork or using a maintained alternative.AI-flagged interpretation of the facts on this page — verify before relying
Before you install
- Requires Python 3.5 or later (requires_python: >=3.5)
- Installation is frictionless—a pure Python wheel with no runtime dependencies.
- However, the project is abandoned; the last commit was 2019-05-02 and no releases have occurred since.
License · maintenance · safety
permissive license (permissive) — Licensed under MIT (permissive), so you can use it freely in commercial and open-source projects with minimal restrictions.
last release 2019-05-02 (2661 days) · last repo commit 2019-05-02 · 54 stars
0 known vulnerabilities (OSV.dev, 2026-08-14) · 236,901 downloads/mo, #8,971 on PyPI
Alternatives
Verify before relying
pip install fifolock
import asyncio
from fifolock import FifoLock
class Mutex(asyncio.Future):
@staticmethod
def is_compatible(holds):
return not holds[Mutex]
lock = FifoLock()
async def access():
async with lock(Mutex):
pass- Whether the package works correctly with Python versions released after 2019.
- Whether there are known issues or edge cases in FIFO lock ordering under high concurrency.
- Whether alternative asyncio lock libraries now provide similar functionality.
What it is and what it does
Fifolock is a minimal asyncio synchronization tool that lets you build custom lock types—mutexes, read/write locks, semaphores—by defining compatibility rules between lock modes. Each mode is a subclass of asyncio.Future, and the lock grants access strictly in the order requests arrive, never allowing reentrancy.
You create a FifoLock instance, define lock-mode classes with an is_compatible method that checks whether a new request can proceed given the currently held locks, then use the lock as an async context manager. The package includes recipes for common patterns like exclusive locks, shared/exclusive (read/write) locks, and bounded semaphores. It requires Python 3.5 or later and has no external dependencies.
Use it for
- Building a read/write lock where multiple readers can access a resource concurrently but writers get exclusive access.
- Implementing a bounded semaphore that allows concurrent operations in strict request order.
- Creating custom synchronization logic where lock compatibility depends on which modes are currently held.
- Ensuring fair, deterministic lock acquisition order in asyncio applications where FIFO fairness matters.
Worth the install?
AI-flagged interpretation of the facts on this page. Verify before relying on it.
No, unless you have an existing codebase already using it.
The package is abandoned (last release 2019-05-02, no commits since), and asyncio now includes built-in primitives that cover most common use cases. If you need custom lock semantics, consider maintaining a fork or using a maintained alternative.
Install
fifolock on PyPI
Before you install
Installation is frictionless—a pure Python wheel with no runtime dependencies. However, the project is abandoned; the last commit was 2019-05-02 and no releases have occurred since.
Requires Python 3.5 or later (requires_python: >=3.5)
License in practice
Licensed under MIT (permissive), so you can use it freely in commercial and open-source projects with minimal restrictions.
Quickstart
pip install fifolock
import asyncio
from fifolock import FifoLock
class Mutex(asyncio.Future):
@staticmethod
def is_compatible(holds):
return not holds[Mutex]
lock = FifoLock()
async def access():
async with lock(Mutex):
passVerify before relying
- Whether the package works correctly with Python versions released after 2019.
- Whether there are known issues or edge cases in FIFO lock ordering under high concurrency.
- Whether alternative asyncio lock libraries now provide similar functionality.
Package facts
| License | permissive license permissive |
| Python support | Supports the current Python release >=3.5 |
| Install friction | Low. Pure-Python wheel |
| Runtime dependencies | None |
| Maintenance | Abandoned 2,661 days since the last release |
| Last repo commit | |
| First released | |
| Downloads | 236,901 / month, #8,971 on PyPI 30-day window, as of 2026-08-14 |
| Known vulnerabilities | None known OSV.dev, checked 2026-08-14 |
| Classifiers | Framework :: AsyncIOLicense :: OSI Approved :: MIT LicenseOperating System :: OS IndependentProgramming Language :: Python :: 3 |
Evidence: fifolock-0.0.20-py3-none-any.whl
Tags
Let your AI agent find packages like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 14,416 PyPI packages by what they can do, searchable in plain language.
wish › “asyncio synchronization primitives”
- fifolockFifolock provides a low-level building block for creating custom…
- aiologicaiologic provides thread-aware and async-aware locking and…
- aioprocessingProvides asyncio-compatible wrappers around multiprocessing objects…
Give your agent the search over MCP, or paste the wish link into any chat.
More Software Development packages
Provides backported and experimental type hints for Python 3.9+, allowing use of newer typing features on older Python versions and enabling early experimentation with type system PEPs before they enter the standard library.
NumPy provides an N-dimensional array object and a comprehensive suite of mathematical, linear algebra, Fourier transform, and random number functions for scientific computing in Python.
FastAPI is a Python web framework for building REST APIs using type hints, with automatic request validation, serialization, and interactive API documentation.
Provides a way to document function parameters, class attributes, return types, and variables inline using Python's `Annotated` type hint syntax instead of traditional docstrings.
Typer builds command-line applications from Python functions using type hints, automatically generating help text, argument parsing, and shell completion.
Install it if you are building CLIs in Python.
Distlib provides low-level packaging utilities for building, distributing, and managing Python software—including metadata handling, version specifiers, wheel support, script installation, and dependency resolution.
See also aiorwlock · filelock · fasteners · aiologic · locket · atomos · portalocker · posix-ipc · readerwriterlock · sysv-ipc