---
id: pylru
version: "1.3.1"
license: MIT
license_treatment: permissive
maintenance: active
---

# pylru — A least recently used (LRU) cache implementation

License: permissive · Maintenance: active · Downloads: 459.4K/mo

## What it is and what it does

Pylru is a pure-Python LRU cache implementation that maintains a fixed-size collection of key-value pairs, automatically evicting the least recently used item when capacity is reached. It provides a dictionary-like interface for direct caching, plus two wrapper classes—WriteThroughCacheManager and WriteBackCacheManager—that compose an LRU cache with any dict-like object (such as a remote store or database) to transparently cache reads and writes. Write-through updates the underlying store immediately; write-back defers store updates until eviction or explicit sync.

The package is written in pure Python with no external dependencies, making it lightweight and portable. All core operations (lookup, insert, delete) run in constant time. It supports optional callbacks on eviction, iteration over keys/values in LRU order, and resizing the cache at runtime. The cache is scan-resistant when using iteration methods, and both the cache and wrapper classes can be used as context managers.

Use it for:

- Cache expensive function results or API calls to reduce latency and improve response times
- Wrap a slow backend storage or database with write-through caching to speed up repeated reads
- Implement write-back caching for batch updates, deferring writes to the store until cache eviction
- Build a bounded in-memory cache for web application session data or computed results
- Use as a decorator or wrapper to memoize function outputs with a fixed memory footprint

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

Provides a pure-Python LRU (least recently used) cache with constant-time lookup, insert, and delete operations, plus wrapper classes for caching access to dict-like objects and functions.

Yes. Pylru is a stable, dependency-free LRU cache with a clean API and no known vulnerabilities. Install it if you need a simple, pure-Python caching layer with constant-time operations and optional write-through or write-back semantics for dict-like backends. Skip it if you only need basic function memoization (functools.lru_cache is built-in) or if you require thread-safety guarantees.

## Install

pip install pylru
uv add pylru
poetry add pylru

## Installing pylru

Before you install: No runtime dependencies and low install friction. Marked as active maintenance with a recent release in 2026-04. Requires Python 3.3 or later.

License in practice: MIT license permits use, modification, and distribution with minimal restrictions, making it suitable for both open-source and commercial projects.

Quickstart:

import pylru

# Create a cache with size 100
cache = pylru.lrucache(100)

# Use it like a dict
cache['key'] = 'value'
print(cache['key'])  # Lookup moves key to most-recently-used

# Or wrap a dict-like object with write-through caching
store = {}  # Any dict-like object
cached = pylru.lruwrap(store, 100)
cached['key'] = 'value'

Verify before relying:

- Performance characteristics compared to functools.lru_cache or other caching libraries in typical workloads
- Thread-safety guarantees or limitations when used in concurrent environments

## Package facts

- License: MIT (permissive)
- Python support: supports_current
- Install friction: low
- Maintenance: active
- Downloads: 459.4K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

lru cache python, least recently used cache, caching decorator, dict-like cache, function memoization, write-through cache, write-back cache, caching, performance, data-structures

[View on SkillFed](https://skillfed.io/packages/pylru) · [View on PyPI](https://pypi.org/project/pylru/)