index.toml-core 0.1.0__tar.gz

index_toml_core-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.3
+Name: index.toml-core
+Version: 0.1.0
+Summary: File-backed editor for ecosystem-neutral package indexes
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Dist: filelock>=3.16,<4
+Requires-Dist: index-toml-contracts>=0.1.0,<0.2
+Requires-Dist: tomlkit>=0.13,<1
+Requires-Python: >=3.10, <3.16
+Project-URL: Repository, https://github.com/groupsum/index.toml

index_toml_core-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "index.toml-core"
+version = "0.1.0"
+description = "File-backed editor for ecosystem-neutral package indexes"
+requires-python = ">=3.10,<3.16"
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+]
+dependencies = [
+    "filelock>=3.16,<4",
+    "index.toml-contracts>=0.1.0,<0.2",
+    "tomlkit>=0.13,<1",
+]
+
+[project.urls]
+Repository = "https://github.com/groupsum/index.toml"
+
+[[tool.uv.cache-keys]]
+file = "pyproject.toml"
+
+[[tool.uv.cache-keys]]
+file = "src/**/*"
+
+[tool.uv.sources."index.toml-contracts"]
+workspace = true
+
+[build-system]
+requires = ["uv_build>=0.9,<1"]
+build-backend = "uv_build"

index_toml_core-0.1.0/pyproject.toml.orig

@@ -0,0 +1,31 @@
+[project]
+name = "index.toml-core"
+version = "0.1.0"
+description = "File-backed editor for ecosystem-neutral package indexes"
+requires-python = ">=3.10,<3.16"
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+]
+dependencies = [
+    "filelock>=3.16,<4",
+    "index.toml-contracts>=0.1.0,<0.2",
+    "tomlkit>=0.13,<1",
+]
+
+[project.urls]
+Repository = "https://github.com/groupsum/index.toml"
+
+[tool.uv]
+cache-keys = [{ file = "pyproject.toml" }, { file = "src/**/*" }]
+
+[tool.uv.sources]
+"index.toml-contracts" = { workspace = true }
+
+[build-system]
+requires = ["uv_build>=0.9,<1"]
+build-backend = "uv_build"

index_toml_core-0.1.0/src/index_toml_core/__init__.py

@@ -0,0 +1,136 @@
+"""Read, validate and edit a repository's package index."""
+
+import os
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+
+import tomlkit
+from filelock import FileLock
+from index_toml_contracts import SCHEMA_VERSION, IndexValidationError, load, loads
+
+__all__ = ["IndexFile", "IndexValidationError", "load", "loads"]
+
+
+class IndexFile:
+    """File-backed CRUD for layers and packages, addressed by stable IDs."""
+
+    def __init__(self, path: str | Path = "pkgs/index.toml"):
+        self.path = Path(path).resolve()
+        self._lock = FileLock(f"{self.path}.lock", timeout=10)
+
+    def initialize(self) -> None:
+        """Create an empty v1 index at an unused path."""
+        with self._lock:
+            if self.path.exists():
+                raise FileExistsError(self.path)
+            self._write(f'schema_version = "{SCHEMA_VERSION}"\nlayers = []\npackages = []\n')
+
+    def read(self) -> dict:
+        return load(self.path)
+
+    def list_layers(self) -> list[dict]:
+        return sorted(self.read()["layers"], key=lambda record: record["order"])
+
+    def list_packages(self, layer: str | None = None) -> list[dict]:
+        index = self.read()
+        orders = {record["id"]: record["order"] for record in index["layers"]}
+        return sorted(
+            (record for record in index["packages"] if layer is None or record["layer"] == layer),
+            key=lambda record: (orders[record["layer"]], record["order"], record["id"]),
+        )
+
+    def get_layer(self, identifier: str) -> dict:
+        return self._get("layers", identifier)
+
+    def get_package(self, identifier: str) -> dict:
+        return self._get("packages", identifier)
+
+    def add_layer(self, identifier: str, *, order: int, **fields) -> None:
+        self._edit("layers", identifier, "add", {"order": order, **fields})
+
+    def add_package(self, identifier: str, *, layer: str, order: int, path: str, **fields) -> None:
+        self._edit("packages", identifier, "add", {
+            "layer": layer, "order": order, "path": path, **fields,
+        })
+
+    def update_layer(self, identifier: str, **changes) -> None:
+        self._edit("layers", identifier, "update", changes)
+
+    def update_package(self, identifier: str, **changes) -> None:
+        self._edit("packages", identifier, "update", changes)
+
+    def delete_layer(self, identifier: str) -> None:
+        self._edit("layers", identifier, "delete", {})
+
+    def delete_package(self, identifier: str) -> None:
+        self._edit("packages", identifier, "delete", {})
+
+    def _get(self, collection: str, identifier: str) -> dict:
+        records = self.read()[collection]
+        return records[self._position(records, identifier)]
+
+    @staticmethod
+    def _position(records, identifier: str) -> int:
+        for position, record in enumerate(records):
+            if record["id"] == identifier:
+                return position
+        raise KeyError(identifier)
+
+    def _edit(self, collection: str, identifier: str, action: str, changes: dict) -> None:
+        if "id" in changes:
+            raise IndexValidationError("Record IDs are immutable")
+        with self._lock:
+            with self.path.open(encoding="utf-8", newline="") as stream:
+                original = stream.read()
+            loads(original)
+            document = tomlkit.parse(original)
+            records = document[collection]
+            if action == "add":
+                if any(record["id"] == identifier for record in records):
+                    raise IndexValidationError(f"Duplicate record ID {identifier!r}")
+                data = {"id": identifier, **changes}
+                if isinstance(records, tomlkit.items.AoT):
+                    record = tomlkit.table()
+                    record.update(data)
+                    records.append(record)
+                else:
+                    record = tomlkit.inline_table()
+                    record.update(data)
+                    records.append(record)
+            else:
+                position = self._position(records, identifier)
+                if action == "delete":
+                    del records[position]
+                    if not records and isinstance(records, tomlkit.items.AoT):
+                        document[collection] = tomlkit.array()
+                else:
+                    record = records[position]
+                    for key, value in changes.items():
+                        if value is None:
+                            if key not in record:
+                                raise IndexValidationError(f"Cannot remove absent field {key!r}")
+                            del record[key]
+                        else:
+                            record[key] = value
+            candidate = document.as_string()
+            loads(candidate)
+            if candidate != original:
+                self._write(candidate)
+
+    def _write(self, content: str) -> None:
+        temporary = None
+        try:
+            with NamedTemporaryFile(
+                dir=self.path.parent, prefix=f".{self.path.name}.", suffix=".tmp",
+                mode="w", encoding="utf-8", newline="", delete=False,
+            ) as stream:
+                temporary = Path(stream.name)
+                stream.write(content)
+                stream.flush()
+                os.fsync(stream.fileno())
+            if self.path.exists():
+                os.chmod(temporary, self.path.stat().st_mode & 0o777)
+            temporary.replace(self.path)
+        finally:
+            if temporary is not None:
+                temporary.unlink(missing_ok=True)

index_toml_core-0.1.0/src/index_toml_core/workspace.py

@@ -0,0 +1,129 @@
+"""Compare adapter snapshots with declared package identities and edges."""
+
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+
+from index_toml_contracts.workspace import (
+    WorkspaceAdapter, WorkspaceDependency, WorkspaceDiagnostic, WorkspaceMember,
+)
+
+from . import IndexFile
+
+
+@dataclass(frozen=True)
+class WorkspaceDifference:
+    code: str
+    package_id: str | None = None
+    identity: str | None = None
+    manifest: str | None = None
+    expected: str | tuple[str, ...] | None = None
+    actual: str | tuple[str, ...] | None = None
+
+
+@dataclass(frozen=True)
+class WorkspaceCheck:
+    adapter: str
+    ecosystem: str
+    matches: tuple[tuple[str, WorkspaceMember], ...]
+    differences: tuple[WorkspaceDifference, ...]
+    diagnostics: tuple[WorkspaceDiagnostic, ...]
+    dependencies: tuple[WorkspaceDependency, ...] = ()
+
+    @property
+    def ok(self) -> bool:
+        return not (self.differences or self.diagnostics)
+
+
+def check_workspace(index: IndexFile, root: Path, adapter: WorkspaceAdapter) -> WorkspaceCheck:
+    """Read the index and compare it with the selected workspace without writing."""
+    document = index.read()
+    snapshot = adapter.discover(root.resolve())
+    if snapshot.diagnostics:
+        diagnostics = sorted(snapshot.diagnostics, key=lambda item: (item.manifest, item.code, item.message))
+        return WorkspaceCheck(adapter.name, adapter.ecosystem, (), (), tuple(diagnostics))
+
+    packages = sorted(
+        (package for package in document["packages"] if package.get("ecosystem") == adapter.ecosystem),
+        key=lambda package: package["id"],
+    )
+    by_path = defaultdict(list)
+    by_name = defaultdict(list)
+    for member in sorted(snapshot.members, key=lambda member: (member.path, member.identity)):
+        by_path[member.path].append(member)
+        by_name[member.identity].append(member)
+
+    candidates = defaultdict(list)
+    differences = []
+    claimed = set()
+    for package in packages:
+        identifier = package["id"]
+        identity = adapter.normalize_name(package.get("name", identifier))
+        paths = by_path[package["path"]]
+        names = by_name[identity]
+        exact = [member for member in paths if member in names]
+        options = exact or list(dict.fromkeys([*paths, *names]))
+        if len(options) > 1:
+            claimed.update(member.path for member in options)
+            differences.append(WorkspaceDifference(
+                "ambiguous_match", identifier, identity, actual=tuple(member.manifest for member in options),
+            ))
+        elif options:
+            member = options[0]
+            claimed.add(member.path)
+            candidates[member.path].append((package, identity, member))
+        else:
+            differences.append(WorkspaceDifference("missing_workspace_member", identifier, identity, expected=package["path"]))
+
+    matches = {}
+    for path, options in sorted(candidates.items()):
+        if len(options) > 1:
+            differences.extend(
+                WorkspaceDifference("ambiguous_match", package["id"], identity, member.manifest, actual=path)
+                for package, identity, member in options
+            )
+            continue
+        package, identity, member = options[0]
+        matches[package["id"]] = member
+        if path != package["path"]:
+            differences.append(WorkspaceDifference(
+                "path_mismatch", package["id"], identity, member.manifest, package["path"], path,
+            ))
+        if identity != member.identity:
+            differences.append(WorkspaceDifference(
+                "identity_mismatch", package["id"], identity, member.manifest,
+                package.get("name", package["id"]), member.name,
+            ))
+
+    for member in sorted(snapshot.members, key=lambda member: (member.path, member.identity)):
+        if member.path not in claimed:
+            differences.append(WorkspaceDifference(
+                "missing_index_record", identity=member.identity, manifest=member.manifest, actual=member.path,
+            ))
+
+    ids = {member.path: identifier for identifier, member in matches.items()}
+    actual_edges = defaultdict(set)
+    for edge in snapshot.dependencies:
+        if edge.source in ids and edge.target in ids:
+            actual_edges[ids[edge.source]].add(ids[edge.target])
+    selected_ids = {package["id"] for package in packages}
+    for package in packages:
+        identifier = package["id"]
+        if identifier not in matches:
+            continue
+        expected = set(package.get("dependencies", [])) & selected_ids
+        actual = actual_edges[identifier]
+        if expected != actual:
+            member = matches[identifier]
+            differences.append(WorkspaceDifference(
+                "dependency_mismatch", identifier, member.identity, member.manifest,
+                tuple(sorted(expected)), tuple(sorted(actual)),
+            ))
+
+    differences.sort(key=lambda item: (item.code, item.package_id or "", item.identity or "", item.manifest or ""))
+    dependencies = tuple(sorted(snapshot.dependencies, key=lambda edge: (
+        edge.source, edge.target, edge.category, edge.manifest, edge.declaration, edge.condition or "",
+    )))
+    return WorkspaceCheck(
+        adapter.name, adapter.ecosystem, tuple(sorted(matches.items())), tuple(differences), (), dependencies,
+    )