atlasdocs-indico 0.9.0__tar.gz

atlasdocs_indico-0.9.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: atlasdocs-indico
+Version: 0.9.0
+Summary: Indico integration scripts for atlasdocs-theme
+Author-email: Jason Oliver <jason.oliver@cern.ch>
+License-Expression: Apache-2.0
+Requires-Python: >=3.9
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: requests>=2.28

atlasdocs_indico-0.9.0/atlasdocs_indico/__init__.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+
+def __getattr__(name: str):
+    if name == "create_indico_pages":
+        from .prepare_indico_pages import create_indico_pages
+        return create_indico_pages
+    if name == "create_indico_nav":
+        from .prepare_indico_nav import create_indico_nav
+        return create_indico_nav
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = ["create_indico_pages", "create_indico_nav"]

atlasdocs_indico-0.9.0/atlasdocs_indico/fetch_indico.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+"""
+Fetch Indico category events and save them as JSON files.
+
+Reads which categories to fetch from indico.toml in the hub directory.
+Writes one file per category:
+    data/indico/category/{id}/category_{id}.json
+
+New events are merged with any existing file (most recent event wins on URL clash).
+Requires an Indico API token via --token or the INDICO_API_TOKEN env variable.
+
+Usage examples
+--------------
+Fetch all categories from indico.toml (no args needed):
+    python -m atlasdocs_indico.fetch_indico
+
+Override categories from the command line:
+    python -m atlasdocs_indico.fetch_indico --category 1234
+    python -m atlasdocs_indico.fetch_indico --category 1234 --category 5678
+
+Limit the date range:
+    python -m atlasdocs_indico.fetch_indico --years 2
+    python -m atlasdocs_indico.fetch_indico --start-date 2023-01-01
+
+Pixi (args after --):
+    pixi run fetch-indico
+    pixi run fetch-indico -- --category 1234
+"""
+
+import argparse
+import json
+import os
+import sys
+import tomllib
+from pathlib import Path
+
+from dotenv import load_dotenv
+load_dotenv(Path('.env').resolve())
+
+# ── Configuration ──────────────────────────────────────────────────────────────
+
+INDICO_SITE = "https://indico.cern.ch"
+DATA_DIR = "data/indico/category"
+DEFAULT_YEARS = 2
+INDICO_CONFIG_FILE = "indico.toml"
+
+
+# ── Config loading ─────────────────────────────────────────────────────────────
+
+def load_indico_config(hub_dir: str = ".") -> dict:
+    """Load indico.toml. Returns {categories: [{id, label}], site, years}."""
+    config_path = Path(hub_dir) / INDICO_CONFIG_FILE
+    if not config_path.exists():
+        return {"categories": [], "site": INDICO_SITE, "years": DEFAULT_YEARS}
+    with open(config_path, "rb") as f:
+        data = tomllib.load(f)
+    return {
+        "categories": data.get("categories", []),
+        "site": data.get("site", INDICO_SITE),
+        "years": int(data.get("years", DEFAULT_YEARS)),
+    }
+
+
+# ── Fetch ──────────────────────────────────────────────────────────────────────
+
+def fetch_category(
+    category_id: int,
+    api_token: str,
+    site: str = INDICO_SITE,
+    years: int = DEFAULT_YEARS,
+    start_date: str | None = None,
+    end_date: str | None = None,
+) -> list[dict]:
+    from .indicoapi.indico import Indico
+
+    indico = Indico(
+        category_id=category_id,
+        api_token=api_token,
+        site=site,
+        years=years,
+        start_date=start_date,
+        end_date=end_date,
+    )
+    meetings = indico.get_meetings(include=None, exclude=None)
+
+    events = []
+    for event in meetings:
+        contributions = [
+            {
+                "title": c.title,
+                "url": c.url,
+                "speakers": c.speakers,
+                "minutes": c.minutes,
+                "start_time": c.start_time,
+                "attachments": c.attachments,
+            }
+            for c in event.contributions
+        ]
+        events.append({
+            "url": event.url,
+            "date": event.date,
+            "title": event.title,
+            "minutes_url": event.minutes_url,
+            "contributions": contributions,
+        })
+
+    return events
+
+
+# ── Prepare ────────────────────────────────────────────────────────────────────
+
+def save_category(category_id: int | str, events: list[dict], data_dir: str) -> Path:
+    cat_id = str(category_id)
+    out_path = Path(data_dir) / cat_id / f"category_{cat_id}.json"
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    existing: dict[str, dict] = {}
+    if out_path.exists():
+        try:
+            with open(out_path) as f:
+                for ev in json.load(f):
+                    if ev.get("url"):
+                        existing[ev["url"]] = ev
+        except Exception:
+            pass
+
+    n_before = len(existing)
+    for ev in events:
+        if ev.get("url"):
+            existing[ev["url"]] = ev
+
+    merged = sorted(existing.values(), key=lambda e: e.get("date", ""), reverse=True)
+    with open(out_path, "w") as f:
+        json.dump(merged, f, separators=(",", ":"))
+
+    new_count = len(merged) - n_before
+    new_str = f"+{new_count} new" if new_count else "no change"
+    print(f"[indico] [{cat_id}] {len(merged)} events ({new_str}) → {out_path}")
+    return out_path
+
+
+def fetch_indico(
+    category_ids: list[int],
+    api_token: str,
+    site: str = INDICO_SITE,
+    years: int = DEFAULT_YEARS,
+    start_date: str | None = None,
+    end_date: str | None = None,
+    data_dir: str = DATA_DIR,
+    hub_dir: str = ".",
+) -> None:
+    resolved_data_dir = str(Path(hub_dir) / data_dir)
+    errors = []
+    for cat_id in category_ids:
+        try:
+            events = fetch_category(
+                category_id=cat_id,
+                api_token=api_token,
+                site=site,
+                years=years,
+                start_date=start_date,
+                end_date=end_date,
+            )
+            save_category(cat_id, events, data_dir=resolved_data_dir)
+        except Exception as e:
+            print(f"[indico] ERROR: category {cat_id}: {e}")
+            errors.append(cat_id)
+
+    if errors:
+        print(f"[indico] Done with {len(errors)} error(s): {errors}")
+        sys.exit(1)
+    n = len(category_ids)
+    print(f"[indico] Fetched {n} {'category' if n == 1 else 'categories'}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Fetch Indico category events and save as JSON.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__.split("Usage examples")[1] if __doc__ and "Usage examples" in __doc__ else "",
+    )
+    parser.add_argument(
+        "--category", "-c",
+        metavar="ID",
+        action="append",
+        type=int,
+        help="Category ID to fetch (repeat for multiple: -c 1234 -c 5678). "
+             "Defaults to all categories listed in indico.toml.",
+    )
+    parser.add_argument("--token", help="Indico API token (default: $INDICO_API_TOKEN)")
+    parser.add_argument("--site", default=None, help=f"Indico base URL (default: from indico.toml or {INDICO_SITE})")
+    parser.add_argument("--years", type=int, default=None, help=f"Years of history to fetch (default: from indico.toml or {DEFAULT_YEARS})")
+    parser.add_argument("--start-date", metavar="YYYY-MM-DD", help="Override start date")
+    parser.add_argument("--end-date",   metavar="YYYY-MM-DD", help="Override end date")
+    parser.add_argument("--data-dir", default=DATA_DIR, help=f"Output directory (default: {DATA_DIR})")
+
+    args = parser.parse_args()
+
+    hub_dir = str(Path.cwd())
+    config = load_indico_config(hub_dir)
+
+    api_token = args.token or os.environ.get("INDICO_API_TOKEN")
+    if not api_token:
+        parser.error("API token required — use --token or set INDICO_API_TOKEN")
+
+    # --category overrides config; fall back to all categories in indico.toml
+    if args.category:
+        category_ids = args.category
+    else:
+        category_ids = [int(c["id"]) for c in config["categories"]]
+        if not category_ids:
+            parser.error("No categories specified — pass --category or add entries to indico.toml")
+
+    site  = args.site  or config["site"]
+    years = args.years or config["years"]
+
+    fetch_indico(
+        category_ids=category_ids,
+        api_token=api_token,
+        site=site,
+        years=years,
+        start_date=args.start_date,
+        end_date=args.end_date,
+        data_dir=args.data_dir,
+        hub_dir=hub_dir,
+    )
+
+
+if __name__ == "__main__":
+    main()

atlasdocs_indico-0.9.0/atlasdocs_indico/indicoapi/__init__.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+
+def __getattr__(name: str):
+    if name == "Category":
+        from .category import Category
+        return Category
+    if name == "Event":
+        from .event import Event
+        return Event
+    if name == "Contribution":
+        from .contribution import Contribution
+        return Contribution
+    if name == "Indico":
+        from .indico import Indico
+        return Indico
+    if name == "BearerAuth":
+        from .indicorequests import BearerAuth
+        return BearerAuth
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = ["Category", "Event", "Contribution", "Indico", "BearerAuth"]

atlasdocs_indico-0.9.0/atlasdocs_indico/indicoapi/category.py

@@ -0,0 +1,26 @@
+"""Category data model for Indico API."""
+
+from dataclasses import dataclass
+
+# ── Configuration ──────────────────────────────────────────────────────────────
+
+INDICO_BASE_URL = "https://indico.cern.ch"
+
+
+@dataclass
+class Category:
+    """Represents an Indico category."""
+
+    category_id: str
+    name: str
+    num_events: int
+    is_protected: bool = False
+    parent_id: str = None
+    url: str = None
+    immediate_children: list = None
+
+    def __post_init__(self):
+        if self.immediate_children is None:
+            self.immediate_children = []
+        if self.url is None:
+            self.url = f"{INDICO_BASE_URL}/category/{self.category_id}/"

atlasdocs_indico-0.9.0/atlasdocs_indico/indicoapi/contribution.py

@@ -0,0 +1,20 @@
+"""Contribution data model for Indico API - pure data, no rendering."""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Contribution:
+    """Represents an Indico contribution with pure data (no markdown rendering)."""
+
+    title: str
+    url: str
+    speakers: list[str] = field(default_factory=list)
+    minutes: dict = None
+    start_time: str = None
+    end_time: str = None
+    duration: int = None
+    attachments: list[dict] = field(default_factory=list)
+    description: str = None
+    keywords: list[str] = field(default_factory=list)
+    contribution_type: str = None

atlasdocs_indico-0.9.0/atlasdocs_indico/indicoapi/event.py

@@ -0,0 +1,30 @@
+"""Event data model for Indico API - pure data, no rendering."""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Event:
+    """Represents an Indico event with pure data (no markdown rendering)."""
+
+    url: str
+    date: str
+    title: str
+    contributions: list[dict]
+    time: str = None
+    end_date: str = None
+    end_time: str = None
+    room: str = None
+    location: str = None
+    minutes_url: str = None
+    created_dt: str = None
+    event_type: str = None
+    description: str = None
+    chairpersons: list[dict] = field(default_factory=list)
+    label: dict = None
+    category: str = None
+    category_id: int = None
+
+    def __lt__(self, other):
+        """Sort by date (newest first)."""
+        return self.date > other.date

atlasdocs_indico-0.9.0/atlasdocs_indico/indicoapi/indico.py

@@ -0,0 +1,262 @@
+import datetime
+import functools
+import os
+import re
+import time
+from dataclasses import dataclass, field
+
+from . import indicorequests as ireq
+from .contribution import Contribution
+from .event import Event
+
+REQUEST_DELAY = 0  # seconds between pagination calls
+
+
+def _paginate(fetch_fn, page_size: int, log_prefix: str) -> tuple[list, int]:
+    """Returns (results, number_of_api_calls).
+
+    Stops when Indico returns an empty page. With detail=contributions the limit
+    controls a contribution offset (not a hard cap on returned events), so pages
+    routinely come back with fewer than page_size events even when more exist.
+    """
+    all_results, offset, page_num = [], 0, 1
+    while True:
+        page = fetch_fn(offset=offset)
+        all_results.extend(page)
+        if not page:
+            break
+        offset += page_size
+        page_num += 1
+        if REQUEST_DELAY > 0:
+            time.sleep(REQUEST_DELAY)
+    return all_results, page_num
+
+
+@dataclass
+class Indico:
+    # Accepts a single int or a list of ints; always stored as category_ids list.
+    category_id: int | list[int]
+    api_token: str = None
+    site: str = "https://indico.cern.ch"
+    years: int = 1
+    # Explicit date overrides — take priority over years when provided (YYYY-MM-DD).
+    start_date: str | None = None
+    end_date: str | None = None
+
+    def __post_init__(self):
+        if self.api_token is None:
+            self.api_token = os.environ.get("INDICO_API_TOKEN", None)
+        if self.api_token is None:
+            msg = "Please provide an API token or set INDICO_API_TOKEN in your env"
+            raise ValueError(msg)
+
+        # Normalise to list regardless of whether a single int was supplied.
+        if isinstance(self.category_id, int):
+            self.category_ids: list[int] = [self.category_id]
+        else:
+            self.category_ids = list(self.category_id)
+
+        self.req_kwargs = {"site": self.site, "api_token": self.api_token}
+
+        today = datetime.datetime.now(tz=datetime.timezone.utc).date()
+        if self.start_date is None:
+            self.start_date = (
+                today - datetime.timedelta(days=365 * self.years)
+            ).strftime("%Y-%m-%d")
+        if self.end_date is None:
+            self.end_date = (today + datetime.timedelta(days=15)).strftime("%Y-%m-%d")
+
+        # Legacy single-category URL points at the primary (first) category.
+        self.url = f"{self.site}/category/{self.category_ids[0]}/"
+
+        all_events: list = []
+        self.api_call_count: int = 0
+
+        for cat_id in self.category_ids:
+            fetch_fn = functools.partial(
+                ireq.request_category_contributions,
+                category_id=cat_id,
+                start_date=self.start_date,
+                end_date=self.end_date,
+                limit=ireq.CONTRIBUTIONS_PAGE_SIZE,
+                **self.req_kwargs,
+            )
+            events, calls = _paginate(
+                fetch_fn=fetch_fn,
+                page_size=ireq.CONTRIBUTIONS_PAGE_SIZE,
+                log_prefix=str(cat_id),
+            )
+            all_events.extend(events)
+            self.api_call_count += calls
+
+            if len(self.category_ids) > 1 and REQUEST_DELAY > 0:
+                time.sleep(REQUEST_DELAY)
+
+        self.events = all_events
+
+    @staticmethod
+    def filter_events(
+        results: list,
+        include: list[str] | None = None,
+        exclude: list[str] | None = None,
+    ) -> list:
+        if include is None:
+            include = []
+        if exclude is None:
+            exclude = []
+        include = [x.lower() for x in include]
+        exclude = [x.lower() for x in exclude]
+
+        if not include:
+            return results
+
+        return [
+            r
+            for r in results
+            if any(x in r["title"].lower() for x in include)
+            and not any(x in r["title"].lower() for x in exclude)
+            and not (
+                "label" in r
+                and r["label"] is not None
+                and r["label"].get("title").lower() == "cancelled"
+            )
+        ]
+
+    def get_meetings(
+        self,
+        include: list[str] | None = None,
+        exclude: list[str] | None = None,
+        events_override: list | None = None,
+    ) -> list[Event]:
+        """Return filtered meetings as typed Event objects with Contribution objects."""
+        if exclude is None:
+            exclude = []
+        exclude += ["cancelled"]
+        raw_events = events_override if events_override is not None else self.events
+        filtered = self.filter_events(raw_events, include=include, exclude=exclude)
+
+        results = []
+        for event in filtered:
+            contributions = []
+            for c in event.get("contributions", []):
+                attachments = []
+                for folder in c.get("folders", []):
+                    for a in folder.get("attachments", []):
+                        attachments.append(
+                            {
+                                "url": a.get("download_url", ""),
+                                "filename": a.get(
+                                    "filename", a.get("title", "unknown")
+                                ),
+                                "size": a.get("size"),
+                                "content_type": a.get("content_type"),
+                                "title": a.get("title"),
+                            }
+                        )
+                contributions.append(
+                    Contribution(
+                        title=c.get("title", ""),
+                        url=c.get("url", ""),
+                        speakers=c.get("speakers", []),
+                        minutes=c.get("note"),
+                        start_time=(c.get("startDate") or {}).get("time"),
+                        end_time=(c.get("endDate") or {}).get("time"),
+                        duration=c.get("duration"),
+                        attachments=attachments,
+                        description=c.get("description"),
+                        keywords=c.get("keywords") or [],
+                        contribution_type=(c.get("type") or {}).get("name") if c.get("type") else None,
+                    )
+                )
+            results.append(
+                Event(
+                    url=event.get("url", ""),
+                    date=(event.get("startDate") or {}).get("date", ""),
+                    title=event.get("title", ""),
+                    contributions=contributions,
+                    location=event.get("location"),
+                    room=event.get("room"),
+                    time=(event.get("startDate") or {}).get("time"),
+                    end_date=(event.get("endDate") or {}).get("date"),
+                    end_time=(event.get("endDate") or {}).get("time"),
+                    minutes_url=(
+                        event["note"]["url"]
+                        if event.get("note") and "url" in event["note"]
+                        else None
+                    ),
+                    created_dt=event.get("createdDT"),
+                    event_type=event.get("type"),
+                    description=event.get("description"),
+                    chairpersons=event.get("chairpersons") or [],
+                    label=event.get("label"),
+                    category=event.get("category"),
+                    category_id=event.get("categoryId"),
+                )
+            )
+
+        return sorted(results, key=lambda e: e.date, reverse=True)
+
+    def get_meetings_for_author(self, author: str) -> list[Event]:
+        """Return meetings where all tokens of `author` appear in a speaker's full_name."""
+        tokens = author.lower().split()
+        matching = []
+        for event in self.events:
+            for contrib in event.get("contributions", []):
+                if any(
+                    all(
+                        t in (s.get("fullName") or s.get("full_name") or "").lower()
+                        for t in tokens
+                    )
+                    for s in contrib.get("speakers", [])
+                ):
+                    matching.append(event)
+                    break
+        return self.get_meetings(events_override=matching)
+
+    def get_ical(
+        self,
+        extra_category_ids: list[int] | None = None,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> str:
+        """Return a combined iCal string for all stored categories (+ any extras).
+
+        Paginates automatically if the range contains > 1000 events.
+        Defaults to 60 days in the past through 15 days in the future.
+        """
+        today = datetime.datetime.now(tz=datetime.timezone.utc).date()
+        if start_date is None:
+            start_date = (today - datetime.timedelta(days=60)).strftime("%Y-%m-%d")
+        if end_date is None:
+            end_date = (today + datetime.timedelta(days=15)).strftime("%Y-%m-%d")
+        ids = self.category_ids + (extra_category_ids or [])
+        pages = []
+        offset = 0
+        page_num = 1
+        while True:
+            page = ireq.request_category_ical(
+                category_ids=ids,
+                start_date=start_date,
+                end_date=end_date,
+                offset=offset,
+                **self.req_kwargs,
+            )
+            n_events = page.count("BEGIN:VEVENT")
+            pages.append(page)
+            if n_events < ireq.ICAL_PAGE_SIZE:
+                break
+            offset += ireq.ICAL_PAGE_SIZE
+            page_num += 1
+            if REQUEST_DELAY > 0:
+                time.sleep(REQUEST_DELAY)
+
+        return _merge_ical_pages(pages)
+
+
+def _merge_ical_pages(pages: list[str]) -> str:
+    if not pages:
+        return ""
+    all_text = "\n".join(pages)
+    events = re.findall(r"BEGIN:VEVENT.*?END:VEVENT", all_text, re.DOTALL)
+    header = pages[0].split("BEGIN:VEVENT")[0].rstrip()
+    return "\n".join([header] + events + ["END:VCALENDAR"])