partd

Appendable key-value storage

partd Permissive license BSD DORMANT ★ 107 v1.4.2 released 2024-05-06

Install

partd on PyPI

pip

pip install partd

uv

uv add partd

poetry

poetry add partd

Package facts

License	BSD (permissive)
Python support	supports the current Python release (>=3.9)
Install friction	low — pure-Python wheel
Runtime dependencies	2 — locket, toolz
Maintenance	dormant — 829 days since the last release
Last repo commit	2024-07-15
First released	2015-05-08
Popularity	one of the top 1,000 most-downloaded packages on PyPI (30-day window, as of 2026-08-13)
Known vulnerabilities	none known (OSV.dev, checked 2026-08-13)

Evidence: partd-1.4.2-py3-none-any.whl

Programming Language :: Python :: 3Programming Language :: Python :: 3.10Programming Language :: Python :: 3.11Programming Language :: Python :: 3.12Programming Language :: Python :: 3.9

About partd

from the package's own PyPI description — quoted content, verbatim

PartD

|Build Status| |Version Status|

Key-value byte store with appendable values

Partd stores key-value pairs.
Values are raw bytes.
We append on old values.

Partd excels at shuffling operations.

Operations

PartD has two main operations, append and get.

Example

Create a Partd backed by a directory::

&gt;&gt;&gt; import partd
&gt;&gt;&gt; p = partd.File('/path/to/new/dataset/')

Append key-byte pairs to dataset::

&gt;&gt;&gt; p.append({'x': b'Hello ', 'y': b'123'})
&gt;&gt;&gt; p.append({'x': b'world!', 'y': b'456'})

Get bytes associated to keys::

&gt;&gt;&gt; p.get('x')         # One key
b'Hello world!'

&gt;&gt;&gt; p.get(['y', 'x'])  # List of keys
[b'123456', b'Hello world!']

Destroy partd dataset::
```
&gt;&gt;&gt; p.drop()
```

That's it.

Implementations

We can back a partd by an in-memory dictionary::

&gt;&gt;&gt; p = Dict()

For larger amounts of data or to share data between processes we back a partd by a directory of files. This uses file-based locks for consistency.::

&gt;&gt;&gt; p = File('/path/to/dataset/')

However this can fail for many small writes. In these cases you may...

Read as markdown · JSON record · Source repository · Homepage

AI interpretation — verify before relying

AI-generated interpretation of the package facts above; every digit, version, license, or vulnerability id it cites is grounded in the facts already shown on this page

Partd is a key-value byte store that appends values to keys and supports multiple storage backends (in-memory, file-based, buffered, or remote server). It excels at shuffling operations and can be composed with compression and encoding layers for transparent serialization.

Partd has low install friction with only two runtime dependencies (locket and toolz) and a pure-Python wheel distribution. However, the package is dormant—last release was 2024-05-06 and no commits in 829 days—so maintenance is minimal and bug fixes or feature updates are unlikely.

Partd is licensed under BSD (permissive), which allows commercial and private use with minimal restrictions, making it safe for most projects from a licensing standpoint.

Usage

import partd

# Create a file-backed store
p = partd.File('/tmp/partd_data')

# Append key-byte pairs
p.append({'x': b'Hello ', 'y': b'123'})
p.append({'x': b'world!', 'y': b'456'})

# Retrieve concatenated bytes
result = p.get('x')  # b'Hello world!'
p.drop()

Requires Python ≥3.9; file-backed stores need write access to the specified directory path.

Verdict: Partd is a lightweight, permissively licensed tool for append-only key-value storage with flexible backends and composition options. Its low install friction and lack of known vulnerabilities make it technically sound, but the dormant maintenance status (no activity in 829 days) means it is unlikely to receive updates for new Python versions or emerging issues. Suitable for stable, self-contained use cases but risky for projects requiring ongoing support.

Needs verification

Whether the file-locking mechanism used by File backend remains reliable on modern filesystems and concurrent workloads
Real-world performance characteristics and memory overhead when composing multiple layers (e.g., Pickle + Snappy + Buffer + File)
Compatibility with Python 3.13+ given the dormant maintenance status

key-value byte store appenddistributed key-value storageshuffling operations datafile-based key-value cachecomposable storage backendsin-memory to disk buffercompression-aware data store