Update app.py

app.py

@@ -77,10 +77,15 @@ def process(input_file):
         col_pov = header_map["product option value"]
         col_qty = header_map["quantity"]
 
-        # --- Aggregate quantities by (SKU, power) ---
-        agg = defaultdict(int)
+        # Capture the entire header row & all row values so unmatched lines can be copied verbatim
+        in_max_col = ws_in.max_column
+        header_values = [ws_in.cell(row=header_row_idx, column=c).value for c in range(1, in_max_col + 1)]
+
+        # Pre-collect all entries (we'll decide matched vs unmatched after loading the template)
+        entries = []  # list of dicts: {sku, power_norm, qty, row_values}
         rows_scanned = 0
         for r in range(header_row_idx + 1, ws_in.max_row + 1):
+            row_values = [ws_in.cell(row=r, column=c).value for c in range(1, in_max_col + 1)]
             sku = ws_in.cell(row=r, column=col_sku).value
             pov = ws_in.cell(row=r, column=col_pov).value
             qty = ws_in.cell(row=r, column=col_qty).value
@@ -90,6 +95,7 @@ def process(input_file):
             rows_scanned += 1
 
             power = _normalize_power(pov)
+            # robust int conversion
             try:
                 q = int(qty) if qty is not None and str(qty).strip() != "" else 0
             except Exception:
@@ -98,8 +104,12 @@ def process(input_file):
                 except Exception:
                     q = 0
 
-            if sku and power is not None and q:
-                agg[(str(sku).strip(), power)] += q
+            entries.append({
+                "sku": (str(sku).strip() if sku is not None else None),
+                "power": power,
+                "qty": q,
+                "row_values": row_values
+            })
 
         # --- OUTPUT: load template ---
         template_path = _download_template()
@@ -117,18 +127,16 @@ def process(input_file):
         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) "MY SKU" detection
             for c, v in enumerate(row_vals, start=1):
                 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)
+            # (B) textual power labels
             labels = {}
             for c, v in enumerate(row_vals, start=1):
                 if isinstance(v, str):
@@ -139,7 +147,7 @@ def process(input_file):
                 power_label_row = r
                 power_col_map = labels
 
-            # (C) numeric triplets (fallback)
+            # (C) numeric triplets
             trip = {}
             for c, v in enumerate(row_vals, start=1):
                 if isinstance(v, str) and re.fullmatch(r"\d{2,3}", v.strip()):
@@ -161,13 +169,11 @@ def process(input_file):
                 continue
             sku_to_row[str(val).strip()] = r
 
-        # 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.
+        # Optional top-area "MY SKU" summary (distinct from the table header row)
         summary_cell = None
         for r in range(1, 11):
             if r == mysku_header_row:
-                continue  # skip the table header "MY SKU"
+                continue
             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":
@@ -175,30 +181,52 @@ def process(input_file):
                     break
             if summary_cell:
                 break
-        if summary_cell and agg:
-            unique_skus = sorted({k[0] for k in agg.keys()})
-            ws_out.cell(row=summary_cell[0], column=summary_cell[1]).value = ", ".join(unique_skus)
 
-        # Write aggregated quantities
+        # Classify entries: matched vs unmatched (line-by-line), and aggregate matched ones
+        agg = defaultdict(int)  # (sku, power) -> summed qty
+        unmatched_rows = []     # list of row_values (verbatim from input)
+
+        for rec in entries:
+            sku, power, qty = rec["sku"], rec["power"], rec["qty"]
+            # Invalid minimal fields => treat as unmatched copy-through
+            if not sku or qty <= 0 or power is None:
+                unmatched_rows.append(rec["row_values"])
+                continue
+
+            row_idx = sku_to_row.get(sku)
+            if row_idx is None:
+                unmatched_rows.append(rec["row_values"])
+                continue
+
+            col_idx = power_col_map.get(power) if power_col_map else None
+            if col_idx is None and triplet_col_map:
+                key = _power_to_triplet_digits(power)
+                col_idx = triplet_col_map.get(key)
+
+            if col_idx is None:
+                unmatched_rows.append(rec["row_values"])
+                continue
+
+            # It's a match — add to aggregation
+            agg[(sku, power)] += qty
+
+        # Write aggregated matches to the template grid
+        written_count = 0
         missing_skus = set()
         missing_powers = set()
-        written_count = 0
 
         for (sku, power), qty in agg.items():
             row_idx = sku_to_row.get(sku)
             if row_idx is None:
                 missing_skus.add(sku)
                 continue
-
             col_idx = power_col_map.get(power) if power_col_map else None
             if col_idx is None and triplet_col_map:
                 key = _power_to_triplet_digits(power)
                 col_idx = triplet_col_map.get(key)
-
             if col_idx is None:
                 missing_powers.add(power)
                 continue
-
             current = ws_out.cell(row=row_idx, column=col_idx).value
             try:
                 current_val = int(current) if current is not None and str(current).strip() != "" else 0
@@ -210,6 +238,39 @@ def process(input_file):
             ws_out.cell(row=row_idx, column=col_idx).value = current_val + int(qty)
             written_count += 1
 
+        # Fill the optional top-area summary of unique SKUs
+        if summary_cell and (agg or unmatched_rows):
+            unique_skus = sorted({sku for (sku, _) in agg.keys()})
+            # Also include SKUs from unmatched rows where available
+            try:
+                # Find the index of "SKU" in the input header to extract from unmatched rows
+                sku_header_idx = next((i for i, v in enumerate(header_values) if isinstance(v, str) and v.strip().lower() == "sku"), None)
+                if sku_header_idx is not None:
+                    for rv in unmatched_rows:
+                        if sku_header_idx < len(rv) and rv[sku_header_idx]:
+                            unique_skus.append(str(rv[sku_header_idx]).strip())
+            except Exception:
+                pass
+            if unique_skus:
+                ws_out.cell(row=summary_cell[0], column=summary_cell[1]).value = ", ".join(sorted(set(unique_skus)))
+
+        # --- Create/replace the "additional order" sheet with unmatched rows copied verbatim ---
+        sheet_name = "additional order"
+        if sheet_name in wb_out.sheetnames:
+            # remove and recreate to avoid remnants
+            ws_old = wb_out[sheet_name]
+            wb_out.remove(ws_old)
+        ws_extra = wb_out.create_sheet(title=sheet_name)
+
+        # Write header
+        for c, val in enumerate(header_values, start=1):
+            ws_extra.cell(row=1, column=c).value = val
+
+        # Write unmatched lines
+        for i, row_vals in enumerate(unmatched_rows, start=2):
+            for c, val in enumerate(row_vals, start=1):
+                ws_extra.cell(row=i, column=c).value = val
+
         # Save output
         tmpdir = tempfile.mkdtemp()
         out_path = os.path.join(tmpdir, "AMMU-order-form-FILLED.xlsx")
@@ -217,13 +278,14 @@ def process(input_file):
 
         log_lines = [
             f"Rows scanned in input: {rows_scanned}",
-            f"Unique (SKU, power) pairs aggregated: {len(agg)}",
+            f"Unique matched (SKU, power) pairs aggregated: {len(agg)}",
             f"Entries written into template: {written_count}",
+            f"Unmatched rows copied to '{sheet_name}': {len(unmatched_rows)}",
         ]
         if missing_skus:
-            log_lines.append(f"⚠️ SKUs not found in template ({len(missing_skus)}): {', '.join(sorted(missing_skus))}")
+            log_lines.append(f"⚠️ SKUs missing during aggregate write ({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_lines.append(f"⚠️ Powers missing during aggregate write ({len(missing_powers)}): {', '.join(sorted(missing_powers))}")
         log = "\n".join(log_lines)
 
         return out_path, log
@@ -232,14 +294,20 @@ 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 fills quantities into the AMMU template using **MY SKU** for row mapping and power columns for quantities.")
+    gr.Markdown(
+        "### AMMU Order Form Filler\n"
+        "• Uses **MY SKU** column to map rows\n"
+        "• Matches power columns (text like `-1.25` or fallback triplets like `125`)\n"
+        "• Aggregates quantities for matched lines\n"
+        "• Copies **unmatched lines** to a new sheet **`additional order`** with headers"
+    )
     with gr.Row():
         in_file = gr.File(label="Upload input Excel (.xlsx)", file_types=[".xlsx"])
     with gr.Row():
         run_btn = gr.Button("Process")
     with gr.Row():
         out_file = gr.File(label="Download filled template (.xlsx)")
-    log_box = gr.Textbox(label="Log", lines=8)
+    log_box = gr.Textbox(label="Log", lines=10)
 
     run_btn.click(fn=process, inputs=in_file, outputs=[out_file, log_box])