Update app.py

app.py

@@ -1,162 +1,162 @@
-import faicons as fa
-import plotly.express as px
+import os
+import time
+import json
+from typing import Dict, Any, List, Generator, Tuple
 
-# Load data and compute static values
-from shared import app_dir, tips
-from shinywidgets import render_plotly
+import requests
+import gradio as gr
 
-from shiny import reactive, render
-from shiny.express import input, ui
+PRINTIFY_BASE = "https://api.printify.com"
+DEFAULT_BASE_PRICE = 24.99
 
-bill_rng = (min(tips.total_bill), max(tips.total_bill))
 
-# Add page title and sidebar
-ui.page_opts(title="Restaurant tipping", fillable=True)
+def _now() -> str:
+    return time.strftime("%H:%M:%S")
 
-with ui.sidebar(open="desktop"):
-    ui.input_slider(
-        "total_bill",
-        "Bill amount",
-        min=bill_rng[0],
-        max=bill_rng[1],
-        value=bill_rng,
-        pre="$",
-    )
-    ui.input_checkbox_group(
-        "time",
-        "Food service",
-        ["Lunch", "Dinner"],
-        selected=["Lunch", "Dinner"],
-        inline=True,
+
+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}"}
+
+
+def _req(method: str, path: str) -> Any:
+    r = requests.request(
+        method,
+        f"{PRINTIFY_BASE}{path}",
+        headers=_auth_headers(),
+        timeout=60,
     )
-    ui.input_action_button("reset", "Reset filter")
-
-# Add main content
-ICONS = {
-    "user": fa.icon_svg("user", "regular"),
-    "wallet": fa.icon_svg("wallet"),
-    "currency-dollar": fa.icon_svg("dollar-sign"),
-    "ellipsis": fa.icon_svg("ellipsis"),
-}
-
-with ui.layout_columns(fill=False):
-    with ui.value_box(showcase=ICONS["user"]):
-        "Total tippers"
-
-        @render.express
-        def total_tippers():
-            tips_data().shape[0]
-
-    with ui.value_box(showcase=ICONS["wallet"]):
-        "Average tip"
-
-        @render.express
-        def average_tip():
-            d = tips_data()
-            if d.shape[0] > 0:
-                perc = d.tip / d.total_bill
-                f"{perc.mean():.1%}"
-
-    with ui.value_box(showcase=ICONS["currency-dollar"]):
-        "Average bill"
-
-        @render.express
-        def average_bill():
-            d = tips_data()
-            if d.shape[0] > 0:
-                bill = d.total_bill.mean()
-                f"${bill:.2f}"
-
-
-with ui.layout_columns(col_widths=[6, 6, 12]):
-    with ui.card(full_screen=True):
-        ui.card_header("Tips data")
-
-        @render.data_frame
-        def table():
-            return render.DataGrid(tips_data())
-
-    with ui.card(full_screen=True):
-        with ui.card_header(class_="d-flex justify-content-between align-items-center"):
-            "Total bill vs tip"
-            with ui.popover(title="Add a color variable", placement="top"):
-                ICONS["ellipsis"]
-                ui.input_radio_buttons(
-                    "scatter_color",
-                    None,
-                    ["none", "sex", "smoker", "day", "time"],
-                    inline=True,
-                )
-
-        @render_plotly
-        def scatterplot():
-            color = input.scatter_color()
-            return px.scatter(
-                tips_data(),
-                x="total_bill",
-                y="tip",
-                color=None if color == "none" else color,
-                trendline="lowess",
-            )
+    if r.status_code >= 400:
+        raise RuntimeError(f"HTTP {r.status_code}: {r.text[:2000]}")
+    return r.json()
+
+
+def _log(logs: List[str], msg: str):
+    logs.append(f"[{_now()}] {msg}")
 
-    with ui.card(full_screen=True):
-        with ui.card_header(class_="d-flex justify-content-between align-items-center"):
-            "Tip percentages"
-            with ui.popover(title="Add a color variable"):
-                ICONS["ellipsis"]
-                ui.input_radio_buttons(
-                    "tip_perc_y",
-                    "Split by:",
-                    ["sex", "smoker", "day", "time"],
-                    selected="day",
-                    inline=True,
-                )
-
-        @render_plotly
-        def tip_perc():
-            from ridgeplot import ridgeplot
-
-            dat = tips_data()
-            dat["percent"] = dat.tip / dat.total_bill
-            yvar = input.tip_perc_y()
-            uvals = dat[yvar].unique()
-
-            samples = [[dat.percent[dat[yvar] == val]] for val in uvals]
-
-            plt = ridgeplot(
-                samples=samples,
-                labels=uvals,
-                bandwidth=0.01,
-                colorscale="viridis",
-                colormode="row-index",
-            )
 
-            plt.update_layout(
-                legend=dict(
-                    orientation="h", yanchor="bottom", y=1.02, xanchor="center", x=0.5
-                )
+def _find_first_valid_pair(logs: List[str]) -> Dict[str, Any]:
+    _log(logs, "Listing blueprints")
+    blueprints = _req("GET", "/v1/catalog/blueprints.json")
+
+    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")
+        for p in providers:
+            p_id = str(p["id"])
+            _log(logs, f"Blueprint {bp_id} / Provider {p_id}: fetching variants")
+
+            vr = _req(
+                "GET",
+                f"/v1/catalog/blueprints/{bp_id}/print_providers/{p_id}/variants.json?show-out-of-stock=1",
             )
+            variants = vr.get("variants")
+            if isinstance(variants, list) and variants:
+                _log(logs, f"FOUND {len(variants)} variants")
+
+                return {
+                    "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"),
+                    "shippingInfo": _req(
+                        "GET",
+                        f"/v1/catalog/blueprints/{bp_id}/print_providers/{p_id}/shipping.json",
+                    ),
+                }
+
+    raise RuntimeError("No blueprint/provider pair with variants found.")
+
+
+def _build_product(blob: Dict[str, Any], currency: str, logs: List[str]) -> Dict[str, Any]:
+    variants = blob["variants"]
+
+    snapshot = []
+    for v in variants:
+        cents = v.get("price")
+        cents = int(cents) if isinstance(cents, (int, str)) and str(cents).isdigit() else None
+        snapshot.append({
+            "id": v.get("id"),
+            "sku": v.get("sku"),
+            "size": (v.get("options") or {}).get("size"),
+            "color": (v.get("options") or {}).get("color"),
+            "priceCents": cents,
+            "price": round(cents / 100, 2) if cents is not None else None,
+        })
+
+    _log(logs, f"VARIANT_SNAPSHOT sample={json.dumps(snapshot[:20])}")
+
+    all_cents = [v["priceCents"] for v in snapshot if v["priceCents"] is not None]
+    min_price = round(min(all_cents) / 100, 2) if all_cents else DEFAULT_BASE_PRICE
+
+    colors = sorted({v["color"] for v in snapshot if v["color"]})
+    sizes = sorted({v["size"] for v in snapshot if v["size"]})
+
+    provider = blob["providerDetails"]
+    loc = provider.get("location") or {}
+    loc_str = ", ".join(x for x in [loc.get("city"), loc.get("country")] if x) or "empty"
+
+    description = (
+        (blob["blueprintDetails"].get("description") or "empty")
+        + f"\n\nFulfilled by {provider.get('title') or provider.get('name')} — {loc_str}"
+    )
+
+    return {
+        "name": blob["blueprintDetails"].get("title"),
+        "currency": currency,
+        "price": min_price,
+        "tags": ["Printify", f"Provider: {provider.get('title') or provider.get('name')}"],
+        "options": {
+            "Color": colors,
+            "Size": sizes,
+        },
+        "description": description,
+        "variants": snapshot,
+        "raw": blob,
+    }
+
+
+def run(currency: 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, "START")
+        yield flush()
 
-            return plt
+        blob = _find_first_valid_pair(logs)
+        yield flush()
 
+        result = _build_product(blob, currency or "USD", logs)
+        _log(logs, "DONE")
+        yield flush()
 
-ui.include_css(app_dir / "styles.css")
+    except Exception as e:
+        _log(logs, f"ERROR: {e}")
+        result = {"error": str(e)}
+        yield flush()
 
-# --------------------------------------------------------
-# Reactive calculations and effects
-# --------------------------------------------------------
 
+with gr.Blocks(title="Printify Catalog Probe") as demo:
+    gr.Markdown("Extract and normalize ONE Printify blueprint/provider into a structured JSON object.")
 
-@reactive.calc
-def tips_data():
-    bill = input.total_bill()
-    idx1 = tips.total_bill.between(bill[0], bill[1])
-    idx2 = tips.time.isin(input.time())
-    return tips[idx1 & idx2]
+    currency = gr.Textbox(label="Currency", value="USD")
+    btn = gr.Button("Run")
+    logs = gr.Textbox(label="Logs", lines=18)
+    out = gr.Textbox(label="Output JSON", lines=18)
 
+    btn.click(run, inputs=[currency], outputs=[logs, out])
 
-@reactive.effect
-@reactive.event(input.reset)
-def _():
-    ui.update_slider("total_bill", value=bill_rng)
-    ui.update_checkbox_group("time", selected=["Lunch", "Dinner"])
+demo.queue(concurrency_count=1).launch()