Update app.py

app.py

@@ -7,6 +7,7 @@ from typing import Dict, Any, List, Generator, Tuple, Optional
 import requests
 import gradio as gr
 import base64
+import re
 
 PRINTIFY_BASE = "https://api.printify.com"
 DEFAULT_BASE_PRICE = 0.001
@@ -28,23 +29,86 @@ def _auth_headers() -> Dict[str, str]:
     return {"Authorization": f"Bearer {token}"}
 
 
-def _req(method: str, path: str, json_body: Optional[Dict[str, Any]] = None) -> Any:
+def _parse_retry_after_seconds(r: requests.Response) -> Optional[float]:
+    ra = r.headers.get("Retry-After")
+    if ra:
+        try:
+            return float(ra)
+        except Exception:
+            pass
+
+    reset = r.headers.get("X-RateLimit-Reset") or r.headers.get("X-RateLimit-Reset-After")
+    if reset:
+        try:
+            return float(reset)
+        except Exception:
+            pass
+
+    try:
+        txt = (r.text or "")[:2000]
+    except Exception:
+        txt = ""
+    m = re.search(r"(\d+(\.\d+)?)\s*(s|sec|secs|second|seconds)\b", txt, re.I)
+    if m:
+        try:
+            return float(m.group(1))
+        except Exception:
+            return None
+    return None
+
+
+def _req(
+    method: str,
+    path: str,
+    json_body: Optional[Dict[str, Any]] = None,
+    logs: Optional[List[str]] = 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}",
-        **kwargs,
-    )
-    if r.status_code >= 400:
-        raise RuntimeError(f"HTTP {r.status_code}: {r.text[:2000]}")
-    if r.text:
-        return r.json()
-    return {}
+
+    while True:
+        r = requests.request(
+            method,
+            f"{PRINTIFY_BASE}{path}",
+            **kwargs,
+        )
+
+        if r.status_code == 429:
+            wait_s = _parse_retry_after_seconds(r)
+            if logs is not None:
+                _log(
+                    logs,
+                    f"RATE_LIMIT 429 path={path} retry_after={wait_s} "
+                    f"headers={dict(r.headers)} body={r.text[:400]}",
+                )
+            if wait_s is None:
+                raise RuntimeError(f"HTTP 429 without retry instruction: {r.text[:2000]}")
+            time.sleep(max(0.0, wait_s))
+            continue
+
+        if r.status_code >= 500:
+            wait_s = _parse_retry_after_seconds(r)
+            if logs is not None:
+                _log(
+                    logs,
+                    f"SERVER_ERROR {r.status_code} path={path} retry_after={wait_s} "
+                    f"body={r.text[:400]}",
+                )
+            if wait_s is None:
+                raise RuntimeError(f"HTTP {r.status_code}: {r.text[:2000]}")
+            time.sleep(max(0.0, wait_s))
+            continue
+
+        if r.status_code >= 400:
+            raise RuntimeError(f"HTTP {r.status_code}: {r.text[:2000]}")
+
+        if r.text:
+            return r.json()
+        return {}
 
 
 def _log(logs: List[str], msg: str):
@@ -53,13 +117,17 @@ def _log(logs: List[str], msg: str):
 
 def _find_first_valid_pair(logs: List[str]) -> Dict[str, Any]:
     _log(logs, "Listing blueprints")
-    blueprints = _req("GET", "/v1/catalog/blueprints.json")
+    blueprints = _req("GET", "/v1/catalog/blueprints.json", logs=logs)
 
     for bp in blueprints:
         bp_id = str(bp["id"])
         _log(logs, f"Blueprint {bp_id}: fetching providers")
 
-        providers = _req("GET", f"/v1/catalog/blueprints/{bp_id}/print_providers.json")
+        providers = _req(
+            "GET",
+            f"/v1/catalog/blueprints/{bp_id}/print_providers.json",
+            logs=logs,
+        )
         for p in providers:
             p_id = str(p["id"])
             _log(logs, f"Blueprint {bp_id} / Provider {p_id}: fetching variants")
@@ -67,6 +135,7 @@ def _find_first_valid_pair(logs: List[str]) -> Dict[str, Any]:
             vr = _req(
                 "GET",
                 f"/v1/catalog/blueprints/{bp_id}/print_providers/{p_id}/variants.json?show-out-of-stock=1",
+                logs=logs,
             )
             variants = vr.get("variants")
             if isinstance(variants, list) and variants:
@@ -76,17 +145,99 @@ def _find_first_valid_pair(logs: List[str]) -> Dict[str, Any]:
                     "blueprint": bp,
                     "provider": p,
                     "variants": variants,
-                    "blueprintDetails": _req("GET", f"/v1/catalog/blueprints/{bp_id}.json"),
-                    "providerDetails": _req("GET", f"/v1/catalog/print_providers/{p_id}.json"),
+                    "blueprintDetails": _req(
+                        "GET",
+                        f"/v1/catalog/blueprints/{bp_id}.json",
+                        logs=logs,
+                    ),
+                    "providerDetails": _req(
+                        "GET",
+                        f"/v1/catalog/print_providers/{p_id}.json",
+                        logs=logs,
+                    ),
                     "shippingInfo": _req(
                         "GET",
                         f"/v1/catalog/blueprints/{bp_id}/print_providers/{p_id}/shipping.json",
+                        logs=logs,
                     ),
                 }
 
     raise RuntimeError("No blueprint/provider pair with variants found.")
 
 
+def _get_all_provider_blobs_for_blueprint(
+    logs: List[str],
+    blueprint: Dict[str, Any],
+) -> List[Dict[str, Any]]:
+    bp_id = str(blueprint.get("id"))
+    if not bp_id:
+        raise RuntimeError("Blueprint object missing id.")
+
+    _log(logs, f"BLUEPRINT_ALL_PROVIDERS blueprint_id={bp_id}: fetching providers")
+    providers = _req(
+        "GET",
+        f"/v1/catalog/blueprints/{bp_id}/print_providers.json",
+        logs=logs,
+    )
+    if not isinstance(providers, list) or not providers:
+        raise RuntimeError(f"No providers found for blueprint {bp_id}.")
+
+    bp_details = _req(
+        "GET",
+        f"/v1/catalog/blueprints/{bp_id}.json",
+        logs=logs,
+    )
+
+    blobs: List[Dict[str, Any]] = []
+    for p in providers:
+        if not isinstance(p, dict):
+            continue
+        p_id = str(p.get("id"))
+        if not p_id:
+            continue
+
+        _log(logs, f"Blueprint {bp_id} / Provider {p_id}: fetching variants (ALL)")
+        vr = _req(
+            "GET",
+            f"/v1/catalog/blueprints/{bp_id}/print_providers/{p_id}/variants.json?show-out-of-stock=1",
+            logs=logs,
+        )
+        variants = vr.get("variants")
+        count = len(variants) if isinstance(variants, list) else 0
+        _log(
+            logs,
+            f"PROVIDER_VARIANTS blueprint={bp_id} provider={p_id} count={count}",
+        )
+        if not isinstance(variants, list) or not variants:
+            continue
+
+        provider_details = _req(
+            "GET",
+            f"/v1/catalog/print_providers/{p_id}.json",
+            logs=logs,
+        )
+        shipping_info = _req(
+            "GET",
+            f"/v1/catalog/blueprints/{bp_id}/print_providers/{p_id}/shipping.json",
+            logs=logs,
+        )
+
+        blobs.append(
+            {
+                "blueprint": blueprint,
+                "provider": p,
+                "variants": variants,
+                "blueprintDetails": bp_details,
+                "providerDetails": provider_details,
+                "shippingInfo": shipping_info,
+            }
+        )
+
+    if not blobs:
+        raise RuntimeError(f"No providers with variants for blueprint {bp_id}.")
+    return blobs
+
+
 def _build_product(blob: Dict[str, Any], currency: str, logs: List[str]) -> Dict[str, Any]:
     variants = blob["variants"]
 
@@ -232,7 +383,7 @@ def _upload_grid_from_file(logs: List[str]) -> Dict[str, Any]:
     }
 
     _log(logs, f"UPLOADING_GRID path={path} bytes={len(raw)} b64len={len(b64)}")
-    resp = _req("POST", "/v1/uploads/images.json", json_body=payload)
+    resp = _req("POST", "/v1/uploads/images.json", json_body=payload, logs=logs)
 
     if not isinstance(resp, dict) or not resp.get("id"):
         raise RuntimeError(f"Unexpected upload response: {str(resp)[:500]}")
@@ -352,7 +503,10 @@ def _create_product_all_variants_with_grid(
     if not print_areas_payload:
         raise RuntimeError("No placeholders payload generated for any variant.")
 
-    title = product_info.get("name") or "Printify Grid Test"
+    provider_details = blob.get("providerDetails") or {}
+    provider_name = provider_details.get("title") or provider_details.get("name") or str(provider_id)
+
+    title = (product_info.get("name") or "Printify Grid Test") + f" — {provider_name}"
     description = product_info.get("description") or ""
 
     payload = {
@@ -374,6 +528,7 @@ def _create_product_all_variants_with_grid(
         "POST",
         f"/v1/shops/{shop_id}/products.json",
         json_body=payload,
+        logs=logs,
     )
     if not isinstance(created, Dict):
         raise RuntimeError(f"Unexpected create response: {str(created)[:500]}")
@@ -383,7 +538,7 @@ def _create_product_all_variants_with_grid(
 
 
 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")
+    prod = _req("GET", f"/v1/shops/{shop_id}/products/{product_id}.json", logs=logs)
     if not isinstance(prod, dict):
         raise RuntimeError(f"Unexpected product response: {str(prod)[:500]}")
     variants = prod.get("variants") or []
@@ -450,6 +605,7 @@ def _update_prices_to_cost_plus_margin(
         "PUT",
         f"/v1/shops/{shop_id}/products/{product_id}.json",
         json_body={"variants": payload_variants},
+        logs=logs,
     )
     if not isinstance(upd, dict):
         raise RuntimeError(f"Unexpected update response: {str(upd)[:500]}")
@@ -469,7 +625,7 @@ def run(currency: str) -> Generator[Tuple[str, str], None, None]:
         _log(logs, "START")
         yield flush()
 
-        shops = _req("GET", "/v1/shops.json")
+        shops = _req("GET", "/v1/shops.json", logs=logs)
         _log(logs, f"SHOP_LIST {json.dumps(shops)}")
         yield flush()
 
@@ -481,8 +637,6 @@ def run(currency: str) -> Generator[Tuple[str, str], None, None]:
         yield flush()
 
         blob = _find_first_valid_pair(logs)
-        yield flush()
-
         result = _build_product(blob, currency or "USD", logs)
         _log(logs, "DONE")
         yield flush()
@@ -504,7 +658,7 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
         _log(logs, "PHASE_B_START")
         yield flush()
 
-        shops = _req("GET", "/v1/shops.json")
+        shops = _req("GET", "/v1/shops.json", logs=logs)
         _log(logs, f"SHOP_LIST {json.dumps(shops)}")
         yield flush()
 
@@ -512,48 +666,90 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
         _log(logs, f"SHOP_ID {shop_id}")
         yield flush()
 
-        blob = _find_first_valid_pair(logs)
+        first_blob = _find_first_valid_pair(logs)
+        bp_obj = first_blob.get("blueprint") or {}
+        bp_id = bp_obj.get("id")
+        if bp_id is None:
+            raise RuntimeError("First valid blob missing blueprint id.")
+        _log(logs, f"PHASE_B_BLUEPRINT {bp_id}")
+        result["phaseBBlueprintId"] = bp_id
         yield flush()
 
-        product_info = _build_product(blob, currency or "USD", logs)
-        result["phaseAProduct"] = product_info
-        _log_catalog_variants(logs, product_info, limit=75)
+        provider_blobs = _get_all_provider_blobs_for_blueprint(logs, bp_obj)
+        result["providerCount"] = len(provider_blobs)
+        _log(logs, f"PHASE_B_PROVIDER_COUNT {len(provider_blobs)}")
         yield flush()
 
         upload = _upload_grid_from_file(logs)
         result["gridUpload"] = upload
         yield flush()
 
-        created = _create_product_all_variants_with_grid(
-            logs,
-            shop_id=shop_id,
-            blob=blob,
-            product_info=product_info,
-            upload=upload,
-        )
-        result["createdProduct"] = created
-        yield flush()
+        provider_runs: List[Dict[str, Any]] = []
+        currency_code = currency or "USD"
+
+        for idx, blob in enumerate(provider_blobs):
+            provider_details = blob.get("providerDetails") or {}
+            provider_meta = blob.get("provider") or {}
+            provider_id = provider_meta.get("id")
+            provider_name = (
+                provider_details.get("title")
+                or provider_details.get("name")
+                or str(provider_id)
+            )
 
-        created_id = str(created.get("id") or "")
-        if not created_id:
-            raise RuntimeError("Created product response missing id.")
+            _log(
+                logs,
+                f"PROVIDER_RUN index={idx} provider_id={provider_id} "
+                f"name={provider_name}",
+            )
+            yield flush()
 
-        prod1 = _get_product(logs, shop_id, created_id)
-        result["createdProductReadback"] = prod1
-        yield flush()
+            product_info = _build_product(blob, currency_code, logs)
+            _log_catalog_variants(logs, product_info, limit=75)
+            yield flush()
 
-        _log(
-            logs,
-            f"COMPARE_COUNTS catalog={len(product_info.get('variants') or [])} shop={len(prod1.get('variants') or [])}",
-        )
-        yield flush()
+            created = _create_product_all_variants_with_grid(
+                logs,
+                shop_id=shop_id,
+                blob=blob,
+                product_info=product_info,
+                upload=upload,
+            )
+            created_id = str(created.get("id") or "")
+            if not created_id:
+                raise RuntimeError("Created product response missing id.")
+            yield flush()
 
-        upd = _update_prices_to_cost_plus_margin(logs, shop_id, created_id, prod1)
-        result["priceUpdateResponse"] = upd
-        yield flush()
+            prod1 = _get_product(logs, shop_id, created_id)
+            yield flush()
+
+            _log(
+                logs,
+                f"COMPARE_COUNTS provider={provider_id} "
+                f"catalog={len(product_info.get('variants') or [])} "
+                f"shop={len(prod1.get('variants') or [])}",
+            )
+            yield flush()
+
+            upd = _update_prices_to_cost_plus_margin(logs, shop_id, created_id, prod1)
+            yield flush()
+
+            prod2 = _get_product(logs, shop_id, created_id)
+            yield flush()
+
+            provider_runs.append(
+                {
+                    "providerId": provider_id,
+                    "providerName": provider_name,
+                    "catalogVariantCount": len(product_info.get("variants") or []),
+                    "shopVariantCountAfterCreate": len(prod1.get("variants") or []),
+                    "shopVariantCountFinal": len(prod2.get("variants") or []),
+                    "productId": created_id,
+                    "priceUpdateResponse": upd,
+                }
+            )
 
-        prod2 = _get_product(logs, shop_id, created_id)
-        result["finalProductReadback"] = prod2
+        result["providerRuns"] = provider_runs
         _log(logs, "PHASE_B_DONE")
         yield flush()
 
@@ -564,7 +760,7 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
 
 
 with gr.Blocks(title="Printify Catalog Probe") as demo:
-    gr.Markdown("Extract and normalize ONE Printify blueprint/provider into a structured JSON object.")
+    gr.Markdown("Extract and normalize ONE Printify blueprint into provider-specific JSON objects and products.")
 
     currency = gr.Textbox(label="Currency", value="USD")
     btn = gr.Button("Run")