spatialscape 0.3.0__py3-none-any.whl

spatialscape/validate.py

@@ -0,0 +1,193 @@
+"""Validate a bundle on disk or over HTTP (schema, shapes, codes, range requests)."""
+from __future__ import annotations
+
+import json
+import urllib.request
+from pathlib import Path
+
+import numpy as np
+
+from .manifest import Manifest
+
+
+def _problem(problems: list[str], msg: str) -> None:
+    problems.append(msg)
+
+
+def validate_local(root: Path) -> list[str]:
+    import zarr
+
+    p: list[str] = []
+    root = Path(root)
+    mpath = root / "manifest.json"
+    if not mpath.exists():
+        return [f"missing {mpath}"]
+    try:
+        m = Manifest.model_validate_json(mpath.read_text())
+    except Exception as e:
+        return [f"manifest.json invalid: {e}"]
+    genes_union = json.loads((root / "genes.json").read_text()) if (root / "genes.json").exists() else None
+    if genes_union is None:
+        _problem(p, "missing genes.json")
+    if m.defaultGene and genes_union is not None and m.defaultGene not in set(genes_union):
+        _problem(p, f"defaultGene {m.defaultGene!r} not in genes.json")
+    fpath = root / "features.json"
+    if fpath.exists():
+        try:
+            feats = json.loads(fpath.read_text())
+            assert isinstance(feats.get("genes"), list) and isinstance(feats.get("groups"), list)
+            for g in feats["groups"]:
+                assert all({"id", "label"} <= set(f) for f in g["features"])
+        except Exception as e:
+            _problem(p, f"features.json malformed: {e}")
+    field_ids = {f.id for f in m.fields}
+    for f in m.fields:
+        if f.type == "categorical" and f.vocabulary not in m.vocabularies:
+            _problem(p, f"field {f.id}: vocabulary {f.vocabulary!r} missing")
+    for v_id, v in m.vocabularies.items():
+        if len(v.categories) != len(v.colors):
+            _problem(p, f"vocabulary {v_id}: categories/colors length mismatch")
+    for sid in m.layout.order:
+        if sid not in {s.id for s in m.samples}:
+            _problem(p, f"layout.order references unknown sample {sid!r}")
+    for s in m.samples:
+        d = root / "samples" / s.id
+        if not d.is_dir():
+            _problem(p, f"{s.id}: missing sample directory")
+            continue
+        try:
+            g = zarr.open_group(str(d / "expr.zarr"), mode="r")
+            u8 = g["u8"]
+            if tuple(u8.shape) != (s.nGenes, s.nObs):
+                _problem(p, f"{s.id}: expr u8 shape {u8.shape} != ({s.nGenes}, {s.nObs})")
+            if u8.chunks[0] != 1:
+                _problem(p, f"{s.id}: expr u8 chunk shape {u8.chunks} is not gene-major (1, n_obs)")
+            if g["gmax"].shape[0] != s.nGenes:
+                _problem(p, f"{s.id}: gmax length mismatch")
+            if "gmin" in g and g["gmin"].shape[0] != s.nGenes:
+                _problem(p, f"{s.id}: gmin length mismatch")
+            gmax = np.asarray(g["gmax"][:])
+            if gmax.size and (not np.all(np.isfinite(gmax)) or (gmax <= 0).any()):
+                _problem(p, f"{s.id}: gmax has non-finite or non-positive values")
+            if s.nGenes:
+                _ = u8[0, :]  # exercise one chunk read (and the shard index)
+        except Exception as e:
+            _problem(p, f"{s.id}: expr.zarr unreadable: {e}")
+        genes = json.loads((d / "genes.json").read_text()) if (d / "genes.json").exists() else None
+        if genes is None or len(genes) != s.nGenes:
+            _problem(p, f"{s.id}: genes.json missing or length != nGenes")
+        try:
+            og = zarr.open_group(str(d / "obs.zarr"), mode="r")
+            if tuple(og["xy"].shape) != (s.nObs, 2):
+                _problem(p, f"{s.id}: obs xy shape {og['xy'].shape}")
+            if tuple(og["order"].shape) != (s.nObs,):
+                _problem(p, f"{s.id}: obs order shape")
+            elif s.nObs:
+                order = np.asarray(og["order"][:])
+                if order.min() != 0 or order.max() != s.nObs - 1 or np.unique(order).size != s.nObs:
+                    _problem(p, f"{s.id}: obs order is not a permutation of the rows")
+            for fid in s.fields:
+                if fid not in field_ids:
+                    _problem(p, f"{s.id}: field {fid!r} not declared in manifest.fields")
+                    continue
+                f = m.field_by_id(fid)
+                if f.type == "categorical":
+                    if fid not in og["cat"]:
+                        _problem(p, f"{s.id}: obs.zarr/cat/{fid} missing")
+                        continue
+                    codes = og["cat"][fid][:]
+                    ncat = len(m.vocabularies[f.vocabulary].categories)
+                    if codes.shape != (s.nObs,):
+                        _problem(p, f"{s.id}: obs.zarr/cat/{fid} has {codes.shape[0]} rows, expected {s.nObs}")
+                    if codes.size and int(codes.max()) >= ncat:
+                        _problem(p, f"{s.id}: field {fid} has code {int(codes.max())} >= {ncat} categories")
+                else:
+                    if fid not in og["num"]:
+                        _problem(p, f"{s.id}: obs.zarr/num/{fid} missing")
+                    elif tuple(og["num"][fid].shape) != (s.nObs,):
+                        _problem(p, f"{s.id}: obs.zarr/num/{fid} has {og['num'][fid].shape[0]} rows, expected {s.nObs}")
+        except Exception as e:
+            _problem(p, f"{s.id}: obs.zarr unreadable: {e}")
+        nblocks = -(-s.nObs // s.idBlock)
+        for b in range(nblocks):
+            fb = d / "ids" / f"{b}.json"
+            if not fb.exists():
+                _problem(p, f"{s.id}: ids/{b}.json missing")
+                break
+            want = min(s.idBlock, s.nObs - b * s.idBlock)
+            try:
+                got = len(json.loads(fb.read_text()))
+            except ValueError:
+                got = -1
+            if got != want:
+                _problem(p, f"{s.id}: ids/{b}.json has {got} ids, expected {want}")
+                break
+        for fid in s.outlines or []:
+            if not (d / "outlines" / f"{fid}.json").exists():
+                _problem(p, f"{s.id}: outlines/{fid}.json listed but missing")
+        if s.polygons:
+            off = d / "polygons.offsets.u32"
+            dl = d / "polygons.i16"
+            if not off.exists() or not dl.exists():
+                _problem(p, f"{s.id}: polygon files missing")
+            elif off.stat().st_size == 4 * (s.nObs + 1) and dl.stat().st_size == 4 * s.polygons.vertices:
+                offs = np.fromfile(off, dtype=np.uint32)
+                if offs[0] != 0 or offs[-1] != s.polygons.vertices or (np.diff(offs.astype(np.int64)) < 0).any():
+                    _problem(p, f"{s.id}: polygon offsets are not a non-decreasing 0..vertices run")
+            else:
+                _problem(p, f"{s.id}: polygon file sizes do not match nObs/vertices")
+        for im in s.images:
+            try:
+                ig = zarr.open_group(str(d / im.path), mode="r")
+                lv0 = ig[ig.attrs["multiscales"][0]["datasets"][0]["path"]]
+                if tuple(lv0.shape[1:]) != tuple(im.size):
+                    _problem(p, f"{s.id}: image {im.id} size {lv0.shape[1:]} != {im.size}")
+            except Exception as e:
+                _problem(p, f"{s.id}: image {im.id} unreadable: {e}")
+        if not np.isfinite(s.bbox).all():
+            _problem(p, f"{s.id}: bbox not finite")
+    return p
+
+
+ORIGIN = "https://viewer.example.org"  # any browser origin; servers that gate CORS on it answer as they would for the viewer
+
+
+def validate_remote(url: str) -> list[str]:
+    p: list[str] = []
+    url = url.rstrip("/")
+    try:
+        req = urllib.request.Request(url + "/manifest.json", headers={"Origin": ORIGIN})
+        with urllib.request.urlopen(req, timeout=20) as r:
+            m = Manifest.model_validate_json(r.read())
+            if not r.headers.get("Access-Control-Allow-Origin"):
+                _problem(p, "manifest.json: no Access-Control-Allow-Origin header; the browser will refuse to load the bundle (configure CORS on the host)")
+    except Exception as e:
+        return [f"cannot fetch manifest: {e}"]
+    if not m.samples:
+        return p + ["manifest has no samples"]
+    s = m.samples[0]
+    sharded = s.expr.sharded
+    chunk = f"{url}/samples/{s.id}/expr.zarr/u8/c/0/0"
+    headers = {"Origin": ORIGIN}
+    if sharded:
+        headers["Range"] = "bytes=0-15"
+    req = urllib.request.Request(chunk, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=20) as r:
+            if sharded:
+                if r.status != 206:
+                    _problem(p, f"range request returned {r.status}, expected 206: this bundle is sharded, so the host must support HTTP Range (or rebuild with --no-shard)")
+                exp = r.headers.get("Access-Control-Expose-Headers", "")
+                if "content-range" not in exp.lower() and "*" not in exp:
+                    _problem(p, "Access-Control-Expose-Headers should include Content-Range for sharded bundles")
+            elif r.status != 200:
+                _problem(p, f"gene chunk request returned {r.status}")
+    except Exception as e:
+        _problem(p, f"gene chunk request failed for {chunk}: {e}")
+    return p
+
+
+def validate(target: str) -> list[str]:
+    if target.startswith(("http://", "https://")):
+        return validate_remote(target)
+    return validate_local(Path(target))

spatialscape/vocab.py

@@ -0,0 +1,188 @@
+"""Dataset-level categorical vocabularies: stable codes + colors across samples and platforms."""
+from __future__ import annotations
+
+import colorsys
+import json
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from .config import FieldSpec
+from .manifest import Vocabulary
+
+NA_LABEL = "NA"
+NA_COLOR = "#c8c8c8"
+
+# Tableau 20 + a few; stable, print-friendly
+QUALITATIVE = [
+    "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b", "#e377c2", "#7f7f7f",
+    "#bcbd22", "#17becf", "#aec7e8", "#ffbb78", "#98df8a", "#ff9896", "#c5b0d5", "#c49c94",
+    "#f7b6d2", "#dbdb8d", "#9edae5", "#393b79", "#637939", "#8c6d31", "#843c39", "#7b4173",
+]
+
+
+def _golden_color(i: int) -> str:
+    h = (i * 0.618033988749895) % 1.0
+    s = 0.55 + 0.35 * ((i * 7) % 3) / 2
+    v = 0.75 + 0.2 * ((i * 11) % 2)
+    r, g, b = colorsys.hsv_to_rgb(h, s, v)
+    return f"#{int(r * 255):02x}{int(g * 255):02x}{int(b * 255):02x}"
+
+
+def load_palette(path: Path | None) -> dict[str, dict[str, str]]:
+    if path is None:
+        return {}
+    with open(path) as fh:
+        raw: dict[str, Any] = json.load(fh)
+    out: dict[str, dict[str, str]] = {}
+    flat: dict[str, str] = {}
+    for k, v in raw.items():
+        if k.startswith("_"):
+            continue
+        if isinstance(v, dict):
+            out[k] = {str(a): str(b) for a, b in v.items()}
+        elif isinstance(v, str):
+            flat[k] = v
+    if flat:
+        out["_flat"] = flat
+    return out
+
+
+MAX_CATEGORIES = 65_535  # codes are uint16
+
+
+def _label(c) -> str:
+    """A category label as text: integral numbers without a trailing .0, so an int column in one sample and a
+    float column (NaN forced it) in another meet in the same category."""
+    if isinstance(c, (float, np.floating)):
+        return str(int(c)) if np.isfinite(c) and float(c).is_integer() else str(c)
+    return str(c)
+
+
+def _label_strings(s: pd.Series) -> pd.Series:
+    if pd.api.types.is_numeric_dtype(s.dtype) and not pd.api.types.is_bool_dtype(s.dtype):
+        v = pd.to_numeric(s, errors="coerce")
+        return v.map(lambda x: None if pd.isna(x) else _label(float(x))).astype("string")
+    return s.astype("string")
+
+
+class VocabRegistry:
+    """Append-only registry: codes never change once assigned, so a rebuilt sample stays consistent with the others."""
+
+    def __init__(
+        self,
+        fields: list[FieldSpec],
+        palette: dict[str, dict[str, str]] | None = None,
+        existing: dict[str, Vocabulary] | None = None,
+    ):
+        self.fields = {f.id: f for f in fields}
+        self.palette = palette or {}
+        self.vocabs: dict[str, dict[str, Any]] = {}
+        for vid, v in (existing or {}).items():
+            self.vocabs[vid] = {
+                "categories": list(v.categories),
+                "colors": list(v.colors),
+                "aliases": dict(v.aliases),
+            }
+        for f in fields:
+            if f.type != "categorical":
+                continue
+            vid = f.vocabulary or f.id
+            v = self.vocabs.setdefault(vid, {"categories": [], "colors": [], "aliases": {}})
+            v["aliases"].update(f.aliases)
+            v.setdefault("_palette_key", f.palette_key or vid)
+            for c in f.categories or []:
+                self._add(vid, c)
+
+    def declare(self, f: FieldSpec) -> None:
+        """Register a field discovered at build time (idempotent)."""
+        if f.id in self.fields:
+            return
+        self.fields[f.id] = f
+        if f.type == "categorical":
+            vid = f.vocabulary or f.id
+            v = self.vocabs.setdefault(vid, {"categories": [], "colors": [], "aliases": {}})
+            v["aliases"].update(f.aliases)
+            v.setdefault("_palette_key", f.palette_key or vid)
+
+    def adopt_manifest_fields(self, manifest, only: set[str] | None = None) -> None:
+        """Keep fields that an existing bundle already declares (e.g. auto-discovered ones); `only` restricts the ids."""
+        for mf in manifest.fields:
+            if mf.id in self.fields or (only is not None and mf.id not in only):
+                continue
+            if mf.type == "categorical":
+                self.declare(FieldSpec(id=mf.id, name=mf.name, type="categorical", vocabulary=mf.vocabulary, description=mf.description))
+            else:
+                self.declare(FieldSpec(id=mf.id, name=mf.name, type="continuous", range=mf.range, colormap=mf.colormap, description=mf.description))
+
+    def recolor_from_palette(self) -> int:
+        """Re-derive the color of every existing label that the palette names, keeping codes. Returns how many changed."""
+        changed = 0
+        for vid, v in self.vocabs.items():
+            key = v.get("_palette_key", vid)
+            keys = [k.strip() for k in str(key).split(",")] + [vid, "_flat"]
+            for i, label in enumerate(v["categories"]):
+                if label == NA_LABEL:
+                    continue
+                for pk in keys:
+                    pal = self.palette.get(pk)
+                    if pal and label in pal:
+                        if v["colors"][i] != pal[label]:
+                            v["colors"][i] = pal[label]
+                            changed += 1
+                        break
+        return changed
+
+    def vocab_id(self, field_id: str) -> str:
+        f = self.fields[field_id]
+        return f.vocabulary or f.id
+
+    def _color_for(self, vid: str, label: str, index: int) -> str:
+        if label == NA_LABEL:
+            return NA_COLOR
+        key = self.vocabs[vid].get("_palette_key", vid)
+        keys = [k.strip() for k in str(key).split(",")] + [vid, "_flat"]
+        for pk in keys:
+            pal = self.palette.get(pk)
+            if pal and label in pal:
+                return pal[label]
+        if index < len(QUALITATIVE):
+            return QUALITATIVE[index]
+        return _golden_color(index)
+
+    def _add(self, vid: str, label: str) -> int:
+        v = self.vocabs[vid]
+        cats = v["categories"]
+        if label in cats:
+            return cats.index(label)
+        if len(cats) >= MAX_CATEGORIES:
+            raise ValueError(f"vocabulary {vid!r}: more than {MAX_CATEGORIES:,} categories across samples")
+        cats.append(label)
+        v["colors"].append(self._color_for(vid, label, len(cats) - 1))
+        return len(cats) - 1
+
+    def encode(self, field_id: str, values: pd.Series) -> np.ndarray:
+        vid = self.vocab_id(field_id)
+        aliases = self.vocabs[vid]["aliases"]
+        s = values
+        if not isinstance(s.dtype, pd.CategoricalDtype):
+            s = _label_strings(s).astype("category")
+        labels = [aliases.get(_label(c), _label(c)) for c in s.cat.categories]
+        if len(labels) > MAX_CATEGORIES:
+            raise ValueError(f"field {field_id!r}: {len(labels):,} categories (at most {MAX_CATEGORIES:,}); map a coarser column, or leave this one out of `fields:`")
+        # preserve source category order for first-seen appends
+        code_map = np.empty(len(labels) + 1, dtype=np.uint16)
+        for i, lab in enumerate(labels):
+            code_map[i] = self._add(vid, lab)
+        code_map[-1] = self._add(vid, NA_LABEL) if (s.cat.codes < 0).any() else 0
+        src = s.cat.codes.to_numpy().astype(np.int64)
+        src[src < 0] = len(labels)
+        return code_map[src]
+
+    def to_manifest(self) -> dict[str, Vocabulary]:
+        return {
+            vid: Vocabulary(categories=v["categories"], colors=v["colors"], aliases=v["aliases"])
+            for vid, v in self.vocabs.items()
+        }

spatialscape-0.3.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.5
+Name: spatialscape
+Version: 0.3.0
+Summary: Build static spatialscape viewer bundles from AnnData / SpatialData
+Project-URL: Homepage, https://mictott.github.io/spatialscape/docs/
+Project-URL: Documentation, https://mictott.github.io/spatialscape/docs/
+Project-URL: Repository, https://github.com/mictott/spatialscape
+Project-URL: Issues, https://github.com/mictott/spatialscape/issues
+Project-URL: Changelog, https://github.com/mictott/spatialscape/blob/main/CHANGELOG.md
+Author-email: Michael Totty <mictott@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: deck.gl,single-cell,spatial-transcriptomics,visium,visualization,xenium,zarr
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.11
+Requires-Dist: anndata>=0.12
+Requires-Dist: imageio>=2.34
+Requires-Dist: numcodecs>=0.15
+Requires-Dist: numpy>=1.26
+Requires-Dist: pandas>=2.0
+Requires-Dist: pillow>=10
+Requires-Dist: pyarrow>=15
+Requires-Dist: pydantic>=2.6
+Requires-Dist: pyyaml>=6
+Requires-Dist: scikit-image>=0.22
+Requires-Dist: scipy>=1.11
+Requires-Dist: tifffile>=2024.1
+Requires-Dist: typer>=0.12
+Requires-Dist: zarr>=3.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: h5py>=3.10; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: spatialdata
+Requires-Dist: spatialdata>=0.4; extra == 'spatialdata'
+Provides-Extra: tracks
+Requires-Dist: pybigwig>=0.3.18; extra == 'tracks'
+Description-Content-Type: text/markdown
+
+# spatialscape (Python)
+
+The command-line tool behind **spatialscape**, a static, reactive browser for spatial transcriptomics and
+snRNA-seq. It turns a saved R object (`SpatialExperiment` / `SingleCellExperiment` as `.rds` or `.rda`, parsed in
+Python) or AnnData / SpatialData files into viewer bundles (sharded Zarr v3 expression, observation arrays in
+microns, OME-Zarr images, domain outlines, cell polygons), and ships the viewer itself so you can open them locally
+or publish them as a website.
+
+```bash
+pip install spatialscape
+spatialscape init analysis/spe_dlpfc.rds --id dlpfc    # writes dlpfc.yaml, a menu of what the data contains
+# edit dlpfc.yaml: keep the annotations you want, name them, pick colors and the opening gene
+spatialscape build dlpfc.yaml                          # -> bundles/dlpfc; rerun after any edit
+spatialscape serve bundles --open                      # viewer + data at http://127.0.0.1:8787/
+spatialscape site build bundles -o site                # folder to upload to any static host
+```
+
+`sscape` is a short alias for the same command. Documentation: https://mictott.github.io/spatialscape/docs/
+Source and issues: https://github.com/MicTott/spatialscape

spatialscape-0.3.0.dist-info/RECORD

@@ -0,0 +1,58 @@
+spatialscape/__init__.py,sha256=ZRSD3VYrKj5EZt0WP4kUKs7zjTXiCVyoPinNKnH7VpI,450
+spatialscape/build.py,sha256=XU3z8n5oikH_iJBpB3kMx_TTIhZcTs3fKPLCDKZ-zP4,29398
+spatialscape/cli.py,sha256=u-GW1A2cXuSiTpfGT-ki9LXMKbRFoyEDN_TyAAVW4EQ,21543
+spatialscape/config.py,sha256=wUEys5KfIe11irlG_fYX0Gla1hUzQ-5Xed3-WWS4gTI,26648
+spatialscape/convert.py,sha256=4ulCYNTDWQoo4TgZMko7aTRcURbwWi0kxhxpdxqzlfM,14389
+spatialscape/discover.py,sha256=xgeTMMhdSUhocojxWQQB6cFf1BkOTb4pN0CC8edi47k,4909
+spatialscape/expression.py,sha256=OpQjI-FX-mY6APn2JXm0xt3bqftQP1fmRPJMPg26JIw,14226
+spatialscape/fingerprint.py,sha256=-MhR2NAYnLnulnVFR8gmuIzirlouXQlMrv4jIXW-VWw,6153
+spatialscape/genes.py,sha256=LI0wBCi-k-Vf3j9ame5yR1cbyVy9OTw8SwCt3YRyBxI,11762
+spatialscape/geometry.py,sha256=0C2HAHDzeDeOdndGCsw4--vZ5qvMcX6yI3GcclrKpXU,5109
+spatialscape/images.py,sha256=n3oXkPL-9-iwioagmZMxir5VMcCfMipoyh8bD0HaFEs,9641
+spatialscape/init.py,sha256=Rq8bgl_UIsspjwrMR3lAJcnuglWI-TYj1_lRijz9jAc,29110
+spatialscape/manifest.py,sha256=QraZYehFtUK3fOxodm1Th-qrp0cvnCU17jt7x4bp4HU,5195
+spatialscape/obs.py,sha256=ckB8lzVe5biO1AC5kz0eNu_o8h8SoNmXKrBrY3jcx64,1664
+spatialscape/outlines.py,sha256=LqOc8pLo-2rbE86iEjJxqwwSG2x-8ltX7ZokRsdPuMY,5379
+spatialscape/polygons.py,sha256=doniQ0g22M2P3dEbAlnMiPge8IpOQjRUpcP7SoPcXcc,3617
+spatialscape/rds.py,sha256=ZpMQY0m_5PWeKvouSgbKU7BhTM4X6S321UMi9bKjqzo,27629
+spatialscape/rdsread.py,sha256=CUjPh38jvh8hcIA020hFW2U0H_fbX_KK3LMrUBKA5vw,24195
+spatialscape/readers.py,sha256=Ub9Myvr3IBoEu-TVrYtAgiuD6XpPvsr6dCpHy8wTDoQ,8243
+spatialscape/registry.py,sha256=Z2p0T1Gysb0jF9Kt_8mvBUA4GKrqeaowMaWoPgMsS0U,3291
+spatialscape/serve.py,sha256=zIX6PQkl3qgF_0JPAox_QNj4gR7u556io6nJFrvdeCg,11731
+spatialscape/session.py,sha256=q-nY_CbQQV8R88UDJz315hjE1Fgy6cLCytx9sA5Q-yQ,22557
+spatialscape/site.py,sha256=VPHUU6zKULj3p4Yf4K2HcbXiK2nZJ76IqvbXCfY5dxk,11434
+spatialscape/synthetic.py,sha256=g0SkfUFUi0ht_EEKX1ON40JA5BtABYoIofHwlusc_rs,5836
+spatialscape/thumbnail.py,sha256=ZwIyQH1wAUMzpfp4LKHVyUIojgb6vbAxFCcjDysza8o,3770
+spatialscape/tracks.py,sha256=3qwrSL30f38b-Pc40ciHoHp6o8yBNjAuwPbVKqUExPE,26627
+spatialscape/validate.py,sha256=qd8NxnesTYUzmhLbbN2zvlb2Np-SK62-7yLZWJny_90,9236
+spatialscape/vocab.py,sha256=WX0p_loYTBv9WJef2VibZqrFgi6TbujH8fOzDDqtvv8,7538
+spatialscape/_app/favicon.svg,sha256=EA9COdL3E7nL4g-GX8hfROaq9CcgNClWMEfiumqL3mY,8733
+spatialscape/_app/index.html,sha256=-xoYf4F1VSFJyzAkmPtpuspnHbut3iW3CAvVDUsmTkE,1303
+spatialscape/_app/assets/array-utils-flat-BL8Cekj1.js,sha256=K1qf-eYyZ5eKD0dW1hULZe5SK8zsn0tr_HbvUueItX8,29590
+spatialscape/_app/assets/blosc-DEOJs6D5.js,sha256=WK_5LTSrxQci60GRd06pq9ARX6hEfs0kkCuIDEGGuMo,603099
+spatialscape/_app/assets/blosc-Df7TknHH.js,sha256=znsurYLuyNhY5ZtYiVoVm06F2emLZVt5Xyk4sGbGEw0,603115
+spatialscape/_app/assets/chunk-INHXZS53-DAOLzMPX.js,sha256=eK-f7WqxPABozcGIuKFx0ybXjcFVY9sRdkIbQc76_r8,422
+spatialscape/_app/assets/chunk-INHXZS53-DfBSTIxr.js,sha256=8B-3e6PgX5yK2HSSihnQRAFMoL6nzOhw_aVR7oeSSro,454
+spatialscape/_app/assets/deflate-B2AbjNo_.js,sha256=reCDT2cAlS16SnlI9vxyytZFMqroFHaRbVP5C8mTmKU,218
+spatialscape/_app/assets/expression-E359vKZW.js,sha256=22F9bTwAJW8Rxi7a4pkAMRYjXsRndxgC8JmBTOhE-BI,96648
+spatialscape/_app/assets/get-attribute-from-layouts-Dd2gixpo.js,sha256=b-bTC36ISROsZjQACh7goYIY_QcZBvk9CeUr_0rjfaI,19267
+spatialscape/_app/assets/index-BKPnXJSt.css,sha256=3V6PZhFpUAlsG7n40JKAN_fPFkSov_CpF14Ut8TJi6E,19502
+spatialscape/_app/assets/index-Gxpj1e1n.js,sha256=r974r8rfdlbs0B2_rQ5lm_YE23RwXMj8_fdide7LzQo,1482098
+spatialscape/_app/assets/jpeg-b0MwBR_9.js,sha256=aXO7QO-HTsQPEimOQVmmm3IG6BoGNfA0oSLGJrMDQ10,8750
+spatialscape/_app/assets/lerc-ujbbHc0C.js,sha256=oLHcKH64wvX5l1-72OSh9AQYUSzccqQOyKfV5oyD_8I,67574
+spatialscape/_app/assets/lz4-BFJkNc3o.js,sha256=hkio-tdkKMBLlm1GqpBFSD3US9LOYqz1FouLcfG7ZQg,36277
+spatialscape/_app/assets/lz4-DNE3IovK.js,sha256=zpFKo_9yyGNUoZPyqY4haGu8WkgxhFEVQM4d4McFCXE,36277
+spatialscape/_app/assets/lzw-DfRkoFB0.js,sha256=asUiIAhvpZZ-arOIEpkjl27PgKZt-NQ22PL45T6zUp4,1401
+spatialscape/_app/assets/packbits-BDCGuk_Z.js,sha256=-Y8AefaY1u8ENm9dsSrO22ze4Qkz1peZwcd4WT11d-s,387
+spatialscape/_app/assets/pako.esm-Ch1S5qKo.js,sha256=FJH3XTGtsUOclbHjl5sXgzinn8_IbqzZWpgUExKFefc,46654
+spatialscape/_app/assets/raw-vNZ-QFXZ.js,sha256=dR8oyPe673x6k89ROPUhLQ4NtovvBHIlLjDdUbxNY2o,150
+spatialscape/_app/assets/webgl-D2Fkccwd.js,sha256=pBvvVDVvtb53QS4DTkYC3x1pRyqOSj014oIW0LsCY00,18883
+spatialscape/_app/assets/webimage-DDU0IC05.js,sha256=WzTH1ij9pijApCv3webKJENFq5FL9sT9WSOPlWnem3Q,713
+spatialscape/_app/assets/worker-CUy87eWB.js,sha256=AbSNcRT9CAnl2EIMfSPSgyYIHjV55_HS6VTfd42s0sc,121308
+spatialscape/_app/assets/zstd-CGD_7wnU.js,sha256=jwzWBB4xi-zOFPt3KBVe8XNndOAb0FlLCJPYU2sNlZM,747108
+spatialscape/_app/assets/zstd-qXhZ_1DN.js,sha256=1IC12lrledtmXSo_FoVC0K8IST7pU1DepwGGlyuNlJc,747108
+spatialscape-0.3.0.dist-info/METADATA,sha256=ihFKQJuZH0NdLFsZ2Kf2Ej0Xgcep-YBFfnWT3jV26ww,3184
+spatialscape-0.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+spatialscape-0.3.0.dist-info/entry_points.txt,sha256=7p3iXfRSX7AJh6h8gYOSOcyHUBwOCW22VtwaL5LirtY,86
+spatialscape-0.3.0.dist-info/licenses/LICENSE,sha256=kQ6fUkaCdrMJA__sulW822y8lCn20JzRUFrCoUxSxg8,1070
+spatialscape-0.3.0.dist-info/RECORD,,

spatialscape-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

spatialscape-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+spatialscape = spatialscape.cli:main
+sscape = spatialscape.cli:main

spatialscape-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Totty
+
+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.