比较提交

..

没有共同的提交。36a3c1708c18e827c4831745497ce67ed62a429e 和 b14fc862d1ee10d61fe599d76b62257a958e87cf 的历史完全不同。

共有 30 个文件被更改,包括 9 次插入 和 1753 次删除

查看文件

@ -29,7 +29,6 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("GET", "profiles", "backend.routes.profile_routes.list_profiles", "read"),
RouteSpec("POST", "profiles", "backend.routes.profile_routes.create_profile", "write"),
RouteSpec("POST", "profiles/quick-draft", "backend.routes.profile_routes.create_quick_profile_draft", "read"),
RouteSpec("POST", "profiles/quick-draft/save", "backend.routes.profile_routes.save_quick_profile_draft", "write"),
RouteSpec("GET", "profiles/{profile_id}", "backend.routes.profile_routes.get_profile", "read"),
RouteSpec("PUT", "profiles/{profile_id}", "backend.routes.profile_routes.update_profile", "write"),
RouteSpec("DELETE", "profiles/{profile_id}", "backend.routes.profile_routes.delete_profile", "write"),
@ -41,7 +40,6 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("POST", "workflows/{workflow_id}/start", "backend.routes.workflow_routes.start_workflow", "write"),
RouteSpec("POST", "workflows/{workflow_id}/cancel", "backend.routes.workflow_routes.cancel_workflow", "write"),
RouteSpec("POST", "workflows/{workflow_id}/archive", "backend.routes.workflow_routes.archive_workflow", "write"),
RouteSpec("POST", "workflows/{workflow_id}/execute-character", "backend.routes.workflow_routes.execute_character_workflow", "write"),
RouteSpec("GET", "workflows/{workflow_id}/nodes", "backend.routes.node_routes.list_workflow_nodes", "read"),
RouteSpec("POST", "workflows/{workflow_id}/nodes", "backend.routes.node_routes.create_workflow_node", "write"),
RouteSpec("GET", "workflows/{workflow_id}/branches", "backend.routes.branch_routes.list_workflow_branches", "read"),
@ -49,7 +47,6 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("POST", "workflows/{workflow_id}/switch-branch", "backend.routes.branch_routes.switch_workflow_branch", "write"),
RouteSpec("GET", "workflows/{workflow_id}/history", "backend.routes.history_routes.list_workflow_history", "read"),
RouteSpec("GET", "nodes/{node_id}", "backend.routes.node_routes.get_node", "read"),
RouteSpec("GET", "nodes/{node_id}/dependency-context", "backend.routes.node_routes.get_node_dependency_context", "read"),
RouteSpec("PUT", "nodes/{node_id}", "backend.routes.node_routes.update_node", "write"),
RouteSpec("POST", "nodes/{node_id}/generate", "backend.routes.node_routes.generate_node", "write"),
RouteSpec("POST", "nodes/{node_id}/retry", "backend.routes.node_routes.retry_node", "write"),
@ -60,7 +57,6 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("GET", "review/policy", "backend.routes.review_routes.get_review_policy", "read"),
RouteSpec("POST", "review/policy/validate", "backend.routes.review_routes.validate_review_policy", "config"),
RouteSpec("POST", "review/policy/save", "backend.routes.review_routes.save_review_policy", "config"),
RouteSpec("POST", "prompts/expand", "backend.routes.prompt_routes.expand_prompt", "read"),
RouteSpec("GET", "nodes/{node_id}/review", "backend.routes.review_routes.review_node", "read"),
RouteSpec("GET", "nodes/{node_id}/images", "backend.routes.image_routes.list_node_images", "read"),
RouteSpec("GET", "workflows/{workflow_id}/review", "backend.routes.review_routes.review_workflow", "read"),
@ -68,7 +64,6 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("POST", "images/{image_id}/select", "backend.routes.image_routes.select_image", "write"),
RouteSpec("POST", "images/{image_id}/unselect", "backend.routes.image_routes.unselect_image", "write"),
RouteSpec("POST", "images/{image_id}/archive", "backend.routes.image_routes.archive_image", "write"),
RouteSpec("POST", "images/{image_id}/safe-delete", "backend.routes.image_routes.safe_delete_image", "write"),
RouteSpec("DELETE", "images/{image_id}", "backend.routes.image_routes.delete_image", "write"),
RouteSpec("GET", "jobs", "backend.routes.job_routes.list_jobs", "read"),
RouteSpec("GET", "jobs/{task_id}", "backend.routes.job_routes.get_job", "read"),
@ -92,8 +87,6 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("GET", "storage/status", "backend.routes.storage_routes.get_storage_status", "read"),
RouteSpec("POST", "storage/migrate", "backend.routes.storage_routes.migrate_storage", "config"),
RouteSpec("GET", "media/sign", "backend.routes.media_routes.sign_media", "read"),
RouteSpec("GET", "media/index", "backend.routes.media_routes.index_media", "read"),
RouteSpec("GET", "media/orphans", "backend.routes.media_routes.scan_orphan_media", "read"),
RouteSpec("GET", "media/fetch", "backend.routes.media_routes.fetch_media", "public_token"),
RouteSpec("GET", "material-categories", "backend.routes.material_routes.list_material_categories", "read"),
RouteSpec("POST", "material-categories", "backend.routes.material_routes.create_material_category", "materials"),

查看文件

@ -7,7 +7,6 @@ from typing import Any
from backend.dto.common import ApiError
from backend.dto.image_dto import GenerationImage
from backend.routes.common import handle_request
from backend.services.deletion_safety_service import DeletionSafetyService
from backend.services.image_service import ImageService
from backend.services.media_service import MediaService
from core.audit_service import AuditService
@ -117,31 +116,6 @@ def delete_image(
return handle_request(ctx, action)
def safe_delete_image(
ctx: RequestContext,
image_id: str,
payload: dict[str, Any] | None = None,
service: DeletionSafetyService | None = None,
image_service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
params = payload or {}
resolved_image_service = image_service or _create_image_service()
resolved_media_service = media_service or MediaService()
deletion_service = service or DeletionSafetyService(resolved_image_service, resolved_media_service)
def action() -> dict[str, Any]:
require_write(ctx)
return deletion_service.delete_image(
image_id,
ctx,
dry_run=_as_bool(params.get("dry_run", True)),
delete_files=_as_bool(params.get("delete_files")),
)
return handle_request(ctx, action)
def _create_image_service() -> ImageService:
database = Database(load_database_settings())
return ImageService(

查看文件

@ -6,12 +6,9 @@ from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.routes.common import handle_request
from backend.services.media_index_service import MediaIndexService
from backend.services.media_service import MediaService
from backend.services.orphan_media_service import OrphanMediaService
from core.identity import RequestContext
from core.security import require_authenticated
from database.db_helper import Database, load_database_settings
def sign_media(
@ -45,56 +42,3 @@ def fetch_media(
return media_service.fetch_media(token)
return handle_request(ctx, action)
def index_media(
ctx: RequestContext,
query: dict[str, Any] | None = None,
service: MediaIndexService | None = None,
) -> dict:
params = query or {}
index_service = service or MediaIndexService(MediaService())
def action() -> dict[str, Any]:
require_authenticated(ctx)
return index_service.index_files(
root=_optional_str(params.get("root")),
limit=_int_or_default(params.get("limit"), 500),
)
return handle_request(ctx, action)
def scan_orphan_media(
ctx: RequestContext,
query: dict[str, Any] | None = None,
service: OrphanMediaService | None = None,
) -> dict:
params = query or {}
orphan_service = service or OrphanMediaService(
Database(load_database_settings()),
MediaIndexService(MediaService()),
)
def action() -> dict[str, Any]:
require_authenticated(ctx)
return orphan_service.scan(
root=_optional_str(params.get("root")),
limit=_int_or_default(params.get("limit"), 500),
)
return handle_request(ctx, action)
def _optional_str(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _int_or_default(value: Any, default: int) -> int:
try:
return int(value)
except (TypeError, ValueError):
return default

查看文件

@ -12,7 +12,6 @@ from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService
from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.model_provider_service import ModelProviderService
from backend.services.node_dependency_context_service import NodeDependencyContextService
from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
@ -69,28 +68,6 @@ def get_node(
return handle_request(ctx, action)
def get_node_dependency_context(
ctx: RequestContext,
node_id: str,
query: dict[str, Any] | None = None,
service: NodeDependencyContextService | None = None,
workflow_service: WorkflowService | None = None,
image_service: ImageService | None = None,
) -> dict:
params = query or {}
if service:
context_service = service
else:
resolved_image_service, resolved_workflow_service = _resolve_services(image_service, workflow_service)
context_service = NodeDependencyContextService(resolved_workflow_service, resolved_image_service)
def action() -> dict[str, Any]:
require_authenticated(ctx)
return context_service.get_context(node_id, include_draft=_bool(params.get("include_draft")))
return handle_request(ctx, action)
def update_node(
ctx: RequestContext,
node_id: str,
@ -258,9 +235,3 @@ def _create_generation_service() -> GenerationService:
model_provider_service=model_provider_service,
event_bus=event_bus,
)
def _bool(value: Any) -> bool:
if isinstance(value, str):
return value.strip().lower() in {"1", "true", "yes", "on"}
return bool(value)

查看文件

@ -115,22 +115,6 @@ def create_quick_profile_draft(
return handle_request(ctx, action)
def save_quick_profile_draft(
ctx: RequestContext,
payload: dict[str, Any],
service: QuickProfileService | None = None,
profile_service: ProfileService | None = None,
) -> dict:
quick_service = service or QuickProfileService()
resolved_profile_service = profile_service or _create_profile_service()
def action() -> dict:
require_write(ctx)
return quick_service.save_draft(payload, resolved_profile_service, ctx)
return handle_request(ctx, action)
def _create_profile_service() -> ProfileService:
database = Database(load_database_settings())
return ProfileService(

查看文件

@ -1,25 +0,0 @@
"""Prompt expansion route handlers."""
from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.prompt_expansion_service import PromptExpansionService
from core.identity import RequestContext
from core.security import require_authenticated
def expand_prompt(
ctx: RequestContext,
payload: dict[str, Any] | None = None,
service: PromptExpansionService | None = None,
) -> dict:
prompt_service = service or PromptExpansionService()
request_payload = payload or {}
def action() -> dict[str, Any]:
require_authenticated(ctx)
return prompt_service.expand_payload(request_payload)
return handle_request(ctx, action)

查看文件

@ -5,7 +5,6 @@ from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.character_workflow_service import CharacterWorkflowService
from backend.services.event_stream_service import get_default_event_bus
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
@ -113,20 +112,6 @@ def _set_workflow_status(
return handle_request(ctx, action)
def execute_character_workflow(
ctx: RequestContext,
workflow_id: str,
service: CharacterWorkflowService | None = None,
) -> dict:
character_service = service or CharacterWorkflowService(_create_workflow_service())
def action() -> dict:
require_write(ctx)
return character_service.execute_workflow(workflow_id, ctx)
return handle_request(ctx, action)
def _create_workflow_service() -> WorkflowService:
database = Database(load_database_settings())
return WorkflowService(

查看文件

@ -1,141 +0,0 @@
"""Deterministic execution helpers for character workflows."""
from __future__ import annotations
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.dto.profile_dto import CharacterProfile
from backend.dto.workflow_dto import ProfileWorkflow, WorkflowNode
from backend.services.workflow_service import WorkflowService
from core.identity import RequestContext
CHARACTER_WORKFLOW_TYPES = {"character_fast", "character_gradual"}
class CharacterWorkflowService:
def __init__(self, workflow_service: WorkflowService):
self.workflow_service = workflow_service
def execute_workflow(self, workflow_id: str, ctx: RequestContext) -> dict[str, Any]:
detail = self.workflow_service.get_workflow(workflow_id)
workflow = detail.workflow
if workflow.workflow_type not in CHARACTER_WORKFLOW_TYPES:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"workflow is not a character workflow",
{"workflow_id": workflow_id, "workflow_type": workflow.workflow_type},
)
profile = self.workflow_service.profile_repository.get(workflow.profile_id)
if profile is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "profile not found", {"profile_id": workflow.profile_id})
active_nodes = [
node
for node in sorted(detail.nodes, key=lambda item: item.sort_order)
if node.branch_name == workflow.current_branch
]
if not active_nodes:
raise ApiError(ErrorCode.VALIDATION_FAILED, "workflow has no executable nodes", {"workflow_id": workflow_id})
running_workflow = workflow
if workflow.status != "running":
running_workflow = self.workflow_service.update_workflow(workflow_id, {"status": "running"}, ctx)
completed_nodes: list[WorkflowNode] = []
prompt_context: list[str] = []
for node in active_nodes:
prompt = _node_prompt(profile, node, running_workflow, prompt_context)
negative_prompt = _negative_prompt(profile, node)
completed = self.workflow_service.update_node(
node.node_id,
{
"status": "completed",
"prompt": prompt,
"negative_prompt": negative_prompt,
"metadata": {
**node.metadata,
"execution": {
"executor": "character_workflow",
"workflow_type": workflow.workflow_type,
"context_prompts": len(prompt_context),
},
},
},
ctx,
)
completed_nodes.append(completed)
prompt_context.append(prompt)
completed_workflow = self.workflow_service.update_workflow(
workflow_id,
{
"status": "completed",
"current_node_id": completed_nodes[-1].node_id,
"metadata": {
**running_workflow.metadata,
"character_execution": {
"executor": "character_workflow",
"workflow_type": workflow.workflow_type,
"completed_node_ids": [node.node_id for node in completed_nodes],
},
},
},
ctx,
)
return {
"workflow": completed_workflow.to_dict(),
"nodes": [node.to_dict() for node in completed_nodes],
"completed_node_ids": [node.node_id for node in completed_nodes],
}
def _node_prompt(
profile: CharacterProfile,
node: WorkflowNode,
workflow: ProfileWorkflow,
prompt_context: list[str],
) -> str:
parts = [
profile.name,
profile.base_prompt,
profile.appearance_prompt,
profile.style_prompt,
_step_instruction(workflow.workflow_type, node.node_key),
node.prompt,
]
if prompt_context:
parts.append(f"consistency reference: {prompt_context[-1]}")
return ", ".join(_unique_text(parts))
def _negative_prompt(profile: CharacterProfile, node: WorkflowNode) -> str:
return ", ".join(_unique_text([profile.negative_prompt, node.negative_prompt, "low quality, blurry"]))
def _step_instruction(workflow_type: str, node_key: str) -> str:
fast = {
"fast_profile": "condensed character design brief",
"fast_candidates": "candidate batch, varied composition, keep identity consistent",
"fast_final": "final selected character illustration, production ready",
}
gradual = {
"profile_brief": "core identity and visual anchors",
"headshot": "headshot, face, hair, eyes, expression",
"half_body": "half body, upper outfit, posture and silhouette",
"full_body": "full body, complete outfit and proportions",
"expression_sheet": "expression sheet with reusable emotions",
"pose_sheet": "pose sheet with action variants",
"style_lock": "style consistency lock and final rendering rules",
"final_pack": "final character pack, accepted images and reusable metadata",
}
table = fast if workflow_type == "character_fast" else gradual
return table.get(node_key, node_key.replace("_", " "))
def _unique_text(values: list[Any]) -> list[str]:
result: list[str] = []
seen: set[str] = set()
for value in values:
text = str(value or "").strip()
if text and text not in seen:
result.append(text)
seen.add(text)
return result

查看文件

@ -1,75 +0,0 @@
"""Safe deletion planners for media-backed records."""
from __future__ import annotations
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.services.image_service import ImageService
from backend.services.media_service import MediaService
from core.identity import RequestContext
class DeletionSafetyService:
def __init__(self, image_service: ImageService, media_service: MediaService):
self.image_service = image_service
self.media_service = media_service
def plan_image_delete(self, image_id: str, *, delete_files: bool = False) -> dict[str, Any]:
image = self.image_service.get_image(image_id)
files = [_file_entry(uri) for uri in (image.image_uri, image.thumbnail_uri) if uri]
return {
"target_type": "generation_image",
"image_id": image.image_id,
"metadata_delete": True,
"delete_files": bool(delete_files),
"requires_explicit_file_delete": not bool(delete_files),
"files": [self._hydrate_entry(entry) for entry in files],
}
def delete_image(
self,
image_id: str,
ctx: RequestContext,
*,
dry_run: bool = True,
delete_files: bool = False,
) -> dict[str, Any]:
plan = self.plan_image_delete(image_id, delete_files=delete_files)
if dry_run:
return {**plan, "dry_run": True, "status": "planned", "deleted_files": []}
deleted_files = []
deleted = self.image_service.delete_image_metadata(image_id, ctx)
if delete_files:
for file_entry in plan["files"]:
if self._delete_storage_file(str(file_entry["uri"])):
deleted_files.append(file_entry["uri"])
return {
**plan,
"dry_run": False,
"status": "completed",
"deleted_image": deleted.to_dict(),
"deleted_files": deleted_files,
}
def _hydrate_entry(self, entry: dict[str, Any]) -> dict[str, Any]:
try:
path = self.media_service.storage.resolve_uri(entry["uri"])
except ApiError:
return {**entry, "exists": False, "bytes": 0}
if path.exists() and not path.is_file():
raise ApiError(ErrorCode.FORBIDDEN, "refusing to delete non-file media path", {"uri": entry["uri"]})
return {**entry, "exists": path.exists(), "bytes": path.stat().st_size if path.exists() else 0}
def _delete_storage_file(self, uri: str) -> bool:
path = self.media_service.storage.resolve_uri(uri)
if not path.exists():
return False
if not path.is_file():
raise ApiError(ErrorCode.FORBIDDEN, "refusing to delete non-file media path", {"uri": uri})
path.unlink()
return True
def _file_entry(uri: str) -> dict[str, Any]:
return {"uri": uri, "exists": False, "bytes": 0}

查看文件

@ -9,7 +9,6 @@ from backend.dto.job_dto import GenerationTask
from backend.services.cost_guard_service import CostGuardService
from backend.services.image_service import ImageService
from backend.services.model_provider_service import ModelProviderService
from backend.services.prompt_expansion_service import PromptExpansionService
from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService
from core.event_bus import EventBus
@ -26,7 +25,6 @@ class GenerationService:
single_flow_engine: SingleFlowEngine | None = None,
model_provider_service: ModelProviderService | None = None,
cost_guard_service: CostGuardService | None = None,
prompt_expansion_service: PromptExpansionService | None = None,
event_bus: EventBus | None = None,
):
self.workflow_service = workflow_service
@ -35,7 +33,6 @@ class GenerationService:
self.single_flow_engine = single_flow_engine or SingleFlowEngine()
self.model_provider_service = model_provider_service
self.cost_guard_service = cost_guard_service
self.prompt_expansion_service = prompt_expansion_service
self.event_bus = event_bus
def generate_node(self, node_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
@ -44,21 +41,11 @@ class GenerationService:
model_route = str(payload.get("model_route") or node.model_route or "image_low")
route_resolution = self._resolve_model_route(model_route)
cost_guard = self._check_cost_budget(payload, model_route, route_resolution)
prompt_expansion = self._expand_prompt(workflow.profile_id, node, payload)
generation_request = {
**payload,
"model_route": model_route,
"resolved_model_route": route_resolution,
**({"cost_guard": cost_guard} if cost_guard else {}),
**(
{
"prompt_expansion": prompt_expansion,
"expanded_prompt": prompt_expansion["prompt"],
"expanded_negative_prompt": prompt_expansion["negative_prompt"],
}
if prompt_expansion
else {}
),
}
idempotency_key = _optional_text(payload.get("idempotency_key"))
if idempotency_key:
@ -125,7 +112,6 @@ class GenerationService:
"image_uri": asset.image_uri,
"thumbnail_uri": asset.thumbnail_uri,
"positive_prompt": asset.positive_prompt,
"negative_prompt": asset.negative_prompt,
"model_route": asset.model_route,
"seed": asset.seed,
"width": asset.width,
@ -230,19 +216,6 @@ class GenerationService:
raise ApiError(ErrorCode.VALIDATION_FAILED, "generation budget exceeded", guard)
return guard
def _expand_prompt(
self,
profile_id: str,
node,
payload: dict[str, Any],
) -> dict[str, Any] | None:
if not self.prompt_expansion_service:
return None
profile = self.workflow_service.profile_repository.get(profile_id)
if profile is None:
return None
return self.prompt_expansion_service.expand_for_node(profile, node, payload)
def _publish(self, event_type: str, payload: dict[str, Any]) -> None:
if self.event_bus:
self.event_bus.publish(event_type, payload)

查看文件

@ -2,7 +2,6 @@
from __future__ import annotations
from pathlib import PurePosixPath
from typing import Any
from uuid import uuid4
@ -14,14 +13,6 @@ from database.repositories.material_repository import MaterialRepository
MATERIAL_STATUSES = {"pending_upload", "pending_recognition", "pending_confirm", "confirmed", "archived"}
MAX_UPLOAD_BYTES = 20 * 1024 * 1024
UPLOAD_SIZE_FIELDS = ("size_bytes", "content_length", "file_size", "size")
UPLOAD_ALLOWED_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp"}
UPLOAD_ALLOWED_CONTENT_TYPES = {
"image/jpeg": {".jpg", ".jpeg"},
"image/png": {".png"},
"image/webp": {".webp"},
}
class MaterialService:
@ -182,31 +173,21 @@ class MaterialService:
return self.update_material(material_id, {"recognition_status": "archived"}, ctx)
def upload_material(self, payload: dict[str, Any], ctx: RequestContext) -> Material:
image_uri = str(payload.get("image_uri") or "").strip()
image_uri = payload.get("image_uri")
if not image_uri:
raise ApiError(ErrorCode.VALIDATION_FAILED, "image_uri is required", {"field": "image_uri"})
filename = _normalize_upload_filename(payload.get("filename"))
content_type = _normalize_upload_content_type(payload.get("content_type"))
declared_size = _normalize_upload_size(payload)
upload_metadata = _normalize_upload_metadata(payload.get("metadata"))
extension = _validate_upload_file_type(filename=filename, image_uri=image_uri, content_type=content_type)
display_name = str(payload.get("display_name") or _display_name_from_filename(filename) or "Uploaded material").strip()
thumbnail_uri = str(payload.get("thumbnail_uri") or image_uri).strip()
display_name = str(payload.get("display_name") or payload.get("filename") or "Uploaded material").strip()
return self.create_material(
{
"category_id": payload.get("category_id"),
"display_name": display_name,
"image_uri": image_uri,
"thumbnail_uri": thumbnail_uri,
"thumbnail_uri": payload.get("thumbnail_uri") or image_uri,
"recognition_status": "pending_recognition",
"metadata": {
**upload_metadata,
"upload": {
"filename": filename,
"content_type": content_type,
"extension": extension,
"size_bytes": declared_size,
"max_size_bytes": MAX_UPLOAD_BYTES,
"filename": payload.get("filename"),
"content_type": payload.get("content_type"),
"mock": True,
}
},
@ -308,101 +289,3 @@ def _mock_tags(material: Material) -> list[str]:
if keyword in text:
tags.append(keyword)
return tags
def _normalize_upload_filename(value: Any) -> str | None:
if value is None:
return None
filename = str(value).strip()
if not filename:
return None
if len(filename) > 255 or filename in {".", ".."} or any(marker in filename for marker in ("/", "\\", "\x00", ":")):
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"filename must be a safe basename",
{"field": "filename"},
)
return filename
def _normalize_upload_content_type(value: Any) -> str | None:
if value is None:
return None
content_type = str(value).split(";", 1)[0].strip().lower()
if not content_type:
return None
if content_type not in UPLOAD_ALLOWED_CONTENT_TYPES:
raise ApiError(
ErrorCode.UNSUPPORTED_FILE_TYPE,
"unsupported upload content type",
{
"field": "content_type",
"content_type": content_type,
"allowed": sorted(UPLOAD_ALLOWED_CONTENT_TYPES),
},
)
return content_type
def _normalize_upload_size(payload: dict[str, Any]) -> int | None:
for field in UPLOAD_SIZE_FIELDS:
if field not in payload or payload[field] in (None, ""):
continue
try:
size = int(payload[field])
except (TypeError, ValueError):
raise ApiError(ErrorCode.VALIDATION_FAILED, "upload size must be an integer", {"field": field}) from None
if size < 0:
raise ApiError(ErrorCode.VALIDATION_FAILED, "upload size must not be negative", {"field": field})
if size > MAX_UPLOAD_BYTES:
raise ApiError(
ErrorCode.UPLOAD_TOO_LARGE,
"upload exceeds maximum allowed size",
{"field": field, "size_bytes": size, "max_size_bytes": MAX_UPLOAD_BYTES},
)
return size
return None
def _normalize_upload_metadata(value: Any) -> dict[str, Any]:
if value in (None, ""):
return {}
if not isinstance(value, dict):
raise ApiError(ErrorCode.VALIDATION_FAILED, "metadata must be an object", {"field": "metadata"})
return dict(value)
def _validate_upload_file_type(*, filename: str | None, image_uri: str, content_type: str | None) -> str:
extension = _suffix(filename) or _suffix(image_uri)
if not extension:
raise ApiError(
ErrorCode.UNSUPPORTED_FILE_TYPE,
"upload filename or image_uri must include a supported image extension",
{"field": "filename", "allowed": sorted(UPLOAD_ALLOWED_EXTENSIONS)},
)
if extension not in UPLOAD_ALLOWED_EXTENSIONS:
raise ApiError(
ErrorCode.UNSUPPORTED_FILE_TYPE,
"unsupported upload file extension",
{"field": "filename", "extension": extension, "allowed": sorted(UPLOAD_ALLOWED_EXTENSIONS)},
)
if content_type and extension not in UPLOAD_ALLOWED_CONTENT_TYPES[content_type]:
raise ApiError(
ErrorCode.UNSUPPORTED_FILE_TYPE,
"upload extension does not match content type",
{"field": "content_type", "extension": extension, "content_type": content_type},
)
return extension
def _suffix(value: str | None) -> str | None:
if not value:
return None
suffix = PurePosixPath(str(value).split("?", 1)[0]).suffix.lower()
return suffix or None
def _display_name_from_filename(filename: str | None) -> str | None:
if not filename:
return None
return PurePosixPath(filename).stem.replace("_", " ").strip() or None

查看文件

@ -1,15 +0,0 @@
"""Media file index service."""
from __future__ import annotations
from typing import Any
from backend.services.media_service import MediaService
class MediaIndexService:
def __init__(self, media_service: MediaService):
self.media_service = media_service
def index_files(self, *, root: str | None = None, limit: int = 500) -> dict[str, Any]:
return self.media_service.storage.index_files(root=root, limit=limit)

查看文件

@ -1,76 +0,0 @@
"""Build dependency context for workflow nodes."""
from __future__ import annotations
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.services.image_service import ImageService
from backend.services.workflow_service import WorkflowService
CONTEXT_STATUSES = {"completed", "selected"}
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)
dependencies = []
for node in sorted(detail.nodes, key=lambda item: item.sort_order):
if node.branch_name != target.branch_name or node.sort_order >= target.sort_order:
continue
if not include_draft and node.status not in CONTEXT_STATUSES:
continue
dependencies.append(self._node_context(node))
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)
]
return {
"workflow_id": target.workflow_id,
"node_id": target.node_id,
"branch_name": target.branch_name,
"dependency_count": len(dependencies),
"dependencies": dependencies,
"prompt_context": ", ".join(prompt_parts),
"selected_image_ids": selected_image_ids,
}
def _node_context(self, node) -> dict[str, Any]:
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": node.node_id,
"node_key": node.node_key,
"title": node.title,
"status": node.status,
"sort_order": node.sort_order,
"prompt": node.prompt,
"negative_prompt": node.negative_prompt,
"selected_image_id": node.selected_image_id,
"selected_image": selected_image,
"metadata": node.metadata,
}

查看文件

@ -1,46 +0,0 @@
"""Find storage files that are not referenced by database records."""
from __future__ import annotations
from typing import Any
from backend.services.media_index_service import MediaIndexService
from database.db_helper import Database
class OrphanMediaService:
def __init__(self, database: Database, media_index_service: MediaIndexService):
self.database = database
self.media_index_service = media_index_service
def scan(self, *, root: str | None = None, limit: int = 500) -> dict[str, Any]:
references = self._referenced_uris()
index = self.media_index_service.index_files(root=root, limit=limit)
orphans = [item for item in index["items"] if item["uri"] not in references]
return {
"root": root,
"total_indexed": len(index["items"]),
"total_files": index["total"],
"index_truncated": index["truncated"],
"referenced_uri_count": len(references),
"orphan_count": len(orphans),
"orphans": orphans,
}
def _referenced_uris(self) -> set[str]:
refs: set[str] = set()
conn = self.database.connect()
try:
for table, columns in (
("generation_images", ("image_uri", "thumbnail_uri")),
("materials", ("image_uri", "thumbnail_uri")),
("character_profiles", ("avatar_image_uri",)),
):
for row in conn.execute(f"SELECT {', '.join(columns)} FROM {table}").fetchall():
for column in columns:
uri = str(row[column] or "").strip()
if uri.startswith("storage://"):
refs.add(uri)
finally:
conn.close()
return refs

查看文件

@ -1,85 +0,0 @@
"""Prompt expansion service for generation requests."""
from __future__ import annotations
from typing import Any
from backend.dto.profile_dto import CharacterProfile
from backend.dto.workflow_dto import WorkflowNode
from core.prompt_pipeline import merge_prompt_sections
class PromptExpansionService:
def expand_payload(self, payload: dict[str, Any]) -> dict[str, Any]:
sections = payload.get("sections")
if not isinstance(sections, list):
sections = [payload]
result = merge_prompt_sections(*[section for section in sections if isinstance(section, dict)])
return {
**result.to_dict(),
"source": "payload",
}
def expand_for_node(
self,
profile: CharacterProfile,
node: WorkflowNode,
payload: dict[str, Any],
) -> dict[str, Any]:
variables = {
"profile_name": profile.name,
"node_title": node.title,
**(profile.metadata.get("prompt_variables") if isinstance(profile.metadata.get("prompt_variables"), dict) else {}),
**(payload.get("variables") if isinstance(payload.get("variables"), dict) else {}),
}
result = merge_prompt_sections(
{
"parts": [profile.base_prompt, profile.appearance_prompt, profile.style_prompt],
"negative_parts": [profile.negative_prompt],
"variables": variables,
},
{
"parts": [node.prompt],
"negative_parts": [node.negative_prompt],
"variables": variables,
},
{
"parts": _payload_parts(payload),
"negative_parts": _payload_negative_parts(payload),
"variables": variables,
},
)
return {
**result.to_dict(),
"source": "profile_node",
"profile_id": profile.profile_id,
"node_id": node.node_id,
}
def _payload_parts(payload: dict[str, Any]) -> list[Any]:
parts: list[Any] = []
parts.extend(_as_list(payload.get("prompt_parts")))
for key in ("prompt_patch", "extra_prompt", "style_prompt"):
value = payload.get(key)
if value:
parts.append(value)
return parts
def _payload_negative_parts(payload: dict[str, Any]) -> list[Any]:
parts: list[Any] = []
parts.extend(_as_list(payload.get("negative_parts")))
for key in ("negative_prompt", "negative_prompt_patch"):
value = payload.get(key)
if value:
parts.append(value)
return parts
def _as_list(value: Any) -> list[Any]:
if value is None:
return []
if isinstance(value, list):
return value
return [value]

查看文件

@ -10,8 +10,6 @@ from typing import Any
from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.services.profile_service import ProfileService
from core.identity import RequestContext
class QuickProfileService:
@ -66,48 +64,6 @@ class QuickProfileService:
},
}
def save_draft(
self,
payload: dict[str, Any],
profile_service: ProfileService,
ctx: RequestContext,
) -> dict[str, Any]:
draft = payload.get("draft") if isinstance(payload.get("draft"), dict) else {}
preview = payload.get("profile_preview") if isinstance(payload.get("profile_preview"), dict) else None
preview = preview or (draft.get("profile_preview") if isinstance(draft.get("profile_preview"), dict) else None)
if not preview:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"\u7f3a\u5c11\u5feb\u901f\u4eba\u8bbe\u9884\u89c8",
{"field": "profile_preview"},
)
name = _text(preview.get("name"))
if not name:
raise ApiError(ErrorCode.VALIDATION_FAILED, "\u89d2\u8272\u540d\u79f0\u4e0d\u80fd\u4e3a\u7a7a", {"field": "name"})
draft_id = _text(payload.get("draft_id") or draft.get("draft_id"))
profile = profile_service.create_profile(
{
"name": name,
"description": payload.get("description"),
"base_prompt": preview.get("base_prompt"),
"appearance_prompt": preview.get("appearance_prompt"),
"style_prompt": preview.get("style_prompt"),
"negative_prompt": preview.get("negative_prompt"),
"default_model_route": payload.get("default_model_route") or preview.get("default_model_route"),
"avatar_image_uri": payload.get("avatar_image_uri") or preview.get("avatar_image_uri"),
"metadata": {
**(payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {}),
"source": "quick_profile",
**({"draft_id": draft_id} if draft_id else {}),
},
},
ctx,
)
return {
"draft_id": draft_id or None,
"profile": profile.to_dict(),
}
def _text(value: Any) -> str:
return str(value or "").strip()

查看文件

@ -4,7 +4,6 @@ from __future__ import annotations
import shutil
from dataclasses import dataclass
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
@ -62,41 +61,6 @@ class VfsStorage:
"execution_enabled": True,
}
def index_files(self, *, root: str | None = None, limit: int = 500) -> dict[str, Any]:
roots = self._root_paths()
if root and root not in roots:
raise ApiError(ErrorCode.MEDIA_NOT_FOUND, "unknown storage root", {"root": root})
selected_roots = [root] if root else sorted(roots)
normalized_limit = min(max(int(limit or 500), 1), 5000)
items: list[dict[str, Any]] = []
total = 0
for root_name in selected_roots:
root_path = _resolve_data_path(roots[root_name]).resolve()
if not root_path.exists():
continue
for path in sorted(root_path.rglob("*")):
if not path.is_file():
continue
total += 1
if len(items) >= normalized_limit:
continue
relative = path.relative_to(root_path).as_posix()
items.append(
{
"root": root_name,
"uri": f"storage://{root_name}/{relative}",
"bytes": path.stat().st_size,
"modified_at": datetime.fromtimestamp(path.stat().st_mtime, timezone.utc).isoformat(),
}
)
return {
"root": root,
"limit": normalized_limit,
"total": total,
"truncated": total > len(items),
"items": items,
}
def resolve_uri(self, uri: str) -> Path:
root, relative = self.split_uri(uri)
root_path = self._root_paths().get(root)

查看文件

@ -110,7 +110,6 @@ class ReviewFlowEngine:
def review_node(self, node: WorkflowNode, images: list[GenerationImage]) -> dict[str, Any]:
warnings: list[dict[str, Any]] = []
errors: list[dict[str, Any]] = []
selected_image = next((image for image in images if image.image_id == node.selected_image_id), None)
if self.policy.warn_without_images and not images:
warnings.append({"code": "NO_IMAGES", "message": "node has no generated images"})
if node.status in self.policy.require_selected_image_for_statuses and not node.selected_image_id:
@ -125,25 +124,6 @@ class ReviewFlowEngine:
image.image_id == node.selected_image_id and image.is_archived for image in images
):
errors.append({"code": "SELECTED_IMAGE_ARCHIVED", "message": "selected image is archived"})
if selected_image and node.model_route and selected_image.model_route and node.model_route != selected_image.model_route:
warnings.append(
{
"code": "MODEL_ROUTE_MISMATCH",
"message": "selected image model_route differs from node model_route",
"node_model_route": node.model_route,
"image_model_route": selected_image.model_route,
}
)
if selected_image and node.prompt and selected_image.positive_prompt:
node_prompt = _normalize_prompt(node.prompt)
image_prompt = _normalize_prompt(selected_image.positive_prompt)
if node_prompt and image_prompt and node_prompt not in image_prompt and image_prompt not in node_prompt:
warnings.append(
{
"code": "PROMPT_MISMATCH",
"message": "selected image prompt differs from node prompt",
}
)
return {
"target_type": "node",
"target_id": node.node_id,
@ -153,9 +133,7 @@ class ReviewFlowEngine:
"summary": {
"image_count": len(images),
"selected_image_id": node.selected_image_id,
"selected_image_model_route": selected_image.model_route if selected_image else None,
"node_status": node.status,
"node_model_route": node.model_route,
"policy_version": self.policy.version,
},
}
@ -177,21 +155,6 @@ class ReviewFlowEngine:
"node_ids": incomplete,
}
)
selected_model_routes = sorted(
{
str(result["summary"].get("selected_image_model_route"))
for result in node_results
if result["summary"].get("selected_image_model_route")
}
)
if len(selected_model_routes) > 1:
warnings.append(
{
"code": "INCONSISTENT_SELECTED_MODEL_ROUTES",
"message": "workflow selected images use multiple model routes",
"model_routes": selected_model_routes,
}
)
return {
"target_type": "workflow",
"target_id": workflow.workflow_id,
@ -202,7 +165,6 @@ class ReviewFlowEngine:
"workflow_type": workflow.workflow_type,
"node_count": len(nodes),
"incomplete_count": len(incomplete),
"selected_model_routes": selected_model_routes,
"policy_version": self.policy.version,
},
"nodes": node_results,
@ -223,7 +185,3 @@ def _normalize_status_list(value: Any) -> tuple[str, ...]:
if status and status not in statuses:
statuses.append(status)
return tuple(statuses)
def _normalize_prompt(value: str) -> str:
return " ".join(str(value or "").lower().replace(",", " ").split())

查看文件

@ -26,7 +26,6 @@ class MockGeneratedAsset:
image_uri: str
thumbnail_uri: str
positive_prompt: str
negative_prompt: str | None
model_route: str | None
width: int
height: int
@ -45,45 +44,32 @@ class SingleFlowEngine:
def generate(self, node: WorkflowNode, task: GenerationTask, request: dict[str, Any]) -> list[MockGeneratedAsset]:
count = _bounded_count(request.get("count", 1))
prompt = _optional_text(request.get("expanded_prompt")) or _compose_prompt(node.prompt, request.get("prompt_patch"))
negative_prompt = _optional_text(request.get("expanded_negative_prompt")) or _optional_text(node.negative_prompt)
prompt = _compose_prompt(node.prompt, request.get("prompt_patch"))
model_route = str(request.get("model_route") or node.model_route or "image_low")
width, height = _dimensions(str(request.get("aspect_ratio") or "1:1"))
provider = self._image_provider(request)
if provider is not None:
try:
return self._generate_with_provider(
provider,
task,
request,
prompt,
negative_prompt,
model_route,
width,
height,
count,
)
return self._generate_with_provider(provider, task, request, prompt, model_route, width, height, count)
except ImageProviderError as exc:
route = request.get("resolved_model_route") if isinstance(request.get("resolved_model_route"), dict) else {}
return self._generate_mock(
task,
request,
prompt,
negative_prompt,
model_route,
width,
height,
count,
provider_error=provider_failure_attribution(exc, route_context=route, fallback_used=True),
)
return self._generate_mock(task, request, prompt, negative_prompt, model_route, width, height, count)
return self._generate_mock(task, request, prompt, model_route, width, height, count)
def _generate_mock(
self,
task: GenerationTask,
request: dict[str, Any],
prompt: str,
negative_prompt: str | None,
model_route: str,
width: int,
height: int,
@ -104,7 +90,6 @@ class SingleFlowEngine:
image_uri=image_uri,
thumbnail_uri=thumbnail_uri,
positive_prompt=prompt,
negative_prompt=negative_prompt,
model_route=model_route,
width=width,
height=height,
@ -125,7 +110,6 @@ class SingleFlowEngine:
task: GenerationTask,
request: dict[str, Any],
prompt: str,
negative_prompt: str | None,
model_route: str,
width: int,
height: int,
@ -157,7 +141,6 @@ class SingleFlowEngine:
image_uri=image_uri,
thumbnail_uri=thumbnail_uri,
positive_prompt=image.revised_prompt or prompt,
negative_prompt=negative_prompt,
model_route=model_route,
width=width,
height=height,
@ -207,13 +190,6 @@ def _compose_prompt(base_prompt: str | None, prompt_patch: Any) -> str:
return ", ".join(parts) if parts else "single image mock generation"
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _dimensions(aspect_ratio: str) -> tuple[int, int]:
if aspect_ratio == "3:4":
return 768, 1024

查看文件

@ -1,104 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.workflow_routes import execute_character_workflow
from backend.services.character_workflow_service import CharacterWorkflowService
from backend.services.profile_service import ProfileService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
class CharacterWorkflowServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(Path(self.tmp.name) / "imagestudio.db")))
)
self.database.initialize()
self.audit_service = AuditService(self.database)
self.profile_repository = ProfileRepository(self.database)
self.workflow_repository = WorkflowRepository(self.database)
self.profile_service = ProfileService(self.profile_repository, self.audit_service)
self.workflow_service = WorkflowService(
self.workflow_repository,
self.profile_repository,
self.audit_service,
)
self.character_service = CharacterWorkflowService(self.workflow_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
self.profile = self.profile_service.create_profile(
{
"name": "Nova",
"base_prompt": "mage student",
"appearance_prompt": "silver hair, blue eyes",
"style_prompt": "watercolor",
"negative_prompt": "low quality",
},
self.ctx,
)
def tearDown(self):
self.tmp.cleanup()
def test_execute_fast_character_workflow_completes_nodes_with_prompts(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_fast", "display_name": "Fast"},
self.ctx,
)
result = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx)
self.assertEqual(result["workflow"]["status"], "completed")
self.assertEqual(len(result["nodes"]), 3)
self.assertTrue(all(node["status"] == "completed" for node in result["nodes"]))
candidate = next(node for node in result["nodes"] if node["node_key"] == "fast_candidates")
self.assertIn("candidate batch", candidate["prompt"])
self.assertIn("mage student", candidate["prompt"])
self.assertEqual(candidate["metadata"]["execution"]["workflow_type"], "character_fast")
def test_execute_gradual_character_workflow_completes_all_template_steps(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_gradual", "display_name": "Gradual"},
self.ctx,
)
result = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx)
self.assertEqual(len(result["completed_node_ids"]), 8)
final_pack = result["nodes"][-1]
self.assertEqual(final_pack["node_key"], "final_pack")
self.assertIn("final character pack", final_pack["prompt"])
self.assertIn("consistency reference", final_pack["prompt"])
def test_execute_character_workflow_route_requires_write_permission(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_fast", "display_name": "Fast"},
self.ctx,
)
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = execute_character_workflow(read_only, detail.workflow.workflow_id, self.character_service)
allowed = execute_character_workflow(self.ctx, detail.workflow.workflow_id, self.character_service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
self.assertTrue(allowed["ok"])
self.assertEqual(allowed["data"]["workflow"]["status"], "completed")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,122 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.image_routes import safe_delete_image
from backend.services.deletion_safety_service import DeletionSafetyService
from backend.services.image_service import ImageService
from backend.services.media_service import MediaService
from backend.services.profile_service import ProfileService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.config_service import ConfigService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.image_repository import ImageRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
class DeletionSafetyServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.config_path = self.root / "config.yaml"
self.config_path.write_text(
f"""
storage:
images_path: "{(self.root / "images").as_posix()}"
thumbnails_path: "{(self.root / "thumbnails").as_posix()}"
materials_path: "{(self.root / "materials").as_posix()}"
styles_path: "{(self.root / "styles").as_posix()}"
archives_path: "{(self.root / "archives").as_posix()}"
temp_path: "{(self.root / "temp").as_posix()}"
""",
encoding="utf-8",
)
for folder in ("images", "thumbnails", "materials", "styles", "archives", "temp"):
(self.root / folder).mkdir(parents=True, exist_ok=True)
self.database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db"))))
self.database.initialize()
self.audit_service = AuditService(self.database)
self.profile_repository = ProfileRepository(self.database)
self.workflow_repository = WorkflowRepository(self.database)
self.image_repository = ImageRepository(self.database)
self.profile_service = ProfileService(self.profile_repository, self.audit_service)
self.workflow_service = WorkflowService(self.workflow_repository, self.profile_repository, self.audit_service)
self.image_service = ImageService(self.image_repository, self.workflow_repository, self.audit_service)
self.media_service = MediaService(ConfigService(self.config_path))
self.deletion_service = DeletionSafetyService(self.image_service, self.media_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx)
workflow = self.workflow_service.create_workflow(
profile.profile_id,
{"workflow_type": "single_image", "display_name": "Single"},
self.ctx,
)
self.node = workflow.nodes[0]
def tearDown(self):
self.tmp.cleanup()
def test_safe_delete_dry_run_exposes_plan_without_local_paths(self):
image = self._create_image_with_files()
plan = self.deletion_service.delete_image(image.image_id, self.ctx, dry_run=True)
self.assertEqual(plan["status"], "planned")
self.assertTrue(plan["requires_explicit_file_delete"])
self.assertEqual({item["uri"] for item in plan["files"]}, {image.image_uri, image.thumbnail_uri})
self.assertNotIn(str(self.root), str(plan))
self.assertIsNotNone(self.image_service.get_image(image.image_id))
def test_safe_delete_can_remove_metadata_and_files_when_explicit(self):
image = self._create_image_with_files(is_selected=True)
result = self.deletion_service.delete_image(
image.image_id,
self.ctx,
dry_run=False,
delete_files=True,
)
self.assertEqual(result["status"], "completed")
self.assertEqual(set(result["deleted_files"]), {image.image_uri, image.thumbnail_uri})
self.assertFalse((self.root / "images" / "delete.png").exists())
self.assertFalse((self.root / "thumbnails" / "delete.webp").exists())
self.assertIsNone(self.workflow_repository.get_node(self.node.node_id).selected_image_id)
def test_safe_delete_route_requires_write_permission(self):
image = self._create_image_with_files()
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = safe_delete_image(read_only, image.image_id, {}, self.deletion_service)
planned = safe_delete_image(self.ctx, image.image_id, {}, self.deletion_service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
self.assertTrue(planned["ok"])
self.assertEqual(planned["data"]["status"], "planned")
def _create_image_with_files(self, *, is_selected: bool = False):
(self.root / "images" / "delete.png").write_bytes(b"image")
(self.root / "thumbnails" / "delete.webp").write_bytes(b"thumb")
return self.image_service.create_image(
{
"node_id": self.node.node_id,
"image_uri": "storage://images/delete.png",
"thumbnail_uri": "storage://thumbnails/delete.webp",
"is_selected": is_selected,
},
self.ctx,
)
if __name__ == "__main__":
unittest.main()

查看文件

@ -17,9 +17,8 @@ from backend.routes.material_routes import (
update_material,
upload_material,
)
from backend.dto.common import ApiError, ErrorCode
from backend.services.media_service import MediaService
from backend.services.material_service import MAX_UPLOAD_BYTES, MaterialService
from backend.services.material_service import MaterialService
from core.audit_service import AuditService
from core.config_service import ConfigService
from core.identity import RequestContext
@ -133,21 +132,12 @@ storage:
{
"category_id": category.category_id,
"filename": "white_blouse.png",
"content_type": "image/png; charset=binary",
"size_bytes": "2048",
"image_uri": "storage://materials/white_blouse.png",
"metadata": {"source": "unit_test"},
},
self.ctx,
)
self.assertEqual(uploaded.recognition_status, "pending_recognition")
self.assertEqual(uploaded.thumbnail_uri, "storage://materials/white_blouse.png")
self.assertEqual(uploaded.display_name, "white blouse")
self.assertEqual(uploaded.metadata["source"], "unit_test")
self.assertEqual(uploaded.metadata["upload"]["filename"], "white_blouse.png")
self.assertEqual(uploaded.metadata["upload"]["content_type"], "image/png")
self.assertEqual(uploaded.metadata["upload"]["extension"], ".png")
self.assertEqual(uploaded.metadata["upload"]["size_bytes"], 2048)
recognized = self.material_service.recognize_material(uploaded.material_id, self.ctx)
self.assertEqual(recognized.recognition_status, "pending_confirm")
@ -170,73 +160,6 @@ storage:
self.assertEqual(re_recognized.recognition_status, "pending_confirm")
self.assertIn("white", re_recognized.tags)
def test_upload_rejects_unsafe_filename(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "../white_blouse.png",
"image_uri": "storage://materials/white_blouse.png",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.VALIDATION_FAILED)
self.assertEqual(caught.exception.details["field"], "filename")
def test_upload_rejects_unsupported_file_type(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.gif",
"content_type": "image/gif",
"image_uri": "storage://materials/white_blouse.gif",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.UNSUPPORTED_FILE_TYPE)
def test_upload_rejects_mismatched_content_type(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.jpg",
"content_type": "image/png",
"image_uri": "storage://materials/white_blouse.jpg",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.UNSUPPORTED_FILE_TYPE)
self.assertEqual(caught.exception.details["field"], "content_type")
def test_upload_rejects_oversized_payload(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.png",
"content_type": "image/png",
"size_bytes": MAX_UPLOAD_BYTES + 1,
"image_uri": "storage://materials/white_blouse.png",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.UPLOAD_TOO_LARGE)
self.assertEqual(caught.exception.details["max_size_bytes"], MAX_UPLOAD_BYTES)
def test_material_routes_wrap_responses_and_require_permission(self):
category = create_material_category(self.ctx, {"name": "Accessory"}, self.material_service)
self.assertTrue(category["ok"])
@ -307,20 +230,6 @@ storage:
self.assertTrue(uploaded["data"]["thumbnail_url"].startswith("/api/v1/plugins/extensions/"))
self.assertNotIn(str(self.root), str(uploaded["data"]))
rejected = upload_material(
self.ctx,
{
"category_id": category["data"]["category_id"],
"filename": "blue_dress.exe",
"content_type": "application/octet-stream",
"image_uri": "storage://materials/blue_dress.exe",
},
self.material_service,
self.media_service,
)
self.assertFalse(rejected["ok"])
self.assertEqual(rejected["error_code"], "UNSUPPORTED_FILE_TYPE")
material_id = uploaded["data"]["material_id"]
recognized = recognize_material(self.ctx, material_id, self.material_service, self.media_service)
self.assertTrue(recognized["ok"])

查看文件

@ -1,68 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.media_routes import index_media
from backend.services.media_index_service import MediaIndexService
from backend.services.media_service import MediaService
from core.config_service import ConfigService
from core.identity import RequestContext
class MediaIndexServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.config_path = self.root / "config.yaml"
self.config_path.write_text(
f"""
storage:
images_path: "{(self.root / "images").as_posix()}"
thumbnails_path: "{(self.root / "thumbnails").as_posix()}"
materials_path: "{(self.root / "materials").as_posix()}"
styles_path: "{(self.root / "styles").as_posix()}"
archives_path: "{(self.root / "archives").as_posix()}"
temp_path: "{(self.root / "temp").as_posix()}"
""",
encoding="utf-8",
)
for folder in ("images", "thumbnails", "materials", "styles", "archives", "temp"):
(self.root / folder).mkdir(parents=True, exist_ok=True)
(self.root / "images" / "a.png").write_bytes(b"aaa")
(self.root / "images" / "nested").mkdir()
(self.root / "images" / "nested" / "b.png").write_bytes(b"bb")
(self.root / "materials" / "mat.png").write_bytes(b"m")
self.media_service = MediaService(ConfigService(self.config_path))
self.index_service = MediaIndexService(self.media_service)
self.ctx = RequestContext.from_astrbot(username="admin", user_id="user_001")
def tearDown(self):
self.tmp.cleanup()
def test_index_files_returns_storage_uris_without_local_paths(self):
index = self.index_service.index_files(root="images")
self.assertEqual(index["total"], 2)
self.assertFalse(index["truncated"])
self.assertEqual(
[item["uri"] for item in index["items"]],
["storage://images/a.png", "storage://images/nested/b.png"],
)
self.assertEqual(index["items"][0]["bytes"], 3)
self.assertNotIn(str(self.root), str(index))
def test_index_media_route_requires_authentication_and_honors_limit(self):
response = index_media(self.ctx, {"limit": "1"}, self.index_service)
anonymous = index_media(RequestContext(), {}, self.index_service)
self.assertTrue(response["ok"])
self.assertEqual(len(response["data"]["items"]), 1)
self.assertTrue(response["data"]["truncated"])
self.assertFalse(anonymous["ok"])
self.assertEqual(anonymous["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,111 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.node_routes import get_node_dependency_context
from backend.services.image_service import ImageService
from backend.services.node_dependency_context_service import NodeDependencyContextService
from backend.services.profile_service import ProfileService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.image_repository import ImageRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
class NodeDependencyContextServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(Path(self.tmp.name) / "imagestudio.db")))
)
self.database.initialize()
self.audit_service = AuditService(self.database)
self.profile_repository = ProfileRepository(self.database)
self.workflow_repository = WorkflowRepository(self.database)
self.image_repository = ImageRepository(self.database)
self.profile_service = ProfileService(self.profile_repository, self.audit_service)
self.workflow_service = WorkflowService(
self.workflow_repository,
self.profile_repository,
self.audit_service,
)
self.image_service = ImageService(self.image_repository, self.workflow_repository, self.audit_service)
self.context_service = NodeDependencyContextService(self.workflow_service, self.image_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
self.profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx)
def tearDown(self):
self.tmp.cleanup()
def test_context_includes_completed_predecessor_prompts_and_selected_images(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_gradual", "display_name": "Gradual"},
self.ctx,
)
first, second, target = detail.nodes[:3]
image = self.image_service.create_image(
{
"node_id": first.node_id,
"image_uri": "storage://images/headshot.png",
"thumbnail_uri": "storage://thumbnails/headshot.png",
"is_selected": True,
"metadata": {"kind": "headshot"},
},
self.ctx,
)
self.workflow_service.update_node(
first.node_id,
{"status": "completed", "prompt": "headshot, silver hair"},
self.ctx,
)
self.workflow_service.update_node(
second.node_id,
{"status": "completed", "prompt": "half body, white blouse"},
self.ctx,
)
context = self.context_service.get_context(target.node_id)
self.assertEqual(context["dependency_count"], 2)
self.assertEqual(context["selected_image_ids"], [image.image_id])
self.assertIn("headshot, silver hair", context["prompt_context"])
self.assertEqual(context["dependencies"][0]["selected_image"]["image_uri"], "storage://images/headshot.png")
self.assertNotIn(str(self.tmp.name), str(context))
def test_dependency_context_route_requires_authentication(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_fast", "display_name": "Fast"},
self.ctx,
)
allowed = get_node_dependency_context(
self.ctx,
detail.nodes[1].node_id,
{},
self.context_service,
)
anonymous = get_node_dependency_context(
RequestContext(),
detail.nodes[1].node_id,
{},
self.context_service,
)
self.assertTrue(allowed["ok"])
self.assertFalse(anonymous["ok"])
self.assertEqual(anonymous["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,72 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.media_routes import scan_orphan_media
from backend.services.media_index_service import MediaIndexService
from backend.services.media_service import MediaService
from backend.services.orphan_media_service import OrphanMediaService
from core.config_service import ConfigService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.image_repository import ImageRepository
class OrphanMediaServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.config_path = self.root / "config.yaml"
self.config_path.write_text(
f"""
storage:
images_path: "{(self.root / "images").as_posix()}"
thumbnails_path: "{(self.root / "thumbnails").as_posix()}"
materials_path: "{(self.root / "materials").as_posix()}"
styles_path: "{(self.root / "styles").as_posix()}"
archives_path: "{(self.root / "archives").as_posix()}"
temp_path: "{(self.root / "temp").as_posix()}"
""",
encoding="utf-8",
)
for folder in ("images", "thumbnails", "materials", "styles", "archives", "temp"):
(self.root / folder).mkdir(parents=True, exist_ok=True)
(self.root / "images" / "used.png").write_bytes(b"used")
(self.root / "images" / "orphan.png").write_bytes(b"orphan")
self.database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db"))))
self.database.initialize()
ImageRepository(self.database).create(
{
"image_id": "img_used",
"image_uri": "storage://images/used.png",
}
)
media_service = MediaService(ConfigService(self.config_path))
self.service = OrphanMediaService(self.database, MediaIndexService(media_service))
self.ctx = RequestContext.from_astrbot(username="admin", user_id="user_001")
def tearDown(self):
self.tmp.cleanup()
def test_scan_reports_unreferenced_storage_files_without_local_paths(self):
result = self.service.scan(root="images")
self.assertEqual(result["total_files"], 2)
self.assertEqual(result["orphan_count"], 1)
self.assertEqual(result["orphans"][0]["uri"], "storage://images/orphan.png")
self.assertNotIn(str(self.root), str(result))
def test_scan_orphan_media_route_requires_authentication(self):
response = scan_orphan_media(self.ctx, {"root": "images"}, self.service)
anonymous = scan_orphan_media(RequestContext(), {"root": "images"}, self.service)
self.assertTrue(response["ok"])
self.assertEqual(response["data"]["orphan_count"], 1)
self.assertFalse(anonymous["ok"])
self.assertEqual(anonymous["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,84 +0,0 @@
from __future__ import annotations
import unittest
from backend.dto.profile_dto import CharacterProfile
from backend.dto.workflow_dto import WorkflowNode
from backend.routes.prompt_routes import expand_prompt
from backend.services.prompt_expansion_service import PromptExpansionService
from core.identity import RequestContext
class PromptExpansionServiceTests(unittest.TestCase):
def test_expand_for_node_combines_profile_node_and_payload(self):
profile = CharacterProfile(
profile_id="profile_001",
name="Nova",
description=None,
base_prompt="portrait of {profile_name}",
appearance_prompt="silver hair",
style_prompt="soft watercolor",
negative_prompt="low quality",
default_model_route="image_low",
owner_platform="webui",
owner_context_id=None,
owner_user_id="user_001",
owner_session_key=None,
avatar_image_uri=None,
status="active",
metadata={"prompt_variables": {"mood": "calm"}},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
node = WorkflowNode(
node_id="node_001",
workflow_id="workflow_001",
node_key="single",
title="Single",
description=None,
step_name=None,
node_type="single_image",
status="draft",
branch_name="main",
prompt="{mood} expression",
negative_prompt="bad hands",
model_route="image_low",
selected_image_id=None,
sort_order=1,
metadata={},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
result = PromptExpansionService().expand_for_node(
profile,
node,
{"prompt_patch": "white blouse", "negative_prompt_patch": "watermark"},
)
self.assertEqual(
result["prompt"],
"portrait of Nova, silver hair, soft watercolor, calm expression, white blouse",
)
self.assertEqual(result["negative_prompt"], "low quality, bad hands, watermark")
self.assertEqual(result["source"], "profile_node")
def test_expand_prompt_route_requires_authentication(self):
ctx = RequestContext.from_astrbot(username="admin", user_id="user_001")
response = expand_prompt(
ctx,
{"sections": [{"prompt": "portrait"}, {"prompt": "portrait", "negative_prompt": "blur"}]},
PromptExpansionService(),
)
anonymous = expand_prompt(RequestContext(), {"prompt": "portrait"}, PromptExpansionService())
self.assertTrue(response["ok"])
self.assertEqual(response["data"]["prompt"], "portrait")
self.assertEqual(response["data"]["negative_prompt"], "blur")
self.assertFalse(anonymous["ok"])
self.assertEqual(anonymous["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,84 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.profile_routes import save_quick_profile_draft
from backend.services.profile_service import ProfileService
from backend.services.quick_profile_service import QuickProfileService
from core.audit_service import AuditService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.profile_repository import ProfileRepository
class QuickProfileServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(Path(self.tmp.name) / "imagestudio.db")))
)
self.database.initialize()
self.profile_service = ProfileService(ProfileRepository(self.database), AuditService(self.database))
self.quick_service = QuickProfileService()
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
def tearDown(self):
self.tmp.cleanup()
def test_save_draft_persists_preview_as_character_profile(self):
draft = self.quick_service.create_draft(
{
"questionnaire": {
"name": "Nova",
"identity": "mage student",
"personality": ["calm", "kind"],
"hair_color": "silver",
"hairstyle": "long hair",
"eye_color": "blue",
"style": "watercolor",
"clothing_keywords": ["white blouse"],
}
}
)
saved = self.quick_service.save_draft({"draft": draft}, self.profile_service, self.ctx)
profile = self.profile_service.get_profile(saved["profile"]["profile_id"])
self.assertEqual(profile.name, "Nova")
self.assertIn("mage student", profile.base_prompt)
self.assertIn("silver hair", profile.appearance_prompt)
self.assertEqual(profile.style_prompt, "watercolor")
self.assertEqual(profile.metadata["source"], "quick_profile")
self.assertEqual(profile.metadata["draft_id"], draft["draft_id"])
def test_save_quick_profile_route_requires_write_permission(self):
draft = self.quick_service.create_draft({"questionnaire": {"name": "Nova"}})
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = save_quick_profile_draft(
read_only,
{"draft": draft},
self.quick_service,
self.profile_service,
)
allowed = save_quick_profile_draft(
self.ctx,
{"draft": draft},
self.quick_service,
self.profile_service,
)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
self.assertTrue(allowed["ok"])
self.assertEqual(allowed["data"]["profile"]["name"], "Nova")
if __name__ == "__main__":
unittest.main()

查看文件

@ -100,55 +100,6 @@ class ReviewServiceTests(unittest.TestCase):
self.assertTrue(result["passed"])
self.assertEqual(result["summary"]["selected_image_id"], image.image_id)
def test_review_warns_about_prompt_and_model_route_mismatch(self):
node = self.workflow.nodes[1]
self.workflow_service.update_node(
node.node_id,
{"status": "completed", "prompt": "portrait, silver hair", "model_route": "image_high"},
self.ctx,
)
image = self.image_service.create_image(
{
"node_id": node.node_id,
"image_uri": "storage://images/mismatch.png",
"positive_prompt": "landscape, blue sky",
"model_route": "image_low",
"is_selected": True,
},
self.ctx,
)
result = self.review_service.review_node(node.node_id)
self.assertTrue(result["passed"])
self.assertEqual(result["summary"]["selected_image_id"], image.image_id)
self.assertIn("MODEL_ROUTE_MISMATCH", [warning["code"] for warning in result["warnings"]])
self.assertIn("PROMPT_MISMATCH", [warning["code"] for warning in result["warnings"]])
def test_review_workflow_warns_when_selected_images_mix_model_routes(self):
first, second = self.workflow.nodes[:2]
for node, route in ((first, "image_low"), (second, "image_high")):
self.workflow_service.update_node(
node.node_id,
{"status": "completed", "prompt": f"{route} prompt", "model_route": route},
self.ctx,
)
self.image_service.create_image(
{
"node_id": node.node_id,
"image_uri": f"storage://images/{route}.png",
"positive_prompt": f"{route} prompt",
"model_route": route,
"is_selected": True,
},
self.ctx,
)
result = self.review_service.review_workflow(self.workflow.workflow.workflow_id)
self.assertIn("INCONSISTENT_SELECTED_MODEL_ROUTES", [warning["code"] for warning in result["warnings"]])
self.assertEqual(result["summary"]["selected_model_routes"], ["image_high", "image_low"])
def test_review_routes_require_authentication(self):
node = self.workflow.nodes[0]
response = review_node(self.ctx, node.node_id, self.review_service)

查看文件

@ -26,7 +26,6 @@ class RouteRegistryTests(unittest.TestCase):
self.assertIn(("GET", "ui/bootstrap"), keys)
self.assertIn(("GET", "ui/actions"), keys)
self.assertIn(("POST", "nodes/{node_id}/generate"), keys)
self.assertIn(("POST", "profiles/quick-draft/save"), keys)
self.assertIn(("GET", "security/audit-logs"), keys)
self.assertIn(("POST", "api-discovery/probe-provider"), keys)
self.assertIn(("PUT", "material-categories/{category_id}"), keys)
@ -37,15 +36,11 @@ class RouteRegistryTests(unittest.TestCase):
self.assertIn(("POST", "workflows/{workflow_id}/start"), keys)
self.assertIn(("POST", "workflows/{workflow_id}/cancel"), keys)
self.assertIn(("POST", "workflows/{workflow_id}/archive"), keys)
self.assertIn(("POST", "workflows/{workflow_id}/execute-character"), keys)
self.assertIn(("GET", "nodes/{node_id}/review"), keys)
self.assertIn(("GET", "nodes/{node_id}/dependency-context"), keys)
self.assertIn(("GET", "workflows/{workflow_id}/review"), keys)
self.assertIn(("GET", "review/policy"), keys)
self.assertIn(("POST", "review/policy/validate"), keys)
self.assertIn(("POST", "review/policy/save"), keys)
self.assertIn(("POST", "prompts/expand"), keys)
self.assertIn(("POST", "images/{image_id}/safe-delete"), keys)
self.assertIn(("POST", "nodes/{node_id}/retry"), keys)
self.assertIn(("POST", "nodes/{node_id}/complete"), keys)
self.assertIn(("POST", "nodes/{node_id}/mark-completed"), keys)
@ -57,8 +52,6 @@ class RouteRegistryTests(unittest.TestCase):
self.assertIn(("GET", "settings/snapshots/{snapshot_id}"), keys)
self.assertIn(("POST", "settings/rollback"), keys)
self.assertIn(("POST", "storage/migrate"), keys)
self.assertIn(("GET", "media/index"), keys)
self.assertIn(("GET", "media/orphans"), keys)
self.assertIn(("GET", "events/stream"), keys)
self.assertIn(("GET", "costs/usage"), keys)
self.assertIn(("POST", "costs/guard"), keys)

查看文件

@ -13,7 +13,6 @@ from backend.services.cost_service import CostService
from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService
from backend.services.model_provider_service import ModelProviderService
from backend.services.prompt_expansion_service import PromptExpansionService
from backend.services.profile_service import ProfileService
from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService
@ -462,55 +461,6 @@ storage:
self.assertIn("cost_budget_exceeded", response["details"]["violations"])
self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0)
def test_generate_node_uses_prompt_expansion_when_service_is_configured(self):
profile = self.profile_service.create_profile(
{
"name": "Nova",
"base_prompt": "portrait of {profile_name}",
"appearance_prompt": "silver hair",
"style_prompt": "watercolor",
"negative_prompt": "low quality",
},
self.ctx,
)
workflow = self.workflow_service.create_workflow(
profile.profile_id,
{"workflow_type": "single_image", "display_name": "Single"},
self.ctx,
)
node_id = workflow.nodes[0].node_id
self.workflow_service.update_node(
node_id,
{"prompt": "calm expression", "negative_prompt": "bad hands"},
self.ctx,
)
generation_service = GenerationService(
workflow_service=self.workflow_service,
queue_service=self.queue_service,
image_service=self.image_service,
single_flow_engine=SingleFlowEngine(VfsStorage(self.config_service)),
model_provider_service=self.model_provider_service,
prompt_expansion_service=PromptExpansionService(),
event_bus=self.event_bus,
)
response = generate_node(
self.ctx,
node_id,
{"prompt_patch": "white blouse", "negative_prompt_patch": "watermark"},
generation_service=generation_service,
)
self.assertTrue(response["ok"])
image = response["data"]["images"][0]
self.assertEqual(
image["positive_prompt"],
"portrait of Nova, silver hair, watercolor, calm expression, white blouse",
)
self.assertEqual(image["negative_prompt"], "low quality, bad hands, watermark")
task = self.queue_service.get_job(response["data"]["task_id"])
self.assertEqual(task.request["prompt_expansion"]["source"], "profile_node")
def test_queue_service_rejects_invalid_task_transition(self):
task = self.queue_service.create_task({"status": "succeeded"}, self.ctx)