Update app.py

app.py

@@ -2,26 +2,28 @@ import os
 import time
 import json
 import tempfile
-from typing import Dict, Any, List, Tuple, Generator, Optional
+from typing import Dict, Any, List, Generator, Tuple, Optional
 
 import requests
 import gradio as gr
 
 PRINTIFY_BASE = "https://api.printify.com"
+DEFAULT_BASE_PRICE = 24.99
 
 
 def _now() -> str:
     return time.strftime("%H:%M:%S")
 
 
+def _sleep(ms: int):
+    time.sleep(ms / 1000)
+
+
 def _auth_headers() -> Dict[str, str]:
     token = os.environ.get("PRINTIFY_API_TOKEN")
     if not token:
         raise RuntimeError("Missing PRINTIFY_API_TOKEN (HF Space Secret).")
-    return {
-        "Authorization": f"Bearer {token}",
-        "User-Agent": "PrintifyPhaseAProbe/1.0",
-    }
+    return {"Authorization": f"Bearer {token}"}
 
 
 def _req(method: str, path: str) -> Any:
@@ -40,18 +42,13 @@ def _log(logs: List[str], msg: str):
     logs.append(f"[{_now()}] {msg}")
 
 
-def list_shops() -> Tuple[str, List[Tuple[str, str]]]:
-    logs: List[str] = []
+def _list_shops(logs: List[str]) -> List[Dict[str, Any]]:
     _log(logs, "Fetching shops: GET /v1/shops.json")
     shops = _req("GET", "/v1/shops.json")
-    choices: List[Tuple[str, str]] = []
-    for s in shops or []:
-        sid = str(s.get("id"))
-        title = s.get("title") or "untitled"
-        chan = s.get("sales_channel") or "unknown"
-        choices.append((f"{title} ({chan}) — {sid}", sid))
-    _log(logs, f"Found {len(choices)} shops")
-    return "\n".join(logs), choices
+    if not isinstance(shops, list):
+        raise RuntimeError("Unexpected shops response")
+    _log(logs, f"Found {len(shops)} shops")
+    return shops
 
 
 def _paginate_blueprints(logs: List[str], per_page: int = 100) -> List[Dict[str, Any]]:
@@ -70,9 +67,44 @@ def _paginate_blueprints(logs: List[str], per_page: int = 100) -> List[Dict[str,
     return out
 
 
+def _extract_variant_snapshot(variants: List[Dict[str, Any]]) -> Tuple[List[Dict[str, Any]], float]:
+    snapshot = []
+    all_cents: List[int] = []
+
+    for v in variants:
+        cents_raw = v.get("price")
+        cents = None
+        try:
+            if isinstance(cents_raw, (int, float)):
+                cents = int(cents_raw)
+            elif isinstance(cents_raw, str) and cents_raw.isdigit():
+                cents = int(cents_raw)
+        except Exception:
+            cents = None
+
+        if cents is not None:
+            all_cents.append(cents)
+
+        opts = v.get("options") or {}
+        snapshot.append(
+            {
+                "id": v.get("id"),
+                "sku": v.get("sku"),
+                "size": opts.get("size"),
+                "color": opts.get("color"),
+                "priceCents": cents,
+                "price": round(cents / 100, 2) if cents is not None else None,
+                "placeholders": v.get("placeholders") or [],
+            }
+        )
+
+    min_price = round(min(all_cents) / 100, 2) if all_cents else DEFAULT_BASE_PRICE
+    return snapshot, min_price
+
+
 def run_phase_a(
-    shop_id: str,
-    max_pairs: int,
+    selected_shop_id: Optional[str],
+    max_templates: int,
     per_page: int,
 ) -> Generator[Tuple[str, str, Optional[str]], None, None]:
     logs: List[str] = []
@@ -83,81 +115,108 @@ def run_phase_a(
         return "\n".join(logs), json.dumps(results[:3], indent=2), download_path
 
     try:
-        if not shop_id:
-            raise RuntimeError("Pick a shop first (Atheria).")
+        _log(logs, "START")
+        yield flush()
+
+        shops = _list_shops(logs)
+        shop_choices = []
+        for s in shops:
+            sid = s.get("id")
+            title = s.get("title") or "untitled"
+            chan = s.get("sales_channel") or "unknown"
+            shop_choices.append((f"{title} ({chan}) — {sid}", str(sid)))
 
-        _log(logs, f"START Phase A (shop_id={shop_id})")
+        if selected_shop_id:
+            shop_id = str(selected_shop_id)
+        else:
+            raise RuntimeError("Pick a shop (Atheria) first, then Run.")
+
+        _log(logs, f"Using shop_id={shop_id}")
         yield flush()
 
+        max_templates = int(max_templates or 0)
+        per_page = int(per_page or 100)
+
         blueprints = _paginate_blueprints(logs, per_page=per_page)
         yield flush()
 
         pairs_scanned = 0
 
         for bp in blueprints:
-            bp_id = str(bp.get("id"))
-            if not bp_id:
+            bp_id = bp.get("id")
+            if bp_id is None:
                 continue
+            bp_id_s = str(bp_id)
 
-            providers = _req("GET", f"/v1/catalog/blueprints/{bp_id}/print_providers.json")
+            _log(logs, f"Blueprint {bp_id_s}: fetching providers")
+            providers = _req("GET", f"/v1/catalog/blueprints/{bp_id_s}/print_providers.json")
             if not isinstance(providers, list) or not providers:
                 continue
 
             for p in providers:
-                p_id = str(p.get("id"))
-                if not p_id:
+                p_id = p.get("id")
+                if p_id is None:
                     continue
+                p_id_s = str(p_id)
 
                 pairs_scanned += 1
-                _log(logs, f"Pair {pairs_scanned}: blueprint={bp_id} provider={p_id}")
+                _log(logs, f"Blueprint {bp_id_s} / Provider {p_id_s}: fetching variants")
 
-                vr = _req("GET", f"/v1/catalog/blueprints/{bp_id}/print_providers/{p_id}/variants.json")
+                vr = _req("GET", f"/v1/catalog/blueprints/{bp_id_s}/print_providers/{p_id_s}/variants.json?show-out-of-stock=1")
                 variants = vr.get("variants") if isinstance(vr, dict) else None
                 if not isinstance(variants, list) or not variants:
                     continue
 
-                _log(logs, f"FOUND variants={len(variants)} for blueprint={bp_id} provider={p_id}")
-
-                blueprint_details = _req("GET", f"/v1/catalog/blueprints/{bp_id}.json")
-                provider_details = _req("GET", f"/v1/catalog/print_providers/{p_id}.json")
-                shipping_info = _req("GET", f"/v1/catalog/blueprints/{bp_id}/print_providers/{p_id}/shipping.json")
-
-                variant_snapshot = []
-                for v in variants:
-                    opts = (v.get("options") or {})
-                    variant_snapshot.append({
-                        "id": v.get("id"),
-                        "title": v.get("title"),
-                        "options": {
-                            "color": opts.get("color"),
-                            "size": opts.get("size"),
-                        },
-                        "placeholders": v.get("placeholders") or [],
-                    })
-
-                results.append({
-                    "blueprint_id": int(bp_id),
-                    "print_provider_id": int(p_id),
-                    "blueprint_title": blueprint_details.get("title") or bp.get("title"),
-                    "brand": blueprint_details.get("brand") or bp.get("brand"),
-                    "model": blueprint_details.get("model") or bp.get("model"),
-                    "provider_title": provider_details.get("title") or p.get("title"),
-                    "provider_location": provider_details.get("location") or {},
-                    "variants_count": len(variants),
+                _log(logs, f"FOUND {len(variants)} variants (bp={bp_id_s}, provider={p_id_s})")
+
+                blueprint_details = _req("GET", f"/v1/catalog/blueprints/{bp_id_s}.json")
+                provider_details = _req("GET", f"/v1/catalog/print_providers/{p_id_s}.json")
+                shipping_info = _req("GET", f"/v1/catalog/blueprints/{bp_id_s}/print_providers/{p_id_s}/shipping.json")
+
+                variant_snapshot, min_price = _extract_variant_snapshot(variants)
+
+                _log(logs, "VARIANT_SNAPSHOT " + json.dumps({"count": len(variant_snapshot), "sample": variant_snapshot[:20]}))
+
+                provider_loc = provider_details.get("location") or {}
+                provider_name = provider_details.get("title") or provider_details.get("name") or "empty"
+                loc_str = ", ".join([x for x in [provider_loc.get("city"), provider_loc.get("country")] if x]) or "empty"
+                base_desc = blueprint_details.get("description") or bp.get("description") or "empty"
+                description = f"{base_desc}\n\nFulfilled by {provider_name} — {loc_str}"
+
+                colors = sorted({v.get("color") for v in variant_snapshot if v.get("color")})
+                sizes = sorted({v.get("size") for v in variant_snapshot if v.get("size")})
+
+                product_template = {
+                    "shop_id": int(shop_id),
+                    "blueprint_id": int(bp_id_s),
+                    "print_provider_id": int(p_id_s),
+                    "name": blueprint_details.get("title") or bp.get("title") or "empty",
+                    "description": description,
+                    "tags": ["Printify", f"Provider: {provider_name}"],
+                    "options": {"Color": colors, "Size": sizes},
+                    "variants_count": len(variant_snapshot),
+                    "price_min": min_price,
                     "variants": variant_snapshot,
                     "shipping": shipping_info,
-                })
-
+                    "raw": {
+                        "blueprint": bp,
+                        "provider": p,
+                        "blueprintDetails": blueprint_details,
+                        "providerDetails": provider_details,
+                    },
+                }
+
+                results.append(product_template)
                 yield flush()
 
-                if max_pairs and len(results) >= max_pairs:
-                    _log(logs, f"Reached max_pairs={max_pairs}. Stopping.")
+                if max_templates and len(results) >= max_templates:
+                    _log(logs, f"Reached max_templates={max_templates}. Stopping.")
                     break
 
-            if max_pairs and len(results) >= max_pairs:
+            if max_templates and len(results) >= max_templates:
                 break
 
-        _log(logs, f"DONE Phase A. templates={len(results)} pairs_scanned={pairs_scanned}")
+        _log(logs, f"DONE templates={len(results)} pairs_scanned={pairs_scanned}")
 
         fd, path = tempfile.mkstemp(prefix="phase_a_", suffix=".json")
         os.close(fd)
@@ -172,7 +231,6 @@ def run_phase_a(
                 indent=2,
             )
         download_path = path
-
         yield flush()
 
     except Exception as e:
@@ -180,31 +238,39 @@ def run_phase_a(
         yield "\n".join(logs), "[]", None
 
 
-with gr.Blocks(title="Printify Phase A") as demo:
-    gr.Markdown("Phase A: discover shop + enumerate blueprint/provider templates (variants + placeholders) and download JSON.")
+def fetch_shops_for_dropdown() -> Tuple[str, gr.Dropdown]:
+    logs: List[str] = []
+    shops = _list_shops(logs)
+    choices = []
+    for s in shops:
+        sid = s.get("id")
+        title = s.get("title") or "untitled"
+        chan = s.get("sales_channel") or "unknown"
+        choices.append((f"{title} ({chan}) — {sid}", str(sid)))
+    return "\n".join(logs), gr.Dropdown(choices=choices, value=None)
+
 
-    shops_log = gr.Textbox(label="Shop Discovery Logs", lines=6)
-    shop_dropdown = gr.Dropdown(label="Select Shop (pick Atheria)", choices=[], value=None)
+with gr.Blocks(title="Printify Phase A Probe") as demo:
+    gr.Markdown("Phase A: fetch shop ID (pick Atheria) + enumerate blueprint/provider templates (variants + placeholders) + download JSON.")
 
+    shops_log = gr.Textbox(label="Shop Logs", lines=6)
+    shop_dropdown = gr.Dropdown(label="Select Shop (pick Atheria)", choices=[], value=None)
     fetch_shops_btn = gr.Button("Fetch Shops")
 
-    max_pairs = gr.Number(label="Max templates to collect (0 = no limit)", value=25, precision=0)
+    max_templates = gr.Number(label="Max templates (0 = no limit)", value=25, precision=0)
     per_page = gr.Number(label="Blueprints per page", value=100, precision=0)
 
     run_btn = gr.Button("Run Phase A")
+
     logs = gr.Textbox(label="Logs", lines=16)
     preview = gr.Textbox(label="Preview (first 3 templates)", lines=16)
-    download = gr.File(label="Download Phase A JSON")
-
-    def _fetch_shops():
-        l, choices = list_shops()
-        return l, gr.Dropdown(choices=choices, value=None)
+    download = gr.File(label="Download Full Phase A JSON")
 
-    fetch_shops_btn.click(_fetch_shops, inputs=[], outputs=[shops_log, shop_dropdown])
+    fetch_shops_btn.click(fetch_shops_for_dropdown, inputs=[], outputs=[shops_log, shop_dropdown])
 
     run_btn.click(
         run_phase_a,
-        inputs=[shop_dropdown, max_pairs, per_page],
+        inputs=[shop_dropdown, max_templates, per_page],
         outputs=[logs, preview, download],
     )