From c3b4257e08eda51e6c5dd387acab3962c4bf1e13 Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Mon, 6 Jul 2026 03:48:39 +0800 Subject: [PATCH] =?UTF-8?q?S104=20=E7=A9=BF=E6=90=AD=E5=85=9C=E5=BA=95?= =?UTF-8?q?=E7=AD=96=E7=95=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/services/integration_service.py | 26 ++++++++++-- backend/services/wardrobe_service.py | 54 ++++++++++++++++++++++++- tests/test_integration_service.py | 20 +++++++++ tests/test_wardrobe_service.py | 43 ++++++++++++++++++++ 4 files changed, 139 insertions(+), 4 deletions(-) diff --git a/backend/services/integration_service.py b/backend/services/integration_service.py index ab7af32..ed4aca8 100644 --- a/backend/services/integration_service.py +++ b/backend/services/integration_service.py @@ -40,18 +40,23 @@ class IntegrationService: raise error categories = payload.get("categories") or _categories_from_keywords(payload.get("keywords") or []) try: - match = self.wardrobe_service.match(profile_id, {"categories": categories}, ctx) + match = self.wardrobe_service.match(profile_id, _wardrobe_match_payload(payload, categories), ctx) except Exception as exc: self._record_failure(source, payload, exc) raise - fallback_prompt = _fallback_prompt(payload) - final_prompt = match["outfit_prompt"] or fallback_prompt + fallback_prompt = match.get("fallback_prompt") or _fallback_prompt(payload) + final_prompt = _final_prompt(match, fallback_prompt) response = { "matched": bool(match["selected_materials"]), "selected_materials": match["selected_materials"], "final_prompt": final_prompt, "job_id": None, "fallback_used": not bool(match["selected_materials"]), + "fallback_supplement_used": bool(match.get("fallback_supplement_used")), + "fallback_reason": match.get("fallback_reason"), + "fallback_prompt": fallback_prompt if match.get("fallback_reason") else None, + "fallback_strategy": match.get("fallback_strategy"), + "match_details": match.get("match_details"), } self.integration_repository.record( { @@ -105,6 +110,14 @@ def _categories_from_keywords(keywords: list[Any]) -> list[str]: return categories or ["top", "bottom", "dress", "shoes", "accessory"] +def _wardrobe_match_payload(payload: dict[str, Any], categories: list[str]) -> dict[str, Any]: + match_payload = {"categories": categories} + for key in ("keywords", "tags", "mood", "weather", "season", "style"): + if key in payload: + match_payload[key] = payload[key] + return match_payload + + def _fallback_prompt(payload: dict[str, Any]) -> str: parts = ["daily outfit"] for key in ("mood", "weather"): @@ -116,6 +129,13 @@ def _fallback_prompt(payload: dict[str, Any]) -> str: return ", ".join(parts) +def _final_prompt(match: dict[str, Any], fallback_prompt: str) -> str: + outfit_prompt = str(match.get("outfit_prompt") or "").strip() + if match.get("fallback_supplement_used") and outfit_prompt and fallback_prompt: + return f"{outfit_prompt}, {fallback_prompt}" + return outfit_prompt or fallback_prompt + + def _error_code(exc: Exception) -> str: code = getattr(exc, "error_code", None) value = getattr(code, "value", None) diff --git a/backend/services/wardrobe_service.py b/backend/services/wardrobe_service.py index e6f2a5d..11347f7 100644 --- a/backend/services/wardrobe_service.py +++ b/backend/services/wardrobe_service.py @@ -134,11 +134,19 @@ class WardrobeService: ) 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"] result = { "profile_id": profile_id, "selected_materials": selected, - "outfit_prompt": ", ".join(prompt_parts), + "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, "match_details": { "requested_categories": categories, "missing_categories": missing_categories, @@ -216,6 +224,50 @@ def _score_candidate(item: WardrobeItem, material, context: dict[str, Any]) -> t 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( [ diff --git a/tests/test_integration_service.py b/tests/test_integration_service.py index e9e2c66..2afa8d1 100644 --- a/tests/test_integration_service.py +++ b/tests/test_integration_service.py @@ -97,8 +97,28 @@ class IntegrationServiceTests(unittest.TestCase): 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_integration_routes_wrap_responses(self): response = private_companion_daily_outfit( self.ctx, diff --git a/tests/test_wardrobe_service.py b/tests/test_wardrobe_service.py index 838c982..683dcef 100644 --- a/tests/test_wardrobe_service.py +++ b/tests/test_wardrobe_service.py @@ -96,6 +96,49 @@ class WardrobeServiceTests(unittest.TestCase): self.assertEqual(deleted.wardrobe_item_id, item.wardrobe_item_id) self.assertEqual(self.wardrobe_service.list_items(self.profile.profile_id), []) + def test_match_returns_fallback_strategy_when_no_category_matches(self): + matched = self.wardrobe_service.match( + self.profile.profile_id, + { + "categories": ["shoes"], + "keywords": ["boots"], + "mood": "formal", + "weather": "rainy", + "season": "winter", + "style": "elegant", + }, + self.ctx, + ) + + self.assertTrue(matched["fallback_used"]) + self.assertFalse(matched["fallback_supplement_used"]) + self.assertEqual(matched["selected_materials"], []) + self.assertEqual(matched["fallback_reason"], "no_matching_materials") + self.assertEqual(matched["fallback_strategy"]["name"], "random_prompt_generation") + self.assertEqual(matched["fallback_strategy"]["missing_categories"], ["shoes"]) + self.assertIn("matching shoes", matched["outfit_prompt"]) + self.assertIn("formal", matched["outfit_prompt"]) + + def test_match_returns_supplement_strategy_for_missing_categories(self): + self.wardrobe_service.import_material( + self.profile.profile_id, + {"material_id": self.material.material_id, "wardrobe_category": "top"}, + self.ctx, + ) + + matched = self.wardrobe_service.match( + self.profile.profile_id, + {"categories": ["top", "shoes"], "keywords": ["casual"]}, + self.ctx, + ) + + self.assertFalse(matched["fallback_used"]) + self.assertTrue(matched["fallback_supplement_used"]) + self.assertEqual(matched["fallback_reason"], "missing_categories") + self.assertEqual(matched["fallback_strategy"]["missing_categories"], ["shoes"]) + self.assertIn("white blouse", matched["outfit_prompt"]) + self.assertIn("matching shoes", matched["fallback_prompt"]) + def test_match_prefers_candidate_by_tags_season_and_style(self): self.wardrobe_service.import_material( self.profile.profile_id,