Update app.py

app.py

@@ -8,23 +8,16 @@ from collections import defaultdict
 
 HF_DATASET_REPO = "leadingbridge/ammu"
 TEMPLATE_FILENAME = "AMMU-order-form-template.xlsx"
-# If you commit the template file into the Space repo, this local fallback will be used.
 LOCAL_TEMPLATE_FALLBACK = os.path.join(os.path.dirname(__file__), TEMPLATE_FILENAME)
 
 def _normalize_power(val):
-    """
-    Normalize input "Product Option Value" to match template's row-2 labels, e.g. '0.00', '-1.25'
-    Accepts numbers or strings such as 'PLANO', '0', '-1', '-1.0', '-1.00'.
-    """
     if val is None:
         return None
     s = str(val).strip()
     if s == "":
         return None
-    # Common synonyms for zero power
     if s.lower() in {"plano", "piano", "0", "0.0", "0.00", "000"}:
         return "0.00"
-    # Extract a signed/decimal number if present
     m = re.search(r"(-?\d+(?:\.\d+)?)", s.replace(",", ""))
     if not m:
         return None
@@ -35,11 +28,9 @@ def _normalize_power(val):
     return f"{num:.2f}"
 
 def _power_to_triplet_digits(power_str: str) -> str:
-    """'-1.25' -> '125', '0.00' -> '000', '-4.00' -> '400'"""
     if power_str is None:
         return None
-    s = power_str.strip().lstrip("+")
-    s = s.replace("-", "")
+    s = power_str.strip().lstrip("+").replace("-", "")
     if "." in s:
         whole, frac = s.split(".", 1)
         frac = (frac + "00")[:2]
@@ -49,10 +40,6 @@ def _power_to_triplet_digits(power_str: str) -> str:
     return digits.zfill(3)
 
 def _find_header_row(ws: Worksheet, required_headers):
-    """
-    Scan the top 10 rows to find a header row that includes all required headers (case-insensitive).
-    Returns (row_index, {header_lower: col_index})
-    """
     req = {h.lower() for h in required_headers}
     for r in range(1, 11):
         header_map = {}
@@ -69,36 +56,29 @@ def _find_header_row(ws: Worksheet, required_headers):
     raise ValueError(f"Could not locate a header row containing: {required_headers}")
 
 def _download_template():
-    # Prefer local copy if present (commit AMMU-order-form-template.xlsx to your Space repo for offline reliability).
     if os.path.exists(LOCAL_TEMPLATE_FALLBACK):
         return LOCAL_TEMPLATE_FALLBACK
-    # Otherwise download from the HF dataset (as you provided).
-    return hf_hub_download(repo_id=HF_DATASET_REPO, filename=TEMPLATE_FILENAME, repo_type="dataset")
+    return hf_hub_download(
+        repo_id=HF_DATASET_REPO, filename=TEMPLATE_FILENAME, repo_type="dataset"
+    )
 
 def process(input_file):
-    """
-    1) Read the uploaded input Excel.
-    2) Aggregate quantities by (SKU, Product Option Value).
-    3) Load the AMMU order form template.
-    4) For each (SKU, power), write quantity into the matching row (by SKU) and column:
-         - Prefer the row-2 labels like '0.00', '-1.00'
-         - Fallback to the row with numeric triplets '000', '125', etc.
-    5) Return a filled Excel file for download + a short log.
-    """
     try:
         if input_file is None:
             return None, "Please upload an Excel file first."
 
-        # --- Read input & detect headers by name (not index) ---
+        # --- INPUT: detect headers by name ---
         wb_in = load_workbook(input_file.name, data_only=True)
         ws_in = wb_in.active
-        header_row_idx, header_map = _find_header_row(ws_in, {"SKU", "Product Option Value", "Quantity"})
+        header_row_idx, header_map = _find_header_row(
+            ws_in, {"SKU", "Product Option Value", "Quantity"}
+        )
         col_sku = header_map["sku"]
         col_pov = header_map["product option value"]
         col_qty = header_map["quantity"]
 
-        # --- Aggregate quantities across duplicate lines (same SKU + same power) ---
-        agg = defaultdict(int)  # (sku, power_str) -> qty sum
+        # --- Aggregate quantities by (SKU, power) ---
+        agg = defaultdict(int)
         rows_scanned = 0
         for r in range(header_row_idx + 1, ws_in.max_row + 1):
             sku = ws_in.cell(row=r, column=col_sku).value
@@ -121,30 +101,34 @@ def process(input_file):
             if sku and power is not None and q:
                 agg[(str(sku).strip(), power)] += q
 
-        # --- Load template ---
+        # --- OUTPUT: load template ---
         template_path = _download_template()
         wb_out = load_workbook(template_path)
         ws_out = wb_out.active
 
         # Find:
-        # a) header row containing "SKU"
-        # b) row containing textual power labels ('0.00', '-1.00', ...)
-        # c) (optional) row containing numeric triplets ('000', '125', ...)
-        sku_header_row = None
-        sku_col_idx = None
+        # (A) "MY SKU" column to build SKU->row map (instead of "SKU")
+        # (B) power label row (text like 0.00, -1.25)
+        # (C) triplet label row (000, 125, 400) as fallback
+        mysku_header_row = None
+        mysku_col_idx = None
         power_label_row = None
         power_col_map = {}
         triplet_row = None
         triplet_col_map = {}
 
+        # First pass over top 10 rows to find labels
         for r in range(1, 11):
             row_vals = [ws_out.cell(row=r, column=c).value for c in range(1, ws_out.max_column + 1)]
-            # (a) 'SKU' header
+
+            # (A) "MY SKU" detection
             for c, v in enumerate(row_vals, start=1):
-                if isinstance(v, str) and v.strip().lower() == "sku":
-                    sku_header_row = r
-                    sku_col_idx = c
-            # (b) textual labels
+                if isinstance(v, str) and v.strip().lower() == "my sku":
+                    # Treat this as the table header for the SKU column
+                    mysku_header_row = r
+                    mysku_col_idx = c
+
+            # (B) textual power labels (prefer)
             labels = {}
             for c, v in enumerate(row_vals, start=1):
                 if isinstance(v, str):
@@ -154,7 +138,8 @@ def process(input_file):
             if len(labels) >= 5 and power_label_row is None:
                 power_label_row = r
                 power_col_map = labels
-            # (c) numeric triplets
+
+            # (C) numeric triplets (fallback)
             trip = {}
             for c, v in enumerate(row_vals, start=1):
                 if isinstance(v, str) and re.fullmatch(r"\d{2,3}", v.strip()):
@@ -163,34 +148,38 @@ def process(input_file):
                 triplet_row = r
                 triplet_col_map = trip
 
-        if sku_header_row is None or sku_col_idx is None:
-            raise ValueError("Could not find the 'SKU' header row in the template (looked in rows 1–10).")
+        if mysku_header_row is None or mysku_col_idx is None:
+            raise ValueError("Could not find the 'MY SKU' header in the template (looked in rows 1–10).")
         if not (power_label_row or triplet_row):
-            raise ValueError("Could not find the power-column headers in the template (looked in rows 1–10).")
+            raise ValueError("Could not find power-column headers in the template (looked in rows 1–10).")
 
-        # Build SKU -> row map from the template
+        # Build SKU -> row map using the "MY SKU" column
         sku_to_row = {}
-        for r in range(sku_header_row + 1, ws_out.max_row + 1):
-            val = ws_out.cell(row=r, column=sku_col_idx).value
+        for r in range(mysku_header_row + 1, ws_out.max_row + 1):
+            val = ws_out.cell(row=r, column=mysku_col_idx).value
             if val is None:
                 continue
             sku_to_row[str(val).strip()] = r
 
-        # Optional: write unique SKUs next to a "My SKU" label if it exists in the top area
-        mysku_cell = None
+        # Optional top-area "MY SKU" label for summary list:
+        # If there is ANOTHER "MY SKU" label in the top area (different from the table header row),
+        # write unique SKUs to the cell to its right.
+        summary_cell = None
         for r in range(1, 11):
+            if r == mysku_header_row:
+                continue  # skip the table header "MY SKU"
             for c in range(1, ws_out.max_column + 1):
                 v = ws_out.cell(row=r, column=c).value
                 if isinstance(v, str) and v.strip().lower() == "my sku":
-                    mysku_cell = (r, c + 1)
+                    summary_cell = (r, c + 1)
                     break
-            if mysku_cell:
+            if summary_cell:
                 break
-        if mysku_cell and agg:
+        if summary_cell and agg:
             unique_skus = sorted({k[0] for k in agg.keys()})
-            ws_out.cell(row=mysku_cell[0], column=mysku_cell[1]).value = ", ".join(unique_skus)
+            ws_out.cell(row=summary_cell[0], column=summary_cell[1]).value = ", ".join(unique_skus)
 
-        # Write aggregated quantities into the correct cells
+        # Write aggregated quantities
         missing_skus = set()
         missing_powers = set()
         written_count = 0
@@ -201,12 +190,9 @@ def process(input_file):
                 missing_skus.add(sku)
                 continue
 
-            # Prefer textual power labels row (e.g. '0.00', '-1.25')
             col_idx = power_col_map.get(power) if power_col_map else None
-
-            # Fallback to numeric triplets (e.g. '000', '125')
             if col_idx is None and triplet_col_map:
-                key = _power_to_triplet_digits(power)  # e.g. '-1.25' -> '125'
+                key = _power_to_triplet_digits(power)
                 col_idx = triplet_col_map.get(key)
 
             if col_idx is None:
@@ -224,20 +210,21 @@ def process(input_file):
             ws_out.cell(row=row_idx, column=col_idx).value = current_val + int(qty)
             written_count += 1
 
-        # Save to a temp file and return
+        # Save output
         tmpdir = tempfile.mkdtemp()
         out_path = os.path.join(tmpdir, "AMMU-order-form-FILLED.xlsx")
         wb_out.save(out_path)
 
-        log_lines = []
-        log_lines.append(f"Rows scanned in input: {rows_scanned}")
-        log_lines.append(f"Unique (SKU, power) pairs aggregated: {len(agg)}")
-        log_lines.append(f"Entries written into template: {written_count}")
+        log_lines = [
+            f"Rows scanned in input: {rows_scanned}",
+            f"Unique (SKU, power) pairs aggregated: {len(agg)}",
+            f"Entries written into template: {written_count}",
+        ]
         if missing_skus:
             log_lines.append(f"⚠️ SKUs not found in template ({len(missing_skus)}): {', '.join(sorted(missing_skus))}")
         if missing_powers:
             log_lines.append(f"⚠️ Powers not found in template ({len(missing_powers)}): {', '.join(sorted(missing_powers))}")
-        log = "\n".join(log_lines) if log_lines else "Done."
+        log = "\n".join(log_lines)
 
         return out_path, log
 
@@ -245,7 +232,7 @@ def process(input_file):
         return None, f"Error: {e}"
 
 with gr.Blocks(title="AMMU Order Form Filler") as demo:
-    gr.Markdown("### AMMU Order Form Filler\nUpload your input Excel. The app will fill quantities into the official AMMU template based on SKU and power.")
+    gr.Markdown("### AMMU Order Form Filler\nUpload your input Excel. The app fills quantities into the AMMU template using **MY SKU** for row mapping and power columns for quantities.")
     with gr.Row():
         in_file = gr.File(label="Upload input Excel (.xlsx)", file_types=[".xlsx"])
     with gr.Row():