Upload 22 files

app.py

@@ -86,22 +86,11 @@ MATCHING_RESULT_CACHE_LOCK = threading.Lock()
 MATCHING_RESULT_CACHE_MAX = int(os.getenv("MATCHING_RESULT_CACHE_MAX", "500"))
 MATCHING_RESULT_CACHE_TTL_SECONDS = int(os.getenv("MATCHING_RESULT_CACHE_TTL_SECONDS", "86400"))
 
-SCRAPER_QUERY_CACHE: dict[str, tuple[dict[str, Any], float]] = {}
-SCRAPER_QUERY_CACHE_LOCK = threading.Lock()
-SCRAPER_QUERY_CACHE_TTL_SECONDS = int(os.getenv("SCRAPER_QUERY_CACHE_TTL_SECONDS", "1296000"))  # 15 days
-
 
 def _matching_cache_storage_key(key: str) -> str:
     return f"matching:{key}"
 
 
-def _scraper_cache_key(user_prompt: str, store: str, gender: str, target_category: str) -> str:
-    """Create deterministic cache key for scraper queries"""
-    import hashlib
-    key_str = f"{user_prompt.lower().strip()}|{store}|{gender}|{target_category}"
-    return hashlib.md5(key_str.encode()).hexdigest()
-
-
 def _normalize_cache_category(value: Any) -> str:
     category = _norm(value)
     if category in {"topwear", "bottomwear", "others"}:
@@ -3118,7 +3107,7 @@ def product_urls(payload: dict[str, Any] = Body(default_factory=dict)) -> dict[s
 
 @app.post("/suggestions")
 @app.post("/api/suggestions")
-def suggestions(payload: dict[str, Any] = Body(default_factory=dict)) -> dict[str, Any]:
+def suggestions(payload: dict[str, Any] = Body(default_factory=dict)) -> dict[str, Any]:
     occasion = str(payload.get("occasion") or "casual")
     target_category = str(payload.get("target_category") or payload.get("targetCategory") or "both")
     gender_preference = str(payload.get("gender_preference") or payload.get("genderPreference") or "any")
@@ -3142,99 +3131,12 @@ def suggestions(payload: dict[str, Any] = Body(default_factory=dict)) -> dict[st
         raise HTTPException(status_code=502, detail=str(exc)) from exc
     except NvidiaPayloadError as exc:
         raise HTTPException(status_code=502, detail=str(exc)) from exc
-    except requests.RequestException as exc:
-        raise HTTPException(status_code=502, detail=f"Failed to fetch {store.title()} pages: {exc}") from exc
-
-
-def _build_static_scraper_result(
-    static_plan: dict[str, Any],
-    *,
-    occasion: str,
-    gender: str,
-    preferences: str,
-    store: str,
-    max_products: int | None,
-) -> dict[str, Any]:
-    query = str(static_plan.get("query") or "").strip()
-    color = str(static_plan.get("color") or "").strip()
-    category = str(static_plan.get("category") or "").strip()
-    if not query:
-        query = " ".join(part for part in [gender, color, category] if str(part or "").strip()).strip()
-    if not query:
-        raise HTTPException(status_code=400, detail="static_query_plan.query is required")
-
-    plan_occasion = str(static_plan.get("occasion") or occasion or "casual").strip() or "casual"
-    plan_gender = _normalize_scraper_gender(gender) or _normalize_scraper_gender(static_plan.get("gender")) or None
-    limit = max_products if isinstance(max_products, int) and max_products > 0 else 12
-    search_urls = _build_store_search_urls_from_query(query, store=store, gender=plan_gender)
-
-    products: list[dict[str, Any]] = []
-    seen_links: set[str] = set()
-    errors: list[str] = []
-    for search_url in search_urls:
-        try:
-            for product in _extract_store_product_summaries(search_url, store=store):
-                item_link = str(product.get("item_link") or "").strip()
-                if not item_link or item_link in seen_links:
-                    continue
-                seen_links.add(item_link)
-                products.append(product)
-                if len(products) >= limit:
-                    break
-        except requests.RequestException as exc:
-            errors.append(str(exc))
-        if len(products) >= limit:
-            break
-
-    query_plan_payload = {
-        "target_category": static_plan.get("target_category") or _normalize_target_category(static_plan.get("targetCategory")),
-        "color": color or "neutral",
-        "category": category or "mixed",
-        "gender": plan_gender,
-        "style_direction": str(static_plan.get("style_direction") or "direct-static").strip() or "direct-static",
-        "occasion_bucket": _occasion_bucket(plan_occasion),
-        "reference_item_ids": [],
-        "query": query,
-        "final_query": query,
-        "wardrobe_grounding": "Static example query selected from the shopping suggestions page.",
-        "reason": "Used a predefined query plan and URL builder without model planning.",
-        "source": "static",
-    }
-
-    response_payload: dict[str, Any] = {
-        "runtime_id": str(uuid.uuid4()),
-        "created_at": _now_iso(),
-        "store": store,
-        "occasion": plan_occasion,
-        "gender": plan_gender or gender or "",
-        "preferences": preferences,
-        "wardrobe_snapshot": _wardrobe_metadata_snapshot(limit=12),
-        "query_plan": query_plan_payload,
-        "search_urls": search_urls,
-        "product_urls": [item["item_link"] for item in products if item.get("item_link")],
-        "products": products,
-        "count": len(products),
-        "intermediate_steps": [
-            {
-                "step": "static_query_plan",
-                "query": query,
-                "url_count": len(search_urls),
-                "new_products": len(products),
-                "total_products": len(products),
-                "errors": errors,
-                "message": "Predefined webpage query used; model planner skipped.",
-            }
-        ],
-        "plan_source": "static",
-        "plan_error": None,
-        "scrape_error": "; ".join(errors) if errors and not products else None,
-    }
-    response_payload["saved_json_path"] = _save_scraper_json_payload("product_urls", response_payload)
-    return _store_scraper_runtime_result(response_payload)
-
-
-@app.post("/scraper/recommend")
-def scraper_recommend(payload: dict[str, Any] = Body(default_factory=dict)) -> dict[str, Any]:
+    except requests.RequestException as exc:
+        raise HTTPException(status_code=502, detail=f"Failed to fetch {store.title()} pages: {exc}") from exc
+
+
+@app.post("/scraper/recommend")
+def scraper_recommend(payload: dict[str, Any] = Body(default_factory=dict)) -> dict[str, Any]:
     user_prompt = str(payload.get("user_prompt") or payload.get("prompt") or "").strip()
     inferred = _infer_structured_request_from_prompt(user_prompt)
     inferred_target_category = _normalize_target_category(inferred.get("target_category"))
@@ -3281,41 +3183,11 @@ def scraper_recommend(payload: dict[str, Any] = Body(default_factory=dict)) -> d
     max_products = int(max_products_raw) if max_products_raw not in {None, ""} else None
     store = _normalize_store_name(str(payload.get("store") or SCRAPER_DEFAULT_STORE or "nike"))
 
-    if isinstance(max_products, int) and max_products < 1:
-        raise HTTPException(status_code=400, detail="max_products must be at least 1")
-
-    static_plan = payload.get("static_query_plan") or payload.get("staticQueryPlan")
-    if isinstance(static_plan, dict):
-        try:
-            return _build_static_scraper_result(
-                static_plan,
-                occasion=occasion,
-                gender=gender,
-                preferences=preferences,
-                store=store,
-                max_products=max_products,
-            )
-        except requests.RequestException as exc:
-            raise HTTPException(status_code=502, detail=f"Failed to fetch {store.title()} pages: {exc}") from exc
-
-    # Check cache first for faster repeat queries
-    cache_key = _scraper_cache_key(user_prompt, store, gender, target_category)
-    with SCRAPER_QUERY_CACHE_LOCK:
-        if cache_key in SCRAPER_QUERY_CACHE:
-            cached_result, cached_timestamp = SCRAPER_QUERY_CACHE[cache_key]
-            if time.time() - cached_timestamp < SCRAPER_QUERY_CACHE_TTL_SECONDS:
-                print(f"[CACHE HIT] Returning cached scraper results for: {user_prompt[:50]}...")
-                return cached_result
-        # Clean up expired cache entries
-        expired_keys = [
-            k for k, (_, ts) in SCRAPER_QUERY_CACHE.items()
-            if time.time() - ts >= SCRAPER_QUERY_CACHE_TTL_SECONDS
-        ]
-        for k in expired_keys:
-            del SCRAPER_QUERY_CACHE[k]
+    if isinstance(max_products, int) and max_products < 1:
+        raise HTTPException(status_code=400, detail="max_products must be at least 1")
 
     try:
-        result = _generate_scraper_plan_with_kimi(
+        return _generate_scraper_plan_with_kimi(
             occasion=occasion,
             gender=gender,
             preferences=preferences,
@@ -3324,12 +3196,8 @@ def scraper_recommend(payload: dict[str, Any] = Body(default_factory=dict)) -> d
             filters=filters,
             max_products=max_products,
             store=store,
-            strict_kimi=False,
+            strict_kimi=True,
         )
-        # Cache the result
-        with SCRAPER_QUERY_CACHE_LOCK:
-            SCRAPER_QUERY_CACHE[cache_key] = (result, time.time())
-        return result
     except NvidiaGatewayError as exc:
         raise HTTPException(status_code=502, detail=str(exc)) from exc
     except NvidiaPayloadError as exc:
@@ -3417,7 +3285,7 @@ def scraper_page() -> Response:
                     </div>
                 </div>
                 <label for="preferences">Other Preferences</label>
-                <textarea id="preferences" placeholder="Example: Category: shirt. Color: navy. Occasion: formal office. Style: structured minimal. Avoid: oversized."></textarea>
+                <textarea id="preferences" placeholder="Example: formal office look, breathable fabric, neutral tones, regular fit, avoid oversized silhouettes"></textarea>
                 <button id="runBtn">Generate Kimi Query and Scrape</button>
                 <div id="status" class="status"></div>
             </div>
@@ -3839,86 +3707,6 @@ def ai_recommend_outfits(payload: dict[str, Any] = Body(default_factory=dict)) -
             bottoms=bottoms,
             others=priority_other_candidates,
         ))
-
-
-@app.post("/ai/classify-item")
-def ai_classify_item(payload: dict[str, Any] = Body(default_factory=dict)) -> dict[str, Any]:
-    """
-    Classify a fashion item using NVIDIA model (primary) with HuggingFace fallback.
-
-    Args:
-        item: Wardrobe item dict with metadata and/or image_url
-
-    Returns:
-        Classification result with category, confidence, and attributes
-    """
-    try:
-        item = payload.get("item")
-        if not isinstance(item, dict):
-            raise HTTPException(status_code=400, detail="'item' must be a dictionary")
-
-        service = get_recommendation_service()
-        result = service.classify_item(item)
-
-        return {
-            "success": True,
-            "classification": result,
-            "model_backend": result.get("backend", "unknown"),
-        }
-    except HTTPException:
-        raise
-    except Exception as e:
-        print(f"[classify-item] Error: {e}")
-        _raise_http_error(e)
-
-
-@app.post("/ai/match-items")
-def ai_match_items(payload: dict[str, Any] = Body(default_factory=dict)) -> dict[str, Any]:
-    """
-    Determine if two fashion items match well together.
-    
-    Uses NVIDIA model as primary with HuggingFace as fallback.
-    
-    Args:
-        item1: First wardrobe item dict
-        item2: Second wardrobe item dict
-        match_threshold: Confidence threshold (0-1), default 0.5
-        
-    Returns:
-        Match result with compatibility scores and reason
-    """
-    try:
-        item1 = payload.get("item1")
-        item2 = payload.get("item2")
-        match_threshold = float(payload.get("match_threshold", 0.5))
-        
-        if not isinstance(item1, dict):
-            raise HTTPException(status_code=400, detail="'item1' must be a dictionary")
-        if not isinstance(item2, dict):
-            raise HTTPException(status_code=400, detail="'item2' must be a dictionary")
-        
-        if match_threshold < 0 or match_threshold > 1:
-            raise HTTPException(status_code=400, detail="'match_threshold' must be between 0 and 1")
-        
-        service = get_recommendation_service()
-        result = service.match_items(item1, item2, match_threshold)
-        
-        return {
-            "success": True,
-            "item1_id": item1.get("id", "unknown"),
-            "item2_id": item2.get("id", "unknown"),
-            "match": result.get("match", False),
-            "match_score": result.get("score", 0.0),
-            "reason": result.get("reason", ""),
-            "compatibility_breakdown": result.get("compatibility", {}),
-        }
-    except HTTPException:
-        raise
-    except Exception as e:
-        print(f"[match-items] Error: {e}")
-        _raise_http_error(e)
-
-
 @app.get("/image-proxy")
 def image_proxy(url: str = Query(..., description="Remote image URL")) -> Response:
     parsed = urlparse(url)