511 行
24 KiB
Python
511 行
24 KiB
Python
"""Wardrobe service and matching."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import sqlite3
|
|
from typing import Any
|
|
from uuid import uuid4
|
|
|
|
from backend.dto.common import ApiError, ErrorCode
|
|
from backend.dto.wardrobe_dto import WardrobeItem
|
|
from backend.services.composition_builder import (
|
|
ADVANCED_VERIFIED_PRIORITY_BONUS,
|
|
CompositionBuilder,
|
|
CompositionPlan,
|
|
)
|
|
from backend.services.material_catalog_resolver import (
|
|
MaterialCatalogResolver,
|
|
is_trusted_advanced_metadata,
|
|
)
|
|
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
|
|
from database.repositories.profile_repository import ProfileRepository
|
|
from database.repositories.wardrobe_repository import (
|
|
AdvancedWardrobeRepository,
|
|
WardrobeRepository,
|
|
)
|
|
|
|
|
|
DEFAULT_WARDROBE_CATEGORIES = ("top", "bottom", "dress", "shoes", "accessory")
|
|
|
|
|
|
class WardrobeService:
|
|
def __init__(
|
|
self,
|
|
wardrobe_repository: WardrobeRepository,
|
|
profile_repository: ProfileRepository,
|
|
material_repository: MaterialRepository,
|
|
audit_service: AuditService,
|
|
advanced_wardrobe_repository: AdvancedWardrobeRepository | None = None,
|
|
material_catalog: MaterialCatalogResolver | None = None,
|
|
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.advanced_wardrobe_repository = advanced_wardrobe_repository
|
|
self.material_catalog = material_catalog
|
|
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)
|
|
material_id = str(payload.get("material_id") or "").strip()
|
|
wardrobe_category = str(payload.get("wardrobe_category") or "").strip()
|
|
if not material_id:
|
|
raise ApiError(ErrorCode.VALIDATION_FAILED, "material_id is required", {"field": "material_id"})
|
|
if not wardrobe_category:
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"wardrobe_category is required",
|
|
{"field": "wardrobe_category"},
|
|
)
|
|
material = self._get_catalog_material(material_id)
|
|
if material is None or material.recognition_status != "confirmed":
|
|
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "confirmed material not found", {"material_id": material_id})
|
|
repository = self._repository_for_material_id(material_id)
|
|
duplicate = next(
|
|
(
|
|
existing
|
|
for existing in repository.list_by_profile(profile_id, wardrobe_category)
|
|
if existing.material_id == material_id
|
|
),
|
|
None,
|
|
)
|
|
if duplicate is not None:
|
|
raise _duplicate_wardrobe_item_error(profile_id, material_id, wardrobe_category, duplicate.wardrobe_item_id)
|
|
try:
|
|
item = repository.create(
|
|
{
|
|
"wardrobe_item_id": payload.get("wardrobe_item_id") or new_wardrobe_item_id(),
|
|
"profile_id": profile_id,
|
|
"material_id": material_id,
|
|
"wardrobe_category": wardrobe_category,
|
|
"tags": payload.get("tags") or material.tags,
|
|
"season": payload.get("season"),
|
|
"style": payload.get("style"),
|
|
"is_favorite": payload.get("is_favorite", False),
|
|
}
|
|
)
|
|
except Exception as exc:
|
|
if not _is_unique_constraint_error(exc):
|
|
raise
|
|
raise _duplicate_wardrobe_item_error(profile_id, material_id, wardrobe_category) from None
|
|
self.audit_service.record(
|
|
ctx=ctx,
|
|
action="add_wardrobe_item",
|
|
target_type="wardrobe_item",
|
|
target_id=item.wardrobe_item_id,
|
|
after_snapshot=item.to_dict(),
|
|
)
|
|
return item
|
|
|
|
def list_items(
|
|
self,
|
|
profile_id: str,
|
|
wardrobe_category: str | None,
|
|
ctx: RequestContext,
|
|
) -> list[WardrobeItem]:
|
|
self._ensure_profile(profile_id, ctx)
|
|
items = self.wardrobe_repository.list_by_profile(profile_id, wardrobe_category)
|
|
if self.advanced_wardrobe_repository is not None:
|
|
items.extend(self.advanced_wardrobe_repository.list_by_profile(profile_id, wardrobe_category))
|
|
return sorted(items, key=lambda item: (item.is_favorite, item.created_at), reverse=True)
|
|
|
|
def delete_item(self, profile_id: str, wardrobe_item_id: str, ctx: RequestContext) -> WardrobeItem:
|
|
self._ensure_profile(profile_id, ctx)
|
|
repository, before = self._find_wardrobe_item(wardrobe_item_id)
|
|
if before is None or before.profile_id != profile_id:
|
|
raise ApiError(
|
|
ErrorCode.RESOURCE_NOT_FOUND,
|
|
"wardrobe item not found",
|
|
{"wardrobe_item_id": wardrobe_item_id},
|
|
)
|
|
deleted = repository.delete(wardrobe_item_id)
|
|
assert deleted is not None
|
|
self.audit_service.record(
|
|
ctx=ctx,
|
|
action="delete_wardrobe_item",
|
|
target_type="wardrobe_item",
|
|
target_id=wardrobe_item_id,
|
|
before_snapshot=deleted.to_dict(),
|
|
)
|
|
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.list_items(profile_id, None, ctx)}
|
|
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.list_items(profile_id, None, ctx)
|
|
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._get_catalog_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"))
|
|
if not categories:
|
|
categories = list(DEFAULT_WARDROBE_CATEGORIES)
|
|
context = _match_context(payload)
|
|
selected: list[dict[str, Any]] = []
|
|
missing_categories: list[str] = []
|
|
material_options = payload.get("material_options") if isinstance(payload.get("material_options"), dict) else {}
|
|
for category in categories:
|
|
candidates = self._list_category_candidates(profile_id, str(category))
|
|
if not candidates:
|
|
missing_categories.append(str(category))
|
|
continue
|
|
scored_candidates = []
|
|
for index, item in enumerate(candidates):
|
|
material = self._get_catalog_material(item.material_id)
|
|
if material is None or material.recognition_status != "confirmed":
|
|
continue
|
|
score, breakdown = _score_candidate(item, material, context)
|
|
scored_candidates.append((score, -index, item, material, breakdown))
|
|
if not scored_candidates:
|
|
missing_categories.append(str(category))
|
|
continue
|
|
score, _order, item, material, breakdown = max(scored_candidates, key=lambda candidate: (candidate[0], candidate[1]))
|
|
self._repository_for_item(item).mark_used(item.wardrobe_item_id)
|
|
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,
|
|
),
|
|
"tags": item.tags,
|
|
"season": item.season,
|
|
"style": item.style,
|
|
"is_favorite": item.is_favorite,
|
|
"usage_count": item.usage_count,
|
|
"score": score,
|
|
"score_breakdown": breakdown,
|
|
"library_kind": item.library_kind,
|
|
**(
|
|
material_options.get(material.material_id)
|
|
if isinstance(material_options.get(material.material_id), dict)
|
|
else {}
|
|
),
|
|
}
|
|
)
|
|
fallback_strategy = _fallback_outfit_strategy(payload, categories, missing_categories, selected, context)
|
|
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,
|
|
"outfit_prompt": outfit_prompt,
|
|
"fallback_used": not selected,
|
|
"fallback_supplement_used": bool(selected and missing_categories),
|
|
"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,
|
|
"matched_count": len(selected),
|
|
"keywords": sorted(context["keywords"]),
|
|
"requested_tags": sorted(context["requested_tags"]),
|
|
"season": context["season"],
|
|
"style": context["style"],
|
|
},
|
|
}
|
|
self.audit_service.record(
|
|
ctx=ctx,
|
|
action="wardrobe_match",
|
|
target_type="character_profile",
|
|
target_id=profile_id,
|
|
after_snapshot=result,
|
|
)
|
|
return result
|
|
|
|
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 _get_catalog_material(self, material_id: str):
|
|
if self.material_catalog is not None:
|
|
return self.material_catalog.get_material(material_id)
|
|
return self.material_repository.get_material(material_id)
|
|
|
|
def _repository_for_material_id(self, material_id: str) -> WardrobeRepository:
|
|
if (
|
|
self.advanced_wardrobe_repository is not None
|
|
and self.material_catalog is not None
|
|
and str(material_id or "").startswith("advmat_")
|
|
):
|
|
return self.advanced_wardrobe_repository
|
|
return self.wardrobe_repository
|
|
|
|
def _repository_for_item(self, item: WardrobeItem) -> WardrobeRepository:
|
|
if item.library_kind == "advanced" and self.advanced_wardrobe_repository is not None:
|
|
return self.advanced_wardrobe_repository
|
|
return self.wardrobe_repository
|
|
|
|
def _find_wardrobe_item(self, wardrobe_item_id: str) -> tuple[WardrobeRepository, WardrobeItem | None]:
|
|
standard = self.wardrobe_repository.get(wardrobe_item_id)
|
|
if standard is not None:
|
|
return self.wardrobe_repository, standard
|
|
if self.advanced_wardrobe_repository is not None:
|
|
advanced = self.advanced_wardrobe_repository.get(wardrobe_item_id)
|
|
if advanced is not None:
|
|
return self.advanced_wardrobe_repository, advanced
|
|
return self.wardrobe_repository, None
|
|
|
|
def _list_category_candidates(self, profile_id: str, category: str) -> list[WardrobeItem]:
|
|
candidates = self.wardrobe_repository.list_by_profile(profile_id, category)
|
|
if self.advanced_wardrobe_repository is not None:
|
|
candidates.extend(self.advanced_wardrobe_repository.list_by_profile(profile_id, category))
|
|
return candidates
|
|
|
|
|
|
def new_wardrobe_item_id() -> str:
|
|
return f"wardrobe_{uuid4().hex}"
|
|
|
|
|
|
def _duplicate_wardrobe_item_error(
|
|
profile_id: str,
|
|
material_id: str,
|
|
wardrobe_category: str,
|
|
wardrobe_item_id: str | None = None,
|
|
) -> ApiError:
|
|
details: dict[str, Any] = {
|
|
"profile_id": profile_id,
|
|
"material_id": material_id,
|
|
"wardrobe_category": wardrobe_category,
|
|
}
|
|
if wardrobe_item_id:
|
|
details["wardrobe_item_id"] = wardrobe_item_id
|
|
return ApiError(ErrorCode.VALIDATION_FAILED, "material already exists in wardrobe category", details)
|
|
|
|
|
|
def _is_unique_constraint_error(exc: Exception) -> bool:
|
|
if isinstance(exc, sqlite3.IntegrityError):
|
|
return True
|
|
return getattr(exc, "sqlstate", None) == "23505" or getattr(exc, "pgcode", None) == "23505"
|
|
|
|
|
|
def _normalize_categories(value: Any) -> list[str]:
|
|
if not isinstance(value, list):
|
|
return []
|
|
categories = []
|
|
for item in value:
|
|
category = str(item or "").strip()
|
|
if category and category not in categories:
|
|
categories.append(category)
|
|
return categories
|
|
|
|
|
|
def _match_context(payload: dict[str, Any]) -> dict[str, Any]:
|
|
keywords = _text_set(payload.get("keywords"))
|
|
requested_tags = _text_set(payload.get("tags")) | keywords
|
|
season = _optional_lower(payload.get("season"))
|
|
style = _optional_lower(payload.get("style"))
|
|
mood = _optional_lower(payload.get("mood"))
|
|
weather = _optional_lower(payload.get("weather"))
|
|
for value in (season, style, mood, weather):
|
|
if value:
|
|
requested_tags.add(value)
|
|
return {
|
|
"keywords": keywords,
|
|
"requested_tags": requested_tags,
|
|
"season": season,
|
|
"style": style,
|
|
"mood": mood,
|
|
"weather": weather,
|
|
}
|
|
|
|
|
|
def _score_candidate(item: WardrobeItem, material, context: dict[str, Any]) -> tuple[float, dict[str, float]]:
|
|
item_terms = _text_set(item.tags) | _text_set(material.tags) | _words(material.display_name) | _words(material.prompt)
|
|
requested_tags = context["requested_tags"]
|
|
tag_overlap = len(item_terms & requested_tags)
|
|
prompt_hits = sum(1 for keyword in context["keywords"] if keyword and keyword in _search_blob(item, material))
|
|
breakdown = {
|
|
"category": 50,
|
|
"favorite": 15 if item.is_favorite else 0,
|
|
"freshness": max(0, 10 - min(item.usage_count, 10)),
|
|
"tag_overlap": tag_overlap * 8,
|
|
"prompt_hits": prompt_hits * 3,
|
|
"season": 12 if context["season"] and _optional_lower(item.season) == context["season"] else 0,
|
|
"style": 12 if context["style"] and _optional_lower(item.style) == context["style"] else 0,
|
|
"advanced_verified": ADVANCED_VERIFIED_PRIORITY_BONUS
|
|
if is_trusted_advanced_metadata(getattr(material, "metadata", None))
|
|
else 0,
|
|
}
|
|
return sum(breakdown.values()), breakdown
|
|
|
|
|
|
def _fallback_outfit_strategy(
|
|
payload: dict[str, Any],
|
|
categories: list[str],
|
|
missing_categories: list[str],
|
|
selected: list[dict[str, Any]],
|
|
context: dict[str, Any],
|
|
) -> dict[str, Any]:
|
|
if not missing_categories and selected:
|
|
return {
|
|
"name": None,
|
|
"reason": None,
|
|
"missing_categories": [],
|
|
"prompt": "",
|
|
}
|
|
reason = "missing_categories" if selected else "no_matching_materials"
|
|
target_categories = missing_categories or categories
|
|
descriptors = [_category_fallback(category) for category in target_categories]
|
|
parts = ["daily outfit fallback"]
|
|
for key in ("style", "season", "mood", "weather"):
|
|
if context.get(key):
|
|
parts.append(str(context[key]))
|
|
keywords = payload.get("keywords") if isinstance(payload.get("keywords"), list) else []
|
|
parts.extend(str(keyword).strip() for keyword in keywords if str(keyword).strip())
|
|
if descriptors:
|
|
parts.append("with " + ", ".join(descriptors))
|
|
parts.append("cohesive colors, clean character outfit reference")
|
|
return {
|
|
"name": "random_prompt_generation",
|
|
"reason": reason,
|
|
"missing_categories": target_categories,
|
|
"prompt": ", ".join(parts),
|
|
}
|
|
|
|
|
|
def _category_fallback(category: str) -> str:
|
|
return {
|
|
"top": "coordinated top",
|
|
"bottom": "matching bottom",
|
|
"dress": "one-piece dress alternative",
|
|
"shoes": "matching shoes",
|
|
"accessory": "subtle accessory",
|
|
}.get(str(category), f"matching {category}")
|
|
|
|
|
|
def _search_blob(item: WardrobeItem, material) -> str:
|
|
return " ".join(
|
|
[
|
|
material.display_name or "",
|
|
material.prompt or "",
|
|
" ".join(item.tags),
|
|
" ".join(material.tags),
|
|
item.season or "",
|
|
item.style or "",
|
|
]
|
|
).lower()
|
|
|
|
|
|
def _text_set(value: Any) -> set[str]:
|
|
if isinstance(value, str):
|
|
values = value.split(",")
|
|
elif isinstance(value, list):
|
|
values = value
|
|
elif isinstance(value, tuple):
|
|
values = list(value)
|
|
else:
|
|
values = []
|
|
return {str(item).strip().lower() for item in values if str(item).strip()}
|
|
|
|
|
|
def _words(value: Any) -> set[str]:
|
|
return {part.strip(" ,.;:/\\_-").lower() for part in str(value or "").split() if part.strip(" ,.;:/\\_-")}
|
|
|
|
|
|
def _optional_lower(value: Any) -> str | None:
|
|
text = str(value or "").strip().lower()
|
|
return text or None
|