feat: implement core foundation modules
这个提交存在于:
父节点
3a44276fe2
当前提交
4ae040a1f7
共有 7 个文件被更改,包括 620 次插入 和 6 次删除
|
|
@ -1 +1,63 @@
|
||||||
"""In-process event bus placeholder."""
|
"""Small in-process event bus for ImageStudio services."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
from collections import defaultdict, deque
|
||||||
|
from dataclasses import dataclass, field
|
||||||
|
from datetime import datetime, timezone
|
||||||
|
from typing import Any, Callable, DefaultDict
|
||||||
|
from uuid import uuid4
|
||||||
|
|
||||||
|
|
||||||
|
EventHandler = Callable[["Event"], None]
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass(frozen=True)
|
||||||
|
class Event:
|
||||||
|
event_type: str
|
||||||
|
payload: dict[str, Any] = field(default_factory=dict)
|
||||||
|
event_id: str = field(default_factory=lambda: f"evt_{uuid4().hex}")
|
||||||
|
created_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
|
||||||
|
|
||||||
|
def to_dict(self) -> dict[str, Any]:
|
||||||
|
return {
|
||||||
|
"event_id": self.event_id,
|
||||||
|
"event_type": self.event_type,
|
||||||
|
"payload": self.payload,
|
||||||
|
"created_at": self.created_at,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
class EventBus:
|
||||||
|
def __init__(self, *, history_limit: int = 200):
|
||||||
|
self._handlers: DefaultDict[str, list[EventHandler]] = defaultdict(list)
|
||||||
|
self._history: deque[Event] = deque(maxlen=max(int(history_limit), 1))
|
||||||
|
|
||||||
|
def subscribe(self, event_type: str, handler: EventHandler) -> None:
|
||||||
|
normalized = _normalize_event_type(event_type)
|
||||||
|
if handler not in self._handlers[normalized]:
|
||||||
|
self._handlers[normalized].append(handler)
|
||||||
|
|
||||||
|
def unsubscribe(self, event_type: str, handler: EventHandler) -> None:
|
||||||
|
normalized = _normalize_event_type(event_type)
|
||||||
|
self._handlers[normalized] = [item for item in self._handlers[normalized] if item is not handler]
|
||||||
|
|
||||||
|
def publish(self, event_type: str, payload: dict[str, Any] | None = None) -> Event:
|
||||||
|
event = Event(event_type=_normalize_event_type(event_type), payload=dict(payload or {}))
|
||||||
|
self._history.append(event)
|
||||||
|
for handler in [*self._handlers.get(event.event_type, []), *self._handlers.get("*", [])]:
|
||||||
|
handler(event)
|
||||||
|
return event
|
||||||
|
|
||||||
|
def history(self, event_type: str | None = None) -> list[Event]:
|
||||||
|
if event_type is None:
|
||||||
|
return list(self._history)
|
||||||
|
normalized = _normalize_event_type(event_type)
|
||||||
|
return [event for event in self._history if event.event_type == normalized]
|
||||||
|
|
||||||
|
|
||||||
|
def _normalize_event_type(event_type: str) -> str:
|
||||||
|
normalized = str(event_type or "").strip()
|
||||||
|
if not normalized:
|
||||||
|
raise ValueError("event_type is required")
|
||||||
|
return normalized
|
||||||
|
|
|
||||||
80
core/fsm.py
80
core/fsm.py
|
|
@ -1 +1,79 @@
|
||||||
"""Workflow finite-state-machine helpers placeholder."""
|
"""Finite-state-machine helpers for workflows, nodes, and tasks."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
from dataclasses import dataclass
|
||||||
|
|
||||||
|
|
||||||
|
WORKFLOW_TRANSITIONS: dict[str, set[str]] = {
|
||||||
|
"draft": {"running", "archived"},
|
||||||
|
"running": {"completed", "failed", "cancelled", "archived"},
|
||||||
|
"completed": {"archived"},
|
||||||
|
"failed": {"running", "archived"},
|
||||||
|
"cancelled": {"running", "archived"},
|
||||||
|
"archived": set(),
|
||||||
|
}
|
||||||
|
|
||||||
|
NODE_TRANSITIONS: dict[str, set[str]] = {
|
||||||
|
"pending": {"queued", "running", "completed", "failed", "skipped"},
|
||||||
|
"queued": {"running", "completed", "failed", "cancelled"},
|
||||||
|
"running": {"completed", "failed", "cancelled"},
|
||||||
|
"completed": {"queued"},
|
||||||
|
"failed": {"queued", "skipped"},
|
||||||
|
"cancelled": {"queued"},
|
||||||
|
"skipped": {"queued"},
|
||||||
|
}
|
||||||
|
|
||||||
|
TASK_TRANSITIONS: dict[str, set[str]] = {
|
||||||
|
"created": {"queued", "running", "cancelled"},
|
||||||
|
"queued": {"running", "cancelled", "failed"},
|
||||||
|
"running": {"completed", "succeeded", "failed", "cancelled"},
|
||||||
|
"completed": set(),
|
||||||
|
"succeeded": set(),
|
||||||
|
"failed": {"queued", "dead_letter"},
|
||||||
|
"cancelled": {"queued"},
|
||||||
|
"dead_letter": {"queued"},
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass(frozen=True)
|
||||||
|
class TransitionResult:
|
||||||
|
allowed: bool
|
||||||
|
current: str
|
||||||
|
target: str
|
||||||
|
reason: str = ""
|
||||||
|
|
||||||
|
|
||||||
|
def can_transition(current: str, target: str, transitions: dict[str, set[str]]) -> bool:
|
||||||
|
normalized_current = _normalize_state(current)
|
||||||
|
normalized_target = _normalize_state(target)
|
||||||
|
return normalized_target == normalized_current or normalized_target in transitions.get(normalized_current, set())
|
||||||
|
|
||||||
|
|
||||||
|
def check_transition(current: str, target: str, transitions: dict[str, set[str]]) -> TransitionResult:
|
||||||
|
normalized_current = _normalize_state(current)
|
||||||
|
normalized_target = _normalize_state(target)
|
||||||
|
if normalized_current not in transitions:
|
||||||
|
return TransitionResult(False, normalized_current, normalized_target, "unknown current state")
|
||||||
|
if can_transition(normalized_current, normalized_target, transitions):
|
||||||
|
return TransitionResult(True, normalized_current, normalized_target)
|
||||||
|
return TransitionResult(False, normalized_current, normalized_target, "transition is not allowed")
|
||||||
|
|
||||||
|
|
||||||
|
def workflow_transition(current: str, target: str) -> TransitionResult:
|
||||||
|
return check_transition(current, target, WORKFLOW_TRANSITIONS)
|
||||||
|
|
||||||
|
|
||||||
|
def node_transition(current: str, target: str) -> TransitionResult:
|
||||||
|
return check_transition(current, target, NODE_TRANSITIONS)
|
||||||
|
|
||||||
|
|
||||||
|
def task_transition(current: str, target: str) -> TransitionResult:
|
||||||
|
return check_transition(current, target, TASK_TRANSITIONS)
|
||||||
|
|
||||||
|
|
||||||
|
def _normalize_state(value: str) -> str:
|
||||||
|
normalized = str(value or "").strip().lower()
|
||||||
|
if not normalized:
|
||||||
|
raise ValueError("state is required")
|
||||||
|
return normalized
|
||||||
|
|
|
||||||
|
|
@ -1 +1,83 @@
|
||||||
"""Model route selection placeholder."""
|
"""Model route selection helpers."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
from dataclasses import dataclass, field
|
||||||
|
from typing import Any
|
||||||
|
|
||||||
|
|
||||||
|
SUPPORTED = "confirmed_supported"
|
||||||
|
UNSUPPORTED = "confirmed_unsupported"
|
||||||
|
UNCONFIRMED = "unconfirmed"
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass(frozen=True)
|
||||||
|
class ModelRoute:
|
||||||
|
provider_id: str
|
||||||
|
model_id: str
|
||||||
|
route_id: str | None = None
|
||||||
|
status: str = UNCONFIRMED
|
||||||
|
capabilities: set[str] = field(default_factory=set)
|
||||||
|
priority: int = 100
|
||||||
|
|
||||||
|
@property
|
||||||
|
def key(self) -> str:
|
||||||
|
return self.route_id or f"{self.provider_id}/{self.model_id}"
|
||||||
|
|
||||||
|
def to_dict(self) -> dict[str, Any]:
|
||||||
|
return {
|
||||||
|
"route_id": self.route_id,
|
||||||
|
"provider_id": self.provider_id,
|
||||||
|
"model_id": self.model_id,
|
||||||
|
"status": self.status,
|
||||||
|
"capabilities": sorted(self.capabilities),
|
||||||
|
"priority": self.priority,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass(frozen=True)
|
||||||
|
class RouteSelection:
|
||||||
|
selected: ModelRoute | None
|
||||||
|
status: str
|
||||||
|
reason: str = ""
|
||||||
|
candidates: list[ModelRoute] = field(default_factory=list)
|
||||||
|
|
||||||
|
@property
|
||||||
|
def valid(self) -> bool:
|
||||||
|
return self.selected is not None and self.status == SUPPORTED
|
||||||
|
|
||||||
|
|
||||||
|
def select_model_route(
|
||||||
|
routes: list[ModelRoute],
|
||||||
|
*,
|
||||||
|
required_capabilities: list[str] | None = None,
|
||||||
|
preferred_route_id: str | None = None,
|
||||||
|
) -> RouteSelection:
|
||||||
|
required = set(required_capabilities or [])
|
||||||
|
candidates = [route for route in routes if required.issubset(route.capabilities)]
|
||||||
|
if preferred_route_id:
|
||||||
|
preferred = [route for route in candidates if route.key == preferred_route_id or route.route_id == preferred_route_id]
|
||||||
|
if preferred:
|
||||||
|
candidates = preferred
|
||||||
|
candidates = sorted(candidates, key=lambda route: (route.status != SUPPORTED, route.priority, route.key))
|
||||||
|
if not candidates:
|
||||||
|
return RouteSelection(None, UNCONFIRMED, "no route advertises required capabilities", [])
|
||||||
|
selected = candidates[0]
|
||||||
|
if selected.status == SUPPORTED:
|
||||||
|
return RouteSelection(selected, SUPPORTED, candidates=candidates)
|
||||||
|
if selected.status == UNSUPPORTED:
|
||||||
|
return RouteSelection(None, UNSUPPORTED, "best matching route is unsupported", candidates)
|
||||||
|
return RouteSelection(None, UNCONFIRMED, "best matching route is unconfirmed", candidates)
|
||||||
|
|
||||||
|
|
||||||
|
def route_from_capability_profile(profile: dict[str, Any]) -> ModelRoute:
|
||||||
|
capabilities = profile.get("capabilities") or {}
|
||||||
|
supports = capabilities.get("supports", capabilities if isinstance(capabilities, list) else [])
|
||||||
|
return ModelRoute(
|
||||||
|
provider_id=str(profile.get("provider_id") or ""),
|
||||||
|
model_id=str(profile.get("model_id") or ""),
|
||||||
|
route_id=profile.get("route_id"),
|
||||||
|
status=str(profile.get("status") or UNCONFIRMED),
|
||||||
|
capabilities={str(item) for item in supports},
|
||||||
|
priority=int(profile.get("priority") or 100),
|
||||||
|
)
|
||||||
|
|
|
||||||
|
|
@ -1 +1,93 @@
|
||||||
"""Prompt composition pipeline placeholder."""
|
"""Prompt composition helpers."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
from dataclasses import dataclass
|
||||||
|
from typing import Any, Mapping
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass(frozen=True)
|
||||||
|
class PromptPart:
|
||||||
|
text: str
|
||||||
|
weight: float = 1.0
|
||||||
|
enabled: bool = True
|
||||||
|
|
||||||
|
def render(self) -> str:
|
||||||
|
text = self.text.strip()
|
||||||
|
if not text:
|
||||||
|
return ""
|
||||||
|
if self.weight == 1:
|
||||||
|
return text
|
||||||
|
return f"({text}:{self.weight:g})"
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass(frozen=True)
|
||||||
|
class PromptResult:
|
||||||
|
prompt: str
|
||||||
|
negative_prompt: str
|
||||||
|
parts: list[str]
|
||||||
|
negative_parts: list[str]
|
||||||
|
|
||||||
|
def to_dict(self) -> dict[str, Any]:
|
||||||
|
return {
|
||||||
|
"prompt": self.prompt,
|
||||||
|
"negative_prompt": self.negative_prompt,
|
||||||
|
"parts": self.parts,
|
||||||
|
"negative_parts": self.negative_parts,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def compose_prompt(
|
||||||
|
parts: list[str | PromptPart],
|
||||||
|
*,
|
||||||
|
negative_parts: list[str | PromptPart] | None = None,
|
||||||
|
variables: Mapping[str, Any] | None = None,
|
||||||
|
) -> PromptResult:
|
||||||
|
rendered_parts = _render_parts(parts, variables or {})
|
||||||
|
rendered_negative = _render_parts(negative_parts or [], variables or {})
|
||||||
|
return PromptResult(
|
||||||
|
prompt=", ".join(rendered_parts),
|
||||||
|
negative_prompt=", ".join(rendered_negative),
|
||||||
|
parts=rendered_parts,
|
||||||
|
negative_parts=rendered_negative,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def merge_prompt_sections(*sections: Mapping[str, Any]) -> PromptResult:
|
||||||
|
parts: list[str | PromptPart] = []
|
||||||
|
negative_parts: list[str | PromptPart] = []
|
||||||
|
variables: dict[str, Any] = {}
|
||||||
|
for section in sections:
|
||||||
|
variables.update(section.get("variables") or {})
|
||||||
|
parts.extend(_as_list(section.get("prompt") or section.get("parts")))
|
||||||
|
negative_parts.extend(_as_list(section.get("negative_prompt") or section.get("negative_parts")))
|
||||||
|
return compose_prompt(parts, negative_parts=negative_parts, variables=variables)
|
||||||
|
|
||||||
|
|
||||||
|
def _render_parts(parts: list[str | PromptPart], variables: Mapping[str, Any]) -> list[str]:
|
||||||
|
rendered: list[str] = []
|
||||||
|
seen: set[str] = set()
|
||||||
|
for part in parts:
|
||||||
|
prompt_part = part if isinstance(part, PromptPart) else PromptPart(str(part))
|
||||||
|
if not prompt_part.enabled:
|
||||||
|
continue
|
||||||
|
text = _substitute(prompt_part.render(), variables)
|
||||||
|
if text and text not in seen:
|
||||||
|
rendered.append(text)
|
||||||
|
seen.add(text)
|
||||||
|
return rendered
|
||||||
|
|
||||||
|
|
||||||
|
def _substitute(text: str, variables: Mapping[str, Any]) -> str:
|
||||||
|
rendered = text
|
||||||
|
for key, value in variables.items():
|
||||||
|
rendered = rendered.replace("{" + str(key) + "}", str(value))
|
||||||
|
return rendered.strip()
|
||||||
|
|
||||||
|
|
||||||
|
def _as_list(value: Any) -> list[Any]:
|
||||||
|
if value is None:
|
||||||
|
return []
|
||||||
|
if isinstance(value, list):
|
||||||
|
return value
|
||||||
|
return [value]
|
||||||
|
|
|
||||||
|
|
@ -1 +1,112 @@
|
||||||
"""Generation queue manager placeholder."""
|
"""In-memory generation queue primitives."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
from collections import deque
|
||||||
|
from dataclasses import dataclass, field
|
||||||
|
from datetime import datetime, timezone
|
||||||
|
from typing import Any
|
||||||
|
from uuid import uuid4
|
||||||
|
|
||||||
|
from core.fsm import task_transition
|
||||||
|
|
||||||
|
|
||||||
|
def _now() -> str:
|
||||||
|
return datetime.now(timezone.utc).isoformat()
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass
|
||||||
|
class QueueItem:
|
||||||
|
task_id: str
|
||||||
|
payload: dict[str, Any]
|
||||||
|
status: str = "queued"
|
||||||
|
idempotency_key: str | None = None
|
||||||
|
attempts: int = 0
|
||||||
|
error_message: str | None = None
|
||||||
|
created_at: str = field(default_factory=_now)
|
||||||
|
updated_at: str = field(default_factory=_now)
|
||||||
|
|
||||||
|
def to_dict(self) -> dict[str, Any]:
|
||||||
|
return {
|
||||||
|
"task_id": self.task_id,
|
||||||
|
"payload": self.payload,
|
||||||
|
"status": self.status,
|
||||||
|
"idempotency_key": self.idempotency_key,
|
||||||
|
"attempts": self.attempts,
|
||||||
|
"error_message": self.error_message,
|
||||||
|
"created_at": self.created_at,
|
||||||
|
"updated_at": self.updated_at,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
class QueueManager:
|
||||||
|
def __init__(self):
|
||||||
|
self._pending: deque[str] = deque()
|
||||||
|
self._items: dict[str, QueueItem] = {}
|
||||||
|
self._idempotency_index: dict[str, str] = {}
|
||||||
|
|
||||||
|
def enqueue(self, payload: dict[str, Any], *, idempotency_key: str | None = None) -> QueueItem:
|
||||||
|
if idempotency_key and idempotency_key in self._idempotency_index:
|
||||||
|
return self._items[self._idempotency_index[idempotency_key]]
|
||||||
|
item = QueueItem(
|
||||||
|
task_id=str(payload.get("task_id") or f"task_{uuid4().hex}"),
|
||||||
|
payload=dict(payload),
|
||||||
|
idempotency_key=idempotency_key,
|
||||||
|
)
|
||||||
|
self._items[item.task_id] = item
|
||||||
|
if idempotency_key:
|
||||||
|
self._idempotency_index[idempotency_key] = item.task_id
|
||||||
|
self._pending.append(item.task_id)
|
||||||
|
return item
|
||||||
|
|
||||||
|
def dequeue(self) -> QueueItem | None:
|
||||||
|
while self._pending:
|
||||||
|
task_id = self._pending.popleft()
|
||||||
|
item = self._items.get(task_id)
|
||||||
|
if item and item.status == "queued":
|
||||||
|
self._set_status(item, "running")
|
||||||
|
item.attempts += 1
|
||||||
|
return item
|
||||||
|
return None
|
||||||
|
|
||||||
|
def complete(self, task_id: str, result: dict[str, Any] | None = None) -> QueueItem:
|
||||||
|
item = self.get(task_id)
|
||||||
|
item.payload = {**item.payload, "result": result or {}}
|
||||||
|
self._set_status(item, "succeeded")
|
||||||
|
item.error_message = None
|
||||||
|
return item
|
||||||
|
|
||||||
|
def fail(self, task_id: str, error_message: str, *, dead_letter: bool = False) -> QueueItem:
|
||||||
|
item = self.get(task_id)
|
||||||
|
self._set_status(item, "failed")
|
||||||
|
item.error_message = error_message
|
||||||
|
if dead_letter:
|
||||||
|
self._set_status(item, "dead_letter")
|
||||||
|
return item
|
||||||
|
|
||||||
|
def retry(self, task_id: str) -> QueueItem:
|
||||||
|
item = self.get(task_id)
|
||||||
|
self._set_status(item, "queued")
|
||||||
|
item.error_message = None
|
||||||
|
if task_id not in self._pending:
|
||||||
|
self._pending.append(task_id)
|
||||||
|
return item
|
||||||
|
|
||||||
|
def get(self, task_id: str) -> QueueItem:
|
||||||
|
item = self._items.get(task_id)
|
||||||
|
if item is None:
|
||||||
|
raise KeyError(task_id)
|
||||||
|
return item
|
||||||
|
|
||||||
|
def summary(self) -> dict[str, int]:
|
||||||
|
counts = {"queued": 0, "running": 0, "succeeded": 0, "failed": 0, "dead_letter": 0}
|
||||||
|
for item in self._items.values():
|
||||||
|
counts[item.status] = counts.get(item.status, 0) + 1
|
||||||
|
return counts
|
||||||
|
|
||||||
|
def _set_status(self, item: QueueItem, status: str) -> None:
|
||||||
|
transition = task_transition(item.status, status)
|
||||||
|
if not transition.allowed:
|
||||||
|
raise ValueError(transition.reason)
|
||||||
|
item.status = transition.target
|
||||||
|
item.updated_at = _now()
|
||||||
|
|
|
||||||
|
|
@ -1 +1,55 @@
|
||||||
"""Secret management placeholder."""
|
"""Secret redaction and environment reference helpers."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import os
|
||||||
|
from dataclasses import dataclass
|
||||||
|
from typing import Any, Mapping
|
||||||
|
|
||||||
|
|
||||||
|
MASK = "***MASKED***"
|
||||||
|
SECRET_KEY_PARTS = ("api_key", "apikey", "token", "secret", "password", "dsn", "credential")
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass(frozen=True)
|
||||||
|
class SecretRef:
|
||||||
|
name: str
|
||||||
|
is_set: bool
|
||||||
|
|
||||||
|
def to_dict(self) -> dict[str, Any]:
|
||||||
|
return {"name": self.name, "is_set": self.is_set, "value": MASK if self.is_set else None}
|
||||||
|
|
||||||
|
|
||||||
|
def is_secret_key(path: str) -> bool:
|
||||||
|
lowered = path.lower()
|
||||||
|
if lowered.endswith("_set"):
|
||||||
|
return False
|
||||||
|
return any(part in lowered for part in SECRET_KEY_PARTS)
|
||||||
|
|
||||||
|
|
||||||
|
def redact(value: Any, path: str = "") -> Any:
|
||||||
|
if isinstance(value, Mapping):
|
||||||
|
redacted: dict[str, Any] = {}
|
||||||
|
for key, child in value.items():
|
||||||
|
child_path = f"{path}.{key}" if path else str(key)
|
||||||
|
redacted[str(key)] = MASK if is_secret_key(child_path) and child else redact(child, child_path)
|
||||||
|
return redacted
|
||||||
|
if isinstance(value, list):
|
||||||
|
return [redact(item, path) for item in value]
|
||||||
|
return value
|
||||||
|
|
||||||
|
|
||||||
|
def env_ref(name: str) -> SecretRef:
|
||||||
|
normalized = str(name or "").strip()
|
||||||
|
if not normalized:
|
||||||
|
raise ValueError("secret env name is required")
|
||||||
|
return SecretRef(name=normalized, is_set=bool(os.environ.get(normalized)))
|
||||||
|
|
||||||
|
|
||||||
|
def resolve_env_value(reference: str) -> str | None:
|
||||||
|
normalized = str(reference or "").strip()
|
||||||
|
if normalized.startswith("env:"):
|
||||||
|
normalized = normalized[4:]
|
||||||
|
if not normalized:
|
||||||
|
return None
|
||||||
|
return os.environ.get(normalized)
|
||||||
|
|
|
||||||
135
tests/test_core_modules.py
普通文件
135
tests/test_core_modules.py
普通文件
|
|
@ -0,0 +1,135 @@
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import os
|
||||||
|
import unittest
|
||||||
|
|
||||||
|
from core.event_bus import EventBus
|
||||||
|
from core.fsm import node_transition, task_transition, workflow_transition
|
||||||
|
from core.model_router import ModelRoute, route_from_capability_profile, select_model_route
|
||||||
|
from core.prompt_pipeline import PromptPart, compose_prompt, merge_prompt_sections
|
||||||
|
from core.queue_manager import QueueManager
|
||||||
|
from core.secret_service import MASK, env_ref, redact, resolve_env_value
|
||||||
|
|
||||||
|
|
||||||
|
class EventBusTests(unittest.TestCase):
|
||||||
|
def test_publish_notifies_specific_and_wildcard_handlers(self):
|
||||||
|
bus = EventBus()
|
||||||
|
received = []
|
||||||
|
|
||||||
|
bus.subscribe("workflow.started", lambda event: received.append(("specific", event.event_type)))
|
||||||
|
bus.subscribe("*", lambda event: received.append(("wildcard", event.payload["workflow_id"])))
|
||||||
|
|
||||||
|
event = bus.publish("workflow.started", {"workflow_id": "workflow_001"})
|
||||||
|
|
||||||
|
self.assertEqual(event.event_type, "workflow.started")
|
||||||
|
self.assertEqual(received, [("specific", "workflow.started"), ("wildcard", "workflow_001")])
|
||||||
|
self.assertEqual(bus.history("workflow.started")[0].event_id, event.event_id)
|
||||||
|
|
||||||
|
|
||||||
|
class FsmTests(unittest.TestCase):
|
||||||
|
def test_known_state_transitions_are_checked(self):
|
||||||
|
self.assertTrue(workflow_transition("draft", "running").allowed)
|
||||||
|
self.assertFalse(workflow_transition("archived", "running").allowed)
|
||||||
|
self.assertTrue(node_transition("failed", "queued").allowed)
|
||||||
|
self.assertFalse(task_transition("succeeded", "queued").allowed)
|
||||||
|
|
||||||
|
|
||||||
|
class QueueManagerTests(unittest.TestCase):
|
||||||
|
def test_queue_is_idempotent_and_tracks_retry(self):
|
||||||
|
queue = QueueManager()
|
||||||
|
first = queue.enqueue({"prompt": "portrait"}, idempotency_key="idem_001")
|
||||||
|
second = queue.enqueue({"prompt": "portrait"}, idempotency_key="idem_001")
|
||||||
|
|
||||||
|
self.assertEqual(first.task_id, second.task_id)
|
||||||
|
running = queue.dequeue()
|
||||||
|
self.assertIsNotNone(running)
|
||||||
|
self.assertEqual(running.status, "running")
|
||||||
|
|
||||||
|
failed = queue.fail(running.task_id, "mock failure")
|
||||||
|
self.assertEqual(failed.status, "failed")
|
||||||
|
retried = queue.retry(running.task_id)
|
||||||
|
self.assertEqual(retried.status, "queued")
|
||||||
|
self.assertEqual(queue.summary()["queued"], 1)
|
||||||
|
|
||||||
|
|
||||||
|
class PromptPipelineTests(unittest.TestCase):
|
||||||
|
def test_compose_prompt_dedupes_and_substitutes_variables(self):
|
||||||
|
result = compose_prompt(
|
||||||
|
["portrait of {name}", "portrait of {name}", PromptPart("soft light", weight=1.2)],
|
||||||
|
negative_parts=["low quality"],
|
||||||
|
variables={"name": "Nova"},
|
||||||
|
)
|
||||||
|
|
||||||
|
self.assertEqual(result.prompt, "portrait of Nova, (soft light:1.2)")
|
||||||
|
self.assertEqual(result.negative_prompt, "low quality")
|
||||||
|
|
||||||
|
def test_merge_prompt_sections_combines_positive_and_negative(self):
|
||||||
|
result = merge_prompt_sections(
|
||||||
|
{"prompt": "anime", "negative_prompt": "blur"},
|
||||||
|
{"parts": ["clean line"], "negative_parts": ["noise"]},
|
||||||
|
)
|
||||||
|
|
||||||
|
self.assertEqual(result.parts, ["anime", "clean line"])
|
||||||
|
self.assertEqual(result.negative_parts, ["blur", "noise"])
|
||||||
|
|
||||||
|
|
||||||
|
class ModelRouterTests(unittest.TestCase):
|
||||||
|
def test_unconfirmed_route_is_not_treated_as_supported(self):
|
||||||
|
selection = select_model_route(
|
||||||
|
[ModelRoute("local", "draft", status="unconfirmed", capabilities={"text_to_image"})],
|
||||||
|
required_capabilities=["text_to_image"],
|
||||||
|
)
|
||||||
|
|
||||||
|
self.assertFalse(selection.valid)
|
||||||
|
self.assertEqual(selection.status, "unconfirmed")
|
||||||
|
|
||||||
|
def test_supported_route_wins_by_priority(self):
|
||||||
|
selection = select_model_route(
|
||||||
|
[
|
||||||
|
ModelRoute("slow", "model", status="confirmed_supported", capabilities={"text_to_image"}, priority=20),
|
||||||
|
ModelRoute("fast", "model", status="confirmed_supported", capabilities={"text_to_image"}, priority=5),
|
||||||
|
],
|
||||||
|
required_capabilities=["text_to_image"],
|
||||||
|
)
|
||||||
|
|
||||||
|
self.assertTrue(selection.valid)
|
||||||
|
self.assertEqual(selection.selected.provider_id, "fast")
|
||||||
|
|
||||||
|
def test_route_can_be_built_from_capability_profile(self):
|
||||||
|
route = route_from_capability_profile(
|
||||||
|
{
|
||||||
|
"provider_id": "p",
|
||||||
|
"model_id": "m",
|
||||||
|
"status": "confirmed_supported",
|
||||||
|
"capabilities": {"supports": ["image_edit"]},
|
||||||
|
}
|
||||||
|
)
|
||||||
|
|
||||||
|
self.assertEqual(route.capabilities, {"image_edit"})
|
||||||
|
|
||||||
|
|
||||||
|
class SecretServiceTests(unittest.TestCase):
|
||||||
|
def test_redact_masks_nested_secret_values(self):
|
||||||
|
redacted = redact(
|
||||||
|
{
|
||||||
|
"database": {"dsn": "postgresql://secret"},
|
||||||
|
"security": {"integration_token_set": True, "integration_token": "abc"},
|
||||||
|
}
|
||||||
|
)
|
||||||
|
|
||||||
|
self.assertEqual(redacted["database"]["dsn"], MASK)
|
||||||
|
self.assertTrue(redacted["security"]["integration_token_set"])
|
||||||
|
self.assertEqual(redacted["security"]["integration_token"], MASK)
|
||||||
|
|
||||||
|
def test_env_ref_reports_presence_without_value(self):
|
||||||
|
os.environ["IMAGESTUDIO_TEST_SECRET"] = "secret-value"
|
||||||
|
try:
|
||||||
|
reference = env_ref("IMAGESTUDIO_TEST_SECRET")
|
||||||
|
self.assertEqual(reference.to_dict()["value"], MASK)
|
||||||
|
self.assertEqual(resolve_env_value("env:IMAGESTUDIO_TEST_SECRET"), "secret-value")
|
||||||
|
finally:
|
||||||
|
os.environ.pop("IMAGESTUDIO_TEST_SECRET", None)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
unittest.main()
|
||||||
正在加载…
添加表格
在新工单中引用