feat: add datasource and definition graph contracts
This commit is contained in:
391
src/govoplan_core/core/datasources.py
Normal file
391
src/govoplan_core/core/datasources.py
Normal file
@@ -0,0 +1,391 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from collections.abc import Mapping, Sequence
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime
|
||||
from typing import Literal, Protocol, runtime_checkable
|
||||
|
||||
|
||||
CAPABILITY_DATASOURCE_CATALOGUE = "datasources.catalogue"
|
||||
CAPABILITY_DATASOURCE_LIFECYCLE = "datasources.lifecycle"
|
||||
CAPABILITY_DATASOURCE_ORIGINS = "connectors.datasourceOrigins"
|
||||
|
||||
DatasourceMode = Literal["live", "cached", "static"]
|
||||
DatasourceKind = Literal[
|
||||
"upload",
|
||||
"database",
|
||||
"http",
|
||||
"rest",
|
||||
"directory",
|
||||
"file",
|
||||
"feed",
|
||||
"custom",
|
||||
]
|
||||
DatasourceShape = Literal["tabular", "document", "binary", "directory", "stream"]
|
||||
DatasourceConsistency = Literal["current", "live", "frozen"]
|
||||
|
||||
|
||||
class DatasourceError(ValueError):
|
||||
"""Stable base error for provider-neutral datasource operations."""
|
||||
|
||||
|
||||
class DatasourceNotFoundError(DatasourceError):
|
||||
pass
|
||||
|
||||
|
||||
class DatasourceAccessError(DatasourceError):
|
||||
pass
|
||||
|
||||
|
||||
class DatasourceValidationError(DatasourceError):
|
||||
pass
|
||||
|
||||
|
||||
class DatasourceUnavailableError(DatasourceError):
|
||||
pass
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasourceField:
|
||||
name: str
|
||||
data_type: str
|
||||
nullable: bool = True
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasourceDescriptor:
|
||||
ref: str
|
||||
source_name: str
|
||||
name: str
|
||||
kind: DatasourceKind
|
||||
mode: DatasourceMode
|
||||
shape: DatasourceShape
|
||||
status: str = "active"
|
||||
description: str | None = None
|
||||
provider: str | None = None
|
||||
provider_ref: str | None = None
|
||||
schema: tuple[DatasourceField, ...] = ()
|
||||
schema_version: str = "1"
|
||||
fingerprint: str = ""
|
||||
current_materialization_ref: str | None = None
|
||||
row_count: int | None = None
|
||||
byte_count: int | None = None
|
||||
updated_at: datetime | None = None
|
||||
capabilities: tuple[str, ...] = ("read",)
|
||||
provenance: Mapping[str, object] = field(default_factory=dict)
|
||||
metadata: Mapping[str, object] = field(default_factory=dict)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasourceMaterialization:
|
||||
ref: str
|
||||
datasource_ref: str
|
||||
revision: int
|
||||
state: str
|
||||
fingerprint: str
|
||||
schema: tuple[DatasourceField, ...] = ()
|
||||
row_count: int | None = None
|
||||
byte_count: int | None = None
|
||||
frozen_at: datetime | None = None
|
||||
frozen_label: str | None = None
|
||||
source_timestamp: datetime | None = None
|
||||
created_at: datetime | None = None
|
||||
provenance: Mapping[str, object] = field(default_factory=dict)
|
||||
metadata: Mapping[str, object] = field(default_factory=dict)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasourceStage:
|
||||
ref: str
|
||||
name: str
|
||||
source_name: str
|
||||
kind: DatasourceKind
|
||||
mode: DatasourceMode
|
||||
shape: DatasourceShape
|
||||
state: str
|
||||
target_datasource_ref: str | None = None
|
||||
fingerprint: str = ""
|
||||
schema: tuple[DatasourceField, ...] = ()
|
||||
row_count: int | None = None
|
||||
byte_count: int | None = None
|
||||
validation: Mapping[str, object] = field(default_factory=dict)
|
||||
created_at: datetime | None = None
|
||||
promoted_at: datetime | None = None
|
||||
promoted_materialization_ref: str | None = None
|
||||
provenance: Mapping[str, object] = field(default_factory=dict)
|
||||
metadata: Mapping[str, object] = field(default_factory=dict)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasourceReadRequest:
|
||||
datasource_ref: str
|
||||
materialization_ref: str | None = None
|
||||
consistency: DatasourceConsistency = "current"
|
||||
limit: int = 250
|
||||
offset: int = 0
|
||||
columns: tuple[str, ...] = ()
|
||||
expected_fingerprint: str | None = None
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasourceReadResult:
|
||||
datasource: DatasourceDescriptor
|
||||
rows: tuple[Mapping[str, object], ...]
|
||||
total_rows: int
|
||||
truncated: bool
|
||||
materialization: DatasourceMaterialization | None = None
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasourceStageInput:
|
||||
name: str
|
||||
source_name: str
|
||||
kind: DatasourceKind
|
||||
mode: DatasourceMode
|
||||
shape: DatasourceShape
|
||||
rows: tuple[Mapping[str, object], ...]
|
||||
description: str | None = None
|
||||
target_datasource_ref: str | None = None
|
||||
provider: str | None = None
|
||||
provider_ref: str | None = None
|
||||
provenance: Mapping[str, object] = field(default_factory=dict)
|
||||
metadata: Mapping[str, object] = field(default_factory=dict)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasourceOrigin:
|
||||
ref: str
|
||||
source_name: str
|
||||
name: str
|
||||
kind: DatasourceKind
|
||||
shape: DatasourceShape
|
||||
supported_modes: tuple[DatasourceMode, ...]
|
||||
provider: str
|
||||
description: str | None = None
|
||||
schema: tuple[DatasourceField, ...] = ()
|
||||
schema_version: str = "1"
|
||||
fingerprint: str = ""
|
||||
row_count: int | None = None
|
||||
byte_count: int | None = None
|
||||
updated_at: datetime | None = None
|
||||
capabilities: tuple[str, ...] = ("read",)
|
||||
metadata: Mapping[str, object] = field(default_factory=dict)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasourceOriginReadRequest:
|
||||
origin_ref: str
|
||||
limit: int = 250
|
||||
offset: int = 0
|
||||
columns: tuple[str, ...] = ()
|
||||
expected_fingerprint: str | None = None
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasourceOriginReadResult:
|
||||
origin: DatasourceOrigin
|
||||
rows: tuple[Mapping[str, object], ...]
|
||||
total_rows: int
|
||||
truncated: bool
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class DatasourceCatalogueProvider(Protocol):
|
||||
def list_datasources(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
query: str = "",
|
||||
limit: int = 100,
|
||||
) -> Sequence[DatasourceDescriptor]:
|
||||
...
|
||||
|
||||
def get_datasource(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
datasource_ref: str,
|
||||
) -> DatasourceDescriptor | None:
|
||||
...
|
||||
|
||||
def read_datasource(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
request: DatasourceReadRequest,
|
||||
) -> DatasourceReadResult:
|
||||
...
|
||||
|
||||
def list_materializations(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
datasource_ref: str,
|
||||
) -> Sequence[DatasourceMaterialization]:
|
||||
...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class DatasourceLifecycleProvider(Protocol):
|
||||
def list_stages(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
limit: int = 100,
|
||||
) -> Sequence[DatasourceStage]:
|
||||
...
|
||||
|
||||
def create_stage(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
stage: DatasourceStageInput,
|
||||
) -> DatasourceStage:
|
||||
...
|
||||
|
||||
def promote_stage(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
stage_ref: str,
|
||||
freeze: bool = False,
|
||||
frozen_label: str | None = None,
|
||||
) -> tuple[DatasourceDescriptor, DatasourceMaterialization]:
|
||||
...
|
||||
|
||||
def register_origin(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
origin_ref: str,
|
||||
name: str,
|
||||
source_name: str,
|
||||
mode: DatasourceMode,
|
||||
description: str | None = None,
|
||||
) -> DatasourceDescriptor:
|
||||
...
|
||||
|
||||
def refresh_datasource(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
datasource_ref: str,
|
||||
) -> tuple[DatasourceDescriptor, DatasourceMaterialization]:
|
||||
...
|
||||
|
||||
def freeze_datasource(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
datasource_ref: str,
|
||||
label: str | None = None,
|
||||
) -> DatasourceMaterialization:
|
||||
...
|
||||
|
||||
def retire_datasource(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
datasource_ref: str,
|
||||
) -> DatasourceDescriptor:
|
||||
...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class DatasourceOriginProvider(Protocol):
|
||||
def list_origins(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
query: str = "",
|
||||
limit: int = 100,
|
||||
) -> Sequence[DatasourceOrigin]:
|
||||
...
|
||||
|
||||
def get_origin(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
origin_ref: str,
|
||||
) -> DatasourceOrigin | None:
|
||||
...
|
||||
|
||||
def read_origin(
|
||||
self,
|
||||
session: object,
|
||||
principal: object,
|
||||
*,
|
||||
request: DatasourceOriginReadRequest,
|
||||
) -> DatasourceOriginReadResult:
|
||||
...
|
||||
|
||||
|
||||
def datasource_catalogue(registry: object | None) -> DatasourceCatalogueProvider | None:
|
||||
capability = _capability(registry, CAPABILITY_DATASOURCE_CATALOGUE)
|
||||
return capability if isinstance(capability, DatasourceCatalogueProvider) else None
|
||||
|
||||
|
||||
def datasource_lifecycle(registry: object | None) -> DatasourceLifecycleProvider | None:
|
||||
capability = _capability(registry, CAPABILITY_DATASOURCE_LIFECYCLE)
|
||||
return capability if isinstance(capability, DatasourceLifecycleProvider) else None
|
||||
|
||||
|
||||
def datasource_origins(registry: object | None) -> DatasourceOriginProvider | None:
|
||||
capability = _capability(registry, CAPABILITY_DATASOURCE_ORIGINS)
|
||||
return capability if isinstance(capability, DatasourceOriginProvider) else None
|
||||
|
||||
|
||||
def _capability(registry: object | None, name: str) -> object | None:
|
||||
if (
|
||||
registry is None
|
||||
or not hasattr(registry, "has_capability")
|
||||
or not hasattr(registry, "capability")
|
||||
or not registry.has_capability(name)
|
||||
):
|
||||
return None
|
||||
return registry.capability(name)
|
||||
|
||||
|
||||
__all__ = [
|
||||
"CAPABILITY_DATASOURCE_CATALOGUE",
|
||||
"CAPABILITY_DATASOURCE_LIFECYCLE",
|
||||
"CAPABILITY_DATASOURCE_ORIGINS",
|
||||
"DatasourceAccessError",
|
||||
"DatasourceCatalogueProvider",
|
||||
"DatasourceConsistency",
|
||||
"DatasourceDescriptor",
|
||||
"DatasourceError",
|
||||
"DatasourceField",
|
||||
"DatasourceKind",
|
||||
"DatasourceLifecycleProvider",
|
||||
"DatasourceMaterialization",
|
||||
"DatasourceMode",
|
||||
"DatasourceNotFoundError",
|
||||
"DatasourceOrigin",
|
||||
"DatasourceOriginProvider",
|
||||
"DatasourceOriginReadRequest",
|
||||
"DatasourceOriginReadResult",
|
||||
"DatasourceReadRequest",
|
||||
"DatasourceReadResult",
|
||||
"DatasourceShape",
|
||||
"DatasourceStage",
|
||||
"DatasourceStageInput",
|
||||
"DatasourceUnavailableError",
|
||||
"DatasourceValidationError",
|
||||
"datasource_catalogue",
|
||||
"datasource_lifecycle",
|
||||
"datasource_origins",
|
||||
]
|
||||
342
src/govoplan_core/core/definition_graphs.py
Normal file
342
src/govoplan_core/core/definition_graphs.py
Normal file
@@ -0,0 +1,342 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from collections import deque
|
||||
from collections.abc import Mapping, Sequence
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Any
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DefinitionPort:
|
||||
id: str
|
||||
label: str
|
||||
required: bool = True
|
||||
multiple: bool = False
|
||||
minimum_connections: int = 1
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DefinitionConfigField:
|
||||
id: str
|
||||
label: str
|
||||
kind: str
|
||||
required: bool = False
|
||||
description: str | None = None
|
||||
options: tuple[tuple[str, str], ...] = ()
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DefinitionNodeType:
|
||||
type: str
|
||||
category: str
|
||||
label: str
|
||||
description: str
|
||||
icon: str
|
||||
input_ports: tuple[DefinitionPort, ...] = ()
|
||||
output_ports: tuple[DefinitionPort, ...] = (
|
||||
DefinitionPort(id="output", label="Output"),
|
||||
)
|
||||
config_fields: tuple[DefinitionConfigField, ...] = ()
|
||||
default_config: Mapping[str, Any] = field(default_factory=dict)
|
||||
metadata: Mapping[str, Any] = field(default_factory=dict)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DefinitionNode:
|
||||
id: str
|
||||
type: str
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DefinitionEdge:
|
||||
id: str
|
||||
source: str
|
||||
target: str
|
||||
source_port: str = "output"
|
||||
target_port: str = "input"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DefinitionNodeCountConstraint:
|
||||
code: str
|
||||
label: str
|
||||
minimum: int = 0
|
||||
maximum: int | None = None
|
||||
node_types: tuple[str, ...] = ()
|
||||
type_prefixes: tuple[str, ...] = ()
|
||||
categories: tuple[str, ...] = ()
|
||||
|
||||
def matches(self, node: DefinitionNode, node_type: DefinitionNodeType | None) -> bool:
|
||||
return (
|
||||
node.type in self.node_types
|
||||
or any(node.type.startswith(prefix) for prefix in self.type_prefixes)
|
||||
or node_type is not None
|
||||
and node_type.category in self.categories
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DefinitionGraphConstraints:
|
||||
max_nodes: int = 100
|
||||
max_edges: int = 200
|
||||
allow_cycles: bool = False
|
||||
require_connected: bool = True
|
||||
node_counts: tuple[DefinitionNodeCountConstraint, ...] = ()
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DefinitionGraphLibrary:
|
||||
id: str
|
||||
version: str
|
||||
category_labels: Mapping[str, str]
|
||||
node_types: tuple[DefinitionNodeType, ...]
|
||||
constraints: DefinitionGraphConstraints = field(default_factory=DefinitionGraphConstraints)
|
||||
|
||||
def node_type(self, type_id: str) -> DefinitionNodeType | None:
|
||||
return next((item for item in self.node_types if item.type == type_id), None)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DefinitionDiagnostic:
|
||||
severity: str
|
||||
code: str
|
||||
message: str
|
||||
node_id: str | None = None
|
||||
field: str | None = None
|
||||
|
||||
|
||||
def validate_definition_graph(
|
||||
library: DefinitionGraphLibrary,
|
||||
*,
|
||||
nodes: Sequence[DefinitionNode],
|
||||
edges: Sequence[DefinitionEdge],
|
||||
) -> tuple[DefinitionDiagnostic, ...]:
|
||||
diagnostics: list[DefinitionDiagnostic] = []
|
||||
constraints = library.constraints
|
||||
if not nodes:
|
||||
return (_error("graph.empty", "Add nodes before saving the definition."),)
|
||||
if len(nodes) > constraints.max_nodes:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
"graph.node_limit",
|
||||
f"Definitions are limited to {constraints.max_nodes:,} nodes.",
|
||||
)
|
||||
)
|
||||
if len(edges) > constraints.max_edges:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
"graph.edge_limit",
|
||||
f"Definitions are limited to {constraints.max_edges:,} edges.",
|
||||
)
|
||||
)
|
||||
|
||||
node_by_id = {node.id: node for node in nodes}
|
||||
if len(node_by_id) != len(nodes):
|
||||
diagnostics.append(_error("graph.duplicate_node", "Node identifiers must be unique."))
|
||||
if len({edge.id for edge in edges}) != len(edges):
|
||||
diagnostics.append(_error("graph.duplicate_edge", "Edge identifiers must be unique."))
|
||||
|
||||
incoming: dict[str, list[DefinitionEdge]] = {node_id: [] for node_id in node_by_id}
|
||||
undirected: dict[str, set[str]] = {node_id: set() for node_id in node_by_id}
|
||||
topology_edges: list[DefinitionEdge] = []
|
||||
for edge in edges:
|
||||
if edge.source not in node_by_id:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
"edge.unknown_source",
|
||||
f"Edge {edge.id!r} references an unknown source node.",
|
||||
)
|
||||
)
|
||||
continue
|
||||
if edge.target not in node_by_id:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
"edge.unknown_target",
|
||||
f"Edge {edge.id!r} references an unknown target node.",
|
||||
)
|
||||
)
|
||||
continue
|
||||
if edge.source == edge.target:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
"edge.self_reference",
|
||||
"A node cannot connect to itself.",
|
||||
node_id=edge.source,
|
||||
)
|
||||
)
|
||||
continue
|
||||
topology_edges.append(edge)
|
||||
source_definition = library.node_type(node_by_id[edge.source].type)
|
||||
target_definition = library.node_type(node_by_id[edge.target].type)
|
||||
if source_definition is not None and edge.source_port not in {
|
||||
port.id for port in source_definition.output_ports
|
||||
}:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
"edge.unknown_source_port",
|
||||
f"Node {edge.source!r} has no output port {edge.source_port!r}.",
|
||||
node_id=edge.source,
|
||||
)
|
||||
)
|
||||
continue
|
||||
if target_definition is not None and edge.target_port not in {
|
||||
port.id for port in target_definition.input_ports
|
||||
}:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
"edge.unknown_target_port",
|
||||
f"Node {edge.target!r} has no input port {edge.target_port!r}.",
|
||||
node_id=edge.target,
|
||||
)
|
||||
)
|
||||
continue
|
||||
incoming[edge.target].append(edge)
|
||||
undirected[edge.source].add(edge.target)
|
||||
undirected[edge.target].add(edge.source)
|
||||
|
||||
for node in nodes:
|
||||
definition = library.node_type(node.type)
|
||||
if definition is None:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
"node.unsupported_type",
|
||||
f"Node type {node.type!r} is not in the {library.id!r} library.",
|
||||
node_id=node.id,
|
||||
field="type",
|
||||
)
|
||||
)
|
||||
continue
|
||||
for port in definition.input_ports:
|
||||
connections = [
|
||||
edge for edge in incoming.get(node.id, ()) if edge.target_port == port.id
|
||||
]
|
||||
minimum = port.minimum_connections if port.required else 0
|
||||
if len(connections) < minimum:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
"node.input_required",
|
||||
(
|
||||
f"{definition.label} requires {minimum} "
|
||||
f"{port.label.lower()} connection"
|
||||
f"{'' if minimum == 1 else 's'}."
|
||||
),
|
||||
node_id=node.id,
|
||||
)
|
||||
)
|
||||
if not port.multiple and len(connections) > 1:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
"node.input_multiple",
|
||||
f"{port.label} accepts only one connection.",
|
||||
node_id=node.id,
|
||||
)
|
||||
)
|
||||
|
||||
for count_constraint in constraints.node_counts:
|
||||
count = sum(
|
||||
count_constraint.matches(node, library.node_type(node.type))
|
||||
for node in nodes
|
||||
)
|
||||
if count < count_constraint.minimum:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
count_constraint.code,
|
||||
(
|
||||
f"A definition needs at least {count_constraint.minimum} "
|
||||
f"{count_constraint.label} node"
|
||||
f"{'' if count_constraint.minimum == 1 else 's'}."
|
||||
),
|
||||
)
|
||||
)
|
||||
if count_constraint.maximum is not None and count > count_constraint.maximum:
|
||||
diagnostics.append(
|
||||
_error(
|
||||
count_constraint.code,
|
||||
(
|
||||
f"A definition allows at most {count_constraint.maximum} "
|
||||
f"{count_constraint.label} node"
|
||||
f"{'' if count_constraint.maximum == 1 else 's'}."
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
_, cyclic = definition_topological_order(nodes, topology_edges)
|
||||
if cyclic and not constraints.allow_cycles:
|
||||
diagnostics.append(_error("graph.cycle", "Definition edges must form an acyclic graph."))
|
||||
if constraints.require_connected and len(node_by_id) > 1:
|
||||
connected = _connected_nodes(next(iter(node_by_id)), undirected)
|
||||
if len(connected) != len(node_by_id):
|
||||
diagnostics.append(
|
||||
_error("graph.disconnected", "Every node must belong to one connected definition.")
|
||||
)
|
||||
return tuple(diagnostics)
|
||||
|
||||
|
||||
def definition_topological_order(
|
||||
nodes: Sequence[DefinitionNode],
|
||||
edges: Sequence[DefinitionEdge],
|
||||
) -> tuple[tuple[str, ...], bool]:
|
||||
node_ids = [node.id for node in nodes]
|
||||
incoming_count = {node_id: 0 for node_id in node_ids}
|
||||
outgoing: dict[str, list[str]] = {node_id: [] for node_id in node_ids}
|
||||
for edge in edges:
|
||||
if (
|
||||
edge.source in outgoing
|
||||
and edge.target in incoming_count
|
||||
and edge.source != edge.target
|
||||
):
|
||||
outgoing[edge.source].append(edge.target)
|
||||
incoming_count[edge.target] += 1
|
||||
ready = deque(node_id for node_id in node_ids if incoming_count[node_id] == 0)
|
||||
ordered: list[str] = []
|
||||
while ready:
|
||||
node_id = ready.popleft()
|
||||
ordered.append(node_id)
|
||||
for target in outgoing[node_id]:
|
||||
incoming_count[target] -= 1
|
||||
if incoming_count[target] == 0:
|
||||
ready.append(target)
|
||||
return tuple(ordered), len(ordered) != len(node_ids)
|
||||
|
||||
|
||||
def _connected_nodes(start: str, adjacency: Mapping[str, set[str]]) -> set[str]:
|
||||
seen: set[str] = set()
|
||||
pending = [start]
|
||||
while pending:
|
||||
node_id = pending.pop()
|
||||
if node_id in seen:
|
||||
continue
|
||||
seen.add(node_id)
|
||||
pending.extend(adjacency.get(node_id, ()))
|
||||
return seen
|
||||
|
||||
|
||||
def _error(
|
||||
code: str,
|
||||
message: str,
|
||||
*,
|
||||
node_id: str | None = None,
|
||||
field: str | None = None,
|
||||
) -> DefinitionDiagnostic:
|
||||
return DefinitionDiagnostic(
|
||||
severity="error",
|
||||
code=code,
|
||||
message=message,
|
||||
node_id=node_id,
|
||||
field=field,
|
||||
)
|
||||
|
||||
|
||||
__all__ = [
|
||||
"DefinitionConfigField",
|
||||
"DefinitionDiagnostic",
|
||||
"DefinitionEdge",
|
||||
"DefinitionGraphConstraints",
|
||||
"DefinitionGraphLibrary",
|
||||
"DefinitionNode",
|
||||
"DefinitionNodeCountConstraint",
|
||||
"DefinitionNodeType",
|
||||
"DefinitionPort",
|
||||
"definition_topological_order",
|
||||
"validate_definition_graph",
|
||||
]
|
||||
@@ -17,7 +17,7 @@ class Settings(BaseSettings):
|
||||
tenant_data_mode: str = Field(default="shared", alias="TENANT_DATA_MODE")
|
||||
tenant_db_url_template: str | None = Field(default=None, alias="TENANT_DB_URL_TEMPLATE")
|
||||
tenant_schema_template: str | None = Field(default=None, alias="TENANT_SCHEMA_TEMPLATE")
|
||||
enabled_modules: str = Field(default="tenancy,organizations,identity,access,admin,dashboard,policy,audit,campaigns,files,mail,calendar,poll,scheduling,connectors,dataflow,notifications,docs,ops", alias="ENABLED_MODULES")
|
||||
enabled_modules: str = Field(default="tenancy,organizations,identity,access,admin,dashboard,policy,audit,campaigns,files,mail,calendar,poll,scheduling,connectors,datasources,dataflow,workflow,notifications,docs,ops", alias="ENABLED_MODULES")
|
||||
migration_track: str = Field(default="release", alias="GOVOPLAN_MIGRATION_TRACK")
|
||||
redis_url: str = Field(default="redis://redis:6379/0", alias="REDIS_URL")
|
||||
celery_enabled: bool = Field(default=False, alias="CELERY_ENABLED")
|
||||
|
||||
Reference in New Issue
Block a user