Upload 6 files

ai_stylist.py

@@ -0,0 +1,326 @@
+# File: ai_stylist.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+from PIL import Image
+
+try:
+    import cv2  # type: ignore
+    import mediapipe as mp  # type: ignore
+    import numpy as np  # type: ignore
+    from sklearn.cluster import KMeans  # type: ignore
+except Exception:
+    cv2 = None
+    np = None
+    mp = None
+    KMeans = None
+
+
+@dataclass(frozen=True)
+class SkinToneResult:
+    skin_label: str
+    confidence: int
+    dominant_hex: str
+    dominant_lab: Tuple[float, float, float]
+    best_palette: Dict[str, Any]
+
+
+def _palette_db() -> List[Dict[str, Any]]:
+    return [
+        {
+            "id": "warm_neutrals_olive",
+            "name": "Warm Neutrals + Olive",
+            "tags": ["warm", "everyday", "soft-contrast"],
+            "colors_hex": ["#F4E3D7", "#D7B49E", "#A97C50", "#6B7B3E", "#2F2B28"],
+            "mean_lab": (190.0, 140.0, 150.0),
+        },
+        {
+            "id": "cool_minimal",
+            "name": "Cool Minimal",
+            "tags": ["cool", "minimal", "clean"],
+            "colors_hex": ["#F6F7FB", "#DDE2EA", "#97A1B2", "#2F3A4C", "#0E0F12"],
+            "mean_lab": (205.0, 128.0, 125.0),
+        },
+        {
+            "id": "bold_jewel",
+            "name": "Bold Jewel Tones",
+            "tags": ["bold", "evening", "high-contrast"],
+            "colors_hex": ["#0B3D91", "#0E7C7B", "#7D1538", "#3B1F2B", "#F2E9E4"],
+            "mean_lab": (165.0, 135.0, 140.0),
+        },
+        {
+            "id": "earthy_rich",
+            "name": "Earthy Rich",
+            "tags": ["warm", "earthy", "autumn"],
+            "colors_hex": ["#7A4E2D", "#C57B57", "#F1AB86", "#2D3A2E", "#E7D7C1"],
+            "mean_lab": (175.0, 145.0, 155.0),
+        },
+        {
+            "id": "deep_contrast",
+            "name": "Deep Contrast",
+            "tags": ["cool", "deep", "contrast"],
+            "colors_hex": ["#111827", "#1F2937", "#0EA5E9", "#DC2626", "#F9FAFB"],
+            "mean_lab": (150.0, 130.0, 120.0),
+        },
+    ]
+
+
+def _lab_to_hex(lab: "np.ndarray") -> str:
+    lab_1x1 = lab.reshape(1, 1, 3).astype("uint8")
+    bgr = cv2.cvtColor(lab_1x1, cv2.COLOR_LAB2BGR)
+    rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB).reshape(3)
+    return "#{:02x}{:02x}{:02x}".format(int(rgb[0]), int(rgb[1]), int(rgb[2]))
+
+
+def _skin_label_from_lab(dominant_lab: "np.ndarray") -> str:
+    L, a, b = float(dominant_lab[0]), float(dominant_lab[1]), float(dominant_lab[2])
+    tone = "Light" if L > 185 else "Medium" if L > 140 else "Deep"
+    undertone = "Warm" if b > a else "Cool"
+    return f"{undertone} / {tone}"
+
+
+def _recommend_best_palette(dominant_lab: Tuple[float, float, float]) -> Dict[str, Any]:
+    db = _palette_db()
+    dl = np.array(dominant_lab, dtype=np.float32)
+
+    scored = []
+    for p in db:
+        pl = np.array(p["mean_lab"], dtype=np.float32)
+        d = float(np.linalg.norm(pl - dl))
+        score = float(np.exp(-d / 35.0))
+        scored.append((score, p))
+
+    scored.sort(key=lambda x: -x[0])
+    best_score, best = scored[0]
+    return {
+        "id": best["id"],
+        "name": best["name"],
+        "score": best_score,
+        "tags": best["tags"],
+        "colors_hex": best["colors_hex"],
+    }
+
+
+def _expand_bbox(
+    x1: int, y1: int, x2: int, y2: int, w: int, h: int, scale: float = 1.5
+) -> Tuple[int, int, int, int]:
+    cx = (x1 + x2) / 2.0
+    cy = (y1 + y2) / 2.0
+    bw = (x2 - x1) * scale
+    bh = (y2 - y1) * scale
+    nx1 = int(max(0, cx - bw / 2))
+    ny1 = int(max(0, cy - bh / 2))
+    nx2 = int(min(w - 1, cx + bw / 2))
+    ny2 = int(min(h - 1, cy + bh / 2))
+    return nx1, ny1, nx2, ny2
+
+
+def _detect_face_crop(rgb: "np.ndarray") -> Optional["np.ndarray"]:
+    h, w, _ = rgb.shape
+    detector = mp.solutions.face_detection.FaceDetection(
+        model_selection=1, min_detection_confidence=0.35
+    )
+    res = detector.process(rgb)
+    if not res.detections:
+        return None
+
+    det = res.detections[0]
+    bbox = det.location_data.relative_bounding_box
+    x1 = int(bbox.xmin * w)
+    y1 = int(bbox.ymin * h)
+    x2 = int((bbox.xmin + bbox.width) * w)
+    y2 = int((bbox.ymin + bbox.height) * h)
+
+    x1, y1, x2, y2 = _expand_bbox(x1, y1, x2, y2, w, h, scale=1.50)
+    crop = rgb[y1:y2, x1:x2].copy()
+    if crop.size == 0:
+        return None
+    return crop
+
+
+def _cheek_mask(face_rgb: "np.ndarray", face_landmarks: Any) -> "np.ndarray":
+    h, w, _ = face_rgb.shape
+    left_ids = [234, 93, 132, 58, 172]
+    right_ids = [454, 323, 361, 288, 397]
+
+    def pts(ids: List[int]) -> "np.ndarray":
+        out = []
+        for i in ids:
+            lm = face_landmarks.landmark[i]
+            out.append([int(lm.x * w), int(lm.y * h)])
+        return np.array(out, dtype=np.int32)
+
+    mask = np.zeros((h, w), dtype=np.uint8)
+    cv2.fillConvexPoly(mask, pts(left_ids), 255)
+    cv2.fillConvexPoly(mask, pts(right_ids), 255)
+    return mask
+
+
+def detect_skin_tone_pil(selfie_pil: Image.Image) -> SkinToneResult:
+    if cv2 is None or np is None or KMeans is None or mp is None:
+        raise RuntimeError(
+            "Missing deps. Install: pip install numpy opencv-python mediapipe scikit-learn"
+        )
+
+    rgb = np.array(selfie_pil.convert("RGB"))
+    rgb = np.ascontiguousarray(rgb)
+
+    face_rgb = _detect_face_crop(rgb)
+    if face_rgb is None:
+        raise ValueError(
+            "Face not detected. Use a clearer front-facing selfie in good light."
+        )
+
+    mesh = mp.solutions.face_mesh.FaceMesh(
+        static_image_mode=True,
+        refine_landmarks=True,
+        max_num_faces=1,
+        min_detection_confidence=0.5,
+    )
+    res = mesh.process(face_rgb)
+    if not res.multi_face_landmarks:
+        raise ValueError("Face landmarks not detected. Try a clearer selfie.")
+
+    face = res.multi_face_landmarks[0]
+    mask = _cheek_mask(face_rgb, face)
+
+    bgr = cv2.cvtColor(face_rgb, cv2.COLOR_RGB2BGR)
+    lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB).astype(np.float32)
+
+    skin_pixels = lab[mask == 255].reshape(-1, 3)
+    if skin_pixels.shape[0] < 180:
+        raise ValueError("Not enough cheek pixels. Try brighter lighting.")
+
+    k = 3 if skin_pixels.shape[0] > 1500 else 2
+    km = KMeans(n_clusters=k, n_init=6, random_state=42)
+    labels = km.fit_predict(skin_pixels)
+    counts = np.bincount(labels)
+    dominant_lab = km.cluster_centers_[int(np.argmax(counts))].astype(np.float32)
+
+    dominant_hex = _lab_to_hex(dominant_lab)
+    label = _skin_label_from_lab(dominant_lab)
+    confidence = int(min(100, 55 + (skin_pixels.shape[0] / 1500.0) * 45))
+
+    best_palette = _recommend_best_palette(
+        (float(dominant_lab[0]), float(dominant_lab[1]), float(dominant_lab[2]))
+    )
+
+    return SkinToneResult(
+        skin_label=label,
+        confidence=confidence,
+        dominant_hex=dominant_hex,
+        dominant_lab=(
+            float(dominant_lab[0]),
+            float(dominant_lab[1]),
+            float(dominant_lab[2]),
+        ),
+        best_palette=best_palette,
+    )
+
+
+def _pose_insights(image_pil: Image.Image) -> Dict[str, Any]:
+    if cv2 is None or np is None or mp is None:
+        return {"pose_detected": False}
+
+    bgr = cv2.cvtColor(np.array(image_pil.convert("RGB")), cv2.COLOR_RGB2BGR)
+    rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+
+    pose = mp.solutions.pose.Pose(static_image_mode=True, model_complexity=1)
+    res = pose.process(rgb)
+    if not res.pose_landmarks:
+        return {"pose_detected": False}
+
+    lm = res.pose_landmarks.landmark
+    L_SH, R_SH = lm[11], lm[12]
+    L_HIP, R_HIP = lm[23], lm[24]
+
+    def dist(a, b) -> float:
+        return float(np.hypot(a.x - b.x, a.y - b.y))
+
+    shoulder_w = dist(L_SH, R_SH)
+    hip_w = dist(L_HIP, R_HIP)
+    ratio = shoulder_w / (hip_w + 1e-6)
+
+    if ratio > 1.08:
+        shape = "Inverted Triangle (shoulders broader)"
+    elif ratio < 0.92:
+        shape = "Pear (hips broader)"
+    else:
+        shape = "Balanced"
+
+    return {"pose_detected": True, "shoulder_to_hip_ratio": float(ratio), "shape": shape}
+
+
+def generate_style_text_suggestions(
+    *,
+    image_pil: Image.Image,
+    skin_label: str,
+    dominant_hex: str,
+    height_cm: Optional[float],
+    body_type: str,
+    gender: str,
+) -> Dict[str, List[str]]:
+    pose = _pose_insights(image_pil)
+
+    recs: List[str] = []
+    avoid: List[str] = []
+
+    recs.append("Prefer solid colors + 1 accent piece (premium, clean look).")
+    recs.append("Use vertical lines (open jacket, long cardigan, straight seams) to look taller.")
+
+    if height_cm is not None:
+        if height_cm < 160:
+            recs.append("Short height: high-waist jeans + shorter jackets elongate legs.")
+            avoid.append("Avoid long oversized tops that cut the leg line.")
+        elif height_cm > 175:
+            recs.append("Tall height: layering (overshirt, long coat) looks balanced.")
+            avoid.append("Avoid ultra-short cropped tops if you want a formal silhouette.")
+
+    bt = (body_type or "Average").lower()
+    if bt == "slim":
+        recs.append("Slim build: add structure with overshirts/blazers and light layering.")
+        recs.append("Bottoms: straight or relaxed jeans work best.")
+    elif bt == "athletic":
+        recs.append("Athletic build: semi-fitted tops + straight jeans/trousers.")
+        avoid.append("Avoid extremely oversized outfits that hide proportions.")
+    elif bt == "heavy":
+        recs.append("Heavier build: darker solids + vertical patterns + structured outerwear.")
+        recs.append("Bottoms: straight-leg or tapered jeans are flattering.")
+        avoid.append("Avoid loud horizontal stripes across the midsection.")
+
+    if pose.get("pose_detected"):
+        ratio = float(pose["shoulder_to_hip_ratio"])
+        shape = pose["shape"]
+        recs.append(f"Body proportion: {shape} (ratio {ratio:.2f}).")
+
+        if ratio > 1.08:
+            recs.append("Patterns: vertical stripes recommended; avoid heavy shoulder details.")
+            recs.append("Jeans: straight/wide-leg to balance shoulders.")
+            recs.append("Shirt length: hip-length tops balance the frame.")
+            avoid.append("Avoid tight crew-necks and shoulder pads.")
+        elif ratio < 0.92:
+            recs.append("Patterns: texture/stripes on top are okay; keep bottoms simpler/darker.")
+            recs.append("Jeans: straight jeans; avoid ultra-skinny if you want balance.")
+            recs.append("Tops: structured jackets help balance hips.")
+            avoid.append("Avoid heavy prints on bottoms if you want balance.")
+        else:
+            recs.append("Balanced: you can wear both fitted and relaxed silhouettes confidently.")
+            recs.append("Try: straight jeans + either cropped or hip-length tops.")
+    else:
+        recs.append("Tip: upload a full-body photo for more accurate pattern/fit advice.")
+
+    if "Warm" in (skin_label or ""):
+        recs.append("Warm undertone: olive, cream, tan, warm browns, mustard accents look best.")
+        avoid.append("Avoid very icy blues if you want a warm glow.")
+    elif "Cool" in (skin_label or ""):
+        recs.append("Cool undertone: navy, charcoal, crisp white, emerald, cobalt accents look best.")
+        avoid.append("Avoid very yellowish oranges if they dull the skin.")
+
+    if gender.lower() == "female":
+        recs.append("Outfit idea: high-waist jeans + structured top + minimal accessories.")
+    elif gender.lower() == "male":
+        recs.append("Outfit idea: straight jeans + overshirt/blazer + clean sneakers.")
+
+    return {"recommendations": recs, "avoid": avoid}

app.py

@@ -0,0 +1,587 @@
+# File: app.py
+from __future__ import annotations
+
+import json
+import os
+import re
+import tempfile
+from dataclasses import dataclass, replace
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import pandas as pd
+from flask import (Flask, flash, redirect, render_template, request, session,
+                   url_for)
+from gradio_client import Client, file
+from PIL import Image
+
+
+from ai_stylist import detect_skin_tone_pil, generate_style_text_suggestions
+
+DATA_CSV = Path("eco_try_products_dataset_fabric_category_fixed.csv")
+OVERRIDES_JSON = Path("overrides.json")
+
+VTON_SPACE_ID = os.environ.get("VTON_SPACE_ID", "").strip()
+VTON_API_NAME = os.environ.get("VTON_API_NAME", "/tryon").strip()
+HF_TOKEN = os.environ.get("HF_TOKEN", "").strip()
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+
+_ALLOWED_IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".webp"}
+_VTON_CLIENT: Optional[Client] = None
+
+
+@dataclass(frozen=True)
+class Product:
+    product_id: int
+    product_name: str
+    fabric_type: str
+    image_url: str
+    water_usage_liters: float
+    co2_emission_kg: float
+    biodegradability_score: float
+    sustainability_score: float
+    awareness_text: str
+    category: str
+    static_filename: str
+
+
+def infer_category(product_name: str) -> str:
+    if not isinstance(product_name, str) or not product_name.strip():
+        return "Other"
+    parts = re.sub(r"[^A-Za-z]+", " ", product_name).strip().split()
+    if not parts:
+        return "Other"
+    last = parts[-1].lower()
+    mapping = {
+        "tshirt": "T-Shirt",
+        "tee": "T-Shirt",
+        "shirt": "Shirt",
+        "jacket": "Jacket",
+        "hoodie": "Hoodie",
+        "sweater": "Sweater",
+        "jeans": "Jeans",
+        "pants": "Pants",
+        "trouser": "Pants",
+        "trousers": "Pants",
+        "shorts": "Shorts",
+        "dress": "Dress",
+        "skirt": "Skirt",
+        "coat": "Coat",
+    }
+    return mapping.get(last, last.capitalize())
+
+
+def normalize_static_image_path(image_url_value: Any) -> str:
+    if not isinstance(image_url_value, str) or not image_url_value.strip():
+        return "images/placeholder.png"
+    s = image_url_value.strip().replace("\\", "/").lstrip("/")
+    if s.startswith("static/"):
+        s = s[len("static/") :]
+    return s
+
+
+def load_overrides() -> Dict[str, Dict[str, Any]]:
+    if not OVERRIDES_JSON.exists():
+        OVERRIDES_JSON.write_text("{}", encoding="utf-8")
+        return {}
+    try:
+        return json.loads(OVERRIDES_JSON.read_text(encoding="utf-8") or "{}")
+    except json.JSONDecodeError:
+        return {}
+
+
+def save_overrides(overrides: Dict[str, Dict[str, Any]]) -> None:
+    OVERRIDES_JSON.write_text(
+        json.dumps(overrides, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+
+def apply_overrides(p: Product, overrides: Dict[str, Dict[str, Any]]) -> Product:
+    override = overrides.get(str(p.product_id))
+    if not override:
+        return p
+
+    allowed = {"product_name", "fabric_type", "category"}
+    data = {
+        k: v
+        for k, v in override.items()
+        if k in allowed and isinstance(v, str) and v.strip()
+    }
+    if not data:
+        return p
+
+    return replace(
+        p,
+        product_name=data.get("product_name", p.product_name),
+        fabric_type=data.get("fabric_type", p.fabric_type),
+        category=data.get("category", p.category),
+    )
+
+
+def _get_vton_client() -> Client:
+    global _VTON_CLIENT
+    if _VTON_CLIENT is not None:
+        return _VTON_CLIENT
+    if not VTON_SPACE_ID:
+        raise RuntimeError("Set VTON_SPACE_ID, e.g. EcoTry/IDM-VTON")
+    _VTON_CLIENT = Client(VTON_SPACE_ID)
+    return _VTON_CLIENT
+
+
+def _secure_ext(filename: str) -> str:
+    ext = Path(filename or "").suffix.lower()
+    return ext if ext in _ALLOWED_IMAGE_EXTS else ".png"
+
+
+def _open_result_as_image(result: Any) -> Image.Image:
+    if isinstance(result, Image.Image):
+        return result.convert("RGBA")
+    if isinstance(result, str):
+        return Image.open(result).convert("RGBA")
+    if isinstance(result, dict) and "path" in result:
+        return Image.open(result["path"]).convert("RGBA")
+    raise ValueError(f"Unexpected VTON result format: {type(result)} => {result}")
+
+# ✅ FIRST FUNCTION (OUTSIDE)
+def _get_vton_client() -> Client:
+    global _VTON_CLIENT
+
+    if _VTON_CLIENT is not None:
+        return _VTON_CLIENT
+
+    if not VTON_SPACE_ID:
+        raise RuntimeError("Set VTON_SPACE_ID, e.g. EcoTry/IDM-VTON")
+
+    # optional token
+    if HF_TOKEN:
+        os.environ["HF_TOKEN"] = HF_TOKEN
+
+    _VTON_CLIENT = Client(VTON_SPACE_ID)
+    return _VTON_CLIENT
+
+
+# ✅ SECOND FUNCTION (SEPARATE)
+def call_vton_space(person_image_path: str, cloth_image_path: str, garment_description: str) -> Image.Image:
+    client = _get_vton_client()
+
+    result = client.predict(
+        dict={
+            "background": file(person_image_path),
+            "layers": [],
+            "composite": None,
+        },
+        garm_img=file(cloth_image_path),
+        garment_des=f"high quality realistic photo of person wearing {garment_description}",
+        is_checked=True,
+        is_checked_crop=True,
+        denoise_steps=40,
+        seed=1234,
+        api_name=VTON_API_NAME,
+    )
+
+    return _open_result_as_image(result[0])
+
+   
+
+    _VTON_CLIENT = Client(VTON_SPACE_ID)
+
+    return _VTON_CLIENT
+    result = client.predict(
+        dict={
+            "background": file(person_image_path),
+            "layers": [],
+            "composite": None,
+        },
+        garm_img=file(cloth_image_path),
+        garment_des=f"high quality realistic photo of person wearing {garment_description}",
+        is_checked=True,
+        is_checked_crop=True,
+        denoise_steps=40,
+        seed=1234,
+        api_name=VTON_API_NAME,
+    )
+    return _open_result_as_image(result[0])
+
+
+def create_app() -> Flask:
+    app = Flask(__name__)
+    app.config["SECRET_KEY"] = os.environ.get("ECOTRY_SECRET_KEY", "change-this-secret")
+    app.config["ADMIN_PASSWORD"] = os.environ.get("ECOTRY_ADMIN_PASSWORD", "admin123")
+
+    df = pd.read_csv(DATA_CSV)
+    df["category"] = df["product_name"].apply(infer_category)
+    df["static_filename"] = df["image_url"].apply(normalize_static_image_path)
+
+    base_products: List[Product] = []
+    for row in df.to_dict(orient="records"):
+        base_products.append(
+            Product(
+                product_id=int(row["product_id"]),
+                product_name=str(row["product_name"]),
+                fabric_type=str(row["fabric_type"]),
+                image_url=str(row["image_url"]),
+                water_usage_liters=float(row["water_usage_liters"]),
+                co2_emission_kg=float(row["co2_emission_kg"]),
+                biodegradability_score=float(row["biodegradability_score"]),
+                sustainability_score=float(row["sustainability_score"]),
+                awareness_text=str(row["awareness_text"]),
+                category=str(row["category"]),
+                static_filename=str(row["static_filename"]),
+            )
+        )
+
+    base_by_id: Dict[int, Product] = {p.product_id: p for p in base_products}
+
+    def get_cart() -> Dict[str, int]:
+        cart = session.get("cart", {})
+        if not isinstance(cart, dict):
+            return {}
+        cleaned: Dict[str, int] = {}
+        for k, v in cart.items():
+            try:
+                qty = int(v)
+            except (TypeError, ValueError):
+                continue
+            if qty > 0:
+                cleaned[str(k)] = qty
+        return cleaned
+
+    def save_cart(cart: Dict[str, int]) -> None:
+        session["cart"] = cart
+        session.modified = True
+
+    def cart_count(cart: Dict[str, int]) -> int:
+        return sum(cart.values())
+
+    def build_category_counts(items: List[Product]) -> List[Tuple[str, int]]:
+        counts: Dict[str, int] = {}
+        for p in items:
+            counts[p.category] = counts.get(p.category, 0) + 1
+        return sorted(counts.items(), key=lambda x: x[1], reverse=True)
+
+    def apply_filters(items: List[Product], *, category: Optional[str], q: Optional[str], sort: str) -> List[Product]:
+        filtered = items
+
+        if category and category != "All":
+            filtered = [p for p in filtered if p.category == category]
+
+        if q:
+            query = q.strip().lower()
+            if query:
+                filtered = [
+                    p
+                    for p in filtered
+                    if query in p.product_name.lower() or query in p.fabric_type.lower()
+                ]
+
+        if sort == "eco_desc":
+            filtered = sorted(filtered, key=lambda p: p.sustainability_score, reverse=True)
+        elif sort == "eco_asc":
+            filtered = sorted(filtered, key=lambda p: p.sustainability_score)
+        elif sort == "name_desc":
+            filtered = sorted(filtered, key=lambda p: p.product_name.lower(), reverse=True)
+        else:
+            filtered = sorted(filtered, key=lambda p: p.product_name.lower())
+
+        return filtered
+
+    def get_products_with_overrides() -> List[Product]:
+        overrides = load_overrides()
+        return [apply_overrides(p, overrides) for p in base_products]
+
+    def render_tryon_page(product: Product, *, result_image_url: Optional[str] = None) -> str:
+        return render_template(
+            "tryon.html",
+            product={
+                "product_id": product.product_id,
+                "product_name": product.product_name,
+                "image_src": url_for("static", filename=product.static_filename),
+            },
+            result_image_url=result_image_url,
+        )
+
+    def admin_authed() -> bool:
+        return session.get("is_admin") is True
+
+    @app.context_processor
+    def inject_globals() -> Dict[str, Any]:
+        cart = get_cart()
+        return {"cart_items_count": cart_count(cart), "brand_logo": url_for("static", filename="assets/ecotry-logo.png")}
+
+    @app.route("/")
+    def home():
+        selected_category = request.args.get("category", "All")
+        q = request.args.get("q", "")
+        sort = request.args.get("sort", "name_asc")
+
+        products = get_products_with_overrides()
+        filtered = apply_filters(products, category=selected_category, q=q, sort=sort)
+
+        view_products: List[Dict[str, Any]] = []
+        for p in filtered:
+            view_products.append(
+                {
+                    "product_id": p.product_id,
+                    "product_name": p.product_name,
+                    "fabric_type": p.fabric_type,
+                    "sustainability_score": p.sustainability_score,
+                    "water_usage_liters": p.water_usage_liters,
+                    "co2_emission_kg": p.co2_emission_kg,
+                    "biodegradability_score": p.biodegradability_score,
+                    "awareness_text": p.awareness_text,
+                    "category": p.category,
+                    "image_src": url_for("static", filename=p.static_filename),
+                }
+            )
+
+        return render_template(
+            "index.html",
+            products=view_products,
+            categories_with_counts=build_category_counts(products),
+            total_count=len(products),
+            selected_category=selected_category,
+            q=q,
+            sort=sort,
+        )
+
+    # ---- CART ROUTES (fixes cart_page BuildError) ----
+    @app.route("/add-to-cart/<int:product_id>", methods=["POST"])
+    def add_to_cart(product_id: int):
+        if product_id not in base_by_id:
+            flash("Product not found.", "error")
+            return redirect(url_for("home"))
+
+        cart = get_cart()
+        key = str(product_id)
+        cart[key] = cart.get(key, 0) + 1
+        save_cart(cart)
+        flash("Added to cart.", "success")
+        return redirect(request.referrer or url_for("home"))
+
+    @app.route("/cart")
+    def cart_page():
+        cart = get_cart()
+        overrides = load_overrides()
+        lines: List[Dict[str, Any]] = []
+        for pid_str, qty in cart.items():
+            p = base_by_id.get(int(pid_str))
+            if not p:
+                continue
+            p = apply_overrides(p, overrides)
+            lines.append(
+                {
+                    "product_id": p.product_id,
+                    "product_name": p.product_name,
+                    "fabric_type": p.fabric_type,
+                    "category": p.category,
+                    "qty": qty,
+                    "eco": p.sustainability_score,
+                    "image_src": url_for("static", filename=p.static_filename),
+                }
+            )
+        return render_template("cart.html", lines=lines)
+
+    @app.route("/cart/update", methods=["POST"])
+    def cart_update():
+        cart = get_cart()
+        for k, v in request.form.to_dict().items():
+            if not k.startswith("qty_"):
+                continue
+            pid = k.replace("qty_", "").strip()
+            try:
+                qty = int(v)
+            except ValueError:
+                qty = 1
+            if qty <= 0:
+                cart.pop(pid, None)
+            else:
+                cart[pid] = min(qty, 99)
+        save_cart(cart)
+        flash("Cart updated.", "success")
+        return redirect(url_for("cart_page"))
+
+    @app.route("/cart/remove/<int:product_id>", methods=["POST"])
+    def cart_remove(product_id: int):
+        cart = get_cart()
+        cart.pop(str(product_id), None)
+        save_cart(cart)
+        flash("Removed from cart.", "success")
+        return redirect(url_for("cart_page"))
+
+    @app.route("/checkout", methods=["GET", "POST"])
+    def checkout():
+        cart = get_cart()
+        if not cart:
+            flash("Your cart is empty.", "error")
+            return redirect(url_for("home"))
+
+        overrides = load_overrides()
+        lines: List[Dict[str, Any]] = []
+        for pid_str, qty in cart.items():
+            p = base_by_id.get(int(pid_str))
+            if not p:
+                continue
+            p = apply_overrides(p, overrides)
+            lines.append({"product_id": p.product_id, "product_name": p.product_name, "qty": qty, "eco": p.sustainability_score})
+
+        eco_avg = round(sum(line["eco"] * line["qty"] for line in lines) / max(1, sum(line["qty"] for line in lines)), 2)
+
+        if request.method == "POST":
+            name = request.form.get("name", "").strip()
+            email = request.form.get("email", "").strip()
+            address = request.form.get("address", "").strip()
+            if not name or not email or not address:
+                flash("Please fill in name, email, and address.", "error")
+                return render_template("checkout.html", lines=lines, eco_avg=eco_avg)
+
+            session["last_order"] = {"name": name, "email": email, "address": address, "items": lines, "eco_avg": eco_avg}
+            save_cart({})
+            return redirect(url_for("order_success"))
+
+        return render_template("checkout.html", lines=lines, eco_avg=eco_avg)
+
+    @app.route("/order-success")
+    def order_success():
+        order = session.get("last_order")
+        if not order:
+            return redirect(url_for("home"))
+        return render_template("success.html", order=order)
+
+    # ---- AI STYLIST PAGE ----
+    @app.route("/stylist", methods=["GET", "POST"])
+    def stylist_page():
+        if request.method == "GET":
+            return render_template("stylist.html", result=None)
+
+        selfie = request.files.get("selfie")
+        if not selfie or not selfie.filename:
+            flash("Please upload an image.", "error")
+            return render_template("stylist.html", result=None)
+
+        height_cm_raw = (request.form.get("height_cm") or "").strip()
+        body_type = (request.form.get("body_type") or "Average").strip()
+        gender = (request.form.get("gender") or "Unspecified").strip()
+
+        height_cm: Optional[float] = None
+        if height_cm_raw:
+            try:
+                height_cm = float(height_cm_raw)
+            except ValueError:
+                height_cm = None
+
+        try:
+            img = Image.open(selfie.stream).convert("RGB")
+
+            generated_dir = Path(app.root_path) / "static" / "generated"
+            generated_dir.mkdir(parents=True, exist_ok=True)
+            filename = "stylist_user.png"
+            img.save(generated_dir / filename)
+
+            skin = detect_skin_tone_pil(img)
+            style = generate_style_text_suggestions(
+                image_pil=img,
+                skin_label=skin.skin_label,
+                dominant_hex=skin.dominant_hex,
+                height_cm=height_cm,
+                body_type=body_type,
+                gender=gender,
+            )
+
+            result = {
+                "image_url": url_for("static", filename=f"generated/{filename}"),
+                "skin": {"label": skin.skin_label, "confidence": skin.confidence, "dominant_hex": skin.dominant_hex},
+                "palette": skin.best_palette,
+                "style": style,
+            }
+            return render_template("stylist.html", result=result)
+        except Exception as exc:
+            flash(f"AI Stylist failed: {exc}", "error")
+            return render_template("stylist.html", result=None)
+
+    # Placeholder for your friend's feature
+    @app.route("/size", methods=["GET"])
+    def size_page():
+        flash("Size Recommendation page is under development.", "success")
+        return redirect(url_for("home"))
+    @app.route("/api/ai/style", methods=["POST"])
+    def ai_style():
+        try:
+             vibe = request.form.get("vibe", "minimal")
+
+             recs = []
+
+          # simple recommendation logic
+             for p in base_products[:5]:
+              recs.append({
+                     "product": {
+                     "product_id": p.product_id,
+                     "product_name": p.product_name,
+                     "category": p.category,
+                     "image_src": url_for("static", filename=p.static_filename)
+                    },
+                    "score": round(p.sustainability_score, 3)
+               })
+
+             return {"ok": True, "recs": recs}
+
+        except Exception as e:
+           return {"ok": False, "error": str(e)}
+
+    @app.route("/tryon/<int:product_id>", methods=["GET", "POST"])
+    def tryon_product(product_id: int):
+        product = base_by_id.get(product_id)
+        if not product:
+            flash("Product not found.", "error")
+            return redirect(url_for("home"))
+
+        cloth_path = Path(app.root_path) / "static" / product.static_filename
+
+        if request.method == "GET":
+            return render_tryon_page(product, result_image_url=None)
+
+        if "person_image" not in request.files:
+            flash("Please upload your photo.", "error")
+            return render_tryon_page(product, result_image_url=None)
+
+        if not cloth_path.exists():
+            flash(f"Cloth image file not found: {cloth_path}", "error")
+            return render_tryon_page(product, result_image_url=None)
+
+        person_file = request.files["person_image"]
+        if not person_file.filename:
+            flash("Invalid person image.", "error")
+            return render_tryon_page(product, result_image_url=None)
+
+        person_ext = _secure_ext(person_file.filename)
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tmp_path = Path(tmp_dir)
+            person_path = tmp_path / f"person{person_ext}"
+            person_file.save(person_path)
+
+            try:
+                out_img = call_vton_space(
+                    person_image_path=str(person_path),
+                    cloth_image_path=str(cloth_path),
+                    garment_description=product.product_name,
+                )
+            except Exception as exc:
+                flash(f"Try-on failed: {exc}", "error")
+                return render_tryon_page(product, result_image_url=None)
+
+            generated_dir = Path(app.root_path) / "static" / "generated"
+            generated_dir.mkdir(parents=True, exist_ok=True)
+
+            output_filename = f"tryon_{product_id}.png"
+            out_img.save(generated_dir / output_filename)
+
+        return render_tryon_page(product, result_image_url=url_for("static", filename=f"generated/tryon_{product_id}.png"))
+
+    return app
+
+app = create_app()
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", "7860"))
+    app.run(host="0.0.0.0", port=port, debug=True)

eco_try_products_dataset_fabric_category_fixed.csv

@@ -0,0 +1,51 @@
+product_id,product_name,fabric_type,image_url,water_usage_liters,co2_emission_kg,biodegradability_score,sustainability_score,awareness_text,category
+1,Hemp Sweater,Cotton jersey,static/images/1.jpeg,1272.8,1.05,9,9.3,"Hemp has water usage ~1272.8L/kg, CO2 emission ~1.05kg/kg, biodegradability 9/10.",Sweater
+2,Recycled Polyester Jeans,Wool knit / wool blend,static/images/2.jpeg,1938.5,2.6,3,6.3,"Recycled Polyester has water usage ~1938.5L/kg, CO2 emission ~2.6kg/kg, biodegradability 3/10.",Jeans
+3,Recycled Polyester Shirt,Satin (polyester or silk satin),static/images/3.jpeg,1924.1,2.58,4,6.6,"Recycled Polyester has water usage ~1924.1L/kg, CO2 emission ~2.58kg/kg, biodegradability 4/10.",Shirt
+4,Silk Jeans,Cotton jersey,static/images/4.jpeg,2800.0,3.25,7,6.7,"Silk has water usage ~2800.0L/kg, CO2 emission ~3.25kg/kg, biodegradability 7/10.",Jeans
+5,Silk Shirt,"Denim (cotton denim, maybe elastane)",static/images/5.jpeg,2267.2,3.98,8,7.3,"Silk has water usage ~2267.2L/kg, CO2 emission ~3.98kg/kg, biodegradability 8/10.",Shirt
+6,Wool Dress,Denim / cotton twill,static/images/6.jpeg,4689.9,10.61,7,3.0,"Wool has water usage ~4689.9L/kg, CO2 emission ~10.61kg/kg, biodegradability 7/10.",Dress
+7,Silk Dress,Fleece (cotton/poly blend),static/images/7.jpeg,2910.0,3.26,8,7.0,"Silk has water usage ~2910.0L/kg, CO2 emission ~3.26kg/kg, biodegradability 8/10.",Dress
+8,Polyester Dress,Fleece (cotton/poly blend),static/images/8.jpeg,2595.5,5.32,1,4.3,"Polyester has water usage ~2595.5L/kg, CO2 emission ~5.32kg/kg, biodegradability 1/10.",Dress
+9,Silk Hoodie,Wool / wool blend (coat wool),static/images/9.jpeg,2326.6,3.84,6,6.6,"Silk has water usage ~2326.6L/kg, CO2 emission ~3.84kg/kg, biodegradability 6/10.",Hoodie
+10,Linen T-shirt,Satin (polyester or silk satin),static/images/10.jpeg,1741.6,1.18,9,8.9,"Linen has water usage ~1741.6L/kg, CO2 emission ~1.18kg/kg, biodegradability 9/10.",Shirt
+11,Linen Shirt,Linen / linen-blend,static/images/11.jpeg,1477.1,1.31,9,9.0,"Linen has water usage ~1477.1L/kg, CO2 emission ~1.31kg/kg, biodegradability 9/10.",Shirt
+12,Silk Hoodie,Polyester (performance knit),static/images/12.jpeg,2068.6,3.58,6,6.9,"Silk has water usage ~2068.6L/kg, CO2 emission ~3.58kg/kg, biodegradability 6/10.",Hoodie
+13,Silk Sweater,Cotton poplin / cotton-linen blend,static/images/13.jpeg,2231.3,3.66,6,6.7,"Silk has water usage ~2231.3L/kg, CO2 emission ~3.66kg/kg, biodegradability 6/10.",Sweater
+14,Wool Jacket,Cotton jersey (or blend),static/images/14.jpeg,4112.6,10.72,7,3.4,"Wool has water usage ~4112.6L/kg, CO2 emission ~10.72kg/kg, biodegradability 7/10.",Jacket
+15,Polyester Hoodie,Nylon/Polyester (synthetic shell),static/images/15.jpeg,2536.6,5.31,3,5.0,"Polyester has water usage ~2536.6L/kg, CO2 emission ~5.31kg/kg, biodegradability 3/10.",Hoodie
+16,Polyester Hoodie,Wool knit / wool blend,static/images/16.jpeg,2742.2,5.97,1,4.0,"Polyester has water usage ~2742.2L/kg, CO2 emission ~5.97kg/kg, biodegradability 1/10.",Hoodie
+17,Hemp Hoodie,Satin (polyester or silk satin),static/images/17.jpeg,953.7,1.1,9,9.5,"Hemp has water usage ~953.7L/kg, CO2 emission ~1.1kg/kg, biodegradability 9/10.",Hoodie
+18,Recycled Polyester Dress,Linen / linen-blend,static/images/18.jpeg,2080.6,2.74,3,6.1,"Recycled Polyester has water usage ~2080.6L/kg, CO2 emission ~2.74kg/kg, biodegradability 3/10.",Dress
+19,Linen Jeans,Polyester-heavy fleece / poly blend,static/images/19.jpeg,1385.8,1.59,9,9.0,"Linen has water usage ~1385.8L/kg, CO2 emission ~1.59kg/kg, biodegradability 9/10.",Jeans
+20,Recycled Polyester Shirt,Cotton jersey,static/images/20.jpeg,1897.9,2.27,5,7.1,"Recycled Polyester has water usage ~1897.9L/kg, CO2 emission ~2.27kg/kg, biodegradability 5/10.",Shirt
+21,Recycled Polyester Hoodie,Cotton jersey,static/images/21.jpeg,1819.8,2.99,5,6.9,"Recycled Polyester has water usage ~1819.8L/kg, CO2 emission ~2.99kg/kg, biodegradability 5/10.",Hoodie
+22,Silk Shirt,Wool / wool blend (coat wool),static/images/22.jpeg,2151.6,3.36,6,6.9,"Silk has water usage ~2151.6L/kg, CO2 emission ~3.36kg/kg, biodegradability 6/10.",Shirt
+23,Silk Jacket,"Denim (cotton denim, maybe elastane)",static/images/23.jpeg,2782.8,3.96,7,6.5,"Silk has water usage ~2782.8L/kg, CO2 emission ~3.96kg/kg, biodegradability 7/10.",Jacket
+24,Wool Jacket,Denim / cotton twill,static/images/24.jpeg,4598.6,10.02,9,3.9,"Wool has water usage ~4598.6L/kg, CO2 emission ~10.02kg/kg, biodegradability 9/10.",Jacket
+25,Wool Dress,Denim / cotton twill,static/images/25.jpeg,4008.0,11.95,7,3.1,"Wool has water usage ~4008.0L/kg, CO2 emission ~11.95kg/kg, biodegradability 7/10.",Dress
+26,Hemp Hoodie,Cotton jersey,static/images/26.jpeg,1073.0,1.12,9,9.4,"Hemp has water usage ~1073.0L/kg, CO2 emission ~1.12kg/kg, biodegradability 9/10.",Hoodie
+27,Polyester Jacket,Satin (polyester or silk satin),static/images/27.jpeg,2941.1,5.81,2,4.2,"Polyester has water usage ~2941.1L/kg, CO2 emission ~5.81kg/kg, biodegradability 2/10.",Jacket
+28,Polyester Sweater,Linen / linen-blend (or cotton-linen),static/images/28.jpeg,2838.0,5.1,3,4.8,"Polyester has water usage ~2838.0L/kg, CO2 emission ~5.1kg/kg, biodegradability 3/10.",Sweater
+29,Recycled Polyester T-shirt,Wool knit / wool blend,static/images/29.jpeg,2085.9,2.5,4,6.5,"Recycled Polyester has water usage ~2085.9L/kg, CO2 emission ~2.5kg/kg, biodegradability 4/10.",Shirt
+30,Polyester Sweater,Fleece (cotton/poly blend),static/images/30.jpeg,2922.3,5.23,1,4.0,"Polyester has water usage ~2922.3L/kg, CO2 emission ~5.23kg/kg, biodegradability 1/10.",Sweater
+31,Hemp T-shirt,Cotton jersey,static/images/31.jpeg,1185.4,1.33,9,9.3,"Hemp has water usage ~1185.4L/kg, CO2 emission ~1.33kg/kg, biodegradability 9/10.",Shirt
+32,Silk T-shirt,Wool / wool blend (coat wool),static/images/32.jpeg,2347.6,3.65,6,6.6,"Silk has water usage ~2347.6L/kg, CO2 emission ~3.65kg/kg, biodegradability 6/10.",Shirt
+33,Silk Sweater,"Denim (cotton denim, maybe elastane)",static/images/33.jpeg,2682.4,3.99,7,6.6,"Silk has water usage ~2682.4L/kg, CO2 emission ~3.99kg/kg, biodegradability 7/10.",Sweater
+34,Hemp T-shirt,Denim / cotton twill,static/images/34.jpeg,1184.9,1.39,10,9.6,"Hemp has water usage ~1184.9L/kg, CO2 emission ~1.39kg/kg, biodegradability 10/10.",Shirt
+35,Linen Hoodie,Denim / cotton twill,static/images/35.jpeg,1157.0,1.0,8,9.0,"Linen has water usage ~1157.0L/kg, CO2 emission ~1.0kg/kg, biodegradability 8/10.",Hoodie
+36,Silk Sweater,Cotton jersey,static/images/36.jpeg,2856.4,3.75,6,6.2,"Silk has water usage ~2856.4L/kg, CO2 emission ~3.75kg/kg, biodegradability 6/10.",Sweater
+37,Hemp Hoodie,Satin (polyester or silk satin),static/images/37.jpeg,1053.7,1.43,10,9.7,"Hemp has water usage ~1053.7L/kg, CO2 emission ~1.43kg/kg, biodegradability 10/10.",Hoodie
+38,Wool Shirt,Linen / linen-blend (or cotton-linen),static/images/38.jpeg,4600.9,11.45,8,3.2,"Wool has water usage ~4600.9L/kg, CO2 emission ~11.45kg/kg, biodegradability 8/10.",Shirt
+39,Polyester Jacket,Wool knit / wool blend,static/images/39.jpeg,2904.3,5.04,1,4.1,"Polyester has water usage ~2904.3L/kg, CO2 emission ~5.04kg/kg, biodegradability 1/10.",Jacket
+40,Hemp T-shirt,Fleece (cotton/poly blend),static/images/40.jpeg,1174.9,1.36,10,9.6,"Hemp has water usage ~1174.9L/kg, CO2 emission ~1.36kg/kg, biodegradability 10/10.",Shirt
+41,Polyester Hoodie,Satin (polyester or silk satin),static/images/41.jpeg,2800.6,5.49,2,4.4,"Polyester has water usage ~2800.6L/kg, CO2 emission ~5.49kg/kg, biodegradability 2/10.",Hoodie
+42,Polyester Jacket,Linen / linen-blend,static/images/42.jpeg,2638.2,5.84,2,4.4,"Polyester has water usage ~2638.2L/kg, CO2 emission ~5.84kg/kg, biodegradability 2/10.",Jacket
+43,Hemp T-shirt,Wool knit / wool blend,static/images/43.jpeg,1004.2,1.5,9,9.4,"Hemp has water usage ~1004.2L/kg, CO2 emission ~1.5kg/kg, biodegradability 9/10.",Shirt
+44,Polyester Sweater,Polyester (performance knit),static/images/44.jpeg,2598.4,5.92,3,4.7,"Polyester has water usage ~2598.4L/kg, CO2 emission ~5.92kg/kg, biodegradability 3/10.",Sweater
+45,Linen Jeans,Fleece (cotton/poly blend),static/images/45.jpeg,1470.5,1.41,8,8.7,"Linen has water usage ~1470.5L/kg, CO2 emission ~1.41kg/kg, biodegradability 8/10.",Jeans
+46,Polyester Dress,Fleece (cotton/poly blend),static/images/46.jpeg,2689.3,5.58,1,4.1,"Polyester has water usage ~2689.3L/kg, CO2 emission ~5.58kg/kg, biodegradability 1/10.",Dress
+47,Hemp T-shirt,Linen / linen-blend,static/images/47.jpeg,1315.2,1.36,9,9.1,"Hemp has water usage ~1315.2L/kg, CO2 emission ~1.36kg/kg, biodegradability 9/10.",Shirt
+48,Recycled Polyester Jacket,Satin (polyester or silk satin),static/images/48.jpeg,2009.6,2.1,5,7.0,"Recycled Polyester has water usage ~2009.6L/kg, CO2 emission ~2.1kg/kg, biodegradability 5/10.",Jacket
+49,Linen Jeans,Polyester/Nylon (synthetic shell),static/images/49.jpeg,1234.5,1.96,7,8.4,"Linen has water usage ~1234.5L/kg, CO2 emission ~1.96kg/kg, biodegradability 7/10.",Jeans
+50,Hemp T-shirt,Cotton jersey,static/images/50.jpeg,2138.9,2.27,5,6.9,"Hemp has water usage ~2138.9L/kg, CO2 emission ~2.27kg/kg, biodegradability 5/10.",Shirt

fabric_mapping_1_to_50.json

@@ -0,0 +1,52 @@
+{
+  "1": "Cotton jersey",
+  "2": "Wool knit / wool blend",
+  "3": "Satin (polyester or silk satin)",
+  "4": "Cotton jersey",
+  "5": "Denim (cotton denim, maybe elastane)",
+  "6": "Denim / cotton twill",
+  "7": "Fleece (cotton/poly blend)",
+  "8": "Fleece (cotton/poly blend)",
+  "9": "Wool / wool blend (coat wool)",
+  "10": "Satin (polyester or silk satin)",
+  "11": "Linen / linen-blend",
+  "12": "Polyester (performance knit)",
+  "13": "Cotton poplin / cotton-linen blend",
+  "14": "Cotton jersey (or blend)",
+  "15": "Nylon/Polyester (synthetic shell)",
+  "16": "Wool knit / wool blend",
+  "17": "Satin (polyester or silk satin)",
+  "18": "Linen / linen-blend",
+  "19": "Polyester-heavy fleece / poly blend",
+  "20": "Cotton jersey",
+  "21": "Cotton jersey",
+  "22": "Wool / wool blend (coat wool)",
+  "23": "Denim (cotton denim, maybe elastane)",
+  "24": "Denim / cotton twill",
+  "25": "Denim / cotton twill",
+  "26": "Cotton jersey",
+  "27": "Satin (polyester or silk satin)",
+  "28": "Linen / linen-blend (or cotton-linen)",
+  "29": "Wool knit / wool blend",
+  "30": "Fleece (cotton/poly blend)",
+  "31": "Cotton jersey",
+  "32": "Wool / wool blend (coat wool)",
+  "33": "Denim (cotton denim, maybe elastane)",
+  "34": "Denim / cotton twill",
+  "35": "Denim / cotton twill",
+  "36": "Cotton jersey",
+  "37": "Satin (polyester or silk satin)",
+  "38": "Linen / linen-blend (or cotton-linen)",
+  "39": "Wool knit / wool blend",
+  "40": "Fleece (cotton/poly blend)",
+  "41": "Satin (polyester or silk satin)",
+  "42": "Linen / linen-blend",
+  "43": "Wool knit / wool blend",
+  "44": "Polyester (performance knit)",
+  "45": "Fleece (cotton/poly blend)",
+  "46": "Fleece (cotton/poly blend)",
+  "47": "Linen / linen-blend",
+  "48": "Satin (polyester or silk satin)",
+  "49": "Polyester/Nylon (synthetic shell)",
+  "50": "Cotton jersey"
+}

overrides.json

@@ -0,0 +1 @@
+{}

tryon_hf.py

@@ -0,0 +1,26 @@
+import os
+from gradio_client import Client, file
+
+VTON_SPACE_ID = "EcoTry/IDM-VTON"
+HF_TOKEN = os.getenv("HF_TOKEN")  # env se lo (best)
+
+# ✅ single clean client
+client = Client(VTON_SPACE_ID, hf_token=HF_TOKEN)
+
+def run_tryon(person_img_path, cloth_img_path, prompt="t-shirt"):
+    result = client.predict(
+        dict={
+            "background": file(person_img_path),
+            "layers": [],
+            "composite": None
+        },
+        garm_img=file(cloth_img_path),
+        garment_des=f"high quality photo of person wearing {prompt}",
+        is_checked=True,
+        is_checked_crop=False,
+        denoise_steps=30,
+        seed=42,
+        api_name="/tryon"
+    )
+
+    return result[0]