Upload app.py with huggingface_hub

app.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+import hashlib
 import json
+import re
 from html import escape
 from pathlib import Path
 
@@ -26,6 +28,7 @@ from src.totem_workbook import (
 from src.codex_extractor import process_upload, format_fingerprint_report
 
 ORIGINAL_WORKBOOK_PATH = "data/order69_macmillan_totem_rebuilt.xlsx"
+CODEX_CATALOGUE_PATH = Path("data/codex_catalogue.xlsx")
 
 
 def _patch_gradio_schema_bool_compat() -> None:
@@ -833,6 +836,164 @@ def dashboard_html(path: Path, notice: str = "") -> str:
 
 # ── CODEX EXTRACTOR FUNCTIONS ─────────────────────────────────────────────────
 
+def _extract_uploaded_path(file_obj) -> str | None:
+    """Handle Gradio file payload variants and return a filesystem path."""
+    if file_obj is None:
+        return None
+    if isinstance(file_obj, str):
+        return file_obj
+    if isinstance(file_obj, dict):
+        return file_obj.get("path") or file_obj.get("name")
+    if hasattr(file_obj, "name"):
+        return file_obj.name
+    return None
+
+
+def _normalise_lookup_key(value: str) -> str:
+    text = str(value or "").lower()
+    text = re.sub(r"[_\-]+", " ", text)
+    text = re.sub(r"[^a-z0-9 ]+", " ", text)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def _generate_codex_author_id(author_name: str) -> str:
+    """
+    Deterministic fallback author ID when missing in catalogue.
+    Format: CA-<3 letters>-<3 digits>
+    """
+    cleaned = re.sub(r"[^A-Za-z]", "", author_name or "").upper()
+    prefix = (cleaned[:3] or "AUT").ljust(3, "X")
+    digest = hashlib.md5((author_name or "").strip().lower().encode("utf-8")).hexdigest()
+    suffix = int(digest[:4], 16) % 1000
+    return f"CA-{prefix}-{suffix:03d}"
+
+
+def _empty_catalogue_df() -> pd.DataFrame:
+    return pd.DataFrame(columns=["authour_id", "author_name", "title"])
+
+
+def _load_codex_catalogue(path: Path = CODEX_CATALOGUE_PATH) -> pd.DataFrame:
+    """
+    Load catalogue workbook with required columns:
+    `authour_id`, `author_name`, `title`
+    """
+    if not path.exists():
+        return _empty_catalogue_df()
+    try:
+        raw = pd.read_excel(path)
+    except Exception:
+        return _empty_catalogue_df()
+    if raw is None or raw.empty:
+        return _empty_catalogue_df()
+
+    col_lookup = {str(col).strip().lower(): col for col in raw.columns}
+    id_col = col_lookup.get("authour_id") or col_lookup.get("author_id")
+    name_col = col_lookup.get("author_name")
+    title_col = col_lookup.get("title")
+
+    if name_col is None or title_col is None:
+        return _empty_catalogue_df()
+
+    if id_col is None:
+        raw["__authour_id"] = ""
+        id_col = "__authour_id"
+
+    cat = raw[[id_col, name_col, title_col]].copy()
+    cat.columns = ["authour_id", "author_name", "title"]
+
+    for col in ["authour_id", "author_name", "title"]:
+        cat[col] = cat[col].fillna("").astype(str).str.strip()
+
+    cat = cat[(cat["author_name"] != "") & (cat["title"] != "")]
+    return cat
+
+
+def _match_catalogue_row(file_path: str, catalogue: pd.DataFrame) -> pd.Series | None:
+    if catalogue.empty:
+        return None
+    stem_key = _normalise_lookup_key(Path(file_path).stem)
+    if not stem_key:
+        return None
+
+    title_keys = catalogue["title"].map(_normalise_lookup_key)
+
+    exact = catalogue[title_keys == stem_key]
+    if not exact.empty:
+        return exact.iloc[0]
+
+    contains = catalogue[
+        title_keys.apply(lambda t: bool(t) and (t in stem_key or stem_key in t))
+    ]
+    if not contains.empty:
+        return contains.assign(_key_len=contains["title"].map(lambda t: len(_normalise_lookup_key(t)))) \
+                       .sort_values("_key_len", ascending=False) \
+                       .iloc[0]
+    return None
+
+
+def autofill_codex_details(
+    file_obj,
+    current_author_name: str,
+    current_author_id: str,
+    current_works: str,
+) -> tuple[str, str, str, str]:
+    """
+    Auto-populate author fields from data/codex_catalogue.xlsx on file upload.
+    Expected columns: authour_id, author_name, title.
+    """
+    file_path = _extract_uploaded_path(file_obj)
+    if not file_path:
+        return (
+            current_author_name,
+            current_author_id or "CA-XXX",
+            current_works,
+            "Ready.",
+        )
+
+    catalogue = _load_codex_catalogue()
+    if catalogue.empty:
+        return (
+            current_author_name,
+            current_author_id or "CA-XXX",
+            current_works,
+            "No catalogue match: add rows to data/codex_catalogue.xlsx with authour_id, author_name, title.",
+        )
+
+    row = _match_catalogue_row(file_path, catalogue)
+    if row is None:
+        return (
+            current_author_name,
+            current_author_id or "CA-XXX",
+            current_works,
+            "No title match found in catalogue for this filename. You can still fill fields manually.",
+        )
+
+    author_name = str(row["author_name"]).strip()
+    author_id = str(row["authour_id"]).strip() or _generate_codex_author_id(author_name)
+
+    by_author = catalogue[
+        catalogue["author_name"].map(_normalise_lookup_key) == _normalise_lookup_key(author_name)
+    ]
+    if author_id:
+        by_id = catalogue[
+            catalogue["authour_id"].fillna("").astype(str).str.strip() == author_id
+        ]
+        if not by_id.empty:
+            by_author = by_id
+
+    works = [w for w in by_author["title"].astype(str).str.strip().tolist() if w]
+    works_sampled = ", ".join(pd.Series(works).drop_duplicates().tolist())
+    if not works_sampled:
+        works_sampled = str(row["title"]).strip()
+
+    return (
+        author_name,
+        author_id,
+        works_sampled,
+        f"Auto-filled from catalogue: {author_name} ({author_id}).",
+    )
+
+
 def run_codex_extraction(
     file_obj,
     author_name: str,
@@ -858,11 +1019,7 @@ def run_codex_extraction(
         )
 
     # Gradio may pass a filepath string or a file-like payload depending on runtime.
-    file_path = file_obj
-    if isinstance(file_obj, dict):
-        file_path = file_obj.get("path") or file_obj.get("name")
-    elif hasattr(file_obj, "name"):
-        file_path = file_obj.name
+    file_path = _extract_uploaded_path(file_obj)
 
     if not file_path:
         return (
@@ -1073,7 +1230,7 @@ with gr.Blocks(title="TOTEM Studio", css=CSS) as demo:
                         color: #5d4037;
                     ">
                         <b>File requirements:</b><br>
-                        • PDF must contain selectable text (not scanned images)<br>
+                        • Selectable text preferred; scanned PDFs are OCR-processed automatically<br>
                         • Minimum 1,000 words for HIGH confidence fingerprint<br>
                         • Combine multiple works in one file to increase sample size<br>
                         • Visual-primary books (Van Allsburg, Jeffers) will flag LOW confidence
@@ -1145,13 +1302,13 @@ with gr.Blocks(title="TOTEM Studio", css=CSS) as demo:
         queue=False,
         trigger_mode="multiple",
     )
-    # Fallback trigger: run extraction immediately after file upload as well.
+    # Auto-fill author metadata from catalogue on file upload.
     codex_file.upload(
-        run_codex_extraction,
+        autofill_codex_details,
         inputs=[codex_file, codex_author_name, codex_author_id, codex_works],
-        outputs=[codex_report, codex_json, codex_status],
+        outputs=[codex_author_name, codex_author_id, codex_works, codex_status],
         queue=False,
-        trigger_mode="multiple",
+        trigger_mode="always_last",
     )
     codex_clear_btn.click(
         clear_codex_form,