dpm-tool 0.1.0__tar.gz

dpm_tool-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZvNico
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dpm_tool-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: dpm-tool
+Version: 0.1.0
+Summary: Textual TUI for EIOPA Solvency II DPM: ingest annotated-templates workbooks, diff versions, and roll deltas onto XBRL instances.
+Author-email: ZvNico <nicolas.baconnier@efrei.net>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ZvNico/michael
+Project-URL: Repository, https://github.com/ZvNico/michael
+Project-URL: Issues, https://github.com/ZvNico/michael/issues
+Keywords: eiopa,solvency-ii,dpm,xbrl,regulatory-reporting,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: duckdb>=1.1.0
+Requires-Dist: lxml>=6.1.1
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: polars>=1.42.1
+Requires-Dist: pyarrow>=25.0.0
+Requires-Dist: textual>=0.80.0
+Requires-Dist: textual-fspicker>=1.0.1
+Requires-Dist: xlsxwriter>=3.2.0
+Dynamic: license-file
+
+# dpm-tool
+
+A terminal UI toolkit for working with the EIOPA Solvency II **Data Point Model
+(DPM)**. It ingests the official annotated-templates workbooks into local
+databases, compares two DPM versions to produce a reviewable delta, and rolls
+that delta forward onto your XBRL instance documents.
+
+Everything runs in a [Textual](https://textual.textualize.io/) TUI — no
+subcommands to memorise.
+
+---
+
+## Install
+
+```bash
+uv tool install dpm-tool     # as a standalone tool
+# or, inside a project
+uv add dpm-tool
+```
+
+Requires Python ≥ 3.12.
+
+## Run
+
+```bash
+dpm-tool
+```
+
+This launches the **EIOPA DPM Toolkit** home screen. Navigate with the arrow
+keys, `Enter` to select, `Esc` to go back, `s` for settings, `q` to quit.
+
+---
+
+## What it does
+
+The home screen exposes five workflows:
+
+| Screen | What it does |
+| --- | --- |
+| **⇩ DPM Ingest** | Parse an EIOPA annotated-templates workbook into a versioned local database (`db/versions/<version>.duckdb`). |
+| **Δ DPM Delta** | Compare two ingested versions and export a reviewable delta workbook (`Delta_DPM.xlsx`). |
+| **⇄ XBRL Apply Delta** | Roll the delta between two versions forward onto an XBRL instance, writing a new file (the input is never modified). |
+| **⌕ Explore Database** | Browse an ingested DPM database — templates, metrics, dimensions and their members. |
+| **≠ Explore Delta** | Browse the computed changes between two versions interactively. |
+
+### Typical flow
+
+1. **Add the versions you track** in **Settings** (`s`). The tool can download
+   the official workbooks straight from EIOPA, or you can supply an explicit URL
+   for the odd hotfix build.
+2. **Ingest** the old and new workbooks into versioned databases.
+3. **Delta** the two versions to review what changed, or **Apply Delta** to
+   update your XBRL instances.
+
+---
+
+## How the XBRL update works
+
+When applying a delta to an XBRL instance:
+
+- **Deleted** metric — matching facts are removed.
+- **Modified** metric with a changed QName — the fact tag is renamed.
+- **Added** metric — ignored (no value or context can be inferred).
+- **Kept** metric — left unchanged.
+
+The perimeter is auto-detected from the instance's `schemaRef`
+(e.g. `.../mod/qrs.xsd` → `qrs`) and can be overridden. A dry-run mode reports
+what *would* change without writing output.
+
+---
+
+## Data & config layout
+
+| Path | Contents |
+| --- | --- |
+| `db/versions/` | Ingested DPM version databases (DuckDB). |
+| `db/delta/` | Cached delta databases computed between two versions. |
+| `data/downloads/` | Source workbooks downloaded from EIOPA. |
+| `dpm-tool.config.json` | Tracked versions and the selected UI theme. |
+
+---
+
+## Development
+
+```bash
+uv sync          # install with dev dependencies
+uv run dpm-tool  # run from source
+uv run pytest    # run the test suite
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

dpm_tool-0.1.0/README.md

@@ -0,0 +1,93 @@
+# dpm-tool
+
+A terminal UI toolkit for working with the EIOPA Solvency II **Data Point Model
+(DPM)**. It ingests the official annotated-templates workbooks into local
+databases, compares two DPM versions to produce a reviewable delta, and rolls
+that delta forward onto your XBRL instance documents.
+
+Everything runs in a [Textual](https://textual.textualize.io/) TUI — no
+subcommands to memorise.
+
+---
+
+## Install
+
+```bash
+uv tool install dpm-tool     # as a standalone tool
+# or, inside a project
+uv add dpm-tool
+```
+
+Requires Python ≥ 3.12.
+
+## Run
+
+```bash
+dpm-tool
+```
+
+This launches the **EIOPA DPM Toolkit** home screen. Navigate with the arrow
+keys, `Enter` to select, `Esc` to go back, `s` for settings, `q` to quit.
+
+---
+
+## What it does
+
+The home screen exposes five workflows:
+
+| Screen | What it does |
+| --- | --- |
+| **⇩ DPM Ingest** | Parse an EIOPA annotated-templates workbook into a versioned local database (`db/versions/<version>.duckdb`). |
+| **Δ DPM Delta** | Compare two ingested versions and export a reviewable delta workbook (`Delta_DPM.xlsx`). |
+| **⇄ XBRL Apply Delta** | Roll the delta between two versions forward onto an XBRL instance, writing a new file (the input is never modified). |
+| **⌕ Explore Database** | Browse an ingested DPM database — templates, metrics, dimensions and their members. |
+| **≠ Explore Delta** | Browse the computed changes between two versions interactively. |
+
+### Typical flow
+
+1. **Add the versions you track** in **Settings** (`s`). The tool can download
+   the official workbooks straight from EIOPA, or you can supply an explicit URL
+   for the odd hotfix build.
+2. **Ingest** the old and new workbooks into versioned databases.
+3. **Delta** the two versions to review what changed, or **Apply Delta** to
+   update your XBRL instances.
+
+---
+
+## How the XBRL update works
+
+When applying a delta to an XBRL instance:
+
+- **Deleted** metric — matching facts are removed.
+- **Modified** metric with a changed QName — the fact tag is renamed.
+- **Added** metric — ignored (no value or context can be inferred).
+- **Kept** metric — left unchanged.
+
+The perimeter is auto-detected from the instance's `schemaRef`
+(e.g. `.../mod/qrs.xsd` → `qrs`) and can be overridden. A dry-run mode reports
+what *would* change without writing output.
+
+---
+
+## Data & config layout
+
+| Path | Contents |
+| --- | --- |
+| `db/versions/` | Ingested DPM version databases (DuckDB). |
+| `db/delta/` | Cached delta databases computed between two versions. |
+| `data/downloads/` | Source workbooks downloaded from EIOPA. |
+| `dpm-tool.config.json` | Tracked versions and the selected UI theme. |
+
+---
+
+## Development
+
+```bash
+uv sync          # install with dev dependencies
+uv run dpm-tool  # run from source
+uv run pytest    # run the test suite
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

dpm_tool-0.1.0/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_tool-0.1.0/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_tool-0.1.0/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_tool-0.1.0/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_tool-0.1.0/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)