AutoRegistry

1.2.1 · active · verified Tue Apr 14

AutoRegistry is a Python library that implements an automatic registry design pattern, enabling the mapping of string names to functionality (classes or functions) without manual lookup dictionaries. It supports inheritance-based registration, decorator-based registration, and module-level traversal for automatic setup. The library is actively maintained with consistent minor and patch releases, currently at version 1.2.1.

Warnings

gotcha Encountering `KeyCollisionError` during module hot-reloading (e.g., in development environments like IPython with `%autoreload`). This could occur if modules containing registered classes were reloaded, leading to re-registration.
Fix: Upgrade to `autoregistry` version 1.2.1 or later, which includes fixes to reduce the strictness of `KeyCollisionError` for hot-reloading scenarios.
gotcha When using `autoregistry.pydantic.BaseModel`, registering multiple classes with the same derived name could trigger `KeyCollisionError`.
Fix: Update to `autoregistry` 1.2.1 or newer. This version specifically addresses `KeyCollisionErrors` when registering multiple same-name classes to `autoregistry.pydantic.BaseModel`.
gotcha Potential issues when combining `autoregistry.Registry` subclasses with `attrs` decorators, especially when `slots` are enabled, leading to unexpected behavior or errors.
Fix: Upgrade to `autoregistry` version 1.0.2 or later, which contains fixes for `attrs` decorator compatibility issues with `Registry` subclasses and `slots`. Users should ensure their `attrs` integration is on a supported `autoregistry` version.
gotcha Unexpected behavior or incorrect naming due to issues with module registry name preprocessing, potentially leading to incorrect keys in the registry when using module-based registration.
Fix: Upgrade to `autoregistry` version 1.1.2 or later, which includes a fix for module registry name preprocessing, ensuring consistent and correct naming.

Install

pip install autoregistry Install core library
pip install autoregistry[pydantic] Install with Pydantic support

Imports

Registry
```
from autoregistry import Registry
```
BaseModel
```
from autoregistry.pydantic import BaseModel
```
The Pydantic-enhanced BaseModel is located in the `autoregistry.pydantic` submodule, not directly under `autoregistry`.

Quickstart

This example demonstrates how to use `Registry` with class inheritance. Subclasses of `Pokemon` are automatically registered by their lowercase name, allowing them to be retrieved via dictionary-like access on the base `Pokemon` class.

from abc import abstractmethod
from dataclasses import dataclass
from autoregistry import Registry

@dataclass
class Pokemon(Registry):
    level: int
    hp: int

    @abstractmethod
    def attack(self, target):
        """Attack another Pokemon."""

class Charmander(Pokemon):
    def attack(self, target):
        return 1

class Pikachu(Pokemon):
    def attack(self, target):
        return 2

# Access registered subclasses
charmander = Pokemon["charmander"](level=5, hp=40) # Name is auto-derived from class name
pikachu = Pokemon["pikachu"](level=7, hp=50)

assert charmander.attack(pikachu) == 1
assert isinstance(charmander, Charmander)
assert isinstance(pikachu, Pikachu)

print(f"Created {charmander.__class__.__name__} (Level: {charmander.level}, HP: {charmander.hp})")
print(f"Created {pikachu.__class__.__name__} (Level: {pikachu.level}, HP: {pikachu.hp})")

view raw JSON →