Image Pipeline Playground
"""Node base class and registry pattern."""
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Any
from app.models.graph import NodeMetadata, ParamField, PortSpec
class BaseNode(ABC):
"""Abstract processing node with metadata, validation, execute, and codegen."""
type: str = ""
label: str = ""
category: str = "general"
description: str = ""
ports: list[PortSpec] = []
params: list[ParamField] = []
stochastic: bool = False
cacheable: bool = True
def metadata(self) -> NodeMetadata:
return NodeMetadata(
type=self.type,
label=self.label,
category=self.category,
description=self.description,
ports=list(self.ports),
params=list(self.params),
stochastic=self.stochastic,
)
def default_params(self) -> dict[str, Any]:
return {field.name: field.default for field in self.params}
def validate_params(self, params: dict[str, Any]) -> dict[str, Any]:
merged = self.default_params()
merged.update(params)
for field in self.params:
if field.name not in merged:
raise ValueError(f"Missing required parameter '{field.name}' for node {self.type}")
value = merged[field.name]
numeric = isinstance(value, (int, float))
if field.minimum is not None and numeric and value < field.minimum:
raise ValueError(f"Parameter '{field.name}' below minimum {field.minimum}")
if field.maximum is not None and numeric and value > field.maximum:
raise ValueError(f"Parameter '{field.name}' above maximum {field.maximum}")
if field.options is not None and value not in field.options:
raise ValueError(f"Parameter '{field.name}' must be one of {field.options}")
return merged
def prepare_run(self, params: dict[str, Any]) -> None:
"""Hook called before execute/cache lookup (e.g. publish source filenames)."""
@abstractmethod
def execute(
self,
inputs: dict[str, Any],
params: dict[str, Any],
seed: int = 0,
) -> dict[str, Any]:
"""Run the node and return output port mapping (images and/or annotations)."""
@abstractmethod
def emit_python(
self,
node_id: str,
params: dict[str, Any],
input_vars: dict[str, str],
output_vars: dict[str, str],
) -> list[str]:
"""Return Python source lines that reproduce this node's effect."""
class NodeRegistry:
"""Singleton-style registry of node implementations."""
def __init__(self) -> None:
self._nodes: dict[str, BaseNode] = {}
def register(self, node: BaseNode) -> None:
if not node.type:
raise ValueError("Node type must be a non-empty string")
if node.type in self._nodes:
raise ValueError(f"Node type '{node.type}' is already registered")
self._nodes[node.type] = node
def get(self, node_type: str) -> BaseNode:
try:
return self._nodes[node_type]
except KeyError as exc:
raise KeyError(f"Unknown node type '{node_type}'") from exc
def has(self, node_type: str) -> bool:
return node_type in self._nodes
def unregister(self, node_type: str) -> None:
self._nodes.pop(node_type, None)
def replace(self, node: BaseNode) -> None:
"""Register or overwrite a node implementation (used for user scripts)."""
if not node.type:
raise ValueError("Node type must be a non-empty string")
self._nodes[node.type] = node
def list_metadata(self) -> list[NodeMetadata]:
return [node.metadata() for node in self._nodes.values()]
def clear(self) -> None:
self._nodes.clear()
registry = NodeRegistry()