Update app.py

app.py

@@ -131,8 +131,67 @@ def call_openrouter(prompt: str):
     except Exception as e:
         return f"[OpenRouter request error] {e}"
 
+# ---------- Helper to read bytes from various Gradio file shapes ----------
+def read_file_bytes(f) -> Tuple[str, bytes]:
+    """
+    Accepts the variety of file objects Gradio may pass:
+     - file-like objects with .name and .read()
+     - objects with .name and .value (NamedString)
+     - tuples like (name, bytes)
+     - dicts that may contain 'name' and 'data' or temporary path keys
+     - string filesystem paths
+    Returns (filename, bytes)
+    Raises ValueError for unsupported shapes.
+    """
+    # tuple (name, bytes)
+    if isinstance(f, tuple) and len(f) == 2 and isinstance(f[1], (bytes, bytearray)):
+        return f[0], bytes(f[1])
+
+    # dict-like (from some frontends)
+    if isinstance(f, dict):
+        name = f.get("name") or f.get("filename") or "uploaded"
+        # raw bytes/content
+        data = f.get("data") or f.get("content") or f.get("value") or f.get("file")
+        if isinstance(data, (bytes, bytearray)):
+            return name, bytes(data)
+        if isinstance(data, str):
+            # data could be text content
+            try:
+                return name, data.encode("utf-8")
+            except Exception:
+                pass
+        # maybe a temp file path
+        tmp_path = f.get("tmp_path") or f.get("path") or f.get("file")
+        if tmp_path and isinstance(tmp_path, str) and os.path.exists(tmp_path):
+            with open(tmp_path, "rb") as fh:
+                return os.path.basename(tmp_path), fh.read()
+
+    # file-like object with read()
+    if hasattr(f, "name") and hasattr(f, "read"):
+        try:
+            name = os.path.basename(f.name) if getattr(f, "name", None) else "uploaded"
+            return name, f.read()
+        except Exception:
+            pass
+
+    # NamedString-like: has .name and .value
+    if hasattr(f, "name") and hasattr(f, "value"):
+        name = os.path.basename(getattr(f, "name") or "uploaded")
+        v = getattr(f, "value")
+        if isinstance(v, (bytes, bytearray)):
+            return name, bytes(v)
+        if isinstance(v, str):
+            return name, v.encode("utf-8")
+
+    # string path
+    if isinstance(f, str) and os.path.exists(f):
+        with open(f, "rb") as fh:
+            return os.path.basename(f), fh.read()
 
-# ---------------- PDF Upload & Index ----------------
+    raise ValueError(f"Unsupported file object type: {type(f)}")
+
+
+# ---------------- PDF Upload & Index (fixed) ----------------
 def upload_and_index(files):
     global DOCS, FILENAMES, EMBEDDINGS, CURRENT_CACHE_KEY
 
@@ -140,13 +199,22 @@ def upload_and_index(files):
         return "No PDF uploaded.", ""
 
     processed = []
-    for f in files:
-        name = os.path.basename(f.name)
-        b = f.read()
-        processed.append((name, b))
+    # files may be a single object or a list; normalize
+    if not isinstance(files, (list, tuple)):
+        files = [files]
 
+    try:
+        for f in files:
+            name, b = read_file_bytes(f)
+            processed.append((name, b))
+    except ValueError as e:
+        # return a clear message to the UI so user can debug what Gradio passed
+        return f"Upload error: {e}", ""
+
+    # preview for UI
     preview = [{"name": n, "size": len(b)} for n, b in processed]
 
+    # cache key
     cache_key = make_cache_key(processed)
     CURRENT_CACHE_KEY = cache_key
 
@@ -158,6 +226,7 @@ def upload_and_index(files):
         build_faiss(EMBEDDINGS)
         return f"Loaded cached embeddings ({len(FILENAMES)} PDFs).", json.dumps(preview)
 
+    # extract text and index
     DOCS = [extract_text_from_pdf(b) for _, b in processed]
     FILENAMES = [n for n, _ in processed]