astrbot_plugin_imagestudio/backend/services/node_dependency_context_service.py

117 行
5.2 KiB
Python

"""Build dependency context for workflow nodes."""
from __future__ import annotations
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.services.branch_lineage_service import (
BranchLineageResolver,
ResolvedNodeSource,
workflow_metadata_for_branch,
)
from backend.services.material_binding_schema_service import material_bindings_for_node
from backend.services.image_service import ImageService
from backend.services.node_injection_template_service import build_node_injection_contract
from backend.services.prompt_plan_schema_service import prompt_plan_for_node
from backend.services.workflow_service import WorkflowService
class NodeDependencyContextService:
def __init__(
self,
workflow_service: WorkflowService,
image_service: ImageService | None = None,
):
self.workflow_service = workflow_service
self.image_service = image_service
def get_context(self, node_id: str, *, include_draft: bool = False) -> dict[str, Any]:
target = self.workflow_service.get_node(node_id)
detail = self.workflow_service.get_workflow(target.workflow_id)
resolver = BranchLineageResolver(self.workflow_service.workflow_repository)
resolved_dependencies = resolver.resolve_dependencies(target, include_draft=include_draft)
dependencies = [self._node_context(item) for item in resolved_dependencies]
prompt_parts = [item["prompt"] for item in dependencies if item.get("prompt")]
selected_image_ids = [
item["selected_image"]["image_id"]
for item in dependencies
if isinstance(item.get("selected_image"), dict)
]
branch_nodes = [node for node in detail.nodes if node.branch_name == target.branch_name]
branch_metadata = workflow_metadata_for_branch(detail.workflow.metadata, target.branch_name)
inherited_seed = resolver.resolve_parent_seed(target)
material_bindings = material_bindings_for_node(branch_metadata, target, branch_nodes)
result = {
"workflow_id": target.workflow_id,
"node_id": target.node_id,
"branch_name": target.branch_name,
"branch_lineage": list(resolver.branch_chain(target.workflow_id, target.branch_name)),
"dependency_count": len(dependencies),
"dependencies": dependencies,
"prompt_context": ", ".join(prompt_parts),
"selected_image_ids": selected_image_ids,
"material_bindings": material_bindings,
"temporary_references": (
material_bindings.get("temporary_references", [])
if isinstance(material_bindings.get("temporary_references"), list)
else []
),
"navigation_context": (
material_bindings.get("navigation_context", {})
if isinstance(material_bindings.get("navigation_context"), dict)
else {}
),
"prompt_plan": prompt_plan_for_node(branch_metadata, target, branch_nodes),
"inherited_seed": self._node_context(inherited_seed) if inherited_seed else None,
}
result["injection_template"] = build_node_injection_contract(
target,
dependency_context=result,
material_bindings=result["material_bindings"],
prompt_plan=result["prompt_plan"],
stage_inputs=_stage_inputs_for_node(branch_metadata, target.node_id),
)
return result
def _node_context(self, resolved: ResolvedNodeSource) -> dict[str, Any]:
logical = resolved.logical_node
node = resolved.source_node
selected_image = None
if node.selected_image_id and self.image_service:
try:
image = self.image_service.get_image(node.selected_image_id)
selected_image = {
"image_id": image.image_id,
"image_uri": image.image_uri,
"thumbnail_uri": image.thumbnail_uri,
"model_route": image.model_route,
"metadata": image.metadata,
}
except ApiError as exc:
if exc.error_code != ErrorCode.RESOURCE_NOT_FOUND:
raise
return {
"node_id": logical.node_id,
"node_key": logical.node_key,
"title": logical.title,
"branch_name": logical.branch_name,
"status": node.status,
"sort_order": logical.sort_order,
"prompt": node.prompt,
"negative_prompt": node.negative_prompt,
"selected_image_id": node.selected_image_id,
"selected_image": selected_image,
"metadata": node.metadata,
"inherited": resolved.inherited,
"source_branch": resolved.source_branch,
"source_node_id": resolved.source_node_id,
"lineage": list(resolved.lineage),
}
def _stage_inputs_for_node(workflow_metadata: dict[str, Any], node_id: str) -> Any:
stage_inputs = workflow_metadata.get("stage_inputs")
if not isinstance(stage_inputs, dict):
return {}
return stage_inputs.get(node_id) or {}