Update app.py

app.py

@@ -3,41 +3,60 @@ import os
 import shutil
 import zipfile
 from pathlib import Path
-from typing import List, Optional, Dict, Any
+from typing import Any, Dict, List, Optional, Tuple
 
 import gradio as gr
 
 from pipeline import run_pipeline
-import asyncio
-asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
-import sys, asyncio
-print("PY_VER", sys.version)
-asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
-print("LOOP_POLICY_SET")
-DEFAULT_CONFIG = {
+
+# ---- Defaults / Constants ----
+
+DEFAULT_CONFIG: Dict[str, Any] = {
     "model": os.getenv("OPENAI_MODEL", "gpt-4o-mini"),
     "rewrite": False,
-    # Later: WordPress will send projects in here
-    "projects": [
-        {"name": "STANDARD", "description": "Generic scoring"}
-    ],
+    "projects": [{"name": "STANDARD", "description": "Generic scoring"}],
 }
 
+TMP_ROOT = Path("/tmp/resume_evaluator").resolve()
+UPLOAD_DIR = TMP_ROOT / "input_uploads"
+OUTPUT_DIR = TMP_ROOT / "output"
+RESULTS_ZIP = TMP_ROOT / "results.zip"
+
+
+# ---- Helpers ----
+
+def _clean_tmp() -> None:
+    if TMP_ROOT.exists():
+        shutil.rmtree(TMP_ROOT, ignore_errors=True)
+    UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
 
-def _stage_inputs(uploaded_files: List[str]) -> List[str]:
+def _parse_config(config_text: str) -> Dict[str, Any]:
+    text = (config_text or "").strip()
+    if not text:
+        return dict(DEFAULT_CONFIG)
+
+    try:
+        cfg = json.loads(text)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Config JSON is invalid: {e}") from e
+
+    # Merge user config over defaults (shallow merge is enough for your current shape)
+    merged = dict(DEFAULT_CONFIG)
+    merged.update(cfg if isinstance(cfg, dict) else {})
+    return merged
+
+
+def _stage_inputs(uploaded_files: Optional[List[str]]) -> List[str]:
     """
-    Gradio gives us file paths (type='filepath').
-    We copy them into /tmp/input_uploads so pipeline has stable paths.
-    If ZIP is uploaded, extract PDFs.
+    Gradio gives file paths when using type='filepath'.
+    We copy into /tmp for stable paths. If ZIP is uploaded, extract PDFs.
     """
-    input_dir = Path("/tmp/input_uploads").resolve()
-    if input_dir.exists():
-        shutil.rmtree(input_dir)
-    input_dir.mkdir(parents=True, exist_ok=True)
-
     staged: List[str] = []
+    uploaded_files = uploaded_files or []
 
-    for f in uploaded_files or []:
+    for f in uploaded_files:
         src = Path(f)
         if not src.exists():
             continue
@@ -45,72 +64,118 @@ def _stage_inputs(uploaded_files: List[str]) -> List[str]:
         # ZIP case
         if src.suffix.lower() == ".zip":
             with zipfile.ZipFile(src, "r") as z:
-                z.extractall(input_dir)
-            # collect PDFs
-            for p in sorted(input_dir.rglob("*.pdf")):
-                staged.append(str(p.resolve()))
+                z.extractall(UPLOAD_DIR)
+            staged.extend([str(p.resolve()) for p in sorted(UPLOAD_DIR.rglob("*.pdf"))])
             continue
 
         # PDF case
         if src.suffix.lower() == ".pdf":
-            dst = input_dir / src.name
+            dst = UPLOAD_DIR / src.name
             shutil.copy2(src, dst)
             staged.append(str(dst.resolve()))
 
-    return staged
+    # Deduplicate while preserving order
+    seen = set()
+    unique: List[str] = []
+    for p in staged:
+        if p not in seen:
+            seen.add(p)
+            unique.append(p)
 
+    return unique
 
-def process(files, config_json: str):
-    # files can be None / single / list depending on gradio version; normalize.
-    if files is None:
-        return None
 
-    if isinstance(files, str):
-        uploaded_files = [files]
-    else:
-        uploaded_files = [f for f in files]
+def _zip_dir(src_dir: Path, zip_path: Path) -> None:
+    if zip_path.exists():
+        zip_path.unlink()
 
-    staged_pdfs = _stage_inputs(uploaded_files)
-    if not staged_pdfs:
-        raise gr.Error("No PDFs found. Upload PDFs or a ZIP containing PDFs.")
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as z:
+        for p in sorted(src_dir.rglob("*")):
+            if p.is_file():
+                z.write(p, arcname=str(p.relative_to(src_dir)))
 
-    # config
-    cfg = DEFAULT_CONFIG
-    if config_json and config_json.strip():
+
+# ---- Gradio handler ----
+
+def process(uploaded_files: Optional[List[str]], config_text: str) -> Tuple[str, Optional[str]]:
+    """
+    Returns:
+      (status_text, results_zip_path_or_none)
+    """
+    _clean_tmp()
+
+    cfg = _parse_config(config_text)
+    pdf_paths = _stage_inputs(uploaded_files)
+
+    if not pdf_paths:
+        return ("No PDFs found. Upload one or more PDFs, or a ZIP containing PDFs.", None)
+
+    # Run pipeline
+    try:
+        # Your pipeline should write outputs somewhere; we give it OUTPUT_DIR if supported.
+        # If your run_pipeline signature differs, adjust here ONLY.
+        run_pipeline(
+            input_files=pdf_paths,
+            config=cfg,
+            output_dir=str(OUTPUT_DIR),
+        )
+    except TypeError:
+        # Fallback if your pipeline has a different signature (common in early iterations).
+        # Try minimal call patterns.
         try:
-            cfg = json.loads(config_json)
-        except Exception:
-            raise gr.Error("Config JSON is invalid. Fix JSON formatting.")
+            run_pipeline(pdf_paths, cfg, str(OUTPUT_DIR))
+        except Exception as e:
+            return (f"Pipeline failed: {type(e).__name__}: {e}", None)
+    except Exception as e:
+        return (f"Pipeline failed: {type(e).__name__}: {e}", None)
+
+    # Zip results
+    try:
+        _zip_dir(OUTPUT_DIR, RESULTS_ZIP)
+    except Exception as e:
+        return (f"Failed to package results: {type(e).__name__}: {e}", None)
+
+    return (f"Processed {len(pdf_paths)} file(s). Results are ready.", str(RESULTS_ZIP))
+
+
+# ---- UI ----
+
+def build_ui() -> gr.Blocks:
+    with gr.Blocks(title="Resume Evaluator") as demo:
+        gr.Markdown("# Resume Evaluator")
+
+        with gr.Group():
+            files = gr.File(
+                label="Upload PDF(s) or a ZIP",
+                file_count="multiple",
+                type="filepath",
+            )
+
+        with gr.Group():
+            config = gr.Code(
+                label="Config JSON (optional)",
+                language="json",
+                value=json.dumps(DEFAULT_CONFIG, indent=2),
+            )
 
-    zip_path = run_pipeline(input_files=staged_pdfs, config=cfg)
-    return zip_path
+        with gr.Row():
+            btn = gr.Button("Process", variant="primary")
 
+        status = gr.Textbox(label="Status", interactive=False)
 
-with gr.Blocks() as demo:
-    gr.Markdown("# Resume Evaluator")
+        results = gr.File(label="Download Results ZIP", interactive=False)
 
-    files = gr.File(
-        label="Upload PDF(s) or a ZIP",
-        file_count="multiple",
-        type="filepath",  # <-- FIX
-    )
+        btn.click(
+            fn=process,
+            inputs=[files, config],
+            outputs=[status, results],
+        )
 
-    config_json = gr.Textbox(
-        label="Config JSON (optional)",
-        value=json.dumps(DEFAULT_CONFIG, indent=2),
-        lines=10,
-    )
+    return demo
 
-    btn = gr.Button("Process")
-    out = gr.File(label="Download Results ZIP")
 
-    btn.click(fn=process, inputs=[files, config_json], outputs=[out])
+demo = build_ui()
 
 if __name__ == "__main__":
-    demo.queue()  # important on HF
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=int(os.getenv("PORT", "7860")),
-        ssr_mode=False,
-        show_error=True,
-    )
+    # Keep it explicit for HF Spaces
+    demo.launch(server_name="0.0.0.0", server_port=7860)