Update app.py

app.py

@@ -1,6 +1,7 @@
 import gradio as gr
 from openpyxl import load_workbook
 from openpyxl.worksheet.worksheet import Worksheet
+from openpyxl.utils import get_column_letter
 from huggingface_hub import hf_hub_download
 import tempfile
 import os, re
@@ -77,12 +78,10 @@ def process(input_file):
         col_pov = header_map["product option value"]
         col_qty = header_map["quantity"]
 
-        # 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}
+        entries = []
         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)]
@@ -95,7 +94,6 @@ 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:
@@ -111,15 +109,11 @@ def process(input_file):
                 "row_values": row_values
             })
 
-        # --- OUTPUT: load template ---
+        # --- OUTPUT template ---
         template_path = _download_template()
         wb_out = load_workbook(template_path)
         ws_out = wb_out.active
 
-        # Find:
-        # (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
@@ -129,14 +123,10 @@ def process(input_file):
 
         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":
                     mysku_header_row = r
                     mysku_col_idx = c
-
-            # (B) textual power labels
             labels = {}
             for c, v in enumerate(row_vals, start=1):
                 if isinstance(v, str):
@@ -146,8 +136,6 @@ 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
             trip = {}
             for c, v in enumerate(row_vals, start=1):
                 if isinstance(v, str) and re.fullmatch(r"\d{2,3}", v.strip()):
@@ -157,11 +145,10 @@ def process(input_file):
                 triplet_col_map = trip
 
         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).")
+            raise ValueError("Could not find the 'MY SKU' header in the template.")
         if not (power_label_row or triplet_row):
-            raise ValueError("Could not find power-column headers in the template (looked in rows 1–10).")
+            raise ValueError("Could not find power-column headers in the template.")
 
-        # Build SKU -> row map using the "MY SKU" column
         sku_to_row = {}
         for r in range(mysku_header_row + 1, ws_out.max_row + 1):
             val = ws_out.cell(row=r, column=mysku_col_idx).value
@@ -169,63 +156,37 @@ def process(input_file):
                 continue
             sku_to_row[str(val).strip()] = r
 
-        # 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
-            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":
-                    summary_cell = (r, c + 1)
-                    break
-            if summary_cell:
-                break
-
-        # 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)
+        agg = defaultdict(int)
+        unmatched_rows = []
 
         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()
-
         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:
@@ -238,39 +199,30 @@ 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 ---
+        # --- Create the "additional order" tab ---
         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)
+            wb_out.remove(wb_out[sheet_name])
         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
+        # Write unmatched rows
         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
 
+        # --- Auto adjust column widths ---
+        for c in range(1, in_max_col + 1):
+            max_len = 0
+            col_letter = get_column_letter(c)
+            for r in range(1, len(unmatched_rows) + 2):  # +1 header
+                val = ws_extra.cell(row=r, column=c).value
+                if val is not None:
+                    max_len = max(max_len, len(str(val)))
+            ws_extra.column_dimensions[col_letter].width = max_len + 2  # padding
+
         # Save output
         tmpdir = tempfile.mkdtemp()
         out_path = os.path.join(tmpdir, "AMMU-order-form-FILLED.xlsx")
@@ -282,12 +234,7 @@ def process(input_file):
             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 missing during aggregate write ({len(missing_skus)}): {', '.join(sorted(missing_skus))}")
-        if 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
 
     except Exception as e:
@@ -299,7 +246,7 @@ with gr.Blocks(title="AMMU Order Form Filler") as demo:
         "• 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"
+        "• Copies **unmatched lines** to new sheet **`additional order`**, with auto column width"
     )
     with gr.Row():
         in_file = gr.File(label="Upload input Excel (.xlsx)", file_types=[".xlsx"])