atlasdocs-metadata 0.9.0__tar.gz

atlasdocs_metadata-0.9.0/.gitignore

@@ -0,0 +1,24 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+
+# Build / dist
+dist/
+build/
+
+# Pixi environments
+.pixi/
+
+# macOS
+.DS_Store
+
+# Editors
+.idea/
+.vscode/
+*.swp
+
+# Secrets / env
+.env
+*.env

atlasdocs_metadata-0.9.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: atlasdocs-metadata
+Version: 0.9.0
+Summary: Syncs the atlasdocs/metadata registry (data_<CODE>.yml / stare_<CODE>.json.br, every group) and renders it via GroupMacros/GlanceMacros for atlasdocs-theme sites
+Author-email: Jason Oliver <jason.oliver@cern.ch>
+License-Expression: Apache-2.0
+Requires-Python: >=3.9
+Requires-Dist: brotli>=1.1
+Requires-Dist: pyyaml>=6

atlasdocs_metadata-0.9.0/atlasdocs_metadata/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+
+def __getattr__(name: str):
+    if name == "fetch_metadata":
+        from .fetch_metadata import main as fetch_metadata
+        return fetch_metadata
+    if name == "GroupMacros":
+        from .group import GroupMacros
+        return GroupMacros
+    if name == "GlanceMacros":
+        from .glance import GlanceMacros
+        return GlanceMacros
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = ["fetch_metadata", "GroupMacros", "GlanceMacros"]

atlasdocs_metadata-0.9.0/atlasdocs_metadata/fetch_metadata.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+"""
+Syncs the whole `data/` tree of atlasdocs/metadata (every group's
+data_<CODE>.yml and stare_<CODE>.json.br — pre-normalized, brotli-compressed
+ATLAS Glance/STARE records) into <hub>/data/metadata/. This is the fetch
+half of the package; atlasdocs_metadata.GroupMacros / .GlanceMacros (see
+group.py / glance.py) are the reader/renderer half, kept in the same
+package deliberately since they read exactly what this writes — splitting
+fetch format and reader across two independently-versioned packages would
+reintroduce the version-skew risk this package exists to avoid.
+
+Deliberately all-or-nothing: there is no per-group allowlist. A site either
+opts in (by adding a [metadata] config, see below) and gets every group, or
+it doesn't fetch anything. This mirrors atlas-docs-bphy's old
+scripts/pull_metadata.sh + pull_stare.sh, merged into one clone (both files
+live under the same `data/` prefix upstream, so one sparse-checkout covers
+both) and widened from a single hardcoded CODE to the full registry.
+
+Config — reads [metadata] from atlasdocs.toml first, falling back to a
+standalone metadata.toml (flat, no [metadata] wrapper) if that file or
+section isn't present. Presence of either is what opts a site in; a site
+with neither is skipped entirely, matching atlasdocs_gitlab's gitlab.toml
+gating. Recognized keys (all optional):
+
+    repo   = "https://gitlab.cern.ch/atlasdocs/metadata.git"  # default shown
+    branch = "main"                                            # default: repo default branch
+
+Auth mirrors atlasdocs_theme.scripts.import_sources: prefers $GITLAB_TOKEN,
+otherwise clones bare — in CI the global url.insteadOf rewrite (set up in
+every consumer's .gitlab-ci.yml pixi before_script) injects $CI_JOB_TOKEN,
+and locally the ambient git credential helper takes over.
+
+A clone failure is non-fatal (warns and exits 0) — same soft-fail behavior
+as the shell scripts it replaces, reinforced by this step being registered
+as required=False in atlasdocs_theme.registry.
+
+Usage:
+    python -m atlasdocs_metadata.fetch_metadata [hub_dir]
+Pixi (via atlasdocs-theme's step registry):
+    pixi run fetch
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+ATLASDOCS_TOML = "atlasdocs.toml"
+LEGACY_TOML = "metadata.toml"
+DEFAULT_REPO = "https://gitlab.cern.ch/atlasdocs/metadata.git"
+CACHE_DIR = ".metadata-cache"
+CLONE_TIMEOUT = 300
+
+
+def load_config(hub_dir: Path) -> dict | None:
+    """Returns the [metadata] config dict, or None if this site hasn't opted in."""
+    unified = hub_dir / ATLASDOCS_TOML
+    if unified.is_file():
+        with open(unified, "rb") as f:
+            data = tomllib.load(f)
+        if "metadata" in data:
+            return data["metadata"]
+
+    legacy = hub_dir / LEGACY_TOML
+    if legacy.is_file():
+        with open(legacy, "rb") as f:
+            return tomllib.load(f)
+
+    return None
+
+
+def _auth_url(url: str) -> str:
+    if token := os.environ.get("GITLAB_TOKEN"):
+        return url.replace("https://", f"https://oauth2:{token}@", 1)
+    return url
+
+
+def _git(args: list[str]) -> subprocess.CompletedProcess:
+    env = {**os.environ, "GIT_TERMINAL_PROMPT": "0"}
+    return subprocess.run(["git", *args], capture_output=True, text=True, env=env, timeout=CLONE_TIMEOUT)
+
+
+def sync_registry(repo_url: str, branch: str | None, cache: Path) -> bool:
+    """Sparse-clone <repo>'s data/ tree (blobless + no-checkout, then sparse
+    checkout just `data`) into `cache`. Returns False on any failure."""
+    if cache.exists():
+        shutil.rmtree(cache)
+    clone = ["clone", "--depth=1", "--filter=blob:none", "--no-checkout"]
+    if branch:
+        clone += ["--branch", branch]
+    clone += [_auth_url(repo_url), str(cache)]
+    try:
+        r = _git(clone)
+        if r.returncode != 0:
+            print(f"WARNING: could not clone {repo_url}, skipping metadata sync:\n{r.stderr.strip()}")
+            return False
+        _git(["-C", str(cache), "sparse-checkout", "set", "data"])
+        co = _git(["-C", str(cache), "checkout"])
+        if co.returncode != 0:
+            print(f"WARNING: checkout failed, skipping metadata sync:\n{co.stderr.strip()}")
+            return False
+    except subprocess.TimeoutExpired:
+        print(f"WARNING: clone of {repo_url} timed out after {CLONE_TIMEOUT}s, skipping metadata sync")
+        return False
+    return True
+
+
+def replace_tree(src: Path, dest: Path) -> tuple[int, int]:
+    """Wholesale-replace dest with src's contents (so groups removed upstream
+    disappear locally too, not just accumulate). Returns (n_yml, n_br) copied."""
+    if dest.exists():
+        shutil.rmtree(dest)
+    shutil.copytree(src, dest)
+    n_yml = len(list(dest.glob("data_*.yml")))
+    n_br = len(list(dest.glob("stare_*.json.br")))
+    return n_yml, n_br
+
+
+def main() -> None:
+    hub_dir = Path(sys.argv[1]).resolve() if len(sys.argv) > 1 else Path.cwd()
+
+    config = load_config(hub_dir)
+    if config is None:
+        print(f"[fetch_metadata] no {ATLASDOCS_TOML} [metadata] section or {LEGACY_TOML} found, skipping")
+        return
+
+    repo_url = config.get("repo", DEFAULT_REPO)
+    branch = config.get("branch")
+
+    cache = hub_dir / CACHE_DIR
+    if not sync_registry(repo_url, branch, cache):
+        shutil.rmtree(cache, ignore_errors=True)
+        return
+
+    src = cache / "data"
+    if not src.is_dir():
+        print(f"WARNING: {repo_url} has no data/ directory, skipping metadata sync")
+        shutil.rmtree(cache, ignore_errors=True)
+        return
+
+    dest = hub_dir / "data" / "metadata"
+    n_yml, n_br = replace_tree(src, dest)
+    print(f"[fetch_metadata] synced {n_yml} data_*.yml + {n_br} stare_*.json.br -> {dest}")
+
+    shutil.rmtree(cache, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    main()

atlasdocs_metadata-0.9.0/atlasdocs_metadata/glance.py

@@ -0,0 +1,490 @@
+from __future__ import annotations
+
+import html
+import json
+import re
+from pathlib import Path
+
+import brotli
+
+_GLANCE_BASE = "https://atlas-glance.cern.ch/atlas/analysis"
+
+# Per-entry-type lifecycle key -> display label, in display order. Mirrors
+# ANALYSIS_LIFECYCLE_LABELS / PAPER_LIFECYCLE_LABELS / NOTE_LIFECYCLE_LABELS
+# in atlas-search-frontend's GlanceStareCard.vue.
+_ANALYSIS_LIFECYCLE_LABELS = {
+    "start_date":                   "Start",
+    "meeting_eoi":                  "EOI",
+    "meeting_eb_request":           "EB Request",
+    "editorial_board_formed_date":  "EB Formed",
+    "pgc_sgc_sign_off_date":        "PGC/SGC",
+    "meeting_pre_approval":         "Pre-approval",
+    "meeting_approval":             "Approval",
+}
+_PAPER_LIFECYCLE_LABELS = {
+    "phase1_start":            "Phase 1 Start",
+    "editorial_board_formed":  "EB Formed",
+    "presentation":            "Presentation",
+    "pgc_approval":            "PGC Approval",
+    "draft1_released":         "Draft 1",
+    "draft2_released":         "Draft 2",
+    "draft2_sent_to_cern":     "Sent to CERN",
+    "paper_closure":           "Closure",
+    "arxiv_submitted":         "arXiv Submitted",
+    "journal_accepted":        "Journal Accepted",
+    "published_online":        "Published Online",
+}
+_NOTE_LIFECYCLE_LABELS = {
+    "start_date":              "Start",
+    "editorial_board_formed":  "EB Formed",
+    "presentation":            "Presentation",
+    "pgc_approval":            "PGC Approval",
+    "first_sign_off":          "First Sign-off",
+    "first_reader_sign_off":   "First Reader Sign-off",
+    "second_sign_off":         "Second Sign-off",
+    "second_reader_sign_off":  "Second Reader Sign-off",
+    "group_approval":          "Group Approval",
+    "atlas_circulation":       "ATLAS Circulation",
+    "release_date":            "Release",
+}
+
+_REPO_LABELS = {"INT": "Int. Note", "PAP": "Paper", "PUB": "PUB Note", "CONF": "CONF Note", "CODE": "Code"}
+
+
+def _e(value) -> str:
+    """Escape a value for HTML text content (titles/keywords can contain '->' etc.)."""
+    return html.escape(str(value)) if value is not None else ""
+
+
+class GlanceMacros:
+    """Renders ATLAS Glance/STARE personnel + analyses views from data/metadata/stare_<CODE>.json.br
+    (pre-normalized, brotli-compressed hit dicts published by atlas-docs-metadata's
+    scripts/split_stare_registry.py, synced locally by atlasdocs_metadata.fetch_metadata). A
+    hand-written HTML/CSS port of atlas-search-frontend's GlanceStareCard.vue — same look, no
+    Vue/OpenSearch involved.
+
+    Usage in markdown::
+
+        {{ GLANCE.active_personnel("BPHY") | safe }}
+        {{ GLANCE.personnel_history("BPHY") | safe }}
+        {{ GLANCE.analyses("BPHY") | safe }}
+        {{ GLANCE.analyses("BPHY", view="list", entry_type="Paper") | safe }}
+        {{ GLANCE.analyses("BPHY", entry_type="Analysis", ongoing_only=True, show_circle=False) | safe }}
+        {{ GLANCE.analysis("ANA-BPHY-2018-14") | safe }}
+    """
+
+    def __init__(self, data_dir: Path):
+        self._hits_by_group: dict[str, list[dict]] = {}
+        self._by_ref: dict[str, dict] = {}
+        for path in sorted(data_dir.glob("stare_*.json.br")):
+            code = path.stem[len("stare_"):].removesuffix(".json")
+            payload = json.loads(brotli.decompress(path.read_bytes()))
+            hits = payload.get("hits", [])
+            self._hits_by_group[code] = hits
+            for hit in hits:
+                ref = hit.get("ref_code")
+                if ref:
+                    self._by_ref.setdefault(ref, hit)
+                final_ref = hit.get("final_ref_code")
+                if final_ref:
+                    self._by_ref.setdefault(final_ref, hit)
+
+    # ── lookups ──────────────────────────────────────────────────────────
+
+    def _find(self, ref_code: str) -> dict | None:
+        if ref_code in self._by_ref:
+            return self._by_ref[ref_code]
+        if not ref_code.startswith("ANA-"):
+            return self._by_ref.get(f"ANA-{ref_code}")
+        return None
+
+    @staticmethod
+    def _glance_url(hit: dict) -> str:
+        ref = hit.get("ref_code", "")
+        et = hit.get("entry_type")
+        if et == "ConfNote":
+            return f"{_GLANCE_BASE}/confnotes/details?ref_code={ref}"
+        if et == "PubNote":
+            return f"{_GLANCE_BASE}/pubnotes/details?ref_code={ref}"
+        if et == "Paper":
+            return f"{_GLANCE_BASE}/papers/details.php?ref_code={ref}"
+        return f"{_GLANCE_BASE}/analyses/details.php?ref_code={ref}"
+
+    @staticmethod
+    def _badge(hit: dict) -> tuple[str, str]:
+        et = hit.get("entry_type", "")
+        if et == "Paper":
+            return "Paper", "glance-type-paper"
+        if et == "ConfNote":
+            return "CONF Note", "glance-type-note"
+        if et == "PubNote":
+            return "PUB Note", "glance-type-note"
+        # Analysis: show the actual status name (e.g. "Phase 0 Active"), as
+        # stored by stare_normalize.py's _status() — not a derived "phase0
+        # active"-style slug.
+        state = hit.get("phase") or ""
+        if not state:
+            return "ongoing", "glance-type-analysis"
+        cls = "glance-type-analysis" if "active" in state.lower() else "glance-type-note"
+        return state, cls
+
+    @staticmethod
+    def _display_title(hit: dict) -> str:
+        """Raw (unescaped) display title — callers must run it through _e() before
+        embedding in HTML; analyses(view="list") also needs the raw form for its
+        markdown "|" escaping."""
+        return re.sub(r"^\[(?:ANA|CONF|PUB)-", "[", hit.get("title", ""))
+
+    @staticmethod
+    def _lifecycle_labels(entry_type: str) -> dict:
+        if entry_type == "Paper":
+            return _PAPER_LIFECYCLE_LABELS
+        if entry_type in ("ConfNote", "PubNote"):
+            return _NOTE_LIFECYCLE_LABELS
+        return _ANALYSIS_LIFECYCLE_LABELS
+
+    # ── card rendering ───────────────────────────────────────────────────
+
+    def _render_card(self, hit: dict, show_circle: bool = True) -> str:
+        ref = hit.get("ref_code", "")
+        badge_label, badge_cls = self._badge(hit)
+        title = _e(self._display_title(hit))
+        glance_url = self._glance_url(hit)
+
+        leading = hit.get("leading_group")
+        subgroups = hit.get("subgroups") or []
+        runs = list(dict.fromkeys(s.strip() for s in (hit.get("run") or "").split(",") if s.strip()))
+
+        tags = []
+        if leading:
+            tags.append(f'<span class="glance-tag glance-leading-group-tag">{_e(leading)}</span>')
+        for sg in subgroups[:3]:
+            tags.append(f'<span class="glance-tag glance-leading-group-tag">{_e(sg.upper())}</span>')
+        if len(subgroups) > 3:
+            tags.append(f'<span class="glance-tag glance-tag-more">+{len(subgroups) - 3}</span>')
+        for r in runs:
+            tags.append(f'<span class="glance-tag glance-run">{_e(r)}</span>')
+
+        date_label = hit.get("date", "")
+
+        # ── lifecycle (left column) ──
+        lifecycle = hit.get("lifecycle") or {}
+        labels = self._lifecycle_labels(hit.get("entry_type", ""))
+        lc_rows = []
+        for key, label in labels.items():
+            val = lifecycle.get(key)
+            if not val:
+                continue
+            if isinstance(val, dict):
+                d = val.get("date")
+                if not d:
+                    continue
+                url = val.get("url")
+                date_html = f'<a class="glance-lifecycle-date" href="{_e(url)}" target="_blank" rel="noopener">{_e(d)} ↗</a>' if url else f'<span class="glance-lifecycle-date">{_e(d)}</span>'
+            else:
+                date_html = f'<span class="glance-lifecycle-date">{_e(val)}</span>'
+            lc_rows.append(f'<div class="glance-lifecycle-row"><span class="glance-lifecycle-label">{_e(label)}</span>{date_html}</div>')
+        has_lifecycle = bool(lc_rows)
+
+        # ── general info / doclinks (right column) ──
+        doclinks = []
+        repos = hit.get("repositories") or []
+        int_repos = [r for r in repos if (r.get("type") or "").split(".")[-1] == "INT"]
+        other_repos = [r for r in repos if (r.get("type") or "").split(".")[-1] != "INT"]
+
+        def _repo_label(r):
+            t = (r.get("type") or "").split(".")[-1]
+            if t in ("INT", "PAP", "CONF"):
+                return r["url"].rstrip("/").split("/")[-1]
+            return ""
+
+        if int_repos:
+            vals = "".join(f'<a href="{_e(r["url"])}" target="_blank" rel="noopener" class="gs-reflink">{_e(_repo_label(r))}</a>' for r in int_repos)
+            doclinks.append(f'<span class="gs-doclabel">INT NOTES</span><div class="gs-docvals">{vals}</div>')
+
+        support_docs = hit.get("supporting_docs") or []
+        if support_docs:
+            vals = "".join(f'<a href="{_e(u)}" target="_blank" rel="noopener" class="gs-docnum">[{i + 1}]</a>' for i, u in enumerate(support_docs))
+            doclinks.append(f'<span class="gs-doclabel">SUPPORT DOCS</span><div class="gs-docvals">{vals}</div>')
+
+        if other_repos:
+            parts = []
+            for i, r in enumerate(other_repos):
+                label = _repo_label(r)
+                t = (r.get("type") or "").split(".")[-1]
+                title_attr = _e(r.get("label") or _REPO_LABELS.get(t, t or "Repo"))
+                cls = "gs-reflink" if label else "gs-docnum"
+                text = _e(label) if label else f"[{i + 1}]"
+                parts.append(f'<a href="{_e(r["url"])}" target="_blank" rel="noopener" class="{cls}" title="{title_attr}">{text}</a>')
+            doclinks.append(f'<span class="gs-doclabel">REPOS</span><div class="gs-docvals">{"".join(parts)}</div>')
+
+        doclinks.append(f'<span class="gs-doclabel">GLANCE</span><div class="gs-docvals"><a href="{_e(glance_url)}" target="_blank" rel="noopener" class="gs-reflink">Glance ↗</a></div>')
+
+        paper_url = hit.get("paper_url")
+        if paper_url:
+            doclinks.append(f'<span class="gs-doclabel">PAPER</span><div class="gs-docvals"><a href="{_e(paper_url)}" target="_blank" rel="noopener" class="gs-reflink">Paper ↗</a></div>')
+
+        arxiv_url = hit.get("arxiv_url")
+        if arxiv_url:
+            doclinks.append(f'<span class="gs-doclabel">ARXIV</span><div class="gs-docvals"><a href="{_e(arxiv_url)}" target="_blank" rel="noopener" class="gs-reflink">arXiv ↗</a></div>')
+
+        related = hit.get("related_publications") or []
+        if related:
+            vals = "".join(
+                f'<a href="{_e(self._glance_url(self._by_ref[r]) if r in self._by_ref else f"{_GLANCE_BASE}/analyses/details.php?ref_code={r}")}" target="_blank" rel="noopener" class="gs-reflink">{_e(r)}</a>'
+                for r in related
+            )
+            doclinks.append(f'<span class="gs-doclabel">RELATED</span><div class="gs-docvals">{vals}</div>')
+
+        if hit.get("entry_type") == "Analysis":
+            fw = hit.get("analysis_framework") or {}
+            for fw_key, fw_label in (("ntupling", "NTUPLING"), ("histogramming", "HISTOGRAMMING")):
+                text = fw.get(fw_key)
+                if text:
+                    doclinks.append(f'<span class="gs-doclabel">{fw_label}</span><div class="gs-docvals"><span class="glance-tag glance-tool-tag">{_e(text)}</span></div>')
+                else:
+                    doclinks.append(f'<span class="gs-doclabel">{fw_label}</span><div class="gs-docvals"><span class="glance-tag glance-missing-tag">Missing information</span></div>')
+
+            stat_tools = hit.get("statistical_tools") or []
+            if stat_tools:
+                vals = "".join(f'<span class="glance-tag glance-tool-tag" title="{_e(t)}">{_e(t)}</span>' for t in stat_tools)
+                doclinks.append(f'<span class="gs-doclabel">STAT TOOLS</span><div class="gs-docvals">{vals}</div>')
+            else:
+                doclinks.append('<span class="gs-doclabel">STAT TOOLS</span><div class="gs-docvals"><span class="glance-tag glance-missing-tag">Missing information</span></div>')
+
+            mva_tools = hit.get("mva_ml_tools") or []
+            if mva_tools:
+                vals = "".join(f'<span class="glance-tag glance-tool-tag" title="{_e(t)}">{_e(t)}</span>' for t in mva_tools)
+                doclinks.append(f'<span class="gs-doclabel">MVA/ML</span><div class="gs-docvals">{vals}</div>')
+
+        keywords = hit.get("keywords") or []
+        if keywords:
+            vals = "".join(f'<span class="glance-tag glance-keyword-tag">{_e(k)}</span>' for k in keywords)
+            doclinks.append(f'<span class="gs-doclabel">KEYWORDS</span><div class="gs-docvals">{vals}</div>')
+
+        # ── triggers / datasets (full width) ──
+        extra_rows = []
+        triggers = hit.get("triggers") or []
+        if triggers:
+            vals = "".join(f'<span class="glance-tag glance-trigger-tag">{_e(t)}</span>' for t in triggers)
+            extra_rows.append(f'<div class="gs-triggers-row"><span class="glance-meta-label">Triggers</span> {vals}</div>')
+        datasets = hit.get("datasets") or []
+        if datasets:
+            vals = "".join(f'<li class="gs-plain-list-item" title="{_e(d)}">{_e(d)}</li>' for d in datasets)
+            extra_rows.append(f'<div class="gs-datasets-section"><span class="glance-meta-label">Datasets ({len(datasets)})</span><ul class="gs-plain-list">{vals}</ul></div>')
+
+        # ── team / editorial board ──
+        team = hit.get("team") or []
+        team_size = hit.get("team_size", len(team))
+        team_sorted = sorted(team, key=lambda m: 0 if m.get("is_contact_editor") else 1 if m.get("is_analysis_contact") else 2)
+        egroup_team = egroup_eb = None
+        if ref.startswith("ANA-"):
+            slug = ref[len("ANA-"):].lower()
+            egroup_team = f"atlas-ana-{slug}-analysis-team@cern.ch"
+            egroup_eb = f"atlas-ana-{slug}-edboard-conveners@cern.ch"
+
+        team_html = ""
+        if team:
+            rows = []
+            if egroup_team:
+                rows.append(f'<a href="mailto:{egroup_team}" class="gs-egroup-plain" title="{egroup_team}">{egroup_team.replace("@cern.ch", "")}</a>')
+            for m in team_sorted:
+                role = "EDITOR" if m.get("is_contact_editor") else "CONTACT" if m.get("is_analysis_contact") else "MEMBER"
+                name = _e(m.get("name", ""))
+                if m.get("email"):
+                    rows.append(f'<div class="gs-team-row"><span class="gs-team-role">{role}</span><a href="mailto:{_e(m["email"])}" class="gs-team-email">{name}</a></div>')
+                else:
+                    rows.append(f'<div class="gs-team-row"><span class="gs-team-role">{role}</span><span>{name}</span></div>')
+            eb = hit.get("editorial_board") or []
+            eb_rows = []
+            if eb:
+                if egroup_eb:
+                    eb_rows.append(f'<a href="mailto:{egroup_eb}" class="gs-egroup-plain" title="{egroup_eb}">{egroup_eb.replace("@cern.ch", "")}</a>')
+                for m in eb:
+                    role = "CHAIR" if m.get("is_chair") else "EX OFFICIO" if m.get("is_ex_officio") else "MEMBER"
+                    name = _e(m.get("name", ""))
+                    if m.get("email"):
+                        eb_rows.append(f'<div class="gs-editor-row"><span class="gs-team-role">{role}</span><a href="mailto:{_e(m["email"])}" class="gs-team-email">{name}</a></div>')
+                    else:
+                        eb_rows.append(f'<div class="gs-editor-row"><span class="gs-team-role">{role}</span><span>{name}</span></div>')
+            elif hit.get("entry_type") == "Analysis":
+                eb_rows.append('<span class="gs-not-appointed">Not currently appointed</span>')
+
+            team_html = (
+                '<hr class="gs-team-divider">'
+                '<div class="gs-team-cols">'
+                f'<div class="gs-col-team"><div class="gs-section-label">Team ({team_size})</div>{"".join(rows)}</div>'
+                f'<div class="gs-col-editors"><div class="gs-section-label">Editorial Board{f" ({len(eb)})" if eb else ""}</div>{"".join(eb_rows)}</div>'
+                '</div>'
+            )
+
+        body_cols_cls = "gs-body-cols" if has_lifecycle else ""
+        lifecycle_col = (
+            f'<div class="gs-col-lifecycle"><div class="gs-section-label">Lifecycle</div>'
+            f'<div class="glance-lifecycle-body">{"".join(lc_rows)}</div></div>'
+        ) if has_lifecycle else ""
+        meta_col = f'<div class="gs-col-meta"><div class="gs-section-label">General Information</div><div class="gs-doclinks">{"".join(doclinks)}</div></div>'
+
+        circle_html = '<div class="source-circle" style="background: rgb(85, 139, 47);">GL</div>' if show_circle else ''
+
+        return (
+            '<div class="search-result">'
+            '<div class="card-row">'
+            f'{circle_html}'
+            '<div class="card-content">'
+            f'<div class="card-title"><a href="{_e(glance_url)}" target="_blank" rel="noopener"><span class="link-text">{title}</span></a>'
+            f'<span class="glance-badge {badge_cls}">{_e(badge_label)}</span></div>'
+            '<div class="card-breadcrumb glance-breadcrumb">'
+            f'<span class="glance-breadcrumb-left">{"".join(tags)}</span>'
+            f'<span class="glance-breadcrumb-right">{f"last updated: {_e(date_label)}" if date_label else ""}</span>'
+            '</div></div></div>'
+            '<hr>'
+            f'<div class="{body_cols_cls}">{lifecycle_col}{meta_col}</div>'
+            f'{"".join(extra_rows)}'
+            f'{team_html}'
+            '</div>'
+        )
+
+    # ── public API ───────────────────────────────────────────────────────
+
+    @staticmethod
+    def _year(hit: dict) -> str | None:
+        raw = hit.get("date") or hit.get("creation_date") or ""
+        return raw[:4] if len(raw) >= 4 and raw[:4].isdigit() else None
+
+    @staticmethod
+    def _is_closed(hit: dict) -> bool:
+        return (hit.get("phase") or "").strip().lower() == "closed"
+
+    @staticmethod
+    def _is_ongoing_analysis(hit: dict) -> bool:
+        """True for an Analysis genuinely in an active phase (phase text
+        contains "Active", e.g. "Phase 0 Active"). Deliberately stricter than
+        "not Closed" — plenty of analyses that have practically moved on
+        (into a paper/note) sit at "Phase 0 Finished" indefinitely without
+        ever being marked Closed in Glance, so "not Closed" alone
+        over-counts as active."""
+        return hit.get("entry_type") == "Analysis" and "active" in (hit.get("phase") or "").lower()
+
+    def _collect_personnel(self, code: str) -> dict[str, dict]:
+        people: dict[str, dict] = {}
+        for hit in self._hits_by_group.get(code, []):
+            year = self._year(hit)
+            ongoing = self._is_ongoing_analysis(hit)
+            for m in hit.get("team", []):
+                ccid = m.get("ccid")
+                if not ccid:
+                    continue
+                p = people.setdefault(ccid, {"name": m.get("name", ""), "email": m.get("email"), "roles": set(), "count": 0, "years": set(), "active": False})
+                p["count"] += 1
+                if year:
+                    p["years"].add(year)
+                if ongoing:
+                    p["active"] = True
+                if m.get("is_contact_editor"):
+                    p["roles"].add("Editor")
+                if m.get("is_analysis_contact"):
+                    p["roles"].add("Contact")
+                if not p["roles"]:
+                    p["roles"].add("Member")
+        return people
+
+    @staticmethod
+    def _render_personnel_table(people: list[dict]) -> str:
+        rows = sorted(people, key=lambda p: p["name"])
+        lines = ["| Name | Email | Roles | # entries | Years |", "|---|---|---|---|---|"]
+        for p in rows:
+            email = f'[{p["email"]}](mailto:{p["email"]})' if p.get("email") else ""
+            years = sorted(p["years"])
+            if not years:
+                years_label = ""
+            elif p["active"]:
+                # Still on an open analysis — leave the end open rather than
+                # implying they stopped after their latest recorded year.
+                years_label = f"{years[0]}–"
+            elif len(years) == 1:
+                years_label = years[0]
+            else:
+                years_label = f"{years[0]}–{years[-1]}"
+            lines.append(f'| {p["name"]} | {email} | {", ".join(sorted(p["roles"]))} | {p["count"]} | {years_label} |')
+        return "\n".join(lines)
+
+    def active_personnel(self, code: str) -> str:
+        """Active members — anyone on at least one genuinely ongoing Analysis
+        (see _is_ongoing_analysis). See personnel_history() for the full,
+        unfiltered roster."""
+        people = self._collect_personnel(code)
+        active = [p for p in people.values() if p["active"]]
+        return self._render_personnel_table(active)
+
+    def personnel_history(self, code: str) -> str:
+        """Every person who has ever appeared on a BPHY analysis, paper,
+        CONF note, or PUB note team — active or not. Whether an entry counts
+        as "Closed" is unreliable enough (see active_personnel()) that a
+        clean past/active split isn't trustworthy; this is the full roster
+        instead of a guessed complement."""
+        people = self._collect_personnel(code)
+        return self._render_personnel_table(list(people.values()))
+
+    @staticmethod
+    def _repo_links(hit: dict, types: set[str] | None) -> str:
+        """Markdown links for hit["repositories"] entries, optionally filtered
+        to a set of RepositoryType suffixes (e.g. {"INT"}); None means "all
+        types except INT" (the general "git repo" column)."""
+        repos = hit.get("repositories") or []
+        out = []
+        for r in repos:
+            t = (r.get("type") or "").split(".")[-1]
+            if types is not None and t not in types:
+                continue
+            if types is None and t == "INT":
+                continue
+            url = r.get("url")
+            if not url:
+                continue
+            label = url.rstrip("/").split("/")[-1]
+            out.append(f"[{label}]({url})")
+        return ", ".join(out)
+
+    @staticmethod
+    def _support_doc_links(hit: dict) -> str:
+        docs = hit.get("supporting_docs") or []
+        return ", ".join(f"[{i + 1}]({url})" for i, url in enumerate(docs))
+
+    def analyses(
+        self,
+        code: str,
+        view: str = "cards",
+        entry_type: str | None = None,
+        ongoing_only: bool = False,
+        show_circle: bool = True,
+    ) -> str:
+        hits = self._hits_by_group.get(code, [])
+        if entry_type:
+            hits = [h for h in hits if h.get("entry_type") == entry_type]
+        if ongoing_only:
+            hits = [h for h in hits if self._is_ongoing_analysis(h)]
+        if view == "list":
+            lines = [
+                "| Reference code | Title | Status | Leading group | Int Notes | Support Docs | Git Repo |",
+                "|---|---|---|---|---|---|---|",
+            ]
+            for hit in sorted(hits, key=lambda h: h.get("ref_code", "")):
+                status = hit.get("phase") or self._badge(hit)[0]
+                title = self._display_title(hit).replace("|", "\\|")
+                ref = hit.get("ref_code", "")
+                int_notes = self._repo_links(hit, {"INT"})
+                support_docs = self._support_doc_links(hit)
+                git_repo = self._repo_links(hit, None)
+                lines.append(
+                    f'| [{ref}]({self._glance_url(hit)}) | {title} | {status} | {hit.get("leading_group", "")} '
+                    f'| {int_notes} | {support_docs} | {git_repo} |'
+                )
+            return "\n".join(lines)
+        return "\n".join(self._render_card(hit, show_circle=show_circle) for hit in hits)
+
+    def analysis(self, ref_code: str) -> str:
+        hit = self._find(ref_code)
+        if not hit:
+            return f'<p><em>No Glance/STARE entry found for {_e(ref_code)}.</em></p>'
+        return self._render_card(hit)

atlasdocs_metadata-0.9.0/atlasdocs_metadata/group.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import yaml
+
+_LINK_LABELS = {
+    "contacts":        "Contacts",
+    "mandate":         "Mandate",
+    "indico":          "Indico",
+    "gitlab":          "GitLab",
+    "mattermost":      "Mattermost",
+    "jira":            "Jira",
+    "glance":          "Glance",
+    "egroup":          "E-Group",
+    "atlastalk":       "AtlasTalk",
+    "recommendations": "Recommendations",
+}
+
+_LINK_ICONS = {
+    "contacts":   "lucide/mail",
+    "gitlab":     "simple/gitlab",
+    "mattermost": "lucide/compass",
+}
+
+
+def _icon_md(icon: str) -> str:
+    """Convert 'lucide/info' -> ':lucide-info: '"""
+    if not icon:
+        return ""
+    return ":" + icon.replace("/", "-") + ": "
+
+
+class GroupMacros:
+    def __init__(self, path: Path | str):
+        with open(path) as f:
+            data = yaml.safe_load(f)
+        group = data.get("group", {})
+        self._contacts = {k: v["contacts"] for k, v in group.items() if isinstance(v, dict) and "contacts" in v}
+        self._email    = {k: v["email"]    for k, v in group.items() if isinstance(v, dict) and "email"    in v}
+        self._links    = data.get("links", {})
+        self._default_icon = data.get("icon")
+
+    def contacts(self, key):
+        names = self._contacts.get(key, "")
+        if not names:
+            return ""
+        account = self._email.get(key, "")
+        if not account:
+            return names
+        address = f"{account}@cern.ch"
+        icon = _icon_md(_LINK_ICONS["contacts"])
+        return f'[{icon}{names}](mailto:{address} "{address}")'
+
+    def email(self, key):
+        value = self._email.get(key, "")
+        return f"[{value}](mailto:{value}@cern.ch)" if value else ""
+
+    @staticmethod
+    def _sanitize(text):
+        """Neutralize characters that would break markdown link/title syntax
+        (unescaped quotes ending a title early, brackets ending a label
+        early, embedded newlines) when text comes from free-form data
+        (Mattermost purposes, CDS policy text, etc.)."""
+        text = re.sub(r"\s+", " ", text).strip()
+        return text.replace('"', "'").replace("[", "(").replace("]", ")")
+
+    @classmethod
+    def _render_link(cls, value, fallback_label, default_icon=None):
+        """Render a link value as markdown. `value` is either a bare URL
+        string, or an object with a mandatory `url` (and optional `label` /
+        `description` overriding `fallback_label` and adding a hover title).
+        `default_icon` (a 'namespace/name' shortcode) is used unless the
+        entry itself sets its own `icon`."""
+        if isinstance(value, dict):
+            url = value.get("url", "")
+            if not url:
+                return ""
+            label = cls._sanitize(value.get("label") or fallback_label)
+            desc = value.get("description", "")
+            title = f' "{cls._sanitize(desc)}"' if desc else ""
+            icon = _icon_md(value.get("icon") or default_icon)
+            return f"[{icon}{label}]({url}{title})"
+        if not value:
+            return ""
+        icon = _icon_md(default_icon)
+        return f"[{icon}{cls._sanitize(fallback_label)}]({value})"
+
+    def locations(self, key, sub=None):
+        entry = self._links.get(key, "")
+        icon = _LINK_ICONS.get(key) or self._default_icon
+        if isinstance(entry, dict) and "url" not in entry:
+            # nested multi-variant map (e.g. recommendations); default to
+            # "latest" when no sub-key is given
+            sub = sub or "latest"
+            base = _LINK_LABELS.get(key, key.title())
+            return self._render_link(entry.get(sub, ""), f"{sub.title()} {base}", icon)
+        if sub is not None:
+            return ""
+        label = _LINK_LABELS.get(key, key.title())
+        return self._render_link(entry, label, icon)

atlasdocs_metadata-0.9.0/atlasdocs_metadata/macros.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+"""
+zensical macros pluglet — loaded via `modules = ["atlasdocs_metadata.macros"]`
+in a site's zensical.toml (see https://zensical.org/docs/setup/extensions/macros/#modules-zensicaltoml),
+on top of that site's own module_name for anything site-specific.
+
+Populates one macro variable per data_<CODE>.yml under data/metadata/ (as
+synced by fetch_metadata.py) plus GLANCE if any stare_*.json.br is present.
+A site with no data/metadata/ (fetch never run, or opted out) is a no-op.
+
+NOTE: zensical enforces a "no watched paths outside the project folder"
+policy for `modules` targets (and for venvs) — as of zensical 0.0.52,
+violating it panics its watcher thread (crates/zensical/src/watcher.rs:299,
+"invariant") on both `build` and `serve`, instead of a clean error. Confirmed
+via a minimal repro: modules=[...] pointing at a file inside the project
+folder builds fine; the identical config pointing outside it panics every
+time. This only bites a *local* dev setup that installs atlasdocs-metadata
+via a path override outside the consumer's project folder (as
+atlas-docs-bphy/internal did before it had a real PyPI release) — a normal
+install (into .pixi/envs/.../site-packages, which is inside the project
+folder) should be fine. Until atlasdocs-metadata has a real release,
+consumer sites should instead import GroupMacros/GlanceMacros directly from
+their own module_name-loaded file and call the same loading logic as
+define_env() below (see atlas-docs-bphy/internal/macros/atlasdocs_main.py
+for the current workaround). Keep this module correct and in sync with that
+workaround regardless — it's the intended path once there's a real release,
+not dead code.
+"""
+
+from pathlib import Path
+
+import yaml
+
+from .glance import GlanceMacros
+from .group import GroupMacros
+
+_VENDOR_DIRNAME = "metadata"
+
+
+def _load_yaml(path: Path) -> dict:
+    with open(path) as f:
+        return yaml.safe_load(f) or {}
+
+
+def define_env(env):
+    data_dir = Path.cwd() / "data" / _VENDOR_DIRNAME
+    if not data_dir.is_dir():
+        return
+
+    for path in sorted(data_dir.glob("data_*.yml")):
+        key = path.stem[len("data_"):]
+        data = _load_yaml(path)
+        env.variables[key] = GroupMacros(path) if isinstance(data, dict) and "group" in data else data
+
+    if any(data_dir.glob("stare_*.json.br")):
+        env.variables["GLANCE"] = GlanceMacros(data_dir)

atlasdocs_metadata-0.9.0/pixi.toml

@@ -0,0 +1,21 @@
+[workspace]
+name = "atlasdocs-metadata-dev"
+description = "Development environment for the atlasdocs-metadata package"
+channels = ["conda-forge"]
+platforms = ["osx-arm64", "linux-64"]
+
+[dependencies]
+python = ">=3.11,<3.15"
+uv = ">=0.4"
+git = "*"
+pyyaml = "*"
+brotli-python = "*"
+
+[tasks.build]
+cmd = "uv build"
+description = "Build wheel and sdist"
+
+[tasks.newrelease]
+cmd = "bash scripts/release.sh"
+depends-on = []
+description = "Bump version in pyproject.toml, build, and publish to PyPI"

atlasdocs_metadata-0.9.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "atlasdocs-metadata"
+version = "0.9.0"
+description = "Syncs the atlasdocs/metadata registry (data_<CODE>.yml / stare_<CODE>.json.br, every group) and renders it via GroupMacros/GlanceMacros for atlasdocs-theme sites"
+authors = [
+  { name = "Jason Oliver", email = "jason.oliver@cern.ch" }
+]
+license = "Apache-2.0"
+requires-python = ">=3.9"
+dependencies = ["pyyaml>=6", "brotli>=1.1"]
+
+[tool.hatch.build.targets.wheel]
+include = ["atlasdocs_metadata"]
+
+[project.scripts]
+fetch-metadata = "atlasdocs_metadata.fetch_metadata:main"

atlasdocs_metadata-0.9.0/scripts/release.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PYPROJECT="$(dirname "$0")/../pyproject.toml"
+PYPROJECT="$(realpath "$PYPROJECT")"
+PKG_DIR="$(dirname "$PYPROJECT")"
+
+current_version() {
+  grep '^version' "$PYPROJECT" | sed 's/version = "\(.*\)"/\1/'
+}
+
+bump_version() {
+  local part="${1:-patch}"
+  local ver
+  ver="$(current_version)"
+  IFS='.' read -r major minor patch <<< "$ver"
+  case "$part" in
+    major) major=$((major + 1)); minor=0; patch=0 ;;
+    minor) minor=$((minor + 1)); patch=0 ;;
+    patch) patch=$((patch + 1)) ;;
+    *) echo "Unknown part: $part (use major|minor|patch)"; exit 1 ;;
+  esac
+  echo "${major}.${minor}.${patch}"
+}
+
+set_version() {
+  local new="$1"
+  sed -i '' "s/^version = \".*\"/version = \"${new}\"/" "$PYPROJECT"
+  echo "Version set to ${new}"
+}
+
+PART="${1:-}"
+SKIP_PUBLISH="${2:-}"
+CURRENT="$(current_version)"
+
+if [[ -z "$PART" ]]; then
+  echo "Current version: ${CURRENT}"
+  echo "Increment:  [1] patch  [2] minor  [3] major"
+  read -r -p "Choice [1]: " choice
+  case "${choice:-1}" in
+    1|patch) PART="patch" ;;
+    2|minor) PART="minor" ;;
+    3|major) PART="major" ;;
+    *) echo "Invalid choice."; exit 1 ;;
+  esac
+fi
+
+if [[ "$PART" == exact:* ]]; then
+  NEW_VERSION="${PART#exact:}"
+else
+  NEW_VERSION="$(bump_version "$PART")"
+fi
+
+echo "Current: ${CURRENT}  →  New: ${NEW_VERSION}  (${PART})"
+read -r -p "Continue? [y/N] " confirm
+[[ "$confirm" =~ ^[Yy]$ ]] || { echo "Aborted."; exit 0; }
+
+set_version "$NEW_VERSION"
+
+echo ""
+echo "▶ uv build"
+uv build --project "$PKG_DIR"
+
+if [[ "$SKIP_PUBLISH" != "--no-publish" ]]; then
+  echo ""
+  echo "▶ uv publish"
+  uv publish dist/atlasdocs_metadata-"${NEW_VERSION}"*.whl dist/atlasdocs_metadata-"${NEW_VERSION}".tar.gz
+fi
+
+echo ""
+echo "▶ git add + commit + tag"
+REPO_ROOT="$(git -C "$PKG_DIR" rev-parse --show-toplevel)"
+git -C "$REPO_ROOT" add "$PYPROJECT"
+git -C "$REPO_ROOT" commit -m "chore(metadata): release ${NEW_VERSION}"
+git -C "$REPO_ROOT" tag "atlasdocs-metadata/v${NEW_VERSION}"
+
+echo ""
+echo "✓ Released atlasdocs-metadata ${NEW_VERSION}"
+echo "  Push with: git push && git push --tags"