Imprint

app.py

@@ -15,6 +15,8 @@ from PyPDF2 import PdfReader, PdfWriter
 from prompts import QP_MS_TRANSCRIPTION_PROMPT, get_grading_prompt
 from supabase import create_client, Client 
 
+from dotenv import load_dotenv
+load_dotenv()
 # ---------------- CONFIG ---------------- 
 # Multi-API Key Configuration for handling RESOURCE_EXHAUSTED errors
 class GeminiClientManager:
@@ -66,7 +68,9 @@ class GeminiClientManager:
 # Initialize the client manager
 client_manager = GeminiClientManager()
 client = client_manager.get_current_client()  # For backward compatibility
-GRID_ROWS, GRID_COLS = 20, 14
+GRID_ROWS, GRID_COLS = 20, 14  # kept for legacy
+N_LINES      = 40
+RIGHT_MARGIN = 60
 
 # Supabase configuration
 SUPABASE_URL = os.getenv("SUPABASE_URL")
@@ -173,8 +177,6 @@ def process_and_upload_input_files(qp_file_obj, ms_file_obj, ans_file_obj):
     
     return qp_path, ms_path, ans_path, upload_urls, run_timestamp 
 
-
-
 # ---------------- HELPERS ---------------- 
 def parse_md_table(md):
     """Parse a Markdown table into a list of rows."""
@@ -595,7 +597,7 @@ def merge_pdfs(paths, output_path):
         writer.write(f) 
     return output_path 
 
-def gemini_generate_content(prompt_text, file_upload_obj=None, image_obj=None, model_name="gemini-2.5-pro", fallback_model="gemini-2.5-flash", fallback_model_2="gemini-2.5-flash-lite", file_path=None): 
+def gemini_generate_content(prompt_text, file_upload_obj=None, image_obj=None, model_name="gemini-3.1-pro-preview", fallback_model="gemini-2.5-flash", fallback_model_2="gemini-2.5-flash-lite", file_path=None): 
     """ 
     Send prompt_text and optionally an uploaded file (or an image object/list) to the model using NEW SDK.
     Automatically rotates through available API keys on RESOURCE_EXHAUSTED errors.
@@ -841,10 +843,6 @@ def gemini_generate_content(prompt_text, file_upload_obj=None, image_obj=None, m
     # If we exhausted all attempts
     raise Exception(f"❌ All {max_attempts} API key(s) exhausted. Please check your quota or try again later.")
 
-
-
-
-
 # ---------------- PARSERS ---------------- 
 def extract_question_ids_from_qpms(text: str):
     """Extract question IDs from QP+MS transcript."""
@@ -939,8 +937,6 @@ Graph found in:
 
     return prompt
 
-
-
 def extract_graph_questions_from_ms(text: str):
     """Extract graph questions and page numbers from MS transcript."""
     clean_text = text.replace("\u00A0", " ").replace("\t", " ")
@@ -1117,66 +1113,340 @@ def check_and_correct_total_marks(grading_text):
     return corrected_report_text, calculated_total_awarded, calculated_total_possible, total_mismatch 
 
 # ---------------- MAPPING/IMPRINT HELPERS ---------------- 
-def ask_gemini_for_mapping_batch(image_paths, grading_json, expected_ids=None, rows=GRID_ROWS, cols=GRID_COLS):
-    """
-    Send multiple page images together to Gemini for batch mapping processing.
-    """
-    ids_block = "{NA}"
-    if expected_ids:
-        ids_block = "{\n" + "\n".join(expected_ids) + "\n}"
-    
-    prompt = f"""You are an exam marker. Your role is to identify where each question begins on each page.
-The pages are divided into a {rows} x {cols} grid. Each cell has a RUNNING NUMBER label.
-For each question in the grading JSON, return the cell NUMBER where the FIRST STEP of that question begins.
-⚠ IMPORTANT RULES:
-- Do not place marks inside another question's answer area.
-- Prefer placing the marks in a BLANK cell immediately to the RIGHT of the answer step. If no blank cell is available to the right, then place in a blank cell to the LEFT.
-- Never place marks above or below the answer.
-- Each question should have unique cell number
-- If a question serial number is visible in the answer image, you must mandatorily identify the corresponding question using the grading JSON.
-IMPORTANT: For your help i have provided u questions that u can expect in the images:
-{ids_block}
-Return JSON only, like:
-[{{"page": 1, "question": "1(a)", "cell_number": 15}}, ...]
+def ask_gemini_for_single_page(image_path, page_num, grading_json, expected_ids=None, rows=GRID_ROWS, cols=GRID_COLS):
+        ids_block = "{NA}"
+        if expected_ids:
+            ids_block = "{\n" + "\n".join(expected_ids) + "\n}"
+
+        prompt = f"""You are an experienced mathematics examiner marking a student's handwritten answer sheet.
+
+    The image shows ONE PAGE of the answer sheet.
+    The page has been divided into a {rows} x {cols} grid (rows x columns).
+    Each cell is labelled "row,col" in its top-left corner (e.g. "8,3" means row 8, column 3).
+    Rows are numbered 1 (top) to {rows} (bottom).
+    Columns are numbered 1 (left) to {cols} (right).
+
+    YOUR TASK
+    For EVERY mark listed in the grading JSON, find the EXACT cell that contains
+    the specific handwritten step that mark belongs to, then report that cell as (row, col).
+
+    MARK MEANINGS
+    M1 = method mark   -> place beside the line where the METHOD or FORMULA is written
+    A1 = accuracy mark -> place beside the line showing the CORRECT numerical answer
+    A0 = mark NOT awarded -> beside the WRONG or missing answer
+    B1 = independent mark -> beside that specific isolated result
+    R1 = reasoning mark -> beside the conclusion/reasoning sentence
+
+    STRICT RULES
+    1. Read handwriting TOP-TO-BOTTOM, LEFT-TO-RIGHT.
+    2. Match marks IN ORDER through marks_awarded: first mark -> first relevant step, second mark -> second step. Do NOT skip steps.
+    3. Each mark must land on a DIFFERENT cell unless two marks truly refer to the exact same single token.
+    4. The col must point to where the writing actually IS — not the blank page margin.
+    5. Only include marks whose working appears on THIS page (page {page_num}). If a question is not on this page, omit it entirely.
+    6. Return ONLY a raw JSON array — no markdown, no prose, no code fences.
+
+    Page number : {page_num}
+    Expected IDs: {ids_block}
+    Grading JSON:
+    {json.dumps(grading_json, indent=2)}
+
+    OUTPUT FORMAT
+    [
+    {{"page": {page_num}, "question": "1.b.ii", "mark": "M1", "row": 8, "col": 2}},
+    {{"page": {page_num}, "question": "1.b.ii", "mark": "A1", "row": 11, "col": 4}},
+    ...
+    ]
+    If nothing belongs on this page: []"""
+
+        image = Image.open(image_path)
+        print(f"  📡 Page {page_num}: querying Gemini ({rows}x{cols} grid)…")
+
+        raw = None
+        for model in ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-1.5-flash"]:
+            try:
+                resp = client_manager.get_current_client().models.generate_content(
+                    model=model, contents=[prompt, image])
+                raw = resp.text
+                print(f"  ✅ {model} -> {len(raw)} chars")
+                break
+            except Exception as e:
+                print(f"  ⚠️  {model}: {e}")
+
+        if not raw:
+            print(f"  ❌ All models failed for page {page_num}")
+            return []
+
+        try:
+            cleaned = re.sub(r"```(?:json)?\s*", "", raw).strip().rstrip("`").strip()
+            m = re.search(r"\[.*\]", cleaned, re.DOTALL)
+            if not m:
+                print(f"  ❌ No JSON array found. Raw: {raw[:300]}")
+                return []
+            result = json.loads(m.group(0))
+            valid = []
+            for item in result:
+                try:
+                    row = int(item.get("row", 0))
+                    col = int(item.get("col", 0))
+                except (ValueError, TypeError):
+                    continue
+                if not (1 <= row <= rows and 1 <= col <= cols):
+                    print(f"  ⚠️  Out-of-range cell ({row},{col}) for {item.get('question')} {item.get('mark')}, skipping")
+                    continue
+                item["row"]  = row
+                item["col"]  = col
+                item["page"] = int(item.get("page", page_num))
+                valid.append(item)
+            print(f"  ✅ Page {page_num}: {len(valid)} valid placements")
+            return valid
+        except Exception as e:
+            print(f"  ❌ Parse error: {e}. Raw: {raw[:300]}")
+            return []
+
+def imprint_marks_using_mapping(pdf_path, grading_json, output_pdf, expected_ids=None, rows=None, cols=None):
+    MARK_COLOR     = (0, 0, 200)
+    MARK_FONT      = cv2.FONT_HERSHEY_SIMPLEX
+    MARK_FONT_SCALE = 1.4
+    MARK_FONT_THICK = 2
+    LINE_COLOR     = (180, 200, 255)
+
+    def draw_line_overlay(page_pil):
+        img  = page_pil.convert("RGB").copy()
+        w, h = img.size
+        draw = ImageDraw.Draw(img)
+        line_h = h / N_LINES
+        label_px = max(10, int(line_h * 0.55))
+        try:
+            font = ImageFont.truetype("arial.ttf", label_px)
+        except Exception:
+            font = ImageFont.load_default()
+        for i in range(N_LINES):
+            y = int(i * line_h)
+            draw.line([(0, y), (w, y)], fill=LINE_COLOR, width=1)
+            label = str(i + 1)
+            bb = draw.textbbox((0, 0), label, font=font)
+            lw, lh = bb[2] - bb[0], bb[3] - bb[1]
+            tx, ty = w - lw - 4, y + 2
+            draw.rectangle([tx - 2, ty - 1, tx + lw + 2, ty + lh + 1], fill=(255, 255, 240))
+            draw.text((tx, ty), label, fill=(80, 80, 180), font=font)
+        tmp = f"__overlay_{int(time.time()*1000)}.png"
+        img.save(tmp, "PNG")
+        return tmp
+
+    def ask_gemini_lines(overlay_path, page_num):
+        prompt = f"""You are an experienced examiner reviewing a student's handwritten answer sheet.
+
+The image shows ONE PAGE of the answer sheet.
+The page is divided into {N_LINES} horizontal LINES numbered 1 (top) to {N_LINES} (bottom).
+Line numbers are printed on the right edge of the image.
+
+YOUR TASK
+For every mark listed in the grading JSON below, find which LINE number
+(1 to {N_LINES}) contains the handwritten work that earned (or missed) that mark,
+then output that line number.
+
+RULES
+1. Read handwriting top-to-bottom.
+2. Match marks in order: first mark -> first relevant step, second -> second, etc.
+3. Only include marks whose work appears on THIS page (page {page_num}).
+4. Return ONLY a raw JSON array — no markdown, no prose.
+
+Page: {page_num}
 Grading JSON:
-{json.dumps(grading_json, indent=2)}"""
+{json.dumps(grading_json, indent=2)}
 
-    images = [Image.open(p) for p in image_paths]
-    
-    print(f"📡 Sending batch mapping request for {len(image_paths)} pages to Gemini...")
-    
-    try:
-        contents = [prompt] + images
-        response = client.models.generate_content(
-            model="gemini-2.5-flash",
-            contents=contents
-        )
-        raw_text = response.text
-    except:
-        print("⚠️ Trying fallback model for mapping...")
-        contents = [prompt] + images
-        response = client.models.generate_content(
-            model="gemini-2.5-flash-preview-09-2025",
-            contents=contents
-        )
-        raw_text = response.text
-    
-    print("📥 Batch mapping response (chars):", len(raw_text))
-    print("🔎 Gemini raw batch output:")
-    print(raw_text)
-    
-    try:
-        match = re.search(r'(\[.*\])', raw_text, re.DOTALL)
-        if match:
-            mapping = json.loads(match.group(1))
-            print(f"✅ Parsed Gemini batch mapping for {len(image_paths)} pages")
-            return mapping
-        else:
-            print("❌ Failed to find JSON array in response")
+OUTPUT FORMAT:
+[
+  {{"page": {page_num}, "question": "1a", "mark": "M1", "line": 5}},
+  {{"page": {page_num}, "question": "1a", "mark": "A1", "line": 8}},
+  ...
+]
+If nothing from this grading belongs on this page: []"""
+
+        image = Image.open(overlay_path)
+        print(f"  📡 Page {page_num}: querying Gemini ({N_LINES} lines)…")
+        raw = None
+        for model in ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-1.5-flash"]:
+            try:
+                resp = client_manager.get_current_client().models.generate_content(
+                    model=model, contents=[prompt, image])
+                raw = resp.text
+                print(f"  ✅ {model} -> {len(raw)} chars")
+                break
+            except Exception as e:
+                print(f"  ⚠️  {model}: {e}")
+        if not raw:
             return []
-    except Exception as e:
-        print(f"❌ Failed to parse Gemini JSON mapping: {e}")
-        return [] 
+        try:
+            cleaned = re.sub(r"```(?:json)?\s*", "", raw).strip().rstrip("`").strip()
+            m = re.search(r"\[.*\]", cleaned, re.DOTALL)
+            if not m:
+                return []
+            result = json.loads(m.group(0))
+            valid = []
+            for item in result:
+                try:
+                    line = int(item.get("line", 0))
+                except (ValueError, TypeError):
+                    continue
+                if not (1 <= line <= N_LINES):
+                    continue
+                item["line"] = line
+                item["page"] = int(item.get("page", page_num))
+                valid.append(item)
+            print(f"  ✅ Page {page_num}: {len(valid)} valid placements")
+            return valid
+        except Exception as e:
+            print(f"  ❌ Parse error: {e}")
+            return []
+
+    print("📄 Converting answer PDF to images for imprinting...")
+    pages = convert_from_path(pdf_path, dpi=200)
+    overlays, ann_paths = [], []
+
+    print(f"📏 Drawing {N_LINES}-line overlays…")
+    for i, page in enumerate(pages):
+        ov = draw_line_overlay(page)
+        overlays.append(ov)
+        print(f"   Page {i+1} overlay ready")
+
+    print("📡 Querying Gemini for line placements…")
+    all_placements = []
+    for i, ov in enumerate(overlays):
+        pn = i + 1
+        placements = ask_gemini_lines(ov, pn)
+        all_placements.extend(placements)
+        print(f"   Page {pn}: {len(placements)} marks placed")
+
+    """
+    SINGLE-LINE MARKS PATCH (fixed font, dynamic margin) for imprint_marks_using_mapping
+    ======================================================================================
+
+    PROBLEM: Marks wrap onto multiple visual lines.
+
+    FIX:
+    1. Group all marks per line into one string: ["B1","B1","B0"] → "B1  B1  B0"
+    2. Measure that string's pixel width at the FIXED font scale.
+    3. Scan the page to find the rightmost dark pixel per line (actual content edge).
+    4. Calculate required extension = max over all lines of (mark_width + PADDING - free_space).
+    5. If extension > 0, add a single white strip of that width to the right of the page.
+    6. Draw each line's string once, right-aligned — always on a single line, never scaled.
+
+    HOW TO APPLY:
+    Replace the entire block from:
+        print("🖊  Annotating pages…")
+    up to (but NOT including):
+        print("📑 Merging into PDF…")
+    with the code below.
+
+    Add this constant near MARK_COLOR / N_LINES at the top of the function:
+        PADDING = 24    # px gap between rightmost content pixel and marks
+    """
+
+    # ── add near the other constants inside imprint_marks_using_mapping ───────────
+    PADDING = 24   # minimum gap (px) between student content and marks
+
+    # ── annotation ────────────────────────────────────────────────────────────
+    print("🖊  Annotating pages…")
+    for i, page in enumerate(pages):
+        pn     = i + 1
+        img_cv = cv2.cvtColor(np.array(page.convert("RGB")), cv2.COLOR_RGB2BGR)
+        h, w   = img_cv.shape[:2]
+        line_h = h / N_LINES
+
+        page_marks = [m for m in all_placements if m.get("page") == pn]
+
+        if not page_marks:
+            ann = f"annotated_page_{pn}.png"
+            cv2.imwrite(ann, img_cv)
+            ann_paths.append(ann)
+            print(f"   ✅ Page {pn}: no marks, saved unchanged.")
+            continue
+
+        # ── SNAP nearby line numbers together (within ±1) ─────────────────────
+        # Sort marks by line number
+        page_marks.sort(key=lambda m: m.get("line", 1))
+
+        # Group marks: if next mark's line is within 1 of current group's min,
+        # merge it into the same group → one label per visual "band"
+        from collections import defaultdict
+        groups = []   # list of (representative_line, [mark, mark, ...])
+        for item in page_marks:
+            ln   = item.get("line", 1)
+            mark = item.get("mark", "?")
+            # Check if this line fits into the last group (within ±1)
+            if groups and abs(ln - groups[-1][0]) <= 1:
+                groups[-1][1].append(mark)
+            else:
+                groups.append((ln, [mark]))
+
+        # Build one label per group
+        line_labels = {rep_ln: "  ".join(marks) for rep_ln, marks in groups}
+
+        # ── measure rightmost content pixel per line ───────────────────────────
+        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
+        THRESHOLD  = 230
+        PADDING    = 30
+        FONT       = cv2.FONT_HERSHEY_SIMPLEX
+        FONT_SCALE = 1.4
+        FONT_THICK = 2
+        COLOR      = (0, 0, 200)
+
+        def rightmost_content(li_0):
+            y0 = int(li_0 * line_h)
+            y1 = min(h, int((li_0 + 1) * line_h))
+            band = gray[y0:y1, :]
+            cols = np.where(np.any(band < THRESHOLD, axis=0))[0]
+            return int(cols[-1]) if cols.size else 0
+
+        def label_width(text):
+            (tw, _), _ = cv2.getTextSize(text, FONT, FONT_SCALE, FONT_THICK)
+            return tw
+
+        # ── calculate canvas extension ─────────────────────────────────────────
+        max_ext = 0
+        for ln, label in line_labels.items():
+            cx     = rightmost_content(ln - 1)
+            needed = cx + PADDING + label_width(label) + PADDING
+            max_ext = max(max_ext, needed - w)
+
+        if max_ext > 0:
+            strip  = np.full((h, int(max_ext), 3), 255, dtype=np.uint8)
+            img_cv = np.hstack([img_cv, strip])
+            print(f"   📐 Page {pn}: canvas +{int(max_ext)}px")
+
+        new_w = img_cv.shape[1]
+
+        # ── draw ONE label per group, right-aligned ────────────────────────────
+        for ln, label in line_labels.items():
+            li = ln - 1
+            (tw, th), _ = cv2.getTextSize(label, FONT, FONT_SCALE, FONT_THICK)
+            y0     = int(li * line_h)
+            y1     = min(h, int((li + 1) * line_h))
+            text_y = y0 + (y1 - y0) // 2 + th // 2
+            text_x = max(new_w - PADDING - tw,
+                        rightmost_content(li) + PADDING)
+            cv2.putText(img_cv, label, (text_x, text_y),
+                        FONT, FONT_SCALE, COLOR, FONT_THICK, cv2.LINE_AA)
+            print(f"   🖊 [{pn}] line {ln} | \"{label}\" | x={text_x} y={text_y}")
+
+        ann = f"annotated_page_{pn}.png"
+        cv2.imwrite(ann, img_cv)
+        ann_paths.append(ann)
+        print(f"   ✅ Page {pn} saved ({new_w}×{h})")
+
+    # ── saving (outside, unchanged) ────────────────────────────────────────────
+    print("📑 Merging into PDF…")
+    with open(output_pdf, "wb") as f:
+        f.write(img2pdf.convert(ann_paths))
+
+    for p in overlays + ann_paths:
+        if os.path.exists(p):
+            os.remove(p)
+
+    compressed = compress_pdf(output_pdf)
+    print("✅ Imprinted PDF saved to:", compressed)
+    return compressed
 
 def normalize_question_id(qid):
     """
@@ -1197,7 +1467,6 @@ def normalize_question_id(qid):
     
     return qid
 
-def imprint_marks_using_mapping(pdf_path, grading_json, output_pdf, expected_ids=None, rows=GRID_ROWS, cols=GRID_COLS): 
     """ 
     Convert PDF to images, create grid-numbered images for batch sending to Gemini, 
     then annotate and produce imprinted PDF.
@@ -1308,7 +1577,6 @@ def imprint_marks_using_mapping(pdf_path, grading_json, output_pdf, expected_ids
     compressed = compress_pdf(output_pdf) 
     print("📑 Imprinted PDF saved to:", compressed) 
     return compressed 
-
 def extract_pdf_pages_as_images(pdf_path, page_numbers, prefix):
     """
     Extracts unique pages (1-based) from a PDF as images, saves as PNG, returns list of file paths.
@@ -1400,7 +1668,7 @@ def align_and_grade_pipeline(qp_path, ms_path, ans_path, subject="Maths", imprin
 
         print("1.i) Transcribing QP+MS (questions first, then full markscheme, with graph detection)...")
         qpms_prompt = QP_MS_TRANSCRIPTION_PROMPT["content"] + "\nAt the end, also list all questions in the markscheme where a graph is expected, in the format:\nGraph expected in:\n- Question <number> → Page <number>\n(One per line, after ==== MARKSCHEME END ====)"
-        qpms_text = gemini_generate_content(qpms_prompt, file_upload_obj=merged_uploaded, model_name="gemini-2.5-flash", fallback_model="gemini-2.5-flash-preview-09-2025", fallback_model_2="gemini-2.5-flash-lite", file_path=merged_qpms_path)
+        qpms_text = gemini_generate_content(qpms_prompt, file_upload_obj=merged_uploaded, model_name="gemini-2.5-flash", fallback_model="gemini-1.5-flash-8b", fallback_model_2="gemini-2.5-flash-lite", file_path=merged_qpms_path)
         print("📄 QP+MS transcription received. Saving debug file: debug_qpms_transcript.txt")
         with open("debug_qpms_transcript.txt", "w", encoding="utf-8") as f:
             f.write(qpms_text)
@@ -1418,7 +1686,7 @@ def align_and_grade_pipeline(qp_path, ms_path, ans_path, subject="Maths", imprin
 
         print("1.ii) Building AS transcription prompt with expected question IDs and graph detection, sending to Gemini...")
         as_prompt = build_as_cot_prompt_with_expected_ids(extracted_ids, qpms_text) + "\nAt the end, also list all answers where a graph is found, in the format:\nGraph found in:\n- Answer <number> → Page <number>\n(One per line, after all answers)"
-        as_text = gemini_generate_content(as_prompt, file_upload_obj=ans_uploaded, model_name="gemini-2.5-flash", fallback_model="gemini-2.5-flash-preview-09-2025", fallback_model_2="gemini-2.5-flash-lite", file_path=ans_path)
+        as_text = gemini_generate_content(as_prompt, file_upload_obj=ans_uploaded, model_name="gemini-2.5-flash", fallback_model="gemini-1.5-flash-8b", fallback_model_2="gemini-2.5-flash-lite", file_path=ans_path)
         print("📝 AS transcription received. Saving debug file: debug_as_transcript.txt")
         with open("debug_as_transcript.txt", "w", encoding="utf-8") as f:
             f.write(as_text)
@@ -1543,16 +1811,26 @@ with gr.Blocks(title="AI Grading (Pandoc + pdflatex)") as demo:
             else:
                 return error_msg, "", "", None, None
         
-        # Process and upload input files (generates shared timestamp)
-        qp_path, ms_path, ans_path, input_urls, run_timestamp = process_and_upload_input_files(
-            qp_file_obj, ms_file_obj, ans_file_obj
-        )
+        # ✅ Only extract local paths — do NOT upload yet
+        qp_path = qp_file_obj.name
+        ms_path = ms_file_obj.name
+        ans_path = ans_file_obj.name
+        run_timestamp = str(int(time.time()))  # generate timestamp here
 
-        # Run the grading pipeline (pass timestamp to keep all files together)
+        # Run the grading pipeline first
         qpms_text, as_text, grading_text, grading_pdf_path, imprinted_pdf_path, output_urls = align_and_grade_pipeline( 
             qp_path, ms_path, ans_path, subject=subject_choice, imprint=imprint_flag, run_timestamp=run_timestamp
         )
         
+        # ✅ Only upload to Supabase if pipeline succeeded (no error string returned)
+        input_urls = {"qp_url": None, "ms_url": None, "ans_url": None}
+        if supabase_client and isinstance(qpms_text, str) and not qpms_text.startswith("❌"):
+            print("\n📤 Uploading input files to Supabase (pipeline succeeded)...")
+            input_urls["qp_url"] = upload_file_to_supabase(qp_path, "qp", run_timestamp)
+            input_urls["ms_url"] = upload_file_to_supabase(ms_path, "ms", run_timestamp)
+            input_urls["ans_url"] = upload_file_to_supabase(ans_path, "ans", run_timestamp)
+
+        
         # Build URLs summary
         urls_summary = ""
         if supabase_client: