Upload 6 files

backend/media_analysis/data_export.py

@@ -29,6 +29,31 @@ def decode_structured_answer(answer: str) -> tuple[str, list[dict], str | None]:
     return str(obj.get("answer") or ""), rows, None
 
 
+NUMERIC_FIELDS = {"minimum", "maximum", "mean", "std", "value", "x", "y", "percent_value"}
+
+
+def normalize_records(records: list[dict]) -> tuple[list[dict], list[str]]:
+    """Normalize unambiguous numeric fields, retain originals when text formatting differs.
+
+    Never infer a missing sign, range, classification, or null value.
+    """
+    result, warnings = [], []
+    for index, original in enumerate(records, 1):
+        item = dict(original)
+        for key in NUMERIC_FIELDS & item.keys():
+            value = item[key]
+            if isinstance(value, str):
+                cleaned = value.strip()
+                normalized = cleaned.replace(",", "")
+                if re.fullmatch(r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)", normalized):
+                    item[key + "_printed"] = value
+                    item[key] = float(normalized) if "." in normalized else int(normalized)
+                elif cleaned:
+                    warnings.append(f"Row {index}: {key} is not an unambiguous number: {value!r}")
+        result.append(item)
+    return result, warnings
+
+
 def csv_attachment(records: list[dict], sources: list[dict]) -> dict | None:
     if not records:
         return None

backend/media_analysis/figure_analysis.py

@@ -119,7 +119,7 @@ def prepare_media_evidence(
 
 def analyze_media_question(question: str, selected_papers: list[dict], *, enabled: bool | None = None,
                            figures_lookup=None, asset_resolver=None, vision_client=None, provider: str = "azure", model: str | None = None, max_output_tokens: int | None = None,
-                           evidence_mode: str = "vision", export_csv: bool = False) -> dict:
+                           evidence_mode: str = "vision", export_csv: bool = False, analysis_mode: str = "auto") -> dict:
     """Explicit opt-in entry point. Never silently substitutes a text summary answer."""
     if enabled is None:
         enabled = os.getenv("WATERSCOPE_ENABLE_MEDIA_ANALYSIS", "0").lower() in ("1", "true", "yes")
@@ -130,6 +130,12 @@ def analyze_media_question(question: str, selected_papers: list[dict], *, enable
     if vision_client is None:
         from .vision_client import analyze_images
         vision_client = analyze_images
+    if analysis_mode not in ("auto", "extract_all", "interpret"):
+        raise ValueError("analysis_mode must be auto, extract_all, or interpret")
+    if analysis_mode == "extract_all":
+        question = question + "\n[Task: extract every available data row and classification subrow from the referenced media.]"
+    elif analysis_mode == "interpret":
+        question = question + "\n[Task: prioritize interpretation; extract only data relevant to the question.]"
     if evidence_mode not in ("vision", "json", "combined"):
         raise ValueError("evidence_mode must be vision, json or combined")
     if evidence_mode != "vision":
@@ -146,11 +152,13 @@ def analyze_media_question(question: str, selected_papers: list[dict], *, enable
                            max_output_tokens=max_output_tokens, evidence_mode=evidence_mode,
                            structured_output=export_csv)
     if export_csv:
-        from .data_export import decode_structured_answer, csv_attachment
+        from .data_export import decode_structured_answer, csv_attachment, normalize_records
         answer, records, warning = decode_structured_answer(result.get("answer", ""))
         result["answer"] = answer
+        records, normalization_warnings = normalize_records(records)
         result["structured_data"] = records
+        result["normalization_warnings"] = normalization_warnings
         result["csv_attachment"] = csv_attachment(records, result.get("sources") or [])
         if warning:
             result["export_warning"] = warning
-    return {"status": "ok", "vision_inspected": evidence_mode != "json", "evidence_mode": evidence_mode, **result}
+    return {"status": "ok", "vision_inspected": evidence_mode != "json", "evidence_mode": evidence_mode, "analysis_mode": analysis_mode, **result}

backend/media_analysis/table_data.py

@@ -34,17 +34,22 @@ def load_table_evidence(folder: str, label: str, resolver: Callable[[str,str], A
     cells = table.get("cells")
     if not isinstance(rows, list) or len(rows) > 500:
         raise ValueError("Invalid/oversized table text rows")
-    # Keep word x/y coordinates so model can align columns. Truncate payload
-    # deterministically rather than sending the enormous extraction JSON.
+    # Preserve every source row, but replace redundant per-word bounding boxes
+    # with a compact word@horizontal-position representation. A text row is NOT
+    # a verified table cell row, especially for merged/multi-line groups.
     compact_rows = []
     for row in rows:
         words = []
-        for word in (row.get("words") or [])[:60]:
+        for word in (row.get("words") or [])[:100]:
             bbox = word.get("bbox_points") or []
-            words.append({"text": str(word.get("text", ""))[:100],
-                          "x": round(float(bbox[0]), 1) if len(bbox) == 4 else None,
-                          "y": round(float(bbox[1]), 1) if len(bbox) == 4 else None})
-        compact_rows.append({"text": str(row.get("text", ""))[:1000], "words": words})
+            token = str(word.get("text", ""))[:120]
+            if len(bbox) == 4:
+                words.append([token, round(float(bbox[0]), 1)])
+            else:
+                words.append([token, None])
+        compact_rows.append({"text": str(row.get("text", ""))[:1600], "positioned_words": words})
+    # Include all nonempty rows, including continuation rows and classifications.
+    # The original JSON remains in the dataset; this is only an inference view.
     return {
         "label": label, "data_file": filename,
         "structure_extracted": bool(table.get("structure_extracted")),

backend/media_analysis/test_routes.py

@@ -48,6 +48,9 @@ def media_analyze_test():
     evidence_mode = str(body.get("evidence_mode", "vision")).strip().lower()
     if evidence_mode not in ("vision", "json", "combined"):
         return jsonify({"error": "evidence_mode must be vision, json or combined"}), 400
+    analysis_mode = str(body.get("analysis_mode", "auto")).strip().lower()
+    if analysis_mode not in ("auto", "extract_all", "interpret"):
+        return jsonify({"error": "analysis_mode must be auto, extract_all, or interpret"}), 400
     export_csv = body.get("export_csv", False)
     if not isinstance(export_csv, bool):
         return jsonify({"error": "export_csv must be boolean"}), 400
@@ -70,7 +73,7 @@ def media_analyze_test():
         sanitized.append(clean)
     try:
         result = analyze_media_question(question, sanitized, enabled=True, provider=provider, model=model, max_output_tokens=max_output_tokens,
-                                        evidence_mode=evidence_mode, export_csv=export_csv)
+                                        evidence_mode=evidence_mode, export_csv=export_csv, analysis_mode=analysis_mode)
         return jsonify(result)
     except (MediaSelectionError, VisionConfigurationError, ValueError, FileNotFoundError) as exc:
         return jsonify({"error": str(exc), "vision_inspected": False}), 400

backend/media_analysis/vision_client.py

@@ -116,12 +116,22 @@ def analyze_images(question: str, evidence: list[dict], *, model: str | None = N
     )
     if structured_output:
         instructions += (
-            " Return ONLY a valid JSON object with keys answer (scientific narrative string) "
-            "and records (array of objects, one per requested data row). Include units, "
+            " Return ONLY valid JSON with keys answer (brief readable summary) and records "
+            "(array containing exactly the requested extracted rows). For a request to extract "
+            "all data, include every parameter and every classification subrow, standard range, "
+            "percentage, reference, units and descriptive statistics, without silently omitting "
+            "rows. In repeated subrows, do not invent or repeat descriptive statistics that "
+            "occur only in the first source row: use null. "
+            "Use stable field names: parameter, unit, minimum, maximum, mean, std, "
+            "standard_range, class_label, classification, percent_samples, references, "
             "estimated (boolean), extraction_method (printed_table|positioned_text|visual_estimate), "
-            "and source_quality when possible. For multiple media items each record MUST "
-            "identify paper_id and media_label. Do not fabricate rows or values. "
-            "For uncertain cells use null and explain uncertainty in answer."
+            "and source_quality. Preserve original printed parameter names, units, inequality "
+            "signs, and numeric precision. Numeric values must be JSON numbers (no thousands "
+            "separators); use *_printed fields if preservation of original formatting matters. "
+            "For ambiguous OCR signs, compare against image; if still unclear use null and "
+            "explain ambiguity. Source-quality is descriptive, never a proof of verification. "
+            "When extracting multiple sources include paper_id and media_label per record. "
+            "The answer must not claim a complete extraction if rows are omitted."
         )
     content: list[dict] = [{"type": "input_text", "text": f"Question: {question.strip()}"}]
     used = []