spatialdata-js-util 0.1.0__py3-none-any.whl

spatialdata_js_util/tui/widgets.py

@@ -0,0 +1,50 @@
+"""Widgets that work around defects in the installed Textual version."""
+
+from __future__ import annotations
+
+from textual.css.query import NoMatches
+from textual.dom import NoScreen
+from textual.events import Mount
+from textual.widgets import Header
+
+# `HeaderTitle` is not re-exported from `textual.widgets`; the override below
+# needs the same class the base implementation queries for.
+from textual.widgets._header import HeaderTitle
+
+
+class SafeHeader(Header):
+    """`Header` that tolerates its title watcher running before compose mounts.
+
+    Textual's `Header._on_mount` registers title watchers with `init=True`, and
+    their callback does `query_one(HeaderTitle)` guarded only against
+    `NoScreen`. `HeaderTitle` is a child yielded by `Header.compose()`, so when
+    the watcher runs before that child has mounted the query raises `NoMatches`
+    — which escapes into the app's message pump and fails whatever is driving
+    the app.
+
+    It is timing-dependent: it surfaced on loaded CI runners and never
+    reproduced locally, including under CPU contention. Verified against textual
+    8.2.8, the latest release when this was written.
+
+    Delete this once upstream catches `NoMatches` as well;
+    `test_tui.py::TestSafeHeader` asserts the stock `Header` still has the
+    defect, so it will fail and prompt the removal when that lands.
+    """
+
+    def _on_mount(self, event: Mount) -> None:
+        # Textual dispatches a handler for every class in the MRO, so defining
+        # `_on_mount` here does not replace the base one — it runs first, and
+        # the unguarded original would still follow. `prevent_default` is what
+        # actually suppresses it.
+        event.prevent_default()
+
+        async def set_title() -> None:
+            try:
+                self.query_one(HeaderTitle).update(self.format_title())
+            except (NoScreen, NoMatches):
+                pass
+
+        self.watch(self.app, "title", set_title)
+        self.watch(self.app, "sub_title", set_title)
+        self.watch(self.screen, "title", set_title)
+        self.watch(self.screen, "sub_title", set_title)

spatialdata_js_util/verify.py

@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+import pyarrow.parquet as pq
+
+from .points import MORTON_CODE_2D_COLUMN
+
+_UINT_INTERMEDIATE_SUFFIXES = ("_uint",)
+
+
+def _dataframe_column(df: pd.DataFrame, name: str) -> pd.Series:
+    column = df[name]
+    if isinstance(column, pd.DataFrame):
+        raise TypeError(f"expected column {name!r} to be a Series, got DataFrame")
+    return column
+
+
+def _series_extrema(series: pd.Series) -> tuple[float, float]:
+    return float(series.min()), float(series.max())
+
+
+@dataclass(frozen=True)
+class VerifyCheck:
+    id: str
+    passed: bool
+    detail: str
+
+
+def _check(id: str, passed: bool, detail: str) -> VerifyCheck:
+    return VerifyCheck(id=id, passed=passed, detail=detail)
+
+
+def _count_sentinel_prefix(morton_values: pd.Series) -> int:
+    count = 0
+    for value in morton_values.head(4):
+        if int(value) != 0:
+            break
+        count += 1
+    return count
+
+
+def _sentinel_count_from_row_group(
+    parquet: pq.ParquetFile,
+    morton_values: pd.Series,
+) -> int | None:
+    if parquet.num_row_groups == 0:
+        return None
+    first_group_rows = parquet.metadata.row_group(0).num_rows
+    if not 2 <= first_group_rows <= 4:
+        return None
+    first_values = morton_values.iloc[:first_group_rows]
+    if first_values.astype("int64").eq(0).all():
+        return int(first_group_rows)
+    return None
+
+
+def verify_morton_parquet(path: str | Path) -> list[VerifyCheck]:
+    parquet_path = Path(path)
+    checks: list[VerifyCheck] = []
+
+    if not parquet_path.is_file():
+        return [_check("file_exists", False, f"Parquet file not found: {parquet_path}")]
+
+    checks.append(_check("file_exists", True, str(parquet_path)))
+
+    try:
+        parquet = pq.ParquetFile(parquet_path)
+    except Exception as exc:
+        checks.append(
+            _check("parquet_readable", False, f"failed to read Parquet metadata: {exc}")
+        )
+        return checks
+
+    columns = parquet.schema_arrow.names
+    checks.append(
+        _check(
+            "column_present",
+            MORTON_CODE_2D_COLUMN in columns,
+            f"expected column {MORTON_CODE_2D_COLUMN!r} in schema",
+        )
+    )
+    checks.append(
+        _check("x_column_present", "x" in columns, "expected column 'x' in schema")
+    )
+    checks.append(
+        _check("y_column_present", "y" in columns, "expected column 'y' in schema")
+    )
+
+    uint_columns = [
+        name
+        for name in columns
+        if any(name.endswith(suffix) for suffix in _UINT_INTERMEDIATE_SUFFIXES)
+    ]
+    checks.append(
+        _check(
+            "no_uint_intermediates",
+            not uint_columns,
+            "no uint staging columns"
+            if not uint_columns
+            else f"unexpected uint columns: {', '.join(uint_columns)}",
+        )
+    )
+
+    if (
+        MORTON_CODE_2D_COLUMN not in columns
+        or "x" not in columns
+        or "y" not in columns
+    ):
+        return checks
+
+    try:
+        df = pd.read_parquet(parquet_path, columns=[MORTON_CODE_2D_COLUMN, "x", "y"])
+    except Exception as exc:
+        checks.append(
+            _check(
+                "required_columns_readable",
+                False,
+                f"failed to read required columns: {exc}",
+            )
+        )
+        return checks
+
+    morton_column = _dataframe_column(df, MORTON_CODE_2D_COLUMN)
+    x_column = _dataframe_column(df, "x")
+    y_column = _dataframe_column(df, "y")
+    sentinel_count = _sentinel_count_from_row_group(parquet, morton_column)
+    if sentinel_count is None:
+        sentinel_count = _count_sentinel_prefix(morton_column)
+    checks.append(
+        _check(
+            "sentinel_prefix",
+            2 <= sentinel_count <= 4,
+            f"sentinel prefix rows: {sentinel_count} (expected 2–4)",
+        )
+    )
+
+    if sentinel_count > 0:
+        sentinel_x = x_column.iloc[:sentinel_count]
+        sentinel_y = y_column.iloc[:sentinel_count]
+        sentinel_x_min, sentinel_x_max = _series_extrema(sentinel_x)
+        dataset_x_min, dataset_x_max = _series_extrema(x_column)
+        sentinel_y_min, sentinel_y_max = _series_extrema(sentinel_y)
+        dataset_y_min, dataset_y_max = _series_extrema(y_column)
+        bbox_match = (
+            sentinel_x_min == dataset_x_min
+            and sentinel_x_max == dataset_x_max
+            and sentinel_y_min == dataset_y_min
+            and sentinel_y_max == dataset_y_max
+        )
+        checks.append(
+            _check(
+                "sentinel_bbox",
+                bbox_match,
+                "sentinel rows encode full x/y bounds"
+                if bbox_match
+                else "sentinel x/y extrema do not match dataset bounds",
+            )
+        )
+
+    if sentinel_count < len(df):
+        tail = morton_column.iloc[sentinel_count:].astype("int64")
+        monotonic = bool((tail.diff().dropna() >= 0).all())
+        checks.append(
+            _check(
+                "morton_monotonic",
+                monotonic,
+                "morton_code_2d non-decreasing after sentinels"
+                if monotonic
+                else "morton_code_2d decreases after sentinel prefix",
+            )
+        )
+    else:
+        checks.append(
+            _check(
+                "morton_monotonic",
+                True,
+                "all rows are sentinel prefix (small dataset)",
+            )
+        )
+
+    if parquet.num_row_groups > 0:
+        first_group_rows = parquet.metadata.row_group(0).num_rows
+        sentinel_only = first_group_rows <= 4 and first_group_rows == sentinel_count
+        checks.append(
+            _check(
+                "row_group_sentinels",
+                sentinel_only,
+                f"row group 0 has {first_group_rows} rows (sentinel count {sentinel_count})",
+            )
+        )
+    else:
+        checks.append(_check("row_group_sentinels", False, "parquet has no row groups"))
+
+    return checks
+
+
+def verify_multiscale_parquet(path: str | Path) -> list[VerifyCheck]:
+    parquet_path = Path(path)
+    checks: list[VerifyCheck] = []
+
+    if not parquet_path.is_file():
+        return [_check("file_exists", False, f"Parquet file not found: {parquet_path}")]
+
+    checks.append(_check("file_exists", True, str(parquet_path)))
+
+    # A verifier that raises on a corrupt file reports nothing about it; the
+    # unreadable file is itself the finding, as in `verify_morton_parquet`.
+    try:
+        schema_metadata = pq.ParquetFile(parquet_path).schema_arrow.metadata
+    except Exception as exc:
+        checks.append(_check("parquet_readable", False, f"failed to read parquet: {exc}"))
+        return checks
+
+    if schema_metadata is None or b"spatialdata_multiscale" not in schema_metadata:
+        checks.append(
+            _check(
+                "multiscale_metadata",
+                False,
+                "missing spatialdata_multiscale schema metadata",
+            )
+        )
+        return checks
+
+    stored = json.loads(schema_metadata[b"spatialdata_multiscale"])
+    checks.append(
+        _check(
+            "multiscale_metadata",
+            stored.get("format") == "spatialdata_multiscale_points",
+            f"format={stored.get('format')!r}",
+        )
+    )
+
+    bbox = stored.get("bounding_box")
+    has_bbox = (
+        isinstance(bbox, dict)
+        and isinstance(bbox.get("min"), list)
+        and isinstance(bbox.get("max"), list)
+        and len(bbox.get("min", [])) > 0
+        and len(bbox.get("max", [])) > 0
+    )
+    checks.append(
+        _check(
+            "multiscale_bbox",
+            has_bbox,
+            "bounding_box min/max present"
+            if has_bbox
+            else "bounding_box missing or incomplete",
+        )
+    )
+    return checks
+
+
+def verify_index_permutations_manifest(dest_zarr: str | Path) -> list[VerifyCheck]:
+    dest_path = Path(dest_zarr)
+    manifest_path = dest_path / "index-manifest.json"
+    checks: list[VerifyCheck] = []
+
+    if not manifest_path.is_file():
+        return [
+            _check(
+                "manifest_exists",
+                False,
+                f"index-manifest.json not found under {dest_path}",
+            )
+        ]
+
+    checks.append(_check("manifest_exists", True, str(manifest_path)))
+    manifest: dict[str, Any] = json.loads(manifest_path.read_text())
+    conditions = manifest.get("conditions", [])
+    if not isinstance(conditions, list) or not conditions:
+        checks.append(_check("manifest_conditions", False, "no conditions in manifest"))
+        return checks
+
+    checks.append(
+        _check("manifest_conditions", True, f"{len(conditions)} condition(s) listed")
+    )
+
+    for condition in conditions:
+        if not isinstance(condition, dict):
+            continue
+        condition_id = condition.get("id", "unknown")
+        element_path = condition.get("element_path")
+        if not isinstance(element_path, str):
+            checks.append(
+                _check(
+                    f"path_{condition_id}",
+                    False,
+                    "condition missing element_path",
+                )
+            )
+            continue
+
+        parquet_path = dest_path / element_path / "points.parquet"
+        if not parquet_path.is_file() and not parquet_path.is_dir():
+            checks.append(
+                _check(
+                    f"path_{condition_id}",
+                    False,
+                    f"missing output: {parquet_path}",
+                )
+            )
+            continue
+
+        checks.append(_check(f"path_{condition_id}", True, str(parquet_path)))
+
+        tiling_kind = condition.get("tiling_kind")
+        if tiling_kind == "morton-points":
+            if parquet_path.is_file():
+                for morton_check in verify_morton_parquet(parquet_path):
+                    checks.append(
+                        VerifyCheck(
+                            id=f"{condition_id}_{morton_check.id}",
+                            passed=morton_check.passed,
+                            detail=morton_check.detail,
+                        )
+                    )
+            else:
+                # A directory dataset passes the path check above, so without this
+                # the manifest would report `all_passed` for a Morton condition
+                # whose ordering was never looked at.
+                checks.append(
+                    _check(
+                        f"{condition_id}_morton_verified",
+                        False,
+                        f"morton ordering not verified: {parquet_path} is a directory dataset",
+                    )
+                )
+
+    return checks
+
+
+def all_passed(checks: list[VerifyCheck]) -> bool:
+    return bool(checks) and all(check.passed for check in checks)