Update app.py

app.py

@@ -9,7 +9,7 @@ import gradio as gr
 import base64
 
 PRINTIFY_BASE = "https://api.printify.com"
-DEFAULT_BASE_PRICE = 0.01
+DEFAULT_BASE_PRICE = 24.99
 GRID_FILENAME = "grid.png"
 
 
@@ -42,7 +42,9 @@ def _req(method: str, path: str, json_body: Optional[Dict[str, Any]] = None) ->
     )
     if r.status_code >= 400:
         raise RuntimeError(f"HTTP {r.status_code}: {r.text[:2000]}")
-    return r.json()
+    if r.text:
+        return r.json()
+    return {}
 
 
 def _log(logs: List[str], msg: str):
@@ -195,10 +197,12 @@ def _pick_shop_id(shops_resp: Any) -> str:
     if not isinstance(items, list) or not items:
         raise RuntimeError("No shops found on /v1/shops.json for this token.")
 
-    # Hard override wins (set this in HF Secrets)
-    forced = os.environ.get("PRINTIFY_SHOP_ID")
+    forced = (os.environ.get("PRINTIFY_SHOP_ID") or "").strip()
     if forced:
-        return str(forced)
+        for s in items:
+            if isinstance(s, dict) and str(s.get("id")) == forced:
+                return str(s["id"])
+        raise RuntimeError(f"Preferred shop '{forced}' not found; refusing to fallback.")
 
     preferred_name = os.environ.get("PRINTIFY_SHOP_NAME", "Atheria").strip().lower()
 
@@ -206,10 +210,11 @@ def _pick_shop_id(shops_resp: Any) -> str:
         if not isinstance(s, dict):
             continue
         title = (s.get("title") or s.get("name") or "").strip().lower()
-        if title == preferred_name:
+        if title and title == preferred_name:
             return str(s["id"])
 
-    raise RuntimeError(f"Preferred shop '{preferred_name}' not found; refusing to fallback.")
+    raise RuntimeError(f"Preferred shop name '{os.environ.get('PRINTIFY_SHOP_NAME','Atheria')}' not found; refusing to fallback.")
+
 
 def _upload_grid_from_file(logs: List[str]) -> Dict[str, Any]:
     path = os.path.join(os.getcwd(), GRID_FILENAME)
@@ -217,14 +222,16 @@ def _upload_grid_from_file(logs: List[str]) -> Dict[str, Any]:
         raise RuntimeError(f"Grid image not found at {path}")
 
     with open(path, "rb") as f:
-        b64 = base64.b64encode(f.read()).decode("ascii")
+        raw = f.read()
+
+    b64 = base64.b64encode(raw).decode("ascii")
 
     payload = {
         "file_name": GRID_FILENAME,
         "contents": b64,
     }
 
-    _log(logs, f"UPLOADING_GRID path={path} bytes={len(b64)}")
+    _log(logs, f"UPLOADING_GRID path={path} bytes={len(raw)} b64len={len(b64)}")
     resp = _req("POST", "/v1/uploads/images.json", json_body=payload)
 
     if not isinstance(resp, dict) or not resp.get("id"):
@@ -237,47 +244,43 @@ def _upload_grid_from_file(logs: List[str]) -> Dict[str, Any]:
     )
     return resp
 
-    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]}")
-
-    resp = r.json()
-    if not isinstance(resp, dict) or not resp.get("id"):
-        raise RuntimeError(f"Unexpected upload response: {str(resp)[:500]}")
-
-    _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(
+def _log_catalog_variants(logs: List[str], product_info: Dict[str, Any], limit: int = 50):
+    variants = product_info.get("variants") or []
+    total = len(variants) if isinstance(variants, list) else 0
+    _log(logs, f"CATALOG_VARIANTS_TOTAL {total}")
+    if not isinstance(variants, list):
+        return
+    n = 0
+    for v in variants:
+        if not isinstance(v, dict):
+            continue
+        vid = v.get("id")
+        size = v.get("size")
+        color = v.get("color")
+        ph = v.get("placeholders") or []
+        phn = len(ph) if isinstance(ph, list) else 0
+        _log(logs, f"CATALOG_VARIANT id={vid} size={size} color={color} placeholders={phn}")
+        n += 1
+        if n >= limit:
+            break
+
+
+def _create_product_all_variants_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")
@@ -288,49 +291,66 @@ def _create_one_product_with_grid(
     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:
+    variants_payload = []
+    print_areas_payload = []
+
+    for v in variants:
+        if not isinstance(v, dict):
             continue
-        try:
-            pwf = float(pw)
-            phf = float(phh)
-        except Exception:
+        vid = v.get("id")
+        if vid is None:
             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,
-            }],
+
+        variants_payload.append({
+            "id": int(vid),
+            "price": 1,
+            "is_enabled": True,
         })
-        _log(
-            logs,
-            f"FILL_PLACEHOLDER pos={pos} ph={int(pwf)}x{int(phf)} "
-            f"img={int(img_w)}x{int(img_h)} scale={round(scale, 6)}",
-        )
 
-    if not ph_payload:
-        raise RuntimeError("No placeholders for chosen variant.")
+        placeholders = v.get("placeholders") or []
+        if not isinstance(placeholders, list) or not placeholders:
+            continue
+
+        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,
+                }],
+            })
+
+        if ph_payload:
+            print_areas_payload.append({
+                "variant_ids": [int(vid)],
+                "placeholders": ph_payload,
+            })
+
+    if not variants_payload:
+        raise RuntimeError("No valid variant ids to create product with.")
+    if not print_areas_payload:
+        raise RuntimeError("No placeholders payload generated for any variant.")
 
     title = product_info.get("name") or "Printify Grid Test"
     description = product_info.get("description") or ""
@@ -340,21 +360,14 @@ def _create_one_product_with_grid(
         "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,
-        }],
+        "variants": variants_payload,
+        "print_areas": print_areas_payload,
     }
 
     _log(
         logs,
-        f"PHASE_B_CREATE shop_id={shop_id} "
-        f"blueprint_id={bp_id} provider_id={provider_id} variant_id={variant_id}",
+        f"PHASE_B_CREATE shop_id={shop_id} blueprint_id={bp_id} provider_id={provider_id} "
+        f"variants_payload={len(variants_payload)} print_areas_payload={len(print_areas_payload)}",
     )
 
     created = _req(
@@ -369,6 +382,82 @@ def _create_one_product_with_grid(
     return created
 
 
+def _get_product(logs: List[str], shop_id: str, product_id: str) -> Dict[str, Any]:
+    prod = _req("GET", f"/v1/shops/{shop_id}/products/{product_id}.json")
+    if not isinstance(prod, dict):
+        raise RuntimeError(f"Unexpected product response: {str(prod)[:500]}")
+    variants = prod.get("variants") or []
+    _log(logs, f"SHOP_VARIANTS_TOTAL {len(variants) if isinstance(variants, list) else 0}")
+    if isinstance(variants, list):
+        for v in variants:
+            if not isinstance(v, dict):
+                continue
+            _log(
+                logs,
+                f"SHOP_VARIANT id={v.get('id')} enabled={v.get('is_enabled')} "
+                f"cost={v.get('cost')} price={v.get('price')}",
+            )
+    return prod
+
+
+def _margin_pct() -> float:
+    raw = (os.environ.get("PRINTIFY_MARGIN_PCT") or "").strip()
+    if not raw:
+        return 0.0
+    try:
+        return float(raw)
+    except Exception:
+        return 0.0
+
+
+def _update_prices_to_cost_plus_margin(
+    logs: List[str],
+    shop_id: str,
+    product_id: str,
+    product: Dict[str, Any],
+) -> Dict[str, Any]:
+    variants = product.get("variants") or []
+    if not isinstance(variants, list) or not variants:
+        raise RuntimeError("No variants found on created product for price update.")
+
+    m = _margin_pct()
+    payload_variants = []
+    for v in variants:
+        if not isinstance(v, dict):
+            continue
+        vid = v.get("id")
+        cost = v.get("cost")
+        if vid is None or cost is None:
+            continue
+        try:
+            cost_cents = int(cost)
+        except Exception:
+            continue
+        price_cents = int(round(cost_cents * (1.0 + m)))
+        if price_cents < 1:
+            price_cents = 1
+        payload_variants.append({
+            "id": int(vid),
+            "price": price_cents,
+            "is_enabled": True,
+        })
+        _log(logs, f"PRICE_SET id={vid} cost={cost_cents} price={price_cents} margin_pct={m}")
+
+    if not payload_variants:
+        raise RuntimeError("No variant prices could be computed from costs.")
+
+    upd = _req(
+        "PUT",
+        f"/v1/shops/{shop_id}/products/{product_id}.json",
+        json_body={"variants": payload_variants},
+    )
+    if not isinstance(upd, dict):
+        raise RuntimeError(f"Unexpected update response: {str(upd)[:500]}")
+
+    _log(logs, f"PRICE_UPDATE_DONE variants={len(payload_variants)}")
+    return upd
+
+
 def run(currency: str) -> Generator[Tuple[str, str], None, None]:
     logs: List[str] = []
     result: Dict[str, Any] = {}
@@ -428,21 +517,43 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
 
         product_info = _build_product(blob, currency or "USD", logs)
         result["phaseAProduct"] = product_info
+        _log_catalog_variants(logs, product_info, limit=75)
         yield flush()
 
         upload = _upload_grid_from_file(logs)
         result["gridUpload"] = upload
         yield flush()
 
-        created = _create_one_product_with_grid(
+        created = _create_product_all_variants_with_grid(
             logs,
             shop_id=shop_id,
             blob=blob,
             product_info=product_info,
             upload=upload,
-            currency=currency or "USD",
         )
         result["createdProduct"] = created
+        yield flush()
+
+        created_id = str(created.get("id") or "")
+        if not created_id:
+            raise RuntimeError("Created product response missing id.")
+
+        prod1 = _get_product(logs, shop_id, created_id)
+        result["createdProductReadback"] = prod1
+        yield flush()
+
+        _log(
+            logs,
+            f"COMPARE_COUNTS catalog={len(product_info.get('variants') or [])} shop={len(prod1.get('variants') or [])}",
+        )
+        yield flush()
+
+        upd = _update_prices_to_cost_plus_margin(logs, shop_id, created_id, prod1)
+        result["priceUpdateResponse"] = upd
+        yield flush()
+
+        prod2 = _get_product(logs, shop_id, created_id)
+        result["finalProductReadback"] = prod2
         _log(logs, "PHASE_B_DONE")
         yield flush()