TypeRegistry

TypeRegistry is the runtime lookup table that maps graph type name strings to GraphType instances. Loaded modules register their GraphType objects here during application startup.

Registration

from knowledge_platform.domain.registry import TypeRegistry
from knowledge_platform.modules.outline.graph_type import OutlineGraphType

registry = TypeRegistry()
registry.register(OutlineGraphType())

# Look up later
gtype = registry.get("outline")
print(registry.registered_names())  # ["outline"]

Duplicate Registration

Attempting to register two types with the same type_name raises ValueError:

registry.register(OutlineGraphType())  # OK
registry.register(OutlineGraphType())  # ValueError: Graph type 'outline' is already registered.

Checking Registration

if registry.is_registered("kanban"):
    module = registry.get("kanban")

Usage in Application Bootstrap

In ui/app.py, ModuleLoader loads configured modules first, then registers their graph types before any graph is created:

from knowledge_platform.modules.loader import ModuleLoader

type_registry = TypeRegistry()
module_loader = ModuleLoader()
module_loader.register_into(type_registry, module_registry)

API Reference

knowledge_platform.domain.registry.TypeRegistry

Singleton-style registry mapping graph type names to :class:GraphType instances.

Modules register their :class:GraphType implementations here during startup. The :class:~knowledge_platform.services.graph_service.GraphService looks up types at creation time to validate new graphs.

Example::

registry = TypeRegistry()
registry.register(OutlineGraphType())
gtype = registry.get("outline")

Source code in src/knowledge_platform/domain/registry.py

class TypeRegistry:
    """Singleton-style registry mapping graph type names to :class:`GraphType` instances.

    Modules register their :class:`GraphType` implementations here during
    startup.  The :class:`~knowledge_platform.services.graph_service.GraphService`
    looks up types at creation time to validate new graphs.

    Example::

        registry = TypeRegistry()
        registry.register(OutlineGraphType())
        gtype = registry.get("outline")
    """

    def __init__(self) -> None:
        self._types: dict[str, GraphType] = {}

    def register(self, graph_type: GraphType) -> None:
        """Register a :class:`GraphType` instance.

        Args:
            graph_type: The type to register.  Its :attr:`~GraphType.type_name`
                must be unique within this registry.

        Raises:
            ValueError: If *type_name* is already registered.
        """
        name = graph_type.type_name
        if not name:
            raise ValueError("GraphType.type_name must be a non-empty string.")
        if name in self._types:
            raise ValueError(f"Graph type '{name}' is already registered.")
        self._types[name] = graph_type
        logger.info("graph_type.registered", type_name=name)

    def get(self, type_name: str) -> GraphType:
        """Return the :class:`GraphType` for *type_name*.

        Args:
            type_name: Registered type name.

        Returns:
            The corresponding :class:`GraphType`.

        Raises:
            KeyError: If *type_name* is not registered.
        """
        if type_name not in self._types:
            raise KeyError(f"Graph type '{type_name}' is not registered.")
        return self._types[type_name]

    def is_registered(self, type_name: str) -> bool:
        """Return ``True`` if *type_name* is currently registered.

        Args:
            type_name: Type name to query.
        """
        return type_name in self._types

    def registered_names(self) -> list[str]:
        """Return a sorted list of all registered type names."""
        return sorted(self._types.keys())

Functions

get

get(type_name: str) -> GraphType

Return the :class:GraphType for type_name.

Parameters:

Name	Type	Description	Default
type_name	str	Registered type name.	required

Returns:

Type	Description
GraphType	The corresponding :class:GraphType.

Raises:

Type	Description
KeyError	If type_name is not registered.

Source code in src/knowledge_platform/domain/registry.py

def get(self, type_name: str) -> GraphType:
    """Return the :class:`GraphType` for *type_name*.

    Args:
        type_name: Registered type name.

    Returns:
        The corresponding :class:`GraphType`.

    Raises:
        KeyError: If *type_name* is not registered.
    """
    if type_name not in self._types:
        raise KeyError(f"Graph type '{type_name}' is not registered.")
    return self._types[type_name]

is_registered

is_registered(type_name: str) -> bool

Return True if type_name is currently registered.

Parameters:

Name	Type	Description	Default
type_name	str	Type name to query.	required

Source code in src/knowledge_platform/domain/registry.py

def is_registered(self, type_name: str) -> bool:
    """Return ``True`` if *type_name* is currently registered.

    Args:
        type_name: Type name to query.
    """
    return type_name in self._types

register

register(graph_type: GraphType) -> None

Register a :class:GraphType instance.

Parameters:

Name	Type	Description	Default
graph_type	GraphType	The type to register. Its :attr:~GraphType.type_name must be unique within this registry.	required

Raises:

Type	Description
ValueError	If type_name is already registered.

Source code in src/knowledge_platform/domain/registry.py

def register(self, graph_type: GraphType) -> None:
    """Register a :class:`GraphType` instance.

    Args:
        graph_type: The type to register.  Its :attr:`~GraphType.type_name`
            must be unique within this registry.

    Raises:
        ValueError: If *type_name* is already registered.
    """
    name = graph_type.type_name
    if not name:
        raise ValueError("GraphType.type_name must be a non-empty string.")
    if name in self._types:
        raise ValueError(f"Graph type '{name}' is already registered.")
    self._types[name] = graph_type
    logger.info("graph_type.registered", type_name=name)

registered_names

registered_names() -> list[str]

Return a sorted list of all registered type names.

Source code in src/knowledge_platform/domain/registry.py

def registered_names(self) -> list[str]:
    """Return a sorted list of all registered type names."""
    return sorted(self._types.keys())