persisting-theory

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 on this page — 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

persisting-theory on PyPI

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

Evidence: persisting_theory-1.0-py3-none-any.whl

Tags

More Application Frameworks packages