Open in Overleaf posts the project itself; tests for the formatter and finder tabs

- formatter_tab.overleaf_html: the LaTeX zip is sent to Overleaf's API
(overleaf.com/devs) in a POST form as snip_uri=data:application/zip;
base64, with engine=pdflatex and main_document=main.tex. Overleaf no
longer has to download it from the Space, so the button works on a
private or sleeping Space and on a local run.
- A project above OVERLEAF_EMBED_MB (6) goes by its public address as
before; without one, only the manual upload is explained.
- tests/test_tools_tabs.py: formatting a Word manuscript (Word, LaTeX
zip with main.tex at the top level, report), the three Overleaf cases,
finder job options, shortlist table, input checks, both tabs wired in.

Checked in a browser that the form renders inside the app; the button
itself was not pressed (it creates a project on Overleaf).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

formatter_tab.py

@@ -6,8 +6,9 @@ house style, the journal's Word template or its author guidelines, and writes th
 a compliance report. Equations, algorithms and complex tables are carried over untouched.
 
 Overleaf: the LaTeX project is a zip with main.tex at its top level, refs.bib and figures/, using classes that
-Overleaf's TeX Live has (IEEEtran, elsarticle, llncs, sn-jnl ...). "Open in Overleaf" hands that zip to Overleaf
-by its address on this Space, so it only appears where the Space is reachable from the internet (SPACE_HOST).
+Overleaf's TeX Live has (IEEEtran, elsarticle, llncs, sn-jnl ...). "Open in Overleaf" posts that zip to Overleaf
+itself (overleaf.com/devs: snip_uri as a base64 data URL), so it works on a private Space and on a local run; only
+a very large project is handed over by its address on the Space (SPACE_HOST) instead.
 """
 import html
 import os
@@ -52,15 +53,37 @@ def public_url(path):
     return f"https://{host}/gradio_api/file={quote(str(path).replace(os.sep, '/'), safe='/:')}"
 
 
+OVERLEAF = "https://www.overleaf.com/docs"                 # Overleaf's "Open in Overleaf" API (overleaf.com/devs)
+# A project up to this size is sent to Overleaf inside the button itself; a larger one by its address on the Space.
+OVERLEAF_EMBED_MB = float(os.getenv("OVERLEAF_EMBED_MB", "6"))
+
+
 def overleaf_html(zip_path):
-    """"Open in Overleaf" for a LaTeX project zip, or how to upload it by hand."""
-    manual = ('<div class="cs-gauge-cap" style="text-align:left">In Overleaf: <b>New Project → Upload Project</b> '
-              'and choose the LaTeX .zip. It opens with <code>main.tex</code>, the references in '
+    """"Open in Overleaf" for a LaTeX project zip.
+
+    Overleaf's API takes the project in `snip_uri`, either as an address it downloads or as the file itself in a
+    base64 data URL. The file itself is the reliable way: Overleaf never has to reach this Space (which may be
+    private, asleep, or a local run), so the zip is posted in a form. Only a project too large to post is handed
+    over by its public address; with neither possible, the manual upload is explained."""
+    manual = ('<div class="cs-gauge-cap" style="text-align:left">Or by hand in Overleaf: <b>New Project → Upload '
+              'Project</b> and choose the LaTeX .zip. It opens with <code>main.tex</code>, the references in '
               '<code>refs.bib</code> and the figures in <code>figures/</code>; compile with pdfLaTeX.</div>')
+    if not zip_path or not os.path.exists(zip_path):
+        return ""
+    size_mb = os.path.getsize(zip_path) / (1024 * 1024)
+    if size_mb <= OVERLEAF_EMBED_MB:
+        import base64
+        data = "data:application/zip;base64," + base64.b64encode(Path(zip_path).read_bytes()).decode("ascii")
+        return (f'<form action="{OVERLEAF}" method="post" target="_blank" style="margin:0">'
+                f'<input type="hidden" name="snip_uri" value="{data}">'
+                '<input type="hidden" name="engine" value="pdflatex">'
+                '<input type="hidden" name="main_document" value="main.tex">'
+                '<button type="submit" class="cs-dl" style="border:0;cursor:pointer;font:inherit">'
+                '🍃 Open in Overleaf</button></form>' + manual)
     url = public_url(zip_path)
     if not url:
         return manual
-    link = "https://www.overleaf.com/docs?engine=pdflatex&snip_uri=" + quote(url, safe="")
+    link = f"{OVERLEAF}?engine=pdflatex&main_document=main.tex&snip_uri=" + quote(url, safe="")
     return (f'<a class="cs-dl" target="_blank" rel="noopener" href="{html.escape(link, quote=True)}">'
             f'🍃 Open in Overleaf</a>' + manual)
 

tests/test_tools_tabs.py

@@ -0,0 +1,149 @@
+"""Journal Formatter and Journal Finder tabs (no network: the journal lookup and the search itself are not run)."""
+import base64
+import io
+import json
+import sys
+import zipfile
+from pathlib import Path
+
+import pytest
+
+import finder_tab as FND
+import formatter_tab as FMT
+
+ROOT = Path(__file__).resolve().parent.parent
+progress = lambda *a, **k: None
+
+
+def _manuscript(tmp_path):
+    from docx import Document
+    d = Document()
+    d.add_heading("A Hybrid Deep Learning Framework for Intrusion Detection", 0)
+    d.add_paragraph("Ravi Kumar, Priya Sharma")
+    d.add_paragraph("Abstract: This study proposes a hybrid model that reaches 98.4% accuracy on a public dataset.")
+    d.add_heading("Introduction", 1)
+    d.add_paragraph("Medical devices are increasingly connected (Smith, 2020). Prior work used shallow models.")
+    d.add_heading("References", 1)
+    d.add_paragraph("Smith, J. (2020). Deep learning for intrusion detection. Journal of Network Security, 12(3), "
+                    "45-67.")
+    p = tmp_path / "my paper.docx"
+    d.save(str(p))
+    return str(p)
+
+
+# ---------------------------------------------------------------- formatter
+def test_formatter_engine_is_available():
+    assert FMT.AVAILABLE, FMT.WHY
+    assert len(FMT._preset_choices()) > 10 and FMT._preset_key(FMT.AUTO) is None
+
+
+def test_format_gives_word_latex_report_and_an_overleaf_button(tmp_path):
+    style = FMT.PRESETS["ieee_journal"]["name"]
+    status, docx, zip_, md, overleaf, report = FMT.format_doc(_manuscript(tmp_path), "", style, None, "", "", True,
+                                                              True, False, FMT.REF_STYLES[0], FMT.CITE_MODES[0],
+                                                              progress)
+    assert "Formatted as" in status and "checks passed" in status
+    assert docx.endswith("my_paper_formatted.docx") and Path(docx).stat().st_size > 5000
+    names = zipfile.ZipFile(zip_).namelist()
+    assert "main.tex" in names and not any(n.startswith("/") for n in names)      # main.tex at the top level
+    main = zipfile.ZipFile(zip_).read("main.tex").decode("utf-8")
+    assert "\\documentclass" in main and "IEEEtran" in main and "\\begin{document}" in main
+    assert Path(md).read_text(encoding="utf-8").startswith("# Formatting report") and "Compliance" in report
+    assert 'action="https://www.overleaf.com/docs"' in overleaf and 'method="post"' in overleaf
+
+
+def test_format_needs_a_manuscript_and_a_target(tmp_path):
+    import gradio as gr
+    with pytest.raises(gr.Error):
+        FMT.format_doc(None, "IEEE Access", FMT.AUTO, None, "", "", True, True, False, "", "", progress)
+    with pytest.raises(gr.Error):
+        FMT.format_doc(_manuscript(tmp_path), "", FMT.AUTO, None, "", "", True, True, False, "", "", progress)
+
+
+def _zip(tmp_path, kb=1):
+    p = tmp_path / "paper_latex.zip"
+    with zipfile.ZipFile(p, "w") as z:
+        z.writestr("main.tex", "\\documentclass{article}\\begin{document}Hi\\end{document}")
+        z.writestr("figures/pad.bin", bytes(range(256)) * 4 * kb, compress_type=zipfile.ZIP_STORED)
+    return str(p)
+
+
+def test_overleaf_button_posts_the_project_itself(tmp_path):
+    p = _zip(tmp_path)
+    h = FMT.overleaf_html(p)
+    assert '<form action="https://www.overleaf.com/docs" method="post" target="_blank"' in h
+    assert 'name="engine" value="pdflatex"' in h and 'name="main_document" value="main.tex"' in h
+    data = h.split('name="snip_uri" value="', 1)[1].split('"', 1)[0]
+    assert data.startswith("data:application/zip;base64,")
+    back = zipfile.ZipFile(io.BytesIO(base64.b64decode(data.split(",", 1)[1])))
+    assert "main.tex" in back.namelist()                    # exactly the project the customer downloads
+    assert "Upload Project" in h                            # and the manual route is always explained
+
+
+def test_a_large_project_goes_by_its_address_or_by_hand(tmp_path, monkeypatch):
+    p = _zip(tmp_path, kb=64)
+    monkeypatch.setattr(FMT, "OVERLEAF_EMBED_MB", 0.01)
+    monkeypatch.setenv("SPACE_HOST", "rasheed-ai-writing-suite.hf.space")
+    h = FMT.overleaf_html(p)
+    assert "<form" not in h and "snip_uri=https%3A%2F%2Frasheed-ai-writing-suite.hf.space%2Fgradio_api%2Ffile%3D" in h
+    assert "main_document=main.tex" in h and "engine=pdflatex" in h
+    monkeypatch.delenv("SPACE_HOST")
+    monkeypatch.delenv("PUBLIC_HOST", raising=False)
+    h = FMT.overleaf_html(p)
+    assert "Open in Overleaf" not in h and "Upload Project" in h
+    assert FMT.overleaf_html(None) == ""
+
+
+# ---------------------------------------------------------------- finder
+def test_finder_files_and_data_are_in_place():
+    assert FND.AVAILABLE
+    data = {f.name for f in (ROOT / "finder" / "data").iterdir()}
+    assert {"ext_list_Jul_2026.xlsx", "scimagojr_2025.csv", "J_Medline.txt", "core_conference_ranks.csv"} <= data
+    assert any("ABDC" in n for n in data)
+
+
+def test_job_options_map_to_the_pipeline_flags():
+    sys.path.insert(0, str(ROOT / "finder"))
+    import run_job
+    a = run_job.Args(title="A study of things", terms=["x"], limit=20, top=5, acceptance=False, turnaround=True,
+                     semantic=False, apc=True, quartiles=[1, 2], require_scopus=True, abdc_ranks=["A*", "A"],
+                     fast_days=60, sort_by="speed", special_issues=False)
+    assert a.title == ["A", "study", "of", "things"] and a.term == ["x"] and a.limit == 20 and a.top == 5
+    assert a.no_scrape is True and a.no_turnaround is False and a.no_semantic is True and a.no_apc is False
+    assert a.fast is True and a.quartile == [1, 2] and a.abdc_ranks == ["A*", "A"] and a.fast_days == 60
+    assert a.sort_by == "speed" and callable(a.progress)
+
+
+def test_shortlist_table_is_readable(tmp_path):
+    csv = tmp_path / "shortlist.csv"
+    csv.write_text("display_name,publisher,quartile,quartile_is_proxy,abdc_rank,in_pubmed,acceptance_rate_used,"
+                   "acceptance_days,acceptance_speed,apc_status,apc_usd_est,term_matches,opportunity_score,homepage,"
+                   "openalex_id\n"
+                   "Computers & Security,Elsevier,1,False,,False,0.21,112,Moderate,paid,3200,2,71.234,"
+                   "https://example.org/cs,S1\n"
+                   "Journal of Things,Springer,2,True,A,True,,,,no APC,,1,55.5,https://example.org/jt,S2\n",
+                   encoding="utf-8")
+    view, n = FND._table(csv)
+    assert n == 2 and list(view.columns)[:3] == ["Journal", "Publisher", "Quartile"] and "openalex_id" not in view
+    r1, r2 = view.iloc[0], view.iloc[1]
+    assert r1["Quartile"] == "Q1" and r1["Acceptance rate"] == "21%" and r1["APC"] == "$3,200" and r1["PubMed"] == "—"
+    assert r2["Quartile"] == "Q2 (estimate)" and r2["APC"] == "no APC" and r2["PubMed"] == "yes" and r2["ABDC"] == "A"
+
+
+def test_find_asks_for_a_title_and_a_subject():
+    import gradio as gr
+    blank = ["", [], "", ["Scopus"], [], [], 40, 10, 3, False, 90, "Best fit", True, True, True, True, 0, False]
+    with pytest.raises(gr.Error):
+        FND.find_journals(*blank, progress=progress)
+    blank[0] = "A hybrid deep learning framework for intrusion detection"
+    with pytest.raises(gr.Error):
+        FND.find_journals(*blank, progress=progress)          # title but no subject kept
+    with pytest.raises(gr.Error):
+        FND.detect_terms("too short")
+
+
+def test_both_tabs_are_part_of_the_app():
+    app = pytest.importorskip("app")
+    labels = json.dumps(app.demo.get_config_file(), default=str)
+    assert "Format my manuscript" in labels and "Find journals" in labels and "Work out the subject" in labels
+    assert "cs-go-formatter" in labels and "cs-go-finder" in labels