sci-report-analyzer 1.0.0__py3-none-any.whl

sci_report_analyzer/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("sci-report-analyzer")
+except PackageNotFoundError:  # running from the sources without installing
+    __version__ = "dev"

sci_report_analyzer/annotations.py

@@ -0,0 +1,415 @@
+"""User annotations on publications: flags, tags (global or per period, stars included),
+notes, forced venue matches."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import select
+
+from .db.models import (
+    STARRED,
+    AppSetting,
+    Flag,
+    Period,
+    PeriodNote,
+    PeriodTag,
+    Publication,
+    PublicationFlag,
+    PublicationTag,
+    Tag,
+)
+from .db.session import session_scope
+
+DEFAULT_FLAGS = (
+    ("short", "#d4a72c", "short"),
+    ("demo", "#8a6fd0", "demo"),
+    ("tutorial", "#1a7f37", "tutorial"),
+)
+
+
+def seed_flags() -> None:
+    with session_scope() as s:
+        if s.scalar(select(Flag.id).limit(1)) is None:
+            for name, colour, track in DEFAULT_FLAGS:
+                s.add(Flag(name=name, colour=colour, track=track))
+
+
+def all_flags() -> list[Flag]:
+    with session_scope() as s:
+        return list(s.scalars(select(Flag).order_by(Flag.name)))
+
+
+def save_flag(name: str, colour: str, track: str | None, flag_id: int | None = None) -> None:
+    with session_scope() as s:
+        f = s.get(Flag, flag_id) if flag_id else Flag(name=name)
+        if flag_id is None:
+            s.add(f)
+        f.name, f.colour, f.track = name, colour, track or None
+
+
+def delete_flag(flag_id: int) -> None:
+    with session_scope() as s:
+        if f := s.get(Flag, flag_id):
+            s.delete(f)
+
+
+def toggle_flag(pub_id: int, flag_id: int) -> bool:
+    with session_scope() as s:
+        row = s.get(PublicationFlag, (pub_id, flag_id))
+        if row:
+            s.delete(row)
+            return False
+        s.add(PublicationFlag(publication_id=pub_id, flag_id=flag_id))
+        return True
+
+
+# ---- tags and notes -------------------------------------------------------------------------
+
+
+def all_tags() -> list[Tag]:
+    """Every tag: the global ones, then the per-period ones (by name)."""
+    with session_scope() as s:
+        return list(s.scalars(select(Tag).order_by(Tag.per_period, Tag.name)))
+
+
+def starred_tag_id() -> int:
+    with session_scope() as s:
+        return s.scalar(select(Tag.id).where(Tag.key == STARRED))
+
+
+def save_tag(
+    name: str, colour: str | None = None, per_period: bool = False, tag_id: int | None = None
+) -> int:
+    """Create a tag (or rename / recolour one; a tag keeps its kind). An existing name is
+    reused."""
+    name = name.strip()
+    with session_scope() as s:
+        t = s.get(Tag, tag_id) if tag_id else s.scalar(select(Tag).where(Tag.name == name))
+        if t is None:
+            t = Tag(name=name, per_period=per_period, colour=colour or "#0969da")
+            s.add(t)
+        t.name = name
+        if colour:
+            t.colour = colour
+        s.flush()
+        return t.id
+
+
+def delete_tag(tag_id: int) -> None:
+    """Delete a tag (from every paper); the built-in ones are kept."""
+    with session_scope() as s:
+        if (t := s.get(Tag, tag_id)) and t.key is None:
+            s.delete(t)
+
+
+def toggle_tag(pub_id: int, tag_id: int, period_id: int | None = None) -> bool:
+    """Put a tag on a paper (or take it off): a per-period tag within ``period_id``."""
+    with session_scope() as s:
+        if s.get(Tag, tag_id).per_period:
+            if period_id is None:
+                raise ValueError("a per-period tag needs a period")
+            row = s.get(PeriodTag, (period_id, pub_id, tag_id))
+            new = PeriodTag(period_id=period_id, publication_id=pub_id, tag_id=tag_id)
+        else:
+            row = s.get(PublicationTag, (pub_id, tag_id))
+            new = PublicationTag(publication_id=pub_id, tag_id=tag_id)
+        if row:
+            s.delete(row)
+            return False
+        s.add(new)
+        return True
+
+
+def tag_numbered(tag_id: int, numbers: dict[int, int | None], period_id: int | None = None) -> None:
+    """Put a tag on papers (pub id -> their number in a list), keeping the tag where it is
+    and setting its number."""
+    with session_scope() as s:
+        per_period = s.get(Tag, tag_id).per_period
+        if per_period and period_id is None:
+            raise ValueError("a per-period tag needs a period")
+        for pub_id, number in numbers.items():
+            if per_period:
+                key = (period_id, pub_id, tag_id)
+                row = s.get(PeriodTag, key) or PeriodTag(
+                    period_id=period_id, publication_id=pub_id, tag_id=tag_id
+                )
+            else:
+                row = s.get(PublicationTag, (pub_id, tag_id)) or PublicationTag(
+                    publication_id=pub_id, tag_id=tag_id
+                )
+            row.number = number
+            s.add(row)
+
+
+def _list_key(person_id: int, tag_id: int, period_id: int | None) -> str:
+    return f"ui.reflist.{person_id}.{period_id or 0}.{tag_id}"
+
+
+def tag_list(person_id: int, tag_id: int, period_id: int | None = None) -> list[dict]:
+    """The last list a tag was put from (its items: number, text, the paper's id or None)."""
+    return list(ui_state(_list_key(person_id, tag_id, period_id), []))
+
+
+def save_tag_list(person_id: int, tag_id: int, period_id: int | None, entries: list[dict]) -> None:
+    save_ui_state(_list_key(person_id, tag_id, period_id), entries)
+
+
+def toggle_star(period_id: int, pub_id: int) -> bool:
+    return toggle_tag(pub_id, starred_tag_id(), period_id)
+
+
+def set_note(pub_id: int, text: str | None, period_id: int | None = None) -> None:
+    """The paper's note (Markdown), or its note within a period; empty: none."""
+    text = (text or "").strip() or None
+    with session_scope() as s:
+        if period_id is None:
+            s.get(Publication, pub_id).note = text
+            return
+        row = s.get(PeriodNote, (period_id, pub_id))
+        if text is None:
+            if row:
+                s.delete(row)
+        elif row:
+            row.text = text
+        else:
+            s.add(PeriodNote(period_id=period_id, publication_id=pub_id, text=text))
+
+
+def periods(person_id: int, *, include_hidden_folders: bool = False) -> list[Period]:
+    """The person's own periods (by start), then their folder periods (latest folder first)."""
+    from sqlalchemy.orm import selectinload
+
+    from .db.models import Folder
+
+    q = (
+        select(Period)
+        .outerjoin(Folder, Period.folder_id == Folder.id)
+        .where(Period.person_id == person_id)
+        .options(selectinload(Period.folder))
+    )
+    if not include_hidden_folders:
+        q = q.where(Period.folder_id.is_(None) | Folder.hidden.is_(False))
+    with session_scope() as s:
+        items = list(s.scalars(q))
+
+    def key(p: Period) -> tuple:
+        if p.folder is None:
+            return (0, p.start_year or 0, p.id)
+        day = p.folder.date.toordinal() if p.folder.date else 0
+        return (1, -day, p.id)
+
+    return sorted(items, key=key)
+
+
+def save_period(
+    person_id: int, name: str, start: int | None, end: int | None, period_id: int | None = None
+) -> int:
+    with session_scope() as s:
+        p = s.get(Period, period_id) if period_id else Period(person_id=person_id)
+        if period_id is None:
+            s.add(p)
+        p.name, p.start_year, p.end_year = name, start, end
+        s.flush()
+        return p.id
+
+
+def delete_period(period_id: int) -> None:
+    with session_scope() as s:
+        if p := s.get(Period, period_id):
+            s.delete(p)
+
+
+def set_rank_override(
+    pub_id: int, override: dict[str, Any] | None, note: str | None = None
+) -> None:
+    """Rank of one publication set by hand: a level ``{"type", "rank", "name"}`` or a
+    ranking record ``{"record_key"}`` (None: back to its venue's rank)."""
+    with session_scope() as s:
+        pub = s.get(Publication, pub_id)
+        pub.rank_override = override
+        pub.rank_note = (note or None) if override else None
+
+
+def set_venue_source(pub_id: int, source: str | None) -> None:
+    """Use this source's venue for the publication (when the sources disagree)."""
+    with session_scope() as s:
+        s.get(Publication, pub_id).venue_source = source
+
+
+_OVERRIDES = ("year_override", "author_pos_override", "note")
+
+
+def set_overrides(pub_id: int, **values: Any) -> None:
+    """Year / author position set by hand (None: from the sources), and a note."""
+    with session_scope() as s:
+        pub = s.get(Publication, pub_id)
+        for k, v in values.items():
+            if k not in _OVERRIDES:
+                raise ValueError(k)
+            setattr(pub, k, v if v not in ("", None) else None)
+
+
+def set_doi(pub_id: int, doi: str | None) -> int:
+    """Give a publication its DOI by hand (None: from the sources). Returns its person."""
+    from .sources.base import normalize_doi
+
+    with session_scope() as s:
+        pub = s.get(Publication, pub_id)
+        pub.doi_manual = normalize_doi(doi)
+        return pub.person_id
+
+
+def set_hidden(pub_id: int, hidden: bool) -> None:
+    with session_scope() as s:
+        s.get(Publication, pub_id).hidden = hidden
+
+
+def ui_state(key: str, default: Any = None) -> Any:
+    with session_scope() as s:
+        row = s.get(AppSetting, key)
+        return row.value if row else default
+
+
+def save_ui_state(key: str, value: Any) -> None:
+    with session_scope() as s:
+        s.merge(AppSetting(key=key, value=value))
+
+
+def panel_state(person_id: int) -> dict[str, Any]:
+    with session_scope() as s:
+        row = s.get(AppSetting, f"ui.person.{person_id}")
+        return dict(row.value) if row else {}
+
+
+def save_panel_state(person_id: int, state: dict[str, Any]) -> None:
+    with session_scope() as s:
+        s.merge(AppSetting(key=f"ui.person.{person_id}", value=state))
+
+
+# ---- name aliases (the person and their PhD students) ---------------------------------------
+
+OWNER = "owner"
+
+
+def add_alias(person_id: int, name: str, student: str | None = None) -> None:
+    """Confirm ``name`` as a spelling of the person (or of PhD student ``student``)."""
+    from .db.models import Person
+
+    with session_scope() as s:
+        p = s.get(Person, person_id)
+        if student is None:
+            if name != p.name and name not in (p.aliases or []):
+                p.aliases = [*(p.aliases or []), name]
+        else:
+            aliases = dict(p.student_aliases or {})
+            if name != student and name not in aliases.get(student, []):
+                aliases[student] = [*aliases.get(student, []), name]
+            p.student_aliases = aliases
+        _unreject(p, student or OWNER, name)
+
+
+def reject_alias(person_id: int, name: str, student: str | None = None) -> None:
+    """``name`` is *not* the person (or the student): stop suggesting it."""
+    from .db.models import Person
+
+    with session_scope() as s:
+        p = s.get(Person, person_id)
+        rejects = dict(p.name_rejects or {})
+        key = student or OWNER
+        if name not in rejects.get(key, []):
+            rejects[key] = [*rejects.get(key, []), name]
+        p.name_rejects = rejects
+
+
+def _unreject(p, key: str, name: str) -> None:
+    rejects = dict(p.name_rejects or {})
+    if name in rejects.get(key, []):
+        rejects[key] = [n for n in rejects[key] if n != name]
+        p.name_rejects = rejects
+
+
+def set_kind_override(pub_id: int, kind: str | None) -> None:
+    with session_scope() as s:
+        s.get(Publication, pub_id).kind_override = kind or None
+
+
+def remove_alias(person_id: int, name: str, student: str | None = None) -> None:
+    """Undo a confirmed spelling: ``name`` is no longer the person (or the student)."""
+    from .db.models import Person
+
+    with session_scope() as s:
+        p = s.get(Person, person_id)
+        if student is None:
+            p.aliases = [a for a in (p.aliases or []) if a != name]
+        else:
+            aliases = dict(p.student_aliases or {})
+            aliases[student] = [a for a in aliases.get(student, []) if a != name]
+            p.student_aliases = aliases
+    reject_alias(person_id, name, student)
+
+
+def set_student_outcome(person_id: int, student: str, note: str) -> None:
+    """Record what became of PhD student ``student`` after the PhD (empty: forget it)."""
+    from .db.models import Person
+
+    with session_scope() as s:
+        p = s.get(Person, person_id)
+        outcomes = dict(p.student_outcomes or {})
+        if note.strip():
+            outcomes[student] = note.strip()
+        else:
+            outcomes.pop(student, None)
+        p.student_outcomes = outcomes
+
+
+# ---- author categories (e.g. "Intl. collaborators") ----------------------------------------
+
+
+def author_categories() -> list:
+    from .db.models import AuthorCategory
+
+    with session_scope() as s:
+        return list(s.scalars(select(AuthorCategory).order_by(AuthorCategory.name)))
+
+
+def save_author_category(name: str, colour: str, category_id: int | None = None) -> int:
+    from .db.models import AuthorCategory
+
+    with session_scope() as s:
+        c = s.get(AuthorCategory, category_id) if category_id else None
+        if c is None:
+            c = s.scalar(select(AuthorCategory).where(AuthorCategory.name == name))
+        if c is None:
+            c = AuthorCategory(name=name)
+            s.add(c)
+        c.name, c.colour = name, colour
+        s.flush()
+        return c.id
+
+
+def delete_author_category(category_id: int) -> None:
+    from .db.models import AuthorCategory, Person
+
+    with session_scope() as s:
+        if c := s.get(AuthorCategory, category_id):
+            s.delete(c)
+        for p in s.scalars(select(Person)):
+            if str(category_id) in (p.author_categories or {}):
+                cats = dict(p.author_categories)
+                del cats[str(category_id)]
+                p.author_categories = cats
+
+
+def set_author_category(person_id: int, name: str, category_id: int, on: bool = True) -> None:
+    """Put co-author ``name`` in (or out of) a category, for this person."""
+    from .db.models import Person
+
+    with session_scope() as s:
+        p = s.get(Person, person_id)
+        cats = dict(p.author_categories or {})
+        names = [n for n in cats.get(str(category_id), []) if n != name]
+        if on:
+            names.append(name)
+        cats[str(category_id)] = names
+        p.author_categories = cats

sci_report_analyzer/authors.py

@@ -0,0 +1,81 @@
+"""Author-name utilities: name keys and same-author tests."""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from collections.abc import Iterable
+
+_COMBINING = re.compile("[̀-ͯ]")
+
+
+def natural_order(name: str) -> str:
+    """ "Given Surname" order for names written "SURNAME Given" or "Surname, Given".
+
+    A word in capitals (two letters or more) mixed with ordinary words is the surname, as in
+    French administrative style ("NEVEOL Aurélie" -> "Aurélie NEVEOL").
+    """
+    name = " ".join(name.split())
+    if name.count(",") == 1:
+        last, first = (x.strip() for x in name.split(","))
+        if last and first:
+            return f"{first} {last}"
+    words = name.split()
+
+    def caps(w: str) -> bool:
+        letters = [c for c in w if c.isalpha()]
+        return len(letters) >= 2 and all(c.isupper() for c in letters)
+
+    upper = [w for w in words if caps(w)]
+    if upper and len(upper) < len(words):
+        return " ".join([w for w in words if not caps(w)] + upper)
+    return name
+
+
+def _fold(name: str) -> list[str]:
+    s = _COMBINING.sub("", unicodedata.normalize("NFD", natural_order(name))).lower()
+    return [p for p in re.sub(r"[^a-z\s]", " ", s).split() if p]
+
+
+def name_key(name: str) -> tuple[str, str]:
+    """(surname, first initial), accent-/case-folded."""
+    parts = _fold(name)
+    if not parts:
+        return "", ""
+    return parts[-1], parts[0][0]
+
+
+def same_author(a: str, b: str) -> bool:
+    sa, ia = name_key(a)
+    sb, ib = name_key(b)
+    if not sa or sa != sb:
+        return False
+    return not ia or not ib or ia == ib
+
+
+def author_position(authors: Iterable[str], names: Iterable[str]) -> int | None:
+    """1-based position of the first author matching any of ``names``."""
+    names = [n for n in names if n]
+    for i, a in enumerate(authors, start=1):
+        if any(same_author(a, n) for n in names):
+            return i
+    return None
+
+
+def name_similarity(query: str, candidate: str) -> float:
+    """Crude [0, 1] similarity between a searched name and a candidate profile name."""
+    q, c = _fold(query), _fold(candidate)
+    if not q or not c:
+        return 0.0
+    if q == c:
+        return 1.0
+    if same_author(query, candidate):
+        # Surname + initial agree; reward matching full given names.
+        return 0.9 if set(q[:-1]) & set(c[:-1]) else 0.75
+    shared = len(set(q) & set(c))
+    return 0.5 * shared / max(len(set(q)), len(set(c)))
+
+
+def fold_name(name: str) -> str:
+    """Accent/case/punctuation-folded full name, for exact alias comparison."""
+    return " ".join(_fold(name))