dpm-tool 0.1.0__py3-none-any.whl

app.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import logging
+
+from textual import work
+from textual.app import App
+
+from dpm.config import load_theme, save_theme
+from dpm.ui._utils import ConfirmCancelModal
+from dpm.ui.main_screen import MainScreen
+
+
+class DpmToolApp(App):
+    TITLE = "EIOPA DPM Toolkit"
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("escape", "go_back", "Back"),
+    ]
+
+    def on_mount(self) -> None:
+        # Restore the persisted theme (ignore an unknown/removed theme name), then
+        # persist any later change (e.g. via the command palette) as it happens.
+        saved = load_theme()
+        if saved and saved in self.available_themes:
+            self.theme = saved
+        self.watch(self, "theme", self._persist_theme, init=False)
+
+        # Push rather than override get_default_screen: Textual only loads a
+        # screen's CSS_PATH when the screen is pushed, not for the default screen.
+        self.push_screen(MainScreen())
+
+    def _persist_theme(self, theme: str) -> None:
+        save_theme(theme)
+
+    def action_go_back(self) -> None:
+        self._go_back()
+
+    @work(exclusive=True, name="go-back")
+    async def _go_back(self) -> None:
+        """Go back a screen, confirming first if the current screen has a running task.
+
+        Shared by the Escape binding and every screen's '← Back' button. ``workers`` is
+        app-global, so we match on ``w.node`` to count only the current screen's tasks
+        (this back worker itself runs on the app).
+        """
+        if isinstance(self.screen, MainScreen):
+            return  # main menu — nothing to go back to
+        screen = self.screen
+        running = [w for w in self.workers if w.is_running and w.node is screen]
+        if running:
+            if not await self.push_screen_wait(ConfirmCancelModal()):
+                return
+            for w in running:
+                w.cancel()
+        self.pop_screen()
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.WARNING)
+    DpmToolApp().run()
+
+
+if __name__ == "__main__":
+    main()

dpm/_constants.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+# ── On-disk layout ──────────────────────────────────────────────────────────
+# All DuckDB artifacts live under a single root: ingested version databases in
+# ``db/versions`` and computed delta databases in ``db/delta``.
+DB_ROOT = Path("db")
+VERSIONS_DIR = DB_ROOT / "versions"
+DELTA_DIR = DB_ROOT / "delta"
+
+# Downloaded source workbooks are cached here; app config lives at CONFIG_PATH.
+DOWNLOADS_DIR = Path("data/downloads")
+CONFIG_PATH = Path("dpm-tool.config.json")
+
+ROW_RE = re.compile(r"\b[A-Z]{0,3}R\d{3,6}\b", re.I)
+COL_RE = re.compile(r"\b[A-Z]{0,3}C\d{3,6}\b", re.I)
+CODE_RE = re.compile(r"\b[A-Z]{1,3}\.(?:[0-9]{2}\.){1,6}[0-9]{2}\b", re.I)
+QNAME_RE = re.compile(
+    r"(^\{[^}]+\}.+)|(^[A-Za-z_][\w.-]*:[A-Za-z_][\w.-]*$)"
+    r"|(^[A-Za-z_][\w.-]*\.[A-Za-z_][\w.-]*(?:\.[A-Za-z_][\w.-]*)+$)"
+)
+QNAME_TOKEN_RE = re.compile(r"\b(?:s2md_met|[A-Za-z_][\w.-]*):[A-Za-z_][\w.-]*\b")
+METRIC_LABEL_RE = re.compile(r"Metric:\s*(.*?)(?:\)\s*(?:\[|$)|$)")
+# Dimension declaration, e.g. "s2c_dim:BL (Line of business [general])"
+DIM_DECL_RE = re.compile(r"\bs2c_dim:([A-Za-z0-9]+)\b", re.I)
+# Dimension member, e.g. "s2c_LB:x91 (Neither unit-linked ...)". Excludes the
+# `dim` domain so declarations are not mistaken for members.
+MEMBER_RE = re.compile(r"\bs2c_(?!dim:)([A-Za-z0-9]+):(x\d+)\b", re.I)
+# Trailing parenthetical label, e.g. "... (Line of business [general])"
+PAREN_LABEL_RE = re.compile(r"\((.*)\)\s*$")
+GENERIC_TOC_CODES = frozenset({"T99", "T.99", "T.99.99", "TOC", "TABLE OF CONTENTS"})
+
+METRIC_COLS = [
+    "perimeter",
+    "template_code",
+    "subtemplate_code",
+    "row_code",
+    "column_code",
+    "qname",
+    "metric_label",
+    "row_label",
+    "column_label",
+]
+# Default single value column: a subtemplate whose only column is this is a plain
+# row list; any other column code makes it a row×column matrix (see change_type).
+DEFAULT_COLUMN_CODE = "C0010"
+KEY_COLS = ["perimeter", "template_code", "subtemplate_code", "row_code", "column_code"]
+IDENTITY_COLS = ["template_code", "subtemplate_code", "row_code", "column_code"]

dpm/_text.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+
+from dpm._constants import (
+    CODE_RE,
+    COL_RE,
+    DIM_DECL_RE,
+    MEMBER_RE,
+    METRIC_LABEL_RE,
+    PAREN_LABEL_RE,
+    QNAME_RE,
+    QNAME_TOKEN_RE,
+    ROW_RE,
+)
+
+
+def norm(value: object) -> str:
+    if value is None:
+        return ""
+    return re.sub(r"\s+", " ", str(value).replace("\n", " ").replace("\r", " ").strip())
+
+
+def first_match(pattern: re.Pattern[str], text: str) -> str:
+    match = pattern.search(text or "")
+    return match.group(0).upper() if match else ""
+
+
+def extract_qname(text: str) -> str:
+    match = QNAME_TOKEN_RE.search(norm(text))
+    return match.group(0) if match else ""
+
+
+def extract_metric_label(text: str) -> str:
+    match = METRIC_LABEL_RE.search(norm(text))
+    return match.group(1).strip() if match else ""
+
+
+def is_qname(text: str) -> bool:
+    text = norm(text)
+    return bool(extract_qname(text) or QNAME_RE.search(text))
+
+
+def extract_paren_label(text: str) -> str:
+    match = PAREN_LABEL_RE.search(norm(text))
+    return match.group(1).strip() if match else ""
+
+
+def extract_dimension_token(text: str) -> str:
+    """Return the full 's2c_dim:XX' declaration token, or ''."""
+    match = DIM_DECL_RE.search(norm(text))
+    return match.group(0) if match else ""
+
+
+def is_dimension_decl(text: str) -> bool:
+    return bool(DIM_DECL_RE.search(norm(text)))
+
+
+def extract_member_token(text: str) -> str:
+    """Return the full 's2c_XX:xN' member token, or ''."""
+    match = MEMBER_RE.search(norm(text))
+    return match.group(0) if match else ""
+
+
+def is_member(text: str) -> bool:
+    return bool(MEMBER_RE.search(norm(text)))
+
+
+def nearest_text(values: Iterable[str]) -> str:
+    for value in values:
+        text = norm(value)
+        if (
+            text
+            and not ROW_RE.fullmatch(text)
+            and not COL_RE.fullmatch(text)
+            and not CODE_RE.fullmatch(text)
+            and text.lower() != "metrics"
+            and not is_qname(text)
+        ):
+            return text[:500]
+    return ""

dpm/_types.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TypedDict
+
+import polars as pl
+from openpyxl import load_workbook
+from openpyxl.workbook.workbook import Workbook
+
+from dpm._text import norm
+
+
+@dataclass(frozen=True)
+class TocEntry:
+    perimeter: str
+    template_code: str
+    subtemplate_code: str
+    sheet_name: str | None = None
+
+
+@dataclass(frozen=True)
+class DpmDataset:
+    metrics: pl.DataFrame
+    entries: list[TocEntry]
+    # Full metric catalogue (metric_code, metric_label) for the metrics delta.
+    metric_catalog: pl.DataFrame = field(default_factory=pl.DataFrame)
+    # Flat dimensions × members frame for the dimensions delta.
+    dimension_members: pl.DataFrame = field(default_factory=pl.DataFrame)
+
+    @property
+    def templates(self) -> set[tuple[str, str]]:
+        return {(e.perimeter, e.template_code) for e in self.entries}
+
+    @property
+    def subtemplates(self) -> set[tuple[str, str, str]]:
+        return {
+            (e.perimeter, e.template_code, e.subtemplate_code) for e in self.entries
+        }
+
+
+@dataclass(frozen=True)
+class DeltaResult:
+    """The three-section delta between two DPM versions.
+
+    Each frame follows the canonical snake_case schema in ``dpm.delta_schema``:
+    ``structure`` the per-perimeter fact/structural delta (``DELTA_STRUCTURE_COLS``),
+    ``metrics`` the metric-catalogue delta (``DELTA_METRIC_COLS``), and
+    ``dimensions`` the dimensions/members delta (``DELTA_DIMENSION_COLS``).
+    """
+
+    structure: pl.DataFrame
+    metrics: pl.DataFrame
+    dimensions: pl.DataFrame
+
+
+class TemplateRow(TypedDict):
+    template_code: str
+    template_label: str
+
+
+class SubtemplateRow(TypedDict):
+    subtemplate_code: str
+    template_code: str
+    subtemplate_label: str
+    subtemplate_type: str
+
+
+class PerimeterRow(TypedDict):
+    perimeter_code: str
+
+
+class PerimeterTemplateRow(TypedDict):
+    perimeter_code: str
+    template_code: str
+
+
+class MetricRow(TypedDict):
+    metric_code: str
+    metric_label: str
+
+
+class FactRow(TypedDict):
+    subtemplate_code: str
+    row_code: str
+    column_code: str
+    row_label: str
+    column_label: str
+    metric_code: str
+
+
+class DimensionRow(TypedDict):
+    dimension_code: str
+    dimension_label: str
+
+
+class DimensionMemberRow(TypedDict):
+    member_code: str
+    dimension_code: str
+    member_label: str
+
+
+class FactDimensionRow(TypedDict):
+    subtemplate_code: str
+    row_code: str
+    column_code: str
+    dimension_code: str
+    member_code: str
+
+
+@dataclass
+class WorkbookCache:
+    path: Path
+    wb: Workbook
+    sheet_names: list[str]
+    _matrix_cache: dict[str, list[list[str]]] = field(
+        default_factory=dict, repr=False, init=False
+    )
+    _crossed_cache: dict[str, frozenset[tuple[int, int]]] = field(
+        default_factory=dict, repr=False, init=False
+    )
+
+    @classmethod
+    def open(cls, path: Path) -> WorkbookCache:
+        wb = load_workbook(path, read_only=True, data_only=True)
+        return cls(path=path, wb=wb, sheet_names=list(wb.sheetnames))
+
+    def close(self) -> None:
+        self.wb.close()
+
+    def _ensure_parsed(self, sheet_name: str) -> None:
+        if sheet_name in self._matrix_cache:
+            return
+        ws = self.wb[sheet_name]
+        rows: list[list[str]] = []
+        crossed: set[tuple[int, int]] = set()
+        for r_idx, row in enumerate(ws.iter_rows()):
+            row_vals: list[str] = []
+            for cell in row:
+                row_vals.append(norm(cell.value))
+                try:
+                    if cell.fill and cell.fill.fill_type == "solid":
+                        col_idx = getattr(cell, "column", None)
+                        if col_idx is not None:
+                            crossed.add((r_idx, col_idx - 1))
+                except (AttributeError, TypeError):
+                    pass
+            rows.append(row_vals)
+        self._matrix_cache[sheet_name] = rows
+        self._crossed_cache[sheet_name] = frozenset(crossed)
+
+    def matrix(self, sheet_name: str) -> list[list[str]]:
+        self._ensure_parsed(sheet_name)
+        return self._matrix_cache[sheet_name]
+
+    def crossed_cells(self, sheet_name: str) -> frozenset[tuple[int, int]]:
+        """Return 0-indexed (row, col) positions where cells have a solid fill (invalid data cells)."""
+        self._ensure_parsed(sheet_name)
+        return self._crossed_cache.get(sheet_name, frozenset())
+
+
+@dataclass(frozen=True)
+class ApplyStats:
+    perimeter: str
+    facts_before: int
+    facts_after: int
+    deleted_facts: int
+    renamed_facts: int
+    deleted_qnames: int
+    modified_qnames: int

dpm/config.py

@@ -0,0 +1,90 @@
+"""Small JSON-backed app config.
+
+Holds the list of DPM versions the user tracks — each entry is
+``{"version": "2.10.0", "url": <str|None>}`` (an optional explicit download URL
+that overrides auto-resolution, needed for the odd hotfix builds) — plus the
+selected UI ``theme``.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+
+from dpm._constants import CONFIG_PATH
+from dpm.workflows import version_key
+
+LOG = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class VersionEntry:
+    version: str
+    url: str | None = None
+
+
+def _load_raw(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError) as exc:
+        LOG.warning("Could not read config %s: %s", path, exc)
+        return {}
+
+
+def _save_raw(raw: dict, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(raw, indent=2))
+
+
+def load_versions(path: Path = CONFIG_PATH) -> list[VersionEntry]:
+    raw = _load_raw(path)
+    entries = [
+        VersionEntry(version=str(e["version"]), url=(e.get("url") or None))
+        for e in raw.get("versions", [])
+        if e.get("version")
+    ]
+    return sorted(entries, key=lambda e: version_key(e.version))
+
+
+def save_versions(entries: list[VersionEntry], path: Path = CONFIG_PATH) -> None:
+    # Merge into the existing config so unrelated keys (e.g. ``theme``) survive.
+    raw = _load_raw(path)
+    raw["versions"] = [
+        {"version": e.version, **({"url": e.url} if e.url else {})}
+        for e in sorted(entries, key=lambda e: version_key(e.version))
+    ]
+    _save_raw(raw, path)
+
+
+def load_theme(path: Path = CONFIG_PATH) -> str | None:
+    """Return the persisted UI theme name, or ``None`` if unset."""
+    return _load_raw(path).get("theme") or None
+
+
+def save_theme(theme: str, path: Path = CONFIG_PATH) -> None:
+    """Persist the selected UI theme, preserving the rest of the config."""
+    raw = _load_raw(path)
+    raw["theme"] = theme
+    _save_raw(raw, path)
+
+
+def add_version(
+    version: str, url: str | None = None, path: Path = CONFIG_PATH
+) -> list[VersionEntry]:
+    """Add (or update the URL of) a version, returning the new list."""
+    version = version.strip()
+    url = (url or "").strip() or None
+    entries = [e for e in load_versions(path) if e.version != version]
+    entries.append(VersionEntry(version=version, url=url))
+    save_versions(entries, path)
+    return load_versions(path)
+
+
+def remove_version(version: str, path: Path = CONFIG_PATH) -> list[VersionEntry]:
+    entries = [e for e in load_versions(path) if e.version != version]
+    save_versions(entries, path)
+    return load_versions(path)