Update app.py

app.py

@@ -2,13 +2,14 @@ import os
 import time
 import json
 import tempfile
-from typing import Dict, Any, List, Generator, Tuple
+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
+GRID_FILENAME = "grid.png"
 
 
 def _now() -> str:
@@ -26,12 +27,17 @@ def _auth_headers() -> Dict[str, str]:
     return {"Authorization": f"Bearer {token}"}
 
 
-def _req(method: str, path: str) -> Any:
+def _req(method: str, path: str, json_body: Optional[Dict[str, Any]] = None) -> Any:
+    kwargs: Dict[str, Any] = {
+        "headers": _auth_headers(),
+        "timeout": 60,
+    }
+    if json_body is not None:
+        kwargs["json"] = json_body
     r = requests.request(
         method,
         f"{PRINTIFY_BASE}{path}",
-        headers=_auth_headers(),
-        timeout=60,
+        **kwargs,
     )
     if r.status_code >= 400:
         raise RuntimeError(f"HTTP {r.status_code}: {r.text[:2000]}")
@@ -177,26 +183,157 @@ def _build_product(blob: Dict[str, Any], currency: str, logs: List[str]) -> Dict
     }
 
 
-def _log_latest_upload(logs: List[str]):
-    uploads = _req("GET", "/v1/uploads.json?limit=1")
-    latest = None
+def _pick_shop_id(shops_resp: Any) -> str:
+    if isinstance(shops_resp, list):
+        items = shops_resp
+    elif isinstance(shops_resp, dict):
+        items = shops_resp.get("data") or shops_resp.get("shops") or shops_resp.get("items") or []
+    else:
+        items = []
+
+    for s in items:
+        if isinstance(s, dict) and s.get("id"):
+            return str(s["id"])
+    raise RuntimeError("No shops found on /v1/shops.json for this token.")
+
+
+def _upload_grid_from_file(logs: List[str]) -> Dict[str, Any]:
+    path = os.path.join(os.getcwd(), GRID_FILENAME)
+    if not os.path.exists(path):
+        raise RuntimeError(f"Grid image not found at {path}")
+
+    _log(logs, f"UPLOADING_GRID path={path}")
+
+    with open(path, "rb") as f:
+        r = requests.post(
+            f"{PRINTIFY_BASE}/v1/uploads/images.json",
+            headers=_auth_headers(),
+            files={"file": (GRID_FILENAME, f, "image/png")},
+            timeout=60,
+        )
+
+    if r.status_code >= 400:
+        raise RuntimeError(f"UPLOAD_HTTP {r.status_code}: {r.text[:2000]}")
 
-    if isinstance(uploads, list) and uploads:
-        latest = uploads[0]
-    elif isinstance(uploads, dict):
-        items = uploads.get("data") or uploads.get("uploads") or uploads.get("items") or []
-        if isinstance(items, list) and items:
-            latest = items[0]
+    resp = r.json()
+    if not isinstance(resp, dict) or not resp.get("id"):
+        raise RuntimeError(f"Unexpected upload response: {str(resp)[:500]}")
 
-    if latest:
+    _log(
+        logs,
+        f"GRID_UPLOAD id={resp.get('id')} "
+        f"file={resp.get('file_name') or resp.get('name')} "
+        f"w={resp.get('width')} h={resp.get('height')}",
+    )
+    return resp
+
+
+def _scale_fill(ph_w: float, ph_h: float, img_w: float, img_h: float) -> float:
+    if ph_w <= 0 or ph_h <= 0 or img_w <= 0 or img_h <= 0:
+        return 1.0
+    # width-based scale; bump if height would underfill
+    s = (ph_h * img_w) / (ph_w * img_h)
+    if s < 1.0:
+        s = 1.0
+    return float(s)
+
+
+def _create_one_product_with_grid(
+    logs: List[str],
+    shop_id: str,
+    blob: Dict[str, Any],
+    product_info: Dict[str, Any],
+    upload: Dict[str, Any],
+    currency: str,
+) -> Dict[str, Any]:
+    bp_id = (blob.get("blueprint") or {}).get("id")
+    provider_id = (blob.get("provider") or {}).get("id")
+    if bp_id is None or provider_id is None:
+        raise RuntimeError("Missing blueprint or provider id.")
+
+    variants = product_info.get("variants") or []
+    if not isinstance(variants, list) or not variants:
+        raise RuntimeError("No variants to create product with.")
+
+    v = variants[0]
+    variant_id = v.get("id")
+    if variant_id is None:
+        raise RuntimeError("Variant missing id.")
+
+    placeholders = v.get("placeholders") or []
+    img_id = upload.get("id")
+    img_w = float(upload.get("width") or 0)
+    img_h = float(upload.get("height") or 0)
+
+    ph_payload = []
+    for ph in placeholders:
+        if not isinstance(ph, dict):
+            continue
+        pos = ph.get("position")
+        pw = ph.get("width")
+        phh = ph.get("height")
+        if not pos or pw is None or phh is None:
+            continue
+        try:
+            pwf = float(pw)
+            phf = float(phh)
+        except Exception:
+            continue
+        scale = _scale_fill(pwf, phf, img_w, img_h)
+        ph_payload.append({
+            "position": pos,
+            "images": [{
+                "id": img_id,
+                "x": 0.5,
+                "y": 0.5,
+                "scale": scale,
+                "angle": 0,
+            }],
+        })
         _log(
             logs,
-            f"LATEST_UPLOAD id={latest.get('id')} "
-            f"file={latest.get('file_name') or latest.get('name')} "
-            f"w={latest.get('width')} h={latest.get('height')}"
+            f"FILL_PLACEHOLDER pos={pos} ph={int(pwf)}x{int(phf)} "
+            f"img={int(img_w)}x{int(img_h)} scale={round(scale, 6)}",
         )
-    else:
-        _log(logs, "LATEST_UPLOAD none found")
+
+    if not ph_payload:
+        raise RuntimeError("No placeholders for chosen variant.")
+
+    title = product_info.get("name") or "Printify Grid Test"
+    description = product_info.get("description") or ""
+
+    payload = {
+        "title": title,
+        "description": description,
+        "blueprint_id": int(bp_id),
+        "print_provider_id": int(provider_id),
+        "variants": [{
+            "id": int(variant_id),
+            "price": int(product_info.get("price", DEFAULT_BASE_PRICE) * 100),
+            "is_enabled": True,
+        }],
+        "print_areas": [{
+            "variant_ids": [int(variant_id)],
+            "placeholders": ph_payload,
+        }],
+    }
+
+    _log(
+        logs,
+        f"PHASE_B_CREATE shop_id={shop_id} "
+        f"blueprint_id={bp_id} provider_id={provider_id} variant_id={variant_id}",
+    )
+
+    created = _req(
+        "POST",
+        f"/v1/shops/{shop_id}/products.json",
+        json_body=payload,
+    )
+    if not isinstance(created, Dict):
+        raise RuntimeError(f"Unexpected create response: {str(created)[:500]}")
+
+    _log(logs, f"PHASE_B_CREATED product_id={created.get('id')}")
+    return created
 
 
 def run(currency: str) -> Generator[Tuple[str, str], None, None]:
@@ -214,10 +351,6 @@ def run(currency: str) -> Generator[Tuple[str, str], None, None]:
         _log(logs, f"SHOP_LIST {json.dumps(shops)}")
         yield flush()
 
-        # NEW: log newest upload right after shops
-        _log_latest_upload(logs)
-        yield flush()
-
         fd, path = tempfile.mkstemp(prefix="shops_", suffix=".json")
         os.close(fd)
         with open(path, "w", encoding="utf-8") as f:
@@ -253,15 +386,31 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
         _log(logs, f"SHOP_LIST {json.dumps(shops)}")
         yield flush()
 
-        # SAME upload logging, but under Phase B
-        _log_latest_upload(logs)
+        shop_id = _pick_shop_id(shops)
+        _log(logs, f"SHOP_ID {shop_id}")
         yield flush()
 
         blob = _find_first_valid_pair(logs)
         yield flush()
 
-        result = _build_product(blob, currency or "USD", logs)
-        _log(logs, "PHASE_B_DONE_NO_CREATE")
+        product_info = _build_product(blob, currency or "USD", logs)
+        result["phaseAProduct"] = product_info
+        yield flush()
+
+        upload = _upload_grid_from_file(logs)
+        result["gridUpload"] = upload
+        yield flush()
+
+        created = _create_one_product_with_grid(
+            logs,
+            shop_id=shop_id,
+            blob=blob,
+            product_info=product_info,
+            upload=upload,
+            currency=currency or "USD",
+        )
+        result["createdProduct"] = created
+        _log(logs, "PHASE_B_DONE")
         yield flush()
 
     except Exception as e: