Skip to main content

A python package to build registries that can autodiscover values accross your project components

Project description


Persisting-theory is a small python utility designed to automate data discovering and access inside a list of packages. Use case: you are building an application that will have pluggable components. You want to allow these components to register data so it can be accessed by any other component of your app.

If you ever used Django framework, you may remember this:

from django.contrib import admin

Basically, persisting-theory will do the same, except that it let you declare what you want to autodiscover.

Okay, I’m bad at explaining things, and english is not my mother tongue. Let’s build a simple example.


A basic setup:


from persiting_theory import Registry

class CallbacksRegistry(Registry):
        Allow your apps to register callbacks
    # the package where the registry will try to find callbacks in each app
    look_into = "callbacks_registry"

callbacks_registry = CallbacksRegistry()

# app1/

from registries import callbacks_registry

def dog():

# app2/

from registries import callbacks_registry

def cat():


from registries import callbacks_registry

APPS = (

# Trigger autodiscovering process

for callback in callbacks_registry.values():

    # Wouf
    # Meow


Registry inherits from python built-in collections.OrderedDict, which means you can use regular dict methods to access registered data:

callbacks_registry.get("dog")()  #  will print Wouf
assert callbacks_registry.get("chicken", None) is None


You can use this function as a decorator for registering functions and classes:

from persisting_theory import Registry

class AwesomeRegistry(Registry):

r = AwesomeRegistry()

# register a class
class AwesomeClass:

# register a function
def awesome_function():

# By default, the key in the registry for a given value is obtained from the function or class name, if possible

assert r.get("AwesomeClass") == AwesomeClass
assert r.get("awesome_function") == awesome_function

# You can override this behaviour:

class AwesomeClass:

def awesome_function():

assert r.get("Chuck") == AwesomeClass
assert r.get("Norris") == awesome_function

# You can also use the register method as is

awesome_var = "Chuck Norris"
r.register(awesome_var, name="Who am I ?")

assert r.get("Who am I ?") == awesome_var

# I f you are not registering a function or a class, you MUST provide a name argument


By default, a registry will accept any registered value. Sometimes, it’s not what you want, so you can restrict what kind of data your registry accepts:

from persisting_theory import Registry

class StartsWithAwesomeRegistry(Registry):

    def validate(self, obj):
        if isinstance(obj, str):
            return obj.startswith("awesome")
        return False

r = StartsWithAwesomeRegistry()

# will pass registration
r.register("awesome day", name="awesome_day")

# will fail and raise ValueError
r.register("not so awesome day", name="not_so_awesome_day")

Going meta

If you have multiple registries, or want to allow your apps to declare their own registries, this is for you:


from persisting_theory import meta_registry, Registry

class RegistryA(Registry):
    look_into = "a"

class RegistryB(Registry):
    look_into = "b"

registry_a = RegistryA()
meta_registry.register(registry_a, name="registry_a")

registry_b = RegistryB()
meta_registry.register(registry_b, name="registry_b")


from persisting_theory import meta_registry

# will import registries declared in `registries` packages, and trigger autodiscover() on each of them
meta_registry.autodiscover(apps=("app1", "app2"))

What the hell is that name ?

It’s an anagram for “python registries”.


Contributions, bug reports, and “thank you” are welcomed. Feel free to contact me at <>.


The project is licensed under BSD licence.

Project details

Release history Release notifications

History Node


History Node


History Node


History Node


This version
History Node


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Filename, size & hash SHA256 hash help File type Python version Upload date
persisting-theory-0.1.tar.gz (6.8 kB) Copy SHA256 hash SHA256 Source None Jul 11, 2014

Supported by

Elastic Elastic Search Pingdom Pingdom Monitoring Google Google BigQuery Sentry Sentry Error logging CloudAMQP CloudAMQP RabbitMQ AWS AWS Cloud computing Fastly Fastly CDN DigiCert DigiCert EV certificate StatusPage StatusPage Status page