Update app.py

app.py

@@ -0,0 +1,172 @@
+import io
+import gradio as gr
+import pandas as pd
+import requests
+from openpyxl import load_workbook
+
+# Use your dataset file. We convert the "blob" URL to the raw "resolve" URL automatically.
+HF_TEMPLATE_URL = "https://huggingface.co/datasets/leadingbridge/ammu/blob/main/AMMU-order-form-template.xlsx"
+TEMPLATE_FILENAME = "AMMU-order-form-template.xlsx"
+
+def _raw_url(url: str) -> str:
+    # Convert blob → resolve to download raw bytes
+    return url.replace("/blob/", "/resolve/")
+
+def _read_input(file_obj):
+    """Read CSV or XLSX to DataFrame with normalized column names."""
+    name = getattr(file_obj, "name", None) or getattr(file_obj, "orig_name", None) or "upload"
+    if name.lower().endswith(".csv"):
+        df = pd.read_csv(file_obj)
+    else:
+        df = pd.read_excel(file_obj)
+    df.columns = [c.strip() for c in df.columns]
+    return df
+
+def _aggregate(df: pd.DataFrame):
+    """Validate required cols and aggregate Quantity by SKU + Product Option Value."""
+    required = ["SKU", "Product Option Value", "Quantity"]
+    missing = [c for c in required if c not in df.columns]
+    if missing:
+        raise ValueError(f"Input file is missing required column(s): {', '.join(missing)}")
+
+    # Ensure numeric quantities
+    df["Quantity"] = pd.to_numeric(df["Quantity"], errors="coerce").fillna(0).astype(int)
+
+    # Group by SKU + Product Option Value
+    grouped = (
+        df.groupby(["SKU", "Product Option Value"], dropna=False)["Quantity"]
+          .sum()
+          .reset_index()
+    )
+    return grouped
+
+def _find_cell(ws, text):
+    """Return (row, col) of the first cell equal to text."""
+    for r in ws.iter_rows(values_only=False):
+        for c in r:
+            if (c.value or "") == text:
+                return c.row, c.column
+    return None, None
+
+def _match_row(ws, opt_val: str):
+    """
+    Match a row using:
+      1) Exact match: Column A == opt_val
+      2) Composite match: Column A == f"{opt_val} - <value in Column B of that row>"
+    Return row index or None.
+    """
+    opt_val = "" if opt_val is None else str(opt_val).strip()
+    max_row = ws.max_row
+    # 1) Exact match on Col A
+    for r in range(1, max_row + 1):
+        colA = ws.cell(row=r, column=1).value
+        if colA is not None and str(colA).strip() == opt_val:
+            return r
+
+    # 2) Composite: "Product Option Value - <Col B>"
+    for r in range(1, max_row + 1):
+        colA = ws.cell(row=r, column=1).value
+        colB = ws.cell(row=r, column=2).value
+        colA = "" if colA is None else str(colA).strip()
+        colB = "" if colB is None else str(colB).strip()
+        if colA == f"{opt_val} - {colB}":
+            return r
+
+    return None
+
+def _choose_quantity_col(ws):
+    """
+    Choose the 'mapping column' to write quantities.
+    Heuristic: If we see a header cell that equals 'Qty' or 'Quantity' in early rows (2 or 3),
+    use that column; otherwise default to column B.
+    """
+    headers = {"qty", "quantity"}
+    for r in (2, 3):
+        for c in range(1, ws.max_column + 1):
+            val = ws.cell(row=r, column=c).value
+            if isinstance(val, str) and val.strip().lower() in headers:
+                return c
+    return 2  # default to column B if nothing explicit is found
+
+def fill_template(input_file):
+    """
+    1) Download template from HF dataset
+    2) Read input (CSV/XLSX)
+    3) Aggregate quantities by SKU + Product Option Value
+    4) Write SKU → 'My SKU' (same row as label, next column)
+    5) Write quantities into the mapping column per matched rows
+    6) Return template bytes under the same filename for download
+    """
+    if input_file is None:
+        return None, "Please upload an input file."
+
+    # Fetch latest template from HF dataset
+    url = _raw_url(HF_TEMPLATE_URL)
+    resp = requests.get(url)
+    resp.raise_for_status()
+    tmpl_bytes = io.BytesIO(resp.content)
+
+    # Load template workbook (preserves formatting)
+    wb = load_workbook(tmpl_bytes)
+    ws = wb.active  # assume first sheet is the order sheet
+
+    # Read & aggregate input
+    df = _read_input(input_file)
+    grouped = _aggregate(df)
+
+    # Decide which SKU to write (if multiple, choose the first)
+    skus = grouped["SKU"].dropna().astype(str).unique().tolist()
+    if not skus:
+        return None, "No SKU found in the input file."
+    chosen_sku = skus[0]
+    note = ""
+    if len(skus) > 1:
+        note = f"Multiple SKUs found {skus}. Using the first: {chosen_sku}."
+
+    # Map SKU → "My SKU" (same row, next column)
+    r, c = _find_cell(ws, "My SKU")
+    if r is not None and c is not None:
+        ws.cell(row=r, column=c + 1, value=str(chosen_sku))
+
+    # Determine mapping column for quantities
+    qty_col = _choose_quantity_col(ws)
+
+    # Filter to chosen SKU and aggregate again by option
+    block = (
+        grouped[grouped["SKU"].astype(str) == str(chosen_sku)]
+          .groupby("Product Option Value", dropna=False)["Quantity"]
+          .sum()
+          .reset_index()
+    )
+
+    # Fill quantities by row match
+    filled = 0
+    for _, rec in block.iterrows():
+        opt_val = rec["Product Option Value"]
+        qty = int(rec["Quantity"])
+        target_row = _match_row(ws, opt_val)
+        if target_row:
+            ws.cell(row=target_row, column=qty_col, value=qty)
+            filled += 1
+
+    # Save back into memory (keeping same filename)
+    out_buf = io.BytesIO()
+    wb.save(out_buf)
+    out_buf.seek(0)
+
+    status = f"Filled {filled} row(s). " + (note if note else "")
+    # Return a tuple (name, bytes-like) so Gradio downloads with the same template filename
+    return (TEMPLATE_FILENAME, out_buf), status
+
+with gr.Blocks(title="AMMU Order Filler (Template Preserved)") as demo:
+    gr.Markdown("## AMMU Order Filler\nUpload your input file; we’ll fill your live AMMU template and return it unchanged in format.")
+
+    file_in = gr.File(label="Upload Input File (CSV or XLSX)", file_count="single", type="binary")
+    run_btn = gr.Button("Fill Template")
+    download = gr.File(label="Download Filled Template")
+    msg = gr.Markdown()
+
+    run_btn.click(fn=fill_template, inputs=file_in, outputs=[download, msg])
+
+if __name__ == "__main__":
+    demo.launch()