luxonis_ml.utils.Registry

class documentation

class Registry(Generic[T]):

Constructor: Registry(name)

A registry to store and retrieve modules.

The registry stores a mapping from string keys to module classes. It provides an interface to register modules and later retrieve them by their string names.

Method	`__contains__`	Undocumented
Method	`__getitem__`	Undocumented
Method	`__init__`	Create a new empty registry.
Method	`__len__`	Undocumented
Method	`__repr__`	Undocumented
Method	`__setitem__`	Undocumented
Method	`__str__`	Undocumented
Method	`get`	Retrieve the registry record for the key.
Method	`register`	Register a module.
Method	`register_module`	Register a module. Deprecated, use `register` instead.
Property	`name`	The name of the registry.
Method	`_register`	Undocumented
Instance Variable	`_module_dict`	Undocumented
Instance Variable	`_name`	Undocumented

def __contains__(self, key: str) -> bool: ¶

Undocumented

def __getitem__(self, key: str) -> T: ¶

Undocumented

def __init__(self, name: str): ¶

Create a new empty registry.

Parameters
name:`str`	The name of the registry, used for error messages.

def __len__(self) -> int: ¶

Undocumented

def __repr__(self) -> str: ¶

Undocumented

def __setitem__(self, key: str, value: T): ¶

Undocumented

def __str__(self) -> str: ¶

Undocumented

def get(self, key: str) -> T: ¶

Retrieve the registry record for the key.

Parameters
key:`str`	The name of the registered item.

Returns
`T`	The registered item corresponding to the key.

Raises
`KeyError`	If the key is not found in the registry.

@overload

def register(self, module: None = ..., *, name: str | None = ..., force: bool = ...) -> Callable[[T], T]:

@overload

def register(self, module: T = ..., *, name: str | None = ..., force: bool = ...):

Can be used as a decorator or as a normal method:

Example

>>> registry = Registry(name="modules")
>>> @registry.register()
... class Foo:
...     pass
>>> registry.get("Foo").__name__
'Foo'
>>> class Bar:
...     pass
>>> registry.register(module=Bar)
>>> registry.get("Bar").__name__
'Bar'

Parameters
module:`T \| None`	The module class to be registered.
name:`str \| None`	The name of the module. If `None`, then use class name.
force:`bool`	Whether to override an existing class with the same name.

Returns
`Callable[[T], T] \| None`	`None` if used as a normal method, or a decorator function if used as a decorator.

Raises
`KeyError`	If a module with the same name already exists and `force` is `False`.

@overload

def register_module(self, name: str | None = ..., module: None = ..., force: bool = ...) -> Callable[[T], T]:

@overload

def register_module(self, name: str | None = ..., module: T = ..., force: bool = ...) -> T:

@deprecated('`register_module` is deprecated, use `register` instead.')

Deprecated since version 0.6.0: Use register instead.

Parameters
name:`str \| None`	Name of the module. If `None`, the class name is used.
module:`T \| None`	Module class to be registered.
force:`bool`	Whether to override an existing class with the same name.

Returns
`T \| Callable[[T], T]`	Registered module or decorator returned by `register`.

Raises
`KeyError`	If a module with the same name already exists and `force` is `False`.

@property

name: str = ¶

The name of the registry.

def _register(self, module: T, module_name: str | None = None, force: bool = False): ¶

Undocumented

_module_dict: dict[str, T] = ¶

Undocumented

_name = ¶

Undocumented