---
id: persisting-theory
version: "1.0"
license: BSD
license_treatment: permissive
maintenance: abandoned
---

# persisting-theory — Registries that can autodiscover values accross your project apps

License: permissive · Maintenance: abandoned · Downloads: 165.7K/mo

## What it is and what it does

Persisting-theory is a lightweight registry utility that automates the discovery and registration of data (functions, classes, or arbitrary values) across multiple application packages. It works by scanning designated modules in your app packages for registered items and making them accessible through a central registry object that behaves like an OrderedDict.

The package is designed for plugin-based architectures where different components need to register themselves without explicit imports. You define a Registry subclass, specify which module names to scan via the `look_into` attribute, decorate items with `@registry.register`, then call `autodiscover()` with your app names to populate the registry. It also supports validation and data transformation through overridable methods, and a meta-registry for managing multiple registries.

Use it for:

- Building plugin systems where components in separate packages self-register without central coordination.
- Creating callback registries so different app modules can register handlers that others can discover and invoke.
- Implementing a configuration or factory pattern where different packages register their implementations for later lookup.
- Automating discovery of test fixtures, validators, or middleware across a modular application.
- Managing multiple independent registries (e.g., one for handlers, one for validators) through a meta-registry.

## Worth the install?

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

Persisting-theory provides a registry system for automatically discovering and accessing registered data across pluggable application components, similar to Django's autodiscovery pattern.

No. While the package is lightweight and has no dependencies, it is abandoned (last release 2022-05-06, no maintenance for over 1561 days). For new projects, consider actively maintained alternatives. For existing code already using it, it may continue to work, but you will receive no updates for bugs or Python version incompatibilities.

## Install

pip install persisting-theory
uv add persisting-theory
poetry add persisting-theory

## Installing persisting-theory

Before you install: Installation is straightforward with no runtime dependencies. However, the package is abandoned—last release was 2022-05-06, over 1561 days ago—so it will not receive bug fixes or maintenance.

License in practice: Licensed under BSD (permissive), which allows commercial and private use with minimal restrictions, though you should include the license text in distributions.

Quickstart:

pip install persisting-theory

from persisting_theory import Registry

class MyRegistry(Registry):
    look_into = "my_module"

my_registry = MyRegistry()

@my_registry.register
def my_function():
    pass

my_registry.autodiscover(['app1', 'app2'])
for item in my_registry.values():
    item()

Verify before relying:

- Whether the package works reliably on Python versions beyond 3.9, given its abandoned status and lack of recent testing.
- Real-world performance and stability when used in large applications with many registered components.

## Package facts

- License: BSD (permissive)
- Python support: unspecified
- Install friction: low
- Maintenance: abandoned
- Downloads: 165.7K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

plugin registry autodiscovery, component registration system, app plugin discovery, dynamic registry pattern, modular app registration, autodiscover callbacks, pluggable component registry, plugin-system, registry-pattern, abandoned

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