Update app.py

app.py

@@ -126,23 +126,98 @@ def call_gpt5_for_metadata(title: str, short_text: str, top_chunks: List[str]) -
         data = {"_parsing_error": True, "raw_output": text}
     return data
 
+# helper: accept multiple upload types and return saved temp path and original name
+def save_uploaded_to_tmp(file_obj):
+    """
+    Accepts:
+      - a file-like object with .read()
+      - a path string (existing file path)
+      - a dict-like object returned by some gradio versions: {"name": "...", "data": b'...'}
+      - a NamedTemporaryFile wrapper (sometimes behaves like a path string)
+
+    Returns (tmp_path, original_name)
+    """
+    import io
+
+    # Case 1: file-like object with .read()
+    if hasattr(file_obj, "read") and callable(getattr(file_obj, "read")):
+        try:
+            content = file_obj.read()
+            # some wrappers return str, ensure bytes
+            if isinstance(content, str):
+                content = content.encode("utf-8")
+            name = getattr(file_obj, "name", "uploaded_file")
+            suffix = os.path.splitext(name)[1] or ""
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+                tmp.write(content)
+                return tmp.name, os.path.basename(name)
+        except Exception:
+            # fallthrough to other handlers
+            pass
+
+    # Case 2: Gradio sometimes returns a dict-like object with 'name' and 'data'
+    if isinstance(file_obj, dict):
+        # some versions: {"name": "foo.pdf", "data": b'...'}
+        if "data" in file_obj and "name" in file_obj:
+            data = file_obj["data"]
+            if isinstance(data, str):
+                data = data.encode("utf-8")
+            name = file_obj["name"]
+            suffix = os.path.splitext(name)[1] or ""
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+                tmp.write(data)
+                return tmp.name, os.path.basename(name)
+
+    # Case 3: file_obj is a path string
+    if isinstance(file_obj, str):
+        # if it's an existing path, just return it
+        if os.path.exists(file_obj):
+            return file_obj, os.path.basename(file_obj)
+        # sometimes gradio passes a NamedString that can be opened as a path -- try to open it
+        try:
+            with open(file_obj, "rb") as f:
+                data = f.read()
+            suffix = os.path.splitext(file_obj)[1] or ""
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+                tmp.write(data)
+                return tmp.name, os.path.basename(file_obj)
+        except Exception:
+            pass
+
+    # Case 4: some wrappers expose .name but not .read (e.g., NamedString)
+    name = getattr(file_obj, "name", None)
+    if name and isinstance(name, str):
+        try:
+            with open(name, "rb") as f:
+                data = f.read()
+            suffix = os.path.splitext(name)[1] or ""
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+                tmp.write(data)
+                return tmp.name, os.path.basename(name)
+        except Exception:
+            pass
+
+    # If we reach here, we can't handle the object
+    raise ValueError(f"Unsupported uploaded file object type: {type(file_obj)}. Value: {str(file_obj)[:200]}")
+
 
 # ----------------------
 # Main processing function
 # ----------------------
+# Updated process_file using the helper above
 def process_file(file_obj) -> Dict[str, Any]:
     """
-    file_obj: the uploaded file object provided by Gradio; has .name and a .file-like interface
+    file_obj: whatever gradio handed to us (file-like, dict, path string, etc.)
     Returns metadata dict ready to display.
     """
-    # Save uploaded file to temporary path
-    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file_obj.name)[1]) as tmp:
-        tmp.write(file_obj.read())
-        tmp_path = tmp.name
+    try:
+        tmp_path, orig_name = save_uploaded_to_tmp(file_obj)
+    except Exception as e:
+        return {"error": f"Failed to save uploaded file: {e}"}
 
-    # Extract text
+    # Now use tmp_path and orig_name for the rest of the pipeline
     try:
-        if file_obj.name.lower().endswith(".pdf"):
+        if orig_name.lower().endswith(".pdf"):
             extracted_text = extract_text_from_pdf(tmp_path)
         else:
             extracted_text = extract_text_from_image(tmp_path)
@@ -154,27 +229,22 @@ def process_file(file_obj) -> Dict[str, Any]:
 
     # Chunk and pick top chunks
     chunks = chunk_text(extracted_text)
-    # Heuristic: pick longest chunks as representative
     sorted_chunks = sorted(chunks, key=lambda x: len(x), reverse=True)
     top_chunks = sorted_chunks[:6] if sorted_chunks else [extracted_text[:2000]]
 
-    # Prepare a "short_text" to feed to the LLM
     short_text = (extracted_text[:1000] + "...") if len(extracted_text) > 1000 else extracted_text
 
-    # Call LLM
-    metadata = call_gpt5_for_metadata(file_obj.name, short_text, top_chunks)
+    metadata = call_gpt5_for_metadata(orig_name, short_text, top_chunks)
 
-    # If LLM returned a parsing error, include it
     if metadata.get("_parsing_error"):
         return {
             "error": "LLM output parsing failed. See raw_output.",
             "raw_output": metadata.get("raw_output")
         }
 
-    # Ensure required keys exist and post-process small things
     now = datetime.datetime.now(datetime.timezone.utc).astimezone().isoformat()
-    metadata.setdefault("doc_id", os.path.splitext(file_obj.name)[0])
-    metadata.setdefault("title", file_obj.name)
+    metadata.setdefault("doc_id", os.path.splitext(orig_name)[0])
+    metadata.setdefault("title", orig_name)
     metadata.setdefault("source", "user_upload")
     metadata.setdefault("raw_url", "")
     metadata.setdefault("ingest_timestamp", now)