codex/ui-navigation-s130-s145 #1

已合并
YokiiroBW 已将来自 codex/ui-navigation-s130-s145 的 11 提交合并入 main 2026-07-12 02:58:02 +08:00
共有 114 个文件被更改,包括 3540 次插入 和 12427 次删除
仅显示提交 82d2519bb5 的更改 - 显示所有提交

查看文件

@ -65,10 +65,7 @@ PG 驱动是可选依赖,优先使用 `psycopg`,兼容回退到 `psycopg2`
## 验证
```powershell
python -m unittest discover -s tests
python -m compileall adapters backend core database engines scripts tests main.py
python scripts/imagestudio_non_ui_smoke.py
python scripts/imagestudio_pg_smoke.py --dry-run
cd frontend
npm.cmd run typecheck
@ -76,7 +73,6 @@ npm.cmd run build:plugin
npm.cmd run build:web
```
设置 `IMAGESTUDIO_TEST_PG_DSN` 后,可运行 `python -m unittest tests.test_pg_smoke` 做真实 PG smoke。
生产构建必须同时提交 `pages/imagestudio/` 的最新插件页面产物。`web/` 仅是独立预览兼容产物,但若仓库保留它,也应与同一份前端源码同步构建,避免两个产物行为漂移。

查看文件

@ -193,17 +193,10 @@ POST integrations/private-companion/token/rotate
## 验证
```powershell
python scripts/imagestudio_non_ui_smoke.py
python scripts/imagestudio_pg_smoke.py --dry-run
python -m unittest discover -s tests
python -m compileall adapters backend core database engines scripts tests main.py
python -m compileall adapters backend core database engines main.py
```
可选的真实 PostgreSQL smoke:
```powershell
$env:IMAGESTUDIO_TEST_PG_DSN = "postgresql://user:password@127.0.0.1:5432/imagestudio_test"
python -m unittest tests.test_pg_smoke
```
## 打包

查看文件

@ -14,6 +14,7 @@ OPTION_NAMES = {
"--数量": "count", "--count": "count",
"--负面": "negative_prompt", "--negative": "negative_prompt",
}
FLAG_OPTIONS = {"--转译": "translation_consent", "--translate": "translation_consent"}
def parse_single_image_command(raw: str) -> SingleImageCommand:
@ -26,6 +27,11 @@ def parse_single_image_command(raw: str) -> SingleImageCommand:
index = 0
while index < len(tokens):
token = tokens[index]
flag = FLAG_OPTIONS.get(token.lower())
if flag:
values[flag] = "true"
index += 1
continue
key = OPTION_NAMES.get(token.lower())
if key:
if index + 1 >= len(tokens) or tokens[index + 1].startswith("--"):
@ -57,6 +63,7 @@ def parse_single_image_command(raw: str) -> SingleImageCommand:
size=size,
count=count,
negative_prompt=values.get("negative_prompt"),
translation_consent=values.get("translation_consent") == "true",
)
@ -65,5 +72,5 @@ def single_image_usage(error: str) -> str:
f"❌ {error}\n\n"
"示例:\n"
"/yp 单图 雨夜街道中的少女 --角色 米卡 --尺寸 1K --数量 1\n\n"
"可用参数:--角色、--模型、--尺寸、--数量、--负面"
"可用参数:--角色、--模型、--尺寸、--数量、--负面、--转译"
)

查看文件

@ -16,6 +16,7 @@ class SingleImageCommand:
size: str = "1920x1080"
count: int = 1
negative_prompt: str | None = None
translation_consent: bool = False
def to_payload(self) -> dict:
return {
@ -25,6 +26,7 @@ class SingleImageCommand:
"size": self.size,
"count": self.count,
"negative_prompt": self.negative_prompt,
"translation_consent": self.translation_consent,
}

查看文件

@ -6,6 +6,66 @@ from dataclasses import dataclass
from typing import Any
@dataclass(frozen=True)
class RawAnalysis:
schema_version: str
prompt_version: str
created_at: str
model_source: dict[str, Any]
attributes: dict[str, Any]
description: str | None = None
source_payload: dict[str, Any] | None = None
def to_dict(self) -> dict[str, Any]:
return {
"schema_version": self.schema_version,
"prompt_version": self.prompt_version,
"created_at": self.created_at,
"model_source": self.model_source,
"attributes": self.attributes,
"description": self.description,
"source_payload": self.source_payload or {},
}
@dataclass(frozen=True)
class NormalizedAssetProfile:
schema_version: str
prompt_version: str
created_at: str
category: str
role: str
body_slots: list[str]
wear_layer: str | None
attributes: dict[str, Any]
must_preserve: list[str]
forbidden_changes: list[str]
confidence: float
requires_confirmation: bool
confirmed: bool = False
user_locked: bool = False
stackable: bool = False
def to_dict(self) -> dict[str, Any]:
return dict(self.__dict__)
@dataclass(frozen=True)
class GenerationCapsule:
schema_version: str
prompt_version: str
created_at: str
tier: str
prompt_parts: list[str]
negative_parts: list[str]
must_preserve: list[str]
forbidden_changes: list[str]
legacy: bool = False
def to_dict(self) -> dict[str, Any]:
return dict(self.__dict__)
@dataclass(frozen=True)
class MaterialCategory:
category_id: str

查看文件

@ -93,6 +93,7 @@ ROUTES: tuple[RouteSpec, ...] = (
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("POST", "prompts/governance-preview", "backend.routes.prompt_routes.preview_prompt_governance", "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"),
@ -101,6 +102,7 @@ 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}/moderation-review", "backend.routes.image_routes.review_moderated_image", "materials"),
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"),
@ -147,13 +149,16 @@ ROUTES: tuple[RouteSpec, ...] = (
"materials",
),
RouteSpec("GET", "materials", "backend.routes.material_routes.list_materials", "read"),
RouteSpec("GET", "materials/analytics", "backend.routes.material_routes.material_analytics", "read"),
RouteSpec("POST", "materials", "backend.routes.material_routes.create_material", "materials"),
RouteSpec("POST", "materials/upload", "backend.routes.material_routes.upload_material", "materials"),
RouteSpec("POST", "materials/renormalize-batch", "backend.routes.material_routes.renormalize_materials_batch", "materials"),
RouteSpec("GET", "materials/{material_id}", "backend.routes.material_routes.get_material", "read"),
RouteSpec("PUT", "materials/{material_id}", "backend.routes.material_routes.update_material", "materials"),
RouteSpec("DELETE", "materials/{material_id}", "backend.routes.material_routes.delete_material", "materials"),
RouteSpec("POST", "materials/{material_id}/recognize", "backend.routes.material_routes.recognize_material", "materials"),
RouteSpec("POST", "materials/{material_id}/re-recognize", "backend.routes.material_routes.re_recognize_material", "materials"),
RouteSpec("POST", "materials/{material_id}/renormalize", "backend.routes.material_routes.renormalize_material", "materials"),
RouteSpec("POST", "materials/{material_id}/confirm", "backend.routes.material_routes.confirm_material", "materials"),
RouteSpec("POST", "assets/import-pack", "backend.routes.asset_routes.import_asset_pack", "materials"),
RouteSpec("GET", "profiles/{profile_id}/wardrobe", "backend.routes.wardrobe_routes.list_wardrobe_items", "read"),
@ -172,6 +177,10 @@ ROUTES: tuple[RouteSpec, ...] = (
"materials",
),
RouteSpec("POST", "profiles/{profile_id}/wardrobe/match", "backend.routes.wardrobe_routes.match_wardrobe", "read"),
RouteSpec("GET", "profiles/{profile_id}/wardrobe-templates", "backend.routes.wardrobe_routes.list_wardrobe_templates", "read"),
RouteSpec("POST", "profiles/{profile_id}/wardrobe-templates", "backend.routes.wardrobe_routes.save_wardrobe_template", "materials"),
RouteSpec("POST", "profiles/{profile_id}/wardrobe-templates/{template_id}/apply", "backend.routes.wardrobe_routes.apply_wardrobe_template", "read"),
RouteSpec("DELETE", "profiles/{profile_id}/wardrobe-templates/{template_id}", "backend.routes.wardrobe_routes.delete_wardrobe_template", "materials"),
RouteSpec("POST", "integrations/private-companion/daily-outfit", "backend.routes.integration_routes.private_companion_daily_outfit", "read"),
RouteSpec("GET", "integrations/private-companion/token", "backend.routes.integration_routes.get_private_companion_token_status", "config"),
RouteSpec("POST", "integrations/private-companion/token/rotate", "backend.routes.integration_routes.rotate_private_companion_token", "config"),

查看文件

@ -12,7 +12,11 @@ def list_backups(ctx:RequestContext,service:DataBackupService|None=None)->dict:
def create_backup(ctx:RequestContext,payload:dict|None=None,service:DataBackupService|None=None)->dict:
instance=service or DataBackupService();params=payload or {}
return handle_request(ctx,lambda:(require_config_manager(ctx),instance.create_backup(include_media=as_bool(params.get("include_media"),default=True)))[1])
return handle_request(ctx,lambda:(require_config_manager(ctx),instance.create_backup(
include_media=as_bool(params.get("include_media"),default=True),
include_prompt_records=as_bool(params.get("include_prompt_records"),default=True),
include_moderation_records=as_bool(params.get("include_moderation_records"),default=True),
))[1])
def inspect_backup(ctx:RequestContext,backup_id:str,service:DataBackupService|None=None)->dict:
instance=service or DataBackupService()

查看文件

@ -4,7 +4,7 @@ from __future__ import annotations
from typing import Any
from backend.dto.common import ApiError
from backend.dto.common import ApiError, ErrorCode
from backend.dto.image_dto import GenerationImage, ImageListResult
from backend.routes.common import handle_request
from backend.routes.params import as_bool, int_or_default, optional_str
@ -38,7 +38,16 @@ def list_images(
page=int_or_default(params.get("page"), 1),
page_size=int_or_default(params.get("page_size"), 60),
)
return _serialize_image_list(result, signer)
include_restricted = as_bool(params.get("include_restricted"), default=False, non_string_truthiness=True)
if include_restricted and not (ctx.has_permission("can_manage_materials") or ctx.has_permission("*")):
include_restricted = False
payload = _serialize_image_list(result, signer)
if not include_restricted:
visible = [item for item in payload["items"] if not _is_restricted_image(item)]
payload["restricted_hidden"] = len(payload["items"]) - len(visible)
payload["items"] = visible
payload["total"] = max(len(visible), int(payload.get("total") or 0) - payload["restricted_hidden"])
return payload
return handle_request(ctx, action)
@ -57,7 +66,11 @@ def list_node_images(
def action() -> list[dict[str, Any]]:
require_authenticated(ctx)
include_archived = as_bool(params.get("include_archived"), non_string_truthiness=True)
return [_serialize_image(image, signer) for image in image_service.list_by_node(node_id, include_archived)]
include_restricted = as_bool(params.get("include_restricted"), default=False, non_string_truthiness=True)
if include_restricted and not (ctx.has_permission("can_manage_materials") or ctx.has_permission("*")):
include_restricted = False
images = [_serialize_image(image, signer) for image in image_service.list_by_node(node_id, include_archived)]
return images if include_restricted else [item for item in images if not _is_restricted_image(item)]
return handle_request(ctx, action)
@ -73,7 +86,10 @@ def get_image(
def action() -> dict[str, Any]:
require_authenticated(ctx)
return _serialize_image(image_service.get_image(image_id), signer)
image = _serialize_image(image_service.get_image(image_id), signer)
if _is_restricted_image(image) and not (ctx.has_permission("can_manage_materials") or ctx.has_permission("*")):
raise ApiError(ErrorCode.FORBIDDEN, "受限图片仅管理员可查看", {"image_id": image_id})
return image
return handle_request(ctx, action)
@ -126,6 +142,24 @@ def archive_image(
return handle_request(ctx, action)
def review_moderated_image(
ctx: RequestContext,
image_id: str,
payload: dict[str, Any],
service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
image_service = service or _create_image_service()
signer = media_service or MediaService()
def action() -> dict[str, Any]:
if not (ctx.has_permission("can_manage_materials") or ctx.has_permission("*")):
raise ApiError(ErrorCode.FORBIDDEN, "仅管理员可复核受限图片", {"image_id": image_id})
return _serialize_image(image_service.review_moderated_image(image_id, payload, ctx), signer)
return handle_request(ctx, action)
def delete_image(
ctx: RequestContext,
image_id: str,
@ -196,3 +230,8 @@ def _signed_url(media_service: MediaService, uri: str | None) -> str | None:
return media_service.sign_media(uri)["url"]
except ApiError:
return None
def _is_restricted_image(image: dict[str, Any]) -> bool:
metadata = image.get("metadata") if isinstance(image.get("metadata"), dict) else {}
return bool(metadata.get("quarantined") or metadata.get("gallery_visibility") == "restricted")

查看文件

@ -4,11 +4,12 @@ from __future__ import annotations
from typing import Any
from backend.dto.common import ApiError
from backend.dto.common import ApiError, ErrorCode
from backend.dto.material_dto import Material, MaterialListResult
from backend.routes.common import handle_request
from backend.routes.params import int_or_default, optional_str
from backend.services.material_service import MaterialService
from backend.services.material_analytics_service import MaterialAnalyticsService
from backend.services.media_service import MediaService
from backend.services.model_provider_bootstrap import sync_vision_provider_from_config
from backend.services.model_provider_runtime import ModelProviderRuntime
@ -94,12 +95,23 @@ def list_materials(
keyword=optional_str(params.get("keyword")),
page=int_or_default(params.get("page"), 1),
page_size=int_or_default(params.get("page_size"), 30),
color=optional_str(params.get("color")),
material_type=optional_str(params.get("material_type")),
body_slot=optional_str(params.get("body_slot")),
wear_layer=optional_str(params.get("wear_layer")),
min_confidence=_optional_float(params.get("min_confidence")),
confirmation_state=optional_str(params.get("confirmation_state")),
)
return _serialize_material_list(result, signer)
return handle_request(ctx, action)
def material_analytics(ctx: RequestContext, service: MaterialAnalyticsService | None = None) -> dict:
analytics = service or MaterialAnalyticsService(Database(load_database_settings()))
return handle_request(ctx, lambda: (require_authenticated(ctx), analytics.summarize())[1])
def create_material(
ctx: RequestContext,
payload: dict[str, Any],
@ -213,6 +225,36 @@ def re_recognize_material(
return handle_request(ctx, action)
def renormalize_material(
ctx: RequestContext,
material_id: str,
service: MaterialService | None = None,
media_service: MediaService | None = None,
) -> dict:
material_service = service or _create_material_service()
signer = media_service or MediaService()
def action() -> dict[str, Any]:
require_permission(ctx, "can_manage_materials")
return _serialize_material(material_service.renormalize_material(material_id, ctx), signer)
return handle_request(ctx, action)
def renormalize_materials_batch(
ctx: RequestContext,
payload: dict[str, Any] | None = None,
service: MaterialService | None = None,
) -> dict:
material_service = service or _create_material_service()
def action() -> dict[str, Any]:
require_permission(ctx, "can_manage_materials")
return material_service.renormalize_batch(payload or {}, ctx)
return handle_request(ctx, action)
def confirm_material(
ctx: RequestContext,
material_id: str,
@ -263,6 +305,15 @@ def _serialize_material(material: Material, media_service: MediaService) -> dict
return payload
def _optional_float(value: Any) -> float | None:
if value in (None, ""):
return None
try:
return float(value)
except (TypeError, ValueError):
raise ApiError(ErrorCode.VALIDATION_FAILED, "min_confidence must be a number", {"field": "min_confidence"}) from None
def _signed_url(media_service: MediaService, uri: str | None) -> str | None:
if not uri:
return None

查看文件

@ -17,6 +17,13 @@ from backend.services.model_provider_bootstrap import sync_generation_provider_f
from backend.services.model_provider_service import ModelProviderService
from backend.services.node_dependency_context_service import NodeDependencyContextService
from backend.services.prompt_expansion_service import PromptExpansionService
from backend.services.prompt_governance_service import (
GenerationRouteService,
ImageModerationService,
PromptModerationService,
PromptSemanticNormalizer,
PromptTranslationService,
)
from backend.services.queue_service import QueueService
from backend.services.workflow_service import (
LOCKED_NODE_STATUSES,
@ -295,6 +302,30 @@ def _create_generation_service() -> GenerationService:
sync_generation_provider_from_config(model_provider_service, config_payload)
generation_config = config_payload.get("generation") if isinstance(config_payload.get("generation"), dict) else {}
model_assignments = config_payload.get("model_assignments") if isinstance(config_payload.get("model_assignments"), dict) else {}
governance_config = config_payload.get("prompt_governance") if isinstance(config_payload.get("prompt_governance"), dict) else {}
translation_config = governance_config.get("translation") if isinstance(governance_config.get("translation"), dict) else {}
moderation_config = governance_config.get("moderation") if isinstance(governance_config.get("moderation"), dict) else {}
routing_config = governance_config.get("routing") if isinstance(governance_config.get("routing"), dict) else {}
image_moderation_config = governance_config.get("image_moderation") if isinstance(governance_config.get("image_moderation"), dict) else {}
translation_route = str(translation_config.get("model_route") or model_assignments.get("prompt_planning") or "").strip()
moderation_route = str(moderation_config.get("model_route") or model_assignments.get("cross_review_primary") or "").strip()
translation_callable = model_provider_runtime.structured_text_callable(translation_route) if translation_route else None
moderation_callable = model_provider_runtime.structured_text_callable(moderation_route) if moderation_route else None
single_flow_engine = SingleFlowEngine(
image_provider_factory=model_provider_runtime.image_provider_for_route,
allow_mock_fallback=False,
)
image_moderation_route = str(image_moderation_config.get("model_route") or "").strip()
image_moderation_callable = model_provider_runtime.structured_vision_callable(
image_moderation_route,
storage=single_flow_engine.storage,
) if image_moderation_route else None
if translation_callable:
raw_translation_callable = translation_callable
translation_callable = lambda request: raw_translation_callable({**request, "purpose": "Chinese-to-English image prompt translation and structured visual decomposition"})
if moderation_callable:
raw_moderation_callable = moderation_callable
moderation_callable = lambda request: raw_moderation_callable({**request, "purpose": "image prompt content risk classification"})
return GenerationService(
workflow_service=WorkflowService(
workflow_repository=workflow_repository,
@ -312,10 +343,7 @@ def _create_generation_service() -> GenerationService:
workflow_repository=workflow_repository,
audit_service=audit_service,
),
single_flow_engine=SingleFlowEngine(
image_provider_factory=model_provider_runtime.image_provider_for_route,
allow_mock_fallback=False,
),
single_flow_engine=single_flow_engine,
model_provider_service=model_provider_service,
cost_guard_service=CostGuardService(CostService(database)),
prompt_expansion_service=PromptExpansionService(),
@ -324,6 +352,11 @@ def _create_generation_service() -> GenerationService:
require_resolved_model_route=True,
material_resolver=MaterialRepository(database),
model_assignments=model_assignments,
prompt_translation_service=PromptTranslationService(translation_config, translation_callable),
prompt_semantic_normalizer=PromptSemanticNormalizer(),
prompt_moderation_service=PromptModerationService(moderation_config, moderation_callable),
generation_route_service=GenerationRouteService(routing_config),
image_moderation_service=ImageModerationService(image_moderation_config, image_moderation_callable),
)

查看文件

@ -6,8 +6,13 @@ from typing import Any
from backend.routes.common import handle_request
from backend.services.prompt_expansion_service import PromptExpansionService
from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.model_provider_service import ModelProviderService
from backend.services.prompt_governance_service import GenerationRouteService, PromptModerationService, PromptSemanticNormalizer, PromptTranslationService
from core.identity import RequestContext
from core.security import require_authenticated
from database.db_helper import Database, load_config_payload, load_database_settings
from database.repositories.model_provider_repository import ModelProviderRepository
def expand_prompt(
@ -23,3 +28,46 @@ def expand_prompt(
return prompt_service.expand_payload(request_payload)
return handle_request(ctx, action)
def preview_prompt_governance(ctx: RequestContext, payload: dict[str, Any] | None = None) -> dict:
request = payload or {}
def action() -> dict[str, Any]:
require_authenticated(ctx)
config = load_config_payload()
governance = config.get("prompt_governance") if isinstance(config.get("prompt_governance"), dict) else {}
assignments = config.get("model_assignments") if isinstance(config.get("model_assignments"), dict) else {}
translation_config = governance.get("translation") if isinstance(governance.get("translation"), dict) else {}
moderation_config = governance.get("moderation") if isinstance(governance.get("moderation"), dict) else {}
routing_config = governance.get("routing") if isinstance(governance.get("routing"), dict) else {}
model_service = ModelProviderService(ModelProviderRepository(Database(load_database_settings())))
runtime = ModelProviderRuntime(model_service)
translation_route = str(translation_config.get("model_route") or assignments.get("prompt_planning") or "").strip()
moderation_route = str(moderation_config.get("model_route") or assignments.get("cross_review_primary") or "").strip()
translator = runtime.structured_text_callable(translation_route) if translation_route else None
reviewer = runtime.structured_text_callable(moderation_route) if moderation_route else None
original = str(request.get("prompt") or "").strip()
translation = PromptTranslationService(translation_config, translator).translate(
original,
entrypoint=str(request.get("entrypoint") or "web"),
user_allowed=bool(request.get("translation_consent", False)),
model_family=str(request.get("model_family") or "natural_language"),
locked_terms=[str(item) for item in request.get("locked_terms", [])] if isinstance(request.get("locked_terms"), list) else [],
budget=int(request.get("prompt_budget")) if str(request.get("prompt_budget") or "").isdigit() else None,
)
selection = str(request.get("selection") or "translated")
selected = original if selection == "original" else str(request.get("manual_prompt") or "").strip() if selection == "manual" else translation.translated_text
normalized = PromptSemanticNormalizer().normalize(selected, locked_terms=[str(item) for item in request.get("locked_terms", [])] if isinstance(request.get("locked_terms"), list) else [])
moderation = PromptModerationService(moderation_config, reviewer).moderate(original_prompt=original, translated_prompt=translation.translated_text, final_prompt=normalized["normalized_text"], negative_prompt=str(request.get("negative_prompt") or ""))
route = GenerationRouteService(routing_config).decide(
str(request.get("model_route") or routing_config.get("safe_route") or "image_low"),
moderation,
entrypoint=str(request.get("entrypoint") or "web"),
user_id=ctx.actor_id,
group_id=str(request.get("group_id") or "").strip() or None,
permission_context=request.get("content_permissions") if isinstance(request.get("content_permissions"), dict) else {},
)
return {"original_prompt": original, "translation": translation.to_dict(), "selection": selection, "selected_prompt": selected, "normalization": normalized, "moderation": moderation.to_dict(), "route_decision": route.to_dict()}
return handle_request(ctx, action)

查看文件

@ -84,6 +84,26 @@ def match_wardrobe(
return handle_request(ctx, action)
def list_wardrobe_templates(ctx: RequestContext, profile_id: str, service: WardrobeService | None = None) -> dict:
wardrobe_service = service or _create_wardrobe_service()
return handle_request(ctx, lambda: (require_authenticated(ctx), wardrobe_service.list_templates(profile_id, ctx))[1])
def save_wardrobe_template(ctx: RequestContext, profile_id: str, payload: dict[str, Any], service: WardrobeService | None = None) -> dict:
wardrobe_service = service or _create_wardrobe_service()
return handle_request(ctx, lambda: (require_permission(ctx, "can_manage_materials"), wardrobe_service.save_template(profile_id, payload, ctx))[1])
def delete_wardrobe_template(ctx: RequestContext, profile_id: str, template_id: str, service: WardrobeService | None = None) -> dict:
wardrobe_service = service or _create_wardrobe_service()
return handle_request(ctx, lambda: (require_permission(ctx, "can_manage_materials"), wardrobe_service.delete_template(profile_id, template_id, ctx))[1])
def apply_wardrobe_template(ctx: RequestContext, profile_id: str, template_id: str, payload: dict[str, Any] | None = None, service: WardrobeService | None = None) -> dict:
wardrobe_service = service or _create_wardrobe_service()
return handle_request(ctx, lambda: (require_authenticated(ctx), wardrobe_service.apply_template(profile_id, template_id, payload or {}, ctx))[1])
def _create_wardrobe_service() -> WardrobeService:
database = Database(load_database_settings())
return WardrobeService(

查看文件

@ -60,6 +60,12 @@ class ChatWorkflowService:
"model_route": command.model_route,
"size": command.size,
"count": command.count,
"entrypoint": _chat_entrypoint(chat.platform),
"platform": chat.platform,
"user_id": chat.user_id,
"group_id": chat.group_id,
"translation_consent": command.translation_consent,
"content_permissions": _content_permissions(config, chat),
"idempotency_key": "chat_" + hashlib.sha256(idempotency_source.encode("utf-8")).hexdigest()[:32],
"metadata": {
"source": "astrbot_chat",
@ -143,7 +149,15 @@ class ChatWorkflowService:
return self._data(self.dispatcher(self._request_context(chat), "GET", f"workflows/{workflow_id}", query={}))
def generate_node(self, node_id: str, chat: ChatCommandContext, *, prompt: str = "") -> dict[str, Any]:
payload = {"prompt": prompt} if prompt else {}
config = self.config_loader()
payload = {
**({"prompt": prompt} if prompt else {}),
"entrypoint": _chat_entrypoint(chat.platform),
"platform": chat.platform,
"user_id": chat.user_id,
"group_id": chat.group_id,
"content_permissions": _content_permissions(config, chat),
}
ctx = self._request_context(chat)
result = self._data(self.dispatcher(ctx, "POST", f"nodes/{node_id}/generate", payload=payload))
result["images"] = [
@ -170,7 +184,13 @@ class ChatWorkflowService:
return {"completed": True, "workflow": workflow}
if candidate.get("node_id") != workflow.get("current_node_id"):
self._data(self.dispatcher(ctx, "PUT", f"workflows/{workflow_id}", payload={"current_node_id": candidate["node_id"]}))
generation = self._data(self.dispatcher(ctx, "POST", f"nodes/{candidate['node_id']}/generate", payload={}))
generation = self._data(self.dispatcher(ctx, "POST", f"nodes/{candidate['node_id']}/generate", payload={
"entrypoint": _chat_entrypoint(chat.platform),
"platform": chat.platform,
"user_id": chat.user_id,
"group_id": chat.group_id,
"content_permissions": _content_permissions(self.config_loader(), chat),
}))
return {"completed": False, "workflow": workflow, "node": candidate, "generation": generation}
def select_node_image(self, node_id: str, image_id: str, chat: ChatCommandContext) -> dict[str, Any]:
@ -309,6 +329,36 @@ class ChatWorkflowService:
return response.get("data")
def _content_permissions(config: dict[str, Any], chat: ChatCommandContext) -> dict[str, Any]:
access = config.get("chat_access") if isinstance(config.get("chat_access"), dict) else {}
adult_users = _id_set(access.get("adult_user_allowlist"))
adult_groups = _id_set(access.get("adult_group_allowlist"))
return {
"adult_user_allowed": bool(chat.user_id and chat.user_id in adult_users),
"adult_group_allowed": bool(not chat.group_id or chat.group_id in adult_groups),
"quota_allowed": True,
}
def _chat_entrypoint(platform: str) -> str:
value = str(platform or "").lower()
if "qq" in value or "onebot" in value:
return "qq"
if "telegram" in value:
return "telegram"
if "discord" in value:
return "discord"
return "unknown"
def _id_set(value: Any) -> set[str]:
if isinstance(value, str):
value = re.split(r"[,,\n]", value)
if not isinstance(value, (list, tuple, set)):
return set()
return {str(item).strip() for item in value if str(item).strip()}
def _quick_questionnaire(text: str) -> dict[str, Any]:
parts = text.split(maxsplit=1)
if len(parts) < 2:

查看文件

@ -0,0 +1,298 @@
"""Deterministic, explainable material composition for generation prompts."""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import Any, Mapping
from backend.services.material_normalization_service import CAPSULE_TIERS, WEAR_LAYERS
BASE_WEIGHTS = {
"identity": 100.0,
"dress": 82.0,
"suit": 80.0,
"outerwear": 72.0,
"top": 70.0,
"bottom": 70.0,
"hair": 68.0,
"footwear": 55.0,
"jewelry": 38.0,
"headwear": 38.0,
"face_accessory": 38.0,
"prop": 34.0,
"pose": 45.0,
"style": 42.0,
"background": 30.0,
"other": 20.0,
}
LAYER_ORDER = {layer: index for index, layer in enumerate(("skin", "inner", "base", "middle", "outer", "overlay", "accessory", "prop"))}
CONTRADICTIONS = (
("fitted", "oversized"), ("matte", "glossy"), ("short sleeve", "long sleeve"),
("transparent", "opaque"), ("minimal", "ornate"),
)
@dataclass(frozen=True)
class ReferenceImageBinding:
material_id: str
image_uri: str
role: str
use_for: list[str]
do_not_inherit: list[str]
weight: float
def to_dict(self) -> dict[str, Any]:
return dict(self.__dict__)
@dataclass(frozen=True)
class CompositionPlan:
materials: list[dict[str, Any]]
identity_prompt: str = ""
user_prompt: str = ""
negative_prompt: str = ""
prompt_budget: int = 4000
max_reference_images: int = 8
visible_slots: list[str] = field(default_factory=list)
season: str = ""
scene: str = ""
@dataclass
class CompositionResult:
prompt: str
negative_prompt: str
selected_materials: list[dict[str, Any]] = field(default_factory=list)
resolution_log: list[dict[str, Any]] = field(default_factory=list)
conflicts: list[dict[str, Any]] = field(default_factory=list)
ignored_materials: list[dict[str, Any]] = field(default_factory=list)
downgraded_materials: list[dict[str, Any]] = field(default_factory=list)
reference_bindings: list[ReferenceImageBinding] = field(default_factory=list)
budget: dict[str, Any] = field(default_factory=dict)
def to_dict(self) -> dict[str, Any]:
return {
"prompt": self.prompt,
"negative_prompt": self.negative_prompt,
"selected_materials": self.selected_materials,
"resolution_log": self.resolution_log,
"conflicts": self.conflicts,
"ignored_materials": self.ignored_materials,
"downgraded_materials": self.downgraded_materials,
"reference_bindings": [item.to_dict() for item in self.reference_bindings],
"budget": self.budget,
}
class CompositionBuilder:
def build(self, plan: CompositionPlan | Mapping[str, Any]) -> CompositionResult:
if not isinstance(plan, CompositionPlan):
plan = CompositionPlan(
materials=list(plan.get("materials") or []),
identity_prompt=_text(plan.get("identity_prompt")),
user_prompt=_text(plan.get("user_prompt")),
negative_prompt=_text(plan.get("negative_prompt")),
prompt_budget=max(int(plan.get("prompt_budget") or 4000), 256),
max_reference_images=max(int(plan.get("max_reference_images") or 8), 0),
visible_slots=_string_list(plan.get("visible_slots")),
season=_text(plan.get("season")),
scene=_text(plan.get("scene")),
)
prepared = [self._prepare_material(item, plan) for item in plan.materials if isinstance(item, dict)]
prepared.sort(key=lambda item: (-item["effective_weight"], item["material_id"]))
kept, ignored, conflicts, resolution_log = self._resolve_conflicts(prepared)
kept.sort(key=lambda item: (self._semantic_order(item), -item["effective_weight"], item["material_id"]))
prompt_parts = _unique([plan.identity_prompt, *self._capsule_parts(kept), plan.user_prompt])
negative_parts = _unique([plan.negative_prompt, *self._negative_parts(kept)])
prompt, budget, downgraded = self._apply_budget(prompt_parts, kept, plan.prompt_budget)
references = self._reference_bindings(kept, plan.max_reference_images, downgraded)
return CompositionResult(
prompt=prompt,
negative_prompt=", ".join(negative_parts),
selected_materials=kept,
resolution_log=resolution_log,
conflicts=conflicts,
ignored_materials=ignored,
downgraded_materials=downgraded,
reference_bindings=references,
budget=budget,
)
def _prepare_material(self, item: dict[str, Any], plan: CompositionPlan) -> dict[str, Any]:
metadata = item.get("metadata") if isinstance(item.get("metadata"), dict) else {}
profile = metadata.get("normalized_asset_profile") if isinstance(metadata.get("normalized_asset_profile"), dict) else {}
capsules = metadata.get("generation_capsules") if isinstance(metadata.get("generation_capsules"), dict) else {}
category = _text(profile.get("category") or item.get("category") or item.get("wardrobe_category") or "other")
role = _text(profile.get("role") or item.get("role") or "other")
confidence = _float(profile.get("confidence"), 0.5)
locked = bool(item.get("locked") or item.get("user_locked") or profile.get("user_locked"))
user_adjustment = _float(item.get("user_adjustment"), 0.0)
role_bonus = 20.0 if role == "identity" else 8.0 if category in {"dress", "suit", "top", "bottom", "outerwear"} else 0.0
lock_bonus = 100.0 if locked else 0.0
slots = _string_list(profile.get("body_slots"))
automatic_visibility = 10.0 if plan.visible_slots and set(slots) & set(plan.visible_slots) else 0.0
visibility_bonus = _float(item.get("visibility_bonus"), 0.0) + automatic_visibility
restoration_feedback_bonus = (_float(item.get("restoration_score"), 0.5) - 0.5) * 20.0
season_penalty = 12.0 if plan.season and _text(item.get("season")) and plan.season.casefold() != _text(item.get("season")).casefold() else 0.0
low_confidence_penalty = max(0.0, 0.80 - confidence) * 40.0
base_weight = BASE_WEIGHTS.get(category, BASE_WEIGHTS["other"])
effective_weight = base_weight + user_adjustment + role_bonus + lock_bonus + visibility_bonus + restoration_feedback_bonus - low_confidence_penalty - season_penalty
tier = _text(item.get("capsule_tier") or "detailed").lower()
if tier not in CAPSULE_TIERS:
tier = "standard"
capsule = capsules.get(tier) if isinstance(capsules.get(tier), dict) else {}
prompt_parts = _string_list(capsule.get("prompt_parts")) or _split_prompt(item.get("prompt"))
negative_parts = _string_list(capsule.get("negative_parts")) or _split_prompt(item.get("negative_prompt"))
return {
**item,
"material_id": _text(item.get("material_id")) or _text(item.get("wardrobe_item_id")) or f"material-{id(item)}",
"category": category,
"role": role,
"body_slots": slots,
"wear_layer": _text(profile.get("wear_layer")) or None,
"stackable": bool(item.get("stackable", profile.get("stackable", False))),
"locked": locked,
"capsule_tier": tier,
"prompt_parts": prompt_parts,
"negative_parts": negative_parts,
"must_preserve": _string_list(capsule.get("must_preserve") or profile.get("must_preserve")),
"forbidden_changes": _string_list(capsule.get("forbidden_changes") or profile.get("forbidden_changes")),
"effective_weight": round(effective_weight, 3),
"weight_breakdown": {
"base_weight": base_weight,
"user_adjustment": user_adjustment,
"lock_bonus": lock_bonus,
"role_bonus": role_bonus,
"visibility_bonus": visibility_bonus,
"restoration_feedback_bonus": round(restoration_feedback_bonus, 3),
"season_penalty": season_penalty,
"low_confidence_penalty": round(low_confidence_penalty, 3),
},
}
def _resolve_conflicts(self, items: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]]]:
kept: list[dict[str, Any]] = []
ignored: list[dict[str, Any]] = []
conflicts: list[dict[str, Any]] = []
log: list[dict[str, Any]] = []
for candidate in items:
blocker = next((current for current in kept if self._conflict_reason(current, candidate)), None)
if blocker is None:
kept.append(candidate)
log.append({"material_id": candidate["material_id"], "decision": "kept", "reason": "no_conflict", "effective_weight": candidate["effective_weight"]})
continue
reason = self._conflict_reason(blocker, candidate) or "conflict"
conflict = {"type": reason, "winner": blocker["material_id"], "loser": candidate["material_id"]}
conflicts.append(conflict)
ignored_item = {**candidate, "ignored_reason": reason, "conflicts_with": blocker["material_id"]}
ignored.append(ignored_item)
log.append({"material_id": candidate["material_id"], "decision": "ignored", "reason": reason, "winner": blocker["material_id"]})
return kept, ignored, conflicts, log
def _conflict_reason(self, left: Mapping[str, Any], right: Mapping[str, Any]) -> str | None:
categories = {left.get("category"), right.get("category")}
if "dress" in categories and categories & {"top", "bottom", "suit"}:
return "dress_separate_garment_conflict"
slots = set(left.get("body_slots") or []) & set(right.get("body_slots") or [])
if slots:
if left.get("stackable") and right.get("stackable"):
return None
left_layer, right_layer = left.get("wear_layer"), right.get("wear_layer")
if left_layer and right_layer and left_layer != right_layer:
return None
return "body_slot_conflict"
left_text = " ".join(left.get("prompt_parts") or []).lower()
right_text = " ".join(right.get("prompt_parts") or []).lower()
if any((a in left_text and b in right_text) or (b in left_text and a in right_text) for a, b in CONTRADICTIONS):
return "attribute_contradiction"
return None
def _semantic_order(self, item: Mapping[str, Any]) -> tuple[int, int]:
role_order = {"identity": 0, "garment": 2, "accessory": 6, "prop": 7, "pose": 8, "background": 9, "style": 10, "other": 11}
return role_order.get(_text(item.get("role")), 11), LAYER_ORDER.get(_text(item.get("wear_layer")), 99)
def _capsule_parts(self, items: list[dict[str, Any]]) -> list[str]:
result: list[str] = []
for item in items:
result.extend(item["prompt_parts"])
result.extend(f"must preserve {value}" for value in item["must_preserve"])
return result
def _negative_parts(self, items: list[dict[str, Any]]) -> list[str]:
return [part for item in items for part in [*item["negative_parts"], *item["forbidden_changes"]]]
def _apply_budget(self, parts: list[str], items: list[dict[str, Any]], budget: int) -> tuple[str, dict[str, Any], list[dict[str, Any]]]:
original = ", ".join(parts)
if len(original) <= budget:
return original, {"limit": budget, "before": len(original), "after": len(original), "removed": []}, []
locked_terms = {term for item in items if item["locked"] or item["role"] == "identity" for term in [*item["prompt_parts"], *item["must_preserve"]]}
kept = list(parts)
removed: list[str] = []
for part in reversed(parts):
if len(", ".join(kept)) <= budget:
break
if part in locked_terms or part.startswith("must preserve "):
continue
kept.remove(part)
removed.append(part)
text = ", ".join(kept)
if len(text) > budget:
# Locked and safety-relevant content is never silently truncated.
text = text
downgraded = [{"reason": "prompt_budget", "removed_prompt_parts": removed}] if removed else []
return text, {"limit": budget, "before": len(original), "after": len(text), "removed": removed}, downgraded
def _reference_bindings(self, items: list[dict[str, Any]], limit: int, downgraded: list[dict[str, Any]]) -> list[ReferenceImageBinding]:
candidates = [item for item in items if _text(item.get("image_uri"))]
candidates.sort(key=lambda item: (-item["effective_weight"], item["material_id"]))
bindings: list[ReferenceImageBinding] = []
for item in candidates[:limit]:
role = item["role"]
if role == "identity":
use_for = ["identity", "face", "hair"]
do_not_inherit = ["pose", "background", "style"]
elif role in {"garment", "accessory"}:
use_for = ["clothing", "design", "color", "material"]
do_not_inherit = ["face", "identity", "body_shape", "pose", "background", "style"]
else:
use_for = [role]
do_not_inherit = ["identity", "face"]
bindings.append(ReferenceImageBinding(item["material_id"], item["image_uri"], role, use_for, do_not_inherit, min(max(item["effective_weight"] / 100.0, 0.1), 1.0)))
for item in candidates[limit:]:
downgraded.append({"material_id": item["material_id"], "reason": "reference_image_limit", "fallback": "text_capsule"})
return bindings
def _split_prompt(value: Any) -> list[str]:
return [part.strip() for part in _text(value).replace(";", ",").split(",") if part.strip()]
def _string_list(value: Any) -> list[str]:
if isinstance(value, str):
return _split_prompt(value)
if not isinstance(value, (list, tuple, set)):
return []
return _unique([_text(item) for item in value])
def _unique(values: list[str]) -> list[str]:
result: list[str] = []
seen: set[str] = set()
for item in values:
text = _text(item)
if text and text.casefold() not in seen:
seen.add(text.casefold())
result.append(text)
return result
def _float(value: Any, default: float) -> float:
try:
return float(value)
except (TypeError, ValueError):
return default
def _text(value: Any) -> str:
return str(value or "").strip()

查看文件

@ -32,7 +32,13 @@ class DataBackupService:
return []
return [self._summary(path) for path in sorted(root.glob("*.zip"), key=lambda item: item.stat().st_mtime, reverse=True)]
def create_backup(self, *, include_media: bool = True) -> dict[str, Any]:
def create_backup(
self,
*,
include_media: bool = True,
include_prompt_records: bool = True,
include_moderation_records: bool = True,
) -> dict[str, Any]:
backup_id = f"backup_{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')}_{uuid4().hex[:8]}"
root = self._backup_root()
root.mkdir(parents=True, exist_ok=True)
@ -57,6 +63,12 @@ class DataBackupService:
source.backup(target)
finally:
target.close(); source.close()
if not include_prompt_records or not include_moderation_records:
_sanitize_sqlite_backup(
db_copy,
include_prompt_records=include_prompt_records,
include_moderation_records=include_moderation_records,
)
entries.append(_entry(db_copy, "database/imagestudio.db"))
else:
warnings.append("PostgreSQL data is not embedded; use pg_dump with the connection recorded in the redacted config.")
@ -77,11 +89,14 @@ class DataBackupService:
entries.append(_entry(path, f"media/{key}/{path.relative_to(media_root).as_posix()}"))
manifest = {
"format": "imagestudio-full-backup",
"version": 1,
"version": 2,
"material_schema_version": "1.0",
"backup_id": backup_id,
"created_at": datetime.now(timezone.utc).isoformat(),
"database_backend": database_settings.selected_backend,
"include_media": include_media,
"include_prompt_records": include_prompt_records,
"include_moderation_records": include_moderation_records,
"entries": entries,
"warnings": warnings,
}
@ -106,7 +121,7 @@ class DataBackupService:
with zipfile.ZipFile(path) as archive:
manifest = _read_manifest(archive)
_validate_archive(archive, manifest)
safety_backup = self.create_backup(include_media=False)
safety_backup = self.create_backup(include_media=False, include_prompt_records=True, include_moderation_records=True)
with tempfile.TemporaryDirectory(prefix="imagestudio-restore-") as temp_dir:
temp = Path(temp_dir)
archive.extractall(temp)
@ -153,7 +168,7 @@ class DataBackupService:
except Exception:
loaded = {}
stat = path.stat()
return {"backup_id": loaded.get("backup_id") or path.stem, "created_at": loaded.get("created_at") or datetime.fromtimestamp(stat.st_mtime,timezone.utc).isoformat(), "size_bytes": stat.st_size, "file_count": len(loaded.get("entries") or []), "database_backend": loaded.get("database_backend"), "include_media": bool(loaded.get("include_media")), "warnings": loaded.get("warnings") or []}
return {"backup_id": loaded.get("backup_id") or path.stem, "created_at": loaded.get("created_at") or datetime.fromtimestamp(stat.st_mtime,timezone.utc).isoformat(), "size_bytes": stat.st_size, "file_count": len(loaded.get("entries") or []), "database_backend": loaded.get("database_backend"), "include_media": bool(loaded.get("include_media")), "include_prompt_records": loaded.get("include_prompt_records", True), "include_moderation_records": loaded.get("include_moderation_records", True), "material_schema_version": loaded.get("material_schema_version"), "warnings": loaded.get("warnings") or []}
def _entry(path: Path, archive_path: str) -> dict[str, Any]:
@ -200,3 +215,79 @@ def _validate_archive(archive: zipfile.ZipFile, manifest: dict[str, Any]) -> Non
digest = hashlib.sha256(archive.read(name)).hexdigest()
if digest != item.get("sha256"):
raise ApiError(ErrorCode.VALIDATION_FAILED, "backup checksum mismatch", {"path": name})
def _sanitize_sqlite_backup(
path: Path,
*,
include_prompt_records: bool,
include_moderation_records: bool,
) -> None:
conn = sqlite3.connect(path)
conn.row_factory = sqlite3.Row
try:
tables = {str(row["name"]) for row in conn.execute("SELECT name FROM sqlite_master WHERE type = 'table'")}
if not include_prompt_records:
if "materials" in tables:
conn.execute("UPDATE materials SET prompt = NULL, negative_prompt = NULL")
if "generation_images" in tables:
conn.execute("UPDATE generation_images SET positive_prompt = NULL, negative_prompt = NULL")
json_columns = {
"materials": ("material_id", ("metadata_json",)),
"generation_images": ("image_id", ("metadata_json",)),
"generation_tasks": ("task_id", ("request_json", "result_json", "metadata_json")),
"audit_logs": ("audit_id", ("before_snapshot", "after_snapshot", "metadata_json")),
}
for table, (primary_key, columns) in json_columns.items():
if table not in tables:
continue
existing_columns = {str(row["name"]) for row in conn.execute(f"PRAGMA table_info({table})")}
selected_columns = [column for column in columns if column in existing_columns]
if not selected_columns:
continue
for row in conn.execute(f"SELECT {primary_key}, {', '.join(selected_columns)} FROM {table}").fetchall():
updates: dict[str, str | None] = {}
for column in selected_columns:
raw = row[column]
if not raw:
continue
try:
parsed = json.loads(raw)
except (TypeError, json.JSONDecodeError):
continue
cleaned = _strip_sensitive_records(
parsed,
include_prompt_records=include_prompt_records,
include_moderation_records=include_moderation_records,
)
updates[column] = json.dumps(cleaned, ensure_ascii=False, separators=(",", ":"))
if updates:
assignments = ", ".join(f"{column} = ?" for column in updates)
conn.execute(f"UPDATE {table} SET {assignments} WHERE {primary_key} = ?", (*updates.values(), row[primary_key]))
conn.commit()
finally:
conn.close()
def _strip_sensitive_records(
value: Any,
*,
include_prompt_records: bool,
include_moderation_records: bool,
) -> Any:
prompt_keys = {"prompt", "positive_prompt", "negative_prompt", "expanded_prompt", "expanded_negative_prompt", "original_text", "translated_text", "normalized_text", "source_payload"}
moderation_keys = {"prompt_governance", "moderation", "moderation_recheck", "image_moderation", "route_fallback", "generation_route_decision"}
if isinstance(value, dict):
result: dict[str, Any] = {}
for key, item in value.items():
lowered = str(key).lower()
if not include_prompt_records and lowered in prompt_keys:
result[key] = "[EXCLUDED_FROM_BACKUP]"
continue
if not include_moderation_records and lowered in moderation_keys:
continue
result[key] = _strip_sensitive_records(item, include_prompt_records=include_prompt_records, include_moderation_records=include_moderation_records)
return result
if isinstance(value, list):
return [_strip_sensitive_records(item, include_prompt_records=include_prompt_records, include_moderation_records=include_moderation_records) for item in value]
return value

查看文件

@ -8,12 +8,22 @@ from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.dto.job_dto import GenerationTask
from backend.services.cost_guard_service import CostGuardService
from backend.services.composition_builder import CompositionBuilder
from backend.services.generation_reference_service import GenerationReferenceService, MaterialResolver
from backend.services.image_service import ImageService
from backend.services.model_provider_service import ModelProviderService
from backend.services.node_dependency_context_service import NodeDependencyContextService
from backend.services.prompt_expansion_service import PromptExpansionService
from backend.services.prompt_governance_service import (
GenerationFailureClassifier,
GenerationRouteService,
ImageModerationService,
PromptModerationService,
PromptSemanticNormalizer,
PromptTranslationService,
)
from backend.services.queue_service import QueueService
from backend.services.reference_binding_mapper import ReferenceBindingMapper
from backend.services.workflow_service import (
LOCKED_NODE_STATUSES,
WorkflowService,
@ -52,6 +62,14 @@ class GenerationService:
require_resolved_model_route: bool = False,
material_resolver: MaterialResolver | None = None,
model_assignments: dict[str, Any] | None = None,
prompt_translation_service: PromptTranslationService | None = None,
prompt_semantic_normalizer: PromptSemanticNormalizer | None = None,
prompt_moderation_service: PromptModerationService | None = None,
generation_route_service: GenerationRouteService | None = None,
generation_failure_classifier: GenerationFailureClassifier | None = None,
image_moderation_service: ImageModerationService | None = None,
reference_binding_mapper: ReferenceBindingMapper | None = None,
composition_builder: CompositionBuilder | None = None,
):
self.workflow_service = workflow_service
self.queue_service = queue_service
@ -69,6 +87,15 @@ class GenerationService:
self.default_model_route = _optional_text(default_model_route)
self.model_assignments = dict(model_assignments or {})
self.require_resolved_model_route = require_resolved_model_route
self.prompt_translation_service = prompt_translation_service
self.prompt_semantic_normalizer = prompt_semantic_normalizer
self.prompt_moderation_service = prompt_moderation_service
self.generation_route_service = generation_route_service
self.generation_failure_classifier = generation_failure_classifier or GenerationFailureClassifier()
self.image_moderation_service = image_moderation_service
self.reference_binding_mapper = reference_binding_mapper or ReferenceBindingMapper()
self.composition_builder = composition_builder or CompositionBuilder()
self.material_resolver = material_resolver
def generate_node(self, node_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
lock_entry = _retain_node_generation_lock(node_id)
@ -120,7 +147,7 @@ class GenerationService:
profile = self.workflow_service.profile_repository.get(workflow.profile_id)
profile_model_route = _optional_text(getattr(profile, "default_model_route", None))
assigned_route = _optional_text(self.model_assignments.get(_assignment_key(node)))
model_route = str(
requested_model_route = str(
payload.get("model_route")
or node.model_route
or assigned_route
@ -128,22 +155,52 @@ class GenerationService:
or self.default_model_route
or "image_low"
)
enriched_payload = self._enrich_generation_payload(node.node_id, payload)
prompt_expansion = self._expand_prompt(workflow.profile_id, node, enriched_payload)
governance = self._govern_prompt(
node=node,
payload=enriched_payload,
prompt_expansion=prompt_expansion,
requested_route=requested_model_route,
ctx=ctx,
)
model_route = governance["route_decision"]["selected_route"] if governance else requested_model_route
if governance and governance.get("prompt"):
prompt_expansion = {
**(prompt_expansion or {}),
"prompt": governance["prompt"],
"negative_prompt": governance.get("negative_prompt") or (prompt_expansion or {}).get("negative_prompt", ""),
"governance": governance,
}
route_resolution = self._resolve_model_route(model_route)
if governance:
excluded_fallback = _optional_text(governance.get("route_decision", {}).get("fallback_route"))
if excluded_fallback and excluded_fallback != model_route:
route_resolution["excluded_fallback_routes"] = [excluded_fallback]
if self.require_resolved_model_route and route_resolution.get("status") != "resolved":
raise ApiError(
ErrorCode.MODEL_CAPABILITY_UNCONFIRMED,
"未找到可用的生图模型路由,请先在模型配置中完成提供商与路由设置",
{"model_route": model_route, "resolution": route_resolution},
)
reference_mapping = self.reference_binding_mapper.map(_reference_binding_summary(enriched_payload), route_resolution)
if reference_mapping["text_constraints"]:
base_prompt = _optional_text((prompt_expansion or {}).get("prompt")) or _optional_text(getattr(node, "prompt", None)) or ""
prompt_expansion = {
**(prompt_expansion or {}),
"prompt": ", ".join([base_prompt, *reference_mapping["text_constraints"]]),
"negative_prompt": _optional_text((prompt_expansion or {}).get("negative_prompt")) or "",
"reference_binding_mapping": reference_mapping,
}
cost_guard = self._check_cost_budget(payload, model_route, route_resolution)
enriched_payload = self._enrich_generation_payload(node.node_id, payload)
prompt_expansion = self._expand_prompt(workflow.profile_id, node, enriched_payload)
reference_images = self.reference_service.resolve(workflow.workflow_id, enriched_payload)
runtime_generation_request = {
**payload,
"model_route": model_route,
"resolved_model_route": route_resolution,
**({"cost_guard": cost_guard} if cost_guard else {}),
**({"prompt_governance": governance} if governance else {}),
"reference_binding_mapping": reference_mapping,
**(
{
"prompt_expansion": prompt_expansion,
@ -171,6 +228,7 @@ class GenerationService:
"metadata": {
"source": "nodes.generate",
"model_route_resolution": route_resolution,
**({"prompt_governance": _governance_audit_summary(governance)} if governance else {}),
},
},
ctx,
@ -262,13 +320,29 @@ class GenerationService:
)
assets: list[Any] = []
images: list[Any] = []
restricted_images: list[Any] = []
try:
runtime_generation_request = {
**runtime_generation_request,
"input_images": reference_images,
}
runtime_generation_request.pop("image", None)
assets = self.single_flow_engine.generate(running_node, task, runtime_generation_request)
try:
assets = self.single_flow_engine.generate(running_node, task, runtime_generation_request)
except ImageProviderError as exc:
fallback = self._content_safety_fallback(
exc=exc,
runtime_request=runtime_generation_request,
governance=governance,
requested_route=requested_model_route,
ctx=ctx,
)
if fallback is None:
raise
runtime_generation_request = fallback["request"]
route_resolution = fallback["route_resolution"]
model_route = fallback["model_route"]
assets = self.single_flow_engine.generate(running_node, task, runtime_generation_request)
if self._cancel_generation_if_requested(task.task_id, workflow.workflow_id, ctx):
return self._finalize_cancelled_generation(
task_id=task.task_id,
@ -278,31 +352,58 @@ class GenerationService:
images=images,
ctx=ctx,
)
precomputed_moderation: dict[str, dict[str, Any]] = {}
if self.image_moderation_service:
for asset in assets:
preview_payload = {
"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,
}
precomputed_moderation[asset.image_uri] = self._moderate_generated_image(preview_payload, governance, model_route)
if any(item.get("action") == "regenerate" for item in precomputed_moderation.values()) and not runtime_generation_request.get("post_moderation_regeneration"):
self._cleanup_generation_outputs(assets=assets, images=[])
retry_seed = int(runtime_generation_request.get("seed") or 1000) + 1
runtime_generation_request = {**runtime_generation_request, "seed": retry_seed, "post_moderation_regeneration": {"attempted": True, "reason": "image_moderation"}}
assets = self.single_flow_engine.generate(running_node, task, runtime_generation_request)
precomputed_moderation = {}
for asset in assets:
images.append(
self.image_service.create_image(
{
"profile_id": workflow.profile_id,
"workflow_id": workflow.workflow_id,
"node_id": node_id,
"task_id": task.task_id,
"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,
"height": asset.height,
# Keep records unselected until the task completion CAS
# wins. A concurrent cancellation can then roll them
# back without disturbing an older selected image.
"is_selected": False,
"metadata": asset.metadata,
},
ctx,
)
)
image_payload = {
"profile_id": workflow.profile_id,
"workflow_id": workflow.workflow_id,
"node_id": node_id,
"task_id": task.task_id,
"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,
"height": asset.height,
# Keep records unselected until the task completion CAS
# wins. A concurrent cancellation can then roll them
# back without disturbing an older selected image.
"is_selected": False,
"metadata": {
**asset.metadata,
**({"prompt_governance": _governance_audit_summary(governance)} if governance else {}),
"reference_binding_mapping": runtime_generation_request.get("reference_binding_mapping") or {},
},
}
moderation = precomputed_moderation.get(asset.image_uri) or self._moderate_generated_image(image_payload, governance, model_route)
self._apply_restoration_feedback(moderation)
image_payload["metadata"] = {**image_payload["metadata"], "image_moderation": moderation}
if moderation.get("action") in {"quarantine", "reject", "regenerate"}:
image_payload["metadata"]["quarantined"] = True
image_payload["metadata"]["gallery_visibility"] = "restricted"
created_image = self.image_service.create_image(image_payload, ctx)
if moderation.get("action") in {"quarantine", "reject", "regenerate"}:
restricted_images.append(created_image)
else:
images.append(created_image)
except Exception as exc:
if self._cancel_generation_if_requested(task.task_id, workflow.workflow_id, ctx):
return self._finalize_cancelled_generation(
@ -313,7 +414,7 @@ class GenerationService:
images=images,
ctx=ctx,
)
self._cleanup_generation_outputs(assets=assets, images=images)
self._cleanup_generation_outputs(assets=assets, images=[*images, *restricted_images])
failure = self._record_generation_failure(
task=task,
node_id=node_id,
@ -340,6 +441,9 @@ class GenerationService:
) from exc
provider_failure = _provider_failure_from_assets([asset.metadata for asset in assets])
result: dict[str, Any] = {"image_ids": [image.image_id for image in images]}
if restricted_images:
result["restricted_image_ids"] = [image.image_id for image in restricted_images]
result["image_moderation"] = "restricted"
update_payload: dict[str, Any] = {
"status": "succeeded",
"progress": 100,
@ -366,7 +470,7 @@ class GenerationService:
images=images,
ctx=ctx,
)
self._cleanup_generation_outputs(assets=assets, images=images)
self._cleanup_generation_outputs(assets=assets, images=[*images, *restricted_images])
raise ApiError(
ErrorCode.GENERATION_FAILED,
"generation task changed before completion",
@ -389,6 +493,7 @@ class GenerationService:
"task_status": completed_task.status,
"node_status": completed_node.status,
"images": [image.to_dict() for image in images],
**({"restricted_count": len(restricted_images), "image_moderation": "restricted"} if restricted_images else {}),
}
def _existing_generation_response(self, task: GenerationTask, node_id: str) -> dict[str, Any]:
@ -439,6 +544,8 @@ class GenerationService:
"model_id": resolved["model_id"],
"modality": resolved["modality"],
"priority": resolved["priority"],
"settings": dict(resolved.get("settings") or {}),
"capabilities": dict(provider.get("capabilities") or {}),
}
def _check_cost_budget(
@ -530,6 +637,195 @@ class GenerationService:
return None
return self.prompt_expansion_service.expand_for_node(profile, node, payload)
def _govern_prompt(
self,
*,
node: Any,
payload: dict[str, Any],
prompt_expansion: dict[str, Any] | None,
requested_route: str,
ctx: RequestContext,
) -> dict[str, Any] | None:
if not any((self.prompt_translation_service, self.prompt_semantic_normalizer, self.prompt_moderation_service, self.generation_route_service)):
return None
original = _optional_text(payload.get("user_prompt") or payload.get("prompt") or payload.get("prompt_patch")) or _optional_text(getattr(node, "prompt", None)) or ""
expanded = _optional_text((prompt_expansion or {}).get("prompt")) or original
negative = _optional_text((prompt_expansion or {}).get("negative_prompt")) or _optional_text(getattr(node, "negative_prompt", None)) or ""
entrypoint = _entrypoint(payload)
locked_terms = _string_list(payload.get("locked_terms"))
translation = None
translated = expanded
if self.prompt_translation_service:
translation_result = self.prompt_translation_service.translate(
expanded,
entrypoint=entrypoint,
user_allowed=bool(payload.get("translation_consent", False)),
model_family=str(payload.get("prompt_model_family") or "natural_language"),
locked_terms=locked_terms,
budget=_positive_int(payload.get("prompt_budget")),
)
translation = translation_result.to_dict()
translated = translation_result.translated_text
normalization = None
final_prompt = translated
if self.prompt_semantic_normalizer:
normalization = self.prompt_semantic_normalizer.normalize(translated, locked_terms=locked_terms)
final_prompt = normalization["normalized_text"]
moderation = (
self.prompt_moderation_service.moderate(
original_prompt=original,
translated_prompt=translated,
final_prompt=final_prompt,
negative_prompt=negative,
reference_bindings=_reference_binding_summary(payload),
)
if self.prompt_moderation_service
else None
)
if moderation is None:
from backend.services.prompt_governance_service import PromptModerationDecision
moderation = PromptModerationDecision("safe", 1.0, [], ["moderation_not_configured"], "allow", None, "none", None, "")
if self.generation_route_service:
route = self.generation_route_service.decide(
requested_route,
moderation,
entrypoint=entrypoint,
user_id=ctx.actor_id,
group_id=_optional_text(payload.get("group_id") or payload.get("chat_group_id")),
permission_context=_permission_context(payload),
)
else:
from backend.services.prompt_governance_service import GenerationRouteDecision
route = GenerationRouteDecision(requested_route, moderation.level, requested_route if moderation.allowed else None, "static_route", None, moderation.allowed, moderation.level == "uncertain", "")
if not route.allowed:
if moderation.level in {"terror_prohibited", "violence_prohibited", "prohibited"}:
try:
self.workflow_service.audit_service.record(
ctx=ctx,
action="generation_content_safety_blocked",
target_type="workflow_node",
target_id=str(getattr(node, "node_id", "")),
metadata={
"priority": "high" if moderation.level in {"terror_prohibited", "violence_prohibited"} else "normal",
"entrypoint": entrypoint,
"moderation_level": moderation.level,
"reason_codes": moderation.reason_codes,
"rules_version": moderation.rules_version,
"group_id": _optional_text(payload.get("group_id") or payload.get("chat_group_id")),
},
)
except Exception:
pass
raise ApiError(
ErrorCode.VALIDATION_FAILED,
moderation.warning or ("内容需要确认后才能生成" if route.requires_confirmation else "内容审核未通过,未创建生成任务"),
{
"moderation_level": moderation.level,
"reason_codes": moderation.reason_codes,
"route_reason": route.reason,
"requires_confirmation": route.requires_confirmation,
"warning": moderation.warning,
},
)
return {
"prompt": final_prompt,
"negative_prompt": negative,
"translation": translation,
"normalization": normalization,
"moderation": moderation.to_dict(),
"route_decision": route.to_dict(),
"entrypoint": entrypoint,
}
def _content_safety_fallback(
self,
*,
exc: ImageProviderError,
runtime_request: dict[str, Any],
governance: dict[str, Any] | None,
requested_route: str,
ctx: RequestContext,
) -> dict[str, Any] | None:
failure = self.generation_failure_classifier.classify(exc)
if failure["failure_class"] != "content_safety_rejection" or not self.prompt_moderation_service or not self.generation_route_service:
return None
if (runtime_request.get("route_fallback") or {}).get("attempted"):
return None
prompt = _optional_text(runtime_request.get("expanded_prompt")) or ""
negative = _optional_text(runtime_request.get("expanded_negative_prompt")) or ""
translation = (governance or {}).get("translation")
translation = translation if isinstance(translation, dict) else {}
moderation = self.prompt_moderation_service.moderate(
original_prompt=_optional_text(translation.get("original_text")) or prompt,
translated_prompt=_optional_text(translation.get("translated_text")) or prompt,
final_prompt=prompt,
negative_prompt=negative,
reference_bindings=[],
)
payload = runtime_request
route = self.generation_route_service.decide(
requested_route,
moderation,
entrypoint=_entrypoint(payload),
user_id=ctx.actor_id,
group_id=_optional_text(payload.get("group_id") or payload.get("chat_group_id")),
permission_context=_permission_context(payload),
)
if not route.allowed or moderation.level != "adult_allowed" or not route.selected_route or route.selected_route == runtime_request.get("model_route"):
return None
resolution = self._resolve_model_route(route.selected_route)
if self.require_resolved_model_route and resolution.get("status") != "resolved":
return None
fallback_cost_guard = self._check_cost_budget(runtime_request, route.selected_route, resolution)
fallback_record = {
"attempted": True,
"initial_route": runtime_request.get("model_route"),
"failure_class": failure,
"moderation_recheck": moderation.to_dict(),
"fallback_route": route.selected_route,
"fallback_reason": route.reason,
}
return {
"model_route": route.selected_route,
"route_resolution": resolution,
"request": {
**runtime_request,
"model_route": route.selected_route,
"resolved_model_route": resolution,
"route_fallback": fallback_record,
"allow_provider_fallback": False,
**({"cost_guard": fallback_cost_guard} if fallback_cost_guard else {}),
},
}
def _moderate_generated_image(self, image_payload: dict[str, Any], governance: dict[str, Any] | None, model_route: str) -> dict[str, Any]:
if not self.image_moderation_service:
return {"status": "not_configured", "action": "allow", "version": "none"}
level = _optional_text((governance or {}).get("moderation", {}).get("level")) or "safe"
route_kind = "nsfw" if level == "adult_allowed" else "safe"
return self.image_moderation_service.moderate(image_payload, requested_level=level, route_kind=route_kind)
def _apply_restoration_feedback(self, moderation: dict[str, Any]) -> None:
if self.material_resolver is None or not hasattr(self.material_resolver, "update_material"):
return
scores = moderation.get("material_restoration_scores")
if not isinstance(scores, dict):
return
for material_id, raw_score in scores.items():
try:
score = min(max(float(raw_score), 0.0), 1.0)
material = self.material_resolver.get_material(str(material_id))
if material is None:
continue
old = material.metadata.get("restoration_feedback") if isinstance(material.metadata.get("restoration_feedback"), dict) else {}
count = int(old.get("count") or 0)
average = ((float(old.get("score") or 0.0) * count) + score) / (count + 1)
self.material_resolver.update_material(str(material_id), {"metadata": {**material.metadata, "restoration_feedback": {"score": round(average, 4), "count": count + 1}}})
except Exception:
continue
def _enrich_generation_payload(self, node_id: str, payload: dict[str, Any]) -> dict[str, Any]:
enriched_payload = dict(payload)
if not isinstance(enriched_payload.get("dependency_context"), dict):
@ -537,8 +833,64 @@ class GenerationService:
self.workflow_service,
self.image_service,
).get_context(node_id)
self._compile_material_bindings(enriched_payload)
return enriched_payload
def _compile_material_bindings(self, payload: dict[str, Any]) -> None:
if self.material_resolver is None:
return
dependency = payload.get("dependency_context") if isinstance(payload.get("dependency_context"), dict) else {}
bindings = dependency.get("material_bindings") if isinstance(dependency.get("material_bindings"), dict) else {}
active = bindings.get("active_bindings") if isinstance(bindings.get("active_bindings"), list) else []
materials: list[dict[str, Any]] = []
for binding in active:
if not isinstance(binding, dict):
continue
material_ref = binding.get("material") if isinstance(binding.get("material"), dict) else {}
material_id = _optional_text(material_ref.get("material_id") or binding.get("material_id"))
material = self.material_resolver.get_material(material_id) if material_id else None
if material is None or str(getattr(material, "recognition_status", "")) != "confirmed":
continue
strength = binding.get("reference_strength") if isinstance(binding.get("reference_strength"), dict) else {}
materials.append({
"material_id": material.material_id,
"category": binding.get("category"),
"prompt": material.prompt or material_ref.get("prompt"),
"negative_prompt": material.negative_prompt,
"image_uri": material.image_uri,
"metadata": material.metadata,
"user_adjustment": 20.0 if binding.get("required") else 0.0,
"visibility_bonus": 10.0 if binding.get("required") else 0.0,
"reference_strength": strength.get("key"),
"restoration_score": (
material.metadata.get("restoration_feedback", {}).get("score")
if isinstance(material.metadata.get("restoration_feedback"), dict)
else None
),
})
if not materials:
return
composition = self.composition_builder.build({
"materials": materials,
"prompt_budget": payload.get("prompt_budget") or 4000,
"max_reference_images": payload.get("max_reference_images") or 8,
"visible_slots": payload.get("visible_slots") or [],
"season": payload.get("season") or "",
"scene": payload.get("scene") or "",
}).to_dict()
dependency["material_bindings"] = {
**bindings,
"composition": composition,
"material_prompts": [composition["prompt"]] if composition.get("prompt") else [],
"prompt_context": composition.get("prompt") or "",
"reference_bindings": composition.get("reference_bindings") or [],
"generation_params": {
**(bindings.get("generation_params") if isinstance(bindings.get("generation_params"), dict) else {}),
"reference_material_ids": [item["material_id"] for item in composition.get("selected_materials") or []],
},
}
payload["dependency_context"] = dependency
def _publish(self, event_type: str, payload: dict[str, Any]) -> None:
if self.event_bus:
self.event_bus.publish(event_type, payload)
@ -825,3 +1177,86 @@ def _planned_image_count(value: Any) -> int:
except (TypeError, ValueError):
count = 1
return min(max(count, 1), 8)
def _entrypoint(payload: dict[str, Any]) -> str:
value = _optional_text(payload.get("entrypoint") or payload.get("platform") or payload.get("source")) or "web"
lowered = value.lower()
if "qq" in lowered or "onebot" in lowered:
return "qq"
if "telegram" in lowered:
return "telegram"
if "discord" in lowered:
return "discord"
if lowered in {"web", "api"}:
return lowered
return "unknown"
def _permission_context(payload: dict[str, Any]) -> dict[str, Any]:
configured = payload.get("content_permissions") if isinstance(payload.get("content_permissions"), dict) else {}
result = {
**configured,
"adult_user_allowed": bool(configured.get("adult_user_allowed", payload.get("adult_user_allowed", False))),
"quota_allowed": bool(configured.get("quota_allowed", payload.get("quota_allowed", True))),
}
if "adult_group_allowed" in configured or "adult_group_allowed" in payload:
result["adult_group_allowed"] = bool(configured.get("adult_group_allowed", payload.get("adult_group_allowed")))
return result
def _reference_binding_summary(payload: dict[str, Any]) -> list[dict[str, Any]]:
composition = payload.get("composition") if isinstance(payload.get("composition"), dict) else {}
bindings = composition.get("reference_bindings")
if not isinstance(bindings, list):
dependency = payload.get("dependency_context") if isinstance(payload.get("dependency_context"), dict) else {}
material_bindings = dependency.get("material_bindings") if isinstance(dependency.get("material_bindings"), dict) else {}
bindings = material_bindings.get("reference_bindings")
return [dict(item) for item in bindings or [] if isinstance(item, dict)]
def _governance_audit_summary(governance: dict[str, Any]) -> dict[str, Any]:
translation = governance.get("translation") if isinstance(governance.get("translation"), dict) else {}
moderation = governance.get("moderation") if isinstance(governance.get("moderation"), dict) else {}
route = governance.get("route_decision") if isinstance(governance.get("route_decision"), dict) else {}
normalization = governance.get("normalization") if isinstance(governance.get("normalization"), dict) else {}
return {
"translation": {
"status": translation.get("status"),
"model_route": translation.get("model_route"),
"template_version": translation.get("template_version"),
"accepted": translation.get("accepted"),
},
"normalization": {
"changed_terms": normalization.get("changed_terms") or [],
"meaning_preserved": normalization.get("meaning_preserved", True),
"version": normalization.get("version"),
},
"moderation": {
"level": moderation.get("level"),
"confidence": moderation.get("confidence"),
"categories": moderation.get("categories") or [],
"reason_codes": moderation.get("reason_codes") or [],
"rules_version": moderation.get("rules_version"),
},
"route_decision": route,
"entrypoint": governance.get("entrypoint"),
}
def _string_list(value: Any) -> list[str]:
if isinstance(value, str):
values = value.split(",")
elif isinstance(value, (list, tuple, set)):
values = value
else:
return []
return [str(item).strip() for item in values if str(item).strip()]
def _positive_int(value: Any) -> int | None:
try:
number = int(value)
except (TypeError, ValueError):
return None
return number if number > 0 else None

查看文件

@ -111,6 +111,34 @@ class ImageService:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "图片不存在", {"image_id": image_id})
return image
def review_moderated_image(self, image_id: str, payload: dict[str, Any], ctx: RequestContext) -> GenerationImage:
before = self.get_image(image_id)
action = str(payload.get("action") or "").strip().lower()
if action not in {"approve", "reject"}:
raise ApiError(ErrorCode.VALIDATION_FAILED, "moderation review action must be approve or reject", {"field": "action"})
metadata = before.metadata if isinstance(before.metadata, dict) else {}
if not (metadata.get("quarantined") or metadata.get("gallery_visibility") == "restricted"):
raise ApiError(ErrorCode.VALIDATION_FAILED, "image is not awaiting moderation review", {"image_id": image_id})
review = {
"action": action,
"reviewer_id": ctx.actor_id,
"reason": str(payload.get("reason") or "").strip(),
}
update = {
"metadata": {
**metadata,
"quarantined": False if action == "approve" else True,
"gallery_visibility": "normal" if action == "approve" else "restricted",
"moderation_admin_review": review,
},
**({"is_archived": True} if action == "reject" else {}),
}
after = self.image_repository.update(image_id, update)
if after is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "图片不存在", {"image_id": image_id})
self.audit_service.record(ctx=ctx, action="review_moderated_image", target_type="generation_image", target_id=image_id, before_snapshot=before.to_dict(), after_snapshot=after.to_dict(), metadata=review)
return after
def select_image(self, image_id: str, ctx: RequestContext) -> GenerationImage:
before = self.get_image(image_id)
self._ensure_image_node_is_editable(before)

查看文件

@ -0,0 +1,97 @@
"""Aggregate material composition and prompt-governance adoption metrics."""
from __future__ import annotations
import json
from collections import Counter
from typing import Any
from database.db_helper import Database
class MaterialAnalyticsService:
def __init__(self, database: Database):
self.database = database
def summarize(self) -> dict[str, Any]:
conn = self.database.connect()
try:
materials = conn.execute("SELECT recognition_status, metadata_json FROM materials WHERE recognition_status != 'archived'").fetchall()
audits = conn.execute("SELECT action, after_snapshot, metadata_json FROM audit_logs WHERE action IN ('wardrobe_match','apply_wardrobe_template','recognize_material','renormalize_material')").fetchall()
tasks = conn.execute("SELECT model_route, request_json, metadata_json FROM generation_tasks").fetchall()
finally:
conn.close()
schema_count = 0
confirmed_count = 0
category_counts: Counter[str] = Counter()
needs_confirmation = 0
for row in materials:
metadata = _json(row["metadata_json"])
profile = metadata.get("normalized_asset_profile") if isinstance(metadata.get("normalized_asset_profile"), dict) else {}
if profile:
schema_count += 1
category_counts[str(profile.get("category") or "other")] += 1
needs_confirmation += int(bool(profile.get("requires_confirmation")))
confirmed_count += int(str(row["recognition_status"]) == "confirmed")
composition_count = conflicts = ignored = downgraded = 0
for row in audits:
snapshot = _json(row["after_snapshot"])
composition = snapshot.get("composition") if isinstance(snapshot.get("composition"), dict) else snapshot.get("composition_result") if isinstance(snapshot.get("composition_result"), dict) else {}
if not composition and row["action"] == "wardrobe_match":
composition = snapshot.get("composition") if isinstance(snapshot.get("composition"), dict) else {}
if composition:
composition_count += 1
conflicts += len(composition.get("conflicts") or [])
ignored += len(composition.get("ignored_materials") or [])
downgraded += len(composition.get("downgraded_materials") or [])
translation_status: Counter[str] = Counter()
moderation_levels: Counter[str] = Counter()
route_reasons: Counter[str] = Counter()
route_counts: Counter[str] = Counter()
for row in tasks:
request = _json(row["request_json"])
governance = request.get("prompt_governance") if isinstance(request.get("prompt_governance"), dict) else {}
translation = governance.get("translation") if isinstance(governance.get("translation"), dict) else {}
moderation = governance.get("moderation") if isinstance(governance.get("moderation"), dict) else {}
route = governance.get("route_decision") if isinstance(governance.get("route_decision"), dict) else {}
if translation:
translation_status[str(translation.get("status") or "unknown")] += 1
if moderation:
moderation_levels[str(moderation.get("level") or "unknown")] += 1
if route:
route_reasons[str(route.get("reason") or "unknown")] += 1
route_counts[str(row["model_route"] or route.get("selected_route") or "unresolved")] += 1
total = len(materials)
return {
"materials": {
"total": total,
"confirmed": confirmed_count,
"schema_adoption_count": schema_count,
"schema_adoption_rate": round(schema_count / total, 4) if total else 0.0,
"needs_confirmation": needs_confirmation,
"categories": dict(category_counts),
},
"composition": {
"runs": composition_count,
"conflicts": conflicts,
"ignored_materials": ignored,
"downgraded_materials": downgraded,
"conflict_rate": round(conflicts / composition_count, 4) if composition_count else 0.0,
},
"prompt_governance": {
"translation_status": dict(translation_status),
"moderation_levels": dict(moderation_levels),
"route_reasons": dict(route_reasons),
"route_distribution": dict(route_counts),
},
}
def _json(value: Any) -> dict[str, Any]:
if isinstance(value, dict):
return value
try:
parsed = json.loads(value or "{}")
except (TypeError, json.JSONDecodeError):
return {}
return parsed if isinstance(parsed, dict) else {}

查看文件

@ -0,0 +1,404 @@
"""Versioned material recognition normalization and generation capsules.
The first rollout intentionally stores these structures inside ``material.metadata``.
That keeps existing database rows and API consumers compatible while giving newer
composition code a stable, explainable representation.
"""
from __future__ import annotations
from copy import deepcopy
from datetime import datetime, timezone
from typing import Any, Mapping
MATERIAL_SCHEMA_VERSION = "1.0"
MATERIAL_PROMPT_VERSION = "1.0"
ASSET_CATEGORIES = {
"identity", "hair", "headwear", "face_accessory", "jewelry", "top", "bottom",
"dress", "suit", "outerwear", "underwear", "hosiery", "footwear", "prop",
"pose", "background", "style", "other",
}
ASSET_ROLES = {"identity", "garment", "accessory", "prop", "pose", "background", "style", "other"}
BODY_SLOTS = {
"identity", "hair", "head", "face", "ears", "neck", "upper_body", "arms", "hands",
"waist", "hips", "upper_legs", "lower_legs", "feet", "pose", "background", "global_style",
}
WEAR_LAYERS = {"skin", "inner", "base", "middle", "outer", "overlay", "accessory", "prop"}
SOURCE_STATES = {"observed", "inferred", "unknown", "occluded", "low_visibility"}
CAPSULE_TIERS = ("compact", "standard", "detailed")
CATEGORY_ALIASES = {
"shirt": "top", "blouse": "top", "t-shirt": "top", "top": "top", "上衣": "top", "衬衫": "top",
"skirt": "bottom", "pants": "bottom", "trousers": "bottom", "shorts": "bottom", "裙子": "bottom", "裤子": "bottom",
"dress": "dress", "gown": "dress", "连衣裙": "dress",
"coat": "outerwear", "jacket": "outerwear", "cloak": "outerwear", "外套": "outerwear",
"shoe": "footwear", "shoes": "footwear", "boot": "footwear", "boots": "footwear", "鞋": "footwear", "靴": "footwear",
"necklace": "jewelry", "earring": "jewelry", "bracelet": "jewelry", "ring": "jewelry", "首饰": "jewelry",
"hat": "headwear", "cap": "headwear", "头饰": "headwear",
"hair": "hair", "发型": "hair", "pose": "pose", "姿势": "pose",
"background": "background", "scene": "background", "背景": "background",
"style": "style", "画风": "style", "character": "identity", "identity": "identity", "角色": "identity",
}
CATEGORY_SEMANTICS: dict[str, tuple[str, list[str], str | None]] = {
"identity": ("identity", ["identity", "face"], None),
"hair": ("identity", ["hair"], None),
"headwear": ("accessory", ["head"], "accessory"),
"face_accessory": ("accessory", ["face"], "accessory"),
"jewelry": ("accessory", ["ears", "neck", "hands"], "accessory"),
"top": ("garment", ["upper_body", "arms"], "base"),
"bottom": ("garment", ["waist", "hips", "upper_legs", "lower_legs"], "base"),
"dress": ("garment", ["upper_body", "waist", "hips", "upper_legs", "lower_legs"], "base"),
"suit": ("garment", ["upper_body", "waist", "hips", "upper_legs", "lower_legs"], "middle"),
"outerwear": ("garment", ["upper_body", "arms"], "outer"),
"underwear": ("garment", ["upper_body", "waist", "hips"], "inner"),
"hosiery": ("garment", ["upper_legs", "lower_legs"], "inner"),
"footwear": ("garment", ["feet"], "base"),
"prop": ("prop", ["hands"], "prop"),
"pose": ("pose", ["pose"], None),
"background": ("background", ["background"], None),
"style": ("style", ["global_style"], None),
"other": ("other", [], None),
}
RAW_ANALYSIS_SCHEMA: dict[str, Any] = {
"type": "object",
"required": ["schema_version", "created_at", "model_source", "attributes"],
"properties": {
"schema_version": {"type": "string"},
"created_at": {"type": "string"},
"model_source": {"type": "object"},
"attributes": {"type": "object"},
"source_payload": {"type": "object"},
},
}
NORMALIZED_ASSET_PROFILE_SCHEMA: dict[str, Any] = {
"type": "object",
"required": ["schema_version", "category", "role", "body_slots", "attributes"],
"properties": {
"category": {"enum": sorted(ASSET_CATEGORIES)},
"role": {"enum": sorted(ASSET_ROLES)},
"body_slots": {"type": "array", "items": {"enum": sorted(BODY_SLOTS)}},
"wear_layer": {"type": ["string", "null"]},
},
}
GENERATION_CAPSULE_SCHEMA: dict[str, Any] = {
"type": "object",
"required": ["schema_version", "prompt_version", "tier", "prompt_parts", "negative_parts"],
"properties": {"tier": {"enum": list(CAPSULE_TIERS)}},
}
class MaterialNormalizationError(ValueError):
"""Raised when provider data cannot be normalized safely."""
class MaterialNormalizationService:
def normalize_recognition(
self,
structured_data: Mapping[str, Any],
*,
prompt: str,
negative_prompt: str | None,
tags: list[str],
confidence: float | None,
provider_id: str,
model: str,
route_name: str,
category_hint: str | None = None,
previous_metadata: Mapping[str, Any] | None = None,
) -> dict[str, Any]:
now = _utc_now()
payload = deepcopy(dict(structured_data))
raw_section = payload.get("raw_analysis") if isinstance(payload.get("raw_analysis"), dict) else payload
raw_attributes = self._normalize_attributes(raw_section.get("attributes"), confidence)
if not raw_attributes:
raw_attributes = self._attributes_from_legacy(prompt, tags, confidence)
raw_analysis = {
"schema_version": MATERIAL_SCHEMA_VERSION,
"prompt_version": MATERIAL_PROMPT_VERSION,
"created_at": now,
"model_source": {"provider_id": provider_id, "model": model, "route_name": route_name},
"attributes": raw_attributes,
"description": _text(raw_section.get("description") or payload.get("description")),
"source_payload": payload,
}
profile_input = payload.get("normalized_asset_profile")
if not isinstance(profile_input, dict):
profile_input = payload.get("asset_profile") if isinstance(payload.get("asset_profile"), dict) else {}
normalized = self._build_profile(
profile_input,
raw_attributes=raw_attributes,
prompt=prompt,
negative_prompt=negative_prompt,
tags=tags,
confidence=confidence,
category_hint=category_hint,
created_at=now,
)
capsules = self._build_capsules(payload.get("generation_capsules"), normalized, prompt, negative_prompt, now)
result = {"raw_analysis": raw_analysis, "normalized_asset_profile": normalized, "generation_capsules": capsules}
validate_material_structures(result)
return self._preserve_history(result, previous_metadata)
def ensure_legacy_structures(
self,
*,
prompt: str | None,
negative_prompt: str | None,
tags: list[str],
metadata: Mapping[str, Any] | None,
category_hint: str | None = None,
) -> dict[str, Any]:
existing = deepcopy(dict(metadata or {}))
if all(isinstance(existing.get(key), dict) for key in ("raw_analysis", "normalized_asset_profile", "generation_capsules")):
return existing
normalized = self.normalize_recognition(
{"legacy": True},
prompt=_text(prompt) or ", ".join(tags) or "material reference",
negative_prompt=negative_prompt,
tags=tags,
confidence=None,
provider_id="legacy",
model="legacy-prompt",
route_name="legacy",
category_hint=category_hint,
previous_metadata=existing,
)
return {**existing, **normalized, "material_schema_migrated": True}
def _build_profile(
self,
value: Mapping[str, Any],
*,
raw_attributes: dict[str, Any],
prompt: str,
negative_prompt: str | None,
tags: list[str],
confidence: float | None,
category_hint: str | None,
created_at: str,
) -> dict[str, Any]:
category = normalize_category(value.get("category") or category_hint or _category_from_text([*tags, prompt]))
role, default_slots, default_layer = CATEGORY_SEMANTICS[category]
body_slots = _enum_list(value.get("body_slots") or value.get("slots"), BODY_SLOTS) or default_slots
wear_layer = _enum(value.get("wear_layer") or value.get("layer"), WEAR_LAYERS) or default_layer
attributes = {
key: item for key, item in raw_attributes.items()
if item.get("source_state") == "observed" and float(item.get("confidence") or 0.0) >= 0.60
}
requires_confirmation = category == "other" or any(
item.get("source_state") != "observed" or float(item.get("confidence") or 0.0) < 0.80
for item in raw_attributes.values()
)
return {
"schema_version": MATERIAL_SCHEMA_VERSION,
"prompt_version": MATERIAL_PROMPT_VERSION,
"created_at": created_at,
"category": category,
"role": _enum(value.get("role"), ASSET_ROLES) or role,
"body_slots": body_slots,
"wear_layer": wear_layer,
"attributes": attributes,
"must_preserve": _string_list(value.get("must_preserve")),
"forbidden_changes": _string_list(value.get("forbidden_changes")) or _split_prompt(negative_prompt),
"tags": sorted(set(tags)),
"confidence": _confidence(value.get("confidence"), confidence),
"requires_confirmation": requires_confirmation,
"confirmed": bool(value.get("confirmed", False)),
"user_locked": bool(value.get("user_locked", False)),
"stackable": bool(value.get("stackable", category in {"jewelry", "headwear"})),
}
def _build_capsules(
self,
provided: Any,
profile: Mapping[str, Any],
prompt: str,
negative_prompt: str | None,
created_at: str,
) -> dict[str, Any]:
supplied = provided if isinstance(provided, dict) else {}
observed_parts = _attribute_prompt_parts(profile.get("attributes"))
must_preserve = _string_list(profile.get("must_preserve"))
base_parts = _unique([prompt, *observed_parts, *must_preserve])
negative_parts = _unique(_split_prompt(negative_prompt) + _string_list(profile.get("forbidden_changes")))
limits = {"compact": 4, "standard": 10, "detailed": 24}
capsules: dict[str, Any] = {}
for tier in CAPSULE_TIERS:
item = supplied.get(tier) if isinstance(supplied.get(tier), dict) else {}
capsules[tier] = {
"schema_version": MATERIAL_SCHEMA_VERSION,
"prompt_version": MATERIAL_PROMPT_VERSION,
"created_at": created_at,
"tier": tier,
"prompt_parts": _string_list(item.get("prompt_parts")) or base_parts[: limits[tier]],
"negative_parts": _string_list(item.get("negative_parts")) or negative_parts,
"must_preserve": _string_list(item.get("must_preserve")) or must_preserve,
"forbidden_changes": _string_list(item.get("forbidden_changes")) or _string_list(profile.get("forbidden_changes")),
"legacy": not bool(supplied),
}
return capsules
def _normalize_attributes(self, value: Any, fallback_confidence: float | None) -> dict[str, Any]:
if not isinstance(value, dict):
return {}
result: dict[str, Any] = {}
for key, raw in value.items():
name = _text(key).lower().replace(" ", "_")
if not name:
continue
item = raw if isinstance(raw, dict) else {"value": raw}
source_state = _enum(item.get("source_state") or item.get("state"), SOURCE_STATES) or "observed"
confidence = _confidence(item.get("confidence"), fallback_confidence)
result[name] = {
"value": deepcopy(item.get("value")),
"confidence": confidence,
"source_state": source_state,
"source": _text(item.get("source")) or "vision_model",
"locked": bool(item.get("locked", False)),
"eligible_for_generation": source_state == "observed" and confidence >= 0.60,
"requires_confirmation": source_state != "observed" or confidence < 0.80,
}
return result
def _attributes_from_legacy(self, prompt: str, tags: list[str], confidence: float | None) -> dict[str, Any]:
value = _unique([*tags, *_split_prompt(prompt)])
score = _confidence(confidence, 0.60)
return {
"legacy_description": {
"value": value,
"confidence": score,
"source_state": "observed" if confidence is not None else "inferred",
"source": "legacy_prompt",
"locked": False,
"eligible_for_generation": confidence is not None and score >= 0.60,
"requires_confirmation": confidence is None or score < 0.80,
}
}
def _preserve_history(self, current: dict[str, Any], previous_metadata: Mapping[str, Any] | None) -> dict[str, Any]:
previous = dict(previous_metadata or {})
old_profile = previous.get("normalized_asset_profile")
old_raw = previous.get("raw_analysis")
history = list(previous.get("material_schema_history") or [])
if isinstance(old_profile, dict) or isinstance(old_raw, dict):
history.append({"archived_at": _utc_now(), "raw_analysis": old_raw, "normalized_asset_profile": old_profile, "generation_capsules": previous.get("generation_capsules")})
if history:
current["material_schema_history"] = history[-10:]
if isinstance(old_profile, dict):
profile = current["normalized_asset_profile"]
if old_profile.get("confirmed") or old_profile.get("user_locked"):
for key in ("category", "role", "body_slots", "wear_layer", "must_preserve", "forbidden_changes", "stackable", "confirmed", "user_locked"):
if key in old_profile:
profile[key] = deepcopy(old_profile[key])
old_attributes = old_profile.get("attributes")
if isinstance(old_attributes, dict):
for key, item in old_attributes.items():
if isinstance(item, dict) and item.get("locked"):
profile.setdefault("attributes", {})[key] = deepcopy(item)
return current
def normalize_category(value: Any) -> str:
text = _text(value).lower().replace("_", " ").strip()
if text in ASSET_CATEGORIES:
return text
for alias, category in CATEGORY_ALIASES.items():
if alias in text:
return category
return "other"
def validate_material_structures(value: Mapping[str, Any]) -> None:
raw = value.get("raw_analysis")
profile = value.get("normalized_asset_profile")
capsules = value.get("generation_capsules")
if not isinstance(raw, dict) or not isinstance(raw.get("attributes"), dict):
raise MaterialNormalizationError("raw_analysis.attributes must be an object")
if not isinstance(profile, dict) or profile.get("category") not in ASSET_CATEGORIES:
raise MaterialNormalizationError("normalized_asset_profile.category is invalid")
if profile.get("role") not in ASSET_ROLES:
raise MaterialNormalizationError("normalized_asset_profile.role is invalid")
if any(slot not in BODY_SLOTS for slot in profile.get("body_slots", [])):
raise MaterialNormalizationError("normalized_asset_profile.body_slots contains an invalid value")
if profile.get("wear_layer") is not None and profile.get("wear_layer") not in WEAR_LAYERS:
raise MaterialNormalizationError("normalized_asset_profile.wear_layer is invalid")
if not isinstance(capsules, dict) or any(not isinstance(capsules.get(tier), dict) for tier in CAPSULE_TIERS):
raise MaterialNormalizationError("generation_capsules must contain compact, standard and detailed")
def _category_from_text(values: list[str]) -> str:
return " ".join(_text(item) for item in values)
def _attribute_prompt_parts(value: Any) -> list[str]:
if not isinstance(value, dict):
return []
parts: list[str] = []
for name, item in value.items():
if not isinstance(item, dict) or not item.get("eligible_for_generation", True):
continue
raw = item.get("value")
if isinstance(raw, list):
text = ", ".join(_text(part) for part in raw if _text(part))
else:
text = _text(raw)
if text:
parts.append(f"{name.replace('_', ' ')}: {text}")
return parts
def _split_prompt(value: Any) -> list[str]:
text = _text(value)
return [part.strip() for part in text.replace(";", ",").split(",") if part.strip()]
def _string_list(value: Any) -> list[str]:
if isinstance(value, str):
return _split_prompt(value)
if not isinstance(value, (list, tuple, set)):
return []
return _unique([_text(item) for item in value])
def _unique(values: list[str]) -> list[str]:
result: list[str] = []
seen: set[str] = set()
for value in values:
text = _text(value)
key = text.casefold()
if text and key not in seen:
seen.add(key)
result.append(text)
return result
def _enum(value: Any, allowed: set[str]) -> str | None:
text = _text(value).lower()
return text if text in allowed else None
def _enum_list(value: Any, allowed: set[str]) -> list[str]:
values = value if isinstance(value, (list, tuple, set)) else [value]
return _unique([item for item in (_enum(part, allowed) for part in values) if item])
def _confidence(value: Any, fallback: float | None) -> float:
try:
number = float(value if value is not None else fallback if fallback is not None else 0.0)
except (TypeError, ValueError):
number = 0.0
return min(max(number, 0.0), 1.0)
def _text(value: Any) -> str:
return str(value or "").strip()
def _utc_now() -> str:
return datetime.now(timezone.utc).isoformat()

查看文件

@ -3,12 +3,18 @@
from __future__ import annotations
import base64
from dataclasses import replace
from pathlib import PurePosixPath
from typing import Any, Callable
from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.dto.material_dto import Material, MaterialCategory, MaterialListResult
from backend.services.material_normalization_service import (
MaterialNormalizationError,
MaterialNormalizationService,
validate_material_structures,
)
from core.audit_service import AuditService
from core.image_formats import (
IMAGE_EXTENSIONS_BY_MIME,
@ -44,6 +50,7 @@ class MaterialService:
vision_provider_factory: Callable[[dict[str, Any]], VisionProvider | None] | None = None,
default_recognition_route: str = "material_vlm",
recognition_prompt_config: dict[str, Any] | None = None,
normalization_service: MaterialNormalizationService | None = None,
storage: VfsStorage | None = None,
):
self.repository = repository
@ -51,6 +58,7 @@ class MaterialService:
self.vision_provider_factory = vision_provider_factory
self.default_recognition_route = default_recognition_route
self.recognition_prompt_config = recognition_prompt_config or {}
self.normalization_service = normalization_service or MaterialNormalizationService()
self.storage = storage or VfsStorage()
def create_category(self, payload: dict[str, Any], ctx: RequestContext) -> MaterialCategory:
@ -158,27 +166,75 @@ class MaterialService:
keyword: str | None = None,
page: int = 1,
page_size: int = 30,
color: str | None = None,
material_type: str | None = None,
body_slot: str | None = None,
wear_layer: str | None = None,
min_confidence: float | None = None,
confirmation_state: str | None = None,
) -> MaterialListResult:
normalized_page = max(page, 1)
normalized_page_size = min(max(page_size, 1), 100)
advanced_filters = any(value not in (None, "") for value in (color, material_type, body_slot, wear_layer, min_confidence, confirmation_state))
if advanced_filters:
all_items: list[Material] = []
repository_page = 1
while True:
batch, total = self.repository.list_materials(
category_id=category_id,
keyword=keyword,
page=repository_page,
page_size=100,
)
all_items.extend(self._with_material_structures(item) for item in batch)
if len(all_items) >= total or not batch:
break
repository_page += 1
filtered = [
item for item in all_items
if _matches_material_filters(
item,
color=color,
material_type=material_type,
body_slot=body_slot,
wear_layer=wear_layer,
min_confidence=min_confidence,
confirmation_state=confirmation_state,
)
]
start = (normalized_page - 1) * normalized_page_size
return MaterialListResult(items=filtered[start : start + normalized_page_size], total=len(filtered), page=normalized_page, page_size=normalized_page_size)
items, total = self.repository.list_materials(
category_id=category_id,
keyword=keyword,
page=normalized_page,
page_size=normalized_page_size,
)
return MaterialListResult(items=items, total=total, page=normalized_page, page_size=normalized_page_size)
return MaterialListResult(
items=[self._with_material_structures(item) for item in items],
total=total,
page=normalized_page,
page_size=normalized_page_size,
)
def get_material(self, material_id: str) -> Material:
material = self.repository.get_material(material_id)
if material is None or material.recognition_status == "archived":
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "material not found", {"material_id": material_id})
return material
return self._with_material_structures(material)
def update_material(self, material_id: str, payload: dict[str, Any], ctx: RequestContext) -> Material:
before = self.get_material(material_id)
self.validate_material_payload(payload, creating=False)
update_payload = dict(payload)
structured_keys = {"raw_analysis", "normalized_asset_profile", "generation_capsules"}
if structured_keys & update_payload.keys():
metadata = {**before.metadata}
for key in structured_keys:
if key in update_payload:
metadata[key] = update_payload.pop(key)
validate_material_structures(metadata)
update_payload["metadata"] = metadata
if "display_name" in update_payload:
update_payload["display_name"] = str(update_payload["display_name"]).strip()
after = self.repository.update_material(material_id, update_payload)
@ -206,6 +262,12 @@ class MaterialService:
self._validate_storage_uri(payload.get("thumbnail_uri"), "thumbnail_uri")
if creating or "recognition_status" in payload:
self._validate_status(payload.get("recognition_status", "pending_upload"))
metadata = payload.get("metadata")
if isinstance(metadata, dict) and any(key in metadata for key in ("raw_analysis", "normalized_asset_profile", "generation_capsules")):
try:
validate_material_structures(metadata)
except MaterialNormalizationError as exc:
raise ApiError(ErrorCode.VALIDATION_FAILED, str(exc), {"field": "metadata"}) from None
def delete_material(self, material_id: str, ctx: RequestContext) -> Material:
return self.update_material(material_id, {"recognition_status": "archived"}, ctx)
@ -256,6 +318,58 @@ class MaterialService:
material = self.get_material(material_id)
return self._recognize_material(material, ctx)
def renormalize_material(self, material_id: str, ctx: RequestContext) -> Material:
material = self.get_material(material_id)
raw = material.metadata.get("raw_analysis") if isinstance(material.metadata.get("raw_analysis"), dict) else {}
source_payload = raw.get("source_payload") if isinstance(raw.get("source_payload"), dict) else {"legacy": True}
recognition = material.metadata.get("recognition") if isinstance(material.metadata.get("recognition"), dict) else {}
structures = self.normalization_service.normalize_recognition(
source_payload,
prompt=material.prompt or str(raw.get("description") or "material reference"),
negative_prompt=material.negative_prompt,
tags=material.tags,
confidence=recognition.get("confidence"),
provider_id=str(recognition.get("provider_id") or "stored_analysis"),
model=str(recognition.get("model") or "stored_analysis"),
route_name=str(recognition.get("route_name") or "stored_analysis"),
category_hint=self._material_category_hint(material),
previous_metadata=material.metadata,
)
after = self.update_material(material_id, {"metadata": {**material.metadata, **structures}}, ctx)
self.audit_service.record(
ctx=ctx,
action="renormalize_material",
target_type="material",
target_id=material_id,
before_snapshot=material.to_dict(),
after_snapshot=after.to_dict(),
metadata={"vision_provider_called": False},
)
return after
def renormalize_batch(self, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
requested = [str(item).strip() for item in payload.get("material_ids", []) if str(item).strip()] if isinstance(payload.get("material_ids"), list) else []
if not requested:
items: list[Material] = []
page = 1
while True:
batch, total = self.repository.list_materials(page=page, page_size=100)
items.extend(batch)
if len(items) >= total or not batch:
break
page += 1
requested = [item.material_id for item in items if item.recognition_status in {"pending_confirm", "confirmed"}]
limit = min(max(int(payload.get("limit") or 500), 1), 5000)
succeeded: list[str] = []
failed: list[dict[str, str]] = []
for material_id in requested[:limit]:
try:
self.renormalize_material(material_id, ctx)
succeeded.append(material_id)
except Exception as exc:
failed.append({"material_id": material_id, "error_type": exc.__class__.__name__})
return {"requested": min(len(requested), limit), "succeeded": succeeded, "failed": failed, "vision_provider_called": False}
def _recognize_material(self, material: Material, ctx: RequestContext) -> Material:
route_name = _recognition_route(material.metadata, self.default_recognition_route)
provider = self._vision_provider(material, route_name)
@ -288,6 +402,30 @@ class MaterialService:
for key, value in material.metadata.items()
if key not in {"confirmed", "recognition", "recognition_failure"}
}
category_hint = self._material_category_hint(material)
try:
structures = self.normalization_service.normalize_recognition(
recognition.structured_data,
prompt=recognition.prompt,
negative_prompt=recognition.negative_prompt,
tags=generated_tags,
confidence=recognition.confidence,
provider_id=recognition.provider_id,
model=recognition.model,
route_name=route_name,
category_hint=category_hint,
previous_metadata=material.metadata,
)
except MaterialNormalizationError as exc:
failure = {
"source": "material_normalization",
"provider_id": recognition.provider_id,
"status_code": None,
"error_type": "invalid_structured_analysis",
"reason": str(exc),
}
self._record_recognition_failure(material, route_name, failure, ctx)
raise _vision_api_error(material.material_id, route_name, failure) from None
after = self.update_material(
material.material_id,
{
@ -301,6 +439,7 @@ class MaterialService:
recognition,
route_name=route_name,
),
**structures,
},
},
ctx,
@ -393,13 +532,22 @@ class MaterialService:
"required_status": "pending_confirm",
},
)
metadata_patch = payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {}
metadata = {**material.metadata, **metadata_patch, "confirmed": True}
profile = metadata.get("normalized_asset_profile")
if isinstance(profile, dict):
profile = {**profile, "confirmed": True}
for key in ("category", "role", "body_slots", "wear_layer", "must_preserve", "forbidden_changes", "stackable", "user_locked"):
if key in payload:
profile[key] = payload[key]
metadata["normalized_asset_profile"] = profile
update_payload = {
"recognition_status": "confirmed",
"display_name": payload.get("display_name", material.display_name),
"prompt": payload.get("prompt", material.prompt),
"negative_prompt": payload.get("negative_prompt", material.negative_prompt),
"tags": payload.get("tags", material.tags),
"metadata": {**material.metadata, "confirmed": True},
"metadata": metadata,
}
after = self.update_material(material_id, update_payload, ctx)
self.audit_service.record(
@ -412,6 +560,24 @@ class MaterialService:
)
return after
def _material_category_hint(self, material: Material) -> str | None:
if not material.category_id:
return None
category = self.repository.get_category(material.category_id)
return category.name if category else None
def _with_material_structures(self, material: Material) -> Material:
if material.recognition_status not in {"pending_confirm", "confirmed"}:
return material
metadata = self.normalization_service.ensure_legacy_structures(
prompt=material.prompt,
negative_prompt=material.negative_prompt,
tags=material.tags,
metadata=material.metadata,
category_hint=self._material_category_hint(material),
)
return material if metadata == material.metadata else replace(material, metadata=metadata)
def _validate_category(self, category_id: Any) -> None:
if category_id and self.repository.get_category(str(category_id)) is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "category not found", {"category_id": category_id})
@ -701,3 +867,42 @@ def _display_name_from_filename(filename: str | None) -> str | None:
def _optional_text(value: Any) -> str | None:
text = str(value or "").strip()
return text or None
def _matches_material_filters(
material: Material,
*,
color: str | None,
material_type: str | None,
body_slot: str | None,
wear_layer: str | None,
min_confidence: float | None,
confirmation_state: str | None,
) -> bool:
profile = material.metadata.get("normalized_asset_profile") if isinstance(material.metadata.get("normalized_asset_profile"), dict) else {}
attributes = profile.get("attributes") if isinstance(profile.get("attributes"), dict) else {}
searchable = " ".join(
[material.display_name, material.prompt or "", " ".join(material.tags), str(attributes)]
).casefold()
if color and str(color).casefold() not in searchable:
return False
if material_type and str(material_type).casefold() not in searchable:
return False
if body_slot and str(body_slot) not in (profile.get("body_slots") or []):
return False
if wear_layer and str(profile.get("wear_layer") or "") != str(wear_layer):
return False
if min_confidence is not None:
try:
if float(profile.get("confidence") or 0.0) < float(min_confidence):
return False
except (TypeError, ValueError):
return False
state = str(confirmation_state or "").lower()
if state == "confirmed" and not profile.get("confirmed"):
return False
if state == "needs_confirmation" and not profile.get("requires_confirmation"):
return False
if state == "unconfirmed" and profile.get("confirmed"):
return False
return True

查看文件

@ -2,11 +2,17 @@
from __future__ import annotations
import base64
import json
import urllib.request
from typing import Any
from urllib.parse import urlsplit
from backend.services.model_provider_service import ModelProviderService
from core.secret_service import SecretStore, resolve_secret_value
from core.remote_fetch import read_http_response_limited, validate_http_url
from core.image_formats import detect_image_format
from core.storage import VfsStorage
from engines.image_provider import FallbackImageProvider, ImageProvider, ImageProviderConfig, OpenAIImageProvider
from engines.vision_provider import OpenAIVisionProvider, VisionProvider, VisionProviderConfig
@ -32,11 +38,14 @@ class ModelProviderRuntime:
fallback_enabled = bool(route_context.get("allow_provider_fallback", True))
if fallback_enabled:
seen = {str(resolved.get("route_id"))}
excluded_routes = {str(item).strip() for item in route_context.get("excluded_fallback_routes", []) if str(item).strip()} if isinstance(route_context.get("excluded_fallback_routes"), list) else set()
fallback_routes = sorted(
self.model_provider_service.list_routes(enabled=True),
key=lambda item: (int(item.get("priority") or 100), str(item.get("route_id") or "")),
)
for route in fallback_routes:
if str(route.get("route_name") or "") in excluded_routes:
continue
if route.get("modality") != "image_generation" or str(route.get("route_id")) in seen:
continue
candidate = self.model_provider_service.resolve_route(str(route.get("route_name")), modality="image_generation")
@ -121,6 +130,123 @@ class ModelProviderRuntime:
)
)
def structured_text_callable(self, route_name: str):
"""Return an OpenAI-compatible JSON completion callable for a configured route."""
resolved = self.model_provider_service.resolve_route(route_name)
if not resolved:
return None
provider = resolved.get("provider") or {}
if str(provider.get("provider_type") or "openai_compatible") != "openai_compatible":
return None
secret = resolve_secret_value(
env_var=provider.get("api_key_env_var"),
secret_ref=provider.get("api_key_secret_ref"),
secret_store=self.secret_store,
)
if (provider.get("api_key_env_var") or provider.get("api_key_secret_ref")) and not secret.value:
return None
base_url = str(provider.get("base_url") or "").rstrip("/")
if not base_url:
return None
settings = dict(resolved.get("settings") or {})
capabilities = dict(provider.get("capabilities") or {})
endpoint = str(settings.get("chat_endpoint") or capabilities.get("chat_endpoint") or "/v1/chat/completions")
url = f"{base_url}{endpoint if endpoint.startswith('/') else '/' + endpoint}"
validate_http_url(url, allow_private=True)
headers = {
"Content-Type": "application/json",
**({"Authorization": f"Bearer {secret.value}"} if secret.value else {}),
**dict(provider.get("extra_headers") or {}),
}
timeout = int(provider.get("timeout_seconds") or 180)
model = str(resolved.get("model_id") or "")
def complete(request_payload: dict[str, Any]) -> dict[str, Any]:
purpose = str(request_payload.get("purpose") or "structured prompt processing")
body = {
"model": model,
"messages": [
{"role": "system", "content": f"Perform {purpose}. Return one JSON object only. Preserve safety-relevant meaning and do not invent facts."},
{"role": "user", "content": json.dumps(request_payload, ensure_ascii=False)},
],
"temperature": 0.1,
"response_format": {"type": "json_object"},
}
raw = read_http_response_limited(
urllib.request.Request(url, data=json.dumps(body, ensure_ascii=False).encode("utf-8"), headers=headers, method="POST"),
timeout_seconds=timeout,
max_bytes=4 * 1024 * 1024,
allow_private=True,
same_origin_redirects_only=True,
).decode("utf-8-sig")
response = json.loads(raw)
content = _completion_content(response)
parsed = json.loads(content)
if not isinstance(parsed, dict):
raise ValueError("structured completion must return an object")
return parsed
return complete
def structured_vision_callable(self, route_name: str, *, storage: VfsStorage | None = None):
resolved = self.model_provider_service.resolve_route(route_name)
if not resolved:
return None
provider = resolved.get("provider") or {}
secret = resolve_secret_value(env_var=provider.get("api_key_env_var"), secret_ref=provider.get("api_key_secret_ref"), secret_store=self.secret_store)
if (provider.get("api_key_env_var") or provider.get("api_key_secret_ref")) and not secret.value:
return None
base_url = str(provider.get("base_url") or "").rstrip("/")
if not base_url:
return None
settings = dict(resolved.get("settings") or {})
capabilities = dict(provider.get("capabilities") or {})
endpoint = str(settings.get("vision_endpoint") or capabilities.get("vision_endpoint") or settings.get("chat_endpoint") or "/v1/chat/completions")
url = f"{base_url}{endpoint if endpoint.startswith('/') else '/' + endpoint}"
validate_http_url(url, allow_private=True)
headers = {"Content-Type": "application/json", **({"Authorization": f"Bearer {secret.value}"} if secret.value else {}), **dict(provider.get("extra_headers") or {})}
timeout = int(provider.get("timeout_seconds") or 180)
model = str(resolved.get("model_id") or "")
vfs = storage or VfsStorage()
def review(request_payload: dict[str, Any]) -> dict[str, Any]:
image = request_payload.get("image") if isinstance(request_payload.get("image"), dict) else {}
uri = str(image.get("image_uri") or image.get("thumbnail_uri") or "").strip()
if uri.startswith("storage://"):
path = vfs.ensure_file(uri)
body = path.read_bytes()
if len(body) > 25 * 1024 * 1024:
raise ValueError("image moderation input exceeds size limit")
image_format = detect_image_format(body)
if image_format is None:
raise ValueError("image moderation input is not a supported image")
uri = f"data:{image_format.mime_type};base64,{base64.b64encode(body).decode('ascii')}"
if not uri.startswith(("data:image/", "http://", "https://")):
raise ValueError("image moderation requires a storage, data, or HTTP image URI")
instruction = {
"requested_level": request_payload.get("requested_level"),
"route_kind": request_payload.get("route_kind"),
"reference_binding_mapping": (image.get("metadata") or {}).get("reference_binding_mapping") if isinstance(image.get("metadata"), dict) else {},
"actions": ["allow", "warn", "quarantine", "regenerate", "reject"],
"requirements": ["detect age ambiguity", "detect unexpected nudity", "detect terrorism or high-risk violence", "detect content beyond the allowed request", "when material IDs are available, return material_restoration_scores from 0 to 1"],
}
payload = {
"model": model,
"messages": [
{"role": "system", "content": "Review the generated image for content safety. Return JSON with action, categories, confidence, reason_codes, and version. Terrorism, high-risk violence, sexual minors, and extreme gore must be reject or quarantine."},
{"role": "user", "content": [{"type": "text", "text": json.dumps(instruction, ensure_ascii=False)}, {"type": "image_url", "image_url": {"url": uri}}]},
],
"temperature": 0.0,
"response_format": {"type": "json_object"},
}
raw = read_http_response_limited(urllib.request.Request(url, data=json.dumps(payload, ensure_ascii=False).encode("utf-8"), headers=headers, method="POST"), timeout_seconds=timeout, max_bytes=4 * 1024 * 1024, allow_private=True, same_origin_redirects_only=True).decode("utf-8-sig")
parsed = json.loads(_completion_content(json.loads(raw)))
if not isinstance(parsed, dict):
raise ValueError("image moderation response must be an object")
return parsed
return review
def _configured_bool(*values: Any, default: bool) -> bool:
for value in values:
@ -142,3 +268,17 @@ def _default_negative_prompt_support(base_url: str) -> bool:
except ValueError:
return True
return not (hostname == "api.openai.com" or hostname.endswith(".openai.azure.com"))
def _completion_content(response: dict[str, Any]) -> str:
if isinstance(response.get("output_text"), str):
return response["output_text"].strip()
choices = response.get("choices")
if isinstance(choices, list) and choices and isinstance(choices[0], dict):
message = choices[0].get("message") if isinstance(choices[0].get("message"), dict) else {}
content = message.get("content")
if isinstance(content, str):
return content.strip()
if isinstance(content, list):
return " ".join(str(item.get("text") or "") for item in content if isinstance(item, dict)).strip()
raise ValueError("structured completion response has no text content")

查看文件

@ -152,6 +152,10 @@ def _material_prompt_parts(material_bindings: Any) -> list[str]:
structured: list[str] = []
contexts: list[str] = []
if isinstance(material_bindings, dict):
composition = material_bindings.get("composition") if isinstance(material_bindings.get("composition"), dict) else {}
composition_prompt = str(composition.get("prompt") or "").strip()
if composition_prompt:
return _split_prompt_text(composition_prompt)
structured.extend(_prompt_values(material_bindings.get("material_prompts")))
structured.extend(_prompt_values(material_bindings.get("reference_prompts")))
generation_params = material_bindings.get("generation_params")

查看文件

@ -0,0 +1,404 @@
"""Prompt translation, semantic normalization, moderation and route governance.
The services are provider-neutral. Optional callables can connect configured LLM/VLM
routes, while deterministic validation and conservative fallbacks remain available
when an external reviewer is unavailable.
"""
from __future__ import annotations
import re
from dataclasses import dataclass
from datetime import datetime, timezone
from typing import Any, Callable, Mapping
RISK_LEVELS = (
"safe", "sensitive", "adult_allowed", "uncertain",
"violence_prohibited", "terror_prohibited", "prohibited",
)
RISK_PRIORITY = {level: index for index, level in enumerate(RISK_LEVELS)}
ENTRYPOINTS = {"web", "qq", "telegram", "discord", "api", "unknown"}
TranslationCallable = Callable[[dict[str, Any]], Mapping[str, Any] | str]
ModerationCallable = Callable[[dict[str, Any]], Mapping[str, Any]]
ImageModerationCallable = Callable[[dict[str, Any]], Mapping[str, Any]]
@dataclass(frozen=True)
class PromptTranslationResult:
original_text: str
translated_text: str
status: str
enabled: bool
accepted: bool
model_route: str | None
template_version: str
created_at: str
sections: dict[str, Any]
difference_summary: list[str]
error: str | None = None
def to_dict(self) -> dict[str, Any]:
return dict(self.__dict__)
class PromptTranslationService:
def __init__(self, config: Mapping[str, Any] | None = None, translator: TranslationCallable | None = None):
self.config = dict(config or {})
self.translator = translator
def translate(self, text: str, *, entrypoint: str = "web", user_allowed: bool = False, model_family: str = "natural_language", locked_terms: list[str] | None = None, budget: int | None = None) -> PromptTranslationResult:
original = _text(text)
enabled = bool(self.config.get("enabled", False))
entrypoint = entrypoint if entrypoint in ENTRYPOINTS else "unknown"
entrypoint_allowed = bool((self.config.get("entrypoints") or {}).get(entrypoint, entrypoint == "web"))
allowed = enabled and user_allowed and entrypoint_allowed
now = _utc_now()
route = _optional_text(self.config.get("model_route"))
version = _text(self.config.get("template_version")) or "1.0"
if not original or not allowed:
return PromptTranslationResult(original, original, "bypassed", enabled, False, route, version, now, {}, [])
if _is_english_only(original):
return PromptTranslationResult(original, original, "english_passthrough", True, True, route, version, now, {"prompt": original}, [])
request = {
"text": original,
"target_language": "English",
"model_family": model_family,
"locked_terms": list(locked_terms or []),
"budget": budget,
"requirements": [
"preserve the user's visual intent",
"separate subject, appearance, clothing, action, composition, scene, style, lighting, camera and negative constraints",
"do not hide or encode safety-relevant meaning",
"do not change age or identity",
],
}
if self.translator is None:
return PromptTranslationResult(original, original, "unavailable_fallback", True, False, route, version, now, {}, [], "translation model is unavailable")
try:
response = self.translator(request)
if isinstance(response, str):
translated, sections = _text(response), {"prompt": _text(response)}
elif isinstance(response, Mapping):
translated = _text(response.get("translated_text") or response.get("prompt"))
sections = dict(response.get("sections") or {})
else:
translated, sections = "", {}
if not translated:
raise ValueError("translator returned an empty prompt")
translated = _restore_locked_terms(original, translated, locked_terms or [])
if budget and len(translated) > budget:
translated = _budget_text(translated, budget, locked_terms or [])
return PromptTranslationResult(original, translated, "translated", True, True, route, version, now, sections, _difference_summary(original, translated))
except Exception as exc:
return PromptTranslationResult(original, original, "failed_fallback", True, False, route, version, now, {}, [], exc.__class__.__name__)
class PromptSemanticNormalizer:
VERSION = "1.0"
def normalize(self, text: str, *, locked_terms: list[str] | None = None) -> dict[str, Any]:
original = _text(text)
normalized = original
changes: list[dict[str, str]] = []
replacements = {
r"(?i)\b(girl|boy)\b": "adult woman" if re.search(r"(?i)\bgirl\b", normalized) else "adult man",
r"少女": "成年女性",
r"少年": "成年男性",
}
# Age-disambiguation is only added for otherwise lawful adult contexts.
if _contains_any(normalized, ADULT_TERMS) and not _contains_any(normalized, MINOR_TERMS):
if not _contains_any(normalized, ADULT_AGE_TERMS):
normalized = f"adult subject, {normalized}"
changes.append({"from": "implicit age", "to": "adult subject", "reason": "adult_age_disambiguation"})
for pattern, replacement in replacements.items():
if re.search(pattern, normalized) and _contains_any(normalized, ADULT_TERMS):
before = normalized
normalized = re.sub(pattern, replacement, normalized)
if normalized != before:
changes.append({"from": pattern, "to": replacement, "reason": "age_disambiguation"})
normalized = _restore_locked_terms(original, normalized, locked_terms or [])
return {
"original_text": original,
"normalized_text": normalized,
"changed_terms": changes,
"reason": "reduce ambiguity without concealing safety meaning" if changes else "no_change",
"meaning_preserved": True,
"requires_confirmation": False,
"version": self.VERSION,
"created_at": _utc_now(),
}
@dataclass(frozen=True)
class PromptModerationDecision:
level: str
confidence: float
categories: list[str]
reason_codes: list[str]
action: str
warning: str | None
rules_version: str
model_route: str | None
created_at: str
@property
def allowed(self) -> bool:
return self.level in {"safe", "sensitive", "adult_allowed"}
def to_dict(self) -> dict[str, Any]:
return {**self.__dict__, "allowed": self.allowed}
class PromptModerationService:
RULES_VERSION = "1.0"
def __init__(self, config: Mapping[str, Any] | None = None, reviewer: ModerationCallable | None = None):
self.config = dict(config or {})
self.reviewer = reviewer
def moderate(self, *, original_prompt: str, translated_prompt: str = "", final_prompt: str = "", negative_prompt: str = "", reference_bindings: list[dict[str, Any]] | None = None) -> PromptModerationDecision:
text = "\n".join(_text(value) for value in (original_prompt, translated_prompt, final_prompt, negative_prompt) if _text(value))
rule = self._rule_decision(text)
model = self._model_decision(text, reference_bindings or [])
return _stricter_decision(rule, model)
def _rule_decision(self, text: str) -> PromptModerationDecision:
lower = text.casefold()
if _contains_any(lower, TERROR_TERMS):
return _decision("terror_prohibited", 0.96, ["terrorism"], ["terrorism_or_extremism"], "reject_warn", "请求涉及恐怖主义或极端主义内容,已禁止生成。")
if _contains_any(lower, VIOLENCE_PROHIBITED_TERMS):
return _decision("violence_prohibited", 0.94, ["high_risk_violence"], ["violent_harm_or_extreme_gore"], "reject_warn", "请求涉及高危暴力、现实伤害或极端血腥内容,已禁止生成。")
adult = _contains_any(lower, ADULT_TERMS)
minor = _contains_any(lower, MINOR_TERMS)
if adult and minor:
return _decision("prohibited", 0.98, ["sexual_minors"], ["adult_content_with_minor_or_ambiguous_age"], "reject_warn", "成人内容中的人物年龄不明确或涉及未成年人,已禁止生成。")
if _contains_any(lower, OTHER_PROHIBITED_TERMS):
return _decision("prohibited", 0.93, ["prohibited"], ["prohibited_content"], "reject", "请求包含禁止生成的内容。")
if adult:
if not _contains_any(lower, ADULT_AGE_TERMS):
return _decision("uncertain", 0.72, ["adult", "ambiguous_age"], ["adult_age_not_explicit"], "confirm_or_reject", "请先明确所有人物均为成年人。")
return _decision("adult_allowed", 0.90, ["adult"], ["lawful_adult_content"], "route_nsfw", None)
if _contains_any(lower, SENSITIVE_TERMS):
return _decision("sensitive", 0.75, ["sensitive"], ["sensitive_but_allowed"], "allow", None)
return _decision("safe", 0.85, [], ["no_risk_signal"], "allow", None)
def _model_decision(self, text: str, references: list[dict[str, Any]]) -> PromptModerationDecision | None:
if self.reviewer is None or not bool(self.config.get("llm_review_enabled", False)):
return None
try:
response = self.reviewer({"text": text, "reference_bindings": references, "levels": list(RISK_LEVELS), "rules_version": self.RULES_VERSION})
level = _text(response.get("level"))
if level not in RISK_LEVELS:
raise ValueError("invalid moderation level")
return PromptModerationDecision(
level=level,
confidence=_bounded_float(response.get("confidence"), 0.5),
categories=_string_list(response.get("categories")),
reason_codes=_string_list(response.get("reason_codes")) or ["model_review"],
action=_text(response.get("action")) or _action_for_level(level),
warning=_optional_text(response.get("warning")),
rules_version=_text(response.get("rules_version")) or self.RULES_VERSION,
model_route=_optional_text(self.config.get("model_route")),
created_at=_utc_now(),
)
except Exception:
fallback = _text(self.config.get("failure_policy") or "fail_closed")
return _decision("uncertain" if fallback == "confirm" else "prohibited", 0.5, ["review_unavailable"], ["moderation_service_failure"], "confirm_or_reject" if fallback == "confirm" else "reject", "内容审核暂时不可用,已采用保守策略。")
@dataclass(frozen=True)
class GenerationRouteDecision:
requested_route: str
moderation_level: str
selected_route: str | None
reason: str
fallback_route: str | None
allowed: bool
requires_confirmation: bool
created_at: str
def to_dict(self) -> dict[str, Any]:
return dict(self.__dict__)
class GenerationRouteService:
def __init__(self, config: Mapping[str, Any] | None = None):
self.config = dict(config or {})
def decide(self, requested_route: str, moderation: PromptModerationDecision, *, entrypoint: str, user_id: str | None, group_id: str | None, permission_context: Mapping[str, Any] | None = None) -> GenerationRouteDecision:
permissions = dict(permission_context or {})
level = moderation.level
if level in {"violence_prohibited", "terror_prohibited", "prohibited"}:
return self._decision(requested_route, level, None, "content_prohibited", None, False, False)
if level == "uncertain":
return self._decision(requested_route, level, None, "moderation_confirmation_required", None, False, True)
safe_route = _optional_text(self.config.get("safe_route")) or requested_route
nsfw_route = _optional_text(self.config.get("nsfw_route"))
if level != "adult_allowed":
return self._decision(requested_route, level, safe_route, "safe_or_sensitive_content", nsfw_route, True, False)
enabled = bool(self.config.get("adult_auto_route_enabled", False))
entry_allowed = bool((self.config.get("entrypoints") or {}).get(entrypoint, False))
user_allowed = bool(permissions.get("adult_user_allowed", False))
group_allowed = bool(permissions.get("adult_group_allowed", group_id is None))
quota_allowed = bool(permissions.get("quota_allowed", True))
if not all((enabled, entry_allowed, user_allowed, group_allowed, quota_allowed)):
return self._decision(requested_route, level, None, "adult_route_permission_denied", nsfw_route, False, False)
if not nsfw_route:
return self._decision(requested_route, level, None, "nsfw_route_not_configured", None, False, False)
return self._decision(requested_route, level, nsfw_route, "adult_content_auto_routed", None, True, False)
def _decision(self, requested: str, level: str, selected: str | None, reason: str, fallback: str | None, allowed: bool, confirm: bool) -> GenerationRouteDecision:
return GenerationRouteDecision(requested, level, selected, reason, fallback, allowed, confirm, _utc_now())
class GenerationFailureClassifier:
CONTENT_SIGNALS = ("nsfw", "safety", "content policy", "moderation", "sexual content", "adult content", "blocked prompt", "内容审核", "敏感内容")
def classify(self, failure: Mapping[str, Any] | BaseException) -> dict[str, Any]:
if isinstance(failure, Mapping):
status = failure.get("status_code")
error_type = _text(failure.get("error_type") or failure.get("category"))
detail = _text(failure.get("message")) + " " + _text(failure.get("details"))
provider_id = _optional_text(failure.get("provider_id"))
else:
status = getattr(failure, "status_code", None)
error_type = _text(getattr(failure, "error_type", failure.__class__.__name__))
details = getattr(failure, "details", {})
detail = f"{failure} {details}"
provider_id = _optional_text(getattr(failure, "provider_id", None))
lower = f"{error_type} {detail}".casefold()
if any(signal in lower for signal in self.CONTENT_SIGNALS):
category = "content_safety_rejection"
elif "quota" in lower or "credit" in lower or "balance" in lower:
category = "quota_exhausted"
elif status == 429 or "rate" in lower:
category = "rate_limit"
elif status in {401, 403} or "auth" in lower or "credential" in lower:
category = "authentication"
elif "timeout" in lower or status in {408, 504}:
category = "timeout"
elif "unsupported" in lower or "capability" in lower:
category = "unsupported_capability"
elif status is not None and 400 <= int(status) < 500:
category = "invalid_request"
elif "network" in lower or (status is not None and int(status) >= 500):
category = "upstream_error"
else:
category = "unknown"
return {"failure_class": category, "provider_id": provider_id, "status_code": status, "error_type": error_type, "summary": _redact(detail)[:500]}
class ImageModerationService:
def __init__(self, config: Mapping[str, Any] | None = None, reviewer: ImageModerationCallable | None = None):
self.config = dict(config or {})
self.reviewer = reviewer
def moderate(self, image: Mapping[str, Any], *, requested_level: str, route_kind: str) -> dict[str, Any]:
if self.reviewer is None or not bool(self.config.get("enabled", False)):
return {"status": "not_configured", "action": "allow", "requested_level": requested_level, "route_kind": route_kind, "version": "1.0"}
try:
result = dict(self.reviewer({"image": dict(image), "requested_level": requested_level, "route_kind": route_kind}))
except Exception:
return {"status": "review_failed", "action": "quarantine", "requested_level": requested_level, "route_kind": route_kind, "version": "1.0"}
action = _text(result.get("action"))
if action not in {"allow", "warn", "quarantine", "regenerate", "reject"}:
action = "quarantine"
return {**result, "action": action, "status": "reviewed", "version": _text(result.get("version")) or "1.0"}
TERROR_TERMS = ("terrorist propaganda", "terror recruitment", "join isis", "join al qaeda", "恐怖组织宣传", "恐怖主义招募", "加入恐怖组织", "极端主义行动")
VIOLENCE_PROHIBITED_TERMS = ("how to kill", "murder a real", "bomb attack", "dismemberment", "torture gore", "beheading gore", "如何杀害", "现实伤害威胁", "炸弹袭击", "肢解", "酷刑血腥", "斩首血腥")
ADULT_TERMS = ("nsfw", "nude", "nudity", "explicit sexual", "erotic", "lingerie", "裸露", "裸体", "裸像", "色情", "成人内容", "情趣内衣")
ADULT_AGE_TERMS = ("adult", "18+", "over 18", "成年", "成年人")
MINOR_TERMS = ("minor", "underage", "child", "kid", "schoolgirl", "schoolboy", "幼女", "幼童", "未成年", "儿童", "小学生", "初中生")
OTHER_PROHIBITED_TERMS = ("sexual assault", "rape scene", "non-consensual explicit", "性侵", "强奸场景", "非自愿色情")
SENSITIVE_TERMS = ("blood", "weapon", "swimsuit", "medical", "内衣写真", "泳装", "武器", "少量血迹")
def _stricter_decision(left: PromptModerationDecision, right: PromptModerationDecision | None) -> PromptModerationDecision:
if right is None:
return left
return right if RISK_PRIORITY[right.level] > RISK_PRIORITY[left.level] else left
def _decision(level: str, confidence: float, categories: list[str], reasons: list[str], action: str, warning: str | None) -> PromptModerationDecision:
return PromptModerationDecision(level, confidence, categories, reasons, action, warning, PromptModerationService.RULES_VERSION, None, _utc_now())
def _action_for_level(level: str) -> str:
return {"safe": "allow", "sensitive": "allow", "adult_allowed": "route_nsfw", "uncertain": "confirm_or_reject", "violence_prohibited": "reject_warn", "terror_prohibited": "reject_warn", "prohibited": "reject"}[level]
def _contains_any(text: str, terms: tuple[str, ...]) -> bool:
lowered = text.casefold()
return any(term.casefold() in lowered for term in terms)
def _is_english_only(value: str) -> bool:
return not bool(re.search(r"[\u3400-\u9fff]", value))
def _restore_locked_terms(original: str, translated: str, locked_terms: list[str]) -> str:
result = translated
for term in locked_terms:
text = _text(term)
if text and text in original and text not in result:
result = f"{result}, {text}"
return result
def _budget_text(value: str, budget: int, locked_terms: list[str]) -> str:
parts = _split_prompt(value)
locked = {_text(item).casefold() for item in locked_terms}
while len(", ".join(parts)) > budget and parts:
removable = next((index for index in range(len(parts) - 1, -1, -1) if parts[index].casefold() not in locked), None)
if removable is None:
break
parts.pop(removable)
return ", ".join(parts)
def _difference_summary(original: str, translated: str) -> list[str]:
summary = ["language: source -> English"] if not _is_english_only(original) and _is_english_only(translated) else []
if len(translated) > len(original) * 1.5:
summary.append("structured visual details expanded")
return summary
def _split_prompt(value: Any) -> list[str]:
return [part.strip() for part in _text(value).replace(";", ",").split(",") if part.strip()]
def _string_list(value: Any) -> list[str]:
if isinstance(value, str):
return _split_prompt(value)
if not isinstance(value, (list, tuple, set)):
return []
return [_text(item) for item in value if _text(item)]
def _bounded_float(value: Any, default: float) -> float:
try:
return min(max(float(value), 0.0), 1.0)
except (TypeError, ValueError):
return default
def _redact(value: str) -> str:
text = re.sub(r"(?i)bearer\s+\S+", "Bearer [REDACTED]", value)
return re.sub(r"\bsk-[A-Za-z0-9_-]{8,}\b", "[REDACTED]", text)
def _optional_text(value: Any) -> str | None:
text = _text(value)
return text or None
def _text(value: Any) -> str:
return str(value or "").strip()
def _utc_now() -> str:
return datetime.now(timezone.utc).isoformat()

查看文件

@ -0,0 +1,69 @@
"""Map semantic reference-image responsibilities to adapter-native inputs."""
from __future__ import annotations
from typing import Any, Mapping
class ReferenceBindingMapper:
def map(self, bindings: list[dict[str, Any]], route_resolution: Mapping[str, Any]) -> dict[str, Any]:
settings = route_resolution.get("settings") if isinstance(route_resolution.get("settings"), dict) else {}
capabilities = route_resolution.get("capabilities") if isinstance(route_resolution.get("capabilities"), dict) else {}
max_references = _positive_int(settings.get("max_reference_images") or capabilities.get("max_reference_images"), 8)
ordered = sorted(
[dict(item) for item in bindings if isinstance(item, dict)],
key=lambda item: (-_float(item.get("weight"), 0.5), str(item.get("material_id") or item.get("image_uri") or "")),
)
active, downgraded = ordered[:max_references], ordered[max_references:]
supports_roles = bool(settings.get("supports_reference_roles", capabilities.get("supports_reference_roles", False)))
dialect = str(settings.get("reference_dialect") or capabilities.get("reference_dialect") or "text_constraints")
native: list[dict[str, Any]] = []
constraints: list[str] = []
for index, binding in enumerate(active):
role = str(binding.get("role") or "reference")
use_for = _strings(binding.get("use_for"))
do_not = _strings(binding.get("do_not_inherit"))
if supports_roles:
native.append({
"index": index,
"role": role,
"use_for": use_for,
"exclude": do_not,
"weight": min(max(_float(binding.get("weight"), 0.5), 0.0), 1.0),
"dialect": dialect,
})
else:
constraint = f"Reference image {index + 1} is for {', '.join(use_for) or role} only"
if do_not:
constraint += f"; do not inherit {', '.join(do_not)}"
constraints.append(constraint)
return {
"dialect": dialect,
"supports_native_roles": supports_roles,
"native_bindings": native,
"text_constraints": constraints,
"active_count": len(active),
"downgraded": [{"material_id": item.get("material_id"), "reason": "adapter_reference_limit", "fallback": "text_capsule"} for item in downgraded],
}
def _strings(value: Any) -> list[str]:
if isinstance(value, str):
value = value.split(",")
if not isinstance(value, (list, tuple, set)):
return []
return [str(item).strip() for item in value if str(item).strip()]
def _float(value: Any, default: float) -> float:
try:
return float(value)
except (TypeError, ValueError):
return default
def _positive_int(value: Any, default: int) -> int:
try:
return max(int(value), 0)
except (TypeError, ValueError):
return default

查看文件

@ -123,12 +123,43 @@ class SettingsService:
_field("category_requirements", "list", label="分类附加要求"),
],
},
{
"key": "prompt_governance",
"title": "提示词与内容分流",
"fields": [
_field("translation.enabled", "bool", label="启用 LLM 提示词转译"),
_field("translation.model_route", "string", label="提示词转译模型路由"),
_field("translation.template_version", "string", label="转译模板版本"),
_field("translation.entrypoints.web", "bool", label="Web 允许转译"),
_field("translation.entrypoints.qq", "bool", label="QQ 允许转译"),
_field("translation.entrypoints.telegram", "bool", label="Telegram 允许转译"),
_field("translation.entrypoints.discord", "bool", label="Discord 允许转译"),
_field("moderation.llm_review_enabled", "bool", label="启用 LLM 内容复核"),
_field("moderation.model_route", "string", label="内容审核模型路由"),
_field("moderation.failure_policy", "select", label="审核失败策略", options=["fail_closed", "confirm"]),
_field("routing.safe_route", "string", label="普通生图路由"),
_field("routing.nsfw_route", "string", label="NSFW 生图路由"),
_field("routing.adult_auto_route_enabled", "bool", label="允许成人内容自动分流"),
_field("routing.entrypoints.web", "bool", label="Web 允许成人路由"),
_field("routing.entrypoints.qq", "bool", label="QQ 允许成人路由"),
_field("routing.entrypoints.telegram", "bool", label="Telegram 允许成人路由"),
_field("routing.entrypoints.discord", "bool", label="Discord 允许成人路由"),
_field("image_moderation.enabled", "bool", label="启用生成后图片审核"),
_field("image_moderation.model_route", "string", label="图片审核模型路由"),
_field("retention.raw_prompt_days", "number", label="原始提示词保留天数"),
_field("retention.translated_prompt_days", "number", label="转译提示词保留天数"),
_field("retention.moderation_record_days", "number", label="审核记录保留天数"),
_field("retention.redact_sensitive_logs", "bool", label="日志默认脱敏"),
],
},
{
"key": "chat_access",
"title": "聊天权限",
"fields": [
_field("group_allowlist", "list", label="群聊白名单"),
_field("user_allowlist", "list", label="用户白名单"),
_field("adult_group_allowlist", "list", label="成人内容群聊白名单"),
_field("adult_user_allowlist", "list", label="成人内容用户白名单"),
_field("user_concurrency_limit", "number", label="用户并发任务上限"),
_field("group_concurrency_limit", "number", label="群聊并发任务上限"),
_field("daily_user_generation_limit", "number", label="用户每日生成上限"),
@ -252,6 +283,28 @@ class SettingsService:
"message": "postgresql backend is selected but connection fields are incomplete",
}
)
governance = config.get("prompt_governance", {})
if isinstance(governance, Mapping):
routing = governance.get("routing", {})
if isinstance(routing, Mapping):
safe_route = str(routing.get("safe_route") or "").strip()
nsfw_route = str(routing.get("nsfw_route") or "").strip()
if routing.get("adult_auto_route_enabled") and not nsfw_route:
errors.append({"field": "prompt_governance.routing.nsfw_route", "message": "NSFW route is required when adult auto routing is enabled"})
if safe_route and nsfw_route and safe_route == nsfw_route:
errors.append({"field": "prompt_governance.routing", "message": "safe and NSFW routes must use different configured routes"})
translation = governance.get("translation", {})
if isinstance(translation, Mapping) and translation.get("enabled") and not str(translation.get("model_route") or "").strip():
warnings.append({"field": "prompt_governance.translation.model_route", "message": "translation is enabled without a dedicated model route; runtime will safely use the original prompt"})
retention = governance.get("retention", {})
if isinstance(retention, Mapping):
for key in ("raw_prompt_days", "translated_prompt_days", "moderation_record_days"):
try:
days = int(retention.get(key, 0))
except (TypeError, ValueError):
days = -1
if days < 0:
errors.append({"field": f"prompt_governance.retention.{key}", "message": "retention days must be zero or greater"})
return {"valid": not errors, "errors": errors, "warnings": warnings}
def diff(self, candidate: Mapping[str, Any]) -> dict[str, Any]:

查看文件

@ -8,6 +8,8 @@ from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.dto.wardrobe_dto import WardrobeItem
from backend.services.composition_builder import CompositionBuilder, CompositionPlan
from backend.services.material_normalization_service import MaterialNormalizationService
from core.audit_service import AuditService
from core.identity import RequestContext
from database.repositories.material_repository import MaterialRepository
@ -25,11 +27,15 @@ class WardrobeService:
profile_repository: ProfileRepository,
material_repository: MaterialRepository,
audit_service: AuditService,
composition_builder: CompositionBuilder | None = None,
normalization_service: MaterialNormalizationService | None = None,
):
self.wardrobe_repository = wardrobe_repository
self.profile_repository = profile_repository
self.material_repository = material_repository
self.audit_service = audit_service
self.composition_builder = composition_builder or CompositionBuilder()
self.normalization_service = normalization_service or MaterialNormalizationService()
def import_material(self, profile_id: str, payload: dict[str, Any], ctx: RequestContext) -> WardrobeItem:
self._ensure_profile(profile_id, ctx)
@ -111,6 +117,83 @@ class WardrobeService:
)
return deleted
def list_templates(self, profile_id: str, ctx: RequestContext) -> list[dict[str, Any]]:
profile = self._ensure_profile(profile_id, ctx)
templates = profile.metadata.get("wardrobe_templates") if isinstance(profile.metadata.get("wardrobe_templates"), list) else []
return [dict(item) for item in templates if isinstance(item, dict)]
def save_template(self, profile_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
profile = self._ensure_profile(profile_id, ctx)
name = str(payload.get("name") or "").strip()
material_ids = [str(item).strip() for item in payload.get("material_ids", []) if str(item).strip()] if isinstance(payload.get("material_ids"), list) else []
if not name or not material_ids:
raise ApiError(ErrorCode.VALIDATION_FAILED, "template name and material_ids are required", {"fields": ["name", "material_ids"]})
owned_material_ids = {item.material_id for item in self.wardrobe_repository.list_by_profile(profile_id)}
missing = [material_id for material_id in material_ids if material_id not in owned_material_ids]
if missing:
raise ApiError(ErrorCode.VALIDATION_FAILED, "template contains materials outside this wardrobe", {"material_ids": missing})
template_id = str(payload.get("template_id") or f"outfit_{uuid4().hex}")
templates = self.list_templates(profile_id, ctx)
template = {
"template_id": template_id,
"name": name,
"material_ids": list(dict.fromkeys(material_ids)),
"description": str(payload.get("description") or "").strip(),
"scene": str(payload.get("scene") or "").strip(),
"season": str(payload.get("season") or "").strip(),
"style": str(payload.get("style") or "").strip(),
"material_options": payload.get("material_options") if isinstance(payload.get("material_options"), dict) else {},
}
templates = [item for item in templates if item.get("template_id") != template_id] + [template]
updated = self.profile_repository.update(profile_id, {"metadata": {**profile.metadata, "wardrobe_templates": templates}})
if updated is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "profile not found", {"profile_id": profile_id})
self.audit_service.record(ctx=ctx, action="save_wardrobe_template", target_type="character_profile", target_id=profile_id, after_snapshot=template)
return template
def delete_template(self, profile_id: str, template_id: str, ctx: RequestContext) -> dict[str, Any]:
profile = self._ensure_profile(profile_id, ctx)
templates = self.list_templates(profile_id, ctx)
removed = next((item for item in templates if item.get("template_id") == template_id), None)
if removed is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "wardrobe template not found", {"template_id": template_id})
self.profile_repository.update(profile_id, {"metadata": {**profile.metadata, "wardrobe_templates": [item for item in templates if item.get("template_id") != template_id]}})
self.audit_service.record(ctx=ctx, action="delete_wardrobe_template", target_type="character_profile", target_id=profile_id, before_snapshot=removed)
return removed
def apply_template(self, profile_id: str, template_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
template = next((item for item in self.list_templates(profile_id, ctx) if item.get("template_id") == template_id), None)
if template is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "wardrobe template not found", {"template_id": template_id})
wardrobe = self.wardrobe_repository.list_by_profile(profile_id)
item_by_material = {item.material_id: item for item in wardrobe}
selected: list[dict[str, Any]] = []
options = template.get("material_options") if isinstance(template.get("material_options"), dict) else {}
for material_id in template.get("material_ids") or []:
item = item_by_material.get(str(material_id))
material = self.material_repository.get_material(str(material_id))
if item is None or material is None or material.recognition_status != "confirmed":
continue
selected.append({
"wardrobe_item_id": item.wardrobe_item_id,
"material_id": material.material_id,
"wardrobe_category": item.wardrobe_category,
"display_name": material.display_name,
"prompt": material.prompt,
"negative_prompt": material.negative_prompt,
"image_uri": material.image_uri,
"metadata": self.normalization_service.ensure_legacy_structures(prompt=material.prompt, negative_prompt=material.negative_prompt, tags=material.tags, metadata=material.metadata, category_hint=item.wardrobe_category),
**(options.get(material.material_id) if isinstance(options.get(material.material_id), dict) else {}),
})
result = self.composition_builder.build({
"materials": selected,
"user_prompt": str(payload.get("prompt") or template.get("scene") or "").strip(),
"prompt_budget": payload.get("prompt_budget") or 4000,
"max_reference_images": payload.get("max_reference_images") or 8,
}).to_dict()
self.audit_service.record(ctx=ctx, action="apply_wardrobe_template", target_type="character_profile", target_id=profile_id, after_snapshot={"template_id": template_id, "composition": result})
return {"profile_id": profile_id, "template": template, "composition": result}
def match(self, profile_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
self._ensure_profile(profile_id, ctx)
categories = _normalize_categories(payload.get("categories"))
@ -118,8 +201,8 @@ class WardrobeService:
categories = list(DEFAULT_WARDROBE_CATEGORIES)
context = _match_context(payload)
selected: list[dict[str, Any]] = []
prompt_parts: list[str] = []
missing_categories: list[str] = []
material_options = payload.get("material_options") if isinstance(payload.get("material_options"), dict) else {}
for category in categories:
candidates = self.wardrobe_repository.list_by_profile(profile_id, str(category))
if not candidates:
@ -144,6 +227,15 @@ class WardrobeService:
"wardrobe_category": item.wardrobe_category,
"display_name": material.display_name,
"prompt": material.prompt,
"negative_prompt": material.negative_prompt,
"image_uri": material.image_uri,
"metadata": self.normalization_service.ensure_legacy_structures(
prompt=material.prompt,
negative_prompt=material.negative_prompt,
tags=material.tags,
metadata=material.metadata,
category_hint=item.wardrobe_category,
),
"tags": item.tags,
"season": item.season,
"style": item.style,
@ -151,14 +243,28 @@ class WardrobeService:
"usage_count": item.usage_count,
"score": score,
"score_breakdown": breakdown,
**(
material_options.get(material.material_id)
if isinstance(material_options.get(material.material_id), dict)
else {}
),
}
)
if material.prompt:
prompt_parts.append(material.prompt)
fallback_strategy = _fallback_outfit_strategy(payload, categories, missing_categories, selected, context)
outfit_prompt = ", ".join(prompt_parts)
if not outfit_prompt:
outfit_prompt = fallback_strategy["prompt"]
composition = self.composition_builder.build(
CompositionPlan(
materials=selected,
identity_prompt=str(payload.get("identity_prompt") or "").strip(),
user_prompt=fallback_strategy["prompt"] if fallback_strategy["reason"] else "",
negative_prompt=str(payload.get("negative_prompt") or "").strip(),
prompt_budget=max(int(payload.get("prompt_budget") or 4000), 256),
max_reference_images=max(int(payload.get("max_reference_images") or 8), 0),
visible_slots=[str(item).strip() for item in payload.get("visible_slots", []) if str(item).strip()] if isinstance(payload.get("visible_slots"), list) else [],
season=str(payload.get("season") or "").strip(),
scene=str(payload.get("scene") or "").strip(),
)
)
outfit_prompt = composition.prompt or fallback_strategy["prompt"]
result = {
"profile_id": profile_id,
"selected_materials": selected,
@ -168,6 +274,7 @@ class WardrobeService:
"fallback_reason": fallback_strategy["reason"],
"fallback_prompt": fallback_strategy["prompt"] if fallback_strategy["reason"] else None,
"fallback_strategy": fallback_strategy,
"composition": composition.to_dict(),
"match_details": {
"requested_categories": categories,
"missing_categories": missing_categories,
@ -187,10 +294,11 @@ class WardrobeService:
)
return result
def _ensure_profile(self, profile_id: str, ctx: RequestContext) -> None:
def _ensure_profile(self, profile_id: str, ctx: RequestContext):
profile = self.profile_repository.get(profile_id)
if profile is None or profile.status == "deleted" or profile.owner_user_id != ctx.actor_id:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "profile not found", {"profile_id": profile_id})
return profile
def new_wardrobe_item_id() -> str:

查看文件

@ -1,7 +1,7 @@
plugin:
name: astrbot_plugin_imagestudio
display_name: ImageStudio
version: 3.0.0
version: 1.0.0
features:
quick_profile: true
@ -66,9 +66,47 @@ recognition_prompts:
请先判断图片中素材的准确分类,再尽可能完整地提取所有可见事实,包括物品类型、主色与辅色、材质、纹理、结构、轮廓、图案、裁剪、缝线、褶皱、装饰、配件、状态、视角、光照及可复用的设计特征。不要把无法确认的推测写成事实,并明确区分确定信息与低置信度判断。根据识别结果生成一段细节充分、可直接用于生图且能够保留原素材设计的正向提示词,同时生成用于排除错误类别、错误材质、结构畸变、文字、水印和无关背景的负向提示词。仅返回 JSON,字段必须包含 prompt、negative_prompt、tags、confidence、description;tags 应简短、可检索,并包含分类、颜色、材质和关键设计元素。
category_requirements: []
# 提示词转译、内容审核和普通/NSFW 模型动态分流。
# 默认只启用本地规则审核;LLM 转译与成人自动分流必须由管理员明确开启。
prompt_governance:
translation:
enabled: false
model_route: ""
template_version: "1.0"
entrypoints:
web: true
qq: false
telegram: false
discord: false
api: false
moderation:
llm_review_enabled: false
model_route: ""
failure_policy: fail_closed
routing:
safe_route: ""
nsfw_route: ""
adult_auto_route_enabled: false
entrypoints:
web: false
qq: false
telegram: false
discord: false
api: false
image_moderation:
enabled: false
model_route: ""
retention:
raw_prompt_days: 30
translated_prompt_days: 90
moderation_record_days: 180
redact_sensitive_logs: true
chat_access:
group_allowlist: []
user_allowlist: []
adult_group_allowlist: []
adult_user_allowlist: []
user_concurrency_limit: 2
group_concurrency_limit: 5
daily_user_generation_limit: 30

查看文件

@ -117,10 +117,7 @@
最终交付前已执行:
```powershell
python -m unittest discover -s tests
python -m compileall -q adapters backend core database engines scripts tests main.py
python scripts/imagestudio_non_ui_smoke.py
python scripts/imagestudio_pg_smoke.py --dry-run
cd frontend
npm.cmd run typecheck

查看文件

@ -0,0 +1,372 @@
# ImageStudio 素材编译、提示词转译与模型分流开发队列
> 状态:已完成(2026-07-12)
> 建立日期:2026-07-12
> 依据:`astrbot_imagestudio_asset_materials_focus_doc_v1.md` 与当前 ImageStudio 后端实现审计
> 目标:升级“素材识别 → 素材库 → 角色拼装 → 提示词转译 → 内容审核 → 模型路由 → 生图”完整链路。
## 1. 当前实现审计结论
当前系统已经具备素材上传、视觉识别、人工确认、素材分类、角色衣橱、素材匹配、工作流节点绑定、参考图注入、静态模型路由、提示词合并和生成结果审核基础能力。
当前主要缺口:
- 素材识别结果仍以单份 `prompt / negative_prompt / tags` 为主,没有 RawAnalysis、NormalizedAssetProfile、GenerationCapsule 三层结构。
- 视觉模型完整结构化返回没有被持久保存,无法可靠地重新标准化或逐项人工修正。
- 衣橱匹配后仍通过字符串连接形成 `outfit_prompt`,没有身体槽位、穿着层级、冲突解决和提示词预算。
- 现有素材 reference strength 只表示参考图强度,不等于素材语义优先级。
- 多张参考图没有 `role / use_for / do_not_inherit` 职责约束。
- `PromptExpansionService` 只负责合并提示词,没有中文到英文的语义转译层。
- 现有模型路由主要按节点、角色或设置静态选择,不能根据提示词审核结果动态分流。
- 现有 review 主要用于工作流、候选图和结果质量审核,不是生成前提示词内容审核。
## 2. 总体目标链路
```text
用户中文需求
→ 原始需求保存
→ 用户授权检查
→ 语义转译与提示词结构化
→ 合规语义规范化(降低歧义和误报,不绕过安全策略)
→ 素材 CompositionBuilder 编译
→ 生成前内容审核
→ 风险分级与路由决策
├─ 普通内容 → 默认生图模型
├─ 允许的成人内容 → 自动分流到已配置 NSFW 模型
├─ 不确定内容 → 人工确认或保守路由
├─ 恐怖主义 / 暴力宣扬 / 极端血腥 → 拒绝生成并警告
└─ 其他禁止内容 → 拒绝生成
→ 生图
→ 生成后图片审核
→ 返回、隔离、重试或拒绝
```
## 3. P0:素材三层数据结构
- [ ] 定义 `RawAnalysis` DTO 与 JSON Schema。
- [ ] 定义 `NormalizedAssetProfile` DTO 与 JSON Schema。
- [ ] 定义 `GenerationCapsule` DTO 与 JSON Schema。
- [ ] 为三层数据增加 `schema_version`、`prompt_version`、`created_at` 和模型来源。
- [ ] 扩展 `VisionRecognitionResult`,保留视觉模型完整结构化结果。
- [ ] 将完整原始识别结果写入素材 metadata,而不是只保存响应键名。
- [ ] 增加视觉模型返回 JSON Schema 校验。
- [ ] 增加可修复 JSON 的有限修复流程;无法修复时明确失败,不生成伪结构。
- [ ] 区分 `observed / inferred / unknown / occluded / low_visibility`。
- [ ] 实现 0.60 与 0.80 置信度分层规则。
- [ ] 低置信度和推测属性默认不得进入生图输入。
- [ ] 实现 `MaterialNormalizationService`。
- [ ] 建立类别、服装类型、颜色、长度、版型、材质等同义词归一表。
- [ ] 自动生成 Compact、Standard、Detailed 三档 Generation Capsule。
- [ ] 旧素材根据现有 prompt 自动生成 Legacy Capsule,保证无破坏迁移。
- [ ] 重新识别时保留历史版本和人工修改,不直接覆盖已确认结构。
## 4. P0:素材语义、身体槽位与穿着层级
- [ ] 定义稳定的素材 `category` 枚举。
- [ ] 定义素材 `role` 枚举。
- [ ] 定义身体槽位:identity、hair、head、face、ears、neck、upper_body、arms、hands、waist、hips、upper_legs、lower_legs、feet、pose、background、global_style。
- [ ] 定义穿着层级:skin、inner、base、middle、outer、overlay、accessory、prop。
- [ ] 建立现有素材分类到标准类别、角色、槽位和层级的映射。
- [ ] 建立衣橱分类到标准语义的映射。
- [ ] 支持用户在确认素材时修正类别、角色、槽位和层级。
- [ ] 为连衣裙、套装、外套、内搭、首饰、鞋靴和道具增加专门规则。
- [ ] 对未知分类使用 `other`,并要求确认后再参加自动拼装。
## 5. P0:CompositionBuilder 素材拼接器
- [ ] 新建 `CompositionPlan` DTO。
- [ ] 新建 `CompositionResult` DTO。
- [ ] 新建 `CompositionBuilder` 或 `OutfitPromptCompiler` 服务。
- [ ] 将角色身份作为最高优先级输入。
- [ ] 从衣橱匹配结果读取素材,而不是直接连接素材 prompt。
- [ ] 从素材读取 Generation Capsule。
- [ ] 按身体槽位对素材分组。
- [ ] 按穿着层级排序。
- [ ] 实现连衣裙与独立上衣、下装冲突检测。
- [ ] 实现同身体槽位多素材冲突检测。
- [ ] 支持配饰可叠戴和不可叠戴规则。
- [ ] 实现同一属性值矛盾检测,例如 fitted/oversized、matte/glossy。
- [ ] 冲突解决遵循:用户锁定 > 人工修正 > 高置信观察 > 中置信观察 > 推测。
- [ ] 记录保留、降级、忽略素材及具体原因。
- [ ] 按统一顺序编译身份、发型、体型、内搭、外套、下装、鞋靴、配饰、姿势、场景、风格和光线。
- [ ] 将 `must_preserve` 编译为明确约束段。
- [ ] 将 `forbidden_changes` 编译到负向提示词或禁止变化段。
- [ ] 输出 `resolution_log`、`conflicts`、`ignored_materials` 和 `downgraded_materials`。
- [ ] 接入快速角色、详细角色和单图生成流程。
## 6. P0:素材权重系统
- [ ] 定义角色身份、主服装、连衣裙、下装、发型、鞋靴、配饰、姿势、画风和背景的默认基础权重。
- [ ] 将衣橱“匹配得分”和生成“语义权重”拆成两个独立概念。
- [ ] 增加 `user_adjustment`。
- [ ] 增加素材锁定状态和 `lock_bonus`。
- [ ] 增加主服装、身份素材等 `role_bonus`。
- [ ] 根据当前构图和节点增加 `visibility_bonus`。
- [ ] 根据冲突结果计算 `conflict_penalty`。
- [ ] 根据置信度和推测状态计算 `low_confidence_penalty`。
- [ ] 计算 `effective_weight` 并保留计算明细。
- [ ] 根据最终权重决定胶囊档位、提示词顺序和参考图保留状态。
- [ ] 保留现有 strong/medium/weak 作为模型参考图强度,不与素材语义权重混用。
## 7. P0:用户授权与提示词转译层
- [ ] 新建 `PromptTranslationService`,放在原始用户输入与 CompositionBuilder/PromptExpansionService 之间。
- [ ] 设置页面增加“启用 LLM 提示词转译”总开关,默认关闭或要求用户明确启用。
- [ ] 分别配置 Web、QQ、Telegram、Discord 等入口是否允许自动转译。
- [ ] 保存用户原始输入、转译结果、模型、模板版本和时间,便于追踪与回滚。
- [ ] 原始输入始终保留,不允许转译层静默改变用户核心意图。
- [ ] 支持中文需求转为面向目标生图模型的英文提示词。
- [ ] 支持自动拆分主体、外观、服装、动作、构图、场景、画风、光线、镜头和负向约束。
- [ ] 支持对 CompositionBuilder 的结构化结果进行英文编译,而不是对最终长字符串盲目翻译。
- [ ] 支持模型专用转译模板,例如自然语言型、标签型、SD 权重型。
- [ ] 支持专有名词、角色名、品牌名和用户锁定词“不翻译/固定翻译”词典。
- [ ] 支持中英文混合输入和仅英文输入直通。
- [ ] 支持转译前后差异摘要。
- [ ] 用户可选择“直接使用原文 / 使用转译 / 手动编辑后使用”。
- [ ] 转译失败时安全回退到原始输入,不得生成空提示词。
- [ ] 对转译服务设置超时、重试、token 预算和成本审计。
## 8. P0:合规语义规范化层
> 本层用于降低歧义、减少无意误报并保持需求效果,不用于隐藏禁止内容或绕过模型、平台及服务商的安全审核。
- [ ] 新建 `PromptSemanticNormalizer`,与翻译服务解耦。
- [ ] 将容易产生歧义的口语转换为准确、中性的视觉描述。
- [ ] 将年龄、人物身份、身体状态等高风险歧义显式化,避免模型误判。
- [ ] 对合法成人题材使用明确的“成年角色”约束。
- [ ] 对摄影、医学、艺术、泳装、舞台服装等合法上下文补充必要语境。
- [ ] 不允许删除或伪装会改变安全分类的核心语义。
- [ ] 不允许将被禁止内容改写成隐语、编码词或规避词。
- [ ] 保留改写前后文本及改写理由。
- [ ] 用户锁定的核心视觉效果不可被无提示删除。
- [ ] 如果规范化会显著改变需求,必须要求用户确认。
- [ ] 为每次规范化输出 `changed_terms`、`reason`、`meaning_preserved`。
## 9. P0:生成前提示词审核层
- [ ] 新建 `PromptModerationService`,在最终模型路由确定前执行。
- [ ] 审核对象包含原始输入、转译输入、CompositionResult、负向提示词和参考图职责。
- [ ] 审核返回结构化类别、置信度、风险等级、原因和处置建议。
- [ ] 风险等级至少区分 `safe / sensitive / adult_allowed / uncertain / violence_prohibited / terror_prohibited / prohibited`。
- [ ] 区分合法成人内容与禁止内容,禁止内容不得通过 NSFW 路由继续生成。
- [ ] 单独识别恐怖主义宣传、招募、赞美、威胁和现实行动引导。
- [ ] 单独识别暴力宣扬、针对现实目标的伤害威胁和高危暴力行动请求。
- [ ] 单独识别以极端血腥、肢解、酷刑为核心表现目的的内容。
- [ ] `terror_prohibited` 与 `violence_prohibited` 必须直接拒绝,不允许进入普通或 NSFW 生图模型。
- [ ] 恐暴拒绝响应必须返回明确警告,同时避免复述可操作的危险细节。
- [ ] 恐暴命中写入高优先级安全审计事件,包含入口、用户、群聊、分类和规则版本。
- [ ] 对涉及未成年人或年龄不明确的成人内容采用拒绝或人工确认策略。
- [ ] 对高风险但不确定内容进入保守策略,不自动选择宽松模型。
- [ ] 支持规则审核与 LLM/VLM 审核组合。
- [ ] 规则结果与模型审核冲突时采用更严格结果,或按配置进入人工确认。
- [ ] 审核服务失败时采用 fail-closed 或由管理员明确配置的保守回退。
- [ ] 将审核决策写入任务 metadata 和审计日志,但敏感原文按日志脱敏策略保存。
- [ ] 增加审核模板和分类版本号。
## 10. P0:普通与 NSFW 生图模型动态分流
- [ ] 设置页面增加“内容审核与模型分流”配置栏。
- [ ] 增加默认安全生图路由选择。
- [ ] 增加允许成人内容的 NSFW 生图路由选择。
- [ ] NSFW 路由只能选择管理员明确标记为允许成人内容的已配置适配器和模型。
- [ ] 增加“是否允许成人内容自动分流”开关,默认关闭;管理员开启后,对通过审核与权限检查的 `adult_allowed` 内容自动执行分流。
- [ ] 增加不同入口、群聊、用户和角色工作流的成人内容权限开关。
- [ ] 成人内容分流同时受现有用户白名单、群聊白名单和额度策略约束。
- [ ] 实现 `GenerationRouteDecision`:requested_route、moderation_level、selected_route、reason、fallback_route。
- [ ] safe/sensitive 默认进入普通模型。
- [ ] `adult_allowed` 且用户、入口、管理员策略全部允许时自动进入 NSFW 模型,无需再次手动选择模型。
- [ ] uncertain 默认要求确认或拒绝,不自动分流到 NSFW 模型。
- [ ] `violence_prohibited`、`terror_prohibited` 和 `prohibited` 始终拒绝,不进入任何生图模型。
- [ ] NSFW 模型只承接允许的成人内容,不得作为恐怖、暴力或其他禁止内容的兜底模型。
- [ ] 未配置 NSFW 路由时返回明确错误,不偷偷回退到普通模型。
- [ ] 增加 `GenerationFailureClassifier`,将普通模型失败至少拆分为 `content_safety_rejection / rate_limit / quota_exhausted / authentication / invalid_request / unsupported_capability / timeout / upstream_error / unknown`,保留供应商状态码、错误码和脱敏错误摘要。
- [ ] 普通模型返回失败时先判断失败类型;网络、超时、额度、鉴权、参数、能力不支持和未知错误不得触发 NSFW 路由。
- [ ] 当供应商明确返回成人内容或内容安全拒绝信号时,重新调用 `PromptModerationService` 复核原始提示词、转译提示词和实际发送提示词,不能仅凭模糊的供应商报错改投 NSFW。
- [ ] 二次审核结果为 `adult_allowed`,且管理员开关、入口权限、用户/群聊白名单、额度策略和 NSFW 路由配置全部通过时,允许从普通模型单次回退到 NSFW 模型尝试。
- [ ] 二次审核为 `uncertain` 时要求确认或拒绝;为 `violence_prohibited / terror_prohibited / prohibited` 时直接禁止并警告,不得回退。
- [ ] 普通模型到 NSFW 模型的失败回退最多执行一次,记录 `initial_route / failure_class / moderation_recheck / fallback_route / fallback_reason`,禁止循环切换模型。
- [ ] NSFW 回退也失败时返回明确的最终失败原因,不再自动投递其他成人模型;是否允许人工重试由管理员策略决定。
- [ ] 动态路由决策必须发生在成本检查、任务入队和模型解析前。
- [ ] 将最终路由原因写入任务、图片和聊天审计记录。
## 11. P1:生成后图片审核
- [ ] 新建独立的 `ImageModerationService`,不要复用工作流质量审核结果冒充内容审核。
- [ ] 对普通模型和 NSFW 模型生成结果采用不同但明确的审核策略。
- [ ] 审核生成图片是否超出请求允许范围。
- [ ] 审核生成结果是否出现年龄不明、禁止内容或意外裸露。
- [ ] 结果分为允许返回、警告返回、隔离、重新生成和拒绝返回。
- [ ] 聊天端返回前执行图片审核。
- [ ] Web 图库对受限结果增加权限控制和遮罩。
- [ ] 隔离图片不进入普通图库、角色封面和素材库。
- [ ] 为误判提供管理员复核流程。
- [ ] 保存审核模型、分类、置信度和版本,但避免不必要地复制敏感图片。
## 12. P1:提示词预算与压缩
- [ ] 为不同模型路由配置提示词/token 预算。
- [ ] 根据预算自动选择 Detailed、Standard 或 Compact 胶囊。
- [ ] 超出预算时依次删除推测项、可选特征和低优先级细节。
- [ ] 用户锁定项、身份级特征和安全必要语境不得自动删除。
- [ ] 转译层必须接收预算信息,避免先生成超长文本再粗暴截断。
- [ ] 输出预算前后长度、删除内容和保留原因。
- [ ] 预算压缩后重新进行一次轻量审核,防止上下文删除造成语义变化。
## 13. P1:参考图职责绑定
- [ ] 定义 `ReferenceImageBinding`。
- [ ] 每张参考图保存 `role`、`use_for`、`do_not_inherit` 和权重。
- [ ] 角色参考图默认只继承身份、面部和发型。
- [ ] 服装参考图默认禁止继承面部、体型、姿势、背景和画风。
- [ ] 根据素材权重决定图片参考保留或降级为文字胶囊。
- [ ] 超过模型参考图上限时给出确定性的降级顺序。
- [ ] 为不同适配器实现职责与原生参数映射。
- [ ] 不支持职责参数的模型自动追加明确的英文文本约束。
## 14. P1:API 与前端
- [ ] 素材详情接口返回 RawAnalysis、NormalizedAssetProfile 和三档 Generation Capsule。
- [ ] 素材详情增加“原始识别 / 标准属性 / 生图胶囊”页签。
- [ ] 支持逐项修改属性、置信度、来源类型、槽位、层级和锁定状态。
- [ ] 素材卡展示类别、槽位、层级和确认状态。
- [ ] 增加按颜色、材质、槽位、层级、置信度筛选。
- [ ] 角色衣橱支持设置优先级、锁定和可叠戴。
- [ ] 角色拼装页增加槽位与层级视图。
- [ ] 生图前显示冲突、自动解决方案和忽略项。
- [ ] 提供最终提示词、负向提示词、参考图职责和路由决策预览。
- [ ] 设置页增加提示词转译模型卡片和模板配置。
- [ ] 设置页增加用户授权、入口授权和转译总开关。
- [ ] 设置页增加普通生图路由、NSFW 生图路由和审核模型路由。
- [ ] 设置页明确显示“成人内容可自动路由;恐怖与高危暴力内容始终禁止”的固定策略。
- [ ] 设置页明确展示禁止内容不会被分流生成。
- [ ] 聊天命令支持查看本次转译、审核和路由摘要,但默认不泄露内部规则细节。
- [ ] 高风险或不确定内容提供用户确认交互。
## 15. P1:数据库、迁移与隐私
- [ ] 第一阶段继续使用 material metadata 保存三层素材结构,避免立即大改表结构。
- [ ] 为旧素材增加惰性迁移器。
- [ ] 为提示词转译、审核和路由决策定义版本化记录结构。
- [ ] 明确原始提示词、转译提示词和审核结果的保留时间。
- [ ] 日志界面默认脱敏高风险原文。
- [ ] 数据导出允许用户选择是否包含原始提示词和审核记录。
- [ ] 数据备份包含素材 Schema 与胶囊版本。
- [ ] 统计查询需求稳定后再评估独立 JSON 字段或子表。
## 16. P1:测试队列
- [ ] 视觉模型合法三层结构返回测试。
- [ ] 缺字段、错误字段类型、非 JSON 和超长响应测试。
- [ ] 置信度 0.60/0.80 边界测试。
- [ ] observed/inferred 分流测试。
- [ ] 三档胶囊生成和旧素材 Legacy Capsule 测试。
- [ ] 同义词标准化测试。
- [ ] 连衣裙与上下装冲突测试。
- [ ] 外套与内搭合法叠穿测试。
- [ ] 同槽位配饰冲突与允许叠戴测试。
- [ ] 用户锁定覆盖自动权重测试。
- [ ] 中文转英文语义保持测试。
- [ ] 中英文混合输入和专有名词锁定测试。
- [ ] 转译模型超时、失败、空返回和格式错误测试。
- [ ] 合规语义规范化不改变核心需求测试。
- [ ] 禁止内容不能通过改写进入生成路由测试。
- [ ] safe、sensitive、adult_allowed、uncertain、violence_prohibited、terror_prohibited、prohibited 分级审核测试。
- [ ] 成人内容权限、用户白名单和群白名单组合测试。
- [ ] 允许的成人内容在全部权限命中后自动选择 NSFW 路由测试。
- [ ] 恐怖主义内容直接拒绝、返回警告且不创建任务测试。
- [ ] 高危暴力与极端血腥内容直接拒绝、返回警告且不创建任务测试。
- [ ] 恐暴内容不能通过手动指定 NSFW 路由绕过审核测试。
- [ ] NSFW 路由未配置时明确失败测试。
- [ ] 普通供应商的网络、超时、额度、鉴权、参数和未知失败不会触发 NSFW 路由测试。
- [ ] 普通供应商明确内容安全拒绝后会触发二次审核测试。
- [ ] 二次审核为 `adult_allowed` 且权限全部通过时,普通模型失败后单次回退 NSFW 模型测试。
- [ ] 二次审核为 uncertain、恐暴或其他禁止内容时不回退并按策略确认、拒绝或警告测试。
- [ ] NSFW 回退失败后不循环重试、不继续切换其他模型测试。
- [ ] 路由决策发生在成本检查和任务入队前测试。
- [ ] 提示词预算压缩与压缩后二次审核测试。
- [ ] 多参考图职责和数量上限测试。
- [ ] 生成后图片审核、隔离和图库权限测试。
- [ ] QQ、Telegram、Discord 和 Web 入口回归测试。
- [ ] 快速角色、详细角色、单图和高清修复全链路回归测试。
## 17. P2:后续增强
- [ ] 素材识别和标准化版本对比。
- [ ] 批量重新标准化,不重新调用视觉模型。
- [ ] 素材组合模板和角色常用套装。
- [ ] 根据角色体型、季节、场景自动调整可见性权重。
- [ ] 基于生成结果审核素材还原度。
- [ ] 将还原度反馈到素材权重和胶囊档位选择。
- [ ] 统计素材采用率、冲突率、降级率、转译采用率、审核命中率和路由分布。
- [ ] 为支持 ControlNet、IP-Adapter、区域提示词和多参考权重的适配器增加高级映射。
- [ ] 对不同模型建立提示词效果基准集和离线评测。
## 18. 推荐实施批次
### 批次 A:数据基础
- [ ] 三层素材 DTO、Schema、识别保存、标准化和 Legacy Capsule。
- [ ] 标准类别、身体槽位、穿着层级。
### 批次 B:素材编译核心
- [ ] CompositionBuilder、权重计算、冲突解决和编译日志。
- [ ] 接入衣橱、快速角色和详细角色流程。
### 批次 C:转译与审核
- [ ] PromptTranslationService、用户授权和语义规范化。
- [ ] PromptModerationService 与成人、恐怖、暴力及其他禁止内容分级结果。
### 批次 D:模型动态分流
- [ ] 普通/NSFW 路由配置、权限检查和 GenerationRouteDecision。
- [ ] 在成本检查、任务入队前完成路由决策。
### 批次 E:前端闭环
- [ ] 素材三层详情、拼装预览、冲突操作、转译预览、审核提示和路由配置。
### 批次 F:生成后审核与全量回归
- [ ] 图片审核、隔离、图库权限和跨聊天平台测试。
## 19. 完成定义
- [x] 任意已确认素材均具有可追溯 RawAnalysis、标准化档案和至少一份可用胶囊。
- [x] 多素材组合不再通过无规则字符串拼接完成。
- [x] 每次拼装都能解释素材保留、降级和忽略原因。
- [x] 用户授权后,中文需求可稳定转为保持原意的英文模型提示词。
- [x] 规范化层不会隐藏禁止内容或绕过安全审核。
- [x] 每次生成前都有可审计的内容风险结果和模型路由决策。
- [x] 只有管理员配置、用户权限和审核结果同时允许时,成人内容才会自动进入 NSFW 路由。
- [x] 恐怖主义、高危暴力和极端血腥内容直接拒绝并警告,且不会创建生成任务。
- [x] 禁止内容不会进入普通或 NSFW 生图模型。
- [x] 生成后图片在返回聊天端和进入图库前完成相应审核。
- [x] 所有旧素材、旧工作流和现有前端功能保持兼容。
- [x] 后端、前端、数据库迁移及聊天平台测试全部通过。
## 20. 实施完成记录
- [x] 批次 A:三层素材 DTO/Schema、完整视觉结构保存、置信度规则、Legacy Capsule、标准类别、身体槽位和穿着层级。
- [x] 批次 B:CompositionBuilder、语义权重、用户锁定、冲突解决、预算压缩、参考图职责和详细工作流素材编译。
- [x] 批次 C:PromptTranslationService、用户授权、原文回退、PromptSemanticNormalizer、PromptModerationService 和恐暴禁止策略。
- [x] 批次 D:GenerationRouteDecision、普通/NSFW 动态路由、供应商失败分类、内容安全拒绝二次审核和单次 NSFW 回退。
- [x] 批次 E:设置页提示词治理卡片、发送前预览、素材三层详情/编辑/历史、语义筛选、套装模板与拼装预览。
- [x] 批次 F:生成后图片审核、单次自动再生成、隔离图库、管理员复核、聊天入口权限和成人独立白名单。
- [x] 数据与隐私:惰性迁移、批量重新标准化、Schema 版本备份、提示词/审核记录可选导出和日志脱敏记录。
- [x] 后续增强:套装模板、场景/季节/可见槽位权重、素材还原度反馈、统计 API、参考图方言映射和离线基准工具。
- [x] 后端回归:420 passed、1 skipped、31 subtests passed。
- [x] 前端验证:plugin-page 与 standalone-web 两套 Vite 生产构建通过。
主要新增入口:
- `POST prompts/governance-preview`
- `GET materials/analytics`
- `POST materials/renormalize-batch`
- `POST materials/{material_id}/renormalize`
- `GET/POST profiles/{profile_id}/wardrobe-templates`
- `POST profiles/{profile_id}/wardrobe-templates/{template_id}/apply`
- `POST images/{image_id}/moderation-review`
说明:上方原始清单保留为需求追溯底稿;本节为最终实施状态,以自动化测试和生产构建结果为验收依据。

查看文件

@ -3,6 +3,7 @@
from __future__ import annotations
import json
import re
import urllib.error
import urllib.request
from dataclasses import dataclass, field
@ -62,6 +63,7 @@ class VisionRecognitionResult:
tags: list[str] = field(default_factory=list)
confidence: float | None = None
description: str | None = None
structured_data: dict[str, Any] = field(default_factory=dict)
raw_metadata: dict[str, Any] = field(default_factory=dict)
@ -151,6 +153,17 @@ class MockVisionProvider:
negative_prompt="body, face, background, watermark",
tags=tags,
confidence=0.72,
structured_data={
"raw_analysis": {
"attributes": {
"design": {
"value": base,
"confidence": 0.72,
"source_state": "observed",
}
}
}
},
raw_metadata={"mock": True},
)
@ -180,7 +193,11 @@ def _system_instruction(request: VisionRecognitionRequest) -> str:
"visible facts including object type, colors, materials, texture, construction, silhouette, patterns, trims, "
"accessories, condition, viewpoint, lighting and reusable design features. Distinguish certainty from guesses. "
"Produce a detailed image-generation prompt that preserves the recognized design, plus a useful negative prompt. "
"Return JSON only with keys prompt, negative_prompt, tags, confidence, description. Tags must be concise and searchable."
"Return one JSON object. Keep compatibility keys prompt, negative_prompt, tags, confidence and description. "
"Also include raw_analysis.attributes where every attribute has value, confidence (0-1), and source_state "
"(observed, inferred, unknown, occluded, or low_visibility); normalized_asset_profile with category, role, "
"body_slots, wear_layer, must_preserve and forbidden_changes; and optional generation_capsules. "
"Never present guesses as observed facts. Tags must be concise and searchable."
)
return configured or fallback
@ -268,7 +285,11 @@ def _parse_vision_response(provider_id: str, model: str, response: JsonDict) ->
tags=_string_list(parsed.get("tags")),
confidence=_float_or_none(parsed.get("confidence")),
description=_optional_text(parsed.get("description")),
raw_metadata={"response_keys": sorted(str(key) for key in response.keys())},
structured_data=parsed,
raw_metadata={
"response_keys": sorted(str(key) for key in response.keys()),
"structured_keys": sorted(str(key) for key in parsed.keys()),
},
)
@ -303,22 +324,34 @@ def _content_to_text(value: Any) -> str:
def _json_from_text(value: str) -> JsonDict:
text = value.strip()
text = value.strip().lstrip("\ufeff")
if not text:
raise VisionProviderError("vision provider response was empty", provider_id="unknown", error_type="invalid_response")
try:
parsed = json.loads(text)
except json.JSONDecodeError:
start = text.find("{")
end = text.rfind("}")
if start < 0 or end <= start:
raise VisionProviderError(
"vision provider response was not JSON",
provider_id="unknown",
error_type="invalid_response",
details={"content_preview": text[:500]},
) from None
parsed = json.loads(text[start : end + 1])
candidates = [text]
start = text.find("{")
end = text.rfind("}")
if start >= 0 and end > start:
extracted = text[start : end + 1]
if extracted != text:
candidates.append(extracted)
# A deliberately small repair set: fenced JSON and trailing commas only.
# It does not invent fields or values when a provider response is malformed.
candidates.extend(re.sub(r",\s*([}\]])", r"\1", item) for item in list(candidates))
parsed: Any = None
last_error: json.JSONDecodeError | None = None
for candidate in candidates[:4]:
try:
parsed = json.loads(candidate)
break
except json.JSONDecodeError as exc:
last_error = exc
if parsed is None:
raise VisionProviderError(
"vision provider response was not valid JSON",
provider_id="unknown",
error_type="invalid_response",
details={"content_preview": text[:500], "parse_error": str(last_error or "unknown")},
) from None
if not isinstance(parsed, dict):
raise VisionProviderError("vision provider JSON must be an object", provider_id="unknown", error_type="invalid_response")
return parsed

查看文件

@ -1,12 +1,12 @@
{
"name": "astrbot-plugin-imagestudio-frontend",
"version": "3.0.0",
"version": "1.0.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "astrbot-plugin-imagestudio-frontend",
"version": "3.0.0",
"version": "1.0.0",
"dependencies": {
"@vitejs/plugin-vue": "^5.2.0",
"pinia": "^2.3.0",

查看文件

@ -1,6 +1,6 @@
{
"name": "astrbot-plugin-imagestudio-frontend",
"version": "3.1.0",
"version": "1.0.0",
"private": true,
"type": "module",
"scripts": {

查看文件

@ -32,6 +32,7 @@ export const endpoints = {
reviewPolicyValidate: "review/policy/validate",
reviewPolicySave: "review/policy/save",
promptsExpand: "prompts/expand",
promptGovernancePreview: "prompts/governance-preview",
nodeReview: (nodeId: string) => `nodes/${nodeId}/review`,
nodeImages: (nodeId: string) => `nodes/${nodeId}/images`,
workflowReview: (workflowId: string) => `workflows/${workflowId}/review`,
@ -84,6 +85,12 @@ export const endpoints = {
wardrobeItem: (profileId: string, wardrobeItemId: string) => `profiles/${profileId}/wardrobe/items/${wardrobeItemId}`,
wardrobeLegacyItem: (profileId: string, wardrobeItemId: string) => `profiles/${profileId}/wardrobe/${wardrobeItemId}`,
wardrobeMatch: (profileId: string) => `profiles/${profileId}/wardrobe/match`,
wardrobeTemplates: (profileId: string) => `profiles/${profileId}/wardrobe-templates`,
wardrobeTemplate: (profileId: string, templateId: string) => `profiles/${profileId}/wardrobe-templates/${templateId}`,
wardrobeTemplateApply: (profileId: string, templateId: string) => `profiles/${profileId}/wardrobe-templates/${templateId}/apply`,
materialAnalytics: "materials/analytics",
materialRenormalizeBatch: "materials/renormalize-batch",
materialRenormalize: (materialId: string) => `materials/${materialId}/renormalize`,
privateCompanionDailyOutfit: "integrations/private-companion/daily-outfit",
privateCompanionToken: "integrations/private-companion/token",
privateCompanionTokenRotate: "integrations/private-companion/token/rotate",

查看文件

@ -217,6 +217,11 @@ interface MaterialLibraryCard {
source: "backend" | "sample"
colors: [string, string, string]
updatedAt: string
semanticCategory: string
bodySlots: string[]
wearLayer: string
confidence: number
profileConfirmed: boolean
}
interface MaterialActionCard extends UiActionCard<MaterialTone> {
@ -1128,6 +1133,9 @@ const selectedQueueFilter = ref<QueueFilterKey>("active")
const selectedQueueTaskId = ref("")
const selectedMaterialCategoryId = ref("")
const selectedMaterialAccessoryGroup = ref("")
const materialSlotFilter = ref("")
const materialLayerFilter = ref("")
const materialConfidenceFilter = ref(0)
const selectedMaterialId = ref("")
const materialActionMessage = ref("")
const materialActionExecutingId = ref("")
@ -1505,10 +1513,14 @@ const materialLibraryCards = computed<MaterialLibraryCard[]>(() => {
const filteredByCategory = activeCategoryIds.length
? cards.filter((card) => activeCategoryIds.includes(card.categoryId))
: []
if (selectedMaterialCategoryCard.value?.label !== QUICK_PROFILE_ACCESSORY_CATEGORY || !selectedMaterialAccessoryGroup.value) {
return filteredByCategory
}
return filteredByCategory.filter((card) => card.subcategory === selectedMaterialAccessoryGroup.value)
const accessoryFiltered = selectedMaterialCategoryCard.value?.label !== QUICK_PROFILE_ACCESSORY_CATEGORY || !selectedMaterialAccessoryGroup.value
? filteredByCategory
: filteredByCategory.filter((card) => card.subcategory === selectedMaterialAccessoryGroup.value)
return accessoryFiltered.filter((card) =>
(!materialSlotFilter.value || card.bodySlots.includes(materialSlotFilter.value)) &&
(!materialLayerFilter.value || card.wearLayer === materialLayerFilter.value) &&
card.confidence >= materialConfidenceFilter.value,
)
})
const selectedMaterialLibraryItem = computed<MaterialLibraryCard | null>(() => {
if (!materialLibraryCards.value.length) return null
@ -5336,6 +5348,9 @@ function materialLibraryCardFromBackend(material: Material, index: number): Mate
metadataString(material.metadata?.group) ||
metadataString(material.metadata?.accessory_group) ||
"其他"
const profile = material.metadata?.normalized_asset_profile && typeof material.metadata.normalized_asset_profile === "object" && !Array.isArray(material.metadata.normalized_asset_profile)
? material.metadata.normalized_asset_profile as Record<string, unknown>
: {}
return {
id: material.material_id,
label: material.display_name || shortId(material.material_id),
@ -5359,6 +5374,11 @@ function materialLibraryCardFromBackend(material: Material, index: number): Mate
source: "backend",
colors: ["#64748b", "#2ec4b6", "#7168f0"],
updatedAt: formatTime(material.updated_at || material.created_at),
semanticCategory: String(profile.category || "other"),
bodySlots: Array.isArray(profile.body_slots) ? profile.body_slots.map(String) : [],
wearLayer: String(profile.wear_layer || ""),
confidence: Number(profile.confidence || 0),
profileConfirmed: profile.confirmed === true,
}
}
@ -5379,6 +5399,11 @@ function materialLibraryCardFromSample(material: QuickProfileMaterialOption, ind
source: "sample",
colors: material.colors,
updatedAt: "本地示例",
semanticCategory: "other",
bodySlots: [],
wearLayer: "",
confidence: 0,
profileConfirmed: false,
}
}
@ -8128,6 +8153,27 @@ async function registerMaterialUri(payload: MaterialRegistrationRequest) {
}
}
async function saveSelectedMaterialProfile(profile: Record<string, unknown>) {
const material = selectedBackendMaterialRecord.value
if (!material || materialOperationExecuting.value) return
const blocked = backendWriteBlockMessage("保存素材标准属性")
if (blocked) {
materialActionMessage.value = blocked
return
}
materialOperationExecuting.value = true
materialActionMessage.value = ""
try {
await putJson<Material>(endpoints.material(material.material_id), { normalized_asset_profile: profile })
await loadMaterials()
materialActionMessage.value = `素材「${material.display_name}」的标准属性已保存。`
} catch (err) {
materialActionMessage.value = `保存标准属性失败:${errorMessage(err)}`
} finally {
materialOperationExecuting.value = false
}
}
async function planMaterialAssetPack(payload: AssetPackRequest) {
if (materialOperationExecuting.value) return
const blocked = backendWriteBlockMessage("预检查素材包")
@ -10817,6 +10863,13 @@ function errorMessage(err: unknown) {
</button>
</div>
<div class="materials-semantic-filters" aria-label="素材语义筛选">
<label><span>身体槽位</span><select v-model="materialSlotFilter"><option value="">全部槽位</option><option v-for="slot in ['identity','hair','head','face','ears','neck','upper_body','arms','hands','waist','hips','upper_legs','lower_legs','feet','pose','background','global_style']" :key="slot" :value="slot">{{ slot }}</option></select></label>
<label><span>穿着层级</span><select v-model="materialLayerFilter"><option value="">全部层级</option><option v-for="layer in ['skin','inner','base','middle','outer','overlay','accessory','prop']" :key="layer" :value="layer">{{ layer }}</option></select></label>
<label><span>最低置信度</span><select v-model.number="materialConfidenceFilter"><option :value="0">不限</option><option :value="0.6">≥ 0.60 可参与生成</option><option :value="0.8">≥ 0.80 高置信</option></select></label>
<button type="button" @click="materialSlotFilter='';materialLayerFilter='';materialConfidenceFilter=0">清除筛选</button>
</div>
<div
v-if="materialAccessoryGroupCards.length"
class="materials-subfilter-strip"
@ -10948,6 +11001,8 @@ function errorMessage(err: unknown) {
:open="showMaterialDetailCard"
:item="selectedMaterialLibraryItem"
:rows="selectedMaterialRows"
:material="selectedBackendMaterialRecord"
@save-profile="saveSelectedMaterialProfile"
@close="closeOverlay('materialDetail')"
/>
</section>
@ -13120,6 +13175,43 @@ body {
padding: 1px 0 3px;
}
.materials-semantic-filters {
display: grid;
grid-template-columns: repeat(3, minmax(0, 1fr)) auto;
align-items: end;
gap: 8px;
border: 1px solid var(--border);
border-radius: 8px;
padding: 9px;
background: var(--panel-muted);
}
.materials-semantic-filters label {
display: grid;
gap: 4px;
}
.materials-semantic-filters span {
color: var(--text-soft);
font-size: 10px;
font-weight: 900;
}
.materials-semantic-filters select,
.materials-semantic-filters button {
min-height: 34px;
border: 1px solid var(--border);
border-radius: 6px;
padding: 0 8px;
color: var(--text);
background: var(--panel);
font: inherit;
}
.materials-semantic-filters button {
cursor: pointer;
}
.materials-category-chip {
display: inline-flex;
align-items: center;

查看文件

@ -1,5 +1,5 @@
<script setup lang="ts">
import { nextTick, ref, watch } from "vue"
import { computed, nextTick, ref, watch } from "vue"
interface MaterialDetailItem {
label: string
@ -18,26 +18,41 @@ const props = defineProps<{
open: boolean
item: MaterialDetailItem | null
rows: readonly MaterialDetailRow[]
material?: { metadata?: Record<string, unknown>; prompt?: string | null; negative_prompt?: string | null } | null
}>()
const emit = defineEmits<{
close: []
saveProfile: [profile: Record<string, unknown>]
}>()
const closeButton = ref<HTMLButtonElement | null>(null)
const activeTab = ref<"summary"|"raw"|"profile"|"capsules"|"history">("summary")
const rawAnalysis = computed(()=>objectValue(props.material?.metadata?.raw_analysis))
const profile = computed(()=>objectValue(props.material?.metadata?.normalized_asset_profile))
const capsules = computed(()=>objectValue(props.material?.metadata?.generation_capsules))
const history = computed(()=>Array.isArray(props.material?.metadata?.material_schema_history)?props.material?.metadata?.material_schema_history:[])
const editCategory=ref("other"),editRole=ref("other"),editSlots=ref(""),editLayer=ref(""),editConfidence=ref(0),editLocked=ref(false),editStackable=ref(false)
const editProfileJson=ref(""),profileEditError=ref("")
watch(
() => props.open,
(open) => {
if (!open) return
activeTab.value = "summary"
void nextTick(() => closeButton.value?.focus())
},
{ immediate: true },
)
watch(profile,(value)=>{editCategory.value=String(value.category||"other");editRole.value=String(value.role||"other");editSlots.value=Array.isArray(value.body_slots)?value.body_slots.map(String).join(", "):"";editLayer.value=String(value.wear_layer||"");editConfidence.value=Number(value.confidence||0);editLocked.value=value.user_locked===true;editStackable.value=value.stackable===true;editProfileJson.value=pretty(value);profileEditError.value=""},{immediate:true})
function requestClose() {
emit("close")
}
function objectValue(value:unknown):Record<string,unknown>{return value&&typeof value==="object"&&!Array.isArray(value)?value as Record<string,unknown>: {}}
function pretty(value:unknown){return JSON.stringify(value??{},null,2)}
function saveProfile(){emit("saveProfile",{...profile.value,category:editCategory.value,role:editRole.value,body_slots:editSlots.value.split(/[,,]/).map(item=>item.trim()).filter(Boolean),wear_layer:editLayer.value||null,confidence:Math.min(Math.max(editConfidence.value,0),1),user_locked:editLocked.value,stackable:editStackable.value,confirmed:true})}
function saveAdvancedProfile(){try{const parsed=JSON.parse(editProfileJson.value);if(!parsed||typeof parsed!=="object"||Array.isArray(parsed))throw new Error("必须是 JSON 对象");profileEditError.value="";emit("saveProfile",parsed)}catch(e){profileEditError.value=e instanceof Error?e.message:String(e)}}
</script>
<template>
@ -74,14 +89,31 @@ function requestClose() {
<button ref="closeButton" type="button" title="关闭" @click="requestClose">×</button>
</header>
<dl>
<nav v-if="props.material" class="detail-tabs" aria-label="素材结构详情">
<button :class="{active:activeTab==='summary'}" @click="activeTab='summary'">基础信息</button>
<button :class="{active:activeTab==='raw'}" @click="activeTab='raw'">原始识别</button>
<button :class="{active:activeTab==='profile'}" @click="activeTab='profile'">标准属性</button>
<button :class="{active:activeTab==='capsules'}" @click="activeTab='capsules'">生图胶囊</button>
<button :class="{active:activeTab==='history'}" @click="activeTab='history'">版本历史</button>
</nav>
<dl v-if="activeTab==='summary'">
<div v-for="row in props.rows" :key="row.label">
<dt>{{ row.label }}</dt>
<dd>{{ row.value }}</dd>
</div>
</dl>
<section v-else-if="activeTab==='raw'" class="structured-panel"><header><strong>RawAnalysis</strong><span>{{String(rawAnalysis.schema_version||'Legacy')}}</span></header><p>保留视觉模型完整结构化返回、属性来源和置信度,便于重新标准化。</p><pre>{{pretty(rawAnalysis)}}</pre></section>
<section v-else-if="activeTab==='profile'" class="structured-panel"><header><strong>NormalizedAssetProfile</strong><span>{{String(profile.category||'other')}}</span></header><div class="profile-editor"><label><span>标准分类</span><select v-model="editCategory"><option v-for="item in ['identity','hair','headwear','face_accessory','jewelry','top','bottom','dress','suit','outerwear','underwear','hosiery','footwear','prop','pose','background','style','other']" :key="item">{{item}}</option></select></label><label><span>角色</span><select v-model="editRole"><option v-for="item in ['identity','garment','accessory','prop','pose','background','style','other']" :key="item">{{item}}</option></select></label><label class="wide"><span>身体槽位(逗号分隔)</span><input v-model="editSlots"></label><label><span>穿着层级</span><select v-model="editLayer"><option value="">无</option><option v-for="item in ['skin','inner','base','middle','outer','overlay','accessory','prop']" :key="item">{{item}}</option></select></label><label><span>总体置信度</span><input v-model.number="editConfidence" type="number" min="0" max="1" step="0.01"></label><label class="check"><input v-model="editLocked" type="checkbox"> 锁定人工修正</label><label class="check"><input v-model="editStackable" type="checkbox"> 允许叠加</label><button type="button" @click="saveProfile">保存标准属性</button></div><details class="advanced-editor"><summary>高级 JSON 编辑(属性值、置信度、来源状态、锁定项)</summary><textarea v-model="editProfileJson" rows="14"></textarea><p v-if="profileEditError">{{profileEditError}}</p><button type="button" @click="saveAdvancedProfile">校验并保存完整档案</button></details><div class="profile-badges"><b>{{String(profile.role||'other')}}</b><b>{{String(profile.wear_layer||'无层级')}}</b><b v-for="slot in (Array.isArray(profile.body_slots)?profile.body_slots:[])" :key="String(slot)">{{slot}}</b></div><pre>{{pretty(profile)}}</pre></section>
<section v-else-if="activeTab==='capsules'" class="structured-panel"><header><strong>Generation Capsule</strong><span>Compact / Standard / Detailed</span></header><article v-for="tier in ['compact','standard','detailed']" :key="tier"><b>{{tier}}</b><p>{{(Array.isArray(objectValue(capsules[tier]).prompt_parts)?objectValue(capsules[tier]).prompt_parts:[]).join(',')||'暂无提示词'}}</p></article></section>
<section v-else class="structured-panel"><header><strong>识别与标准化版本</strong><span>{{history.length}} 个历史版本</span></header><p>重新识别与批量重新标准化不会覆盖已确认结构;历史版本可用于人工对比。</p><article v-for="(version,index) in history" :key="index"><b>{{String(objectValue(version).archived_at||`版本 ${index+1}`)}}</b><p>{{String(objectValue(objectValue(version).normalized_asset_profile).category||'other')}} · {{String(objectValue(objectValue(version).normalized_asset_profile).role||'other')}}</p><pre>{{pretty(version)}}</pre></article><p v-if="!history.length">暂无历史版本。</p></section>
</aside>
</section>
</div>
</Transition>
</template>
<style scoped>
.detail-tabs{display:grid;grid-template-columns:repeat(4,1fr);gap:5px;border-bottom:1px solid var(--border);padding-bottom:10px}.detail-tabs button{min-height:34px;border:1px solid var(--border);border-radius:6px;color:var(--text-soft);background:var(--panel-muted);cursor:pointer}.detail-tabs button.active{border-color:var(--primary);color:var(--primary);background:var(--primary-soft)}.structured-panel{display:grid;gap:9px;min-height:0}.structured-panel>header{display:flex;align-items:center;justify-content:space-between}.structured-panel>header span,.structured-panel>p{color:var(--text-soft);font-size:12px}.structured-panel>p{margin:0;line-height:1.5}.structured-panel pre{max-height:45vh;overflow:auto;margin:0;border:1px solid var(--border);border-radius:7px;padding:11px;background:var(--panel-muted);font-size:11px;white-space:pre-wrap}.profile-editor{display:grid;grid-template-columns:repeat(2,1fr);gap:8px;border:1px solid var(--border);border-radius:7px;padding:10px;background:var(--panel-muted)}.profile-editor label{display:grid;gap:4px}.profile-editor label.wide{grid-column:1/-1}.profile-editor label>span{color:var(--text-soft);font-size:11px}.profile-editor input,.profile-editor select{min-height:34px;border:1px solid var(--border);border-radius:6px;padding:0 8px;color:var(--text);background:var(--panel)}.profile-editor .check{display:flex;align-items:center;gap:6px}.profile-editor .check input{min-height:auto}.profile-editor button{grid-column:1/-1;min-height:35px;border:1px solid var(--primary);border-radius:6px;color:#fff;background:var(--primary);cursor:pointer}.profile-badges{display:flex;flex-wrap:wrap;gap:5px}.profile-badges b,.structured-panel article>b{border-radius:5px;padding:4px 7px;color:var(--primary);background:var(--primary-soft);font-size:11px}.structured-panel article{display:grid;gap:5px;border:1px solid var(--border);border-radius:7px;padding:10px;background:var(--panel-muted)}.structured-panel article p{margin:0;color:var(--text-soft);font-size:12px;line-height:1.5}@media(max-width:700px){.detail-tabs,.profile-editor{grid-template-columns:repeat(2,1fr)}}
.detail-tabs{grid-template-columns:repeat(5,1fr)}
.advanced-editor{display:grid;gap:7px;border:1px solid var(--border);border-radius:7px;padding:9px;background:var(--panel-muted)}.advanced-editor summary{cursor:pointer;font-size:12px;font-weight:750}.advanced-editor textarea{width:100%;box-sizing:border-box;border:1px solid var(--border);border-radius:6px;padding:8px;color:var(--text);background:var(--panel);font:11px/1.5 ui-monospace,monospace;resize:vertical}.advanced-editor p{color:var(--danger)}.advanced-editor button{min-height:34px;border:1px solid var(--primary);border-radius:6px;color:#fff;background:var(--primary);cursor:pointer}
</style>

查看文件

@ -298,6 +298,7 @@ function forwardWardrobeAdd(materialId: string, wardrobeCategory: string) {
:loading="wardrobeLoading"
:busy="wardrobeBusy"
:error="wardrobeError"
:profile-id="profile.profile_id"
@retry="emit('wardrobeRetry')"
@add="forwardWardrobeAdd"
@remove="emit('wardrobeRemove', $event)"

查看文件

@ -4,6 +4,8 @@ import { computed, nextTick, ref, watch } from "vue"
import type { UiBootstrap } from "../../../../shared/types/bootstrap"
import type { Material, MaterialCategory } from "../../../../shared/types/material"
import type { WardrobeItem } from "../../../../shared/types/wardrobe"
import { deleteJson, getJson, postJson } from "../../../../shared/api/client"
import { endpoints } from "../../../../shared/api/endpoints"
const props = withDefaults(
defineProps<{
@ -14,6 +16,7 @@ const props = withDefaults(
loading?: boolean
busy?: boolean
error?: string
profileId?: string
}>(),
{
wardrobeItems: () => [],
@ -23,6 +26,7 @@ const props = withDefaults(
loading: false,
busy: false,
error: "",
profileId: "",
},
)
@ -51,6 +55,7 @@ const selectedAddCategoryTouched = ref(false)
const pickerDialog = ref<HTMLElement | null>(null)
const pickerCloseButton = ref<HTMLButtonElement | null>(null)
const pickerTrigger = ref<HTMLElement | null>(null)
const outfitTemplates=ref<Array<Record<string,unknown>>>([]),templateName=ref(""),templateBusy=ref(false),templateMessage=ref(""),compositionPreview=ref<Record<string,unknown>|null>(null)
const categoryValues = computed(() => {
const customCategories = [
@ -142,6 +147,7 @@ watch(selectedMaterial, (material) => {
? suggestedCategory
: pickerDefaultCategory.value
})
watch(()=>props.profileId,()=>{void loadTemplates()},{immediate:true})
function wardrobeCategoryLabel(category: string) {
const normalized = category.trim()
@ -237,6 +243,10 @@ function submitAdd() {
if (!selectedMaterial.value || !category || props.busy || !canManage.value) return
emit("add", selectedMaterial.value.material_id, category)
}
async function loadTemplates(){if(!props.profileId){outfitTemplates.value=[];return}try{outfitTemplates.value=await getJson(endpoints.wardrobeTemplates(props.profileId))}catch{outfitTemplates.value=[]}}
async function saveCurrentTemplate(){if(!props.profileId||!templateName.value.trim()||!props.wardrobeItems.length)return;templateBusy.value=true;templateMessage.value="";try{await postJson(endpoints.wardrobeTemplates(props.profileId),{name:templateName.value.trim(),material_ids:props.wardrobeItems.map(item=>item.material_id)});templateName.value="";templateMessage.value="套装模板已保存";await loadTemplates()}catch(e){templateMessage.value=e instanceof Error?e.message:String(e)}finally{templateBusy.value=false}}
async function applyTemplate(templateId:string){if(!props.profileId)return;templateBusy.value=true;try{const result=await postJson<Record<string,unknown>>(endpoints.wardrobeTemplateApply(props.profileId,templateId),{});compositionPreview.value=result.composition as Record<string,unknown>;templateMessage.value="套装已编译,可在下方检查冲突与提示词。"}catch(e){templateMessage.value=e instanceof Error?e.message:String(e)}finally{templateBusy.value=false}}
async function removeTemplate(templateId:string){if(!props.profileId)return;templateBusy.value=true;try{await deleteJson(endpoints.wardrobeTemplate(props.profileId,templateId));await loadTemplates()}catch(e){templateMessage.value=e instanceof Error?e.message:String(e)}finally{templateBusy.value=false}}
</script>
<template>
@ -283,6 +293,8 @@ function submitAdd() {
</button>
</nav>
<section class="outfit-templates"><header><div><span>常用组合</span><strong>衣橱套装模板</strong></div><div><input v-model="templateName" placeholder="套装名称"><button :disabled="templateBusy||!templateName.trim()||!wardrobeItems.length||!canManage" @click="saveCurrentTemplate">保存当前衣橱</button></div></header><p v-if="templateMessage">{{templateMessage}}</p><div v-if="outfitTemplates.length" class="template-list"><article v-for="item in outfitTemplates" :key="String(item.template_id)"><span><strong>{{item.name}}</strong><small>{{Array.isArray(item.material_ids)?item.material_ids.length:0}} 件素材</small></span><button :disabled="templateBusy" @click="applyTemplate(String(item.template_id))">编译预览</button><button class="danger" :disabled="templateBusy||!canManage" @click="removeTemplate(String(item.template_id))">删除</button></article></div><div v-if="compositionPreview" class="composition-preview"><header><strong>拼装结果</strong><span>{{Array.isArray(compositionPreview.conflicts)?compositionPreview.conflicts.length:0}} 个冲突</span></header><p>{{String(compositionPreview.prompt||'')}}</p><details><summary>查看解决日志</summary><pre>{{JSON.stringify({conflicts:compositionPreview.conflicts,ignored_materials:compositionPreview.ignored_materials,downgraded_materials:compositionPreview.downgraded_materials,reference_bindings:compositionPreview.reference_bindings},null,2)}}</pre></details></div></section>
<div v-if="loading && !wardrobeItems.length" class="wardrobe-loading" role="status" aria-label="正在加载角色衣橱">
<span v-for="index in 6" :key="index" />
</div>
@ -544,6 +556,8 @@ button:disabled {
font-weight: 800;
}
.outfit-templates{display:grid;gap:9px;border:1px solid var(--border);border-radius:8px;padding:12px;background:var(--panel-muted)}.outfit-templates>header{display:flex;align-items:center;justify-content:space-between;gap:10px}.outfit-templates>header>div{display:flex;align-items:center;gap:7px}.outfit-templates>header>div:first-child{display:grid;gap:2px}.outfit-templates>header span,.outfit-templates p,.template-list small{color:var(--text-soft);font-size:11px}.outfit-templates input{min-height:36px;border:1px solid var(--border);border-radius:7px;padding:0 9px;color:var(--text);background:var(--panel)}.outfit-templates button{min-height:36px;border:1px solid var(--border);border-radius:7px;padding:0 9px;color:var(--text);background:var(--panel);cursor:pointer}.template-list{display:grid;gap:6px}.template-list article{display:grid;grid-template-columns:minmax(0,1fr) auto auto;align-items:center;gap:7px;border-radius:7px;padding:8px;background:var(--panel)}.template-list article>span{display:grid;gap:2px}.template-list .danger{color:var(--danger)}.composition-preview{display:grid;gap:7px;border-top:1px solid var(--border);padding-top:9px}.composition-preview header{display:flex;justify-content:space-between}.composition-preview p{margin:0;line-height:1.5}.composition-preview pre{max-height:240px;overflow:auto;border-radius:6px;padding:8px;background:var(--panel);font-size:10px;white-space:pre-wrap}
.wardrobe-grid,
.wardrobe-loading {
display: grid;

查看文件

@ -3,10 +3,15 @@ import { onMounted, ref } from "vue"
import { getJson, postJson } from "../../../../shared/api/client"
import { endpoints } from "../../../../shared/api/endpoints"
import type { DiffSettingsResult, ExportSettingsResult, ImportSettingsResult, RollbackSettingsResult, SettingsSnapshot } from "../../../../shared/types/settings"
const props=defineProps<{snapshots:readonly SettingsSnapshot[];backendConnected:boolean;canManage:boolean}>();const emit=defineEmits<{refresh:[]}>()
const busy=ref(false),message=ref(""),error=ref(""),importPreview=ref<Record<string,unknown>|null>(null),importFileName=ref("")
const props=defineProps<{snapshots:readonly SettingsSnapshot[];backendConnected:boolean;canManage:boolean}>()
const emit=defineEmits<{refresh:[]}>()
const busy=ref(false),message=ref(""),error=ref("")
const importPreview=ref<Record<string,unknown>|null>(null),importFileName=ref("")
const selectedSnapshot=ref<SettingsSnapshot|null>(null),snapshotDiff=ref<DiffSettingsResult|null>(null)
const fullBackups=ref<Array<Record<string,unknown>>>([]),selectedBackup=ref<Record<string,unknown>|null>(null),includeMedia=ref(true)
const fullBackups=ref<Array<Record<string,unknown>>>([]),selectedBackup=ref<Record<string,unknown>|null>(null)
const includeMedia=ref(true),includePromptRecords=ref(true),includeModerationRecords=ref(true)
async function task(operation:()=>Promise<void>){busy.value=true;error.value="";try{await operation()}catch(e){error.value=e instanceof Error?e.message:String(e)}finally{busy.value=false}}
async function exportConfig(){await task(async()=>{const data=await getJson<ExportSettingsResult>(endpoints.settingsExport);const blob=new Blob([JSON.stringify({format:"imagestudio-settings-backup",version:1,exported_at:new Date().toISOString(),...data},null,2)],{type:"application/json"});const url=URL.createObjectURL(blob),link=document.createElement("a");link.href=url;link.download=`imagestudio-config-${new Date().toISOString().slice(0,10)}.json`;link.click();URL.revokeObjectURL(url);message.value="脱敏配置已导出。"})}
async function selectFile(event:Event){const file=(event.target as HTMLInputElement).files?.[0];if(!file)return;await task(async()=>{const parsed=JSON.parse(await file.text()) as Record<string,unknown>;const config=(parsed.config??parsed) as Record<string,unknown>;if(!config||typeof config!=="object"||Array.isArray(config)||!Object.keys(config).length)throw new Error("备份文件没有有效配置");importPreview.value=config;importFileName.value=file.name;message.value="文件读取成功,请确认导入。"})}
@ -14,10 +19,39 @@ async function importConfig(){if(!importPreview.value)return;await task(async()=
async function inspectSnapshot(item:SettingsSnapshot){await task(async()=>{const loaded=await getJson<SettingsSnapshot>(endpoints.settingsSnapshot(item.snapshot_id));selectedSnapshot.value=loaded;snapshotDiff.value=await postJson(endpoints.settingsDiff,{config:loaded.config})})}
async function rollbackSnapshot(){if(!selectedSnapshot.value||!confirm("确定回滚到此配置快照吗?"))return;await task(async()=>{await postJson<RollbackSettingsResult>(endpoints.settingsRollback,{snapshot_id:selectedSnapshot.value!.snapshot_id});selectedSnapshot.value=null;snapshotDiff.value=null;message.value="配置已回滚。";emit("refresh")})}
async function loadFull(){if(!props.backendConnected)return;await task(async()=>{fullBackups.value=await getJson(endpoints.backups)})}
async function createFull(){await task(async()=>{const created=await postJson<Record<string,unknown>>(endpoints.backups,{include_media:includeMedia.value});message.value=`完整备份 ${created.backup_id} 已创建`;await loadFull()})}
async function createFull(){await task(async()=>{const created=await postJson<Record<string,unknown>>(endpoints.backups,{include_media:includeMedia.value,include_prompt_records:includePromptRecords.value,include_moderation_records:includeModerationRecords.value});message.value=`完整备份 ${created.backup_id} 已创建`;await loadFull()})}
async function inspectFull(item:Record<string,unknown>){await task(async()=>{selectedBackup.value=await getJson(endpoints.backup(String(item.backup_id)))})}
async function restoreFull(){if(!selectedBackup.value||!confirm("确定恢复此完整备份吗?系统会先创建安全备份,请先停止运行中的生成任务。"))return;await task(async()=>{const result=await postJson<Record<string,unknown>>(endpoints.backupRestore(String(selectedBackup.value!.backup_id)),{confirm:true});message.value=`恢复完成,安全备份:${result.safety_backup_id}`;emit("refresh");await loadFull()})}
onMounted(loadFull)
</script>
<template><div class="page"><section class="hero"><b>↕</b><div><strong>ImageStudio 数据备份</strong><p>配置导入导出、服务器侧数据库与媒体完整备份。</p></div></section><div v-if="error||message" :class="['notice',{bad:!!error}]">{{error||message}}</div><div class="cards"><article><span>轻量备份</span><strong>脱敏配置 JSON</strong><p>适合迁移设置,不包含真实密钥。</p><button class="primary" :disabled="busy||!canManage" @click="exportConfig">导出配置</button></article><article><span>配置恢复</span><strong>{{importFileName||'选择 JSON 文件'}}</strong><label><input type="file" accept=".json,application/json" @change="selectFile"><i>选择文件</i></label><small v-if="importPreview">{{Object.keys(importPreview).length}} 个配置分区</small><button :disabled="busy||!importPreview||!canManage" @click="importConfig">确认导入</button></article></div><section class="full"><header><div><span>服务器侧完整备份</span><strong>配置、数据库与媒体</strong></div><label><input v-model="includeMedia" type="checkbox"> 包含媒体文件</label><button class="primary" :disabled="busy||!canManage||!backendConnected" @click="createFull">创建完整备份</button></header><p>SQLite 使用在线一致性快照;图片、缩略图、素材和风格文件会写入带 SHA-256 清单的 ZIP。PostgreSQL 会记录导出提示,需配合 pg_dump。</p><div class="list"><button v-for="item in fullBackups" :key="String(item.backup_id)" :class="{active:selectedBackup?.backup_id===item.backup_id}" @click="inspectFull(item)"><span><strong>{{item.backup_id}}</strong><small>{{Number(item.size_bytes||0).toLocaleString()}} bytes · {{item.file_count}} 文件</small></span><time>{{new Date(String(item.created_at)).toLocaleString('zh-CN')}}</time></button><small v-if="!fullBackups.length">暂无完整备份</small></div><div v-if="selectedBackup" class="selected"><span>校验:{{selectedBackup.valid?'通过':'未校验'}}</span><span>数据库:{{selectedBackup.database_backend}}</span><span>文件:{{selectedBackup.file_count}}</span><button class="danger" :disabled="busy||!canManage" @click="restoreFull">恢复此备份</button></div></section><section class="snapshots"><header><div><span>配置历史</span><strong>快照、差异与回滚</strong></div><small>{{snapshots.length}} 条</small></header><div class="list"><button v-for="item in snapshots" :key="item.snapshot_id" :class="{active:selectedSnapshot?.snapshot_id===item.snapshot_id}" @click="inspectSnapshot(item)"><span><strong>{{item.reason||'配置变更'}}</strong><small>{{item.actor_id||'system'}}</small></span><time>{{new Date(item.created_at).toLocaleString('zh-CN')}}</time></button><small v-if="!snapshots.length">暂无配置快照</small></div><div v-if="selectedSnapshot" class="selected"><div class="diff"><span v-if="!snapshotDiff?.changes.length">与当前配置没有差异</span><span v-for="(change,index) in snapshotDiff?.changes||[]" :key="index"><b>{{change.path}}</b><small>{{change.sensitive?'敏感字段状态变化':`${String(change.before??'—')} → ${String(change.after??'—')}`}}</small></span></div><button class="danger" :disabled="busy||!canManage" @click="rollbackSnapshot">回滚到此快照</button></div></section></div></template>
<style scoped>.page{display:grid;gap:14px}.hero,.full,.snapshots{border:1px solid var(--border);border-radius:10px;padding:15px}.hero{display:flex;align-items:center;gap:12px;background:linear-gradient(105deg,var(--primary-soft),var(--panel-muted))}.hero>b{display:grid;place-items:center;width:46px;height:46px;border-radius:10px;color:#fff;background:var(--primary)}p{margin:0;color:var(--text-soft);line-height:1.5}.cards{display:grid;grid-template-columns:1fr 1fr;gap:12px}.cards article{display:grid;gap:9px;border:1px solid var(--border);border-radius:9px;padding:14px;background:var(--panel-muted)}.cards span,.full header span,.snapshots header span{color:var(--text-soft);font-size:11px;font-weight:800}button,.cards label i{min-height:36px;border:1px solid var(--border);border-radius:7px;padding:0 10px;color:var(--text);background:var(--panel-muted);font:inherit;cursor:pointer}.primary{color:#fff;background:var(--primary)}button:disabled{opacity:.5}.cards label input{position:absolute;opacity:0}.cards label i{display:grid;place-items:center;border-style:dashed;color:var(--primary);font-style:normal}.full,.snapshots{display:grid;gap:11px}.full header,.snapshots header{display:flex;align-items:center;gap:10px}.full header>div,.snapshots header>div{display:grid;gap:3px;margin-right:auto}.full>p{font-size:12px}.list{display:grid;grid-template-columns:1fr 1fr;gap:7px}.list button{display:flex;justify-content:space-between;height:auto;padding:9px;text-align:left}.list button span{display:grid;gap:3px}.list small,.list time{color:var(--text-soft);font-size:10px}.list button.active{border-color:var(--primary);background:var(--primary-soft)}.selected{display:flex;align-items:center;gap:10px;border-top:1px solid var(--border);padding-top:10px}.selected .danger{margin-left:auto;color:var(--danger)}.diff{display:grid;flex:1;gap:5px;max-height:200px;overflow:auto}.diff>span{display:grid;border-radius:5px;padding:6px;background:var(--panel-muted)}.notice{padding:10px;color:#26865a;background:var(--primary-soft)}.notice.bad{color:var(--danger);background:var(--danger-soft)}@media(max-width:760px){.cards,.list{grid-template-columns:1fr}.full header,.selected{align-items:stretch;flex-direction:column}.selected .danger{margin-left:0}}</style>
<template>
<div class="page">
<section class="hero"><b>↕</b><div><strong>ImageStudio 数据备份</strong><p>配置导入导出、服务器侧数据库与媒体完整备份。</p></div></section>
<div v-if="error||message" :class="['notice',{bad:!!error}]">{{error||message}}</div>
<div class="cards">
<article><span>轻量备份</span><strong>脱敏配置 JSON</strong><p>适合迁移设置,不包含真实密钥。</p><button class="primary" :disabled="busy||!canManage" @click="exportConfig">导出配置</button></article>
<article><span>配置恢复</span><strong>{{importFileName||'选择 JSON 文件'}}</strong><label class="file"><input type="file" accept=".json,application/json" @change="selectFile"><i>选择文件</i></label><small v-if="importPreview">{{Object.keys(importPreview).length}} 个配置分区</small><button :disabled="busy||!importPreview||!canManage" @click="importConfig">确认导入</button></article>
</div>
<section class="full">
<header><div><span>服务器侧完整备份</span><strong>配置、数据库与媒体</strong></div><button class="primary" :disabled="busy||!canManage||!backendConnected" @click="createFull">创建完整备份</button></header>
<div class="backup-options">
<label><input v-model="includeMedia" type="checkbox">包含媒体文件</label>
<label><input v-model="includePromptRecords" type="checkbox">包含原始与转译提示词</label>
<label><input v-model="includeModerationRecords" type="checkbox">包含审核与路由记录</label>
</div>
<p>取消提示词或审核记录后,只清理备份副本,不修改运行数据库。素材 Schema、胶囊版本和文件校验清单始终保留。</p>
<div class="list"><button v-for="item in fullBackups" :key="String(item.backup_id)" :class="{active:selectedBackup?.backup_id===item.backup_id}" @click="inspectFull(item)"><span><strong>{{item.backup_id}}</strong><small>{{Number(item.size_bytes||0).toLocaleString()}} bytes · {{item.file_count}} 文件</small></span><time>{{new Date(String(item.created_at)).toLocaleString('zh-CN')}}</time></button><small v-if="!fullBackups.length">暂无完整备份</small></div>
<div v-if="selectedBackup" class="selected"><span>校验:{{selectedBackup.valid?'通过':'未校验'}}</span><span>数据库:{{selectedBackup.database_backend}}</span><span>文件:{{selectedBackup.file_count}}</span><button class="danger" :disabled="busy||!canManage" @click="restoreFull">恢复此备份</button></div>
</section>
<section class="snapshots">
<header><div><span>配置历史</span><strong>快照、差异与回滚</strong></div><small>{{snapshots.length}} 条</small></header>
<div class="list"><button v-for="item in snapshots" :key="item.snapshot_id" :class="{active:selectedSnapshot?.snapshot_id===item.snapshot_id}" @click="inspectSnapshot(item)"><span><strong>{{item.reason||'配置变更'}}</strong><small>{{item.actor_id||'system'}}</small></span><time>{{new Date(item.created_at).toLocaleString('zh-CN')}}</time></button><small v-if="!snapshots.length">暂无配置快照</small></div>
<div v-if="selectedSnapshot" class="selected"><div class="diff"><span v-if="!snapshotDiff?.changes.length">与当前配置没有差异</span><span v-for="(change,index) in snapshotDiff?.changes||[]" :key="index"><b>{{change.path}}</b><small>{{change.sensitive?'敏感字段状态变化':`${String(change.before??'—')} → ${String(change.after??'—')}`}}</small></span></div><button class="danger" :disabled="busy||!canManage" @click="rollbackSnapshot">回滚到此快照</button></div>
</section>
</div>
</template>
<style scoped>
.page{display:grid;gap:14px}.hero,.full,.snapshots{border:1px solid var(--border);border-radius:10px;padding:15px}.hero{display:flex;align-items:center;gap:12px;background:linear-gradient(105deg,var(--primary-soft),var(--panel-muted))}.hero>b{display:grid;place-items:center;width:46px;height:46px;border-radius:10px;color:#fff;background:var(--primary)}p{margin:0;color:var(--text-soft);line-height:1.5}.cards{display:grid;grid-template-columns:1fr 1fr;gap:12px}.cards article{display:grid;gap:9px;border:1px solid var(--border);border-radius:9px;padding:14px;background:var(--panel-muted)}.cards span,.full header span,.snapshots header span{color:var(--text-soft);font-size:11px;font-weight:800}button,.file i{min-height:36px;border:1px solid var(--border);border-radius:7px;padding:0 10px;color:var(--text);background:var(--panel-muted);font:inherit;cursor:pointer}.primary{color:#fff;background:var(--primary)}button:disabled{opacity:.5}.file input{position:absolute;opacity:0}.file i{display:grid;place-items:center;border-style:dashed;color:var(--primary);font-style:normal}.full,.snapshots{display:grid;gap:11px}.full header,.snapshots header{display:flex;align-items:center;gap:10px}.full header>div,.snapshots header>div{display:grid;gap:3px;margin-right:auto}.full>p{font-size:12px}.backup-options{display:flex;flex-wrap:wrap;gap:8px;border:1px solid var(--border);border-radius:8px;padding:10px;background:var(--panel-muted)}.backup-options label{display:flex;align-items:center;gap:6px;border-radius:6px;padding:6px 8px;background:var(--panel);font-size:12px}.list{display:grid;grid-template-columns:1fr 1fr;gap:7px}.list button{display:flex;justify-content:space-between;height:auto;padding:9px;text-align:left}.list button span{display:grid;gap:3px}.list small,.list time{color:var(--text-soft);font-size:10px}.list button.active{border-color:var(--primary);background:var(--primary-soft)}.selected{display:flex;align-items:center;gap:10px;border-top:1px solid var(--border);padding-top:10px}.selected .danger{margin-left:auto;color:var(--danger)}.diff{display:grid;flex:1;gap:5px;max-height:200px;overflow:auto}.diff>span{display:grid;border-radius:5px;padding:6px;background:var(--panel-muted)}.notice{padding:10px;color:#26865a;background:var(--primary-soft)}.notice.bad{color:var(--danger);background:var(--danger-soft)}@media(max-width:760px){.cards,.list{grid-template-columns:1fr}.full header,.selected{align-items:stretch;flex-direction:column}.selected .danger{margin-left:0}}
</style>

查看文件

@ -12,6 +12,8 @@ function update(key: string, value: string) {
function updateValue(key: string, value: number | boolean) { emit("update:modelValue", { ...props.modelValue, [key]: value }) }
const groupCount = computed(() => ids("group_allowlist").length)
const userCount = computed(() => ids("user_allowlist").length)
const adultGroupCount = computed(() => ids("adult_group_allowlist").length)
const adultUserCount = computed(() => ids("adult_user_allowlist").length)
</script>
<template>
@ -25,6 +27,11 @@ const userCount = computed(() => ids("user_allowlist").length)
<label><span>群聊白名单 <em>{{ groupCount }} 项</em></span><textarea :value="text('group_allowlist')" :disabled="disabled" rows="10" placeholder="每行一个群聊 ID&#10;例如:123456789" @input="update('group_allowlist', ($event.target as HTMLTextAreaElement).value)"></textarea><small>用于判断命令所在群聊是否获得授权。</small></label>
<label><span>用户白名单 <em>{{ userCount }} 项</em></span><textarea :value="text('user_allowlist')" :disabled="disabled" rows="10" placeholder="每行一个用户 ID&#10;例如:987654321" @input="update('user_allowlist', ($event.target as HTMLTextAreaElement).value)"></textarea><small>使用 AstrBot 事件返回的平台用户 ID,不使用昵称。</small></label>
</div>
<div class="adult-intro"><div><span>成人内容独立授权</span><strong>必须同时通过内容审核与成人白名单</strong></div><p>这些名单不会放宽恐怖主义、高危暴力、现实伤害或其他禁止内容。群聊内要求成人群聊与成人用户同时命中;私聊要求成人用户命中。</p></div>
<div class="lists adult-lists">
<label><span>成人内容群聊白名单 <em>{{ adultGroupCount }} 项</em></span><textarea :value="text('adult_group_allowlist')" :disabled="disabled" rows="6" placeholder="每行一个允许成人路由的群聊 ID" @input="update('adult_group_allowlist', ($event.target as HTMLTextAreaElement).value)"></textarea><small>仅影响通过审核的 adult_allowed 内容。</small></label>
<label><span>成人内容用户白名单 <em>{{ adultUserCount }} 项</em></span><textarea :value="text('adult_user_allowlist')" :disabled="disabled" rows="6" placeholder="每行一个允许成人路由的用户 ID" @input="update('adult_user_allowlist', ($event.target as HTMLTextAreaElement).value)"></textarea><small>不会继承普通用户白名单,必须单独授权。</small></label>
</div>
<div class="limits">
<label><span>用户并发上限</span><input type="number" min="1" :value="Number(modelValue.user_concurrency_limit || 2)" :disabled="disabled" @input="updateValue('user_concurrency_limit', Number(($event.target as HTMLInputElement).value))"></label>
<label><span>群聊并发上限</span><input type="number" min="1" :value="Number(modelValue.group_concurrency_limit || 5)" :disabled="disabled" @input="updateValue('group_concurrency_limit', Number(($event.target as HTMLInputElement).value))"></label>
@ -37,5 +44,5 @@ const userCount = computed(() => ids("user_allowlist").length)
</template>
<style scoped>
.chat-access{display:grid;gap:14px}.intro{display:grid;gap:5px;border:1px solid var(--border);border-radius:10px;padding:15px;background:linear-gradient(105deg,var(--primary-soft),var(--panel-muted))}.intro span{color:var(--text-soft);font-size:11px;font-weight:800}.intro p,.rules p{margin:0;color:var(--text-soft);line-height:1.5}.rules,.lists{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}.rules article{display:grid;gap:6px;border:1px solid var(--border);border-radius:10px;padding:14px;background:var(--panel-muted)}.rules b{color:var(--text-soft);font-size:11px}.rules strong{color:var(--primary)}.lists label{display:grid;gap:7px;border:1px solid var(--border);border-radius:10px;padding:14px;background:var(--panel-muted)}.lists label>span{display:flex;justify-content:space-between;font-weight:750}.lists em{border-radius:5px;padding:2px 6px;color:var(--primary);background:var(--primary-soft);font-size:11px;font-style:normal}.lists textarea{width:100%;box-sizing:border-box;border:1px solid var(--border);border-radius:7px;padding:10px;color:var(--text);background:var(--panel);font:inherit;line-height:1.55;resize:vertical}.lists small{color:var(--text-soft)}.limits{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:10px;border:1px solid var(--border);border-radius:10px;padding:14px;background:var(--panel-muted)}.limits label{display:grid;gap:6px}.limits input[type=number]{min-height:40px;border:1px solid var(--border);border-radius:7px;padding:0 10px;color:var(--text);background:var(--panel);font:inherit}.limits .check{display:flex;align-items:center;gap:8px}@media(max-width:760px){.rules,.lists,.limits{grid-template-columns:1fr}}
.chat-access{display:grid;gap:14px}.intro{display:grid;gap:5px;border:1px solid var(--border);border-radius:10px;padding:15px;background:linear-gradient(105deg,var(--primary-soft),var(--panel-muted))}.intro span{color:var(--text-soft);font-size:11px;font-weight:800}.intro p,.rules p{margin:0;color:var(--text-soft);line-height:1.5}.rules,.lists{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}.rules article{display:grid;gap:6px;border:1px solid var(--border);border-radius:10px;padding:14px;background:var(--panel-muted)}.rules b{color:var(--text-soft);font-size:11px}.rules strong{color:var(--primary)}.lists label{display:grid;gap:7px;border:1px solid var(--border);border-radius:10px;padding:14px;background:var(--panel-muted)}.lists label>span{display:flex;justify-content:space-between;font-weight:750}.lists em{border-radius:5px;padding:2px 6px;color:var(--primary);background:var(--primary-soft);font-size:11px;font-style:normal}.lists textarea{width:100%;box-sizing:border-box;border:1px solid var(--border);border-radius:7px;padding:10px;color:var(--text);background:var(--panel);font:inherit;line-height:1.55;resize:vertical}.lists small{color:var(--text-soft)}.adult-intro{display:flex;align-items:center;justify-content:space-between;gap:18px;border-left:3px solid #d39b35;border-radius:7px;padding:12px;background:color-mix(in srgb,#e1a53a 10%,var(--panel))}.adult-intro>div{display:grid;gap:3px}.adult-intro span{color:#9a6818;font-size:11px;font-weight:800}.adult-intro p{max-width:58%;margin:0;color:var(--text-soft);font-size:12px;line-height:1.5}.adult-lists label{border-color:color-mix(in srgb,#e1a53a 35%,var(--border))}.limits{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:10px;border:1px solid var(--border);border-radius:10px;padding:14px;background:var(--panel-muted)}.limits label{display:grid;gap:6px}.limits input[type=number]{min-height:40px;border:1px solid var(--border);border-radius:7px;padding:0 10px;color:var(--text);background:var(--panel);font:inherit}.limits .check{display:flex;align-items:center;gap:8px}@media(max-width:760px){.rules,.lists,.limits{grid-template-columns:1fr}.adult-intro{align-items:flex-start;flex-direction:column}.adult-intro p{max-width:none}}
</style>

查看文件

@ -0,0 +1,40 @@
<script setup lang="ts">
import { computed, ref } from "vue"
import { postJson } from "../../../../shared/api/client"
import { endpoints } from "../../../../shared/api/endpoints"
type AdapterOption = { name:string; route:string; model:string; enabled:boolean }
const props = defineProps<{modelValue:Record<string,unknown>;adapters:AdapterOption[];disabled:boolean}>()
const emit = defineEmits<{"update:modelValue":[value:Record<string,unknown>]}>()
const value = computed(()=>clone(props.modelValue))
const routes = computed(()=>props.adapters.filter(item=>item.enabled&&item.route).map(item=>({label:`${item.name}${item.model?` · ${item.model}`:""}`,value:item.route})))
const previewPrompt=ref(""),previewSelection=ref("translated"),manualPrompt=ref(""),previewBusy=ref(false),previewError=ref(""),previewResult=ref<Record<string,unknown>|null>(null)
function clone<T>(input:T):T{return JSON.parse(JSON.stringify(input??{})) as T}
function get(path:string,fallback:unknown=""){let current:unknown=value.value;for(const key of path.split(".")){if(!current||typeof current!=="object"||Array.isArray(current))return fallback;current=(current as Record<string,unknown>)[key]}return current??fallback}
function set(path:string,nextValue:unknown){const next=clone(value.value);const keys=path.split(".");let current=next;for(const key of keys.slice(0,-1)){if(!current[key]||typeof current[key]!=="object"||Array.isArray(current[key]))current[key]={};current=current[key] as Record<string,unknown>}current[keys.at(-1)!]=nextValue;emit("update:modelValue",next)}
function checked(path:string){return get(path,false)===true}
const entrypoints=[{key:"web",label:"Web"},{key:"qq",label:"QQ"},{key:"telegram",label:"Telegram"},{key:"discord",label:"Discord"},{key:"api",label:"API"}]
async function runPreview(){if(!previewPrompt.value.trim())return;previewBusy.value=true;previewError.value="";try{previewResult.value=await postJson(endpoints.promptGovernancePreview,{prompt:previewPrompt.value,entrypoint:"web",translation_consent:true,selection:previewSelection.value,manual_prompt:manualPrompt.value,model_route:String(get('routing.safe_route')||'image_low'),content_permissions:{adult_user_allowed:true,adult_group_allowed:true,quota_allowed:true}})}catch(e){previewError.value=e instanceof Error?e.message:String(e)}finally{previewBusy.value=false}}
</script>
<template>
<section class="governance">
<header class="intro"><div><span>提示词处理链</span><strong>转译、审核与模型分流</strong><p>原始需求始终保留。转译只降低歧义并生成适配模型的英文提示词,不隐藏禁止语义,也不绕过平台安全策略。</p></div><div class="flow"><b>原文</b><i>→</i><b>转译</b><i>→</i><b>审核</b><i>→</i><b>路由</b></div></header>
<article class="preview-card"><header><div><span>链路预览</span><strong>发送前检查最终提示词与路由</strong></div><button :disabled="previewBusy||!previewPrompt.trim()" @click="runPreview">{{previewBusy?'处理中…':'运行预览'}}</button></header><textarea v-model="previewPrompt" rows="3" placeholder="输入中文或英文生图需求"></textarea><div class="preview-choice"><label><input v-model="previewSelection" type="radio" value="original">直接使用原文</label><label><input v-model="previewSelection" type="radio" value="translated">使用转译</label><label><input v-model="previewSelection" type="radio" value="manual">手动编辑后使用</label></div><textarea v-if="previewSelection==='manual'" v-model="manualPrompt" rows="2" placeholder="输入手动调整后的提示词"></textarea><p v-if="previewError" class="preview-error">{{previewError}}</p><div v-if="previewResult" class="preview-result"><span><b>转译</b>{{String((previewResult.translation as any)?.status||'—')}}</span><span><b>审核</b>{{String((previewResult.moderation as any)?.level||'—')}}</span><span><b>路由</b>{{String((previewResult.route_decision as any)?.selected_route||(previewResult.route_decision as any)?.reason||'—')}}</span><p>{{String((previewResult.normalization as any)?.normalized_text||previewResult.selected_prompt||'')}}</p><details><summary>查看完整决策摘要</summary><pre>{{JSON.stringify(previewResult,null,2)}}</pre></details></div></article>
<article class="card"><header><div><span>01 · Prompt Translation</span><strong>LLM 提示词转译</strong><p>用户明确允许后,将中文需求结构化为英文生图提示词;失败时安全回退原文。</p></div><label class="switch"><input type="checkbox" :checked="checked('translation.enabled')" :disabled="disabled" @change="set('translation.enabled',($event.target as HTMLInputElement).checked)"><span></span></label></header><div class="grid"><label><span>转译模型路由</span><select :value="String(get('translation.model_route'))" :disabled="disabled" @change="set('translation.model_route',($event.target as HTMLSelectElement).value)"><option value="">未配置(使用原文)</option><option v-for="route in routes" :key="route.value" :value="route.value">{{route.label}}</option></select><small>建议选择指令遵循稳定、支持结构化 JSON 的文本或视觉模型。</small></label><label><span>模板版本</span><input :value="String(get('translation.template_version','1.0'))" :disabled="disabled" @input="set('translation.template_version',($event.target as HTMLInputElement).value)"><small>便于追踪提示词差异和回滚。</small></label></div><div class="entries"><span>允许自动转译的入口</span><label v-for="item in entrypoints" :key="item.key"><input type="checkbox" :checked="checked(`translation.entrypoints.${item.key}`)" :disabled="disabled" @change="set(`translation.entrypoints.${item.key}`,($event.target as HTMLInputElement).checked)">{{item.label}}</label></div></article>
<article class="card"><header><div><span>02 · Moderation</span><strong>生成前内容审核</strong><p>规则审核始终执行;可增加一个 LLM 复核模型,冲突时采用更严格结果。</p></div><label class="switch"><input type="checkbox" :checked="checked('moderation.llm_review_enabled')" :disabled="disabled" @change="set('moderation.llm_review_enabled',($event.target as HTMLInputElement).checked)"><span></span></label></header><div class="grid"><label><span>审核模型路由</span><select :value="String(get('moderation.model_route'))" :disabled="disabled" @change="set('moderation.model_route',($event.target as HTMLSelectElement).value)"><option value="">仅使用本地规则</option><option v-for="route in routes" :key="route.value" :value="route.value">{{route.label}}</option></select><small>建议使用对中文语义、年龄和风险分类理解稳定的模型。</small></label><label><span>审核服务失败策略</span><select :value="String(get('moderation.failure_policy','fail_closed'))" :disabled="disabled" @change="set('moderation.failure_policy',($event.target as HTMLSelectElement).value)"><option value="fail_closed">保守拒绝</option><option value="confirm">要求人工确认</option></select><small>审核不可用时不会自动进入宽松模型。</small></label></div></article>
<article class="card routing"><header><div><span>03 · Dynamic Routing</span><strong>普通 / NSFW 动态模型路由</strong><p>普通内容走安全模型;仅通过审核且权限满足的成人内容可自动进入指定 NSFW 模型。</p></div><label class="switch"><input type="checkbox" :checked="checked('routing.adult_auto_route_enabled')" :disabled="disabled" @change="set('routing.adult_auto_route_enabled',($event.target as HTMLInputElement).checked)"><span></span></label></header><div class="route-pair"><label><span>普通生图路由</span><select :value="String(get('routing.safe_route'))" :disabled="disabled" @change="set('routing.safe_route',($event.target as HTMLSelectElement).value)"><option value="">跟随当前默认路由</option><option v-for="route in routes" :key="route.value" :value="route.value">{{route.label}}</option></select></label><div class="arrow">→</div><label><span>NSFW 生图路由</span><select :value="String(get('routing.nsfw_route'))" :disabled="disabled" @change="set('routing.nsfw_route',($event.target as HTMLSelectElement).value)"><option value="">未配置</option><option v-for="route in routes" :key="route.value" :value="route.value">{{route.label}}</option></select></label></div><div class="entries"><span>允许成人内容路由的入口</span><label v-for="item in entrypoints" :key="item.key"><input type="checkbox" :checked="checked(`routing.entrypoints.${item.key}`)" :disabled="disabled" @change="set(`routing.entrypoints.${item.key}`,($event.target as HTMLInputElement).checked)">{{item.label}}</label></div><div class="policy"><b>固定安全策略</b><span>允许的成人内容:审核 + 管理员开关 + 入口权限 + 用户/群聊权限全部通过后自动分流。</span><span>恐怖主义、高危暴力、现实伤害威胁和极端血腥:始终禁止并警告,不进入任何生图模型。</span><span>普通模型仅在明确内容安全拒绝、二次审核为 adult_allowed 时单次回退 NSFW;网络、额度、鉴权和参数错误不会触发。</span></div></article>
<article class="card"><header><div><span>04 · Output Review</span><strong>生成后图片审核</strong><p>在聊天返回和普通图库展示前检查结果;异常结果进入受限图库并等待复核。</p></div><label class="switch"><input type="checkbox" :checked="checked('image_moderation.enabled')" :disabled="disabled" @change="set('image_moderation.enabled',($event.target as HTMLInputElement).checked)"><span></span></label></header><div class="grid"><label><span>图片审核模型路由</span><select :value="String(get('image_moderation.model_route'))" :disabled="disabled" @change="set('image_moderation.model_route',($event.target as HTMLSelectElement).value)"><option value="">未配置</option><option v-for="route in routes" :key="route.value" :value="route.value">{{route.label}}</option></select><small>需要支持图片理解和结构化风险输出。</small></label><label><span>敏感日志脱敏</span><select :value="String(get('retention.redact_sensitive_logs',true))" :disabled="disabled" @change="set('retention.redact_sensitive_logs',($event.target as HTMLSelectElement).value==='true')"><option value="true">开启</option><option value="false">关闭</option></select></label></div><div class="retention"><label><span>原始提示词</span><input type="number" min="0" :value="Number(get('retention.raw_prompt_days',30))" :disabled="disabled" @input="set('retention.raw_prompt_days',Number(($event.target as HTMLInputElement).value))"><small>天</small></label><label><span>转译提示词</span><input type="number" min="0" :value="Number(get('retention.translated_prompt_days',90))" :disabled="disabled" @input="set('retention.translated_prompt_days',Number(($event.target as HTMLInputElement).value))"><small>天</small></label><label><span>审核记录</span><input type="number" min="0" :value="Number(get('retention.moderation_record_days',180))" :disabled="disabled" @input="set('retention.moderation_record_days',Number(($event.target as HTMLInputElement).value))"><small>天</small></label></div></article>
</section>
</template>
<style scoped>
.governance{display:grid;gap:13px}.intro,.card{border:1px solid var(--border);border-radius:10px;background:var(--panel-muted)}.intro{display:flex;align-items:center;justify-content:space-between;gap:18px;padding:16px;background:linear-gradient(105deg,var(--primary-soft),var(--panel-muted))}.intro>div:first-child,.card header>div{display:grid;gap:4px}.intro span,.card header span,.entries>span{color:var(--text-soft);font-size:11px;font-weight:800}.intro p,.card p,.grid small{margin:0;color:var(--text-soft);font-size:12px;line-height:1.5}.flow{display:flex;align-items:center;gap:6px;white-space:nowrap}.flow b{border-radius:6px;padding:6px 8px;color:var(--primary);background:var(--panel)}.flow i{color:var(--text-soft);font-style:normal}.card{display:grid;gap:14px;padding:15px}.card>header{display:flex;align-items:flex-start;justify-content:space-between;gap:16px}.grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}.grid label,.route-pair label{display:grid;gap:6px}.grid label>span,.route-pair label>span,.retention span{font-size:12px;font-weight:750}select,input{width:100%;min-height:40px;box-sizing:border-box;border:1px solid var(--border);border-radius:7px;padding:0 10px;color:var(--text);background:var(--panel)}.switch input{position:absolute;opacity:0;pointer-events:none}.switch span{position:relative;display:block;width:44px;height:25px;border-radius:99px;background:var(--border);cursor:pointer}.switch span:after{position:absolute;top:3px;left:3px;width:19px;height:19px;border-radius:50%;background:#fff;content:"";transition:.18s}.switch input:checked+span{background:var(--primary)}.switch input:checked+span:after{transform:translateX(19px)}.entries{display:flex;align-items:center;flex-wrap:wrap;gap:10px;border-top:1px solid var(--border);padding-top:12px}.entries label{display:flex;align-items:center;gap:5px;font-size:12px}.entries input{width:auto;min-height:auto}.route-pair{display:grid;grid-template-columns:1fr 36px 1fr;align-items:end;gap:8px}.arrow{display:grid;place-items:center;min-height:40px;color:var(--primary);font-size:20px}.routing{border-color:color-mix(in srgb,var(--primary) 35%,var(--border))}.policy{display:grid;gap:6px;border-left:3px solid #d39b35;border-radius:6px;padding:11px 12px;background:color-mix(in srgb,#e1a53a 10%,var(--panel))}.policy b{color:#9a6818}.policy span{color:var(--text-soft);font-size:12px;line-height:1.45}.retention{display:grid;grid-template-columns:repeat(3,1fr);gap:10px}.retention label{display:grid;grid-template-columns:1fr 72px auto;align-items:center;gap:7px}.retention small{color:var(--text-soft)}@media(max-width:800px){.intro{align-items:flex-start;flex-direction:column}.flow{flex-wrap:wrap}.grid,.route-pair,.retention{grid-template-columns:1fr}.arrow{transform:rotate(90deg)}}
.preview-card{display:grid;gap:10px;border:1px solid var(--border);border-radius:10px;padding:15px;background:var(--panel-muted)}.preview-card>header{display:flex;align-items:center;justify-content:space-between;gap:12px}.preview-card>header>div{display:grid;gap:3px}.preview-card>header span{color:var(--text-soft);font-size:11px;font-weight:800}.preview-card button{min-height:36px;border:1px solid var(--primary);border-radius:7px;padding:0 11px;color:#fff;background:var(--primary);cursor:pointer}.preview-card button:disabled{opacity:.5}.preview-card textarea{width:100%;box-sizing:border-box;border:1px solid var(--border);border-radius:7px;padding:9px;color:var(--text);background:var(--panel);font:inherit;resize:vertical}.preview-choice{display:flex;flex-wrap:wrap;gap:10px}.preview-choice label{display:flex;align-items:center;gap:5px;font-size:12px}.preview-result{display:grid;grid-template-columns:repeat(3,1fr);gap:7px;border-top:1px solid var(--border);padding-top:10px}.preview-result>span{display:grid;gap:3px;border-radius:6px;padding:8px;background:var(--panel)}.preview-result>span b{color:var(--text-soft);font-size:10px}.preview-result>p,.preview-result>details{grid-column:1/-1}.preview-result>p{margin:0;border-radius:6px;padding:9px;background:var(--panel);font-size:12px;line-height:1.5}.preview-result pre{max-height:260px;overflow:auto;border-radius:6px;padding:8px;background:var(--panel);font-size:10px;white-space:pre-wrap}.preview-error{color:var(--danger)!important}
</style>

查看文件

@ -12,6 +12,7 @@ import SystemManagementPanel from "./SystemManagementPanel.vue"
import ModelAssignmentsPanel from "./ModelAssignmentsPanel.vue"
import RecognitionPromptsPanel from "./RecognitionPromptsPanel.vue"
import ChatAccessPanel from "./ChatAccessPanel.vue"
import PromptGovernancePanel from "./PromptGovernancePanel.vue"
type ConfigValue = string | number | boolean | string[] | null
type Adapter = { id:string; name:string; provider_type:string; base_url:string; image_endpoint:string; model_id:string; route_name:string; api_key_env_var:string; timeout_seconds:number; enabled:boolean }
@ -36,7 +37,7 @@ const previewSchema: SettingsSchema = {schema_version:"3.0-preview",sections:[
{key:"backup",title:"数据备份",fields:[]},
]}
const previewConfig = computed<Record<string,unknown>>(()=>({generation:{default_model:"image_default",provider:{provider_id:"openai-compatible",base_url:"",image_endpoint:"/v1/images/generations",model_id:"",route_name:"image_default",api_key_env_var:"IMAGE_API_KEY",timeout_seconds:180}},model_assignments:{material_recognition:"material_vlm",quick_generation:"image_default",portrait_generation:"image_default",halfbody_generation:"image_default",fullbody_generation:"image_default",sheet_generation:"image_default",hires_fix:"image_default"},recognition_prompts:{default_instruction:"请先判断图片中素材的准确分类,再尽可能完整提取所有可见事实,包括颜色、材质、纹理、结构、轮廓、图案、裁剪、装饰、配件、视角和光照。不要把推测写成事实。根据结果生成可直接用于生图的详细正向提示词和负向提示词。仅返回 JSON:prompt、negative_prompt、tags、confidence、description。",category_requirements:[]},chat_access:{group_allowlist:[],user_allowlist:[]},features:{quick_profile:true,workspace:true,material_library:true,wardrobe:true,api_discovery:true,private_companion_integration:false},storage:{images_path:"data/images",thumbnails_path:"data/thumbnails",materials_path:"data/materials",styles_path:"data/styles",archives_path:"data/archives",temp_path:"data/temp"},database:{backend:"auto",sqlite:{path:"data/imagestudio.db"},postgresql:{enabled:false,host:"127.0.0.1",port:5432,database:"imagestudio",user:"",password:""}}}))
const effectiveSchema=computed(()=>{const schema=clone(props.schema??previewSchema);for(const section of [{key:"review",title:"审查策略",fields:[]},{key:"capabilities",title:"能力档案",fields:[]},{key:"integration",title:"私伴集成",fields:[]},{key:"cost_guard",title:"成本保护",fields:[]},{key:"diagnostics",title:"系统诊断",fields:[]},{key:"backup",title:"数据备份",fields:[]}])if(!schema.sections.some(item=>item.key===section.key))schema.sections.push(section);return schema})
const effectiveSchema=computed(()=>{const schema=clone(props.schema??previewSchema);for(const section of [{key:"prompt_governance",title:"提示词与内容分流",fields:[]},{key:"review",title:"审查策略",fields:[]},{key:"capabilities",title:"能力档案",fields:[]},{key:"integration",title:"私伴集成",fields:[]},{key:"cost_guard",title:"成本保护",fields:[]},{key:"diagnostics",title:"系统诊断",fields:[]},{key:"backup",title:"数据备份",fields:[]}])if(!schema.sections.some(item=>item.key===section.key))schema.sections.push(section);return schema})
const baseline=computed(()=>props.current?.config??previewConfig.value)
const draft=ref<Record<string,unknown>>({})
const activeSectionKey=ref("generation")
@ -89,13 +90,14 @@ function updateField(path:string,value:ConfigValue){const next=clone(draft.value
function updateModelAssignments(value:Record<string,unknown>){draft.value={...clone(draft.value),model_assignments:value}}
function updateRecognitionPrompts(value:Record<string,unknown>){draft.value={...clone(draft.value),recognition_prompts:value}}
function updateChatAccess(value:Record<string,unknown>){draft.value={...clone(draft.value),chat_access:value}}
function updatePromptGovernance(value:Record<string,unknown>){draft.value={...clone(draft.value),prompt_governance:value}}
function inputValue(e:Event,type:string):ConfigValue{const t=e.target as HTMLInputElement|HTMLSelectElement;if(type==="bool"||type==="boolean")return t.value==="true";if(type==="number")return t.value===""?null:Number(t.value);return t.value}
</script>
<template><section class="settings-page">
<header class="hero"><div><span>系统设置</span><h2>插件与生成服务</h2><p>集中管理 ImageStudio 的生成适配器、运行参数与功能配置。</p></div><div class="actions"><button @click="emit('refresh')">刷新配置</button><button :disabled="busy||!backendConnected||!canManage" @click="emit('reload')">重载配置</button></div></header>
<section v-if="error||message" :class="['notice',{error:!!error}]">{{error||message}}</section>
<section class="workspace"><aside class="nav"><header><span>设置导航</span><strong>{{effectiveSchema.sections.length}}</strong></header><button v-for="s in effectiveSchema.sections" :key="s.key" :class="{active:activeSection?.key===s.key}" @click="activeSectionKey=s.key"><span>{{s.title}}</span><small>{{s.key==='generation'?`${adapters.length} 个适配器`:s.key==='model_assignments'?'12 个功能节点':s.key==='recognition_prompts'?'分类识别要求':s.key==='chat_access'?'群聊 / 用户':s.key==='backup'?'导入 / 导出':s.key==='review'?'规则管理':s.key==='capabilities'?'模型档案':s.key==='integration'?'凭据管理':s.key==='cost_guard'?'预算预检':s.key==='diagnostics'?'运行检查':`${s.fields.length} 项`}}</small></button></aside>
<section class="workspace"><aside class="nav"><header><span>设置导航</span><strong>{{effectiveSchema.sections.length}}</strong></header><button v-for="s in effectiveSchema.sections" :key="s.key" :class="{active:activeSection?.key===s.key}" @click="activeSectionKey=s.key"><span>{{s.title}}</span><small>{{s.key==='generation'?`${adapters.length} 个适配器`:s.key==='model_assignments'?'12 个功能节点':s.key==='recognition_prompts'?'分类识别要求':s.key==='prompt_governance'?'转译 / 审核 / 路由':s.key==='chat_access'?'群聊 / 用户':s.key==='backup'?'导入 / 导出':s.key==='review'?'规则管理':s.key==='capabilities'?'模型档案':s.key==='integration'?'凭据管理':s.key==='cost_guard'?'预算预检':s.key==='diagnostics'?'运行检查':`${s.fields.length} 项`}}</small></button></aside>
<main class="editor">
<template v-if="activeSection?.key==='generation'"><header class="section-head"><div><span>生成服务</span><h3>API 适配器</h3><p>每个服务独立配置,展开卡片后填写 API 信息。首张卡片作为当前默认生成路由。</p></div></header>
<div class="adapter-list"><article v-for="(a,index) in adapters" :key="a.id" class="adapter-card" :class="{connected:a.enabled&&!!a.base_url,disabled:!a.enabled}"><button class="adapter-summary" @click="expandedAdapter=a.id"><span class="adapter-icon">{{a.name.slice(0,1).toUpperCase()}}</span><span class="adapter-title"><strong>{{a.name}}</strong><small>{{a.enabled?(a.base_url?'链接已配置':'等待配置'):'已停用'}}</small></span><em v-if="index===0">默认</em><span class="corner" aria-hidden="true"></span></button></article></div>
@ -117,6 +119,7 @@ function inputValue(e:Event,type:string):ConfigValue{const t=e.target as HTMLInp
<SystemManagementPanel v-else-if="activeSection?.key==='diagnostics'" mode="diagnostics" :backend-connected="backendConnected" :can-manage="canManage" />
<ModelAssignmentsPanel v-else-if="activeSection?.key==='model_assignments'" :model-value="modelAssignments" :adapters="modelAdapterOptions" :vision-route="visionRouteOption" :disabled="backendConnected&&!canManage" @update:model-value="updateModelAssignments" />
<RecognitionPromptsPanel v-else-if="activeSection?.key==='recognition_prompts'" :model-value="obj(draft.recognition_prompts)" :disabled="backendConnected&&!canManage" @update:model-value="updateRecognitionPrompts" />
<PromptGovernancePanel v-else-if="activeSection?.key==='prompt_governance'" :model-value="obj(draft.prompt_governance)" :adapters="modelAdapterOptions" :disabled="backendConnected&&!canManage" @update:model-value="updatePromptGovernance" />
<ChatAccessPanel v-else-if="activeSection?.key==='chat_access'" :model-value="obj(draft.chat_access)" :disabled="backendConnected&&!canManage" @update:model-value="updateChatAccess" />
<div v-else-if="activeSection?.key==='features'" class="feature-grid"><article v-for="f in activeSection.fields" :key="f.key" class="feature-card" :class="{enabled:fieldValue(fieldPath(f.key))===true}"><div class="feature-mark">{{f.label.slice(0,1)}}</div><div><strong>{{f.label}}</strong><p>{{featureDescription(f.key)}}</p></div><label class="toggle"><input type="checkbox" :checked="fieldValue(fieldPath(f.key))===true" @change="updateField(fieldPath(f.key),($event.target as HTMLInputElement).checked)"><span></span></label></article></div>
<div v-else class="config-panel"><div class="config-banner"><div class="config-symbol">{{activeSection?.key==='storage'?'▣':'DB'}}</div><div><strong>{{activeSection?.key==='storage'?'存储目录规划':'数据库连接'}}</strong><p>{{activeSection?.key==='storage'?'支持相对插件数据目录或绝对路径,保存前请确保 AstrBot 进程具备写入权限。':'auto 会优先使用已配置的 PostgreSQL,否则回退到本地 SQLite。'}}</p></div></div><div class="fields"><label v-for="f in activeSection?.fields||[]" :key="f.key"><span>{{f.label}}</span><select v-if="f.options.length||f.type==='bool'||f.type==='boolean'" :value="String(fieldValue(fieldPath(f.key)))" @change="updateField(fieldPath(f.key),inputValue($event,f.type))"><option v-if="f.type==='bool'||f.type==='boolean'" value="true">开启</option><option v-if="f.type==='bool'||f.type==='boolean'" value="false">关闭</option><option v-for="o in f.options" :key="o" :value="o">{{o}}</option></select><input v-else :type="f.type==='number'?'number':f.sensitive?'password':'text'" :placeholder="f.type==='path'?'输入目录或文件路径':''" :value="fieldValue(fieldPath(f.key)) as any" @input="updateField(fieldPath(f.key),inputValue($event,f.type))"><small>{{fieldPath(f.key)}}</small></label></div><StorageMaintenance v-if="activeSection?.key==='storage'" :can-manage="canManage" :backend-connected="backendConnected" /></div>

查看文件

@ -2,7 +2,7 @@ name: astrbot_plugin_imagestudio
display_name: ImageStudio
desc: AstrBot >=4.25 ImageStudio role asset and image-generation workspace for Windows, Linux, macOS and Docker.
short_desc: AstrBot 内的角色资产、工作流与图片生成管理工作台。
version: 3.1.0
version: 1.0.0
author: YokiiroBW
repo: "http://192.168.31.210:18085/YokiiroBW/astrbot_plugin_imagestudio"
astrbot_version: ">=4.25.0,<5"

文件差异因一行或多行过长而隐藏

文件差异因一行或多行过长而隐藏

文件差异因一行或多行过长而隐藏

文件差异因一行或多行过长而隐藏

查看文件

@ -4,8 +4,8 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>AstrBot ImageStudio</title>
<script type="module" crossorigin src="./assets/index-zEvRFDXh.js"></script>
<link rel="stylesheet" crossorigin href="./assets/index-Ccb1kxoS.css">
<script type="module" crossorigin src="./assets/index-CppAmOWf.js"></script>
<link rel="stylesheet" crossorigin href="./assets/index-DEyHqmNh.css">
</head>
<body>
<div id="app"></div>

二进制文件未显示。

查看文件

@ -1 +0,0 @@
"""Operational scripts for ImageStudio."""

查看文件

@ -1,65 +0,0 @@
"""Non-UI backend smoke for ImageStudio."""
from __future__ import annotations
import argparse
import json
import sys
import tempfile
from pathlib import Path
from typing import Any
REPO_ROOT = Path(__file__).resolve().parents[1]
if str(REPO_ROOT) not in sys.path:
sys.path.insert(0, str(REPO_ROOT))
from adapters.astrbot_adapter import runtime_health
from backend.services.contract_service import ContractService
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.seed import seed_default_material_categories
from main import get_plugin_manifest
from scripts.imagestudio_pg_smoke import run_pg_smoke
def run_non_ui_smoke(*, include_pg_dry_run: bool = True) -> dict[str, Any]:
with tempfile.TemporaryDirectory() as tmp:
database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(Path(tmp) / "imagestudio.db"))))
database.initialize()
seed = seed_default_material_categories(database)
conn = database.connect()
try:
migrations = conn.execute("SELECT COUNT(*) AS total FROM schema_migrations").fetchone()["total"]
categories = conn.execute("SELECT COUNT(*) AS total FROM material_categories").fetchone()["total"]
finally:
conn.close()
health = runtime_health()
contract = ContractService().get_contract()
manifest = get_plugin_manifest()
result = {
"ok": bool(health["ok"] and migrations and categories and contract["routes"]),
"checks": {
"runtime_health": health,
"sqlite_migrations": int(migrations),
"seed": seed,
"material_categories": int(categories),
"contract_routes": len(contract["routes"]),
"manifest_routes": len(manifest["routes"]),
"contract_url": manifest["contract_url"],
},
}
if include_pg_dry_run:
result["checks"]["pg_dry_run"] = run_pg_smoke(dry_run=True)
return result
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(description="Run ImageStudio non-UI backend smoke.")
parser.add_argument("--no-pg-dry-run", action="store_true")
args = parser.parse_args(argv)
result = run_non_ui_smoke(include_pg_dry_run=not args.no_pg_dry_run)
print(json.dumps(result, ensure_ascii=False, sort_keys=True))
return 0 if result["ok"] else 1
if __name__ == "__main__":
raise SystemExit(main())

查看文件

@ -1,77 +0,0 @@
"""PostgreSQL migration smoke entrypoint.
The script intentionally prints only redacted configuration state. It can be
used as a dry-run plan in unit tests, or pointed at a real PG config for a live
migration and seed smoke.
"""
from __future__ import annotations
import argparse
import json
import os
import sys
from pathlib import Path
from typing import Any
REPO_ROOT = Path(__file__).resolve().parents[1]
if str(REPO_ROOT) not in sys.path:
sys.path.insert(0, str(REPO_ROOT))
from database.db_helper import Database, load_database_settings
from database.seed import seed_default_material_categories
def build_pg_smoke_plan(config_path: str | Path = "config.yaml") -> dict[str, Any]:
settings = load_database_settings(config_path)
pg = settings.postgresql
return {
"config_path": "***PATH***",
"selected_backend": settings.selected_backend,
"postgresql_configured": pg.is_configured,
"postgresql_enabled": pg.enabled,
"connection_mode": "dsn" if pg.dsn else "host",
"host_set": bool(pg.host),
"database_set": bool(pg.database),
"user_set": bool(pg.user),
"password_set": bool(pg.password),
}
def run_pg_smoke(config_path: str | Path = "config.yaml", *, dry_run: bool = False) -> dict[str, Any]:
plan = build_pg_smoke_plan(config_path)
if dry_run:
return {"ok": True, "dry_run": True, "plan": plan}
if plan["selected_backend"] != "postgresql" or not plan["postgresql_configured"]:
raise RuntimeError("PostgreSQL smoke requires a configured PostgreSQL backend")
database = Database(load_database_settings(config_path))
database.initialize()
seed_result = seed_default_material_categories(database)
conn = database.connect()
try:
migrations = conn.execute("SELECT COUNT(*) AS total FROM schema_migrations").fetchone()["total"]
categories = conn.execute("SELECT COUNT(*) AS total FROM material_categories").fetchone()["total"]
finally:
conn.close()
return {
"ok": True,
"dry_run": False,
"plan": plan,
"migrations_applied": int(migrations),
"seed": seed_result,
"material_categories": int(categories),
}
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(description="Run ImageStudio PostgreSQL migration smoke.")
parser.add_argument("--config", default=os.environ.get("IMAGESTUDIO_CONFIG", "config.yaml"))
parser.add_argument("--dry-run", action="store_true")
args = parser.parse_args(argv)
result = run_pg_smoke(args.config, dry_run=args.dry_run)
print(json.dumps(result, ensure_ascii=False, sort_keys=True))
return 0
if __name__ == "__main__":
raise SystemExit(main())

查看文件

@ -1,181 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.api_discovery_routes import (
list_capabilities,
list_dialects,
manual_override,
probe_model,
probe_provider,
validate_render_plan,
)
from backend.services.api_discovery_service import ApiDiscoveryService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.capability_repository import CapabilityRepository
class ApiDiscoveryServiceTests(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.repository = CapabilityRepository(self.database)
self.service = ApiDiscoveryService(self.repository)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_manage_config"},
)
def tearDown(self):
self.tmp.cleanup()
def test_safe_probe_records_unconfirmed_profile(self):
profile = self.service.probe_provider(
{
"provider_id": "local_provider",
"model_id": "image_low",
"dialect": "openai_images",
"capabilities": {"supports": ["text_to_image"]},
}
)
self.assertEqual(profile["status"], "unconfirmed")
self.assertEqual(profile["probe_result"]["mode"], "safe")
self.assertEqual(len(self.service.capabilities()), 1)
def test_render_plan_treats_missing_profile_as_unconfirmed(self):
result = self.service.validate_render_plan(
{
"provider_id": "missing",
"model_id": "image_low",
"required_capabilities": ["text_to_image"],
}
)
self.assertFalse(result["valid"])
self.assertEqual(result["status"], "unconfirmed")
self.assertEqual(result["errors"][0]["code"], "MODEL_CAPABILITY_UNCONFIRMED")
def test_render_plan_checks_confirmed_supported_capabilities(self):
profile = self.service.probe_provider(
{
"provider_id": "local_provider",
"model_id": "image_low",
"dialect": "openai_images",
"capabilities": {"supports": ["text_to_image"]},
}
)
self.repository.update_profile(profile["capability_profile_id"], {"status": "confirmed_supported"})
valid = self.service.validate_render_plan(
{
"provider_id": "local_provider",
"model_id": "image_low",
"required_capabilities": ["text_to_image"],
}
)
self.assertTrue(valid["valid"])
invalid = self.service.validate_render_plan(
{
"provider_id": "local_provider",
"model_id": "image_low",
"required_capabilities": ["image_edit"],
}
)
self.assertFalse(invalid["valid"])
self.assertEqual(invalid["errors"][0]["code"], "MODEL_CAPABILITY_UNSUPPORTED")
def test_probe_model_and_manual_override(self):
probed = self.service.probe_model(
{
"provider_id": "local_provider",
"model_id": "image_high",
"dialect": "openai_images",
}
)
self.assertEqual(probed["probe_result"]["model_probe"], "safe_metadata_only")
overridden = self.service.manual_override(
{
"provider_id": "local_provider",
"model_id": "image_high",
"status": "confirmed_supported",
"capabilities": {"supports": ["text_to_image", "image_edit"]},
}
)
self.assertEqual(overridden["status"], "confirmed_supported")
self.assertIn("image_edit", overridden["capabilities"]["supports"])
render_plan = self.service.validate_render_plan(
{
"provider_id": "local_provider",
"model_id": "image_high",
"required_capabilities": ["image_edit"],
}
)
self.assertTrue(render_plan["valid"])
def test_api_discovery_routes_wrap_responses(self):
dialects = list_dialects(self.ctx, self.service)
self.assertTrue(dialects["ok"])
self.assertIn("unknown", [item["dialect"] for item in dialects["data"]])
probed = probe_provider(
self.ctx,
{"provider_id": "local_provider", "model_id": "image_low"},
self.service,
)
self.assertTrue(probed["ok"])
model_probe = probe_model(
self.ctx,
{"provider_id": "local_provider", "model_id": "image_low"},
self.service,
)
self.assertTrue(model_probe["ok"])
override = manual_override(
self.ctx,
{
"provider_id": "local_provider",
"model_id": "image_low",
"status": "confirmed_supported",
"capabilities": {"supports": ["text_to_image"]},
},
self.service,
)
self.assertTrue(override["ok"])
capabilities = list_capabilities(self.ctx, self.service)
self.assertTrue(capabilities["ok"])
self.assertEqual(len(capabilities["data"]), 1)
validation = validate_render_plan(
self.ctx,
{
"provider_id": "local_provider",
"model_id": "image_low",
"required_capabilities": ["text_to_image"],
},
self.service,
)
self.assertTrue(validation["ok"])
self.assertTrue(validation["data"]["valid"])
self.assertEqual(validation["data"]["status"], "confirmed_supported")
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = probe_provider(read_only, {"provider_id": "x", "model_id": "y"}, self.service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,13 +0,0 @@
from adapters.astrbot_card_renderer import render_help_card, render_status_card
import pytest
def test_help_and_status_cards_render_png(tmp_path, monkeypatch):
pytest.importorskip("PIL")
import adapters.astrbot_card_renderer as renderer
monkeypatch.setattr(renderer, "CARD_DIR", tmp_path)
help_card = render_help_card(["/影棚 帮助", "/yp 状态"])
status_card = render_status_card(state="正常", version="3.0.0", database="已初始化", api="/api/test")
assert help_card.read_bytes().startswith(b"\x89PNG")
assert status_card.read_bytes().startswith(b"\x89PNG")

查看文件

@ -1,43 +0,0 @@
from adapters.astrbot_command_adapter import command_allowed, command_context_from_event, help_text, message_text_from_event
class FakeEvent:
unified_msg_origin = "qq:group:100"
message_str = "确认"
def get_sender_id(self):
return "user-1"
def get_group_id(self):
return "group-1"
def get_platform_name(self):
return "aiocqhttp"
def test_command_context_uses_platform_neutral_event_fields():
context = command_context_from_event(FakeEvent())
assert context.user_id == "user-1"
assert context.group_id == "group-1"
assert context.message_origin == "qq:group:100"
assert context.platform == "aiocqhttp"
assert context.message_id == ""
assert message_text_from_event(FakeEvent()) == "确认"
def test_command_adapter_reuses_allowlist_policy():
config = {"chat_access": {"group_allowlist": ["group-1"], "user_allowlist": ["user-1"]}}
context = command_context_from_event(FakeEvent())
assert command_allowed(config, "quick_profile", context)
assert command_allowed(config, "single_image", context)
assert "/影棚 快速角色" in help_text()
assert "/yp 帮助" in help_text()
def test_event_context_falls_back_for_telegram_and_discord_style_fields():
telegram = type("TelegramEvent", (), {"sender_id": 42, "group_id": -1001, "platform_name": "telegram", "message_origin": "telegram:chat:-1001"})()
discord = type("DiscordEvent", (), {"user_id": "u2", "group_id": "guild-2", "platform_name": "discord", "message_origin": "discord:guild:guild-2"})()
assert command_context_from_event(telegram).platform == "telegram"
assert command_context_from_event(telegram).group_id == "-1001"
assert command_context_from_event(discord).user_id == "u2"
assert command_context_from_event(discord).message_origin == "discord:guild:guild-2"

查看文件

@ -1,19 +0,0 @@
import pytest
from adapters.astrbot_command_parser import parse_single_image_command
from backend.dto.chat_command_dto import ChatCommandParseError
def test_parse_natural_and_explicit_single_image_command():
command = parse_single_image_command('雨夜街道中的少女 --角色 "米卡" --尺寸 2K --数量 2 --负面 水印')
assert command.prompt == "雨夜街道中的少女"
assert command.profile_ref == "米卡"
assert command.size == "2560x1440"
assert command.count == 2
assert command.negative_prompt == "水印"
@pytest.mark.parametrize("raw", ["", "测试 --尺寸 8K", "测试 --数量 0", "测试 --未知 x"])
def test_parse_rejects_invalid_single_image_commands(raw):
with pytest.raises(ChatCommandParseError):
parse_single_image_command(raw)

查看文件

@ -1,27 +0,0 @@
from main import Main
import pytest
from adapters.astrbot_command_adapter import command_context_from_event
class Event:
def plain_result(self, text):
return {"type": "plain", "text": text}
def test_card_and_image_results_fall_back_to_text_without_platform_components():
plugin = Main(None)
event = Event()
card = plugin._card_result(event, lambda: (_ for _ in ()).throw(RuntimeError("no renderer")), "fallback")
images = plugin._generation_result(event, "done", [{"image_id": "img-1", "image_url": "https://example.com/a.png"}])
assert card["text"] == "fallback"
assert "https://example.com/a.png" in images["text"]
@pytest.mark.parametrize("platform,origin", [("aiocqhttp", "qq:group:1"), ("telegram", "telegram:chat:1"), ("discord", "discord:guild:1")])
def test_platform_context_and_image_fallback_contract(platform, origin):
event = type("PlatformEvent", (), {"sender_id": "u1", "group_id": "g1", "platform_name": platform, "message_origin": origin})()
context = command_context_from_event(event)
assert context.platform == platform
assert context.message_origin == origin
result = Main(None)._generation_result(Event(), "completed", [{"image_id": "img", "image_url": "https://example.com/image.png"}])
assert "image.png" in result["text"]

查看文件

@ -1,47 +0,0 @@
import os
import subprocess
import sys
import tempfile
import textwrap
import unittest
from pathlib import Path
class AstrBotEntrypointImportTest(unittest.TestCase):
def test_main_imports_when_plugin_root_is_not_on_sys_path(self):
repo_root = Path(__file__).resolve().parents[1]
code = textwrap.dedent(
f"""
import importlib.util
import json
import sys
from pathlib import Path
repo_root = Path({str(repo_root)!r})
sys.path = [p for p in sys.path if Path(p or ".").resolve() != repo_root]
spec = importlib.util.spec_from_file_location(
"imagestudio_runtime_entry",
repo_root / "main.py",
)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
manifest = module.get_plugin_manifest()
print(json.dumps({{"plugin_name": manifest["plugin_name"]}}))
"""
)
with tempfile.TemporaryDirectory() as tmp:
env = dict(os.environ)
env.pop("PYTHONPATH", None)
result = subprocess.run(
[sys.executable, "-c", code],
cwd=tmp,
env=env,
check=True,
capture_output=True,
text=True,
)
self.assertIn("astrbot_plugin_imagestudio", result.stdout)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,18 +0,0 @@
from adapters.astrbot_media_adapter import image_references_from_event
class Image:
def __init__(self, url):
self.url = url
class Plain:
text = "hello"
class Event:
message_obj = type("Message", (), {"message": [Plain(), Image("https://example.com/a.png")]})()
def test_extracts_only_image_references():
assert image_references_from_event(Event()) == ["https://example.com/a.png"]

查看文件

@ -1,164 +0,0 @@
from __future__ import annotations
import shutil
import unittest
from pathlib import Path
from uuid import uuid4
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_path = Path(".tmp") / f"test_character_workflow_service_{uuid4().hex}"
self.tmp_path.mkdir(parents=True, exist_ok=False)
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(self.tmp_path / "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):
shutil.rmtree(self.tmp_path, ignore_errors=True)
def test_execute_fast_character_workflow_prepares_generation_nodes(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"], "running")
self.assertEqual(len(result["nodes"]), 3)
self.assertTrue(all(node["status"] == "queued" for node in result["nodes"]))
self.assertEqual(result["completed_node_ids"], [])
self.assertEqual(len(result["queued_node_ids"]), 3)
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_planning_and_queues_generation(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(result["workflow"]["status"], "running")
self.assertEqual(len(result["completed_node_ids"]), 0)
self.assertEqual(len(result["queued_node_ids"]), 8)
self.assertEqual(len(result["prepared_node_ids"]), 2)
material_bind = next(node for node in result["nodes"] if node["node_key"] == "material_bind")
self.assertEqual(material_bind["status"], "draft")
self.assertIn("reference material binding rules", material_bind["prompt"])
updated_material_bind = self.workflow_service.update_node(
material_bind["node_id"],
{"metadata": {**material_bind["metadata"], "material_bindings": {"selected_material_ids": []}}},
self.ctx,
)
self.assertIn("material_bindings", updated_material_bind.metadata)
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_running_character_workflow_refreshes_prepared_prompts(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_gradual", "display_name": "Gradual"},
self.ctx,
)
first = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx)
second = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx)
self.assertEqual(first["workflow"]["status"], "running")
self.assertEqual(second["workflow"]["status"], "running")
self.assertEqual(first["queued_node_ids"], second["queued_node_ids"])
def test_execute_quick_profile_workflow_completes_profile_draft_nodes(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "quick_profile", "display_name": "Quick profile"},
self.ctx,
)
result = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx)
self.assertEqual(result["workflow"]["status"], "completed")
self.assertEqual([node["node_key"] for node in result["nodes"]], ["questionnaire", "preview"])
preview = result["nodes"][-1]
self.assertIn("saved quick profile prompts", preview["prompt"])
self.assertEqual(preview["metadata"]["execution"]["workflow_type"], "quick_profile")
def test_execute_completed_quick_profile_workflow_is_idempotent(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "quick_profile", "display_name": "Quick profile"},
self.ctx,
)
first = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx)
replay = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx)
self.assertEqual(first["workflow"]["status"], "completed")
self.assertEqual(replay["workflow"]["status"], "completed")
self.assertTrue(replay["idempotent_replay"])
self.assertTrue(all(node["status"] == "completed" for node in replay["nodes"]))
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"], "running")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,17 +0,0 @@
from core.chat_access_policy import chat_action_allowed
CONFIG = {"chat_access": {"group_allowlist": ["group-1"], "user_allowlist": ["user-1"]}}
def test_quick_profile_and_workflow_require_both_allowlists():
assert chat_action_allowed(CONFIG, "quick_profile", group_id="group-1", user_id="user-1")
assert chat_action_allowed(CONFIG, "character_workflow", group_id="group-1", user_id="user-1")
assert not chat_action_allowed(CONFIG, "quick_profile", group_id="group-1", user_id="user-2")
assert not chat_action_allowed(CONFIG, "character_workflow", group_id=None, user_id="user-1")
def test_single_image_accepts_either_allowlist():
assert chat_action_allowed(CONFIG, "single_image", group_id="group-1", user_id="user-2")
assert chat_action_allowed(CONFIG, "single_image", group_id="group-2", user_id="user-1")
assert not chat_action_allowed(CONFIG, "single_image", group_id="group-2", user_id="user-2")

查看文件

@ -1,109 +0,0 @@
from __future__ import annotations
import unittest
import adapters
from adapters.onebot11_adapter import handle_message_event, normalize_message_event
from adapters.wechat_adapter import handle_message_event as handle_wechat_message_event
from adapters.wechat_adapter import normalize_message_event as normalize_wechat_message_event
class OneBotAdapterTests(unittest.TestCase):
def test_normalizes_text_segments(self):
message = normalize_message_event(
{
"message_type": "group",
"user_id": 10001,
"group_id": 20002,
"message": [
{"type": "text", "data": {"text": " 图像"}},
{"type": "text", "data": {"text": "工作台 "}},
],
}
)
self.assertEqual(message.user_id, "10001")
self.assertEqual(message.group_id, "20002")
self.assertEqual(message.text, "图像工作台")
def test_workbench_command_returns_reply_payload(self):
result = handle_message_event({"user_id": "u1", "raw_message": "/imagestudio"}, api_base="/api/plugin")
self.assertIsNotNone(result)
self.assertEqual(result["platform"], "onebot11")
self.assertEqual(result["action"], "open_workbench")
self.assertEqual(result["reply"]["url"], "/api/plugin/web")
def test_workbench_aliases_are_shared(self):
for command in ["/is", "image studio", "工作台", "生图工作台"]:
with self.subTest(command=command):
result = handle_message_event({"user_id": "u1", "raw_message": command}, api_base="/api/plugin")
self.assertIsNotNone(result)
self.assertEqual(result["action"], "open_workbench")
def test_ignores_non_commands(self):
self.assertIsNone(handle_message_event({"user_id": "u1", "raw_message": "hello"}))
def test_quick_profile_command_returns_action_payload(self):
result = handle_message_event({"user_id": "u1", "raw_message": "/imagestudio profile Nova"})
self.assertIsNotNone(result)
self.assertEqual(result["action"], "quick_profile")
self.assertEqual(result["payload"]["action_type"], "quick_profile")
self.assertTrue(result["payload"]["draft_only"])
self.assertEqual(result["payload"]["questionnaire"], {"name": "Nova"})
self.assertNotIn("data", result)
class WeChatAdapterTests(unittest.TestCase):
def test_normalizes_wechat_event_aliases(self):
message = normalize_wechat_message_event(
{"sender": "wx_user", "chatroom_id": "room_001", "content": " 图像工作台 "}
)
self.assertEqual(message.user_id, "wx_user")
self.assertEqual(message.room_id, "room_001")
self.assertEqual(message.text, "图像工作台")
def test_workbench_command_returns_reply_payload(self):
result = handle_wechat_message_event(
{"from_user": "wx_user", "text": "imagestudio"},
api_base="/api/plugin",
)
self.assertIsNotNone(result)
self.assertEqual(result["platform"], "wechat")
self.assertEqual(result["action"], "open_workbench")
self.assertEqual(result["reply"]["url"], "/api/plugin/web")
def test_workbench_aliases_are_shared(self):
for command in ["/is", "image studio", "工作台", "生图工作台"]:
with self.subTest(command=command):
result = handle_wechat_message_event({"from_user": "wx_user", "text": command}, api_base="/api/plugin")
self.assertIsNotNone(result)
self.assertEqual(result["action"], "open_workbench")
def test_ignores_non_commands(self):
self.assertIsNone(handle_wechat_message_event({"from_user": "wx_user", "text": "hello"}))
def test_quick_profile_command_returns_action_payload(self):
result = handle_wechat_message_event({"from_user": "wx_user", "text": "创建角色 Nova"})
self.assertIsNotNone(result)
self.assertEqual(result["action"], "quick_profile")
self.assertEqual(result["payload"]["action_type"], "quick_profile")
self.assertTrue(result["payload"]["draft_only"])
self.assertEqual(result["payload"]["questionnaire"], {"name": "Nova"})
self.assertNotIn("data", result)
class AdapterExportTests(unittest.TestCase):
def test_chat_adapter_entrypoints_are_exported(self):
self.assertTrue(callable(adapters.handle_onebot11_message_event))
self.assertTrue(callable(adapters.handle_wechat_message_event))
self.assertTrue(callable(adapters.dispatch_extension_request))
self.assertTrue(callable(adapters.resolve_web_asset))
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,28 +0,0 @@
import pytest
from adapters.astrbot_command_adapter import ChatCommandContext
from backend.services.chat_command_guard_service import ChatCommandGuardService
class Audit:
def record(self, **kwargs): pass
class Guard(ChatCommandGuardService):
def __init__(self):
self.audit = Audit()
def _daily_count(self, user_id): return 0
def _daily_group_count(self, group_id): return 0
CHAT = ChatCommandContext("user-1", "group-1", "qq:group:1", "aiocqhttp", "msg-1")
def test_guard_enforces_resolution_and_concurrency():
guard = Guard()
config = {"chat_access": {"allow_2k": True, "allow_4k": False, "user_concurrency_limit": 1}}
guard.check_generation(config, CHAT, size="2560x1440", active_jobs=[])
with pytest.raises(ValueError, match="4K"):
guard.check_generation(config, CHAT, size="3840x2160", active_jobs=[])
with pytest.raises(ValueError, match="用户并发"):
guard.check_generation(config, CHAT, size="1920x1080", active_jobs=[{"request": {"metadata": {"user_id": "user-1"}}}])

查看文件

@ -1,22 +0,0 @@
import base64
from pathlib import Path
from backend.services.chat_media_import_service import ChatMediaImportService
class Storage:
def __init__(self, root): self.root = Path(root)
def resolve_uri(self, uri): return self.root / uri.removeprefix("storage://materials/")
def ensure_file(self, uri):
path = self.resolve_uri(uri)
if not path.is_file(): raise FileNotFoundError(uri)
return path
def test_data_url_import_uses_portable_storage_path(tmp_path):
service = ChatMediaImportService(Storage(tmp_path))
uri, filename, size = service.import_image("data:image/png;base64," + base64.b64encode(b"png-data").decode())
assert uri.startswith("storage://materials/chat/")
assert "\\" not in uri
assert filename.endswith(".png")
assert size == 8

查看文件

@ -1,20 +0,0 @@
from backend.services.chat_session_service import ChatSessionStore
import time
def test_chat_session_store_binds_and_pops_session(tmp_path):
path = tmp_path / "sessions.json"
store = ChatSessionStore(ttl_seconds=60, max_sessions=2, persistence_path=path)
store.put("qq:group:user", "select_image", {"images": ["img-1"]})
restored = ChatSessionStore(ttl_seconds=60, max_sessions=2, persistence_path=path)
assert restored.get("qq:group:user").action == "select_image"
assert store.get("qq:group:user").payload["images"] == ["img-1"]
assert store.pop("qq:group:user").action == "select_image"
assert store.get("qq:group:user") is None
def test_chat_session_expires(tmp_path):
store = ChatSessionStore(ttl_seconds=0, max_sessions=2, persistence_path=tmp_path / "expired.json")
store.put("key", "confirm", {})
time.sleep(0.01)
assert store.get("key") is None

查看文件

@ -1,52 +0,0 @@
from adapters.astrbot_command_adapter import ChatCommandContext
from backend.dto.chat_command_dto import SingleImageCommand
from backend.services.chat_workflow_service import ChatWorkflowService, _quick_questionnaire
def test_single_image_orchestration_reuses_existing_routes():
calls = []
def dispatch(ctx, method, path, query=None, payload=None):
calls.append((method, path, query, payload))
if method == "GET" and path == "jobs":
return {"ok": True, "data": {"items": []}}
if method == "GET" and path == "profiles":
return {"ok": True, "data": {"items": []}}
if method == "POST" and path == "profiles":
return {"ok": True, "data": {"profile_id": "profile-chat", "name": "chat"}}
if path.endswith("/workflows"):
return {"ok": True, "data": {"workflow": {"workflow_id": "wf-1"}, "nodes": [{"node_id": "node-1"}]}}
if path.endswith("/start"):
return {"ok": True, "data": {"status": "running"}}
if path.endswith("/generate"):
return {"ok": True, "data": {"task_id": "task-1", "images": [{"image_id": "img-1"}]}}
if path == "images/img-1":
return {"ok": True, "data": {"image_id": "img-1", "image_url": "/media/img-1"}}
raise AssertionError((method, path))
class Guard:
def check_generation(self, *args, **kwargs): pass
def record(self, *args, **kwargs): pass
service = ChatWorkflowService(
dispatch,
lambda: {"chat_access": {"group_allowlist": ["group-1"], "user_allowlist": ["user-1"]}},
guard=Guard(),
)
context = ChatCommandContext("user-1", "group-1", "qq:group:1", "aiocqhttp", "msg-1")
result = service.submit_single_image(SingleImageCommand("portrait"), context)
assert result["generation"]["task_id"] == "task-1"
assert result["images"][0]["image_url"] == "/media/img-1"
generate = next(item for item in calls if item[1] == "nodes/node-1/generate")
assert generate[3]["size"] == "1920x1080"
assert generate[3]["idempotency_key"].startswith("chat_")
first_key = generate[3]["idempotency_key"]
assert first_key == "chat_" + __import__("hashlib").sha256(b"msg-1").hexdigest()[:32]
def test_quick_questionnaire_extracts_character_fields():
result = _quick_questionnaire("米卡 银发蓝眼的冷静少女,穿学院制服,留着长发")
assert result["name"] == "米卡"
assert "冷静" in result["personality"]
assert "制服" in result["clothing_keywords"]
assert result["hairstyle"] == "长发"

查看文件

@ -1,39 +0,0 @@
from __future__ import annotations
import unittest
from backend.dto.common import ErrorCode
from backend.route_registry import ROUTES
from backend.routes.contract_routes import get_api_contract
from backend.services.contract_service import ContractService
from core.identity import RequestContext
class ContractServiceTests(unittest.TestCase):
def test_contract_exports_routes_permissions_and_error_codes(self):
contract = ContractService().get_contract()
self.assertEqual(contract["contract_version"], "3.0")
self.assertTrue(contract["api_base"].endswith("astrbot_plugin_imagestudio"))
self.assertEqual(len(contract["routes"]), len(ROUTES))
self.assertIn("VALIDATION_FAILED", contract["error_codes"])
self.assertEqual(set(contract["error_codes"]), {code.value for code in ErrorCode})
self.assertTrue(all("auth_required" in route for route in contract["routes"]))
self.assertTrue(any(item["permission"] == "config" for item in contract["permissions"]))
self.assertEqual(contract["response_shape"]["success"]["ok"], True)
self.assertEqual(contract["response_shape"]["error"]["ok"], False)
def test_contract_route_requires_authentication(self):
ctx = RequestContext.from_astrbot(username="admin", user_id="user_001")
response = get_api_contract(ctx, ContractService())
anonymous = get_api_contract(RequestContext(), ContractService())
self.assertTrue(response["ok"])
self.assertEqual(response["data"]["contract_version"], "3.0")
self.assertFalse(anonymous["ok"])
self.assertEqual(anonymous["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,203 +0,0 @@
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.interactions import build_default_actions, filter_actions_for_permissions, normalize_action
from core.interop import PRIVATE_COMPANION, daily_outfit_request, is_allowed_plugin, normalize_plugin_request
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,
redact_provider_secret_state,
resolve_env_value,
resolve_secret_value,
)
from core.webhook import WebhookEvent, sign_event, to_sse, verify_signature
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)
def test_secret_resolution_prefers_env_and_redacts_public_state(self):
os.environ["IMAGESTUDIO_PROVIDER_KEY"] = "secret-value"
try:
resolution = resolve_secret_value(
env_var="IMAGESTUDIO_PROVIDER_KEY",
plaintext="fallback-value",
)
public = redact_provider_secret_state(
{
"provider_id": "site_b",
"api_key_env_var": "IMAGESTUDIO_PROVIDER_KEY",
"api_key_secret_ref": "secret/provider/site_b",
"api_key_plaintext": "secret-value",
}
)
finally:
os.environ.pop("IMAGESTUDIO_PROVIDER_KEY", None)
self.assertEqual(resolution.value, "secret-value")
self.assertEqual(resolution.to_public_dict()["value"], MASK)
self.assertTrue(public["api_key_set"])
self.assertEqual(public["api_key_secret_ref"], MASK)
self.assertNotIn("api_key_plaintext", public)
class InteractionTests(unittest.TestCase):
def test_actions_are_normalized_and_filtered_by_permission(self):
action = normalize_action({"type": "open_logs", "label": "Logs"})
self.assertEqual(action.action_type, "open_logs")
actions = build_default_actions(api_base="/api/plugin")
filtered = filter_actions_for_permissions(actions, {"can_write"})
self.assertIn("quick_profile", [item.action_id for item in filtered])
self.assertNotIn("open_settings", [item.action_id for item in filtered])
class InteropTests(unittest.TestCase):
def test_plugin_request_normalization_and_allow_list(self):
request = normalize_plugin_request(
{"plugin_name": PRIVATE_COMPANION, "action": "daily_outfit", "payload": {"profile_id": "profile_001"}}
)
self.assertTrue(is_allowed_plugin(request.plugin_name))
self.assertEqual(request.payload["profile_id"], "profile_001")
self.assertEqual(daily_outfit_request({"profile_id": "profile_001"}).plugin_name, PRIVATE_COMPANION)
class WebhookTests(unittest.TestCase):
def test_webhook_signature_and_sse_format(self):
event = WebhookEvent("task.completed", {"task_id": "task_001"}, event_id="wh_test")
signature = sign_event(event, "secret")
self.assertTrue(verify_signature(event, "secret", signature))
self.assertFalse(verify_signature(event, "secret", "bad"))
sse = to_sse(event)
self.assertIn("event: task.completed", sse)
self.assertIn("data:", sse)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,196 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.cost_routes import get_cost_usage
from backend.routes.cost_routes import check_cost_guard
from backend.services.cost_guard_service import CostGuardService
from backend.services.cost_service import CostService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.image_repository import ImageRepository
class CostServiceTests(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()
conn = self.database.connect()
try:
conn.execute(
"""
INSERT INTO character_profiles (
profile_id, name, owner_platform, owner_user_id
) VALUES (?, ?, ?, ?)
""",
("profile_001", "Cost Test", "astrbot", "user_001"),
)
conn.commit()
finally:
conn.close()
self.image_repository = ImageRepository(self.database)
self.ctx = RequestContext.from_astrbot(username="admin", user_id="user_001", permissions={"can_write"})
def tearDown(self):
self.tmp.cleanup()
def test_usage_summary_groups_provider_usage_and_estimated_cost(self):
for index, tokens in enumerate((1000, 500), start=1):
self.image_repository.create(
{
"image_id": f"img_b_{index}",
"task_id": "task_b_1",
"profile_id": "profile_001",
"image_uri": f"storage://images/b_{index}.png",
"model_route": "image_high",
"metadata": {
"provider_id": "site_b",
"provider_model": "image2",
"usage": {"total_tokens": tokens, "input_tokens": tokens // 2, "output_tokens": tokens // 2},
},
}
)
self.image_repository.create(
{
"image_id": "img_a_1",
"task_id": "task_a_1",
"profile_id": "profile_001",
"image_uri": "storage://images/a_1.png",
"model_route": "image_low",
"metadata": {
"provider_id": "site_a",
"provider_model": "gpt-image-1.5",
"usage": {"total_tokens": 200},
},
}
)
summary = CostService(self.database).usage_summary(
profile_id="profile_001",
unit_prices={
"site_b": 0.045,
"site_a:gpt-image-1.5": {"per_image": 0.01},
},
)
self.assertEqual(summary["totals"]["image_count"], 3)
self.assertEqual(summary["totals"]["task_count"], 2)
self.assertEqual(summary["totals"]["total_tokens"], 1200)
self.assertEqual(summary["totals"]["estimated_cost"], 0.055)
site_b = next(group for group in summary["groups"] if group["provider_id"] == "site_b")
self.assertEqual(site_b["image_count"], 2)
self.assertEqual(site_b["task_count"], 1)
self.assertEqual(site_b["total_tokens"], 1000)
self.assertEqual(site_b["estimated_cost"], 0.045)
def test_usage_summary_counts_identical_multi_image_request_usage_once(self):
for index in range(3):
self.image_repository.create(
{
"image_id": f"img_multi_{index}",
"task_id": "task_multi",
"profile_id": "profile_001",
"image_uri": f"storage://images/multi_{index}.png",
"model_route": "image_high",
"metadata": {
"provider_id": "site_b",
"provider_model": "image2",
"usage": {"total_tokens": 900, "input_tokens": 600, "output_tokens": 300},
},
}
)
summary = CostService(self.database).usage_summary(profile_id="profile_001")
self.assertEqual(summary["totals"]["image_count"], 3)
self.assertEqual(summary["totals"]["task_count"], 1)
self.assertEqual(summary["totals"]["total_tokens"], 900)
self.assertEqual(summary["totals"]["input_tokens"], 600)
self.assertEqual(summary["totals"]["output_tokens"], 300)
def test_usage_summary_does_not_mislabel_missing_provider_as_mock(self):
self.image_repository.create(
{
"image_id": "img_unknown_provider",
"task_id": "task_unknown_provider",
"profile_id": "profile_001",
"image_uri": "storage://images/unknown.png",
"model_route": "image_default",
"metadata": {},
}
)
summary = CostService(self.database).usage_summary(profile_id="profile_001")
self.assertEqual(summary["groups"][0]["provider_id"], "unknown")
def test_cost_usage_route_requires_auth_and_accepts_price_table(self):
self.image_repository.create(
{
"image_id": "img_b_1",
"task_id": "task_b_1",
"image_uri": "storage://images/b_1.png",
"model_route": "image_high",
"metadata": {"provider_id": "site_b", "provider_model": "image2", "usage": {"total_tokens": 100}},
}
)
response = get_cost_usage(
self.ctx,
{"unit_prices": {"site_b": 0.045}},
CostService(self.database),
)
anonymous = get_cost_usage(RequestContext(), {}, CostService(self.database))
self.assertTrue(response["ok"])
self.assertEqual(response["data"]["totals"]["estimated_cost"], 0.045)
self.assertFalse(anonymous["ok"])
self.assertEqual(anonymous["error_code"], "UNAUTHORIZED")
def test_cost_guard_blocks_projected_budget_overrun(self):
self.image_repository.create(
{
"image_id": "img_b_1",
"task_id": "task_b_1",
"image_uri": "storage://images/b_1.png",
"model_route": "image_high",
"metadata": {"provider_id": "site_b", "provider_model": "image2", "usage": {"total_tokens": 100}},
}
)
guard = CostGuardService(CostService(self.database))
result = guard.check_generation_budget(
provider_id="site_b",
provider_model="image2",
model_route="image_high",
planned_task_count=1,
planned_image_count=1,
max_task_count=1,
max_estimated_cost=0.05,
unit_prices={"site_b": 0.045},
)
route_result = check_cost_guard(
self.ctx,
{
"provider_id": "site_b",
"provider_model": "image2",
"max_estimated_cost": 0.05,
"unit_prices": {"site_b": 0.045},
},
guard,
)
self.assertFalse(result["allowed"])
self.assertIn("task_budget_exceeded", result["violations"])
self.assertIn("cost_budget_exceeded", result["violations"])
self.assertTrue(route_result["ok"])
self.assertFalse(route_result["data"]["allowed"])
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,12 +0,0 @@
from backend.services.cross_review_service import CrossReviewService, _disagreements
def test_cross_review_routes_are_deduplicated_and_include_legacy_fields():
service = CrossReviewService.__new__(CrossReviewService)
service.config = {"model_assignments": {"cross_review_routes": ["vision-a", "vision-b"], "cross_review_primary": "vision-a", "cross_review_secondary": "vision-c"}}
assert service._routes() == ["vision-a", "vision-b", "vision-c"]
def test_cross_review_reports_model_disagreements():
result = _disagreements([{"defects": ["hands", "text"]}, {"defects": ["hands", "anatomy"]}])
assert result == ["anatomy", "text"]

查看文件

@ -1,77 +0,0 @@
from __future__ import annotations
import sqlite3
import tempfile
import unittest
from pathlib import Path
from backend.services.data_backup_service import DataBackupService
from core.config_service import ConfigService
class DataBackupServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.db = self.root / "imagestudio.db"
conn = sqlite3.connect(self.db)
conn.execute("CREATE TABLE sample(id INTEGER PRIMARY KEY, value TEXT)")
conn.execute("INSERT INTO sample(value) VALUES ('before')")
conn.commit(); conn.close()
self.images = self.root / "images"
self.images.mkdir()
(self.images / "one.png").write_bytes(b"image-data")
self.archives = self.root / "archives"
self.config = self.root / "config.yaml"
self.config.write_text(
f"""database:
backend: sqlite
sqlite:
path: "{self.db.as_posix()}"
storage:
images_path: "{self.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.archives.as_posix()}"
""",
encoding="utf-8",
)
self.service = DataBackupService(ConfigService(self.config))
def tearDown(self):
self.tmp.cleanup()
def test_create_and_inspect_full_backup(self):
created = self.service.create_backup(include_media=True)
inspected = self.service.inspect_backup(created["backup_id"])
self.assertTrue(inspected["valid"])
self.assertTrue(inspected["include_media"])
paths = {item["path"] for item in inspected["manifest"]["entries"]}
self.assertIn("config/config.yaml", paths)
self.assertIn("database/imagestudio.db", paths)
self.assertIn("media/images/one.png", paths)
def test_restore_requires_confirmation_and_creates_safety_backup(self):
created = self.service.create_backup(include_media=True)
conn = sqlite3.connect(self.db)
conn.execute("UPDATE sample SET value = 'after'")
conn.commit(); conn.close()
(self.images / "one.png").write_bytes(b"changed")
preview = self.service.restore_backup(created["backup_id"], confirm=False)
restored = self.service.restore_backup(created["backup_id"], confirm=True)
self.assertTrue(preview["requires_confirmation"])
self.assertTrue(restored["restored"])
self.assertTrue(restored["safety_backup_id"].startswith("backup_"))
conn = sqlite3.connect(self.db)
value = conn.execute("SELECT value FROM sample").fetchone()[0]
conn.close()
self.assertEqual(value, "before")
self.assertEqual((self.images / "one.png").read_bytes(), b"image-data")
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()

查看文件

@ -1,89 +0,0 @@
from __future__ import annotations
import json
import re
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
PLUGIN_NAME = "astrbot_plugin_imagestudio"
DATA_ROOT = f"data/plugin_data/{PLUGIN_NAME}"
CURRENT_API = f"/api/v1/plugins/extensions/{PLUGIN_NAME}/<endpoint>"
LEGACY_API = f"/api/plug/{PLUGIN_NAME}/<endpoint>"
def read(path: str) -> str:
return (ROOT / path).read_text(encoding="utf-8")
class PackagingDocsTests(unittest.TestCase):
def test_install_docs_cover_smoke_pg_and_archive_commands(self):
install = read("INSTALL.md")
readme = read("README.md")
self.assertIn("python scripts/imagestudio_non_ui_smoke.py", install)
self.assertIn("python scripts/imagestudio_pg_smoke.py --dry-run", install)
self.assertIn("git archive --format=zip", install)
self.assertIn("psycopg2", install)
self.assertIn("[INSTALL.md](INSTALL.md)", readme)
def test_docs_describe_official_astrbot_discovery_and_lifecycle(self):
docs = "\n".join(read(path) for path in ("README.md", "INSTALL.md", "DEVELOPMENT.md", "backend/README.md"))
self.assertIn("pages/imagestudio/index.html", docs)
self.assertIn("context.register_web_api", docs)
self.assertIn("initialize()", docs)
self.assertIn("terminate()", docs)
self.assertIn("相对 endpoint", docs)
self.assertIn("4.25.0", docs)
def test_docs_cover_legacy_bridge_and_current_direct_api(self):
docs = "\n".join(read(path) for path in ("README.md", "INSTALL.md", "DEVELOPMENT.md", "backend/README.md"))
self.assertIn(LEGACY_API, docs)
self.assertIn(CURRENT_API, docs)
self.assertIn('apiGet("ui/bootstrap")', docs)
def test_docs_do_not_claim_custom_helpers_are_astrbot_callbacks(self):
docs = "\n".join(read(path) for path in ("README.md", "INSTALL.md", "DEVELOPMENT.md", "backend/README.md"))
self.assertNotIn("get_plugin_manifest", docs)
self.assertNotIn("register_plugin", docs)
def test_runtime_data_paths_use_astrbot_plugin_data_directory(self):
config = read("config.yaml")
schema = json.loads(read("_conf_schema.json"))
docs = "\n".join(read(path) for path in ("README.md", "INSTALL.md", "DEVELOPMENT.md", "backend/README.md"))
self.assertIn(DATA_ROOT, config)
self.assertEqual(schema["sqlite_path"]["default"], "data/db/imagestudio.db")
self.assertIn(DATA_ROOT, docs)
self.assertIn("path: data/db/imagestudio.db", config)
self.assertNotIn(f"path: {DATA_ROOT}/db/imagestudio.db", config)
def test_plugin_page_build_is_packaged(self):
self.assertTrue((ROOT / "pages" / "imagestudio" / "index.html").is_file())
self.assertTrue((ROOT / "metadata.yaml").is_file())
self.assertTrue((ROOT / "main.py").is_file())
metadata = read("metadata.yaml")
self.assertRegex(metadata, re.compile(rf"^name:\s*{PLUGIN_NAME}$", re.MULTILINE))
self.assertRegex(metadata, re.compile(r"^display_name:\s*ImageStudio$", re.MULTILINE))
self.assertRegex(metadata, re.compile(r'^astrbot_version:\s*["\']>=4\.25\.0,<5["\']$', re.MULTILINE))
def test_postgresql_drivers_are_documented_but_not_forced(self):
requirements = read("requirements.txt")
active_requirements = [
line.strip()
for line in requirements.splitlines()
if line.strip() and not line.lstrip().startswith("#")
]
self.assertEqual(active_requirements, [])
self.assertRegex(requirements, re.compile(r"^# psycopg\[binary\]", re.MULTILINE))
self.assertRegex(requirements, re.compile(r"^# psycopg2-binary", re.MULTILINE))
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,63 +0,0 @@
from __future__ import annotations
import unittest
from backend.routes.event_routes import get_event_stream
from backend.services.event_stream_service import EventStreamService
from core.event_bus import EventBus
from core.identity import RequestContext
class EventRoutesTests(unittest.TestCase):
def setUp(self):
self.event_bus = EventBus()
self.service = EventStreamService(self.event_bus)
self.ctx = RequestContext.from_astrbot(username="admin", user_id="user_001")
def test_event_stream_returns_sse_payload(self):
event = self.event_bus.publish("task.completed", {"task_id": "task_001"})
self.event_bus.publish("workflow.updated", {"workflow_id": "workflow_001"})
response = get_event_stream(self.ctx, {"limit": 10}, self.service)
self.assertTrue(response["ok"])
data = response["data"]
self.assertEqual(data["content_type"], "text/event-stream")
self.assertEqual(data["count"], 2)
self.assertIn("event: task.completed", data["body"])
self.assertEqual(data["events"][0]["event_id"], event.event_id)
def test_event_stream_filters_event_type(self):
self.event_bus.publish("task.completed", {"task_id": "task_001"})
self.event_bus.publish("workflow.updated", {"workflow_id": "workflow_001"})
response = get_event_stream(self.ctx, {"event_type": "workflow.updated"}, self.service)
self.assertTrue(response["ok"])
self.assertEqual(response["data"]["count"], 1)
self.assertEqual(response["data"]["events"][0]["event_type"], "workflow.updated")
def test_event_stream_limit_is_normalized(self):
for index in range(3):
self.event_bus.publish("task.completed", {"task_id": f"task_{index}"})
bad_limit = get_event_stream(self.ctx, {"limit": "bad"}, self.service)
zero_limit = get_event_stream(self.ctx, {"limit": 0}, self.service)
huge_limit = get_event_stream(self.ctx, {"limit": 999}, self.service)
self.assertTrue(bad_limit["ok"])
self.assertEqual(bad_limit["data"]["count"], 3)
self.assertTrue(zero_limit["ok"])
self.assertEqual(zero_limit["data"]["count"], 1)
self.assertTrue(huge_limit["ok"])
self.assertEqual(huge_limit["data"]["count"], 3)
def test_event_stream_requires_authentication(self):
response = get_event_stream(RequestContext(), {}, self.service)
self.assertFalse(response["ok"])
self.assertEqual(response["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,491 +0,0 @@
from __future__ import annotations
import re
import unittest
from pathlib import Path
from backend.route_registry import route_manifest
from database.db_helper import REPO_ROOT
class FrontendApiContractTests(unittest.TestCase):
def test_static_frontend_endpoints_exist_in_backend_registry(self):
endpoint_source = _endpoint_source()
frontend_static = {
match.group("endpoint")
for match in re.finditer(r"\w+:\s*\"(?P<endpoint>[^\"]+)\"", endpoint_source)
if "${" not in match.group("endpoint")
}
backend_endpoints = {route["endpoint"] for route in route_manifest()}
self.assertTrue(frontend_static)
self.assertEqual(sorted(frontend_static - backend_endpoints), [])
def test_dynamic_frontend_endpoints_exist_in_backend_registry(self):
endpoint_source = _endpoint_source()
frontend_dynamic = {
_expand_frontend_template(match.group("template"))
for match in re.finditer(
r"\w+:\s*\((?P<params>[^)]*)\)\s*=>\s*`(?P<template>[^`]+)`",
endpoint_source,
)
}
backend_expanded = {_expand_backend_endpoint(route["endpoint"]) for route in route_manifest()}
self.assertTrue(frontend_dynamic)
self.assertEqual(sorted(frontend_dynamic - backend_expanded), [])
def test_api_client_supports_nested_astrbot_envelopes_and_method_override(self):
source = _frontend_source("shared", "api", "client.ts")
self.assertIn('current.status === "error"', source)
self.assertIn("current = current.data", source)
self.assertIn('const METHOD_OVERRIDE_KEY = "__imagestudio_method"', source)
self.assertIn('const METHOD_OVERRIDE_BODY_KEY = "__imagestudio_body"', source)
self.assertIn('["PUT", "PATCH", "DELETE"].includes(method)', source)
self.assertIn('method === "DELETE" ? {}', source)
self.assertIn('throw new ApiClientError("bridge_method_unavailable"', source)
def test_plugin_page_hosts_the_full_workbench_and_html_shells_are_complete(self):
plugin_app = _frontend_source("plugin-page", "src", "App.vue")
self.assertIn('import WorkbenchApp from "../../standalone-web/src/App.vue"', plugin_app)
self.assertIn("<WorkbenchApp />", plugin_app)
self.assertNotIn("/web", plugin_app)
for project in ("plugin-page", "standalone-web"):
html = _frontend_source(project, "index.html").lower()
self.assertIn("<!doctype html>", html)
self.assertIn('<meta charset="utf-8"', html)
self.assertIn('name="viewport"', html)
def test_workbench_is_split_into_reusable_components_and_feature_modules(self):
source = _frontend_source("standalone-web", "src", "App.vue")
navigation = _frontend_source("standalone-web", "src", "components", "AppNavigationRail.vue")
viewer = _frontend_source("standalone-web", "src", "components", "ImagePreviewDialog.vue")
profile_import = _frontend_source(
"standalone-web", "src", "features", "quick-profile", "profile-import.ts"
)
for component in (
"AppNavigationRail",
"ImagePreviewDialog",
"MaterialCategoryCreateDialog",
"MaterialDetailDialog",
"MaterialOperationDialog",
"MetricCardGrid",
"StateCard",
"EmptyState",
):
self.assertIn(f"<{component}", source)
self.assertIn('aria-current="props.activeKey === item.key ? \'page\' : undefined"', navigation)
self.assertIn('@click.self="close"', viewer)
self.assertIn("export function parseExternalProfileImport", profile_import)
self.assertNotIn("function parseExternalProfileImport", source)
def test_profiles_navigation_renders_the_dedicated_feature_page(self):
source = _frontend_source("standalone-web", "src", "App.vue")
navigation = _frontend_source(
"standalone-web", "src", "features", "navigation", "navigation-config.ts"
)
profiles_branch = _source_between(
source,
'<template v-else-if="activeNav === \'profiles\'">',
'<template v-else-if="activeNav === \'materials\'">',
)
profiles_nav_item = _source_between(
navigation,
'key: "profiles"',
'key: "materials"',
)
self.assertIn('import ProfilesPage from "./features/profiles/ProfilesPage.vue"', source)
self.assertIn("<ProfilesPage", profiles_branch)
self.assertIn('data-module="profiles"', profiles_branch)
self.assertIn('module: "profiles"', profiles_nav_item)
def test_profiles_page_exposes_states_and_primary_actions(self):
page = _frontend_source(
"standalone-web", "src", "features", "profiles", "ProfilesPage.vue"
)
master = _frontend_source(
"standalone-web", "src", "features", "profiles", "ProfileMasterPane.vue"
)
self.assertIn('v-if="loading && !profiles.length"', master)
self.assertIn('v-if="error"', page)
self.assertNotIn('v-else-if="!backendConnected"', page)
self.assertIn('v-if="showBackendConnectionBanner"', _frontend_source("standalone-web", "src", "App.vue"))
self.assertIn('v-else-if="!filteredProfiles.length"', master)
self.assertIn('v-else class="detail-empty"', page)
self.assertIn(':loading="loading"', page)
for event in ("create", "import", "generate", "workflow", "materials"):
self.assertIn(f" {event}: []", page)
self.assertIn(f"emit('{event}')", page)
def test_profiles_list_avoids_workflow_n_plus_one_and_details_load_on_selection(self):
source = _frontend_source("standalone-web", "src", "App.vue")
profile_items = _source_between(
source,
"const previewCharacterProfiles",
"const selectedProfilePage =",
)
profile_loader = _source_between(
source,
"async function loadBackendQuickProfiles",
"async function loadProfilePageDetails",
)
profile_details_loader = _source_between(
source,
"async function loadProfilePageDetails",
"async function resolveProfileAvatar",
)
self.assertIn('source: "sample"', profile_items)
self.assertIn('backendConnection.value.state === "connected"', profile_items)
self.assertIn("? backendProfiles.value : previewCharacterProfiles.value", profile_items)
self.assertIn("getJson<ProfileListResult>(endpoints.profiles", profile_loader)
self.assertIn("loadRemainingProfilePages(firstPage)", profile_loader)
self.assertIn("pageCount - 1", profile_loader)
self.assertNotIn("endpoints.profileWorkflows", profile_loader)
self.assertIn(
"getJson<ProfileWorkflow[]>(endpoints.profileWorkflows(profile.profile_id))",
profile_details_loader,
)
def test_profile_generation_categories_and_text_profile_actions_are_wired(self):
source = _frontend_source("standalone-web", "src", "App.vue")
master = _frontend_source(
"standalone-web", "src", "features", "profiles", "ProfileMasterPane.vue"
)
detail = _frontend_source(
"standalone-web", "src", "features", "profiles", "ProfileDetailPane.vue"
)
profile_ui = _frontend_source(
"standalone-web", "src", "features", "profiles", "profile-ui.ts"
)
generation_actions = _source_between(
source,
"async function startSelectedProfileGeneration",
"function openSelectedProfileWorkspace",
)
questionnaire_save = _source_between(
source,
"async function generateQuickProfileArchiveFromQuestionnaire",
"function buildQuickProfileDraftPayload",
)
continue_action = _source_between(
source,
"async function continueSelectedProfileWorkflow",
"function openSelectedProfileWorkspace",
)
workflow_resource = _source_between(
detail,
"<span>生成工作流</span>",
"</section>\n </div>",
)
for label in ("未生成", "快速角色", "详细角色"):
self.assertIn(label, master)
self.assertIn(label, profile_ui)
self.assertIn('role="group" aria-label="角色分类"', master)
self.assertIn("repeat(4, minmax(0, 1fr))", master)
self.assertIn('emit("select", "")', master)
self.assertIn("profileGenerationKind(profile)", master)
self.assertIn("generationKind === 'ungenerated'", detail)
self.assertIn("生成快速角色", detail)
self.assertIn("创建详细工作流", detail)
self.assertIn('role="group" aria-label="角色详情视图"', detail)
self.assertLess(
detail.index('class="generation-error"'),
detail.index('<div v-if="activeTab === \'overview\'"'),
)
self.assertNotIn("<button", workflow_resource)
self.assertIn('mode === "quick" ? QUICK_CHARACTER_WORKFLOW_TYPE : CHARACTER_WORKFLOW_TYPE', generation_actions)
self.assertIn("ensureCharacterWorkflowForProfile(editorProfile, workflowType)", generation_actions)
self.assertIn("endpoints.workflowExecuteCharacter(workflow.workflow_id)", generation_actions)
self.assertIn('if (profileGenerationKind(profile) === "ungenerated") return []', source)
self.assertIn('if (profile.metadata?.source !== "sample")', source)
self.assertIn("profileGenerationBusyByProfileId", generation_actions)
self.assertIn("nextCharacterWorkflowId(profile.profileId, workflowType, workflows)", source)
self.assertIn('["running", "completed"].includes(normalizeStatus(workflow.status))', generation_actions)
self.assertIn("openProfileWorkspace(profile.profile_id, \"workflow\")", generation_actions)
self.assertIn("invalidateProfileDetailsRequests(profile.profile_id)", generation_actions)
self.assertNotIn("ensureCharacterWorkflowForProfile(profile)", questionnaire_save)
self.assertIn('activeGenerateMode.value = "quickProfile"', questionnaire_save)
self.assertIn('if (source === "quick_profile") return "快速问卷建档"', profile_ui)
self.assertIn("PROFILE_NO_SELECTION_ID", source)
self.assertIn("getJson<ProfileWorkflow[]>(endpoints.profileWorkflows(profile.profile_id))", continue_action)
self.assertIn("needsCreation", continue_action)
self.assertNotIn("backendWriteBlockMessage", continue_action)
def test_profile_wardrobe_uses_real_endpoints_categories_and_confirmed_materials(self):
source = _frontend_source("standalone-web", "src", "App.vue")
detail = _frontend_source(
"standalone-web", "src", "features", "profiles", "ProfileDetailPane.vue"
)
wardrobe = _frontend_source(
"standalone-web", "src", "features", "profiles", "ProfileWardrobePane.vue"
)
wardrobe_loader = _source_between(
source,
"async function loadProfileWardrobe",
"async function hydrateWardrobeMaterials",
)
wardrobe_actions = _source_between(
source,
"function profileWardrobeWriteBlockMessage",
"function openSelectedProfileWorkspace",
)
self.assertIn("ProfileWardrobePane", detail)
self.assertIn("activeTab === 'wardrobe'", detail)
self.assertIn("getJson<WardrobeItem[]>(endpoints.wardrobe(profileId))", wardrobe_loader)
self.assertIn("postJson<WardrobeItem>(endpoints.wardrobeItems(profile.profile_id)", wardrobe_actions)
self.assertIn("material_id: materialId", wardrobe_actions)
self.assertIn("wardrobe_category: category", wardrobe_actions)
self.assertIn("deleteJson<WardrobeItem>(endpoints.wardrobeItem(profile.profile_id, wardrobeItemId))", wardrobe_actions)
self.assertIn('profile.metadata?.source === "sample"', wardrobe_loader)
self.assertIn("bootstrap.value?.feature_flags.wardrobe", wardrobe_loader)
self.assertIn('material.recognition_status.trim().toLowerCase() === "confirmed"', wardrobe)
self.assertIn("!wardrobeMaterialIds.value.has(material.material_id)", wardrobe)
self.assertIn('["top", "bottom", "dress", "shoes", "accessory"]', wardrobe)
self.assertIn("props.permissions?.can_manage_materials", wardrobe)
self.assertNotIn("props.permissions?.can_write &&", wardrobe)
self.assertIn("nextProfileWardrobeRequestGeneration(profileId)", wardrobe_loader)
self.assertIn("isCurrentProfileWardrobeRequest(profileId, requestGeneration)", wardrobe_loader)
self.assertIn("profileWardrobeLoadingByProfileId", source)
self.assertIn("loadRemainingMaterialPages(firstMaterialPage)", source)
self.assertIn("pageCount - 1", source)
self.assertGreaterEqual(
wardrobe_actions.count("invalidateProfileWardrobeRequests(profile.profile_id)"),
4,
)
def test_ui_does_not_present_demo_data_as_connected_backend_data(self):
source = _frontend_source("standalone-web", "src", "App.vue")
model_options = _source_between(source, "const imageModelOptions", "const selectedImageModelOption")
material_cards = _source_between(source, "const rawMaterialLibraryCards", "const activeMaterialCategoryId")
self.assertIn('backendConnection.value.state === "preview"', model_options)
self.assertIn(": []", model_options)
self.assertIn('["preview", "error"].includes(backendConnection.value.state)', material_cards)
self.assertIn("return []", material_cards)
self.assertIn("请先在设置中配置并确认一个生图模型", source)
self.assertIn("尚未配置生图模型", source)
self.assertNotIn("使用本地模型", source)
def test_workbench_keyboard_navigation_and_real_overview_actions_are_wired(self):
source = _frontend_source("standalone-web", "src", "App.vue")
self.assertIn('role="combobox"', source)
self.assertIn('role="listbox"', source)
self.assertIn("moveSearchSelection(1)", source)
self.assertIn('event.key.toLowerCase() === "k"', source)
self.assertIn('aria-current="props.activeKey === item.key ? \'page\' : undefined"', _frontend_source(
"standalone-web", "src", "components", "AppNavigationRail.vue"
))
self.assertIn('@click="openQueueJob(job)"', source)
self.assertIn('@click="retryQueueJob(job)"', source)
self.assertIn("function canRetryQueueJob", source)
self.assertIn("@click=\"setActiveNav('settings', 'settings')\"", source)
self.assertIn("@click=\"setActiveNav('materials', 'images')\"", source)
def test_workflow_details_and_generated_images_use_safe_frontend_contracts(self):
source = _frontend_source("standalone-web", "src", "App.vue")
self.assertIn("getJson<WorkflowDetail>(endpoints.workflow(", source)
self.assertNotIn("getJson<ProfileWorkflow>(endpoints.workflow(", source)
self.assertIn("function isAuthenticGenerationImage", source)
self.assertIn("metadata.mock", source)
self.assertIn('"provider_error"', source)
self.assertIn("images.filter(isAuthenticGenerationImage)", source)
self.assertIn("selectedWorkflowDraftImages.value\n .filter(isAuthenticGenerationImage)", source)
def test_quick_profile_never_submits_sample_material_ids_or_creates_on_selection(self):
source = _frontend_source("standalone-web", "src", "App.vue")
self.assertIn('normalized.startsWith("qp-material-")', source)
self.assertNotIn("material_id: profile.materialId", source)
for selected_ids_expression in re.findall(r"selected_material_ids:\s*([^,\n]+)", source):
self.assertNotIn(".map", selected_ids_expression)
self.assertIn("selectedQuickProfileMaterialIdsForApi", selected_ids_expression)
self.assertIn("if (profile.profileId && profile.workflowId)", source)
self.assertIn("characterWorkflowEnsureRequests", source)
def test_quick_profile_picker_uses_confirmed_backend_materials_and_reports_real_bindings(self):
source = _frontend_source("standalone-web", "src", "App.vue")
self.assertIn("const backendQuickProfileMaterialOptions = computed<QuickProfileMaterialOption[]>", source)
self.assertIn('normalizeStatus(material.recognition_status) === "confirmed"', source)
self.assertIn("function quickProfileMaterialOptionFromBackend", source)
self.assertIn("id: material.material_id", source)
self.assertIn("quickProfileSelectableMaterials.value.filter(", source)
self.assertIn("workflowNodeActionError.value = payload.selected_material_ids.length", source)
self.assertNotIn("workflowNodeActionError.value = selectedQuickProfileMaterials.value.length", source)
def test_created_workflow_link_updates_backend_profile_state(self):
source = _frontend_source("standalone-web", "src", "App.vue")
self.assertIn("function updateQuickProfileWorkflowLink", source)
self.assertIn(
"backendQuickProfileLibraryItems.value = backendQuickProfileLibraryItems.value.map(applyWorkflowLink)",
source,
)
self.assertNotIn("updateLocalQuickProfileWorkflowLink", source)
def test_job_retry_ui_describes_synchronous_execution_contract(self):
source = _frontend_source("standalone-web", "src", "App.vue")
presentation = _frontend_source("shared", "utils", "presentation.ts")
self.assertIn("立即使用原请求创建并执行新任务", source)
self.assertIn('endpoints.jobDeadLetterRetry, { limit: 5 }', source)
self.assertIn('retrying: "重试执行中"', presentation)
self.assertIn('superseded: "已被重试替代"', presentation)
self.assertIn("死信任务已重新执行", source)
self.assertIn('recordString(err.details, "replacement_task_id")', source)
self.assertIn("失败的替代任务", source)
self.assertIn('["completed", "succeeded", "superseded"]', source)
self.assertNotIn('["failed", "dead_letter", "cancelled", "superseded"]', source)
self.assertNotIn("死信任务已重新排队", source)
def test_completed_generation_nodes_can_persist_selection_without_unlocking_generation(self):
source = _frontend_source("standalone-web", "src", "App.vue")
selection_source = _source_between(
source,
"function toggleWorkflowDraftSelection",
"async function submitImageGenerationPrompt",
)
generation_source = _source_between(
source,
"async function runSelectedWorkflowNodeGeneration",
"async function enterWorkflowPersonaSplit",
)
self.assertIn("if (isSelectedWorkflowNodeLocked.value)", selection_source)
self.assertNotIn("if (isSelectedWorkflowNodeWriteLocked.value) return", selection_source)
self.assertIn("endpoints.nodeSelectImage(backendNodeId)", selection_source)
self.assertIn("selected_image_id: selected.image_id", selection_source)
self.assertIn('workflowLockedNodeWriteMessage(options.retry ? "节点重跑" : "节点生成")', generation_source)
self.assertIn(':disabled="isSelectedWorkflowNodeLocked"', source)
def test_daily_cost_uses_real_usage_and_does_not_claim_zero_without_pricing(self):
source = _frontend_source("standalone-web", "src", "App.vue")
endpoint_source = _endpoint_source()
self.assertIn('costUsage: "costs/usage"', endpoint_source)
self.assertIn("getJson<CostUsageSummary>(endpoints.costUsage, { days: 1 })", source)
self.assertIn('"未配置可信价格"', source)
self.assertIn('";不按零成本展示"', source)
self.assertNotIn('label: "今日成本",\n value: "未接入"', source)
def test_material_page_actions_use_real_forms_and_backend_endpoints(self):
source = _frontend_source("standalone-web", "src", "App.vue")
dialog = _frontend_source("standalone-web", "src", "components", "MaterialOperationDialog.vue")
upload_card = _source_between(source, 'id: "upload"', 'id: "create-category"')
asset_pack_card = _source_between(source, 'id: "asset-pack"', 'id: "wardrobe"')
wardrobe_card = _source_between(source, 'id: "wardrobe"', 'id: "workflow-bind"')
self.assertIn('title: "登记素材 URI"', source)
self.assertIn("postJson<Material>(endpoints.materialUpload", source)
self.assertIn("postJson<AssetImportPlan>(endpoints.assetImportPack", source)
self.assertIn("dry_run: true", source)
self.assertIn("dry_run: false", source)
self.assertIn("postJson<WardrobeItem>(endpoints.wardrobeImportMaterial", source)
self.assertNotIn("这个入口需要表单承接", source)
self.assertNotIn("预留入口", source)
self.assertNotIn('uploaded: "已上传"', source)
self.assertIn('uploaded: "URI 已登记"', source)
self.assertNotIn("enabled: false", upload_card)
self.assertNotIn("enabled: false", asset_pack_card)
self.assertNotIn("enabled: false", wardrobe_card)
self.assertIn("不会从浏览器上传文件字节", dialog)
self.assertIn("storage:// URI", dialog)
self.assertIn("dry-run 摘要", dialog)
self.assertIn('emit("executeAssetPack"', dialog)
self.assertIn("wardrobe_category", dialog)
self.assertIn('props.material.recognition_status !== "confirmed"', dialog)
def test_material_operation_dialog_reuses_shared_uri_helpers_and_accessible_close_behavior(self):
dialog = _frontend_source("standalone-web", "src", "components", "MaterialOperationDialog.vue")
presentation = _frontend_source("shared", "utils", "presentation.ts")
storage_uri = _frontend_source("shared", "utils", "storage-uri.ts")
self.assertIn('from "../../../shared/utils/presentation"', dialog)
self.assertIn('from "../../../shared/utils/storage-uri"', dialog)
self.assertNotIn("function formatBytes", dialog)
self.assertNotIn("function isStorageUri", dialog)
self.assertIn("export function formatBytes", presentation)
self.assertIn("export function isStorageUri", storage_uri)
self.assertIn("export function storageFilename", storage_uri)
self.assertIn("export function isSupportedImageStorageUri", storage_uri)
self.assertIn("png|jpe?g|gif|webp", storage_uri)
self.assertIn("PNG、JPG、JPEG、GIF 或 WEBP", dialog)
self.assertIn('@click.self="requestClose"', dialog)
self.assertIn(':aria-busy="busy"', dialog)
self.assertIn('event.key === "Escape"', dialog)
self.assertIn("if (props.busy) return", dialog)
self.assertIn('event.key !== "Tab"', dialog)
self.assertIn("firstInputRef.value?.focus()", dialog)
def test_capability_copy_describes_metadata_only_profiles(self):
source = _frontend_source("standalone-web", "src", "App.vue")
self.assertIn("能力档案", source)
self.assertIn("metadata-only", source)
self.assertNotIn("能力探测", source)
def test_node_retry_posts_generation_payload_once_and_reuses_generate_result_handling(self):
source = _frontend_source("standalone-web", "src", "App.vue")
retry_source = _source_between(
source,
"async function runSelectedWorkflowNodeGeneration",
"async function enterWorkflowPersonaSplit",
)
self.assertIn("const generationPayload = {", retry_source)
self.assertIn("? endpoints.nodeRetry(backendNodeId)", retry_source)
self.assertIn(": endpoints.nodeGenerate(backendNodeId)", retry_source)
self.assertEqual(retry_source.count("postJson<NodeGenerateResult>"), 1)
self.assertIn("hydrateGenerationImages(result.images ?? [])", retry_source)
self.assertNotIn("postJson<WorkflowNode>(endpoints.nodeRetry", retry_source)
def _endpoint_source() -> str:
return (REPO_ROOT / "frontend" / "shared" / "api" / "endpoints.ts").read_text(encoding="utf-8")
def _frontend_source(*relative_parts: str) -> str:
return (REPO_ROOT / "frontend" / Path(*relative_parts)).read_text(encoding="utf-8")
def _source_between(source: str, start: str, end: str) -> str:
return source[source.index(start) : source.index(end)]
def _expand_frontend_template(template: str) -> str:
return re.sub(r"\$\{(?P<param>\w+)\}", lambda match: _sample_value(match.group("param")), template)
def _expand_backend_endpoint(endpoint: str) -> str:
return re.sub(r"\{(?P<param>[^{}]+)\}", lambda match: _sample_value(match.group("param")), endpoint)
def _sample_value(param_name: str) -> str:
normalized = re.sub(r"(?<!^)([A-Z])", r"_\1", param_name).lower()
samples = {
"category_id": "category_sample",
"image_id": "image_sample",
"material_id": "material_sample",
"node_id": "node_sample",
"profile_id": "profile_sample",
"snapshot_id": "snapshot_sample",
"task_id": "task_sample",
"wardrobe_item_id": "wardrobe_item_sample",
"workflow_id": "workflow_sample",
}
return samples.get(normalized, f"{normalized}_sample")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,339 +0,0 @@
from __future__ import annotations
import tempfile
import threading
import unittest
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from backend.dto.common import ApiError, ErrorCode
from backend.routes.job_routes import retry_dead_letter_jobs, retry_job
from backend.services.generation_job_retry_service import (
MAX_SYNCHRONOUS_DEAD_LETTER_RETRIES,
GenerationJobRetryService,
)
from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService
from backend.services.profile_service import ProfileService
from backend.services.queue_service import QueueService
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 core.storage import VfsStorage
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.image_repository import ImageRepository
from database.repositories.job_repository import JobRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
from engines.single_flow import SingleFlowEngine
class GenerationJobRetryServiceTests(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"""
plugin:
name: astrbot_plugin_imagestudio
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.queue_service = QueueService(JobRepository(self.database), self.audit_service)
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(
ImageRepository(self.database),
self.workflow_repository,
self.audit_service,
)
self.generation_service = GenerationService(
workflow_service=self.workflow_service,
queue_service=self.queue_service,
image_service=self.image_service,
single_flow_engine=SingleFlowEngine(
VfsStorage(ConfigService(self.config_path)),
allow_mock_fallback=True,
),
)
self.retry_service = GenerationJobRetryService(self.queue_service, self.generation_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write", "can_retry_tasks"},
)
def tearDown(self):
self.tmp.cleanup()
def test_retry_executes_replacement_and_supersedes_original(self):
original = self._failed_generation_task(status="failed")
response = retry_job(self.ctx, original.task_id, service=self.retry_service)
self.assertTrue(response["ok"])
replacement = response["data"]
self.assertNotEqual(replacement["task_id"], original.task_id)
self.assertEqual(replacement["status"], "succeeded")
self.assertEqual(replacement["metadata"]["retry_lineage"]["retry_of_task_id"], original.task_id)
superseded = self.queue_service.get_job(original.task_id)
self.assertEqual(superseded.status, "superseded")
self.assertEqual(superseded.result["replacement_task_id"], replacement["task_id"])
self.assertEqual(self.queue_service.queue_summary()["pending"], 0)
repeated = retry_job(self.ctx, original.task_id, service=self.retry_service)
self.assertFalse(repeated["ok"])
self.assertEqual(repeated["error_code"], "TASK_NOT_RETRYABLE")
def test_failed_replacement_is_returned_in_error_lineage(self):
original = self._failed_generation_task(status="failed")
service = GenerationJobRetryService(
self.queue_service,
_CreatesFailedReplacement(self.queue_service, self.workflow_service),
)
response = retry_job(self.ctx, original.task_id, service=service)
self.assertFalse(response["ok"])
self.assertEqual(response["error_code"], "GENERATION_FAILED")
replacement_task_id = response["details"]["replacement_task_id"]
self.assertTrue(replacement_task_id.startswith("task_"))
self.assertEqual(response["details"]["retry_lineage"]["replacement_task_id"], replacement_task_id)
replacement = self.queue_service.get_job(replacement_task_id)
self.assertEqual(replacement.status, "failed")
self.assertEqual(replacement.metadata["retry_lineage"]["retry_of_task_id"], original.task_id)
self.assertEqual(self.queue_service.get_job(original.task_id).status, "superseded")
def test_preflight_failure_restores_original_status(self):
original = self._failed_generation_task(status="dead_letter")
service = GenerationJobRetryService(
self.queue_service,
_RejectsBeforeTaskCreation(self.workflow_service),
)
response = retry_job(self.ctx, original.task_id, service=service)
self.assertFalse(response["ok"])
self.assertTrue(response["details"]["original_status_restored"])
self.assertIsNone(response["details"]["replacement_task_id"])
restored = self.queue_service.get_job(original.task_id)
self.assertEqual(restored.status, "dead_letter")
self.assertEqual(restored.metadata["retry_execution"]["status"], "rejected")
def test_cancelled_task_with_matching_active_node_can_retry(self):
original = self._failed_generation_task(status="cancelled", node_status="running")
response = retry_job(self.ctx, original.task_id, service=self.retry_service)
self.assertTrue(response["ok"])
self.assertEqual(response["data"]["status"], "succeeded")
self.assertEqual(self.queue_service.get_job(original.task_id).status, "superseded")
def test_preflight_failure_restores_matching_active_node(self):
original = self._failed_generation_task(status="cancelled", node_status="running")
before_node = self.workflow_service.get_node(str(original.node_id))
service = GenerationJobRetryService(
self.queue_service,
_RejectsBeforeTaskCreation(self.workflow_service),
)
response = retry_job(self.ctx, original.task_id, service=service)
self.assertFalse(response["ok"])
self.assertTrue(response["details"]["original_status_restored"])
self.assertTrue(response["details"]["node_status_restored"])
self.assertEqual(self.queue_service.get_job(original.task_id).status, "cancelled")
after_node = self.workflow_service.get_node(str(original.node_id))
self.assertEqual(after_node.status, "running")
self.assertEqual(after_node.metadata, before_node.metadata)
def test_retry_requires_replacement_for_ephemeral_inline_references(self):
original = self._failed_generation_task(status="failed")
self.queue_service.update_task(
original.task_id,
{
"request": {
**original.request,
"reference_persistence": {"ephemeral_data_urls_omitted": 1},
}
},
self.ctx,
)
rejected = retry_job(self.ctx, original.task_id, service=self.retry_service)
accepted = retry_job(
self.ctx,
original.task_id,
{"input_images": ["https://example.com/replacement.png"]},
service=self.retry_service,
)
self.assertFalse(rejected["ok"])
self.assertEqual(rejected["error_code"], "TASK_NOT_RETRYABLE")
self.assertEqual(rejected["details"]["ephemeral_data_urls_omitted"], 1)
self.assertTrue(accepted["ok"])
def test_retry_claim_is_compare_and_set_under_concurrency(self):
task = self.queue_service.create_task({"status": "failed"}, self.ctx)
barrier = threading.Barrier(2)
def claim(index: int) -> str:
barrier.wait(timeout=2)
try:
return self.queue_service.begin_retry(
task.task_id,
self.ctx,
operation_id=f"op_{index}",
).status
except ApiError as exc:
return exc.error_code.value
with ThreadPoolExecutor(max_workers=2) as executor:
results = list(executor.map(claim, (1, 2)))
self.assertEqual(sorted(results), ["TASK_NOT_RETRYABLE", "retrying"])
self.assertEqual(self.queue_service.get_job(task.task_id).status, "retrying")
def test_dead_letter_retry_is_synchronous_and_capped(self):
tasks = [self._failed_generation_task(status="dead_letter") for _ in range(7)]
service = GenerationJobRetryService(
self.queue_service,
_CompletesReplacement(self.queue_service, self.workflow_service),
)
response = retry_dead_letter_jobs(self.ctx, {"limit": 50}, service)
self.assertTrue(response["ok"])
data = response["data"]
self.assertEqual(data["execution_mode"], "synchronous")
self.assertEqual(data["applied_limit"], MAX_SYNCHRONOUS_DEAD_LETTER_RETRIES)
self.assertEqual(data["processed"], MAX_SYNCHRONOUS_DEAD_LETTER_RETRIES)
self.assertEqual(data["total"], MAX_SYNCHRONOUS_DEAD_LETTER_RETRIES)
self.assertEqual(data["remaining"], len(tasks) - MAX_SYNCHRONOUS_DEAD_LETTER_RETRIES)
statuses = [self.queue_service.get_job(task.task_id).status for task in tasks]
self.assertEqual(statuses.count("superseded"), MAX_SYNCHRONOUS_DEAD_LETTER_RETRIES)
self.assertEqual(statuses.count("dead_letter"), len(tasks) - MAX_SYNCHRONOUS_DEAD_LETTER_RETRIES)
def _failed_generation_task(self, *, status: str, node_status: str = "failed"):
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": "Retry"},
self.ctx,
)
node = workflow.nodes[0]
task = self.queue_service.create_task(
{
"profile_id": profile.profile_id,
"workflow_id": workflow.workflow.workflow_id,
"node_id": node.node_id,
"status": status,
"model_route": "image_low",
"request": {"prompt_patch": "retry portrait", "model_route": "image_low"},
"error_message": "provider outage",
},
self.ctx,
)
if node_status == "running":
queued = self.workflow_service.update_node(
node.node_id,
{"status": "queued", "metadata": {**node.metadata, "last_task_id": task.task_id}},
self.ctx,
)
self.workflow_service.update_node(
node.node_id,
{"status": "running", "metadata": queued.metadata},
self.ctx,
)
else:
self.workflow_service.update_node(
node.node_id,
{"status": node_status, "metadata": {**node.metadata, "last_task_id": task.task_id}},
self.ctx,
)
return task
class _CompletesReplacement:
def __init__(self, queue_service: QueueService, workflow_service: WorkflowService):
self.queue_service = queue_service
self.workflow_service = workflow_service
def generate_node(self, node_id: str, request: dict, ctx: RequestContext) -> dict:
node = self.workflow_service.get_node(node_id)
workflow = self.workflow_service.get_workflow(node.workflow_id).workflow
task = self.queue_service.create_task(
{
"profile_id": workflow.profile_id,
"workflow_id": workflow.workflow_id,
"node_id": node_id,
"status": "succeeded",
"idempotency_key": request["idempotency_key"],
"request": request,
"progress": 100,
},
ctx,
)
return {"task_id": task.task_id, "task_status": task.status}
class _CreatesFailedReplacement(_CompletesReplacement):
def generate_node(self, node_id: str, request: dict, ctx: RequestContext) -> dict:
node = self.workflow_service.get_node(node_id)
workflow = self.workflow_service.get_workflow(node.workflow_id).workflow
task = self.queue_service.create_task(
{
"profile_id": workflow.profile_id,
"workflow_id": workflow.workflow_id,
"node_id": node_id,
"status": "failed",
"idempotency_key": request["idempotency_key"],
"request": request,
"error_message": "provider still unavailable",
},
ctx,
)
raise ApiError(
ErrorCode.GENERATION_FAILED,
"replacement generation failed",
{"provider_error": "temporary outage", "created_task_id": task.task_id},
)
class _RejectsBeforeTaskCreation:
def __init__(self, workflow_service: WorkflowService):
self.workflow_service = workflow_service
def generate_node(self, node_id: str, request: dict, ctx: RequestContext) -> dict:
raise ApiError(
ErrorCode.MODEL_CAPABILITY_UNCONFIRMED,
"model route is unavailable",
{"node_id": node_id},
)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,262 +0,0 @@
from __future__ import annotations
import shutil
import unittest
from pathlib import Path
from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.routes.history_routes import adopt_node_image, list_workflow_history, save_workflow_history
from backend.services.history_service import HistoryService
from backend.services.image_service import ImageService
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 HistoryServiceTests(unittest.TestCase):
def setUp(self):
self.tmp_path = Path(".tmp") / f"test_history_service_{uuid4().hex}"
self.tmp_path.mkdir(parents=True, exist_ok=False)
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(self.tmp_path / "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.history_service = HistoryService(
workflow_repository=self.workflow_repository,
workflow_service=self.workflow_service,
image_service=self.image_service,
audit_service=self.audit_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)
self.workflow = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_gradual", "display_name": "Character"},
self.ctx,
)
self.node = self.workflow.nodes[1]
self.image = self.image_service.create_image(
{
"node_id": self.node.node_id,
"image_uri": "storage://images/headshot.png",
"thumbnail_uri": "storage://thumbnails/headshot.png",
"positive_prompt": "headshot, silver hair",
},
self.ctx,
)
def tearDown(self):
shutil.rmtree(self.tmp_path, ignore_errors=True)
def test_adopt_node_image_writes_history_and_selects_image(self):
history = self.history_service.adopt_node_image(
self.node.node_id,
{"image_id": self.image.image_id, "title": "Accepted headshot"},
self.ctx,
)
self.assertTrue(history.history_id.startswith("hist_"))
self.assertEqual(history.action, "adopt_image")
self.assertEqual(history.image_id, self.image.image_id)
self.assertEqual(history.prompt, "headshot, silver hair")
self.assertEqual(history.title, "Accepted headshot")
selected = self.image_service.get_image(self.image.image_id)
node = self.workflow_service.get_node(self.node.node_id)
self.assertTrue(selected.is_selected)
self.assertEqual(node.status, "selected")
self.assertEqual(node.selected_image_id, self.image.image_id)
listed = self.history_service.list_workflow_history(self.workflow.workflow.workflow_id)
self.assertEqual([entry.history_id for entry in listed], [history.history_id])
def test_adopt_node_image_can_finalize_completed_node(self):
self.workflow_service.update_node(self.node.node_id, {"status": "completed"}, self.ctx)
history = self.history_service.adopt_node_image(
self.node.node_id,
{"image_id": self.image.image_id, "title": "Finalized headshot"},
self.ctx,
)
node = self.workflow_service.get_node(self.node.node_id)
selected = self.image_service.get_image(self.image.image_id)
self.assertEqual(history.action, "adopt_image")
self.assertEqual(node.status, "selected")
self.assertEqual(node.selected_image_id, self.image.image_id)
self.assertTrue(selected.is_selected)
def test_adopt_node_image_persists_stage_handoff_bucket(self):
next_node = self.workflow.nodes[2]
history = self.history_service.adopt_node_image(
self.node.node_id,
{
"image_id": self.image.image_id,
"metadata": {
"source": "standalone_web_stage_review_confirm",
"ui_review_node_id": "portrait-review",
"source_ui_node_id": "portrait-03",
"next_ui_node_id": "hires-fix",
"next_backend_node_id": next_node.node_id,
"handoff_bucket": "hires-fix",
"handoff_role": "hires_fix_input",
},
},
self.ctx,
)
workflow = self.workflow_service.get_workflow(self.workflow.workflow.workflow_id).workflow
stage_input = workflow.metadata["stage_inputs"][next_node.node_id]
self.assertEqual(workflow.current_node_id, next_node.node_id)
self.assertEqual(workflow.metadata["stage_input_schema_version"], "2026-07-09.stage-input-bucket.v1")
self.assertEqual(stage_input["image_id"], self.image.image_id)
self.assertEqual(stage_input["image_uri"], "storage://images/headshot.png")
self.assertEqual(stage_input["from_node_id"], self.node.node_id)
self.assertEqual(stage_input["history_id"], history.history_id)
self.assertEqual(stage_input["role"], "hires_fix_input")
self.assertTrue(stage_input["locked_source_node"])
def test_adopt_node_image_rejects_switching_selected_node_without_branch(self):
self.history_service.adopt_node_image(self.node.node_id, {"image_id": self.image.image_id}, self.ctx)
other = self.image_service.create_image(
{
"node_id": self.node.node_id,
"image_uri": "storage://images/other-headshot.png",
"positive_prompt": "alternate headshot",
},
self.ctx,
)
with self.assertRaises(ApiError) as raised:
self.history_service.adopt_node_image(self.node.node_id, {"image_id": other.image_id}, self.ctx)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
self.assertEqual(raised.exception.details["suggested_action"], "create_branch")
def test_history_routes_wrap_responses_and_require_permissions(self):
response = adopt_node_image(
self.ctx,
self.node.node_id,
{"image_id": self.image.image_id},
self.history_service,
)
self.assertTrue(response["ok"])
workflow_id = self.workflow.workflow.workflow_id
listed = list_workflow_history(self.ctx, workflow_id, {}, self.history_service)
self.assertTrue(listed["ok"])
self.assertEqual(len(listed["data"]), 1)
snapshot = save_workflow_history(
self.ctx,
workflow_id,
{"title": "Manual snapshot", "include_nodes": True},
self.history_service,
)
self.assertTrue(snapshot["ok"])
self.assertEqual(snapshot["data"]["action"], "save_version")
self.assertEqual(snapshot["data"]["title"], "Manual snapshot")
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = adopt_node_image(
read_only,
self.node.node_id,
{"image_id": self.image.image_id},
self.history_service,
)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
def test_save_snapshot_rejects_missing_image_before_foreign_key_insert(self):
with self.assertRaises(ApiError) as raised:
self.history_service.save_workflow_snapshot(
self.workflow.workflow.workflow_id,
{"image_id": "img_missing"},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.RESOURCE_NOT_FOUND)
self.assertEqual(raised.exception.details["image_id"], "img_missing")
self.assertEqual(
self.history_service.list_workflow_history(self.workflow.workflow.workflow_id),
[],
)
def test_save_snapshot_rejects_image_from_another_workflow(self):
other_workflow = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "single_image", "display_name": "Other"},
self.ctx,
)
other_image = self.image_service.create_image(
{
"node_id": other_workflow.nodes[0].node_id,
"image_uri": "storage://images/other-workflow.png",
},
self.ctx,
)
with self.assertRaises(ApiError) as raised:
self.history_service.save_workflow_snapshot(
self.workflow.workflow.workflow_id,
{"image_id": other_image.image_id},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
self.assertEqual(raised.exception.details["image_id"], other_image.image_id)
self.assertEqual(raised.exception.details["image_workflow_id"], other_workflow.workflow.workflow_id)
def test_save_snapshot_rejects_image_from_another_node(self):
other_node = self.workflow.nodes[2]
with self.assertRaises(ApiError) as raised:
self.history_service.save_workflow_snapshot(
self.workflow.workflow.workflow_id,
{"node_id": other_node.node_id, "image_id": self.image.image_id},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
self.assertEqual(raised.exception.details["node_id"], other_node.node_id)
self.assertEqual(raised.exception.details["image_id"], self.image.image_id)
def test_save_snapshot_accepts_image_from_matching_workflow_and_node(self):
history = self.history_service.save_workflow_snapshot(
self.workflow.workflow.workflow_id,
{"node_id": self.node.node_id, "image_id": self.image.image_id},
self.ctx,
)
self.assertEqual(history.node_id, self.node.node_id)
self.assertEqual(history.image_id, self.image.image_id)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,225 +0,0 @@
from __future__ import annotations
import base64
import json
import unittest
import zlib
from unittest.mock import patch
from engines.image_provider import (
MAX_PROVIDER_JSON_HARD_BYTES,
ImageGenerationRequest,
ImageProviderConfig,
ImageProviderError,
MockImageProvider,
OpenAIImageProvider,
_provider_json_limit,
)
from engines.single_flow import _image_bytes
ONE_PIXEL_PNG = base64.b64decode(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII="
)
def _png_with_text_payload(size: int) -> bytes:
data = b"note\x00" + (b"x" * size)
chunk_type = b"tEXt"
chunk = (
len(data).to_bytes(4, "big")
+ chunk_type
+ data
+ (zlib.crc32(chunk_type + data) & 0xFFFFFFFF).to_bytes(4, "big")
)
return ONE_PIXEL_PNG[:-12] + chunk + ONE_PIXEL_PNG[-12:]
class ImageProviderTests(unittest.TestCase):
def test_openai_image_provider_normalizes_generation_response(self):
calls = []
def transport(url, payload, headers, timeout):
calls.append((url, payload, headers, timeout))
return {
"created": 1783268032,
"data": [
{
"b64_json": "aW1hZ2U=",
"url": "https://example.test/image.png",
"revised_prompt": "red dot",
}
],
"usage": {"total_tokens": 12},
}
provider = OpenAIImageProvider(
ImageProviderConfig(
provider_id="site_b",
base_url="https://botcf.com",
api_key="secret",
image_model="image2",
timeout_seconds=180,
),
transport=transport,
)
result = provider.generate_image(
ImageGenerationRequest(
prompt="red dot",
negative_prompt="blur, watermark",
input_images=("https://example.test/input.jpg",),
)
)
self.assertTrue(result.has_images)
self.assertEqual(result.provider_id, "site_b")
self.assertEqual(result.model, "image2")
self.assertEqual(result.usage["total_tokens"], 12)
self.assertEqual(result.images[0].b64_json, "aW1hZ2U=")
self.assertEqual(result.images[0].url, "https://example.test/image.png")
self.assertEqual(calls[0][0], "https://botcf.com/v1/images/generations")
self.assertEqual(calls[0][1]["model"], "image2")
self.assertEqual(calls[0][1]["image"], ["https://example.test/input.jpg"])
self.assertEqual(calls[0][1]["negative_prompt"], "blur, watermark")
self.assertEqual(calls[0][1]["response_format"], "b64_json")
self.assertEqual(calls[0][3], 180)
self.assertEqual(result.raw_metadata["provider_base_url"], "https://botcf.com")
def test_provider_requires_model(self):
provider = OpenAIImageProvider(ImageProviderConfig(provider_id="missing", base_url="https://example.test"))
with self.assertRaises(ImageProviderError) as raised:
provider.generate_image(ImageGenerationRequest(prompt="red dot"))
self.assertEqual(raised.exception.error_type, "configuration_error")
def test_provider_omits_authorization_header_for_no_auth_local_backend(self):
calls = []
def transport(url, payload, headers, timeout):
calls.append(headers)
return {"data": [{"b64_json": "aW1hZ2U="}]}
provider = OpenAIImageProvider(
ImageProviderConfig(
provider_id="local",
base_url="http://127.0.0.1:8080",
image_model="local-image",
),
transport=transport,
)
provider.generate_image(ImageGenerationRequest(prompt="red dot"))
self.assertNotIn("Authorization", calls[0])
def test_provider_can_explicitly_disable_negative_prompt_for_strict_endpoints(self):
calls = []
def transport(url, payload, headers, timeout):
calls.append(payload)
return {"data": [{"b64_json": "aW1hZ2U="}]}
provider = OpenAIImageProvider(
ImageProviderConfig(
provider_id="strict-openai",
base_url="https://api.openai.com",
image_model="gpt-image-1",
supports_negative_prompt=False,
),
transport=transport,
)
provider.generate_image(
ImageGenerationRequest(prompt="red dot", negative_prompt="blur, watermark")
)
self.assertNotIn("negative_prompt", calls[0])
def test_provider_relabels_transport_errors_with_configured_provider(self):
def transport(url, payload, headers, timeout):
raise ImageProviderError(
"remote unauthorized",
provider_id="unknown",
status_code=401,
error_type="http_error",
details={"body_preview": "invalid credentials"},
)
provider = OpenAIImageProvider(
ImageProviderConfig(
provider_id="site_b",
base_url="https://botcf.com",
api_key="secret",
image_model="image2",
),
transport=transport,
)
with self.assertRaises(ImageProviderError) as raised:
provider.generate_image(ImageGenerationRequest(prompt="red dot"))
self.assertEqual(raised.exception.provider_id, "site_b")
self.assertEqual(raised.exception.status_code, 401)
self.assertEqual(raised.exception.error_type, "http_error")
def test_default_transport_accepts_legal_base64_json_responses_over_four_mib(self):
provider = OpenAIImageProvider(
ImageProviderConfig(
provider_id="large",
base_url="https://example.test",
image_model="large-image",
)
)
cases = (
(1, [_png_with_text_payload(3 * 1024 * 1024)]),
(
2,
[
_png_with_text_payload(1600 * 1024),
_png_with_text_payload(1600 * 1024),
],
),
)
for count, image_bodies in cases:
with self.subTest(count=count):
response_body = json.dumps(
{
"data": [
{"b64_json": base64.b64encode(body).decode("ascii")}
for body in image_bodies
]
},
separators=(",", ":"),
).encode("utf-8")
self.assertGreater(len(response_body), 4 * 1024 * 1024)
with patch(
"engines.image_provider.read_http_response_limited",
return_value=response_body,
) as fetch:
result = provider.generate_image(
ImageGenerationRequest(prompt="large response", count=count)
)
response_limit = fetch.call_args.kwargs["max_bytes"]
self.assertGreaterEqual(response_limit, len(response_body))
self.assertLessEqual(response_limit, MAX_PROVIDER_JSON_HARD_BYTES)
self.assertEqual(len(result.images), count)
for parsed, expected in zip(result.images, image_bodies):
self.assertEqual(_image_bytes(parsed.b64_json, None, provider_id="large"), expected)
def test_provider_json_limit_scales_by_count_and_keeps_aggregate_hard_cap(self):
self.assertGreater(_provider_json_limit(2), _provider_json_limit(1))
self.assertEqual(_provider_json_limit(8), MAX_PROVIDER_JSON_HARD_BYTES)
self.assertEqual(_provider_json_limit(999), MAX_PROVIDER_JSON_HARD_BYTES)
def test_mock_provider_returns_image_payload(self):
result = MockImageProvider().generate_image(ImageGenerationRequest(prompt="red dot", model="mock"))
self.assertTrue(result.has_images)
self.assertEqual(result.images[0].revised_prompt, "red dot")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,199 +0,0 @@
from __future__ import annotations
import shutil
import unittest
from pathlib import Path
from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.services.image_service import ImageService
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 ImageServiceTests(unittest.TestCase):
def setUp(self):
self.tmp_path = Path(".tmp") / f"test_image_service_{uuid4().hex}"
self.tmp_path.mkdir(parents=True, exist_ok=False)
db_path = self.tmp_path / "imagestudio.db"
self.database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(db_path))))
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(
repository=self.profile_repository,
audit_service=self.audit_service,
)
self.workflow_service = WorkflowService(
workflow_repository=self.workflow_repository,
profile_repository=self.profile_repository,
audit_service=self.audit_service,
)
self.image_service = ImageService(
image_repository=self.image_repository,
workflow_repository=self.workflow_repository,
audit_service=self.audit_service,
)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
self.profile = self.profile_service.create_profile({"name": "莉娅"}, self.ctx)
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "single_image",
"display_name": "单图流",
},
self.ctx,
)
self.workflow = detail.workflow
self.node = detail.nodes[0]
def tearDown(self):
shutil.rmtree(self.tmp_path, ignore_errors=True)
def test_create_image_inherits_profile_and_workflow_from_node(self):
image = self.image_service.create_image(
{
"node_id": self.node.node_id,
"image_uri": "storage://images/2026/07/04/img_001.png",
"thumbnail_uri": "storage://thumbnails/2026/07/04/img_001.webp",
"positive_prompt": "masterpiece, 1girl",
"negative_prompt": "bad hands",
"model_used": "model_x",
"seed": 123,
"width": 1024,
"height": 1536,
"metadata": {"candidate": 1},
},
self.ctx,
)
self.assertTrue(image.image_id.startswith("img_"))
self.assertEqual(image.profile_id, self.profile.profile_id)
self.assertEqual(image.workflow_id, self.workflow.workflow_id)
self.assertEqual(image.node_id, self.node.node_id)
self.assertEqual(image.metadata, {"candidate": 1})
def test_create_image_rejects_non_vfs_uri(self):
with self.assertRaises(ApiError) as raised:
self.image_service.create_image(
{
"node_id": self.node.node_id,
"image_uri": "C:/real/path/image.png",
},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
def test_list_by_node_excludes_archived_images(self):
kept = self._create_image("storage://images/kept.png")
archived = self._create_image("storage://images/archived.png")
self.image_service.archive_image(archived.image_id, self.ctx)
visible = self.image_service.list_by_node(self.node.node_id)
all_images = self.image_service.list_by_node(self.node.node_id, include_archived=True)
self.assertEqual([image.image_id for image in visible], [kept.image_id])
self.assertEqual({image.image_id for image in all_images}, {kept.image_id, archived.image_id})
def test_select_image_is_exclusive_within_node(self):
first = self._create_image("storage://images/first.png")
second = self._create_image("storage://images/second.png")
self.image_service.select_image(first.image_id, self.ctx)
selected = self.image_service.select_image(second.image_id, self.ctx)
first_after = self.image_service.get_image(first.image_id)
node_after = self.workflow_repository.get_node(self.node.node_id)
self.assertTrue(selected.is_selected)
self.assertFalse(first_after.is_selected)
self.assertEqual(node_after.selected_image_id, second.image_id)
def test_unselect_image_clears_node_selected_image_id(self):
image = self._create_image("storage://images/selected.png")
self.image_service.select_image(image.image_id, self.ctx)
unselected = self.image_service.unselect_image(image.image_id, self.ctx)
node_after = self.workflow_repository.get_node(self.node.node_id)
self.assertFalse(unselected.is_selected)
self.assertIsNone(node_after.selected_image_id)
def test_completed_node_allows_candidate_curation_until_adopted(self):
first = self._create_image("storage://images/first-completed.png")
second = self._create_image("storage://images/second-completed.png")
self.workflow_service.update_node(self.node.node_id, {"status": "completed"}, self.ctx)
selected = self.image_service.select_image(second.image_id, self.ctx)
archived = self.image_service.archive_image(first.image_id, self.ctx)
self.assertTrue(selected.is_selected)
self.assertTrue(archived.is_archived)
def test_select_image_rejects_formally_adopted_node(self):
image = self._create_image("storage://images/locked.png")
self.workflow_service.update_node(self.node.node_id, {"status": "completed"}, self.ctx)
self.workflow_service.update_node(
self.node.node_id,
{"status": "selected", "selected_image_id": image.image_id},
self.ctx,
allow_locked_adoption=True,
)
with self.assertRaises(ApiError) as raised:
self.image_service.select_image(image.image_id, self.ctx)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
self.assertEqual(raised.exception.details["suggested_action"], "create_branch")
def test_delete_image_metadata_removes_record_and_writes_audit(self):
image = self._create_image("storage://images/delete.png")
deleted = self.image_service.delete_image_metadata(image.image_id, self.ctx)
self.assertEqual(deleted.image_id, image.image_id)
with self.assertRaises(ApiError):
self.image_service.get_image(image.image_id)
conn = self.database.connect()
try:
audit = conn.execute(
"""
SELECT action, target_type
FROM audit_logs
WHERE target_id = ? AND action = 'delete_image'
""",
(image.image_id,),
).fetchone()
finally:
conn.close()
self.assertIsNotNone(audit)
self.assertEqual(audit["target_type"], "generation_image")
def _create_image(self, image_uri: str):
return self.image_service.create_image(
{
"node_id": self.node.node_id,
"image_uri": image_uri,
"positive_prompt": "prompt",
},
self.ctx,
)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,236 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.dto.common import ErrorCode
from backend.routes.integration_routes import list_integration_logs, private_companion_daily_outfit
from backend.services.integration_service import IntegrationService
from backend.services.integration_token_service import IntegrationTokenService
from backend.services.material_service import MaterialService
from backend.services.profile_service import ProfileService
from backend.services.wardrobe_service import WardrobeService
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.integration_repository import IntegrationRepository
from database.repositories.material_repository import MaterialRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.wardrobe_repository import WardrobeRepository
class IntegrationServiceTests(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.material_repository = MaterialRepository(self.database)
self.wardrobe_repository = WardrobeRepository(self.database)
self.integration_repository = IntegrationRepository(self.database)
self.profile_service = ProfileService(self.profile_repository, self.audit_service)
self.material_service = MaterialService(self.material_repository, self.audit_service)
self.wardrobe_service = WardrobeService(
self.wardrobe_repository,
self.profile_repository,
self.material_repository,
self.audit_service,
)
self.integration_service = IntegrationService(self.wardrobe_service, self.integration_repository)
self.ctx = RequestContext.from_astrbot(
username="companion",
user_id="companion_001",
permissions={"can_manage_materials"},
)
self.profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx)
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
material = self.material_service.create_material(
{
"category_id": category.category_id,
"display_name": "White blouse",
"image_uri": "storage://materials/white_blouse.png",
"prompt": "white blouse, clean collar",
"tags": ["white", "top"],
"recognition_status": "confirmed",
},
self.ctx,
)
self.wardrobe_service.import_material(
self.profile.profile_id,
{"material_id": material.material_id, "wardrobe_category": "top"},
self.ctx,
)
def tearDown(self):
self.tmp.cleanup()
def test_daily_outfit_uses_wardrobe_match_and_records_log(self):
response = self.integration_service.daily_outfit(
{
"profile_id": self.profile.profile_id,
"mood": "relaxed",
"weather": "sunny",
"keywords": ["top"],
"request_source": "astrbot_plugin_private_companion",
},
self.ctx,
)
self.assertTrue(response["matched"])
self.assertIn("white blouse", response["final_prompt"])
logs = self.integration_service.list_integration_logs("astrbot_plugin_private_companion")
self.assertEqual(len(logs), 1)
self.assertEqual(logs[0]["action"], "daily_outfit")
def test_daily_outfit_fallback_when_no_materials_match(self):
response = self.integration_service.daily_outfit(
{
"profile_id": self.profile.profile_id,
"mood": "formal",
"weather": "rainy",
"categories": ["shoes"],
},
self.ctx,
)
self.assertFalse(response["matched"])
self.assertTrue(response["fallback_used"])
self.assertFalse(response["fallback_supplement_used"])
self.assertEqual(response["fallback_reason"], "no_matching_materials")
self.assertEqual(response["fallback_strategy"]["name"], "random_prompt_generation")
self.assertIn("formal", response["final_prompt"])
def test_daily_outfit_supplements_missing_categories(self):
response = self.integration_service.daily_outfit(
{
"profile_id": self.profile.profile_id,
"categories": ["top", "shoes"],
"keywords": ["casual"],
},
self.ctx,
)
self.assertTrue(response["matched"])
self.assertFalse(response["fallback_used"])
self.assertTrue(response["fallback_supplement_used"])
self.assertEqual(response["fallback_reason"], "missing_categories")
self.assertIn("white blouse", response["final_prompt"])
self.assertIn("matching shoes", response["final_prompt"])
def test_daily_outfit_requires_configured_token_and_redacts_logs(self):
token_config = self.tmp.name and Path(self.tmp.name) / "token_config.yaml"
token_config.write_text(
"""
security:
allowed_integration_plugins:
- astrbot_plugin_private_companion
""",
encoding="utf-8",
)
token_service = IntegrationTokenService(ConfigService(token_config))
token_service.rotate({"token": "daily-token-value"}, self.ctx)
service = IntegrationService(self.wardrobe_service, self.integration_repository, token_service)
with self.assertRaises(Exception):
service.daily_outfit(
{
"profile_id": self.profile.profile_id,
"categories": ["top"],
"integration_token": "wrong-token-value",
},
self.ctx,
)
failed_logs = service.list_integration_logs(status="failed")
self.assertEqual(failed_logs[0]["response"]["error_code"], "INTEGRATION_TOKEN_INVALID")
self.assertEqual(failed_logs[0]["request"]["integration_token"], "***MASKED***")
response = service.daily_outfit(
{
"profile_id": self.profile.profile_id,
"categories": ["top"],
"integration_token": "daily-token-value",
},
self.ctx,
)
self.assertTrue(response["matched"])
succeeded_logs = service.list_integration_logs(status="succeeded")
self.assertEqual(succeeded_logs[0]["request"]["integration_token"], "***MASKED***")
def test_integration_routes_wrap_responses(self):
response = private_companion_daily_outfit(
self.ctx,
{"profile_id": self.profile.profile_id, "keywords": ["top"]},
self.integration_service,
)
self.assertTrue(response["ok"])
self.assertTrue(response["data"]["matched"])
logs = list_integration_logs(self.ctx, {}, self.integration_service)
self.assertTrue(logs["ok"])
self.assertEqual(len(logs["data"]), 1)
bad_source = private_companion_daily_outfit(
self.ctx,
{"profile_id": self.profile.profile_id, "request_source": "unknown_plugin"},
self.integration_service,
)
self.assertFalse(bad_source["ok"])
self.assertEqual(bad_source["error_code"], "INTEGRATION_TOKEN_INVALID")
failed_logs = list_integration_logs(
self.ctx,
{"integration_name": "unknown_plugin", "status": "failed"},
self.integration_service,
)
self.assertTrue(failed_logs["ok"])
self.assertEqual(len(failed_logs["data"]), 1)
self.assertEqual(failed_logs["data"][0]["response"]["error_code"], "INTEGRATION_TOKEN_INVALID")
def test_daily_outfit_validation_failure_records_failed_log(self):
with self.assertRaises(Exception):
self.integration_service.daily_outfit({"keywords": ["top"]}, self.ctx)
logs = self.integration_service.list_integration_logs(status="failed")
self.assertEqual(len(logs), 1)
self.assertEqual(logs[0]["action"], "daily_outfit")
self.assertEqual(logs[0]["response"]["error_code"], "VALIDATION_FAILED")
def test_daily_outfit_rejects_calls_when_integration_is_disabled(self):
service = IntegrationService(
self.wardrobe_service,
self.integration_repository,
enabled=False,
)
with self.assertRaises(Exception) as raised:
service.daily_outfit({"profile_id": self.profile.profile_id}, self.ctx)
self.assertEqual(raised.exception.error_code, ErrorCode.FORBIDDEN)
logs = service.list_integration_logs(status="failed")
self.assertEqual(logs[0]["response"]["error_code"], "FORBIDDEN")
def test_integration_log_limit_is_normalized(self):
for index in range(3):
self.integration_repository.record(
{
"integration_log_id": f"log_{index}",
"integration_name": "manual",
"action": "sync",
"status": "succeeded",
}
)
self.assertEqual(len(self.integration_repository.list(limit=0)), 1)
self.assertEqual(len(self.integration_repository.list(limit=-10)), 1)
self.assertEqual(len(self.integration_repository.list(limit=999)), 3)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,100 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.dto.common import ApiError, ErrorCode
from backend.routes.integration_routes import get_private_companion_token_status, rotate_private_companion_token
from backend.services.integration_token_service import IntegrationTokenService
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
class IntegrationTokenServiceTests(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(
"""
security:
allowed_integration_plugins:
- astrbot_plugin_private_companion
""",
encoding="utf-8",
)
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db")))
)
self.database.initialize()
self.audit_service = AuditService(self.database)
self.service = IntegrationTokenService(ConfigService(self.config_path), audit_service=self.audit_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_manage_config"},
)
def tearDown(self):
self.tmp.cleanup()
def test_rotate_hashes_token_and_accepts_previous_during_grace(self):
first = self.service.rotate({"token": "first-token-value", "grace_seconds": 3600}, self.ctx)
second = self.service.rotate({"token": "second-token-value", "grace_seconds": 3600}, self.ctx)
self.assertEqual(first["token"], "first-token-value")
self.assertEqual(second["token_preview"], "seco...alue")
self.assertTrue(self.service.status()["integration_token_set"])
self.assertTrue(self.service.status()["previous_token_set"])
self.assertEqual(
self.service.verify("astrbot_plugin_private_companion", "second-token-value")["token_slot"],
"current",
)
self.assertEqual(
self.service.verify("astrbot_plugin_private_companion", "first-token-value")["token_slot"],
"previous",
)
config_text = self.config_path.read_text(encoding="utf-8")
self.assertNotIn("first-token-value", config_text)
self.assertNotIn("second-token-value", config_text)
def test_verify_rejects_missing_or_bad_token_when_configured(self):
self.service.rotate({"token": "first-token-value"}, self.ctx)
for token in (None, "bad-token-value"):
with self.assertRaises(ApiError) as raised:
self.service.verify("astrbot_plugin_private_companion", token)
self.assertEqual(raised.exception.error_code, ErrorCode.INTEGRATION_TOKEN_INVALID)
def test_verify_rejects_requests_until_token_is_configured(self):
self.assertFalse(self.service.status()["integration_token_set"])
with self.assertRaises(ApiError) as raised:
self.service.verify("astrbot_plugin_private_companion", None)
self.assertEqual(raised.exception.error_code, ErrorCode.INTEGRATION_TOKEN_INVALID)
self.assertFalse(raised.exception.details["token_configured"])
def test_token_routes_require_config_permission_and_return_token_once(self):
rotated = rotate_private_companion_token(
self.ctx,
{"token": "route-token-value"},
self.service,
)
self.assertTrue(rotated["ok"])
self.assertEqual(rotated["data"]["token"], "route-token-value")
self.assertTrue(rotated["data"]["status"]["integration_token_set"])
status = get_private_companion_token_status(self.ctx, self.service)
self.assertTrue(status["ok"])
self.assertNotIn("route-token-value", str(status["data"]))
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = rotate_private_companion_token(read_only, {"token": "another-token-value"}, self.service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,168 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.log_routes import (
get_audit_logs,
get_error_logs,
get_generation_logs,
get_integration_logs,
get_workflow_logs,
)
from backend.services.history_service import HistoryService
from backend.services.image_service import ImageService
from backend.services.integration_service import IntegrationService
from backend.services.log_service import LogService
from backend.services.material_service import MaterialService
from backend.services.profile_service import ProfileService
from backend.services.queue_service import QueueService
from backend.services.wardrobe_service import WardrobeService
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.integration_repository import IntegrationRepository
from database.repositories.job_repository import JobRepository
from database.repositories.material_repository import MaterialRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.wardrobe_repository import WardrobeRepository
from database.repositories.workflow_repository import WorkflowRepository
class LogRoutesTests(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.material_repository = MaterialRepository(self.database)
self.wardrobe_repository = WardrobeRepository(self.database)
self.integration_repository = IntegrationRepository(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.queue_service = QueueService(JobRepository(self.database), self.audit_service)
self.history_service = HistoryService(
self.workflow_repository,
self.workflow_service,
self.image_service,
self.audit_service,
)
self.material_service = MaterialService(self.material_repository, self.audit_service)
self.wardrobe_service = WardrobeService(
self.wardrobe_repository,
self.profile_repository,
self.material_repository,
self.audit_service,
)
self.integration_service = IntegrationService(self.wardrobe_service, self.integration_repository)
self.log_service = LogService(self.database)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write", "can_manage_config", "can_manage_materials"},
)
def tearDown(self):
self.tmp.cleanup()
def test_log_routes_return_operational_views(self):
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,
)
node_id = workflow.nodes[0].node_id
image = self.image_service.create_image(
{"node_id": node_id, "image_uri": "storage://images/sample.png"},
self.ctx,
)
self.history_service.adopt_node_image(node_id, {"image_id": image.image_id}, self.ctx)
failed_task = self.queue_service.create_task(
{"status": "failed", "error_message": "mock failure"},
self.ctx,
)
superseded_task = self.queue_service.create_task(
{"status": "superseded", "error_message": "historical failure"},
self.ctx,
)
self.integration_service.daily_outfit({"profile_id": profile.profile_id, "categories": ["top"]}, self.ctx)
generation = get_generation_logs(self.ctx, {"limit": 5}, self.log_service)
self.assertTrue(generation["ok"])
self.assertEqual(generation["data"][0]["status"], "failed")
filtered_generation = get_generation_logs(self.ctx, {"status": "failed", "limit": 5}, self.log_service)
self.assertTrue(filtered_generation["ok"])
self.assertTrue(filtered_generation["data"])
self.assertTrue(all(item["status"] == "failed" for item in filtered_generation["data"]))
workflow_logs = get_workflow_logs(self.ctx, {"workflow_id": workflow.workflow.workflow_id}, self.log_service)
self.assertTrue(workflow_logs["ok"])
self.assertEqual(workflow_logs["data"][0]["action"], "adopt_image")
filtered_workflow_logs = get_workflow_logs(
self.ctx,
{"workflow_id": workflow.workflow.workflow_id, "action": "adopt_image"},
self.log_service,
)
self.assertTrue(filtered_workflow_logs["ok"])
self.assertEqual(filtered_workflow_logs["data"][0]["node_id"], node_id)
integrations = get_integration_logs(self.ctx, {}, self.log_service)
self.assertTrue(integrations["ok"])
self.assertEqual(integrations["data"][0]["action"], "daily_outfit")
self.assertIn("profile_id", integrations["data"][0]["request"])
filtered_integrations = get_integration_logs(
self.ctx,
{"status": "succeeded", "action": "daily_outfit"},
self.log_service,
)
self.assertTrue(filtered_integrations["ok"])
self.assertTrue(all(item["status"] == "succeeded" for item in filtered_integrations["data"]))
errors = get_error_logs(self.ctx, {}, self.log_service)
self.assertTrue(errors["ok"])
self.assertEqual(errors["data"][0]["source"], "generation_task")
error_ids = {item["id"] for item in errors["data"]}
self.assertIn(failed_task.task_id, error_ids)
self.assertNotIn(superseded_task.task_id, error_ids)
task_errors = get_error_logs(self.ctx, {"source": "generation_task", "status": "failed"}, self.log_service)
self.assertTrue(task_errors["ok"])
self.assertTrue(all(item["source"] == "generation_task" for item in task_errors["data"]))
audit = get_audit_logs(self.ctx, {"limit": 10}, self.log_service)
self.assertTrue(audit["ok"])
self.assertTrue(any(item["action"] == "create_profile" for item in audit["data"]))
filtered_audit = get_audit_logs(self.ctx, {"action": "create_profile", "limit": 10}, self.log_service)
self.assertTrue(filtered_audit["ok"])
self.assertTrue(filtered_audit["data"])
self.assertTrue(all(item["action"] == "create_profile" for item in filtered_audit["data"]))
def test_audit_logs_require_config_permission(self):
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
response = get_audit_logs(read_only, {}, self.log_service)
self.assertFalse(response["ok"])
self.assertEqual(response["error_code"], "FORBIDDEN")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,116 +0,0 @@
from __future__ import annotations
import unittest
from backend.dto.workflow_dto import WorkflowNode
from backend.services.material_binding_schema_service import (
MATERIAL_BINDING_SCHEMA_VERSION,
node_material_binding_view,
normalize_material_bindings,
)
class MaterialBindingSchemaServiceTests(unittest.TestCase):
def test_normalize_material_bindings_indexes_active_rules_by_stage_and_node(self):
headshot = _node("node_headshot", "headshot", "Headshot")
half_body = _node("node_half_body", "half_body", "Half body")
full_body = _node("node_full_body", "full_body", "Full body")
normalized = normalize_material_bindings(
{
"profile_id": "profile_001",
"profile_name": "Nova",
"selected_material_ids": ["mat_style"],
"rules": [
{
"id": "rule_style",
"category": "风格",
"material_id": "mat_style",
"material_label": "Soft light",
"material_group": "style",
"material_prompt": "soft watercolor, clean line art",
"material_colors": ["#f7d9e5"],
"bind_to_stages": [
{"stage_id": "portrait-draft", "stage_title": "头像"},
{"stage_id": "halfbody-draft", "stage_title": "半身像"},
],
"inheritance_rule": "keep style across portrait and half body",
"reference_strength": "强",
"required": True,
"status": "ready",
},
{
"id": "rule_clothing",
"category": "服装",
"material_id": "",
"material_prompt": "",
"bind_to_stages": [{"stage_id": "body-sheet", "stage_title": "设定图"}],
"reference_strength": "中",
},
],
},
[headshot, half_body, full_body],
)
self.assertEqual(normalized["schema_version"], MATERIAL_BINDING_SCHEMA_VERSION)
self.assertFalse(normalized["reference_policy"]["default_use_reference"])
self.assertEqual(normalized["summary"]["rule_count"], 2)
self.assertEqual(normalized["summary"]["active_rule_count"], 1)
self.assertEqual(normalized["summary"]["disabled_categories"], ["服装"])
self.assertIn("portrait-draft", normalized["by_stage"])
self.assertIn("headshot", normalized["by_node_key"])
self.assertIn("half_body", normalized["by_node_key"])
self.assertIn("node_headshot", normalized["by_node_id"])
self.assertNotIn("node_full_body", normalized["by_node_id"])
half_body_view = node_material_binding_view(normalized, half_body)
self.assertTrue(half_body_view["has_references"])
self.assertEqual(half_body_view["active_bindings"][0]["material"]["material_id"], "mat_style")
self.assertEqual(half_body_view["generation_params"]["reference_material_ids"], ["mat_style"])
def test_empty_material_rule_means_do_not_use_reference(self):
headshot = _node("node_headshot", "headshot", "Headshot")
normalized = normalize_material_bindings(
{
"rules": [
{
"category": "构图",
"bind_to_stages": [{"stage_id": "portrait-draft", "stage_title": "头像"}],
"reference_strength": "中",
}
]
},
[headshot],
)
view = node_material_binding_view(normalized, headshot)
self.assertFalse(normalized["summary"]["has_references"])
self.assertFalse(view["has_references"])
self.assertEqual(view["generation_params"]["reference_material_ids"], [])
def _node(node_id: str, node_key: str, title: str) -> WorkflowNode:
return WorkflowNode(
node_id=node_id,
workflow_id="workflow_001",
node_key=node_key,
title=title,
description=None,
step_name=node_key,
node_type="generation",
status="draft",
branch_name="main",
prompt=None,
negative_prompt=None,
model_route=None,
selected_image_id=None,
sort_order=1,
metadata={},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,593 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.material_routes import (
confirm_material,
create_material,
create_material_category,
delete_material,
get_material,
list_material_categories,
list_materials,
re_recognize_material,
recognize_material,
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 core.audit_service import AuditService
from core.config_service import ConfigService
from core.identity import RequestContext
from core.storage import VfsStorage
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.material_repository import MaterialRepository
from engines.vision_provider import MockVisionProvider, VisionProviderError, VisionRecognitionResult
PNG_BYTES = b"\x89PNG\r\n\x1a\n" + (b"\x00" * 24)
GIF_BYTES = b"GIF89a\x01\x00\x01\x00\x00\x00\x00;"
class MaterialServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.config_path = self.root / "config.yaml"
(self.root / "materials").mkdir(parents=True, exist_ok=True)
self.config_path.write_text(
f"""
storage:
materials_path: "{(self.root / "materials").as_posix()}"
""",
encoding="utf-8",
)
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db")))
)
self.database.initialize()
self.audit_service = AuditService(self.database)
self.config_service = ConfigService(self.config_path)
self.storage = VfsStorage(self.config_service)
self.material_service = MaterialService(
MaterialRepository(self.database),
self.audit_service,
vision_provider_factory=lambda route: MockVisionProvider(),
storage=self.storage,
)
self.media_service = MediaService(self.config_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_manage_materials"},
)
def tearDown(self):
self.tmp.cleanup()
def test_category_and_material_crud(self):
category = self.material_service.create_category(
{"name": "Upper", "category_id": "cat_upper", "sort_order": 10},
self.ctx,
)
self.assertEqual(category.name, "Upper")
material = self.material_service.create_material(
{
"category_id": category.category_id,
"display_name": "White blouse",
"image_uri": "storage://materials/white_blouse.png",
"thumbnail_uri": "storage://materials/white_blouse_thumb.png",
"prompt": "white blouse, clean collar",
"tags": ["upper", "white"],
"recognition_status": "confirmed",
},
self.ctx,
)
self.assertTrue(material.material_id.startswith("mat_"))
self.assertEqual(material.tags, ["upper", "white"])
listed = self.material_service.list_materials(category_id=category.category_id, keyword="blouse")
self.assertEqual(listed.total, 1)
self.assertEqual(listed.items[0].material_id, material.material_id)
updated = self.material_service.update_material(
material.material_id,
{"display_name": "White short sleeve blouse", "tags": ["summer"]},
self.ctx,
)
self.assertEqual(updated.display_name, "White short sleeve blouse")
self.assertEqual(updated.tags, ["summer"])
deleted = self.material_service.delete_material(material.material_id, self.ctx)
self.assertEqual(deleted.recognition_status, "archived")
self.assertEqual(self.material_service.list_materials().total, 0)
def test_material_requires_storage_uri(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(Exception):
self.material_service.create_material(
{
"category_id": category.category_id,
"display_name": "Bad path",
"image_uri": "C:/real/path.png",
},
self.ctx,
)
def test_material_repository_pagination_is_normalized(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
for index in range(3):
self.material_service.create_material(
{
"category_id": category.category_id,
"display_name": f"Material {index}",
"image_uri": f"storage://materials/item_{index}.png",
},
self.ctx,
)
zero_items, zero_total = self.material_service.repository.list_materials(page=0, page_size=0)
huge_items, huge_total = self.material_service.repository.list_materials(page=1, page_size=999)
self.assertEqual(len(zero_items), 1)
self.assertEqual(zero_total, 3)
self.assertEqual(len(huge_items), 3)
self.assertEqual(huge_total, 3)
def test_upload_recognize_and_confirm_material(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
(self.root / "materials" / "white_blouse.png").write_bytes(PNG_BYTES)
uploaded = self.material_service.upload_material(
{
"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")
self.assertIn("white", recognized.tags)
self.assertIn("clean product reference", recognized.prompt)
self.assertEqual(recognized.metadata["recognition"]["provider_id"], "mock")
self.assertFalse(recognized.metadata["recognition"]["fallback_used"])
confirmed = self.material_service.confirm_material(
uploaded.material_id,
{
"display_name": "White short-sleeve blouse",
"prompt": "white short-sleeve blouse, clean collar",
"tags": ["upper", "white", "summer"],
},
self.ctx,
)
self.assertEqual(confirmed.recognition_status, "confirmed")
self.assertEqual(confirmed.tags, ["upper", "white", "summer"])
re_recognized = self.material_service.re_recognize_material(uploaded.material_id, self.ctx)
self.assertEqual(re_recognized.recognition_status, "pending_confirm")
self.assertIn("white", re_recognized.tags)
def test_recognize_material_uses_injected_vlm_adapter(self):
class FakeVisionProvider:
provider_id = "fake_vlm"
def __init__(self):
self.requests = []
def recognize_material(self, request):
self.requests.append(request)
return VisionRecognitionResult(
provider_id=self.provider_id,
model="vision-test",
prompt="white lace blouse, product reference",
negative_prompt="body",
tags=["white", "lace", "upper"],
confidence=0.93,
description="white lace blouse",
raw_metadata={"test": True},
)
provider = FakeVisionProvider()
service = MaterialService(
MaterialRepository(self.database),
self.audit_service,
vision_provider_factory=lambda route: provider,
storage=self.storage,
)
category = service.create_category({"name": "Upper"}, self.ctx)
(self.root / "materials" / "white_blouse.png").write_bytes(PNG_BYTES)
uploaded = service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.png",
"image_uri": "storage://materials/white_blouse.png",
"recognition_model_route": "material_vlm",
},
self.ctx,
)
recognized = service.recognize_material(uploaded.material_id, self.ctx)
self.assertEqual(provider.requests[0].display_name, "white blouse")
self.assertTrue(provider.requests[0].image_uri.startswith("data:image/png;base64,"))
self.assertNotIn("storage://", provider.requests[0].image_uri)
self.assertEqual(recognized.prompt, "white lace blouse, product reference")
self.assertEqual(recognized.negative_prompt, "body")
self.assertIn("lace", recognized.tags)
self.assertEqual(recognized.metadata["recognition"]["provider_id"], "fake_vlm")
self.assertEqual(recognized.metadata["recognition"]["model"], "vision-test")
self.assertEqual(recognized.metadata["recognition"]["route_name"], "material_vlm")
self.assertFalse(recognized.metadata["recognition"]["fallback_used"])
def test_recognize_material_keeps_pending_state_when_vlm_adapter_fails(self):
class FailingVisionProvider:
provider_id = "broken_vlm"
def recognize_material(self, request):
raise VisionProviderError(
"vision endpoint timeout",
provider_id=self.provider_id,
error_type="timeout",
details={"retryable": True},
)
service = MaterialService(
MaterialRepository(self.database),
self.audit_service,
vision_provider_factory=lambda route: FailingVisionProvider(),
storage=self.storage,
)
category = service.create_category({"name": "Upper"}, self.ctx)
(self.root / "materials" / "white_blouse.png").write_bytes(PNG_BYTES)
uploaded = service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.png",
"image_uri": "storage://materials/white_blouse.png",
},
self.ctx,
)
with self.assertRaises(ApiError) as caught:
service.recognize_material(uploaded.material_id, self.ctx)
self.assertEqual(caught.exception.error_code, ErrorCode.GENERATION_FAILED)
failed = service.get_material(uploaded.material_id)
self.assertEqual(failed.recognition_status, "pending_recognition")
self.assertIsNone(failed.prompt)
self.assertEqual(failed.tags, [])
self.assertNotIn("recognition", failed.metadata)
failure = failed.metadata["recognition_failure"]
self.assertEqual(failure["provider_id"], "broken_vlm")
self.assertEqual(failure["error_type"], "timeout")
self.assertTrue(failure["retryable"])
self.assertNotIn("details", failure)
self.assertNotIn("message", failure)
def test_recognize_material_requires_a_configured_vision_route(self):
service = MaterialService(
MaterialRepository(self.database),
self.audit_service,
storage=self.storage,
)
category = service.create_category({"name": "Upper"}, self.ctx)
(self.root / "materials" / "white_blouse.png").write_bytes(PNG_BYTES)
uploaded = service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.png",
"image_uri": "storage://materials/white_blouse.png",
},
self.ctx,
)
with self.assertRaises(ApiError) as caught:
service.recognize_material(uploaded.material_id, self.ctx)
self.assertEqual(caught.exception.error_code, ErrorCode.MODEL_CAPABILITY_UNCONFIRMED)
self.assertEqual(service.get_material(uploaded.material_id).recognition_status, "pending_recognition")
routed = recognize_material(self.ctx, uploaded.material_id, service, self.media_service)
self.assertFalse(routed["ok"])
self.assertEqual(routed["error_code"], "MODEL_CAPABILITY_UNCONFIRMED")
def test_recognize_material_rejects_file_signature_mismatch(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
(self.root / "materials" / "not_png.png").write_bytes(b"not an image")
uploaded = self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "not_png.png",
"image_uri": "storage://materials/not_png.png",
},
self.ctx,
)
with self.assertRaises(ApiError) as caught:
self.material_service.recognize_material(uploaded.material_id, self.ctx)
self.assertEqual(caught.exception.error_code, ErrorCode.UNSUPPORTED_FILE_TYPE)
def test_recognize_material_rejects_actual_file_over_size_limit(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
image_path = self.root / "materials" / "too_large.png"
with image_path.open("wb") as handle:
handle.seek(MAX_UPLOAD_BYTES)
handle.write(b"\x00")
uploaded = self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "too_large.png",
"image_uri": "storage://materials/too_large.png",
},
self.ctx,
)
with self.assertRaises(ApiError) as caught:
self.material_service.recognize_material(uploaded.material_id, 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_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.bmp",
"content_type": "image/bmp",
"image_uri": "storage://materials/white_blouse.bmp",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.UNSUPPORTED_FILE_TYPE)
def test_gif_material_recognition_uses_matching_data_url_mime(self):
class GifVisionProvider:
provider_id = "gif_vlm"
def __init__(self):
self.requests = []
def recognize_material(self, request):
self.requests.append(request)
return VisionRecognitionResult(
provider_id=self.provider_id,
model="vision-test",
prompt="animated ribbon reference",
negative_prompt=None,
tags=["ribbon"],
confidence=0.9,
description="ribbon",
)
provider = GifVisionProvider()
service = MaterialService(
MaterialRepository(self.database),
self.audit_service,
vision_provider_factory=lambda route: provider,
storage=self.storage,
)
category = service.create_category({"name": "Accessory"}, self.ctx)
(self.root / "materials" / "ribbon.gif").write_bytes(GIF_BYTES)
uploaded = service.upload_material(
{
"category_id": category.category_id,
"filename": "ribbon.gif",
"content_type": "image/gif",
"image_uri": "storage://materials/ribbon.gif",
},
self.ctx,
)
recognized = service.recognize_material(uploaded.material_id, self.ctx)
self.assertTrue(provider.requests[0].image_uri.startswith("data:image/gif;base64,"))
self.assertEqual(provider.requests[0].metadata["vision_input"]["content_type"], "image/gif")
self.assertEqual(recognized.recognition_status, "pending_confirm")
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": "配饰"}, self.material_service)
self.assertTrue(category["ok"])
category_id = category["data"]["category_id"]
child_category = create_material_category(
self.ctx,
{"name": "头部", "parent_id": category_id, "category_type": "accessory_group"},
self.material_service,
)
self.assertTrue(child_category["ok"])
self.assertEqual(child_category["data"]["parent_id"], category_id)
self.assertEqual(child_category["data"]["category_type"], "accessory_group")
categories = list_material_categories(self.ctx, self.material_service)
self.assertTrue(categories["ok"])
self.assertEqual(len(categories["data"]), 2)
self.assertTrue(any(item["name"] == "头部" and item["parent_id"] == category_id for item in categories["data"]))
bad_child = create_material_category(
self.ctx,
{"name": "断链分类", "parent_id": "cat_missing", "category_type": "accessory_group"},
self.material_service,
)
self.assertFalse(bad_child["ok"])
self.assertEqual(bad_child["error_code"], "RESOURCE_NOT_FOUND")
(self.root / "materials" / "ribbon.png").write_bytes(b"ribbon")
material = create_material(
self.ctx,
{
"category_id": category_id,
"display_name": "Blue ribbon",
"image_uri": "storage://materials/ribbon.png",
},
self.material_service,
self.media_service,
)
self.assertTrue(material["ok"])
material_id = material["data"]["material_id"]
self.assertTrue(material["data"]["image_url"].startswith("/api/plug/"))
self.assertIsNone(material["data"]["thumbnail_url"])
self.assertNotIn(str(self.root), str(material["data"]))
detail = get_material(self.ctx, material_id, self.material_service, self.media_service)
self.assertTrue(detail["ok"])
self.assertTrue(detail["data"]["image_url"].startswith("/api/plug/"))
updated = update_material(self.ctx, material_id, {"recognition_status": "confirmed"}, self.material_service)
self.assertTrue(updated["ok"])
self.assertEqual(updated["data"]["recognition_status"], "confirmed")
listed = list_materials(self.ctx, {"keyword": "ribbon"}, self.material_service, self.media_service)
self.assertTrue(listed["ok"])
self.assertEqual(listed["data"]["total"], 1)
self.assertTrue(listed["data"]["items"][0]["image_url"].startswith("/api/plug/"))
self.assertNotIn(str(self.root), str(listed["data"]["items"][0]))
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = create_material(read_only, {"display_name": "Denied"}, self.material_service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
deleted = delete_material(self.ctx, material_id, self.material_service)
self.assertTrue(deleted["ok"])
missing = get_material(self.ctx, material_id, self.material_service)
self.assertFalse(missing["ok"])
self.assertEqual(missing["error_code"], "RESOURCE_NOT_FOUND")
def test_material_upload_recognize_confirm_routes(self):
category = create_material_category(self.ctx, {"name": "Dress"}, self.material_service)
(self.root / "materials" / "blue_dress.png").write_bytes(PNG_BYTES)
uploaded = upload_material(
self.ctx,
{
"category_id": category["data"]["category_id"],
"filename": "blue_dress.png",
"image_uri": "storage://materials/blue_dress.png",
},
self.material_service,
self.media_service,
)
self.assertTrue(uploaded["ok"])
self.assertEqual(uploaded["data"]["recognition_status"], "pending_recognition")
self.assertTrue(uploaded["data"]["image_url"].startswith("/api/plug/"))
self.assertTrue(uploaded["data"]["thumbnail_url"].startswith("/api/plug/"))
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"])
self.assertEqual(recognized["data"]["recognition_status"], "pending_confirm")
self.assertIn("blue", recognized["data"]["tags"])
self.assertTrue(recognized["data"]["image_url"].startswith("/api/plug/"))
self.assertTrue(recognized["data"]["thumbnail_url"].startswith("/api/plug/"))
self.assertNotIn(str(self.root), str(recognized["data"]))
confirmed = confirm_material(
self.ctx,
material_id,
{"display_name": "Blue dress", "tags": ["dress", "blue"]},
self.material_service,
self.media_service,
)
self.assertTrue(confirmed["ok"])
self.assertEqual(confirmed["data"]["recognition_status"], "confirmed")
self.assertTrue(confirmed["data"]["image_url"].startswith("/api/plug/"))
self.assertTrue(confirmed["data"]["thumbnail_url"].startswith("/api/plug/"))
self.assertNotIn(str(self.root), str(confirmed["data"]))
re_recognized = re_recognize_material(self.ctx, material_id, self.material_service, self.media_service)
self.assertTrue(re_recognized["ok"])
self.assertEqual(re_recognized["data"]["recognition_status"], "pending_confirm")
self.assertTrue(re_recognized["data"]["image_url"].startswith("/api/plug/"))
self.assertTrue(re_recognized["data"]["thumbnail_url"].startswith("/api/plug/"))
self.assertNotIn(str(self.root), str(re_recognized["data"]))
if __name__ == "__main__":
unittest.main()

查看文件

@ -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,43 +0,0 @@
from __future__ import annotations
import unittest
from types import SimpleNamespace
from backend.services.generation_service import _assignment_key
from backend.services.settings_service import SettingsService
class ModelAssignmentTests(unittest.TestCase):
def test_generation_nodes_map_to_function_assignments(self):
cases = {
"headshot": "portrait_generation",
"half_body": "halfbody_generation",
"full_body": "fullbody_generation",
"expression_sheet": "sheet_generation",
"pose_sheet": "sheet_generation",
"style_lock": "hires_fix",
}
for node_key, expected in cases.items():
with self.subTest(node_key=node_key):
self.assertEqual(_assignment_key(SimpleNamespace(node_key=node_key, node_type="generation")), expected)
def test_virtual_single_image_uses_quick_generation(self):
self.assertEqual(
_assignment_key(SimpleNamespace(node_key="single", node_type="virtual_single_image")),
"quick_generation",
)
def test_settings_schema_exposes_model_assignment_section(self):
schema = SettingsService().get_schema()
section = next(item for item in schema["sections"] if item["key"] == "model_assignments")
keys = {field["key"] for field in section["fields"]}
self.assertIn("material_recognition", keys)
self.assertIn("cross_review_primary", keys)
self.assertIn("cross_review_secondary", keys)
self.assertIn("cross_review_routes", keys)
self.assertIn("quick_generation", keys)
self.assertIn("hires_fix", keys)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,290 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.services.model_provider_bootstrap import (
sync_generation_provider_from_config,
sync_vision_provider_from_config,
)
from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.model_provider_service import ModelProviderService
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.model_provider_repository import ModelProviderRepository
class ModelProviderBootstrapTests(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.service = ModelProviderService(ModelProviderRepository(self.database))
def tearDown(self):
self.tmp.cleanup()
def test_config_bootstrap_creates_resolvable_route_without_inline_secret(self):
result = sync_generation_provider_from_config(
self.service,
{
"generation": {
"default_model": "image_default",
"provider": {
"base_url": "http://127.0.0.1:8080",
"model_id": "local-image-model",
},
}
},
)
self.assertTrue(result["configured"])
resolved = self.service.resolve_route("image_default", modality="image_generation")
self.assertEqual(resolved["model_id"], "local-image-model")
provider = ModelProviderRuntime(self.service).image_provider_for_route({"route_name": "image_default"})
self.assertIsNotNone(provider)
self.assertEqual(provider.config.api_key, "")
def test_incomplete_provider_is_reported_without_creating_route(self):
result = sync_generation_provider_from_config(
self.service,
{"generation": {"default_model": "image_default", "provider": {}}},
)
self.assertFalse(result["configured"])
self.assertEqual(result["status"], "incomplete")
self.assertIsNone(self.service.resolve_route("image_default", modality="image_generation"))
def test_vision_bootstrap_reuses_generation_provider_connection(self):
config = {
"generation": {
"default_model": "image_default",
"provider": {
"provider_id": "shared_provider",
"base_url": "https://provider.example",
"image_endpoint": "/v1/images/generations",
"api_key_env_var": "IMAGESTUDIO_SHARED_KEY",
"timeout_seconds": 90,
"model_id": "image-model",
},
},
"vision": {
"default_route": "material_vlm",
"provider": {
"model_id": "vision-model",
"vision_endpoint": "/v1/chat/completions",
},
},
}
sync_generation_provider_from_config(self.service, config)
result = sync_vision_provider_from_config(self.service, config)
self.assertTrue(result["configured"])
self.assertTrue(result["reuses_generation_provider"])
resolved = self.service.resolve_route("material_vlm", modality="vision_recognition")
self.assertEqual(resolved["provider_id"], "shared_provider")
self.assertEqual(resolved["model_id"], "vision-model")
self.assertEqual(resolved["settings"]["vision_endpoint"], "/v1/chat/completions")
self.assertEqual(resolved["provider"]["base_url"], "https://provider.example")
self.assertEqual(resolved["provider"]["api_key_env_var"], "IMAGESTUDIO_SHARED_KEY")
def test_vision_bootstrap_reports_missing_model_without_creating_route(self):
result = sync_vision_provider_from_config(
self.service,
{
"generation": {"provider": {"base_url": "https://provider.example"}},
"vision": {
"default_route": "material_vlm",
"provider": {"provider_id": "shared_provider"},
},
},
)
self.assertFalse(result["configured"])
self.assertEqual(result["status"], "incomplete")
self.assertIn("vision.provider.model_id", result["missing_fields"])
self.assertIsNone(self.service.resolve_route("material_vlm", modality="vision_recognition"))
def test_vision_connection_overrides_do_not_mutate_generation_provider(self):
config = {
"generation": {
"default_model": "image_default",
"provider": {
"provider_id": "shared_provider",
"base_url": "https://images.example",
"api_key_env_var": "IMAGE_KEY",
"timeout_seconds": 90,
"model_id": "image-model",
},
},
"vision": {
"default_route": "material_vlm",
"provider": {
"base_url": "https://vision.example",
"api_key_env_var": "VISION_KEY",
"timeout_seconds": 180,
"model_id": "vision-model",
},
},
}
sync_generation_provider_from_config(self.service, config)
result = sync_vision_provider_from_config(self.service, config)
self.assertTrue(result["configured"])
self.assertFalse(result["reuses_generation_provider"])
self.assertTrue(result["provider_id_auto_derived"])
self.assertEqual(result["provider_id"], "shared_provider_vision")
image_route = self.service.resolve_route("image_default", modality="image_generation")
vision_route = self.service.resolve_route("material_vlm", modality="vision_recognition")
self.assertEqual(image_route["provider"]["base_url"], "https://images.example")
self.assertEqual(image_route["provider"]["api_key_env_var"], "IMAGE_KEY")
self.assertEqual(image_route["provider"]["timeout_seconds"], 90)
self.assertEqual(vision_route["provider_id"], "shared_provider_vision")
self.assertEqual(vision_route["provider"]["base_url"], "https://vision.example")
self.assertEqual(vision_route["provider"]["api_key_env_var"], "VISION_KEY")
self.assertEqual(vision_route["provider"]["timeout_seconds"], 180)
def test_config_bootstrap_updates_stable_route_and_disables_legacy_config_route(self):
self.service.upsert_provider(
{
"provider_id": "legacy_provider",
"base_url": "https://legacy.example",
}
)
legacy_route = self.service.upsert_route(
{
"route_name": "image_default",
"provider_id": "legacy_provider",
"model_id": "model-a",
"modality": "image_generation",
"enabled": True,
"metadata": {"source": "config_bootstrap"},
}
)
config = {
"generation": {
"default_model": "image_default",
"provider": {
"provider_id": "current_provider",
"base_url": "https://current.example",
"model_id": "model-b",
},
}
}
first = sync_generation_provider_from_config(self.service, config)
config["generation"]["provider"]["model_id"] = "model-c"
second = sync_generation_provider_from_config(self.service, config)
self.assertEqual(first["route_name"], "image_default")
self.assertEqual(second["model_id"], "model-c")
resolved = self.service.resolve_route("image_default", modality="image_generation")
self.assertEqual(resolved["route_id"], "route_config_image_generation_image_default")
self.assertEqual(resolved["provider_id"], "current_provider")
self.assertEqual(resolved["model_id"], "model-c")
routes = [
route
for route in self.service.list_routes()
if route["route_name"] == "image_default" and route["modality"] == "image_generation"
]
self.assertEqual(sum(1 for route in routes if route["enabled"]), 1)
disabled_legacy = next(route for route in routes if route["route_id"] == legacy_route["route_id"])
self.assertFalse(disabled_legacy["enabled"])
self.assertEqual(
disabled_legacy["metadata"]["superseded_by"],
"route_config_image_generation_image_default",
)
def test_clearing_config_disables_previously_bootstrapped_routes(self):
generation_config = {
"generation": {
"default_model": "image_default",
"provider": {
"base_url": "https://images.example",
"model_id": "image-model",
},
}
}
vision_config = {
**generation_config,
"vision": {
"default_route": "material_vlm",
"provider": {"model_id": "vision-model"},
},
}
sync_generation_provider_from_config(self.service, generation_config)
sync_vision_provider_from_config(self.service, vision_config)
self.assertIsNotNone(self.service.resolve_route("image_default", modality="image_generation"))
self.assertIsNotNone(self.service.resolve_route("material_vlm", modality="vision_recognition"))
generation_result = sync_generation_provider_from_config(self.service, {"generation": {}})
vision_result = sync_vision_provider_from_config(self.service, {"vision": {}})
self.assertEqual(generation_result["status"], "not_configured")
self.assertEqual(vision_result["status"], "not_configured")
self.assertIsNone(self.service.resolve_route("image_default", modality="image_generation"))
self.assertIsNone(self.service.resolve_route("material_vlm", modality="vision_recognition"))
def test_multiple_generation_adapters_create_independent_routes(self):
result = sync_generation_provider_from_config(
self.service,
{
"generation": {
"default_model": "primary_image",
"adapters": [
{
"id": "primary",
"name": "Primary",
"base_url": "https://primary.example/v1",
"model_id": "image-a",
"route_name": "primary_image",
"enabled": True,
},
{
"id": "fallback",
"name": "Fallback",
"base_url": "https://fallback.example/v1",
"model_id": "image-b",
"route_name": "fallback_image",
"priority": 20,
"enabled": True,
},
],
}
},
)
self.assertTrue(result["configured"])
self.assertEqual(result["adapter_count"], 2)
primary = self.service.resolve_route("primary_image", modality="image_generation")
fallback = self.service.resolve_route("fallback_image", modality="image_generation")
self.assertEqual(primary["provider_id"], "primary")
self.assertEqual(primary["model_id"], "image-a")
self.assertEqual(fallback["provider_id"], "fallback")
self.assertEqual(fallback["model_id"], "image-b")
def test_removing_adapter_disables_its_config_route(self):
config = {
"generation": {
"default_model": "primary_image",
"adapters": [
{"id": "primary", "base_url": "https://primary.example", "model_id": "a", "route_name": "primary_image"},
{"id": "old", "base_url": "https://old.example", "model_id": "b", "route_name": "old_image"},
],
}
}
sync_generation_provider_from_config(self.service, config)
config["generation"]["adapters"] = [config["generation"]["adapters"][0]]
sync_generation_provider_from_config(self.service, config)
self.assertIsNotNone(self.service.resolve_route("primary_image", modality="image_generation"))
self.assertIsNone(self.service.resolve_route("old_image", modality="image_generation"))
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,158 +0,0 @@
from __future__ import annotations
import os
import tempfile
import unittest
from pathlib import Path
from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.model_provider_service import ModelProviderService
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.model_provider_repository import ModelProviderRepository
from engines.image_provider import GeneratedImagePayload, ImageGenerationRequest, ImageGenerationResult, ImageProviderError
class ModelProviderRuntimeTests(unittest.TestCase):
def test_runtime_falls_back_to_next_enabled_route(self):
with tempfile.TemporaryDirectory() as tmp:
database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(Path(tmp) / "imagestudio.db"))))
database.initialize()
service = ModelProviderService(ModelProviderRepository(database))
for provider_id in ("primary", "fallback"):
service.upsert_provider({"provider_id": provider_id, "base_url": f"https://{provider_id}.example"})
service.upsert_route({"route_name": "primary_image", "provider_id": "primary", "model_id": "a", "priority": 10})
service.upsert_route({"route_name": "fallback_image", "provider_id": "fallback", "model_id": "b", "priority": 20})
runtime = ModelProviderRuntime(service)
provider = runtime.image_provider_for_route({"route_name": "primary_image"})
self.assertEqual(len(provider.providers), 2)
def fail(_request):
raise ImageProviderError("failed", provider_id="primary", error_type="network_error")
def succeed(_request):
return ImageGenerationResult(provider_id="fallback", model="b", images=[GeneratedImagePayload(b64_json="abc")])
provider.providers[0].generate_image = fail
provider.providers[1].generate_image = succeed
result = provider.generate_image(ImageGenerationRequest(prompt="test"))
self.assertEqual(result.provider_id, "fallback")
self.assertEqual(result.raw_metadata["fallback_attempts"][0]["provider_id"], "primary")
def test_runtime_builds_openai_provider_from_env_secret(self):
with tempfile.TemporaryDirectory() as tmp:
database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(Path(tmp) / "imagestudio.db"))))
database.initialize()
service = ModelProviderService(ModelProviderRepository(database))
service.upsert_provider(
{
"provider_id": "site_b",
"base_url": "https://botcf.com",
"image_endpoint": "/v1/images/generations",
"api_key_env_var": "IMAGESTUDIO_TEST_SITE_B",
"timeout_seconds": 180,
}
)
service.upsert_route({"route_name": "image_high", "provider_id": "site_b", "model_id": "image2"})
os.environ["IMAGESTUDIO_TEST_SITE_B"] = "secret-value"
try:
provider = ModelProviderRuntime(service).image_provider_for_route({"route_name": "image_high"})
finally:
os.environ.pop("IMAGESTUDIO_TEST_SITE_B", None)
self.assertIsNotNone(provider)
self.assertEqual(provider.config.provider_id, "site_b")
self.assertEqual(provider.config.image_model, "image2")
self.assertEqual(provider.config.api_key, "secret-value")
self.assertTrue(provider.config.supports_negative_prompt)
def test_runtime_route_settings_can_disable_negative_prompt(self):
with tempfile.TemporaryDirectory() as tmp:
database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(Path(tmp) / "imagestudio.db"))))
database.initialize()
service = ModelProviderService(ModelProviderRepository(database))
service.upsert_provider(
{
"provider_id": "strict",
"base_url": "https://api.openai.com",
"capabilities": {"supports_negative_prompt": True},
}
)
service.upsert_route(
{
"route_name": "image_strict",
"provider_id": "strict",
"model_id": "gpt-image-1",
"settings": {"supports_negative_prompt": False},
}
)
provider = ModelProviderRuntime(service).image_provider_for_route(
{"route_name": "image_strict"}
)
self.assertIsNotNone(provider)
self.assertFalse(provider.config.supports_negative_prompt)
def test_runtime_defaults_negative_prompt_off_for_official_openai(self):
with tempfile.TemporaryDirectory() as tmp:
database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(Path(tmp) / "imagestudio.db"))))
database.initialize()
service = ModelProviderService(ModelProviderRepository(database))
service.upsert_provider(
{
"provider_id": "openai",
"base_url": "https://api.openai.com/v1",
}
)
service.upsert_route(
{
"route_name": "image_openai",
"provider_id": "openai",
"model_id": "gpt-image-1",
}
)
provider = ModelProviderRuntime(service).image_provider_for_route(
{"route_name": "image_openai"}
)
self.assertIsNotNone(provider)
self.assertFalse(provider.config.supports_negative_prompt)
def test_runtime_builds_openai_vision_provider_from_route_settings(self):
with tempfile.TemporaryDirectory() as tmp:
database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(Path(tmp) / "imagestudio.db"))))
database.initialize()
service = ModelProviderService(ModelProviderRepository(database))
service.upsert_provider(
{
"provider_id": "site_vlm",
"base_url": "https://vision.example",
"api_key_env_var": "IMAGESTUDIO_TEST_VLM",
"timeout_seconds": 90,
}
)
service.upsert_route(
{
"route_name": "material_vlm",
"provider_id": "site_vlm",
"model_id": "vision-model",
"modality": "vision_recognition",
"settings": {"vision_endpoint": "/v1/chat/completions"},
}
)
os.environ["IMAGESTUDIO_TEST_VLM"] = "vision-secret"
try:
provider = ModelProviderRuntime(service).vision_provider_for_route({"route_name": "material_vlm"})
finally:
os.environ.pop("IMAGESTUDIO_TEST_VLM", None)
self.assertIsNotNone(provider)
self.assertEqual(provider.config.provider_id, "site_vlm")
self.assertEqual(provider.config.vision_model, "vision-model")
self.assertEqual(provider.config.vision_endpoint, "/v1/chat/completions")
self.assertEqual(provider.config.api_key, "vision-secret")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,80 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.services.model_provider_service import ModelProviderService
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.models import table_spec
from database.repositories.model_provider_repository import ModelProviderRepository
class ModelProviderServiceTests(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.service = ModelProviderService(ModelProviderRepository(self.database))
def tearDown(self):
self.tmp.cleanup()
def test_provider_and_route_are_persisted_and_resolved(self):
provider = self.service.upsert_provider(
{
"provider_id": "site_b",
"display_name": "B Site",
"base_url": "https://botcf.com",
"image_endpoint": "/v1/images/generations",
"api_key_env_var": "IMAGESTUDIO_SITE_B_KEY",
"timeout_seconds": 180,
"capabilities": {"image_generation": True},
}
)
route = self.service.upsert_route(
{
"route_name": "image_high",
"provider_id": "site_b",
"model_id": "image2",
"priority": 10,
"settings": {"size": "1024x1024"},
}
)
resolved = self.service.resolve_route("image_high", modality="image_generation")
self.assertEqual(provider["provider_id"], "site_b")
self.assertEqual(route["route_id"], "route_image_high_site_b_image2")
self.assertIsNotNone(resolved)
self.assertEqual(resolved["model_id"], "image2")
self.assertEqual(resolved["provider"]["base_url"], "https://botcf.com")
self.assertEqual(resolved["provider"]["api_key_env_var"], "IMAGESTUDIO_SITE_B_KEY")
self.assertTrue(provider["api_key_set"] in {True, False})
self.assertNotIn("api_key_plaintext", provider)
def test_route_resolution_prefers_lower_priority_enabled_provider(self):
self.service.upsert_provider({"provider_id": "slow", "base_url": "https://slow.example"})
self.service.upsert_provider({"provider_id": "fast", "base_url": "https://fast.example"})
self.service.upsert_route(
{"route_name": "image_low", "provider_id": "slow", "model_id": "slow-model", "priority": 50}
)
self.service.upsert_route(
{"route_name": "image_low", "provider_id": "fast", "model_id": "fast-model", "priority": 5}
)
resolved = self.service.resolve_route("image_low")
self.assertEqual(resolved["provider_id"], "fast")
self.assertEqual(resolved["model_id"], "fast-model")
def test_model_tables_are_registered_as_metadata(self):
self.assertEqual(table_spec("model_providers").primary_key, "provider_id")
self.assertEqual(table_spec("model_routes").primary_key, "route_id")
self.assertEqual(table_spec("model_providers").sensitive_columns(), ["api_key_secret_ref"])
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,217 +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.assertEqual(context["injection_template"]["version"], "2026-07-09.node-injection-schema.v1")
self.assertEqual(context["injection_template"]["template_kind"], "material_bind")
self.assertEqual(context["injection_template"]["language_policy"]["translation_mode"], "backend_llm")
self.assertIn("expected_response_schema", context["injection_template"])
self.assertNotIn(str(self.tmp.name), str(context))
def test_context_includes_node_scoped_material_bindings(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_gradual", "display_name": "Gradual"},
self.ctx,
)
material_bind = next(node for node in detail.nodes if node.node_key == "material_bind")
headshot = next(node for node in detail.nodes if node.node_key == "headshot")
half_body = next(node for node in detail.nodes if node.node_key == "half_body")
self.workflow_service.update_node(
material_bind.node_id,
{
"metadata": {
"material_bindings": {
"rules": [
{
"id": "rule_style",
"category": "风格",
"material_id": "mat_style",
"material_label": "Soft light",
"material_prompt": "soft watercolor",
"bind_to_stages": [{"stage_id": "portrait-draft", "stage_title": "头像"}],
"reference_strength": "强",
"status": "ready",
},
{
"id": "rule_clothing",
"category": "服装",
"material_id": "mat_clothing",
"material_label": "White blouse",
"material_prompt": "white lace blouse",
"bind_to_stages": [{"stage_id": "halfbody-draft", "stage_title": "半身像"}],
"reference_strength": "中",
"status": "ready",
},
]
}
}
},
self.ctx,
)
headshot_context = self.context_service.get_context(headshot.node_id)
half_body_context = self.context_service.get_context(half_body.node_id)
self.assertEqual(headshot_context["material_bindings"]["target_node_key"], "headshot")
self.assertEqual(headshot_context["material_bindings"]["generation_params"]["reference_material_ids"], ["mat_style"])
self.assertEqual(half_body_context["material_bindings"]["generation_params"]["reference_material_ids"], ["mat_clothing"])
self.assertEqual(
headshot_context["injection_template"]["material_bindings"]["schema_version"],
"2026-07-09.material-binding-schema.v1",
)
def test_context_includes_node_scoped_prompt_plan(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_gradual", "display_name": "Gradual"},
self.ctx,
)
prompt_plan = next(node for node in detail.nodes if node.node_key == "prompt_plan")
headshot = next(node for node in detail.nodes if node.node_key == "headshot")
full_body = next(node for node in detail.nodes if node.node_key == "full_body")
self.workflow_service.update_node(
prompt_plan.node_id,
{
"metadata": {
"prompt_plan": {
"items": [
{
"id": "portrait",
"title": "头像节点",
"prompt": "Nova, face reference, clear eyes",
"negative": "low quality, blurry",
"inherits": ["name", "hair", "eyes"],
"status": "ready",
},
{
"id": "fullbody",
"title": "全身节点",
"prompt": "Nova, full body standing pose",
"negative": "bad anatomy",
"conflicts": ["shoe details need review"],
"status": "review",
},
]
}
}
},
self.ctx,
)
headshot_context = self.context_service.get_context(headshot.node_id)
full_body_context = self.context_service.get_context(full_body.node_id)
self.assertEqual(headshot_context["prompt_plan"]["target_node_key"], "headshot")
self.assertEqual(headshot_context["prompt_plan"]["generation_params"]["prompt_patch"], "Nova, face reference, clear eyes")
self.assertEqual(full_body_context["prompt_plan"]["generation_params"]["negative_patch"], "bad anatomy")
self.assertEqual(
headshot_context["injection_template"]["prompt_plan"]["schema_version"],
"2026-07-09.prompt-plan-schema.v1",
)
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,23 +0,0 @@
from __future__ import annotations
import unittest
from scripts.imagestudio_non_ui_smoke import run_non_ui_smoke
class NonUiSmokeTests(unittest.TestCase):
def test_non_ui_smoke_runs_core_backend_checks(self):
result = run_non_ui_smoke()
self.assertTrue(result["ok"])
checks = result["checks"]
self.assertTrue(checks["runtime_health"]["ok"])
self.assertGreaterEqual(checks["sqlite_migrations"], 1)
self.assertGreaterEqual(checks["material_categories"], 1)
self.assertEqual(checks["contract_routes"], checks["manifest_routes"])
self.assertTrue(checks["contract_url"].endswith("/contract"))
self.assertTrue(checks["pg_dry_run"]["ok"])
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,81 +0,0 @@
from __future__ import annotations
import os
import tempfile
import unittest
from pathlib import Path
from scripts.imagestudio_pg_smoke import build_pg_smoke_plan, run_pg_smoke
class PostgresSmokeTests(unittest.TestCase):
def test_pg_smoke_plan_redacts_config_and_reports_connection_shape(self):
with tempfile.TemporaryDirectory() as tmp:
config_path = Path(tmp) / "config.yaml"
config_path.write_text(
"""
database:
backend: postgresql
postgresql:
enabled: true
host: localhost
port: 5432
database: imagestudio_test
user: imagestudio
password: super-secret
""",
encoding="utf-8",
)
plan = build_pg_smoke_plan(config_path)
self.assertEqual(plan["config_path"], "***PATH***")
self.assertEqual(plan["selected_backend"], "postgresql")
self.assertTrue(plan["postgresql_configured"])
self.assertEqual(plan["connection_mode"], "host")
self.assertTrue(plan["password_set"])
self.assertNotIn("super-secret", str(plan))
self.assertNotIn(str(config_path), str(plan))
def test_pg_smoke_dry_run_does_not_connect(self):
with tempfile.TemporaryDirectory() as tmp:
config_path = Path(tmp) / "config.yaml"
config_path.write_text(
"""
database:
backend: sqlite
""",
encoding="utf-8",
)
result = run_pg_smoke(config_path, dry_run=True)
self.assertTrue(result["ok"])
self.assertTrue(result["dry_run"])
self.assertEqual(result["plan"]["selected_backend"], "sqlite")
@unittest.skipUnless(os.environ.get("IMAGESTUDIO_TEST_PG_DSN"), "IMAGESTUDIO_TEST_PG_DSN is not set")
def test_live_pg_smoke_from_env_dsn(self):
with tempfile.TemporaryDirectory() as tmp:
config_path = Path(tmp) / "config.yaml"
config_path.write_text(
f"""
database:
backend: postgresql
postgresql:
enabled: true
dsn: "{os.environ["IMAGESTUDIO_TEST_PG_DSN"]}"
""",
encoding="utf-8",
)
result = run_pg_smoke(config_path)
self.assertTrue(result["ok"])
self.assertFalse(result["dry_run"])
self.assertGreaterEqual(result["migrations_applied"], 1)
self.assertGreaterEqual(result["material_categories"], 1)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,541 +0,0 @@
from __future__ import annotations
import asyncio
import sys
import tempfile
import threading
import types
import unittest
from pathlib import Path
from unittest.mock import patch
from backend.route_registry import ROUTES
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.db_helper import get_runtime_config_overrides, load_database_settings, set_runtime_config_overrides
from main import (
BRIDGE_PERMISSIONS,
Main,
PLUGIN_NAME,
apply_astrbot_config_overrides,
dispatch_bridge_request,
dispatch_web_request,
get_plugin_manifest,
get_runtime_health,
initialize_runtime_database,
register_bridge_api,
register_plugin,
_current_astrbot_web_request,
_request_context_from_astrbot_request,
_request_payload,
_request_query,
)
class PluginEntrypointTests(unittest.TestCase):
def test_plugin_manifest_exposes_astrbot_mounts(self):
manifest = get_plugin_manifest()
self.assertEqual(manifest["plugin_name"], PLUGIN_NAME)
self.assertTrue(manifest["api_base"].endswith("astrbot_plugin_imagestudio"))
self.assertTrue(manifest["contract_url"].endswith("/contract"))
self.assertIn("web", manifest)
self.assertTrue(any(route["endpoint"] == "dashboard/summary" for route in manifest["routes"]))
self.assertTrue(manifest["runtime"]["health"]["ok"])
self.assertEqual(manifest["health"]["route_count"], len(ROUTES))
def test_dispatch_web_request_delegates_to_adapter(self):
ctx = RequestContext.from_astrbot(username="admin", user_id="user_001")
response = dispatch_web_request(
ctx,
"GET",
"/api/v1/plugins/extensions/astrbot_plugin_imagestudio/ui/bootstrap",
)
self.assertTrue(response["ok"])
self.assertEqual(response["data"]["plugin_name"], PLUGIN_NAME)
def test_register_plugin_delegates_to_runtime_registration(self):
class FakeRuntime:
def __init__(self):
self.routes = []
self.mounts = []
def register_extension_route(self, **kwargs):
self.routes.append(kwargs)
def register_web_mount(self, **kwargs):
self.mounts.append(kwargs)
runtime = FakeRuntime()
result = register_plugin(runtime)
self.assertTrue(result["registered"])
self.assertEqual(len(runtime.routes), len(ROUTES))
self.assertEqual(len(runtime.mounts), 1)
self.assertFalse(result["bridge_api"]["registered"])
self.assertTrue(get_runtime_health()["ok"])
def test_register_bridge_api_registers_astrbot_web_routes(self):
class FakeRuntime:
def __init__(self):
self.web_apis = []
def register_web_api(self, path, handler, methods=None):
self.web_apis.append({"path": path, "handler": handler, "methods": methods or []})
runtime = FakeRuntime()
result = register_bridge_api(runtime)
self.assertTrue(result["registered"])
expected_methods = sorted({route.method for route in ROUTES})
self.assertEqual(len(runtime.web_apis), len(expected_methods))
self.assertEqual(result["routes_registered"], len(expected_methods))
self.assertEqual(
{api["path"] for api in runtime.web_apis},
{f"/{PLUGIN_NAME}/<path:endpoint>"},
)
bootstrap_api = next(
api
for api in runtime.web_apis
if api["methods"] == ["GET"]
)
request = types.SimpleNamespace(method="GET", username="admin", client_host="127.0.0.1")
response = asyncio.run(bootstrap_api["handler"](request=request, endpoint="ui/bootstrap"))
self.assertEqual(response["status"], "ok")
self.assertEqual(response["data"]["plugin_name"], PLUGIN_NAME)
def test_register_bridge_api_supports_official_astrbot_signature_without_duplicate_paths(self):
class FakeRuntime:
def __init__(self):
self.web_apis = []
def register_web_api(self, route, handler, methods, desc):
self.web_apis.append(
{
"route": route,
"handler": handler,
"methods": methods,
"desc": desc,
}
)
runtime = FakeRuntime()
result = register_bridge_api(runtime)
expected_methods = sorted({route.method for route in ROUTES})
self.assertTrue(result["registered"])
self.assertEqual(result["errors"], [])
self.assertEqual(len(runtime.web_apis), len(expected_methods))
self.assertEqual(
{api["route"] for api in runtime.web_apis},
{f"/{PLUGIN_NAME}/<path:endpoint>"},
)
self.assertEqual(
sorted(api["methods"][0] for api in runtime.web_apis),
expected_methods,
)
def test_dispatch_bridge_request_accepts_astrbot_plugin_path(self):
class FakeUrl:
path = "/api/plug/astrbot_plugin_imagestudio/ui/bootstrap"
class FakeRequest:
method = "GET"
username = "admin"
url = FakeUrl()
query_params = {}
response = asyncio.run(dispatch_bridge_request("", request=FakeRequest()))
self.assertEqual(response["status"], "ok")
self.assertEqual(response["data"]["plugin_name"], PLUGIN_NAME)
def test_modern_request_uses_authenticated_fields_not_identity_headers(self):
class FakeRequest:
username = "real-admin"
user_id = "real-user-id"
client_host = "10.0.0.8"
headers = {
"x-username": "spoofed-admin",
"x-user-id": "spoofed-user-id",
"x-forwarded-for": "203.0.113.9",
}
ctx = _request_context_from_astrbot_request(FakeRequest())
self.assertEqual(ctx.username, "real-admin")
self.assertEqual(ctx.user_id, "real-user-id")
self.assertEqual(ctx.client_ip, "10.0.0.8")
self.assertEqual(ctx.permissions, BRIDGE_PERMISSIONS)
self.assertIn("can_retry_tasks", ctx.permissions)
self.assertNotIn("*", ctx.permissions)
class HeaderOnlyRequest:
headers = {"x-username": "spoofed-admin", "x-user-id": "spoofed-user-id"}
anonymous_ctx = _request_context_from_astrbot_request(HeaderOnlyRequest())
self.assertIsNone(anonymous_ctx.username)
self.assertIsNone(anonymous_ctx.user_id)
self.assertFalse(anonymous_ctx.is_authenticated)
self.assertFalse(anonymous_ctx.permissions)
def test_modern_request_reads_query_and_async_json(self):
class FakeRequest:
method = "POST"
query = {"limit": "5", "status": "queued"}
async def json(self, default=None):
return {"name": "runtime payload"}
request = FakeRequest()
self.assertEqual(_request_query(request), request.query)
self.assertEqual(asyncio.run(_request_payload(request)), {"name": "runtime payload"})
def test_legacy_quart_request_and_g_are_supported(self):
class FakeRequest:
method = "GET"
args = {"limit": "3"}
remote_addr = "127.0.0.9"
quart = types.ModuleType("quart")
quart.request = FakeRequest()
quart.g = types.SimpleNamespace(username="legacy-admin")
with patch.dict(sys.modules, {"quart": quart}):
current = _current_astrbot_web_request()
ctx = _request_context_from_astrbot_request(current)
self.assertIs(current, quart.request)
self.assertEqual(ctx.username, "legacy-admin")
self.assertEqual(ctx.user_id, "legacy-admin")
self.assertEqual(ctx.client_ip, "127.0.0.9")
self.assertEqual(_request_query(current), {"limit": "3"})
def test_post_method_override_envelope_dispatches_original_method_and_body(self):
class FakeRequest:
method = "POST"
username = "admin"
client_host = "127.0.0.1"
query = {"force": "true"}
async def json(self, default=None):
return {
"__imagestudio_method": "PUT",
"__imagestudio_body": {"name": "updated"},
}
routed = {
"ok": True,
"data": {"updated": True},
"warnings": [],
"request_id": "req_override",
}
with patch("main.dispatch_web_request", return_value=routed) as dispatch:
response = asyncio.run(dispatch_bridge_request("profiles/profile_1", request=FakeRequest()))
self.assertEqual(response["status"], "ok")
args, kwargs = dispatch.call_args
self.assertEqual(args[1], "PUT")
self.assertEqual(args[2], "profiles/profile_1")
self.assertEqual(kwargs["query"], {"force": "true"})
self.assertEqual(kwargs["payload"], {"name": "updated"})
def test_dispatch_bridge_request_offloads_sync_business_dispatch(self):
event_loop_thread = threading.get_ident()
dispatch_threads = []
def routed(*args, **kwargs):
dispatch_threads.append(threading.get_ident())
return {
"ok": True,
"data": {"threaded": True},
"warnings": [],
"request_id": "req_threaded",
}
with patch("main.dispatch_web_request", side_effect=routed) as dispatch:
response = asyncio.run(
dispatch_bridge_request(
"profiles/profile_1",
method="GET",
query={"limit": "1"},
)
)
self.assertEqual(response["status"], "ok")
self.assertEqual(response["data"], {"threaded": True})
dispatch.assert_called_once()
self.assertEqual(len(dispatch_threads), 1)
self.assertNotEqual(dispatch_threads[0], event_loop_thread)
def test_method_override_is_ignored_for_non_post_requests(self):
envelope = {
"__imagestudio_method": "DELETE",
"__imagestudio_body": {},
}
routed = {
"ok": True,
"data": {},
"warnings": [],
"request_id": "req_no_override",
}
with patch("main.dispatch_web_request", return_value=routed) as dispatch:
asyncio.run(dispatch_bridge_request("profiles/profile_1", method="PUT", payload=envelope))
args, kwargs = dispatch.call_args
self.assertEqual(args[1], "PUT")
self.assertEqual(kwargs["payload"], envelope)
def test_delete_method_override_accepts_empty_original_body(self):
routed = {
"ok": True,
"data": {},
"warnings": [],
"request_id": "req_delete_override",
}
envelope = {
"__imagestudio_method": "DELETE",
"__imagestudio_body": {},
}
with patch("main.dispatch_web_request", return_value=routed) as dispatch:
asyncio.run(
dispatch_bridge_request(
"profiles/profile_1",
method="POST",
payload=envelope,
)
)
args, kwargs = dispatch.call_args
self.assertEqual(args[1], "DELETE")
self.assertEqual(kwargs["payload"], {})
def test_media_fetch_bridge_returns_binary_modern_response(self):
class FakeResponse:
def __init__(self, *, content, media_type, headers):
self.body = content
self.media_type = media_type
self.headers = headers
astrbot = types.ModuleType("astrbot")
astrbot.__path__ = []
astrbot_api = types.ModuleType("astrbot.api")
astrbot_api.__path__ = []
astrbot_web = types.ModuleType("astrbot.api.web")
astrbot_web.request = object()
astrbot.api = astrbot_api
astrbot_api.web = astrbot_web
starlette = types.ModuleType("starlette")
starlette.__path__ = []
starlette_responses = types.ModuleType("starlette.responses")
starlette_responses.Response = FakeResponse
routed = {
"ok": True,
"data": {
"body_base64": "MTIzNDU",
"content_type": "image/png",
"cache_control": "private, max-age=300",
},
"warnings": [],
"request_id": "req_media",
}
modules = {
"astrbot": astrbot,
"astrbot.api": astrbot_api,
"astrbot.api.web": astrbot_web,
"starlette": starlette,
"starlette.responses": starlette_responses,
}
with patch.dict(sys.modules, modules), patch("main.dispatch_web_request", return_value=routed):
response = asyncio.run(dispatch_bridge_request("media/fetch", method="GET", query={"token": "x"}))
self.assertEqual(response.body, b"12345")
self.assertEqual(response.media_type, "image/png")
self.assertEqual(response.headers["Cache-Control"], "private, max-age=300")
def test_media_fetch_uses_host_native_file_response_before_base64_dispatch(self):
class FakeFileResponse:
def __init__(self, path, *, content_type, headers):
self.path = Path(path)
self.content_type = content_type
self.headers = headers
astrbot = types.ModuleType("astrbot")
astrbot.__path__ = []
astrbot_api = types.ModuleType("astrbot.api")
astrbot_api.__path__ = []
astrbot_web = types.ModuleType("astrbot.api.web")
astrbot_web.file_response = lambda path, *, content_type, headers: FakeFileResponse(
path,
content_type=content_type,
headers=headers,
)
astrbot.api = astrbot_api
astrbot_api.web = astrbot_web
with tempfile.TemporaryDirectory() as tmp:
media_path = Path(tmp) / "image.png"
media_path.write_bytes(b"png")
modules = {"astrbot": astrbot, "astrbot.api": astrbot_api, "astrbot.api.web": astrbot_web}
with patch.dict(sys.modules, modules), patch(
"main.MediaProxy.resolve_file",
return_value=(media_path, {"content_type": "image/png"}),
), patch("main.dispatch_web_request") as dispatch:
response = asyncio.run(dispatch_bridge_request("media/fetch", method="GET", query={"token": "signed"}))
self.assertEqual(response.path, media_path)
self.assertEqual(response.content_type, "image/png")
self.assertEqual(response.headers["Cache-Control"], "private, max-age=300")
dispatch.assert_not_called()
def test_media_fetch_bridge_returns_binary_legacy_quart_response(self):
class FakeQuartResponse:
def __init__(self, body, *, content_type, headers):
self.body = body
self.content_type = content_type
self.headers = headers
quart = types.ModuleType("quart")
quart.Response = FakeQuartResponse
quart.g = types.SimpleNamespace(username="legacy-admin")
routed = {
"ok": True,
"data": {
"body_base64": "MTIzNDU",
"content_type": "image/webp",
"cache_control": "private, max-age=300",
},
"warnings": [],
"request_id": "req_media_legacy",
}
with patch.dict(sys.modules, {"quart": quart, "astrbot.api.web": None}), patch(
"main.dispatch_web_request", return_value=routed
):
response = asyncio.run(dispatch_bridge_request("media/fetch", method="GET", query={"token": "x"}))
self.assertEqual(response.body, b"12345")
self.assertEqual(response.content_type, "image/webp")
self.assertEqual(response.headers["Cache-Control"], "private, max-age=300")
def test_initialize_runtime_database_runs_migrations(self):
with tempfile.TemporaryDirectory() as tmp:
db_path = Path(tmp) / "imagestudio.db"
settings = DatabaseSettings(sqlite=SqliteSettings(path=str(db_path)))
result = initialize_runtime_database(settings)
self.assertTrue(result["initialized"])
self.assertEqual(result["backend"], "sqlite")
self.assertGreater(result["seed"]["material_categories"]["total"], 0)
self.assertTrue(db_path.exists())
database = Database(settings)
conn = database.connect()
try:
row = conn.execute(
"""
SELECT parent_id, category_type
FROM material_categories
WHERE category_id = 'cat_imagestudio_accessory_头部'
"""
).fetchone()
finally:
conn.close()
self.assertEqual(row["parent_id"], "cat_imagestudio_配饰")
self.assertEqual(row["category_type"], "accessory_group")
def test_astrbot_config_overrides_default_database_settings(self):
try:
result = apply_astrbot_config_overrides(
{
"database_backend": "postgresql",
"postgresql_enabled": True,
"postgresql_host": "127.0.0.1",
"postgresql_port": "5432",
"postgresql_database": "imagestudio_runtime",
"postgresql_user": "imagestudio",
"enable_private_companion_integration": True,
}
)
settings = load_database_settings()
self.assertTrue(result["applied"])
self.assertIn("database.postgresql.host", result["keys"])
self.assertEqual(settings.selected_backend, "postgresql")
self.assertEqual(settings.postgresql.database, "imagestudio_runtime")
finally:
set_runtime_config_overrides({})
def test_astrbot_flat_config_maps_material_vision_provider(self):
try:
result = apply_astrbot_config_overrides(
{
"vision_provider_id": "vision_site",
"vision_provider_base_url": "https://vision.example",
"vision_provider_endpoint": "/v1/chat/completions",
"vision_provider_model": "vision-model",
"vision_provider_route": "material_custom",
"vision_provider_api_key_env_var": "IMAGESTUDIO_VISION_KEY",
"vision_provider_timeout_seconds": "75",
"vision_provider_enabled": True,
}
)
overrides = get_runtime_config_overrides()
self.assertIn("vision.provider.model_id", result["keys"])
self.assertEqual(overrides["vision"]["default_route"], "material_custom")
self.assertEqual(overrides["vision"]["provider"]["route_name"], "material_custom")
self.assertEqual(overrides["vision"]["provider"]["vision_endpoint"], "/v1/chat/completions")
self.assertEqual(overrides["vision"]["provider"]["timeout_seconds"], 75)
finally:
set_runtime_config_overrides({})
def test_astrbot_main_class_exposes_manifest(self):
plugin = Main(context=object())
manifest = plugin.get_plugin_manifest()
self.assertEqual(manifest["plugin_name"], PLUGIN_NAME)
self.assertTrue(manifest["runtime"]["health"]["ok"])
def test_astrbot_main_initialize_registers_routes_when_supported(self):
class FakeRuntime:
def __init__(self):
self.routes = []
self.mounts = []
def register_extension_route(self, **kwargs):
self.routes.append(kwargs)
def register_web_mount(self, **kwargs):
self.mounts.append(kwargs)
runtime = FakeRuntime()
plugin = Main(context=runtime)
asyncio.run(plugin.initialize())
self.assertTrue(plugin.registration_result["registered"])
self.assertEqual(len(runtime.routes), len(ROUTES))
self.assertEqual(len(runtime.mounts), 1)
self.assertFalse(plugin.registration_result["bridge_api"]["registered"])
def test_plugin_page_uses_relative_assets(self):
page = Path(__file__).resolve().parents[1] / "pages" / "imagestudio" / "index.html"
html = page.read_text(encoding="utf-8")
self.assertRegex(html, r'src="\.?/assets/')
self.assertRegex(html, r'href="\.?/assets/')
self.assertNotIn('src="/assets/', html)
self.assertNotIn('href="/assets/', html)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,215 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.dto.common import ApiError, ErrorCode
from backend.services.profile_service import ProfileService
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 ProfileServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
db_path = Path(self.tmp.name) / "imagestudio.db"
self.database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(db_path))))
self.database.initialize()
self.service = ProfileService(
repository=ProfileRepository(self.database),
audit_service=AuditService(self.database),
)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
def tearDown(self):
self.tmp.cleanup()
def test_create_profile_writes_profile_and_audit_log(self):
profile = self.service.create_profile(
{
"name": "莉娅",
"description": "银白发少女",
"appearance_prompt": "silver long hair, blue eyes",
"default_model_route": "image_low",
"metadata": {"source": "unit_test"},
},
self.ctx,
)
self.assertTrue(profile.profile_id.startswith("profile_"))
self.assertEqual(profile.name, "莉娅")
self.assertEqual(profile.owner_user_id, "user_001")
self.assertEqual(profile.metadata, {"source": "unit_test"})
conn = self.database.connect()
try:
audit = conn.execute(
"""
SELECT action, target_type, target_id
FROM audit_logs
WHERE target_id = ?
""",
(profile.profile_id,),
).fetchone()
finally:
conn.close()
self.assertIsNotNone(audit)
self.assertEqual(audit["action"], "create_profile")
self.assertEqual(audit["target_type"], "character_profile")
def test_update_profile_changes_fields_and_writes_audit_log(self):
profile = self.service.create_profile({"name": "莉娅"}, self.ctx)
updated = self.service.update_profile(
profile.profile_id,
{
"name": "莉娅 Nova",
"style_prompt": "anime impasto",
},
self.ctx,
)
self.assertEqual(updated.name, "莉娅 Nova")
self.assertEqual(updated.style_prompt, "anime impasto")
conn = self.database.connect()
try:
count = conn.execute(
"""
SELECT COUNT(*) AS total
FROM audit_logs
WHERE target_id = ? AND action = 'update_profile'
""",
(profile.profile_id,),
).fetchone()["total"]
finally:
conn.close()
self.assertEqual(count, 1)
def test_delete_profile_soft_deletes_and_hides_from_get(self):
profile = self.service.create_profile({"name": "莉娅"}, self.ctx)
deleted = self.service.delete_profile(profile.profile_id, self.ctx)
self.assertEqual(deleted.status, "deleted")
with self.assertRaises(ApiError) as raised:
self.service.get_profile(profile.profile_id)
self.assertEqual(raised.exception.error_code, ErrorCode.RESOURCE_NOT_FOUND)
def test_list_profiles_is_scoped_to_actor(self):
own = self.service.create_profile({"name": "莉娅"}, self.ctx)
other_ctx = RequestContext.from_astrbot(username="guest", user_id="user_002")
self.service.create_profile({"name": "诺亚"}, other_ctx)
result = self.service.list_profiles(ctx=self.ctx)
self.assertEqual(result.total, 1)
self.assertEqual(result.items[0].profile_id, own.profile_id)
def test_profile_owner_is_derived_from_context_and_cross_owner_access_is_hidden(self):
profile = self.service.create_profile(
{"name": "莉娅", "owner_user_id": "attacker_selected_owner"},
self.ctx,
)
other_ctx = RequestContext.from_astrbot(
username="guest",
user_id="user_002",
permissions={"can_write"},
)
self.assertEqual(profile.owner_user_id, "user_001")
for operation in (
lambda: self.service.get_profile(profile.profile_id, other_ctx),
lambda: self.service.update_profile(profile.profile_id, {"name": "stolen"}, other_ctx),
lambda: self.service.delete_profile(profile.profile_id, other_ctx),
):
with self.assertRaises(ApiError) as raised:
operation()
self.assertEqual(raised.exception.error_code, ErrorCode.RESOURCE_NOT_FOUND)
def test_wildcard_permission_does_not_bypass_profile_ownership(self):
profile = self.service.create_profile({"name": "莉娅"}, self.ctx)
system_like_other_user = RequestContext.from_astrbot(
username="root",
user_id="user_999",
permissions={"*"},
)
with self.assertRaises(ApiError) as raised:
self.service.get_profile(profile.profile_id, system_like_other_user)
self.assertEqual(raised.exception.error_code, ErrorCode.RESOURCE_NOT_FOUND)
def test_profile_repository_pagination_is_normalized(self):
for index in range(3):
self.service.create_profile({"name": f"Nova {index}"}, self.ctx)
zero_size = self.service.repository.list(owner_user_id=self.ctx.actor_id, page=0, page_size=0)
huge_size = self.service.repository.list(owner_user_id=self.ctx.actor_id, page=1, page_size=999)
self.assertEqual(zero_size.page, 1)
self.assertEqual(zero_size.page_size, 1)
self.assertEqual(len(zero_size.items), 1)
self.assertEqual(huge_size.page_size, 100)
self.assertEqual(huge_size.total, 3)
def test_profile_list_reports_generation_kind_from_workflow_types(self):
text_profile = self.service.create_profile({"name": "纯文本"}, self.ctx)
quick_draft_profile = self.service.create_profile({"name": "快速档案文本"}, self.ctx)
quick_profile = self.service.create_profile({"name": "快速角色"}, self.ctx)
detailed_profile = self.service.create_profile({"name": "详细角色"}, self.ctx)
fallback_quick_profile = self.service.create_profile({"name": "取消详细后快速"}, self.ctx)
conn = self.database.connect()
try:
conn.executemany(
"""
INSERT INTO profile_workflows (
workflow_id, profile_id, workflow_type, display_name, status
) VALUES (?, ?, ?, ?, ?)
""",
[
("workflow_quick_draft", quick_draft_profile.profile_id, "quick_profile", "Draft", "completed"),
("workflow_quick", quick_profile.profile_id, "character_fast", "Fast", "running"),
("workflow_detailed", detailed_profile.profile_id, "character_gradual", "Detailed", "draft"),
("workflow_cancelled", text_profile.profile_id, "character_gradual", "Cancelled", "cancelled"),
("workflow_cancelled_fast", text_profile.profile_id, "character_fast", "Cancelled fast", "cancelled"),
("workflow_fast_older", detailed_profile.profile_id, "character_fast", "Fast older", "completed"),
("workflow_cancelled_detailed", fallback_quick_profile.profile_id, "character_gradual", "Cancelled detailed", "cancelled"),
("workflow_fallback_fast", fallback_quick_profile.profile_id, "character_fast", "Fallback fast", "running"),
],
)
conn.commit()
finally:
conn.close()
kinds = {
profile.profile_id: profile.generation_kind
for profile in self.service.list_profiles(ctx=self.ctx).items
}
self.assertEqual(kinds[text_profile.profile_id], "ungenerated")
self.assertEqual(kinds[quick_draft_profile.profile_id], "ungenerated")
self.assertEqual(kinds[quick_profile.profile_id], "quick")
self.assertEqual(kinds[detailed_profile.profile_id], "detailed")
self.assertEqual(kinds[fallback_quick_profile.profile_id], "quick")
self.assertEqual(self.service.get_profile(detailed_profile.profile_id).to_dict()["generation_kind"], "detailed")
def test_create_profile_requires_name(self):
with self.assertRaises(ApiError) as raised:
self.service.create_profile({"name": " "}, self.ctx)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,176 +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",
"metadata": {
"node_injection_kind": "portrait_generation",
"user_instruction": "把眼神改得更坚定",
"selected_draft_image_ids": ["img_draft_001"],
},
"dependency_context": {
"dependency_count": 1,
"prompt_context": "approved headshot, silver hair",
"selected_image_ids": ["img_headshot_001"],
"dependencies": [],
"material_bindings": {
"schema_version": "2026-07-09.material-binding-schema.v1",
"target_node_key": "headshot",
"generation_params": {"reference_material_ids": ["mat_style"]},
"active_bindings": [{"category": "风格"}],
},
},
},
)
self.assertEqual(
result["prompt"],
"portrait of Nova, silver hair, soft watercolor, calm expression, approved headshot, white blouse",
)
self.assertEqual(result["prompt"].count("silver hair"), 1)
self.assertEqual(result["negative_prompt"], "low quality, bad hands, watermark")
self.assertEqual(result["source"], "profile_node")
self.assertEqual(result["node_injection"]["version"], "2026-07-09.node-injection-schema.v1")
self.assertEqual(result["node_injection"]["template_kind"], "portrait_generation")
self.assertEqual(result["node_injection"]["language_policy"]["target_prompt_language"], "en")
self.assertEqual(result["node_injection"]["user_instruction"]["raw_text"], "把眼神改得更坚定")
self.assertEqual(result["node_injection"]["dependency_context"]["selected_image_ids"], ["img_headshot_001"])
self.assertEqual(result["node_injection"]["material_bindings"]["generation_params"]["reference_material_ids"], ["mat_style"])
self.assertEqual(result["node_injection"]["selected_draft_image_ids"], ["img_draft_001"])
def test_expand_for_node_includes_prompt_plan_context(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={},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
node = WorkflowNode(
node_id="node_headshot",
workflow_id="workflow_001",
node_key="headshot",
title="Headshot",
description=None,
step_name=None,
node_type="generation",
status="draft",
branch_name="main",
prompt="base headshot",
negative_prompt="bad hands",
model_route="image_low",
selected_image_id=None,
sort_order=40,
metadata={},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
result = PromptExpansionService().expand_for_node(
profile,
node,
{
"dependency_context": {
"prompt_plan": {
"schema_version": "2026-07-09.prompt-plan-schema.v1",
"target_node_key": "headshot",
"generation_params": {
"prompt_patch": "clear eyes, stronger face lock",
"negative_patch": "duplicate face",
},
}
}
},
)
self.assertEqual(
result["prompt"],
"portrait of Nova, silver hair, soft watercolor, base headshot, clear eyes, stronger face lock",
)
self.assertEqual(result["negative_prompt"], "low quality, bad hands, duplicate face")
self.assertEqual(result["node_injection"]["prompt_plan"]["target_node_key"], "headshot")
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,115 +0,0 @@
from __future__ import annotations
import unittest
from backend.dto.workflow_dto import WorkflowNode
from backend.services.prompt_plan_schema_service import (
PROMPT_PLAN_SCHEMA_VERSION,
node_prompt_plan_view,
normalize_prompt_plan,
)
class PromptPlanSchemaServiceTests(unittest.TestCase):
def test_normalize_prompt_plan_indexes_matrix_by_target_and_node(self):
headshot = _node("node_headshot", "headshot", "Headshot")
half_body = _node("node_half_body", "half_body", "Half body")
full_body = _node("node_full_body", "full_body", "Full body")
normalized = normalize_prompt_plan(
{
"profile_id": "profile_001",
"profile_name": "Nova",
"items": [
{
"id": "portrait",
"title": "头像节点",
"prompt": "Nova, face reference, clear eyes",
"negative": "low quality, blurry",
"weight": "face identity 1.25",
"weightBasis": "lock identity first",
"inherits": ["name", "hair", "eyes"],
"status": "ready",
},
{
"id": "fullbody",
"title": "全身节点",
"prompt": "Nova, full body standing pose",
"negative": "bad anatomy",
"weight_changes": [{"label": "body proportion", "value": 1.18, "reason": "keep silhouette"}],
"conflicts": ["shoe and accessory inheritance needs review"],
"status": "review",
},
],
"guard_checks": [
{"label": "冲突检查", "value": "shoe and accessory inheritance needs review", "status": "review"}
],
},
[headshot, half_body, full_body],
)
self.assertEqual(normalized["schema_version"], PROMPT_PLAN_SCHEMA_VERSION)
self.assertEqual(normalized["summary"]["target_count"], 2)
self.assertEqual(normalized["summary"]["review_count"], 1)
self.assertEqual(normalized["summary"]["conflict_count"], 2)
self.assertIn("portrait", normalized["by_target"])
self.assertIn("headshot", normalized["by_node_key"])
self.assertIn("full_body", normalized["by_node_key"])
self.assertIn(headshot.node_id, normalized["by_node_id"])
self.assertNotIn(half_body.node_id, normalized["by_node_id"])
headshot_view = node_prompt_plan_view(normalized, headshot)
self.assertTrue(headshot_view["has_prompt_plan"])
self.assertEqual(headshot_view["generation_params"]["prompt_patch"], "Nova, face reference, clear eyes")
self.assertEqual(headshot_view["generation_params"]["negative_patch"], "low quality, blurry")
self.assertEqual(headshot_view["generation_params"]["inheritance_fields"], ["name", "hair", "eyes"])
def test_llm_update_shape_is_accepted(self):
headshot = _node("node_headshot", "headshot", "Headshot")
normalized = normalize_prompt_plan(
{
"updates": [
{
"target": "portrait",
"positive_patch": "clearer gaze, stronger face lock",
"negative_patch": "duplicate face",
"weight_suggestions": [{"label": "eye color", "value": 1.18}],
"inheritance_changes": ["preserve silver hair"],
}
],
"guardrails": {"negative_prompt": "duplicate face"},
},
[headshot],
)
view = node_prompt_plan_view(normalized, headshot)
self.assertEqual(view["generation_params"]["prompt_patch"], "clearer gaze, stronger face lock")
self.assertEqual(view["generation_params"]["negative_patch"], "duplicate face")
self.assertEqual(view["generation_params"]["weight_suggestions"][0]["label"], "eye color")
def _node(node_id: str, node_key: str, title: str) -> WorkflowNode:
return WorkflowNode(
node_id=node_id,
workflow_id="workflow_001",
node_key=node_key,
title=title,
description=None,
step_name=node_key,
node_type="generation",
status="draft",
branch_name="main",
prompt=None,
negative_prompt=None,
model_route=None,
selected_image_id=None,
sort_order=1,
metadata={},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,152 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch
from backend.dto.common import ApiError, ErrorCode
from backend.services.queue_service import QueueService
from core.audit_service import AuditService
from core.event_bus import EventBus
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.job_repository import JobRepository
class QueueServiceTests(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.event_bus = EventBus()
self.queue_service = QueueService(JobRepository(self.database), self.audit_service, self.event_bus)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
def tearDown(self):
self.tmp.cleanup()
def test_create_task_reuses_existing_idempotency_key(self):
first = self.queue_service.create_task(
{
"status": "queued",
"idempotency_key": "generate-node-001",
"request": {"prompt": "portrait"},
},
self.ctx,
)
second = self.queue_service.create_task(
{
"status": "queued",
"idempotency_key": " generate-node-001 ",
"request": {"prompt": "different prompt"},
},
self.ctx,
)
self.assertEqual(first.task_id, second.task_id)
self.assertEqual(second.request, {"prompt": "portrait"})
self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 1)
self.assertEqual(len(self.event_bus.history("generation.task_created")), 1)
def test_blank_idempotency_key_is_treated_as_missing(self):
first = self.queue_service.create_task({"status": "queued", "idempotency_key": " "}, self.ctx)
second = self.queue_service.create_task({"status": "queued", "idempotency_key": ""}, self.ctx)
self.assertNotEqual(first.task_id, second.task_id)
self.assertIsNone(first.idempotency_key)
self.assertIsNone(second.idempotency_key)
def test_cancel_job_records_actor_reason_and_is_idempotent(self):
task = self.queue_service.create_task({"status": "running", "metadata": {"worker_attempt": 1}}, self.ctx)
cancelled = self.queue_service.cancel_job(task.task_id, self.ctx, reason="user stopped")
repeated = self.queue_service.cancel_job(task.task_id, self.ctx, reason="ignored")
self.assertEqual(cancelled.status, "cancelled")
self.assertEqual(repeated.task_id, task.task_id)
self.assertEqual(repeated.metadata["cancellation"]["reason"], "user stopped")
self.assertEqual(cancelled.metadata["cancellation"]["requested_by"], "user_001")
self.assertEqual(cancelled.metadata["cancellation"]["previous_status"], "running")
self.assertTrue(self.queue_service.is_cancelled(task.task_id))
def test_retrying_task_cannot_be_cancelled_mid_execution(self):
task = self.queue_service.create_task({"status": "failed"}, self.ctx)
claimed = self.queue_service.begin_retry(task.task_id, self.ctx, operation_id="retry_test")
with self.assertRaises(ApiError) as raised:
self.queue_service.cancel_job(claimed.task_id, self.ctx)
self.assertEqual(raised.exception.error_code, ErrorCode.TASK_NOT_CANCELABLE)
self.assertEqual(self.queue_service.get_job(task.task_id).status, "retrying")
def test_cancel_job_does_not_overwrite_terminal_state_from_stale_snapshot(self):
task = self.queue_service.create_task({"status": "running"}, self.ctx)
repository = self.queue_service.repository
original_update_if_status = repository.update_if_status
injected_terminal_update = False
def finish_before_cancel(task_id, expected_statuses, payload):
nonlocal injected_terminal_update
if not injected_terminal_update:
injected_terminal_update = True
repository.update(task_id, {"status": "succeeded", "progress": 100})
return original_update_if_status(task_id, expected_statuses, payload)
with patch.object(repository, "update_if_status", side_effect=finish_before_cancel):
with self.assertRaises(ApiError) as raised:
self.queue_service.cancel_job(task.task_id, self.ctx, reason="stale cancel")
self.assertEqual(raised.exception.error_code, ErrorCode.TASK_NOT_CANCELABLE)
self.assertEqual(raised.exception.details["status"], "succeeded")
completed = self.queue_service.get_job(task.task_id)
self.assertEqual(completed.status, "succeeded")
self.assertNotIn("cancellation", completed.metadata)
def test_dead_letter_batch_limits_are_normalized(self):
for index in range(3):
self.queue_service.create_task({"status": "failed", "error_message": f"failure {index}"}, self.ctx)
none_moved = self.queue_service.move_failed_to_dead_letter(self.ctx, limit=0)
self.assertEqual(none_moved["total"], 1)
self.assertEqual(self.queue_service.queue_summary()["dead_letter"], 1)
moved = self.queue_service.move_failed_to_dead_letter(self.ctx, limit=999)
self.assertEqual(moved["total"], 2)
requeued = self.queue_service.requeue_dead_letters(self.ctx, limit=-5)
self.assertEqual(requeued["total"], 1)
self.assertEqual(self.queue_service.queue_summary()["dead_letter"], 2)
def test_recent_job_limit_is_normalized(self):
repository = self.queue_service.repository
for index in range(3):
self.queue_service.create_task({"status": "queued", "request": {"index": index}}, self.ctx)
self.assertEqual(len(repository.recent(limit=0)), 1)
self.assertEqual(len(repository.recent(limit=-5)), 1)
self.assertEqual(len(repository.recent(limit=999)), 3)
def test_job_repository_pagination_is_normalized(self):
repository = self.queue_service.repository
for index in range(3):
self.queue_service.create_task({"status": "queued", "request": {"index": index}}, self.ctx)
zero_items, zero_total = repository.list(page=0, page_size=0)
huge_items, huge_total = repository.list(page=1, page_size=999)
self.assertEqual(len(zero_items), 1)
self.assertEqual(zero_total, 3)
self.assertEqual(len(huge_items), 3)
self.assertEqual(huge_total, 3)
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,108 +0,0 @@
from __future__ import annotations
import shutil
import unittest
from pathlib import Path
from uuid import uuid4
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 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 QuickProfileServiceTests(unittest.TestCase):
def setUp(self):
self.tmp_path = Path(".tmp") / f"test_quick_profile_service_{uuid4().hex}"
self.tmp_path.mkdir(parents=True, exist_ok=False)
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(self.tmp_path / "imagestudio.db")))
)
self.database.initialize()
self.profile_repository = ProfileRepository(self.database)
self.workflow_repository = WorkflowRepository(self.database)
self.audit_service = AuditService(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.quick_service = QuickProfileService()
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
def tearDown(self):
shutil.rmtree(self.tmp_path, ignore_errors=True)
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, "create_workflow": True},
self.profile_service,
self.ctx,
self.workflow_service,
)
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"])
self.assertEqual(saved["workflow"]["profile_id"], profile.profile_id)
self.assertEqual(saved["workflow"]["workflow_type"], "quick_profile")
self.assertEqual(saved["workflow"]["metadata"]["source"], "quick_profile")
self.assertEqual(saved["workflow"]["metadata"]["draft_id"], draft["draft_id"])
self.assertEqual([node["node_key"] for node in saved["nodes"]], ["questionnaire", "preview"])
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")
self.assertEqual(allowed["data"]["workflow"]["workflow_type"], "quick_profile")
self.assertEqual([node["node_key"] for node in allowed["data"]["nodes"]], ["questionnaire", "preview"])
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,42 +0,0 @@
from __future__ import annotations
import ipaddress
import unittest
from unittest.mock import patch
from core.remote_fetch import RemoteFetchError, validate_http_url
from engines.image_provider import ImageProviderError
from engines.single_flow import MAX_PROVIDER_IMAGE_BYTES, _image_bytes
class RemoteFetchSafetyTests(unittest.TestCase):
def test_rejects_non_http_and_private_targets(self):
with self.assertRaises(RemoteFetchError):
validate_http_url("file:///etc/passwd")
with patch("core.remote_fetch._resolve_addresses", return_value={ipaddress.ip_address("127.0.0.1")}):
with self.assertRaises(RemoteFetchError):
validate_http_url("http://localhost/internal")
with patch("core.remote_fetch._resolve_addresses", return_value={ipaddress.ip_address("100.64.0.1")}):
with self.assertRaises(RemoteFetchError):
validate_http_url("http://overlay.internal/image.png")
with self.assertRaises(RemoteFetchError):
validate_http_url("https://example.test:invalid/image.png")
def test_allows_explicit_private_provider_host(self):
with patch("core.remote_fetch._resolve_addresses", return_value={ipaddress.ip_address("127.0.0.1")}):
validate_http_url("http://localhost/image.png", allowed_private_hosts={"localhost"})
def test_image_payload_rejects_invalid_and_oversized_base64(self):
with self.assertRaises(ImageProviderError):
_image_bytes("bm90LWFuLWltYWdl", None, provider_id="test")
oversized = "A" * ((((MAX_PROVIDER_IMAGE_BYTES + 2) // 3) * 4) + 4)
with self.assertRaises(ImageProviderError):
_image_bytes(oversized, None, provider_id="test")
if __name__ == "__main__":
unittest.main()

查看文件

@ -1,320 +0,0 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.review_routes import (
get_review_policy,
review_node,
review_workflow,
save_review_policy,
validate_review_policy,
)
from backend.services.history_service import HistoryService
from backend.services.image_service import ImageService
from backend.services.profile_service import ProfileService
from backend.services.review_service import ReviewService
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 ReviewServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.config_path = Path(self.tmp.name) / "config.yaml"
self.config_service = ConfigService(self.config_path)
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.history_service = HistoryService(
self.workflow_repository,
self.workflow_service,
self.image_service,
self.audit_service,
)
self.review_service = ReviewService(self.workflow_service, self.image_repository, config_service=self.config_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write", "can_manage_config"},
)
self.profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx)
self.workflow = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_fast", "display_name": "Fast"},
self.ctx,
)
def tearDown(self):
self.tmp.cleanup()
def test_review_node_warns_without_images_and_errors_without_selected_image(self):
node = self.workflow.nodes[0]
empty = self.review_service.review_node(node.node_id)
self.assertTrue(empty["passed"])
self.assertEqual(empty["warnings"][0]["code"], "NO_IMAGES")
self.workflow_service.update_node(node.node_id, {"status": "completed"}, self.ctx)
missing_selection = self.review_service.review_node(node.node_id)
self.assertFalse(missing_selection["passed"])
self.assertEqual(missing_selection["errors"][0]["code"], "MISSING_SELECTED_IMAGE")
def test_review_passes_after_image_adoption(self):
node = self.workflow.nodes[1]
image = self.image_service.create_image(
{
"node_id": node.node_id,
"image_uri": "storage://images/fast.png",
"positive_prompt": "fast character",
"model_route": "image_low",
"metadata": {"review_score": 91},
},
self.ctx,
)
self.history_service.adopt_node_image(node.node_id, {"image_id": image.image_id}, 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.assertEqual(result["stage_review"]["schema_version"], "2026-07-09.stage-review-result.v1")
self.assertEqual(result["stage_review"]["review_mode"], "same_prompt_multi_model")
self.assertEqual(result["stage_review"]["selected_candidate"]["image_id"], image.image_id)
self.assertEqual(result["stage_review"]["candidates"][0]["score"]["value"], 91)
self.assertEqual(result["stage_review"]["manual_confirmation"]["endpoint"], f"nodes/{node.node_id}/adopt-image")
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_stage_result_tracks_multi_model_regeneration_candidates(self):
node = self.workflow.nodes[1]
self.workflow_service.update_node(
node.node_id,
{"status": "completed", "prompt": "portrait, silver hair", "model_route": "image_low"},
self.ctx,
)
source = self.image_service.create_image(
{
"node_id": node.node_id,
"image_uri": "storage://images/source.png",
"positive_prompt": "portrait, silver hair",
"model_route": "image_low",
"is_selected": True,
},
self.ctx,
)
rerun = self.image_service.create_image(
{
"node_id": node.node_id,
"image_uri": "storage://images/rerun.png",
"positive_prompt": "portrait, silver hair",
"model_route": "image_high",
"metadata": {
"same_prompt_regeneration": True,
"regenerated_from_image_id": source.image_id,
"regeneration_attempt": 2,
"review_defects": ["face drift"],
},
},
self.ctx,
)
result = self.review_service.review_node(node.node_id)
self.assertEqual(len(result["stage_review"]["candidates"]), 2)
self.assertEqual(result["stage_review"]["selected_candidate"]["image_id"], source.image_id)
self.assertEqual(result["stage_review"]["regeneration_records"][0]["image_id"], rerun.image_id)
self.assertEqual(result["stage_review"]["regeneration_records"][0]["source_image_id"], source.image_id)
self.assertEqual(result["stage_review"]["regeneration_records"][0]["attempt"], 2)
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_workflow_fails_when_generation_nodes_are_incomplete(self):
result = self.review_service.review_workflow(self.workflow.workflow.workflow_id)
self.assertFalse(result["passed"])
incomplete_error = next(
error for error in result["errors"] if error["code"] == "INCOMPLETE_GENERATION_NODES"
)
self.assertEqual(incomplete_error["node_ids"], [node.node_id for node in self.workflow.nodes])
self.assertIn("INCOMPLETE_NODES", [warning["code"] for warning in result["warnings"]])
def test_review_single_image_workflow_fails_until_virtual_node_is_finished(self):
workflow = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "single_image", "display_name": "Single image"},
self.ctx,
)
result = self.review_service.review_workflow(workflow.workflow.workflow_id)
self.assertFalse(result["passed"])
self.assertEqual(
next(error for error in result["errors"] if error["code"] == "INCOMPLETE_GENERATION_NODES")[
"node_ids"
],
[workflow.nodes[0].node_id],
)
def test_review_routes_require_authentication(self):
node = self.workflow.nodes[0]
response = review_node(self.ctx, node.node_id, self.review_service)
self.assertTrue(response["ok"])
workflow_response = review_workflow(self.ctx, self.workflow.workflow.workflow_id, self.review_service)
self.assertTrue(workflow_response["ok"])
self.assertEqual(workflow_response["data"]["summary"]["node_count"], 3)
anonymous = RequestContext()
denied = review_node(anonymous, node.node_id, self.review_service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "UNAUTHORIZED")
def test_review_policy_is_exposed_and_validated(self):
policy_response = get_review_policy(self.ctx, self.review_service)
self.assertTrue(policy_response["ok"])
self.assertEqual(policy_response["data"]["version"], "default-v1")
self.assertIn("completed", policy_response["data"]["require_selected_image_for_statuses"])
valid_response = validate_review_policy(
self.ctx,
{
"version": "custom-v1",
"warn_without_images": False,
"require_selected_image_for_statuses": ["selected"],
"workflow_terminal_statuses": ["selected", "skipped"],
},
self.review_service,
)
self.assertTrue(valid_response["ok"])
self.assertTrue(valid_response["data"]["valid"])
self.assertFalse(valid_response["data"]["policy"]["warn_without_images"])
self.assertEqual(valid_response["data"]["policy"]["version"], "custom-v1")
invalid_response = validate_review_policy(
self.ctx,
{
"warn_without_images": "yes",
"workflow_terminal_statuses": ["selected", "unknown"],
},
self.review_service,
)
self.assertTrue(invalid_response["ok"])
self.assertFalse(invalid_response["data"]["valid"])
self.assertEqual(
[error["code"] for error in invalid_response["data"]["errors"]],
["INVALID_BOOLEAN", "UNKNOWN_STATUS"],
)
def test_review_policy_validation_requires_config_permission(self):
read_only = RequestContext.from_astrbot(username="reader", user_id="user_002", permissions=set())
response = validate_review_policy(read_only, {}, self.review_service)
self.assertFalse(response["ok"])
self.assertEqual(response["error_code"], "FORBIDDEN")
def test_review_policy_can_be_saved_and_reloaded(self):
saved = save_review_policy(
self.ctx,
{
"version": "custom-v2",
"warn_without_images": False,
"require_selected_image_for_statuses": ["selected"],
"workflow_terminal_statuses": ["selected", "skipped"],
},
self.review_service,
)
self.assertTrue(saved["ok"])
self.assertTrue(saved["data"]["saved"])
self.assertEqual(saved["data"]["policy"]["version"], "custom-v2")
self.assertIn("review_policy:", self.config_path.read_text(encoding="utf-8"))
reloaded = ReviewService(self.workflow_service, self.image_repository, config_service=self.config_service)
self.assertEqual(reloaded.get_policy()["version"], "custom-v2")
self.assertFalse(reloaded.get_policy()["warn_without_images"])
invalid = save_review_policy(
self.ctx,
{
"warn_without_images": "no",
"workflow_terminal_statuses": ["unknown"],
},
self.review_service,
)
self.assertFalse(invalid["ok"])
self.assertEqual(invalid["error_code"], "VALIDATION_FAILED")
if __name__ == "__main__":
unittest.main()

某些文件未显示,因为此 diff 中更改的文件太多 显示更多