Update app.py

app.py

@@ -1,329 +1,109 @@
-# app.py
 import gradio as gr
-import pandas as pd
 import pytesseract
-import cv2
+from PIL import Image, ImageOps, ImageFilter
+import pandas as pd
 import re
-import tempfile
-import shutil
 import os
-import numpy as np
-from PIL import Image
-from io import BytesIO
-from zipfile import ZipFile
-from openpyxl import load_workbook
-
-# ----------------- CONFIG -----------------
-PRICE_REGEX = re.compile(r"(?:₹|Rs\.?|INR)?\s*([0-9]{1,6}(?:\.[0-9]{1,2})?)(?:\s*/-)?\s*$", flags=re.IGNORECASE)
-CATEGORY_HINTS = ["maggi", "noodles", "pizza", "burger", "rice", "continental", "beverages", "coffee", "tea"]
-DEFAULTS = {
-    "Active": "1",
-    "Priority": "",
-    "Image": "",
-    "Food type": "",
-    "NoOfMains": "1",
-    "OnlineName": "",
-    "AlternateClassification": "",
-    "ItemTaxInclusive": "0",
-    "TaxPct": "",
-    "BrandName": "",
-    "ClassificationCode": "",
-    "HSN Code": ""
-}
-
-def parse_filename(filename: str):
-    base = os.path.splitext(os.path.basename(filename))[0]
-    if "_" in base:
-        left, right = base.split("_", 1)
-        store_name = left.strip()
-        parts = right.strip().split(" ", 1)
-        store_code = parts[0].strip()
-        branch_name = parts[1].strip() if len(parts) > 1 else ""
-    else:
-        m = re.match(r"(.+?)\s*\((.+?)\)", base)
-        if m:
-            store_name = m.group(1).strip()
-            branch_name = m.group(2).strip()
-            store_code = ""
+import zipfile
+import tempfile
+import uuid
+
+# -----------------------------
+# Basic parsing helpers
+# -----------------------------
+PRICE_PATTERN = re.compile(r'(?<!\d)(?:₹\s*|Rs\.?\s*|INR\s*)?\d+(?:\.\d{1,2})?(?!\d)')
+CLEAN_PRICE = re.compile(r'[^0-9.]')
+
+def preprocess_image(img: Image.Image) -> Image.Image:
+    # Convert to grayscale, increase contrast, denoise lightly, sharpen
+    gray = ImageOps.grayscale(img)
+    enhanced = ImageOps.autocontrast(gray)
+    denoised = enhanced.filter(ImageFilter.MedianFilter(size=3))
+    sharpened = denoised.filter(ImageFilter.UnsharpMask(radius=1.5, percent=150, threshold=3))
+    return sharpened
+
+def simple_parse_lines(text: str):
+    """
+    Heuristic parser:
+    - Splits text into lines
+    - Tries to extract Item and Price from each line
+    - Category guessed from headings (lines in ALL CAPS or ending with ':')
+    """
+    rows = []
+    current_category = None
+
+    lines = [l.strip() for l in text.splitlines() if l.strip()]
+    for line in lines:
+        # Category guess
+        if (line.isupper() and len(line.split()) <= 6) or line.endswith(':'):
+            current_category = line.rstrip(':').strip()
+            continue
+
+        # Find price
+        price_match = PRICE_PATTERN.search(line)
+        if price_match:
+            price_text = price_match.group(0)
+            price_value = CLEAN_PRICE.sub('', price_text)
+            # Item is everything before price
+            item = line[:price_match.start()].strip(" -:•\t")
+            # Cleanup item
+            item = re.sub(r'\s{2,}', ' ', item)
+            if item:
+                rows.append({
+                    "Item": item,
+                    "Price": price_value,
+                    "Category": current_category if current_category else ""
+                })
         else:
-            store_name = base
-            store_code = ""
-            branch_name = ""
-    return store_name, store_code, branch_name
+            # If no price, optionally keep as a note; comment out if you prefer dropping
+            pass
 
-def preprocess_image_cv(np_img):
-    gray = cv2.cvtColor(np_img, cv2.COLOR_RGB2GRAY)
-    h, w = gray.shape[:2]
-    if min(h, w) < 1000:
-        scale = max(1.5, 1000.0 / min(h, w))
-        gray = cv2.resize(gray, None, fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
-    th = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-                               cv2.THRESH_BINARY, 41, 11)
-    kernel = np.ones((1, 1), np.uint8)
-    opened = cv2.morphologyEx(th, cv2.MORPH_OPEN, kernel)
-    return opened
+    return rows
 
-def ocr_with_confidence(pil_img):
-    # returns full text and line-level confidences
-    data = pytesseract.image_to_data(pil_img, output_type=pytesseract.Output.DATAFRAME, lang='eng')
-    data = data.dropna(subset=['text'])
-    lines = []
-    if data.empty:
-        return "", []
-    data['line_key'] = data['block_num'].astype(str) + "_" + data['par_num'].astype(str) + "_" + data['line_num'].astype(str)
-    for key, grp in data.groupby('line_key'):
-        text = " ".join(grp['text'].astype(str).tolist()).strip()
-        confs = grp['conf'].astype(float)
-        confs = confs[confs >= 0]
-        avg_conf = float(confs.mean()) if not confs.empty else 0.0
-        lines.append({"line": text, "conf": round(avg_conf, 2)})
-    full_text = "\n".join([l["line"] for l in lines])
-    return full_text, lines
+def process_images_to_zip(files):
+    # Create temp workspace
+    work_dir = tempfile.mkdtemp(prefix="menu_excel_")
+    output_files = []
 
-def split_lines(text: str):
-    cleaned = re.sub(r"[•·●\t]", " ", text)
-    cleaned = re.sub(r"[ ]{2,}", " ", cleaned)
-    lines = [ln.strip() for ln in cleaned.splitlines() if ln.strip()]
-    return lines
+    for idx, file_obj in enumerate(files, start=1):
+        # Load image
+        image = Image.open(file_obj.name).convert("RGB")
+        image = preprocess_image(image)
 
-def looks_like_category(line: str):
-    low = line.lower()
-    if any(k in low for k in CATEGORY_HINTS):
-        return True
-    if not re.search(r"\d", line) and len(line.split()) <= 6:
-        return True
-    return False
+        # OCR
+        text = pytesseract.image_to_string(image, lang="eng")
 
-def parse_menu_lines(lines):
-    rows = []
-    current_parent = ""
-    current_category = ""
-    for ln in lines:
-        if looks_like_category(ln):
-            if ln.isupper() or any(k in ln.lower() for k in CATEGORY_HINTS):
-                current_parent = ln.strip(":- ")
-                continue
-            else:
-                current_category = ln.strip(":- ")
-                continue
-        m = PRICE_REGEX.search(ln)
-        if m:
-            price = m.group(1).strip()
-            name_part = PRICE_REGEX.sub("", ln).strip(" -:.")
-            row = {
-                "Parent Category": current_parent,
-                "Category": current_category,
-                "Name": name_part,
-                "Item Code": "",
-                "Master Item Name": name_part,
-                "EAN Code": "",
-                "Price": price,
-                "Active": DEFAULTS["Active"],
-                "Priority": DEFAULTS["Priority"],
-                "Image": DEFAULTS["Image"],
-                "Food type": DEFAULTS["Food type"],
-                "NoOfMains": DEFAULTS["NoOfMains"],
-                "OnlineName": DEFAULTS["OnlineName"],
-                "AlternateClassification": DEFAULTS["AlternateClassification"],
-                "ItemTaxInclusive": DEFAULTS["ItemTaxInclusive"],
-                "TaxPct": DEFAULTS["TaxPct"],
-                "BrandName": DEFAULTS["BrandName"],
-                "ClassificationCode": DEFAULTS["ClassificationCode"],
-                "HSN Code": DEFAULTS["HSN Code"]
-            }
-            rows.append(row)
+        # Parse
+        rows = simple_parse_lines(text)
+        if not rows:
+            # Fallback: dump raw text if parsing failed
+            df = pd.DataFrame([{"Extracted Text": text}])
         else:
-            if re.search(r"\d", ln):
-                name_part = ln.strip()
-                row = {
-                    "Parent Category": current_parent,
-                    "Category": current_category,
-                    "Name": name_part,
-                    "Item Code": "",
-                    "Master Item Name": name_part,
-                    "EAN Code": "",
-                    "Price": "",
-                    "Active": DEFAULTS["Active"],
-                    "Priority": DEFAULTS["Priority"],
-                    "Image": DEFAULTS["Image"],
-                    "Food type": DEFAULTS["Food type"],
-                    "NoOfMains": DEFAULTS["NoOfMains"],
-                    "OnlineName": DEFAULTS["OnlineName"],
-                    "AlternateClassification": DEFAULTS["AlternateClassification"],
-                    "ItemTaxInclusive": DEFAULTS["ItemTaxInclusive"],
-                    "TaxPct": DEFAULTS["TaxPct"],
-                    "BrandName": DEFAULTS["BrandName"],
-                    "ClassificationCode": DEFAULTS["ClassificationCode"],
-                    "HSN Code": DEFAULTS["HSN Code"]
-                }
-                rows.append(row)
-    return rows
+            df = pd.DataFrame(rows, columns=["Item", "Price", "Category"])
 
-def fill_template(template_path, rows, store_name, store_code, branch_name):
-    wb = load_workbook(template_path)
-    ws = wb.active
-    ws["A1"] = store_name
-    ws["B1"] = store_code
-    ws["C1"] = branch_name
-    start_row = 3
-    r = start_row
-    for item in rows:
-        ws.cell(row=r, column=1, value=item["Parent Category"])
-        ws.cell(row=r, column=2, value=item["Category"])
-        ws.cell(row=r, column=3, value=item["Name"])
-        ws.cell(row=r, column=4, value=item["Item Code"])
-        ws.cell(row=r, column=5, value=item["Master Item Name"])
-        ws.cell(row=r, column=6, value=item["EAN Code"])
-        ws.cell(row=r, column=7, value=item["Price"])
-        ws.cell(row=r, column=8, value=item["Active"])
-        ws.cell(row=r, column=9, value=item["Priority"])
-        ws.cell(row=r, column=10, value=item["Image"])
-        ws.cell(row=r, column=11, value=item["Food type"])
-        ws.cell(row=r, column=12, value=item["NoOfMains"])
-        ws.cell(row=r, column=13, value=item["OnlineName"])
-        ws.cell(row=r, column=14, value=item["AlternateClassification"])
-        ws.cell(row=r, column=15, value=item["ItemTaxInclusive"])
-        ws.cell(row=r, column=16, value=item["TaxPct"])
-        ws.cell(row=r, column=17, value=item["BrandName"])
-        ws.cell(row=r, column=18, value=item["ClassificationCode"])
-        ws.cell(row=r, column=19, value=item["HSN Code"])
-        r += 1
-    out = BytesIO()
-    wb.save(out)
-    out.seek(0)
-    return out
+        # Save Excel
+        excel_name = f"menu_{idx:03d}.xlsx"
+        excel_path = os.path.join(work_dir, excel_name)
+        df.to_excel(excel_path, index=False)
+        output_files.append(excel_path)
 
-# Gradio callbacks and UI
-def parse_uploaded(batch_images, template_file):
-    parsed = {}
-    for img in batch_images:
-        raw = img.read()
-        store_name, store_code, branch_name = parse_filename(img.name)
-        pil = Image.open(BytesIO(raw)).convert("RGB")
-        np_img = np.array(pil)
-        pre = preprocess_image_cv(np_img)
-        pil_pre = Image.fromarray(pre)
-        full_text, lines_conf = ocr_with_confidence(pil_pre)
-        lines = split_lines(full_text)
-        rows = parse_menu_lines(lines)
-        parsed[img.name] = {
-            "store_name": store_name,
-            "store_code": store_code,
-            "branch_name": branch_name,
-            "rows": rows,
-            "raw_text": full_text,
-            "lines_conf": lines_conf
-        }
-    return parsed
+    # Bundle ZIP
+    zip_name = f"menus_output_{uuid.uuid4().hex[:8]}.zip"
+    zip_path = os.path.join(work_dir, zip_name)
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zipf:
+        for path in output_files:
+            zipf.write(path, arcname=os.path.basename(path))
 
-def to_display_df(rows):
-    if not rows:
-        return pd.DataFrame(columns=["Parent Category","Category","Name","Item Code","Master Item Name","EAN Code","Price","Active","Priority","Image","Food type","NoOfMains","OnlineName","AlternateClassification","ItemTaxInclusive","TaxPct","BrandName","ClassificationCode","HSN Code"])
-    return pd.DataFrame(rows)
-
-def save_single(parsed_item, template_file):
-    rows = parsed_item["rows"]
-    if isinstance(rows, pd.DataFrame):
-        rows = rows.to_dict(orient="records")
-    out_buf = fill_template(template_file.name, rows, parsed_item["store_name"], parsed_item["store_code"], parsed_item["branch_name"])
-    return out_buf
-
-def download_all(parsed_state, template_file):
-    tempdir = tempfile.mkdtemp()
-    zip_path = os.path.join(tempdir, "Menu_Results.zip")
-    with ZipFile(zip_path, "w") as zf:
-        for name, item in parsed_state.items():
-            try:
-                out_buf = save_single(item, template_file)
-                out_name = os.path.splitext(os.path.basename(name))[0] + ".xlsx"
-                tmp_path = os.path.join(tempdir, out_name)
-                with open(tmp_path, "wb") as f:
-                    f.write(out_buf.read())
-                zf.write(tmp_path, arcname=out_name)
-            except Exception as e:
-                err_name = os.path.splitext(os.path.basename(name))[0] + "_ERROR.txt"
-                err_path = os.path.join(tempdir, err_name)
-                with open(err_path, "w", encoding="utf-8") as ef:
-                    ef.write(str(e))
-                zf.write(err_path, arcname=err_name)
     return zip_path
 
-# UI layout
-with gr.Blocks() as demo:
-    gr.Markdown("# 🍽️ Menu OCR → Excel (Batch + Validation)\nUpload multiple menu images (named like <StoreName>_<StoreCode> <BranchName>.jpg) and an Excel template. Parse → review/edit each file → download ZIP of filled Excel files.")
-    with gr.Row():
-        img_input = gr.File(label="Upload Menu Images (multiple)", file_count="multiple", file_types=["image"])
-        template_input = gr.File(label="Upload Excel Template (.xlsx)", file_count="single", file_types=[".xlsx"])
-    parse_btn = gr.Button("Parse all images")
-    parsed_state = gr.State({})
-    status = gr.Textbox(label="Status", interactive=False)
+with gr.Blocks(title="Menu to Excel (one file per image)") as demo:
+    gr.Markdown("## Menu to Excel converter\nUpload menu images to get a ZIP containing separate Excel files (one per image).")
     with gr.Row():
-        file_select = gr.Dropdown(choices=[], label="Select parsed image to review")
-        refresh_btn = gr.Button("Refresh list")
-    with gr.Row():
-        raw_text_area = gr.Textbox(label="Raw OCR Text", lines=10)
-        conf_area = gr.Dataframe(headers=["line","confidence"], interactive=False)
-    df_editor = gr.Dataframe(headers=["Parent Category","Category","Name","Item Code","Master Item Name","EAN Code","Price","Active","Priority","Image","Food type","NoOfMains","OnlineName","AlternateClassification","ItemTaxInclusive","TaxPct","BrandName","ClassificationCode","HSN Code"], interactive=True, datatype="str")
-    with gr.Row():
-        save_btn = gr.Button("Save current edits (generate Excel for this file)")
-        save_status = gr.Textbox(label="Save status", interactive=False)
-    download_btn = gr.Button("Download ZIP of all (use after saving/edits)")
-    download_output = gr.File(label="Download ZIP")
-
-    # Callbacks
-    def do_parse(images, template):
-        if images is None or template is None:
-            return {}, "Please upload images and a template", [], ""
-        parsed = parse_uploaded(images, template)
-        choices = list(parsed.keys())
-        return parsed, f"Parsed {len(choices)} images", choices, ""
-
-    parse_btn.click(fn=do_parse, inputs=[img_input, template_input], outputs=[parsed_state, status, file_select, raw_text_area])
-
-    def refresh_choices(parsed):
-        if not parsed:
-            return [], ""
-        return list(parsed.keys()), ""
-
-    refresh_btn.click(fn=refresh_choices, inputs=[parsed_state], outputs=[file_select, status])
-
-    def show_file_details(selected, parsed):
-        if not parsed or not selected:
-            return "", pd.DataFrame(), []
-        item = parsed.get(selected)
-        raw = item.get("raw_text","")
-        lines_conf = item.get("lines_conf",[])
-        df = to_display_df(item.get("rows",[]))
-        df_conf = pd.DataFrame(lines_conf)
-        return raw, df, df_conf
-
-    file_select.change(fn=show_file_details, inputs=[file_select, parsed_state], outputs=[raw_text_area, df_editor, conf_area])
-
-    def save_current(selected, parsed, edited_df, template):
-        if not parsed or not selected:
-            return "Nothing to save"
-        item = parsed.get(selected)
-        if isinstance(edited_df, pd.DataFrame):
-            rows = edited_df.fillna("").to_dict(orient="records")
-        else:
-            rows = edited_df
-        item["rows"] = rows
-        out_buf = fill_template(template.name, rows, item["store_name"], item["store_code"], item["branch_name"])
-        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx")
-        tmp.write(out_buf.read())
-        tmp.close()
-        item["generated_path"] = tmp.name
-        parsed[selected] = item
-        return f"Saved {selected} -> {os.path.basename(tmp.name)}"
-
-    save_btn.click(fn=save_current, inputs=[file_select, parsed_state, df_editor, template_input], outputs=[save_status])
-
-    def do_download(parsed, template):
-        if not parsed:
-            return None
-        zip_path = download_all(parsed, template)
-        return zip_path
+        input_files = gr.File(label="Upload menu images", file_count="multiple", type="file", file_types=[".png", ".jpg", ".jpeg"])
+    run_btn = gr.Button("Process")
+    output_zip = gr.File(label="Download ZIP")
 
-    download_btn.click(fn=do_download, inputs=[parsed_state, template_input], outputs=[download_output])
+    run_btn.click(fn=process_images_to_zip, inputs=[input_files], outputs=[output_zip])
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()