From 76708ce7676f45d51d2d7c0cd13331174843437e Mon Sep 17 00:00:00 2001 From: govin Date: Tue, 22 Sep 2026 21:50:27 +0800 Subject: [PATCH] =?UTF-8?q?backend:=20print=20the=20=E5=8F=82=E8=80=83?= =?UTF-8?q?=E6=96=87=E7=8C=AE=20list=20as=20a=20bibliography,=20one=20entr?= =?UTF-8?q?y=20per=20work?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The list was printing each citation's quote under a `引用 #53` tag: no authors, no year, no pages, no DOI — the quoted passage where the entry should be — and it numbered *citations*, so a paper with 86 citations to 65 works listed 21 of them two or three times under different numbers. The same article was `[5]` in one paragraph and `[17]` in another. Two rules were wrong, so two are stated here: **A work is numbered where the reader first meets it.** A citation is a place in the text; an entry is a work. `citations` still has one row per place, and each row now carries the number of its *work*, so the marker in the text, the tooltip on it and the entry in the list are the same number. The document grew a `references` list — the entries, in order — and `reference_style`, which names the style that wrote them. **How a reference prints is a property of a style, not of a citation.** The new `app/citation_styles` package holds one module per style; `springer.py` implements Springer's basic style, whose shape is `Names: Title. (year). ` with a branch per document type — a journal with its volume(issue) and pages, a book with publisher and place, a chapter inside somebody else's book, a patent with its number, a page whose URL is its source. Three of its rules are decisions rather than transcription, and each is documented where it applies: up to six contributors are named and more become three plus `et al.`; a journal prints under its 刊名缩写 when the writer stored one, because no algorithm abbreviates an arbitrary title correctly; and a CJK name keeps its printed form even with halves filled in, because dotting 「三」 into an initial is wrong in Chinese and insufficient in English. Nothing is invented to fill a gap. An entry says what it knows and reports the rest as `missing` (「缺 责任者、出版年」), and the document warns about the incomplete ones by number: an entry that is short because fields are empty looks like a fact about the document rather than a library that needs attention. `document_text` had the same bug in the MCP surface and now prints the entries, with in-text markers taken from the document's numbering rather than from each sentence's local position — which is what made the text an agent reads disagree with the list under it. `scripts/check_citation_styles.py` checks the formatter with no server and no database: one reference of every type, and the exact entry the style calls for. --- backend/app/citation_styles/__init__.py | 87 ++++ backend/app/citation_styles/springer.py | 564 +++++++++++++++++++++++ backend/app/crud/paper.py | 113 ++++- backend/app/mcp/support.py | 49 +- backend/app/schemas/__init__.py | 2 + backend/app/schemas/paper.py | 52 ++- backend/scripts/check_citation_styles.py | 435 +++++++++++++++++ backend/scripts/smoke_papers.py | 49 +- 8 files changed, 1305 insertions(+), 46 deletions(-) create mode 100644 backend/app/citation_styles/__init__.py create mode 100644 backend/app/citation_styles/springer.py create mode 100644 backend/scripts/check_citation_styles.py diff --git a/backend/app/citation_styles/__init__.py b/backend/app/citation_styles/__init__.py new file mode 100644 index 0000000..d3e5967 --- /dev/null +++ b/backend/app/citation_styles/__init__.py @@ -0,0 +1,87 @@ +"""Citation styles: a stored reference written out as a bibliography entry. + +A reference is stored as fields — 题名, 刊名, 卷, 期, 页码, DOI, 责任者 — and a +*paper* prints those fields in the order and with the punctuation one particular +style asks for. The two are deliberately separate: the library holds the facts +once, and a style decides how to write them down, so adding a style adds a module +rather than a column. + +The module is one style per file, registered in :data:`STYLES`, and this package +is the only thing the rest of the application imports: + +.. code-block:: python + + from app.citation_styles import DEFAULT_STYLE, format_reference + + text = format_reference(reference) # the default style + gaps = missing_fields(reference) # 「缺 责任者、出版年」 + +``DEFAULT_STYLE`` is what a document is assembled with, and the document reports +it back as ``reference_style`` so a client can name the format it is showing +without hard-coding the choice. +""" + +from typing import Protocol + +from app.citation_styles import springer +from app.models import Reference + + +class Style(Protocol): + """What a style module provides. + + Structural rather than a base class: a style is a module of two functions, + and inheriting from something would only add an import to every one of them. + """ + + def format_reference(self, reference: Reference) -> str: + """Write one reference out as a bibliography entry.""" + + def missing_fields(self, reference: Reference) -> list[str]: + """Which parts a complete entry is missing, in Chinese.""" + + +#: The styles this build can print, by the token a document reports. +STYLES: dict[str, Style] = {"springer": springer} + +#: The style a document is assembled with when nothing says otherwise. +#: +#: Springer's basic style: bracketed numerals in the text, a numbered list at the +#: end, and entries of the shape ``Names: Title. (year). ``. +DEFAULT_STYLE = "springer" + + +def _style(name: str): + """Look a style up, or say which ones exist.""" + try: + return STYLES[name] + except KeyError: + known = "、".join(sorted(STYLES)) + raise ValueError(f"未知的参考文献格式:{name}(可用:{known})") from None + + +def format_reference(reference: Reference | None, style: str = DEFAULT_STYLE) -> str: + """Write one reference out as a bibliography entry. + + ``None`` — a citation whose row the library no longer has — yields the empty + string rather than a fabricated entry: the caller decides how to say + "unlinked", and this module never guesses. + """ + if reference is None: + return "" + return _style(style).format_reference(reference) + + +def missing_fields(reference: Reference | None, style: str = DEFAULT_STYLE) -> list[str]: + """Which parts a complete entry is missing, in the style's own terms.""" + if reference is None: + return [] + return _style(style).missing_fields(reference) + + +__all__ = [ + "DEFAULT_STYLE", + "STYLES", + "format_reference", + "missing_fields", +] diff --git a/backend/app/citation_styles/springer.py b/backend/app/citation_styles/springer.py new file mode 100644 index 0000000..9061fe3 --- /dev/null +++ b/backend/app/citation_styles/springer.py @@ -0,0 +1,564 @@ +"""Springer basic style: one stored reference, written out as a bibliography entry. + +Springer's **basic** style is the numbered one — bracketed numerals in the text +and a numbered list at the end — which is the shape this project already has. +What it adds is the layout of the entry itself, taken from Springer's own +examples: + +.. code-block:: text + + Van der Geer, J., Hanraads, J.A.J., Lupton, R.A.: The art of writing a + scientific article. J. Sci. Commun. 163(2), 51–59 (2010). + https://doi.org/10.1016/j.Sc.2010.00372 + + Strunk Jr., W., White, E.B.: The Elements of Style, 4th edn. Longman, + New York (2000) + + Mettam, G.R., Adams, L.B.: How to prepare an electronic version of your + article. In: Jones, B.S., Smith, R.Z. (eds.) Introduction to the Electronic + Age, pp. 281–304. E-Publishing Inc., New York (2009) + +So an entry is ``Names: Title. (year). ``, +and *where it sits* is the only part that changes with the document type: a +journal with its volume and pages, a book with its publisher, a chapter inside +somebody else's book, a patent with its number. + +Three rules here are decisions rather than transcription, and each is stated +where it is applied: + +* **Up to six contributors are named; more become the first three and + ``et al.``** — Springer's rule for this style. +* **A journal prints under its 刊名缩写 when the writer stored one**, because + Springer abbreviates journal titles and no algorithm abbreviates an arbitrary + title correctly: the library has a column for the abbreviation precisely so a + human decides it. Without one, the full 刊名 is printed rather than an + invention. +* **A CJK name is printed as stored**, halves or no halves: dotting 「三」 into + an initial is wrong in Chinese and insufficient in English (see + :func:`_name`). +* **Nothing is invented to fill a gap.** A missing year prints no parentheses, a + missing publisher no publisher; the field simply does not appear. What a + complete entry would need is reported separately by :func:`missing_fields`, so + the writer is told what is absent instead of being shown a plausible-looking + fabrication. +""" + +from __future__ import annotations + +import re +from datetime import date +from typing import Callable + +from app.models import Reference, ReferenceAuthor + +#: How many contributors are named before the list is cut short, and how many +#: survive the cut. Springer's basic style names up to six, then the first three +#: followed by ``et al.`` +_AUTHOR_LIMIT = 6 +_AUTHOR_KEEP = 3 + +#: ``122-141`` → ``122–141``. Springer prints ranges with an en dash, and the +#: stored value is whatever the writer pasted — often a plain hyphen. +_PAGE_RANGE = re.compile(r"(\d+)\s*[-–—]\s*(\d+)") + +#: CJK ideographs and kana. A name containing one is printed as stored rather +#: than inverted and initialised; see :func:`_name`. +_CJK = re.compile(r"[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]") + +_MONTHS = ( + "January", + "February", + "March", + "April", + "May", + "June", + "July", + "August", + "September", + "October", + "November", + "December", +) + +#: For a web page the URL *is* the source, so it is printed where a journal +#: would be rather than at the end as an identifier. Every other type keeps the +#: URL for the trailing ``https://doi.org/…`` slot. +_URL_IS_THE_SOURCE = frozenset({"web-page"}) + + +def format_reference(reference: Reference) -> str: + """Write one reference out as a Springer bibliography entry. + + The clauses are assembled and joined by ``". "``, which is the style's own + punctuation: the colon after the names, the period between the title and + where the entry sits, and the period before the DOI all fall out of it. + """ + clauses = [ + clause + for clause in ( + _head(reference), + *_where(reference), + _identifier(reference), + _accessed(reference), + ) + if clause + ] + + # A clause that is nothing but a year is not a sentence, so it attaches to + # what precedes it rather than following a full stop. This is the shape a + # reference with a title and a year and nothing else takes: "…: Six (2021)", + # not "…: Six. (2021)". Doing it here rather than in each of the fourteen + # builders is one rule instead of fourteen chances to forget it. + parts: list[str] = [] + for clause in clauses: + if parts and clause.startswith("(") and clause.endswith(")"): + parts[-1] = f"{parts[-1]} {clause}" + else: + parts.append(clause) + return ". ".join(parts) + + +# --- the two halves every entry has ------------------------------------------ + + +def _head(reference: Reference) -> str: + """``Names: Title`` — what the entry is, and who wrote it.""" + names = _head_names(reference) + title = _title(reference) + return f"{names}: {title}" if names else title + + +def _title(reference: Reference) -> str: + """The title, with its subtitle after a colon. + + The library stores 副题名 as its own column because a citation style is + allowed to drop it; this one prints it, so the two are joined back into the + title the reader saw. + """ + title = _clean(reference.title) + subtitle = _clean(reference.subtitle) + if subtitle and not title.endswith((":", ":")): + title = f"{title}: {subtitle}" + elif subtitle: + title = f"{title} {subtitle}" + + # For a whole book the edition belongs to the title ("The Elements of + # Style, 4th edn"); for a chapter it belongs to the book it sits in, which + # is where :func:`_where_chapter` puts it. + if reference.type == "book" and _clean(reference.edition): + title = f"{title}, {_clean(reference.edition)}" + return title + + +def _head_names(reference: Reference) -> str: + """The contributors that lead the entry. + + Authors first. A book whose contributors are all marked 编者 is written by + its editors — ``Jones, B.S. (ed.)`` — and a 汇编 / 译者 with no author at all + still has to appear somewhere, so the last resort is the stored list in + print order. + """ + authors = [author for author in reference.authors if author.role == "author"] + if authors: + return _name_list(authors) + + editors = [author for author in reference.authors if author.role == "editor"] + if editors: + return _name_list(editors) + (" (ed.)" if len(editors) == 1 else " (eds.)") + + return _name_list(list(reference.authors)) + + +def _editor_names(reference: Reference) -> str: + """The 编者 of a chapter's containing book, marked ``(ed.)`` / ``(eds.)``. + + The library keeps one contributor list per entry, so these are the + contributors the writer marked 编者. When there are none the container is + printed without a mark rather than guessing whose book it is. + """ + editors = [author for author in reference.authors if author.role == "editor"] + if not editors: + return "" + mark = " (ed.)" if len(editors) == 1 else " (eds.)" + return _name_list(editors) + mark + + +def _name_list(people: list[ReferenceAuthor]) -> str: + """The contributor list, cut to Springer's limit.""" + names = [_name(person) for person in people if person.name.strip()] + if len(names) > _AUTHOR_LIMIT: + return ", ".join(names[:_AUTHOR_KEEP]) + ", et al." + return ", ".join(names) + + +def _name(person: ReferenceAuthor) -> str: + """One contributor as ``Family, I.N.`` + + The halves are the authority for rewriting a name and the whole ``name`` is + the authority for printing it, as the model says. So a row with Latin halves + is inverted and initialised — some of them arrive already abbreviated + (``Lai KK`` → ``Lai, K.K.``) — while a row without them is printed exactly as + stored, which is the only correct thing to do for an institutional author + (「世界卫生组织」, "World Health Organization") and for a CJK name whose + romanisation the library was never told. + + A CJK name keeps its printed form even *with* halves filled in. ``张`` + + ``三`` inverted and dotted gives 「张, 三.」, which is neither Chinese nor + English: an initial is a Latin-script idea, and 「三」 is not the initial of + a given name, it is the whole of it. Springer's own ``Zhang, S.`` needs a + romanisation this library does not hold, so the stored 「张三」 is printed + rather than turned into something that is wrong in both languages. + """ + family = _clean(person.family_name) + given = _clean(person.given_name) + if not family or _CJK.search(family) or _CJK.search(given): + return _clean(person.name) + initials = _initials(given) + return f"{family}, {initials}" if initials else family + + +def _initials(given: str) -> str: + """``Yong Ming`` → ``Y.M.``, ``AL`` → ``A.L.``, ``Jean-Luc`` → ``J.-L.``""" + if not given: + return "" + + initials: list[str] = [] + for token in given.split(): + parts = [part for part in re.split(r"[-–]", token) if part] + if len(parts) > 1: + initials.append("-".join(_initial(part) for part in parts)) + else: + initials.append(_initial(token)) + return "".join(part for part in initials if part) + + +def _initial(token: str) -> str: + """One given-name token as initials. + + A token that is already a block of initials is expanded letter by letter — + ``KK`` is two names, not one — and a token that is a name contributes its + first letter. + """ + letters = [character for character in token if character.isalpha()] + if not letters: + return "" + if len(letters) > 1 and token.isupper(): + return "".join(f"{character.upper()}." for character in letters) + return f"{letters[0].upper()}." + + +# --- where the entry sits ---------------------------------------------------- + + +def _where(reference: Reference) -> list[str]: + """The clauses between the title and the identifier, by document type.""" + builder: Callable[[Reference], list[str]] = _WHERE.get( + reference.type, _where_generic + ) + return builder(reference) + + +def _where_journal(reference: Reference) -> list[str]: + """``J. Sci. Commun. 163(2), 51–59 (2010)``""" + source = _join_space(_container(reference), _volume_issue(reference)) + source = _join_comma(source, _pages(reference)) + return [_with_year(source, reference)] + + +def _where_newspaper(reference: Reference) -> list[str]: + """``The Times, p. 12 (2020)`` — a newspaper has a date, not a volume.""" + source = _join_comma(_container(reference), _pages(reference)) + return [_with_year(source, reference)] + + +def _where_book(reference: Reference) -> list[str]: + """``Longman, New York (2000)``, with the series ahead of it.""" + clauses = [] + series = _join_comma(_clean(reference.series_title), _clean(reference.series_number)) + if series: + clauses.append(series) + place = _join_comma(_clean(reference.publisher), _clean(reference.publisher_place)) + clauses.append(_with_year(place, reference)) + return [clause for clause in clauses if clause] + + +def _where_chapter(reference: Reference) -> list[str]: + """``In: Jones, B.S. (ed.) Book title, pp. 281–304. E-Publishing Inc., New York (2009)``""" + inside = _container(reference) + if inside and _clean(reference.edition): + inside = f"{inside}, {_clean(reference.edition)}" + pages = _pages(reference) + if pages: + inside = _join_comma(inside, f"pp. {pages}") + + editors = _editor_names(reference) + inside = _join_space(editors, inside) if editors else inside + opening = f"In: {inside}" if inside else "" + + place = _with_year( + _join_comma(_clean(reference.publisher), _clean(reference.publisher_place)), + reference, + ) + return [clause for clause in (opening, place) if clause] + + +def _where_conference(reference: Reference) -> list[str]: + """``In: Proceedings of …, pp. 10–20. Springer, Cham (2022)``""" + inside = _container(reference) or _clean(reference.event_title) + pages = _pages(reference) + if pages: + inside = _join_comma(inside, f"pp. {pages}") + opening = f"In: {inside}" if inside else "" + + place = _with_year( + _join_comma( + _clean(reference.publisher), + _clean(reference.publisher_place) or _clean(reference.event_place), + ), + reference, + ) + return [clause for clause in (opening, place) if clause] + + +def _where_thesis(reference: Reference) -> list[str]: + """``Thesis, 清华大学 (2020)`` + + The degree (PhD, 硕士) is not a field of this library, so the entry says + what it knows rather than inventing a doctorate. + """ + return [_with_year(_join_comma("Thesis", _clean(reference.publisher)), reference)] + + +def _where_patent(reference: Reference) -> list[str]: + """``中国 Patent CN114000000A (2023)`` — the country and number inside the mark.""" + mark = _join_space(_clean(reference.patent_country), "Patent") + marked = _join_space(mark, _clean(reference.patent_number)) + return [_with_year(marked, reference)] + + +def _where_standard(reference: Reference) -> list[str]: + """``GB/T 7714-2015. 中国标准出版社, 北京 (2015)`` + + The number follows the title rather than leading the entry: the title is + what the writer searched by and what the reader recognises. + """ + number = _clean(reference.standard_number) + place = _with_year( + _join_comma(_clean(reference.publisher), _clean(reference.publisher_place)), + reference, + ) + return [clause for clause in (number, place) if clause] + + +def _where_report(reference: Reference) -> list[str]: + """``NREL/TP-5000-12345, NREL, Golden (2012)``""" + clause = _join_comma( + _clean(reference.report_number), + _clean(reference.publisher), + _clean(reference.publisher_place), + ) + return [_with_year(clause, reference)] + + +def _where_web(reference: Reference) -> list[str]: + """``https://… (2021)`` — for a page the URL is where the entry sits.""" + return [_with_year(_clean(reference.url), reference)] + + +def _where_dataset(reference: Reference) -> list[str]: + """``Dataset (2024)`` — the type stands where a journal name would.""" + return [_with_year("Dataset", reference)] + + +def _where_software(reference: Reference) -> list[str]: + """``Software (2024)``""" + return [_with_year("Software", reference)] + + +def _where_preprint(reference: Reference) -> list[str]: + """``Preprint arXiv:2405.12345 (2024)`` — how a paper is cited before a DOI.""" + return [_with_year(_join_space("Preprint", _clean(reference.arxiv_id)), reference)] + + +def _where_generic(reference: Reference) -> list[str]: + """Anything typed ``other``: the container, then the publisher. + + The year closes whichever of the two is the last thing printed, so it never + dangles on its own in the middle of an entry. + """ + source = _join_comma(_container(reference), _pages(reference)) + place = _join_comma(_clean(reference.publisher), _clean(reference.publisher_place)) + if place: + return [clause for clause in (source, _with_year(place, reference)) if clause] + return [_with_year(source, reference)] + + +_WHERE: dict[str, Callable[[Reference], list[str]]] = { + "journal-article": _where_journal, + "newspaper-article": _where_newspaper, + "book": _where_book, + "book-chapter": _where_chapter, + "conference-paper": _where_conference, + "thesis": _where_thesis, + "patent": _where_patent, + "standard": _where_standard, + "report": _where_report, + "web-page": _where_web, + "dataset": _where_dataset, + "software": _where_software, + "preprint": _where_preprint, +} + + +# --- the identifier, and the day it was read --------------------------------- + + +def _identifier(reference: Reference) -> str: + """``https://doi.org/10.1016/j.Sc.2010.00372``, or the URL, or nothing. + + A DOI is printed as the resolvable link, which is how Springer prints it — + the column stores it bare so the two spellings cannot drift. + """ + doi = _clean(reference.doi) + if doi: + return f"https://doi.org/{doi}" + if reference.type in _URL_IS_THE_SOURCE: + return "" + return _clean(reference.url) + + +def _accessed(reference: Reference) -> str: + """``Accessed 12 May 2021`` — the day an online resource was read.""" + if reference.accessed_date is None: + return "" + return f"Accessed {_long_date(reference.accessed_date)}" + + +def _long_date(value: date) -> str: + return f"{value.day} {_MONTHS[value.month - 1]} {value.year}" + + +# --- what a complete entry is still missing ---------------------------------- + + +#: The fields a complete entry needs, per type. ``None`` means "this type has no +#: such field", so the list is not padded with requirements that do not apply. +_REQUIRED: dict[str, tuple[str, ...]] = { + "journal-article": ("责任者", "刊名", "卷期页码", "出版年"), + "newspaper-article": ("责任者", "报纸名", "页码", "出版年"), + "book": ("责任者", "出版者", "出版年"), + "book-chapter": ("责任者", "书名", "页码", "出版者", "出版年"), + "conference-paper": ("责任者", "会议名", "出版年"), + "thesis": ("责任者", "培养单位", "出版年"), + "patent": ("责任者", "专利号", "出版年"), + "standard": ("标准编号", "出版年"), + "report": ("责任者", "报告编号", "出版年"), + "web-page": ("URL", "引用日期"), + "dataset": ("URL", "出版年"), + "software": ("URL", "出版年"), + "preprint": ("责任者", "出版年"), + "other": ("责任者", "出版年"), +} + + +def missing_fields(reference: Reference) -> list[str]: + """Which parts of a complete entry this reference still lacks, in Chinese. + + The point is that a gap should be *reported* rather than quietly rendered as + a shorter entry: an entry with no author and no year looks like a fact about + the document instead of a field nobody filled in. + """ + missing: list[str] = [] + for field in _REQUIRED.get(reference.type, _REQUIRED["other"]): + if not _has(reference, field): + missing.append(field) + return missing + + +def _has(reference: Reference, field: str) -> bool: + """Whether the field this label names is filled in.""" + if field == "责任者": + return bool(reference.authors) + if field == "刊名" or field == "报纸名" or field == "会议名" or field == "书名": + # A chapter's 书名 and a paper's 论文集名 are both the container; a + # conference may carry its meeting name instead. + return bool( + _clean(reference.container_title) + or (field == "会议名" and _clean(reference.event_title)) + ) + if field == "卷期页码": + return bool( + _clean(reference.volume) + or _clean(reference.issue) + or _clean(reference.pages) + or _clean(reference.article_number) + ) + if field == "页码": + return bool(_clean(reference.pages) or _clean(reference.article_number)) + if field == "出版者" or field == "培养单位": + return bool(_clean(reference.publisher)) + if field == "标准编号": + return bool(_clean(reference.standard_number)) + if field == "报告编号": + return bool(_clean(reference.report_number) or _clean(reference.publisher)) + if field == "专利号": + return bool(_clean(reference.patent_number)) + if field == "URL": + return bool(_clean(reference.url) or _clean(reference.doi)) + if field == "引用日期": + return reference.accessed_date is not None + if field == "出版年": + return reference.publication_year is not None + return True + + +# --- small helpers ----------------------------------------------------------- + + +def _clean(value: str | None) -> str: + """Whitespace folded, or ``""`` — so a blank field is simply absent.""" + if value is None: + return "" + return " ".join(value.split()) + + +def _container(reference: Reference) -> str: + """The journal or book the entry sits in. + + The abbreviation wins when the writer stored one: Springer abbreviates + journal titles, and an algorithm cannot abbreviate an arbitrary title + correctly, so the 刊名缩写 column is where a human decides it. + """ + return _clean(reference.container_title_short) or _clean(reference.container_title) + + +def _volume_issue(reference: Reference) -> str: + """``163(2)``, ``163``, ``(2)`` or nothing.""" + volume = _clean(reference.volume) + issue = _clean(reference.issue) + if volume and issue: + return f"{volume}({issue})" + return volume or (f"({issue})" if issue else "") + + +def _pages(reference: Reference) -> str: + """``51–59`` with an en dash, or the article number when there is no page.""" + pages = _clean(reference.pages) + if pages: + return _PAGE_RANGE.sub(lambda match: f"{match.group(1)}–{match.group(2)}", pages) + return _clean(reference.article_number) + + +def _with_year(clause: str, reference: Reference) -> str: + """``Journal 163(2), 51–59 (2010)`` — the year closes the clause it follows.""" + if reference.publication_year is None: + return clause + return f"{clause} ({reference.publication_year})" if clause else f"({reference.publication_year})" + + +def _join_comma(*parts: str) -> str: + return ", ".join(part for part in parts if part) + + +def _join_space(*parts: str) -> str: + return " ".join(part for part in parts if part) diff --git a/backend/app/crud/paper.py b/backend/app/crud/paper.py index 7b716b8..7f959cf 100644 --- a/backend/app/crud/paper.py +++ b/backend/app/crud/paper.py @@ -21,6 +21,12 @@ all three behaviours the feature needs: Deleting is done in Python rather than with ``ON DELETE CASCADE`` because TiDB parses foreign keys and then ignores them; the ORM's cascades are the only thing that actually removes dependent rows. + +The 参考文献 list is assembled in the same pass, and by the same rule: a work is +numbered where the reader first meets it, however many times it is cited +afterwards. The entries themselves are written by :mod:`app.citation_styles`, +because how a reference prints is a property of a style rather than of a +citation. """ from collections import defaultdict @@ -31,6 +37,7 @@ from sqlalchemy import func, or_, select from sqlalchemy import update as sa_update from sqlalchemy.orm import Session +from app.citation_styles import DEFAULT_STYLE, format_reference, missing_fields from app.crud import reference as reference_crud from app.crud.filters import LIKE_ESCAPE, like_pattern from app.models import ( @@ -47,6 +54,7 @@ from app.schemas.paper import ( PaperDocumentRead, PaperListItem, PaperRead, + PaperReferenceRead, ParagraphRead, ParagraphUpdate, SentenceCreate, @@ -329,9 +337,71 @@ def build_document(db: Session, paper: Paper) -> PaperDocumentRead: # --- 3. the union, in ascending position order -------------------------- positions = sorted(set(placement_by_sort) | set(sentences_by_sort)) + # --- 4. the literature the document cites, in one query ----------------- + # + # The 参考文献 list is assembled here rather than by the client, for the same + # reason the paragraph order is: "which work is number 7" is a rule, and two + # implementations of a rule eventually disagree. Formatting needs the rows + # themselves — authors, container, pages, DOI — so they are loaded up front, + # once, with their contributors. + cited_ids = { + citation.reference_id + for sentence in paper.sentences + for citation in sentence.citations + if citation.reference_id is not None + } + cited_references = { + row.id: row for row in reference_crud.get_many(db, sorted(cited_ids)) + } + if len(cited_references) != len(cited_ids): + # Only reachable if a citation points at a row the library no longer has, + # which the foreign key is there to prevent — so it is a warning rather + # than a crash, and the entries below print as unlinked. + warnings.append( + f"有 {len(cited_ids) - len(cited_references)} 条引用指向的文献已不在库中," + "参考文献表中只保留了引用位置。" + ) + paragraphs: list[ParagraphRead] = [] citations: list[PaperCitationRead] = [] - citation_index = 0 + references: list[PaperReferenceRead] = [] + + #: Work → its entry in the list above. Keyed by reference id, because that is + #: what "the same work" means; a citation with no id at all is its own work + #: and is keyed by its citation id so it still gets one entry and one number. + entry_by_work: dict[object, PaperReferenceRead] = {} + + def entry_for(citation: PaperSentenceReference) -> PaperReferenceRead: + """The entry this citation belongs to, numbering it on first sight. + + Numbering on first *sight* rather than on first citation is the whole + rule: the entries come out in the order the reader meets the works, and a + work met again keeps the number it already had. + """ + key: object = ( + ("reference", citation.reference_id) + if citation.reference_id is not None + else ("citation", citation.id) + ) + existing = entry_by_work.get(key) + if existing is not None: + return existing + + reference = ( + cited_references.get(citation.reference_id) + if citation.reference_id is not None + else None + ) + entry = PaperReferenceRead( + index=len(references) + 1, + reference_id=citation.reference_id, + text=format_reference(reference), + missing=missing_fields(reference), + citations=[], + ) + entry_by_work[key] = entry + references.append(entry) + return entry for position in positions: placement = placement_by_sort.get(position) @@ -363,30 +433,43 @@ def build_document(db: Session, paper: Paper) -> PaperDocumentRead: sentences=sentences, ) - # Citations are numbered in reading order, so a marker in the text and - # its entry in the 参考文献 list cannot disagree. + # Citations are numbered in reading order and by work, so a marker in the + # text and its entry in the 参考文献 list cannot disagree. for sentence in sentences: for citation in sentence.citations: - citation_index += 1 - citations.append( - PaperCitationRead( - index=citation_index, - id=citation.id, - reference_id=citation.reference_id, - quote=citation.quote, - sentence_id=sentence.id, - sentence_content=sentence.content, - paper_template_filed_sort=position, - paragraph_name=paragraph.name, - ) + entry = entry_for(citation) + row = PaperCitationRead( + index=entry.index, + id=citation.id, + reference_id=citation.reference_id, + quote=citation.quote, + sentence_id=sentence.id, + sentence_content=sentence.content, + paper_template_filed_sort=position, + paragraph_name=paragraph.name, ) + citations.append(row) + entry.citations.append(row) paragraphs.append(paragraph) + unlinked = sum(1 for entry in references if entry.reference_id is None) + if unlinked: + warnings.append( + f"有 {unlinked} 处引用还没有关联文献库条目,参考文献表中缺少它们的条目。" + ) + + incomplete = [entry for entry in references if entry.missing] + if incomplete: + numbers = "、".join(f"[{entry.index}]" for entry in incomplete) + warnings.append(f"参考文献 {numbers} 的字段不完整,条目里会缺少相应信息。") + return PaperDocumentRead( paper=read(paper), paragraphs=paragraphs, citations=citations, + references=references, + reference_style=DEFAULT_STYLE, warnings=warnings, ) diff --git a/backend/app/mcp/support.py b/backend/app/mcp/support.py index c36da55..5861026 100644 --- a/backend/app/mcp/support.py +++ b/backend/app/mcp/support.py @@ -34,7 +34,7 @@ from __future__ import annotations import json import re -from collections.abc import Iterator, Sequence +from collections.abc import Iterator, Mapping, Sequence from contextlib import contextmanager from datetime import date, datetime from decimal import Decimal @@ -277,19 +277,37 @@ def paragraph_row(paragraph: ParagraphRead, *, preview: int = 80) -> dict: } -def paragraph_text(paragraph: ParagraphRead, *, citations: bool = False) -> str: +def paragraph_text( + paragraph: ParagraphRead, + *, + citations: bool = False, + index_by_citation: Mapping[int, int] | None = None, +) -> str: """Print one paragraph exactly as the document renders it. ``separator_before`` is added, not invented: the server decided what belongs at each seam, so a tool result and the paper view agree on where the spaces go. Nothing here adds spacing of its own. + + A marker's number comes from ``index_by_citation`` — the citation's *work* + number as the whole document assigned it, not its position in this sentence — + so what is printed in the text matches the 参考文献 list it points at. Read + without that map there is no document to number against, and the marker + falls back to the citation's place in the sentence. """ parts: list[str] = [] for sentence in paragraph.sentences: parts.append(sentence.separator_before + sentence.content) if citations and sentence.citations: - markers = ",".join(str(index) for index in range(1, len(sentence.citations) + 1)) - parts.append(f"[{markers}]") + numbers = [ + str( + index_by_citation.get(citation.id, position) + if index_by_citation is not None + else position + ) + for position, citation in enumerate(sentence.citations, start=1) + ] + parts.append(f"[{','.join(numbers)}]") return "".join(parts) @@ -306,22 +324,31 @@ def document_text( three rules the paper view renders by, applied here so a single tool call can hand a model the finished manuscript. """ + # Citation id → the number of the work it cites, so the markers printed in + # the text are the numbers the list below uses. + index_by_citation = {row.id: row.index for row in document.citations} + lines: list[str] = [] for paragraph in document.paragraphs: - body = paragraph_text(paragraph, citations=citations) + body = paragraph_text( + paragraph, citations=citations, index_by_citation=index_by_citation + ) if not body and not include_empty: continue lines.append(paragraph.name if paragraph.matched and paragraph.name else "未设定") lines.append(body) lines.append("") - if citations and document.citations: + if citations and document.references: + # The entries, not the quotes: a 参考文献 list is a bibliography, and the + # one assembled above already carries each work once, numbered as the + # text numbers it. A work whose library row is missing prints the gap + # rather than a fabricated entry. lines.append("参考文献") - for citation in document.citations: - reference = ( - f"[{citation.reference_id}]" if citation.reference_id else "" - ) - lines.append(f"[{citation.index}]{reference} {citation.quote}") + for entry in document.references: + text = entry.text or "(未关联文献库条目)" + note = f"(缺 {'、'.join(entry.missing)})" if entry.missing else "" + lines.append(f"[{entry.index}] {text}{note}") lines.append("") text = "\n".join(lines).rstrip("\n") diff --git a/backend/app/schemas/__init__.py b/backend/app/schemas/__init__.py index 01354c9..d0de746 100644 --- a/backend/app/schemas/__init__.py +++ b/backend/app/schemas/__init__.py @@ -14,6 +14,7 @@ from app.schemas.paper import ( PaperDocumentRead, PaperListItem, PaperRead, + PaperReferenceRead, PaperStatus, PaperUpdate, ParagraphListRead, @@ -75,6 +76,7 @@ __all__ = [ "PaperDocumentRead", "PaperListItem", "PaperRead", + "PaperReferenceRead", "PaperStatus", "PaperUpdate", "ParagraphListRead", diff --git a/backend/app/schemas/paper.py b/backend/app/schemas/paper.py index 8d8e951..3cca11b 100644 --- a/backend/app/schemas/paper.py +++ b/backend/app/schemas/paper.py @@ -8,8 +8,8 @@ Three shapes of payload live here: reading every sentence of it and writing the whole set back, so the update schema is a full replacement; * the **document** — what the reader sees: the template's paragraphs in order, - each carrying the sentences stored at its position, plus the flat citation - list for the 参考文献 block. + each carrying the sentences stored at its position, plus the 参考文献 list, + already formatted in one citation style. Text normalisation is deliberately strict, because the two sides of the wire have to agree on what counts as empty: @@ -27,6 +27,8 @@ from typing import Literal from pydantic import BaseModel, ConfigDict, Field, field_validator +from app.citation_styles import DEFAULT_STYLE as DEFAULT_REFERENCE_STYLE + #: Writing states, mirroring :data:`app.models.paper.PAPER_STATUSES`. Kept as a #: literal so the generated OpenAPI document describes the enum for clients. PaperStatus = Literal["draft", "writing", "done"] @@ -200,11 +202,13 @@ class ParagraphRead(BaseModel): class PaperCitationRead(BaseModel): - """One citation as it appears in the paper's 参考文献 list. + """One citation — one place in the text where one work is cited. - ``index`` is the number shown in the text as ``[index]``; it counts - citations in reading order across the whole document, so the list and the - markers cannot disagree. + A citation is not a row of the 参考文献 list, and this is the difference that + matters: a paper that cites the same article in three sentences has three + citations and **one** entry, so ``index`` is the number of the *work* and is + shared by all three. The in-text markers and the list therefore cannot + disagree about what ``[7]`` means. """ index: int @@ -217,6 +221,30 @@ class PaperCitationRead(BaseModel): paragraph_name: str | None = None +class PaperReferenceRead(BaseModel): + """One entry of the 参考文献 list: one work, however often it is cited. + + ``text`` is the entry as it prints — the whole point of the list — and it is + assembled by :mod:`app.citation_styles` rather than by a client, so the paper + view, an export and an agent all print the same bibliography. + """ + + #: The number the text shows as ``[index]``, assigned in order of first + #: appearance so the list reads in the order the reader meets the works. + index: int + #: The library row it came from, or ``None`` for a citation written before + #: the literature was entered. + reference_id: int | None + #: The formatted entry, or ``""`` when there is no library row to print. + text: str + #: Which parts a complete entry still lacks, in Chinese — 责任者、出版年、DOI… + #: Empty for a complete entry, and empty for an unlinked one, where the + #: question is not what is missing but what this is. + missing: list[str] = Field(default_factory=list) + #: Every place it is cited, in reading order. + citations: list[PaperCitationRead] = Field(default_factory=list) + + class PaperBase(BaseModel): """Shared body of the paper create payload.""" @@ -342,8 +370,18 @@ class PaperDocumentRead(BaseModel): #: template or a sentence mentions appears exactly once, so an empty #: paragraph is still a paragraph — the structure survives with no content. paragraphs: list[ParagraphRead] - #: Citations in reading order, numbered to match the in-text markers. + #: Citations in reading order, each carrying the number of the work it cites. + #: One row per place in the text, not per work: this is what renders the + #: in-text markers. citations: list[PaperCitationRead] + #: The 参考文献 list: one entry per work, numbered in order of first + #: appearance, already formatted. A client prints these and does not group, + #: sort or assemble them — two implementations of the same rules would + #: eventually print two different bibliographies. + references: list[PaperReferenceRead] = Field(default_factory=list) + #: The citation style the entries were written in, so a client can name it + #: without hard-coding the choice (see ``app.citation_styles``). + reference_style: str = DEFAULT_REFERENCE_STYLE #: Anything the reader should be told about the document as a whole, e.g. #: a template that places two fields at the same position. warnings: list[str] = Field(default_factory=list) diff --git a/backend/scripts/check_citation_styles.py b/backend/scripts/check_citation_styles.py new file mode 100644 index 0000000..0611a44 --- /dev/null +++ b/backend/scripts/check_citation_styles.py @@ -0,0 +1,435 @@ +"""Check the citation formatter against one reference of every type. + +Run it with no server and no database:: + + .venv/bin/python scripts/check_citation_styles.py + +The formatter is pure — a reference in, a printed entry out — so unlike the +``smoke_*`` scripts this one needs nothing running. It builds a reference of each +document type in memory, asserts the exact entry Springer's basic style calls +for, and exits non-zero on the first entry that does not match. + +Why it exists: the style has one branch per document type, and a branch that is +wrong prints something that *looks* like a bibliography entry rather than +failing loudly. A paper citing a patent would show a plausible-looking, +incorrect line. Nineteen assertions is a cheap way to keep that from happening. +""" + +from __future__ import annotations + +import sys +from datetime import date +from pathlib import Path + +# Running this as a plain script puts scripts/ on sys.path, not backend/, so +# `import app` would fail. Anchor to the backend directory instead. +BACKEND_DIR = Path(__file__).resolve().parents[1] +if str(BACKEND_DIR) not in sys.path: + sys.path.insert(0, str(BACKEND_DIR)) + +from app.citation_styles import ( # noqa: E402 + DEFAULT_STYLE, + STYLES, + format_reference, + missing_fields, +) +from app.models import Reference, ReferenceAuthor # noqa: E402 + +_checks = 0 + + +def check(label: str, actual: str, expected: str) -> None: + """Assert one printed entry, showing both sides when it differs.""" + global _checks + _checks += 1 + if actual != expected: + raise AssertionError( + f"{label}\n expected: {expected}\n actual: {actual}" + ) + print(f" ok {label}") + + +def author(name: str, family: str | None = None, given: str | None = None, + role: str = "author") -> ReferenceAuthor: + """One contributor, built in memory — no session, no flush.""" + return ReferenceAuthor( + name=name, family_name=family, given_name=given, role=role, sort=0 + ) + + +def reference(**fields) -> Reference: + """A reference with sensible filled-in defaults, overridden per case.""" + base: dict = { + "type": "journal-article", + "title": "题名", + "authors": [author("Smith J", "Smith", "J")], + } + base.update(fields) + authors = base.pop("authors") + row = Reference(**base) + row.authors = authors + return row + + +def main() -> int: + print(f"style: {DEFAULT_STYLE}(可用:{'、'.join(sorted(STYLES))})") + + print("\n1. a journal article: names, title, journal, volume(issue), pages, year, DOI") + check( + "journal article", + format_reference( + reference( + title="The art of writing a scientific article", + container_title="Journal of Science Communication", + container_title_short="J. Sci. Commun.", + volume="163", + issue="2", + pages="51-59", + publication_year=2010, + doi="10.1016/j.Sc.2010.00372", + authors=[ + author("Van der Geer J", "Van der Geer", "J"), + author("Hanraads JAJ", "Hanraads", "JAJ"), + author("Lupton RA", "Lupton", "RA"), + ], + ) + ), + "Van der Geer, J., Hanraads, J.A.J., Lupton, R.A.: The art of writing a " + "scientific article. J. Sci. Commun. 163(2), 51–59 (2010). " + "https://doi.org/10.1016/j.Sc.2010.00372", + ) + + print("\n2. the abbreviation wins when the writer stored one, and a range gets an en dash") + entry = format_reference( + reference( + title="A paper", + container_title="Full Journal Name", + container_title_short=None, + volume="9", + pages="1000-1010", + publication_year=2020, + ) + ) + check( + "full 刊名 when there is no 缩写", + entry, + "Smith, J.: A paper. Full Journal Name 9, 1000–1010 (2020)", + ) + + print("\n3. more than six contributors become three and et al.") + check( + "seven authors", + format_reference( + reference( + title="A crowded paper", + volume="1", + pages="1-2", + publication_year=2021, + authors=[ + author(f"Family{index} A", f"Family{index}", "A") + for index in range(1, 8) + ], + ) + ), + "Family1, A., Family2, A., Family3, A., et al.: A crowded paper. " + "1, 1–2 (2021)", + ) + check( + "six authors are all named", + format_reference( + reference( + title="Six", + publication_year=2021, + authors=[ + author(f"Family{index} A", f"Family{index}", "A") + for index in range(1, 7) + ], + ) + ), + "Family1, A., Family2, A., Family3, A., Family4, A., Family5, A., " + "Family6, A.: Six (2021)", + ) + + print("\n4. names: initials, blocks of initials, hyphens, and no halves at all") + check( + "given names become initials", + format_reference(reference(title="T", authors=[author("Yong Ming Li", "Li", "Yong Ming")], publication_year=2020)), + "Li, Y.M.: T (2020)", + ) + check( + "a block of initials is expanded letter by letter", + format_reference(reference(title="T", authors=[author("Lai KK", "Lai", "KK")], publication_year=2020)), + "Lai, K.K.: T (2020)", + ) + check( + "a hyphenated given name keeps its hyphen", + format_reference(reference(title="T", authors=[author("Dupont JL", "Dupont", "Jean-Luc")], publication_year=2020)), + "Dupont, J.-L.: T (2020)", + ) + check( + "an institutional author is printed as stored", + format_reference(reference(title="T", authors=[author("世界卫生组织")], publication_year=2020)), + "世界卫生组织: T (2020)", + ) + check( + "a CJK name with no halves is not romanised by guesswork", + format_reference(reference(title="T", authors=[author("张三")], publication_year=2020)), + "张三: T (2020)", + ) + check( + "a CJK name keeps its printed form even with halves filled in", + format_reference( + reference( + title="T", + authors=[author("张三", "张", "三")], + publication_year=2020, + ) + ), + "张三: T (2020)", + ) + check( + "editors of a book are marked (ed.)", + format_reference( + reference( + type="book", + title="Edited volume", + publisher="Springer", + publisher_place="Cham", + publication_year=2021, + authors=[author("Jones BS", "Jones", "BS", role="editor")], + ) + ), + "Jones, B.S. (ed.): Edited volume. Springer, Cham (2021)", + ) + + print("\n5. every other document type") + check( + "book with an edition and a series", + format_reference( + reference( + type="book", + title="The Elements of Style", + edition="4th edn", + series_title="Style Guides", + series_number="7", + publisher="Longman", + publisher_place="New York", + publication_year=2000, + authors=[author("Strunk W", "Strunk", "W")], + ) + ), + "Strunk, W.: The Elements of Style, 4th edn. Style Guides, 7. " + "Longman, New York (2000)", + ) + check( + "book chapter, with the book's editors marked", + format_reference( + reference( + type="book-chapter", + title="How to prepare an electronic version of your article", + container_title="Introduction to the Electronic Age", + pages="281-304", + publisher="E-Publishing Inc.", + publisher_place="New York", + publication_year=2009, + authors=[ + author("Mettam GR", "Mettam", "GR"), + author("Adams LB", "Adams", "LB"), + author("Jones BS", "Jones", "BS", role="editor"), + ], + ) + ), + "Mettam, G.R., Adams, L.B.: How to prepare an electronic version of your " + "article. In: Jones, B.S. (ed.) Introduction to the Electronic Age, " + "pp. 281–304. E-Publishing Inc., New York (2009)", + ) + check( + "conference paper", + format_reference( + reference( + type="conference-paper", + title="Crowdsourcing in the tourism industry", + container_title="Proceedings of the 3rd International Conference on Tourism", + pages="1-10", + publisher="Springer", + publisher_place="Cham", + publication_year=2019, + authors=[author("Garrigos-Simon FJ", "Garrigos-Simon", "FJ")], + ) + ), + "Garrigos-Simon, F.J.: Crowdsourcing in the tourism industry. In: " + "Proceedings of the 3rd International Conference on Tourism, pp. 1–10. " + "Springer, Cham (2019)", + ) + check( + "conference paper that only knows its meeting", + format_reference( + reference( + type="conference-paper", + title="A meeting paper", + event_title="第 20 届管理学年会", + event_place="北京", + publication_year=2022, + ) + ), + "Smith, J.: A meeting paper. In: 第 20 届管理学年会. 北京 (2022)", + ) + check( + "thesis", + format_reference( + reference( + type="thesis", + title="A dissertation", + publisher="清华大学", + publisher_place="北京", + publication_year=2020, + ) + ), + "Smith, J.: A dissertation. Thesis, 清华大学 (2020)", + ) + check( + "patent", + format_reference( + reference( + type="patent", + title="一种基于多层聚类的技术识别方法", + patent_country="中国", + patent_number="CN114000000A", + publication_year=2023, + ) + ), + "Smith, J.: 一种基于多层聚类的技术识别方法. 中国 Patent CN114000000A (2023)", + ) + check( + "standard", + format_reference( + reference( + type="standard", + title="信息与文献 参考文献著录规则", + standard_number="GB/T 7714-2015", + publisher="中国标准出版社", + publisher_place="北京", + publication_year=2015, + authors=[], + ) + ), + "信息与文献 参考文献著录规则. GB/T 7714-2015. 中国标准出版社, 北京 (2015)", + ) + check( + "report", + format_reference( + reference( + type="report", + title="Annual technology review", + report_number="NREL/TP-5000-12345", + publisher="NREL", + publisher_place="Golden", + publication_year=2012, + ) + ), + "Smith, J.: Annual technology review. NREL/TP-5000-12345, NREL, Golden (2012)", + ) + check( + "web page, with the day it was read", + format_reference( + reference( + type="web-page", + title="Cancer statistics for the UK", + url="https://www.cancerresearchuk.org/health-professional/cancer-statistics", + publication_year=2021, + accessed_date=date(2021, 5, 12), + authors=[author("Cancer Research UK")], + ) + ), + "Cancer Research UK: Cancer statistics for the UK. " + "https://www.cancerresearchuk.org/health-professional/cancer-statistics " + "(2021). Accessed 12 May 2021", + ) + check( + "dataset", + format_reference( + reference( + type="dataset", + title="Patent citation network", + url="https://doi.org/10.6084/m9.figshare.1234567", + publication_year=2024, + ) + ), + "Smith, J.: Patent citation network. Dataset (2024). " + "https://doi.org/10.6084/m9.figshare.1234567", + ) + check( + "preprint, which has no DOI yet", + format_reference( + reference( + type="preprint", + title="A preprint", + arxiv_id="arXiv:2405.12345", + publication_year=2024, + ) + ), + "Smith, J.: A preprint. Preprint arXiv:2405.12345 (2024)", + ) + check( + "newspaper article", + format_reference( + reference( + type="newspaper-article", + title="A news story", + container_title="The Times", + pages="12", + publication_year=2020, + ) + ), + "Smith, J.: A news story. The Times, 12 (2020)", + ) + check( + "a subtitle rejoins its title", + format_reference( + reference( + title="技术惯性与冲量的耦合机制", + subtitle="基于科学与技术融合网络的实证分析", + volume="198", + pages="122-141", + publication_year=2024, + ) + ), + "Smith, J.: 技术惯性与冲量的耦合机制: 基于科学与技术融合网络的实证分析. " + "198, 122–141 (2024)", + ) + + print("\n6. a gap is reported, not papered over") + check( + "an entry with no year prints no invented year", + format_reference(reference(title="No year", volume="1", pages="1-2")), + "Smith, J.: No year. 1, 1–2", + ) + missing = missing_fields( + reference(title="No year", volume=None, pages=None, container_title=None) + ) + check("the missing fields are named in Chinese", "、".join(missing), "刊名、卷期页码、出版年") + check( + "a complete entry reports nothing missing", + "、".join(missing_fields(reference( + title="Complete", + container_title="A Journal", + volume="1", + pages="1-2", + publication_year=2020, + ))), + "", + ) + check( + "a web page without a URL is told so, in the style's own terms", + "、".join(missing_fields(reference( + type="web-page", title="No address", url=None, doi=None, accessed_date=None + ))), + "URL、引用日期", + ) + + print(f"\nall {_checks} checks passed") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/backend/scripts/smoke_papers.py b/backend/scripts/smoke_papers.py index bef3334..066d2a3 100644 --- a/backend/scripts/smoke_papers.py +++ b/backend/scripts/smoke_papers.py @@ -165,13 +165,36 @@ def main() -> int: check("citations numbered", [c["sort"] for c in paragraph["sentences"][1]["citations"]] == [1, 2]) check("three citations in the paper", len(document["citations"]) == 3) check( - "citation index is reading order", - [c["index"] for c in document["citations"]] == [1, 2, 3], + "a citation carries the number of its work, not of itself", + [c["index"] for c in document["citations"]] == [1, 1, 2], str([c["index"] for c in document["citations"]]), ) + + print("5. the 参考文献 list: one entry per work, in Springer's basic style") + check( + "two works — the article cited twice, and the unlinked quote", + len(document["references"]) == 2, + str(len(document["references"])), + ) + first, second = document["references"] + check("both places that cite the article share its entry", len(first["citations"]) == 2) + check( + "the entry is a bibliography line, not the quote", + first["text"] + == "测试作者: 用于验证引用链路的文献. 测试期刊 (2024)", + first["text"], + ) + check( + "what a complete entry still lacks is named", + first["missing"] == ["卷期页码"], + str(first["missing"]), + ) + check("the unlinked quote is its own entry", second["reference_id"] is None) + check("and prints no fabricated entry", second["text"] == "", second["text"]) + check("the style is reported", document["reference_style"] == "springer", document["reference_style"]) check("sentence template stamped", paragraph["sentences"][0]["template_id"] == wide["id"]) - print("5. explicit sorts decide the order, not the order they were sent") + print("6. explicit sorts decide the order, not the order they were sent") second_sort = document["paragraphs"][1]["paper_template_filed_sort"] reordered = call( "PUT", @@ -202,7 +225,7 @@ def main() -> int: {"sentences": []}, ) - print("6. the seam between sentences depends on the language") + print("7. the seam between sentences depends on the language") # Chinese needs nothing after 。; English needs a space, or two # sentences print as `First.Second.` mixed = call( @@ -244,7 +267,7 @@ def main() -> int: # Clear it again so the counts asserted below stay meaningful. call("PUT", f"/papers/{paper['id']}/paragraphs/{second_sort}", {"sentences": []}) - print("7. reject a citation with no quote") + print("8. reject a citation with no quote") bad = call( "PUT", f"/papers/{paper['id']}/paragraphs/{first_sort}", @@ -262,7 +285,7 @@ def main() -> int: ) check("citation without content refused", "detail" in bad) - print("8. a sentence with no paragraph in the template survives a switch") + print("9. a sentence with no paragraph in the template survives a switch") # A position neither template defines, so the check means the same # thing before and after the switch below. orphan_sort = ( @@ -290,7 +313,7 @@ def main() -> int: p for p in document["paragraphs"] if p["paper_template_filed_sort"] == orphan_sort )["name"] is None) - print("9. switch the template") + print("10. switch the template") switched = call("PATCH", f"/papers/{paper['id']}", {"template_id": narrow["id"]}) check("template changed", switched["template_id"] == narrow["id"]) document = call("GET", f"/papers/{paper['id']}/document") @@ -320,7 +343,7 @@ def main() -> int: ), ) - print("10. move one paragraph onto another position") + print("11. move one paragraph onto another position") document = call( "PUT", f"/papers/{paper['id']}/paragraphs/{orphan_sort}", @@ -335,18 +358,18 @@ def main() -> int: all(p["paper_template_filed_sort"] != orphan_sort for p in document["paragraphs"]), ) - print("11. paper list reports progress") + print("12. paper list reports progress") listing = call("GET", f"/papers?keyword=冒烟&status=writing") check("found by keyword and status", listing["total"] == 1, str(listing["total"])) row = listing["items"][0] check("paragraph count", row["paragraph_count"] == 1, str(row["paragraph_count"])) check("sentence count", row["sentence_count"] == 3, str(row["sentence_count"])) - print("12. a template in use cannot be deleted") + print("13. a template in use cannot be deleted") conflict = call("DELETE", f"/templates/{narrow['id']}", expect=409) check("template delete refused", "正被论文使用" in conflict["detail"], conflict["detail"]) - print("13. single sentence edit and delete") + print("14. single sentence edit and delete") sentence_id = target["sentences"][0]["id"] updated = call( "PATCH", @@ -362,7 +385,7 @@ def main() -> int: sum(len(p["sentences"]) for p in document["paragraphs"]) == 2, ) - print("14. a paper with no template still works") + print("15. a paper with no template still works") bare = call( "POST", "/papers", @@ -385,7 +408,7 @@ def main() -> int: call("DELETE", f"/papers/{bare['id']}", expect=204) created_papers.remove(bare["id"]) - print("15. delete the paper") + print("16. delete the paper") call("DELETE", f"/papers/{paper['id']}", expect=204) created_papers.clear() for reference_id in created_references: