Update app.py

app.py

@@ -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,20 +197,23 @@ 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.")
 
-    preferred_name = os.environ.get("PRINTIFY_SHOP_NAME", "Atheria")
+    forced = (os.environ.get("PRINTIFY_SHOP_ID") or "").strip()
+    if 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()
 
     for s in items:
         if not isinstance(s, dict):
             continue
-        title = s.get("title") or s.get("name")
-        if title and title.strip().lower() == preferred_name.strip().lower():
-            return str(s["id"])
-
-    for s in items:
-        if isinstance(s, dict) and s.get("id"):
+        title = (s.get("title") or s.get("name") or "").strip().lower()
+        if title and title == preferred_name:
             return str(s["id"])
 
-    raise RuntimeError("Could not pick a shop id from response.")
+    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]:
@@ -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"):
@@ -247,13 +254,33 @@ def _scale_fill(ph_w: float, ph_h: float, img_w: float, img_h: float) -> float:
     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")
@@ -264,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 ""
@@ -316,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": 1,
-            "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(
@@ -345,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] = {}
@@ -404,99 +517,44 @@ 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
-        _log(logs, "PHASE_B_DONE")
         yield flush()
 
-    except Exception as e:
-        _log(logs, f"ERROR: {e}")
-        result = {"error": str(e)}
-        yield flush()
+        created_id = str(created.get("id") or "")
+        if not created_id:
+            raise RuntimeError("Created product response missing id.")
 
-
-def phase_c(currency: str, product_id: str) -> Generator[Tuple[str, str], None, None]:
-    logs: List[str] = []
-    result: Dict[str, Any] = {}
-
-    def flush():
-        return "\n".join(logs), json.dumps(result, indent=2)
-
-    try:
-        _log(logs, "PHASE_C_START")
+        prod1 = _get_product(logs, shop_id, created_id)
+        result["createdProductReadback"] = prod1
         yield flush()
 
-        if not product_id or not str(product_id).strip():
-            raise RuntimeError("Missing product_id.")
-
-        shops = _req("GET", "/v1/shops.json")
-        _log(logs, f"SHOP_LIST {json.dumps(shops)}")
-        yield flush()
-
-        shop_id = _pick_shop_id(shops)
-        _log(logs, f"SHOP_ID {shop_id}")
-        yield flush()
-
-        pid = str(product_id).strip()
-        _log(logs, f"PHASE_C_GET_PRODUCT product_id={pid}")
-        prod = _req("GET", f"/v1/shops/{shop_id}/products/{pid}.json")
-        result["productDetails"] = prod
+        _log(
+            logs,
+            f"COMPARE_COUNTS catalog={len(product_info.get('variants') or [])} shop={len(prod1.get('variants') or [])}",
+        )
         yield flush()
 
-        variants = prod.get("variants") or []
-        if not isinstance(variants, list) or not variants:
-            raise RuntimeError("Product details missing variants.")
-
-        update_variants = []
-        for v in variants:
-            vid = v.get("id")
-            cost = v.get("cost")
-            if vid is None or cost is None:
-                _log(logs, f"COST_MISSING variant_id={vid} cost={cost}")
-                continue
-            try:
-                vid_i = int(vid)
-                cost_i = int(cost)
-            except Exception:
-                _log(logs, f"COST_BAD variant_id={vid} cost={cost}")
-                continue
-
-            update_variants.append({
-                "id": vid_i,
-                "price": cost_i,
-                "is_enabled": bool(v.get("is_enabled")),
-            })
-
-            _log(
-                logs,
-                f"PRICE_RECONCILE variant_id={vid_i} cost={cost_i} "
-                f"old_price={v.get('price')} enabled={bool(v.get('is_enabled'))}",
-            )
-
-        if not update_variants:
-            raise RuntimeError("No variants with cost found to reconcile pricing.")
-
-        payload = {"variants": update_variants}
-
-        _log(logs, f"PHASE_C_UPDATE_PRICES count={len(update_variants)}")
-        updated = _req("PUT", f"/v1/shops/{shop_id}/products/{pid}.json", json_body=payload)
-        result["priceUpdateResponse"] = updated
+        upd = _update_prices_to_cost_plus_margin(logs, shop_id, created_id, prod1)
+        result["priceUpdateResponse"] = upd
         yield flush()
 
-        _log(logs, "PHASE_C_DONE")
+        prod2 = _get_product(logs, shop_id, created_id)
+        result["finalProductReadback"] = prod2
+        _log(logs, "PHASE_B_DONE")
         yield flush()
 
     except Exception as e:
@@ -509,16 +567,12 @@ with gr.Blocks(title="Printify Catalog Probe") as demo:
     gr.Markdown("Extract and normalize ONE Printify blueprint/provider into a structured JSON object.")
 
     currency = gr.Textbox(label="Currency", value="USD")
-    product_id = gr.Textbox(label="Product ID (for Phase C)", value="")
-
-    btn = gr.Button("Run (A)")
-    btn_b = gr.Button("Phase B (Create Test)")
-    btn_c = gr.Button("Phase C (Pricing Reconciliation)")
+    btn = gr.Button("Run")
+    btn_b = gr.Button("Phase B (Test)")
     logs = gr.Textbox(label="Logs", lines=18)
     out = gr.Textbox(label="Output JSON", lines=18)
 
     btn.click(run, inputs=[currency], outputs=[logs, out])
     btn_b.click(phase_b, inputs=[currency], outputs=[logs, out])
-    btn_c.click(phase_c, inputs=[currency, product_id], outputs=[logs, out])
 
 demo.queue().launch()