put in API

Dockerfile

@@ -1,17 +1,30 @@
-FROM python:3.9
+# FROM python:3.9
+
+# # install system-wide (root)
+# WORKDIR /app
+# COPY requirements.txt .
+# RUN pip install --no-cache-dir -r requirements.txt
+
+# # now drop privs
+# RUN useradd -m -u 1000 user
+# USER user
+# ENV PYTHONUNBUFFERED=1 \
+#     PATH="/home/user/.local/bin:$PATH"
+
+# # copy the source code
+# COPY --chown=user . /app
+
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+
+FROM python:3.11-slim
 
-# install system-wide (root)
 WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# now drop privs
-RUN useradd -m -u 1000 user
-USER user
-ENV PYTHONUNBUFFERED=1 \
-    PATH="/home/user/.local/bin:$PATH"
-
-# copy the source code
-COPY --chown=user . /app
+# copy source *after* deps to use layer caching
+COPY . .
 
+# expose any port (HF maps it); 7860 is conventional
+EXPOSE 7860
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -1,4 +1,5 @@
 from fastapi import FastAPI
+from ai_reviewer.api import app
 
 app = FastAPI()
 

requirements.txt

@@ -1,2 +1,7 @@
 fastapi
-uvicorn[standard]
+uvicorn[standard]
+python-dotenv
+openai
+anthropic
+pydantic
+requests

reviewer/__init__.py

@@ -0,0 +1,5 @@
+# tmlr_reviewer package
+
+from .reviewer import PDFReviewer
+
+__all__ = ["PDFReviewer"] 

reviewer/api.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import JSONResponse
+
+from pathlib import Path
+import tempfile
+
+from .reviewer import PDFReviewer
+
+app = FastAPI(title="TMLR Reviewer PDF API", description="Generate reviews for uploaded PDFs")
+
+reviewer = PDFReviewer()
+
+
+@app.post("/review")
+async def review_pdf(file: UploadFile = File(...)):
+    """Upload a PDF file and return the structured review as JSON."""
+    if file.content_type != "application/pdf":
+        raise HTTPException(status_code=400, detail="Only PDF files are supported")
+
+    # Save to temporary location
+    suffix = Path(file.filename).suffix or ".pdf"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+        content = await file.read()
+        tmp.write(content)
+        tmp_path = Path(tmp.name)
+
+    try:
+        review_result = reviewer.review_pdf(tmp_path)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc))
+    finally:
+        tmp_path.unlink(missing_ok=True)
+
+    return JSONResponse(content=review_result) 

reviewer/cli.py

@@ -0,0 +1,86 @@
+import argparse
+import pathlib
+import uvicorn
+import gradio as gr
+
+from .reviewer import PDFReviewer
+from .api import app as fastapi_app
+
+
+def _cli_review(args):
+    reviewer = PDFReviewer(debug=args.debug)
+    result = reviewer.review_pdf(args.pdf)
+    for key, value in result.items():
+        print(f"\n{key.upper()}:\n{value}\n")
+
+
+def _cli_demo(args):
+    reviewer = PDFReviewer(debug=args.debug)
+
+    def gradio_interface(file, progress=gr.Progress()):
+        result = reviewer.review_pdf(file.name)
+        return (
+            result["contributions"],
+            result["strengths"],
+            result["weaknesses"],
+            result["requested_changes"],
+            result["impact_concerns"],
+            result["claims_and_evidence"],
+            result["audience_interest"],
+        )
+
+    iface = gr.Interface(
+        fn=gradio_interface,
+        inputs=gr.File(label="Upload PDF"),
+        outputs=[
+            gr.Textbox(label="Contributions"),
+            gr.Textbox(label="Strengths"),
+            gr.Textbox(label="Weaknesses"),
+            gr.Textbox(label="Requested Changes"),
+            gr.Textbox(label="Impact Concerns"),
+            gr.Textbox(label="Claims and Evidence"),
+            gr.Textbox(label="Audience Interest"),
+        ],
+        title="PDF Review Parser",
+        description="Upload a PDF to parse and review its content.",
+    )
+    iface.launch(share=True)
+
+
+def _cli_api(args):
+    uvicorn.run(fastapi_app, host=args.host, port=args.port, reload=args.reload)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="TMLR PDF Reviewer")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # Review command
+    p_review = subparsers.add_parser("review", help="Process a PDF and output to console")
+    p_review.add_argument("pdf", type=pathlib.Path, help="Path to the PDF file")
+    p_review.add_argument("--debug", action="store_true", help="Enable debug mode (uses gpt-4o and drops to pdb on errors)")
+    p_review.set_defaults(func=_cli_review)
+
+    # Demo command
+    p_demo = subparsers.add_parser("demo", help="Launch Gradio demo")
+    p_demo.add_argument("--debug", action="store_true", help="Enable debug mode (uses gpt-4o and drops to pdb on errors)")
+    p_demo.set_defaults(func=_cli_demo)
+
+    # API command
+    p_api = subparsers.add_parser("api", help="Run FastAPI server")
+    p_api.add_argument("--host", default="0.0.0.0")
+    p_api.add_argument("--port", type=int, default=8000)
+    p_api.add_argument("--reload", action="store_true")
+    p_api.set_defaults(func=_cli_api)
+
+    return parser
+
+
+def main():
+    parser = build_parser()
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main() 

reviewer/logger.py

@@ -0,0 +1,37 @@
+import logging
+from pathlib import Path
+from datetime import datetime
+
+__all__ = ["get_review_logger"]
+
+
+LOG_DIR = Path("logs")
+LOG_DIR.mkdir(exist_ok=True)
+
+
+def get_review_logger(review_id: str | None = None) -> logging.Logger:
+    """Return a configured logger for a single review run.
+
+    A new ``FileHandler`` is attached whose filename is based on *review_id* or a
+    timestamp if none is given.
+    """
+    name = f"tmlr_reviewer.{review_id or datetime.utcnow().strftime('%Y%m%d_%H%M%S')}"
+    logger = logging.getLogger(name)
+    if logger.handlers:
+        # already configured
+        return logger
+
+    logger.setLevel(logging.INFO)
+
+    # Console output
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+    logger.addHandler(stream_handler)
+
+    # File output
+    log_file = LOG_DIR / f"{name}.log"
+    file_handler = logging.FileHandler(log_file)
+    file_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+    logger.addHandler(file_handler)
+
+    return logger 

reviewer/reviewer.py

@@ -0,0 +1,363 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Dict, List, Literal, Tuple
+
+from dotenv import load_dotenv
+from openai import OpenAI
+import anthropic
+import requests
+import base64
+
+from pydantic import BaseModel
+
+from .logger import get_review_logger
+from .utils import extract_all_tags
+
+load_dotenv()
+
+# ---------------------------------------------------------------------------
+# Pydantic models
+# ---------------------------------------------------------------------------
+
+class Point(BaseModel):
+    content: str
+    importance: Literal["critical", "minor"]
+
+
+class Review(BaseModel):
+    contributions: str
+    strengths: List[Point]
+    weaknesses: List[Point]
+    requested_changes: List[Point]
+    impact_concerns: str
+    claims_and_evidence: str
+    audience_interest: str
+
+
+IMPORTANCE_MAPPING = {"critical": 2, "minor": 1}
+
+# ---------------------------------------------------------------------------
+# Reviewer Class
+# ---------------------------------------------------------------------------
+
+
+class PDFReviewer:
+    """Encapsulates the full PDF review life-cycle.
+
+    Parameters
+    ----------
+    openai_key:
+        OAuth key for the OpenAI client. Falls back to ``OPENAI_API_KEY`` env var.
+    anthropic_key:
+        Key for Anthropic Claude API. Falls back to ``ANTHROPIC_API_KEY`` env var.
+    cache_dir:
+        Where temporary PDFs are stored.
+    """
+
+    def __init__(
+        self,
+        *,
+        openai_key: str | None = None,
+        anthropic_key: str | None = None,
+        cache_dir: str | Path = "cache",
+        debug: bool = False,
+    ) -> None:
+        self.openai_key = openai_key or os.getenv("OPENAI_API_KEY")
+        self.anthropic_key = anthropic_key or os.getenv("ANTHROPIC_API_KEY")
+
+        if not self.openai_key:
+            raise EnvironmentError("Missing OPENAI_API_KEY env var or parameter")
+
+        if not self.anthropic_key:
+            raise EnvironmentError("Missing ANTHROPIC_API_KEY env var or parameter")
+
+        self.client = OpenAI(api_key=self.openai_key)
+        self.claude_client = anthropic.Anthropic(api_key=self.anthropic_key)
+
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(exist_ok=True)
+
+        self.debug = debug
+
+        self.logger = get_review_logger()
+
+        # Lazy import prompts to avoid circular dependency during tests
+        import importlib
+
+        self.PROMPTS = importlib.import_module("prompts")
+
+    # ---------------------------------------------------------------------
+    # Public high-level API
+    # ---------------------------------------------------------------------
+
+    def review_pdf(self, pdf_path: str | Path) -> Dict[str, str]:
+        """Main entry-point: review *pdf_path* and return parsed results."""
+        pdf_path = Path(pdf_path)
+        self.logger.info("Starting review for %s", pdf_path.name)
+        file_uploaded = self._step("upload_pdf", self._upload_pdf, pdf_path)
+        self.logger.info("PDF uploaded, id=%s", file_uploaded.id)
+
+        literature_report = self._step("literature_search", self._literature_search, file_uploaded)
+        self.logger.info("Literature search complete")
+
+        raw_review = self._step("generate_initial_review", self._generate_initial_review, file_uploaded, literature_report)
+        self.logger.info("Initial review generated")
+
+        # Optional defense / revision stage
+        defended_review = self._step("defend_review", self._defend_review, file_uploaded, raw_review)
+
+        parsed_review = self._step("parse_final", self._parse_final, defended_review)
+        self.logger.info("Review parsed")
+
+        return parsed_review
+
+    # ------------------------------------------------------------------
+    # Internal helpers (prefixed with _)
+    # ------------------------------------------------------------------
+
+    def _upload_pdf(self, pdf_path: Path):
+        """Upload *pdf_path* to OpenAI and return the file object."""
+        with open(pdf_path, "rb") as pdf_file:
+            return self.client.files.create(file=pdf_file, purpose="user_data")
+
+    def _literature_search(self, file):
+        """Run literature search tool call."""
+        model_name = "gpt-4o" if self.debug else "gpt-4.1"
+        resp = self.client.responses.create(
+            model=model_name,
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "input_file", "file_id": file.id},
+                        {"type": "input_text", "text": self.PROMPTS.literature_search},
+                    ],
+                }
+            ],
+            tools=[{"type": "web_search"}],
+        )
+        return resp.output_text
+
+    def _generate_initial_review(self, file, literature_report: str):
+        """Query GPT model with combined prompts to get initial review."""
+        prompt = self.PROMPTS.review_prompt.format(
+            literature_search_report=literature_report,
+            acceptance_criteria=self.PROMPTS.acceptance_criteria,
+            review_format=self.PROMPTS.review_format,
+        )
+        model_name = "gpt-4o" if self.debug else "o4-mini"
+        resp = self.client.responses.create(
+            model=model_name,
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "input_file", "file_id": file.id},
+                        {"type": "input_text", "text": prompt},
+                    ],
+                }
+            ],
+        )
+        return resp.output_text
+
+    # ------------------------------------------------------------------
+    # Static/utility parsing helpers
+    # ------------------------------------------------------------------
+
+    def _parse_final(self, parsed: Dict, *, max_strengths: int = 3, max_weaknesses: int = 5, max_requested_changes: int = 5) -> Dict[str, str]:
+        """Convert model structured response into simplified text blobs."""
+        self.logger.debug("Parsing final review json -> human readable")
+        if isinstance(parsed, str):
+            # attempt to parse via Pydantic
+            try:
+                parsed = Review.model_validate_json(parsed).model_dump()
+            except Exception:
+                self.logger.warning("parse_final received string that could not be parsed by Review model. Returning as-is text under 'contributions'.")
+                return {"contributions": parsed}
+
+        new_parsed: Dict[str, str] = {}
+        new_parsed["contributions"] = parsed["contributions"]
+        new_parsed["claims_and_evidence"] = parsed["claims_and_evidence"]
+        new_parsed["audience_interest"] = parsed["audience_interest"]
+        new_parsed["impact_concerns"] = parsed["impact_concerns"]
+
+        new_parsed["strengths"] = "\n".join(
+            [f"- {point['content']}" for point in parsed["strengths"][:max_strengths]]
+        )
+        new_parsed["weaknesses"] = "\n".join(
+            [f"- {point['content']}" for point in parsed["weaknesses"][:max_weaknesses]]
+        )
+        request_changes_sorted = sorted(
+            parsed["requested_changes"],
+            key=lambda x: IMPORTANCE_MAPPING[x["importance"]],
+            reverse=True,
+        )
+        new_parsed["requested_changes"] = "\n".join(
+            [f"- {point['content']}" for point in request_changes_sorted[:max_requested_changes]]
+        )
+        return new_parsed
+
+    # ------------------------------------------------------------------
+    # Optional – could integrate unit tests style checks here
+    # ------------------------------------------------------------------
+
+    def _run_unit_tests(self, pdf_path: Path, review: Dict[str, str]) -> Tuple[bool, str | None]:
+        """Run post-hoc sanity tests powered by Claude prompts."""
+        test_prompt = self.PROMPTS.unit_test_prompt.format(review=review)
+        response = self._ask_claude(test_prompt, pdf_path)
+        results = extract_all_tags(response)
+        for test_name in [
+            "reviewing_process_references",
+            "inappropriate_language",
+            "llm_generated_review",
+            "hallucinations",
+            "formatting_and_style",
+        ]:
+            self.logger.info("Unit test %s: %s", test_name, results.get(test_name))
+            if results.get(test_name) == "FAIL":
+                return False, test_name
+        return True, None
+
+    # ------------------------------------------------------------------
+    # Claude wrapper
+    # ------------------------------------------------------------------
+
+    def _ask_claude(
+        self,
+        query: str,
+        pdf_path: str | Path | None = None,
+        *,
+        max_tokens: int = 8000,
+        model: str = "claude-3-5-sonnet-20241022",
+    ) -> str:
+        content = query
+        betas: List[str] = []
+
+        # Attach PDF for context if provided
+        if pdf_path is not None:
+            if str(pdf_path).startswith(("http://", "https://")):
+                binary_data = requests.get(str(pdf_path)).content
+            else:
+                with open(pdf_path, "rb") as fp:
+                    binary_data = fp.read()
+            pdf_data = base64.standard_b64encode(binary_data).decode()
+            content = [
+                {
+                    "type": "document",
+                    "source": {
+                        "type": "base64",
+                        "media_type": "application/pdf",
+                        "data": pdf_data,
+                    },
+                },
+                {"type": "text", "text": query},
+            ]
+            betas.append("pdfs-2024-09-25")
+
+        kwargs = {
+            "model": model,
+            "max_tokens": max_tokens,
+            "messages": [{"role": "user", "content": content}],
+        }
+        if betas:
+            kwargs["betas"] = betas
+
+        message = self.claude_client.beta.messages.create(**kwargs)  # type: ignore[arg-type]
+        return message.content[0].text
+
+    # ------------------------------------------------------------------
+    # Public utility methods
+    # ------------------------------------------------------------------
+
+    def get_prompts(self):
+        """Return the prompts module for inspection."""
+        return self.PROMPTS
+
+    def get_logger(self):
+        """Return the logger for inspection."""
+        return self.logger
+
+    # ------------------------------------------------------------------
+    # _step helper (defined at end to avoid cluttering core logic)
+    # ------------------------------------------------------------------
+
+    def _step(self, name: str, fn, *args, **kwargs):
+        """Execute *fn* and, if an exception occurs, trigger pdb in debug mode."""
+        try:
+            self.logger.info("Starting step: %s", name)
+            result = fn(*args, **kwargs)
+            self.logger.info("Completed step: %s", name)
+            return result
+        except Exception:
+            self.logger.exception("Step %s failed", name)
+            if self.debug:
+                import pdb, traceback
+                traceback.print_exc()
+                pdb.post_mortem()
+            raise
+
+    # ------------------------------------------------------------------
+    # Defense / revision helpers
+    # ------------------------------------------------------------------
+
+    def _run_query_on_file(self, file, prompt: str, *, model_name: str):
+        """Thin wrapper around OpenAI responses.create used by several steps."""
+        return self.client.responses.create(
+            model=model_name,
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "input_file", "file_id": file.id},
+                        {"type": "input_text", "text": prompt},
+                    ],
+                }
+            ],
+        ).output_text
+
+    def _defend_review(self, file, review: str):
+        """Run defense → revision → human-style polishing as in legacy workflow."""
+        model_name = "gpt-4o" if self.debug else "o3"
+
+        defense = self._run_query_on_file(
+            file,
+            self.PROMPTS.defend_prompt.format(combined_review=review),
+            model_name=model_name,
+        )
+
+        revision_prompt = self.PROMPTS.revise_prompt.format(
+            review_format=self.PROMPTS.review_format.format(
+                acceptance_criteria=self.PROMPTS.acceptance_criteria,
+                review_format=self.PROMPTS.review_format,
+            ),
+            combined_review=review,
+            defended_paper=defense,
+        )
+        revision = self._run_query_on_file(file, revision_prompt, model_name=model_name)
+
+        humanised = self._run_query_on_file(
+            file,
+            self.PROMPTS.human_style.format(review=revision),
+            model_name=model_name,
+        )
+
+        # Finally, convert to structured Review JSON using formatting prompt
+        formatted = self._format_review(humanised, model_name=model_name)
+
+        return formatted
+
+    def _format_review(self, review_text: str, *, model_name: str):
+        """Use OpenAI function calling to map *review_text* → Review model dict."""
+        chat_completion = self.client.beta.chat.completions.parse(
+            messages=[
+                {
+                    "role": "user",
+                    "content": self.PROMPTS.formatting_prompt.format(review=review_text),
+                }
+            ],
+            model=model_name,
+            response_format=Review,
+        )
+        return chat_completion.choices[0].message.parsed.model_dump() 

reviewer/utils.py

@@ -0,0 +1,64 @@
+"""Utility helper functions for tmlr_reviewer package."""
+
+import re
+from typing import Dict
+
+__all__ = [
+    "extract_all_tags",
+    "extract_output_tags",
+    "parse_json_from_text",
+]
+
+
+def extract_all_tags(text: str) -> Dict[str, str]:
+    """Extracts content between any XML-style tags from a string.
+
+    Args:
+        text: Input string that may contain tags
+
+    Returns:
+        Mapping of tag name -> tag content with surrounding whitespace stripped.
+    """
+    pattern = r"<(\w+)>(.*?)</\1>"
+    matches = re.findall(pattern, text, re.DOTALL)
+    return {tag: content.strip() for tag, content in matches}
+
+
+def extract_output_tags(text: str) -> str:
+    """Extract content between <output></output> tags from *text* if present.
+
+    Args:
+        text: Arbitrary string that may contain output tags.
+
+    Returns:
+        The content inside the first pair of <output> tags if found otherwise the original text.
+    """
+    pattern = r"<output>(.*?)</output>"
+    match = re.search(pattern, text, re.DOTALL)
+    return match.group(1).strip() if match else text
+
+
+def parse_json_from_text(text: str):
+    """Attempt to parse the *first* JSON object found in *text*.
+
+    Returns the parsed Python object if successful, otherwise ``None``.
+    """
+    import json, re
+
+    # 1) Direct attempt
+    try:
+        return json.loads(text)
+    except Exception:
+        pass
+
+    # 2) Look for JSON object inside text
+    json_pattern = re.compile(r"\{[\s\S]*?\}")  # non-greedy to first closing brace
+    match = json_pattern.search(text)
+    if match:
+        candidate = match.group(0)
+        try:
+            return json.loads(candidate)
+        except Exception:
+            pass
+
+    return None