auroraomics 0.1.0.dev0__py3-none-any.whl

auroraomics/qc.py

@@ -0,0 +1,288 @@
+"""Patch quality control: which tiles are worth predicting on.
+
+A whole-slide image is mostly not tissue. Feeding the empty glass, the pen
+marks and the out-of-focus edges to a model wastes the run and drags every
+downstream summary toward the mean of nothing, so every candidate tile passes
+three independent predicates first:
+
+``foreground_mask``
+    How much of the tile is *not* slide background — the share of pixels darker
+    than the white level. Rejects empty glass.
+``blur_filter``
+    The variance of the tile's Laplacian, the standard sharpness proxy: a flat
+    response means nothing in the tile has an edge. Rejects out-of-focus tiles.
+``hsv_filter``
+    How much of the tile looks *stained* — pixels with enough saturation to
+    carry dye and not so bright that they are glare. Rejects grey artefacts,
+    which are dark (so they have foreground) and sharp (so they are not blurry)
+    but carry no stain.
+
+All three are ratios or variances of the tile itself, so a tile can be judged
+wherever it is decoded, with no slide reader and no model.
+
+**Higher is stricter for every threshold**: each one is a floor the measured
+value must reach, so raising it keeps fewer tiles.
+
+The stained-tissue predicate is the one that has to agree across
+implementations — the same rule decides which tiles a model sees and which
+tiles a reviewer is shown, in more than one language — so its two constants are
+named here and pinned by a shared vector fixture rather than restated in prose.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import asdict, dataclass, fields
+from typing import Any
+
+import cv2
+import numpy as np
+from . import contracts
+
+#: A pixel counts as stained tissue when its OpenCV-HSV saturation is strictly
+#: above this and its value strictly below :data:`VALUE_MAX`. Both are in
+#: OpenCV's 0-255 HSV units, not the 0-1 or 0-360 conventions.
+SATURATION_MIN = 15
+#: Above this value a pixel is glare or bare glass, however saturated it looks.
+VALUE_MAX = 240
+#: Grey level at or below which a pixel counts as foreground, in 0-255.
+#:
+#: Read from the shipped contract rather than written here, for the reason the
+#: floors below are: it was a bare ``210`` in three places — here and in each
+#: pipeline's ``patch_qc.py`` — and it is the other half of the foreground rule,
+#: so a client cutting foreground at a different level filters a different set
+#: of tiles than the service will.
+WHITE_LEVEL = contracts.foreground_white_level()
+
+#: The service's own floors, read from the contract shipped in this package.
+_DEFAULTS = contracts.qc_thresholds()
+
+@dataclass(frozen=True)
+class QcThresholds:
+    """The floors a tile must reach to be used.
+
+    The field names are the ones a model card's ``input_spec.qc`` block uses,
+    so a card's own thresholds go straight in:
+
+        >>> QcThresholds.from_input_spec(card["input_spec"])   # doctest: +SKIP
+
+    The defaults are the values a card carries when it has no reason to differ,
+    and they are what every predicate below falls back to.
+    """
+
+    #: The three floors, defaulting to the values the service itself runs. They
+    #: come from the vendored contract rather than being typed here: a client that
+    #: filters tiles differently from the server it sends them to would drop tiles
+    #: the service would have kept, or keep tiles it will discard, and every
+    #: number downstream would still look plausible.
+    foreground_ratio: float = _DEFAULTS["foreground_ratio"]
+    hsv_tissue_ratio: float = _DEFAULTS["hsv_tissue_ratio"]
+    blur_laplacian_var: float = _DEFAULTS["blur_laplacian_var"]
+
+    @classmethod
+    def field_names(cls) -> tuple[str, ...]:
+        """The threshold keys, in declaration order."""
+        return tuple(f.name for f in fields(cls))
+
+    @classmethod
+    def from_input_spec(cls, input_spec: dict[str, Any]) -> QcThresholds:
+        """Build from a model card's ``input_spec``.
+
+        Refuses a spec whose ``qc`` block names a threshold this version does
+        not know, rather than silently ignoring it: a threshold the caller
+        believes is being applied and is not is the one failure here that
+        produces plausible-looking results from the wrong tiles.
+        """
+        qc = input_spec.get("qc")
+        if not isinstance(qc, dict):
+            raise ValueError("input_spec has no 'qc' block of thresholds")
+        unknown = sorted(set(qc) - set(cls.field_names()))
+        if unknown:
+            raise ValueError(
+                f"input_spec.qc names thresholds this version cannot apply: "
+                f"{', '.join(unknown)}"
+            )
+        return cls(**{k: float(v) for k, v in qc.items()})
+
+    def as_dict(self) -> dict[str, float]:
+        """The thresholds as a plain mapping, for reports and provenance."""
+        return {k: float(v) for k, v in asdict(self).items()}
+
+
+DEFAULT_THRESHOLDS = QcThresholds()
+
+
+@dataclass(frozen=True)
+class QcResult:
+    """One tile's verdict and the three numbers behind it.
+
+    A statistic the cascade never reached is ``nan``, not zero: zero is a
+    measurement ("this tile has no stained pixels") and would be averaged into
+    per-slide summaries as one.
+
+    ``rejected_by`` names the threshold that rejected the tile, using the
+    :class:`QcThresholds` field name, and is ``None`` when the tile passed.
+    ``passes`` is derived from it rather than stored, because the two must
+    agree and a stored pair can be constructed disagreeing.
+    """
+
+    foreground_ratio: float
+    hsv_ratio: float
+    laplacian_var: float
+    rejected_by: str | None = None
+
+    @property
+    def passes(self) -> bool:
+        """No threshold rejected this tile."""
+        return self.rejected_by is None
+
+    @classmethod
+    def stat_names(cls) -> tuple[str, ...]:
+        """The three measured statistics, in declaration order.
+
+        Callers that persist QC output — the tile manifest inside an archive,
+        the arrays beside an embedding — take their column names from here, so
+        a renamed statistic moves every writer at once.
+        """
+        skip = {"rejected_by"}
+        return tuple(f.name for f in fields(cls) if f.name not in skip)
+
+    def stats(self) -> dict[str, float]:
+        """The three measured statistics as a mapping."""
+        return {name: float(getattr(self, name)) for name in self.stat_names()}
+
+
+def _as_rgb_uint8(tile: np.ndarray) -> np.ndarray:
+    """Check a tile is what every predicate below assumes: HxWx3 RGB uint8.
+
+    Channel ORDER is the trap worth failing loudly on. OpenCV's own decoders
+    hand back BGR, and the conversions below are written against RGB, so a
+    caller who forgets the swap gets a red/blue exchange — which changes hue
+    and therefore saturation, which silently changes which tiles are called
+    tissue. Nothing in the array says which order it is in, so this can only be
+    documented and asserted in shape, never detected.
+    """
+    arr = np.asarray(tile)
+    if arr.ndim != 3 or arr.shape[2] != 3:
+        raise ValueError(
+            f"a tile must be a height x width x 3 RGB array, got shape "
+            f"{arr.shape}"
+        )
+    if arr.dtype != np.uint8:
+        raise ValueError(
+            f"a tile must be uint8 (0-255), got dtype {arr.dtype}; converting "
+            "a float image without rescaling would change every threshold"
+        )
+    if arr.shape[0] == 0 or arr.shape[1] == 0:
+        raise ValueError("a tile must have a non-zero height and width")
+    return arr
+
+
+def foreground_mask(
+    tile: np.ndarray, threshold: float = DEFAULT_THRESHOLDS.foreground_ratio
+) -> tuple[bool, float]:
+    """Is at least ``threshold`` percent of the tile non-background?
+
+    Returns ``(passes, foreground_ratio)`` — the ratio is a percentage, 0-100.
+    """
+    return _foreground_from_grey(_grey(tile), threshold)
+
+
+def _grey(tile: np.ndarray) -> np.ndarray:
+    """Validate the tile and convert it to greyscale, once.
+
+    Two of the three predicates work on greyscale, and :func:`qc_tile` runs
+    both on the same tile, so converting inside each one converts twice —
+    on a cascade whose whole ordering is justified by cost.
+    """
+    return cv2.cvtColor(_as_rgb_uint8(tile), cv2.COLOR_RGB2GRAY)
+
+
+def _foreground_from_grey(grey: np.ndarray, threshold: float) -> tuple[bool, float]:
+    _, mask = cv2.threshold(grey, WHITE_LEVEL, 255, cv2.THRESH_BINARY_INV)
+    foreground_ratio = float(cv2.countNonZero(mask) / mask.size * 100)
+    return foreground_ratio >= threshold, foreground_ratio
+
+
+def hsv_filter(
+    tile: np.ndarray, required_ratio: float = DEFAULT_THRESHOLDS.hsv_tissue_ratio
+) -> tuple[bool, float]:
+    """Is at least ``required_ratio`` percent of the tile stained tissue?
+
+    A pixel is stained when its saturation is above :data:`SATURATION_MIN` and
+    its value below :data:`VALUE_MAX`; both bounds are exclusive.
+
+    Returns ``(passes, ratio)`` — the ratio is a percentage, 0-100.
+    """
+    arr = _as_rgb_uint8(tile)
+    hsv = cv2.cvtColor(arr, cv2.COLOR_RGB2HSV)
+    mask = (hsv[:, :, 1] > SATURATION_MIN) & (hsv[:, :, 2] < VALUE_MAX)
+    ratio = float(np.sum(mask) / mask.size * 100)
+    return ratio >= required_ratio, ratio
+
+
+def blur_filter(
+    tile: np.ndarray, blur_threshold: float = DEFAULT_THRESHOLDS.blur_laplacian_var
+) -> tuple[bool, float]:
+    """Is the tile sharp enough, by Laplacian variance?
+
+    Returns ``(passes, laplacian_var)``. The variance is a bare number, not a
+    percentage: it scales with contrast, so a threshold tuned on one stain and
+    scanner does not transfer unexamined to another.
+    """
+    return _blur_from_grey(_grey(tile), blur_threshold)
+
+
+def _blur_from_grey(grey: np.ndarray, blur_threshold: float) -> tuple[bool, float]:
+    laplacian_var = float(cv2.Laplacian(grey, cv2.CV_64F).var())
+    return laplacian_var >= blur_threshold, laplacian_var
+
+
+def qc_tile(
+    tile: np.ndarray, thresholds: QcThresholds | None = None
+) -> QcResult:
+    """Run the three predicates over one tile and return the verdict.
+
+    The order is foreground, then blur, then stain, and it SHORT-CIRCUITS: a
+    tile that fails an earlier predicate is not measured by the later ones, and
+    their statistics come back ``nan``. Two reasons, in this order:
+
+    * cost — the cascade runs on every candidate tile of a slide, which is
+      hundreds of thousands of them, and the cheapest predicate rejects the
+      most;
+    * meaning — the stain ratio of a tile that is 95 % empty glass is not a
+      property of any tissue, and recording it as a number invites it into an
+      average.
+
+    The order itself is part of the contract, because it decides which
+    statistics exist: swapping blur and stain would leave a different column
+    populated for exactly the same tiles.
+    """
+    thresholds = thresholds or DEFAULT_THRESHOLDS
+    # nan, not zero: a statistic the cascade never reached was not measured.
+    foreground_ratio = hsv_ratio = laplacian_var = math.nan
+
+    def verdict(rejected_by: str | None = None) -> QcResult:
+        return QcResult(
+            foreground_ratio=foreground_ratio,
+            hsv_ratio=hsv_ratio,
+            laplacian_var=laplacian_var,
+            rejected_by=rejected_by,
+        )
+
+    # Both grey predicates read the same conversion.
+    grey = _grey(tile)
+
+    passed, foreground_ratio = _foreground_from_grey(grey, thresholds.foreground_ratio)
+    if not passed:
+        return verdict("foreground_ratio")
+
+    passed, laplacian_var = _blur_from_grey(grey, thresholds.blur_laplacian_var)
+    if not passed:
+        return verdict("blur_laplacian_var")
+
+    passed, hsv_ratio = hsv_filter(tile, required_ratio=thresholds.hsv_tissue_ratio)
+    if not passed:
+        return verdict("hsv_tissue_ratio")
+
+    return verdict()

auroraomics/subsample.py

@@ -0,0 +1,140 @@
+"""Spend a limited tile budget on the densest part of the slide.
+
+A run is allowed a maximum number of tiles. When a slide yields more, something
+has to choose, and *which* tiles are dropped changes what the result can be
+used for: taking the first N walks a raster line across the slide, and taking a
+random N shreds the tissue into isolated spots, so every neighbourhood
+statistic downstream is computed over holes.
+
+So the choice is a contiguous region — the densest square that holds the budget
+— and spatial structure survives inside it. What is lost is stated plainly: the
+tissue outside that square is not predicted at all, and a result must say so
+rather than look like a whole slide.
+
+The implementation is an integral image: build an occupancy grid, prefix-sum
+it, then binary-search for the smallest square window that holds the budget and
+place it where the count is highest. That is O(n + G² log G) in the grid size,
+against the O(n² · iterations) of sweeping windows over the points themselves —
+the difference between milliseconds and minutes at 300k spots.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+#: Grid resolution cap per axis. 500 x 500 cells is 250k of them, which bounds
+#: both the prefix sum and the binary search regardless of how many distinct
+#: coordinates a slide has.
+MAX_GRID = 500
+
+#: Seed for the final trim. The densest square usually holds slightly MORE than
+#: the budget, and the overflow has to go; a fixed seed makes which tiles go a
+#: property of the input rather than of the day, so two runs of one slide
+#: produce the same tiles.
+SEED = 42
+
+
+def subsample_spatial_square(
+    x: np.ndarray, y: np.ndarray, max_items: int
+) -> np.ndarray:
+    """Choose at most ``max_items`` of the given points, as a boolean mask.
+
+    Parameters
+    ----------
+    x, y:
+        Coordinates of each candidate spot, in the same units (pixels), one
+        entry per spot.
+    max_items:
+        The budget. When there are no more points than this, every point is
+        kept and no work is done.
+
+    Returns
+    -------
+    numpy.ndarray
+        A boolean mask over the input order: ``True`` for the points to keep.
+        Returning a mask rather than the selected coordinates lets the caller
+        apply the same choice to everything it holds per spot.
+    """
+    x = np.asarray(x, dtype=np.float64).ravel()
+    y = np.asarray(y, dtype=np.float64).ravel()
+    if x.shape != y.shape:
+        raise ValueError(
+            f"x and y must describe the same points, got {x.shape} and {y.shape}"
+        )
+    if max_items <= 0:
+        raise ValueError(f"max_items must be positive, got {max_items}")
+
+    n_points = x.size
+    if n_points <= max_items:
+        return np.ones(n_points, dtype=bool)
+
+    # ── map coordinates onto a grid ─────────────────────────────────────────
+    # Distinct coordinates become grid cells directly while there are few
+    # enough of them, which keeps a regular spot lattice exact. Past the cap
+    # the axis is binned into equal-width cells instead.
+    column_index, columns = _axis_index(x)
+    row_index, rows = _axis_index(y)
+
+    # ── occupancy grid and its prefix sum ───────────────────────────────────
+    grid = np.zeros((rows, columns), dtype=np.int32)
+    np.add.at(grid, (row_index, column_index), 1)
+    prefix = np.zeros((rows + 1, columns + 1), dtype=np.int64)
+    prefix[1:, 1:] = np.cumsum(np.cumsum(grid, axis=0), axis=1)
+
+    def window_counts(size: int) -> np.ndarray:
+        """Point count of every square window of ``size`` cells, vectorised."""
+        if size > rows or size > columns:
+            return np.zeros((1, 1), dtype=np.int64)
+        return (
+            prefix[size:, size:]
+            - prefix[size:, : columns - size + 1]
+            - prefix[: rows - size + 1, size:]
+            + prefix[: rows - size + 1, : columns - size + 1]
+        )
+
+    # ── the smallest window that holds the budget ───────────────────────────
+    low, high = 1, max(rows, columns)
+    best_size = high
+    while low <= high:
+        middle = (low + high) // 2
+        counts = window_counts(middle)
+        if counts.size and counts.max() >= max_items:
+            best_size = middle
+            high = middle - 1
+        else:
+            low = middle + 1
+
+    # ── and the densest place to put it ─────────────────────────────────────
+    counts = window_counts(best_size)
+    best_row, best_column = np.unravel_index(int(np.argmax(counts)), counts.shape)
+
+    inside = (
+        (column_index >= best_column)
+        & (column_index < best_column + best_size)
+        & (row_index >= best_row)
+        & (row_index < best_row + best_size)
+    )
+
+    selected = int(inside.sum())
+    if selected <= max_items:
+        return inside
+
+    # The window is the smallest that HOLDS the budget, so it usually holds a
+    # few more; trim the overflow at random from inside it, seeded.
+    positions = np.flatnonzero(inside)
+    keep = np.random.RandomState(SEED).choice(
+        positions.size, size=max_items, replace=False
+    )
+    mask = np.zeros(inside.shape, dtype=bool)
+    mask[positions[keep]] = True
+    return mask
+
+
+def _axis_index(values: np.ndarray) -> tuple[np.ndarray, int]:
+    """Grid index of every coordinate on one axis, and the axis's cell count."""
+    unique = np.unique(values)
+    if unique.size > MAX_GRID:
+        edges = np.linspace(values.min(), values.max() + 1, MAX_GRID + 1)
+        index = np.clip(np.digitize(values, edges) - 1, 0, MAX_GRID - 1)
+        return index, MAX_GRID
+    return np.searchsorted(unique, values), int(unique.size)

auroraomics-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: auroraomics
+Version: 0.1.0.dev0
+Summary: Virtual spatial transcriptomics from H&E histology: patch QC, tile packing and the .h5ad result contract.
+Author: Kalin Nonchev
+License-Expression: PolyForm-Noncommercial-1.0.0
+Keywords: histopathology,spatial-transcriptomics,h5ad,anndata,whole-slide-image
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23
+Requires-Dist: h5py>=3.9
+Requires-Dist: opencv-python-headless>=4.5
+Requires-Dist: pillow>=9
+Provides-Extra: client
+Requires-Dist: httpx>=0.27; extra == "client"
+Requires-Dist: pydantic>=2; extra == "client"
+Requires-Dist: anndata>=0.10; extra == "client"
+Provides-Extra: deepspotm
+Provides-Extra: slide
+Requires-Dist: tifffile>=2023.7.10; extra == "slide"
+Requires-Dist: imagecodecs>=2023.3.16; extra == "slide"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: setuptools>=77; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: anndata<0.12,>=0.10; extra == "dev"
+Requires-Dist: tifffile>=2023.7.10; extra == "dev"
+Requires-Dist: imagecodecs>=2023.3.16; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: numpy<2; extra == "dev"
+Dynamic: license-file
+
+# auroraomics
+
+Virtual spatial transcriptomics from H&E histology.
+
+This package holds the pieces of that pipeline that are pure Python, so the
+same code runs on your laptop, in a GPU container and on the service:
+
+- **`auroraomics.qc`** — the three patch-quality predicates (foreground, blur,
+  stained tissue) applied to every candidate tile before a model sees it, and
+  the short-circuiting cascade that combines them.
+- **`auroraomics.pack`** — build the `patches` archive a prediction takes as
+  input (`pack_tiles`), and validate one you have been handed (`read_archive`).
+- **`auroraomics.h5ad`** — write the standard `.h5ad` result with `h5py`
+  alone, streaming the expression matrix batch by batch so peak memory is one
+  batch rather than the whole matrix.
+- **`auroraomics.subsample`** — pick the densest contiguous square of spots
+  when a slide yields more tiles than a run is allowed to spend.
+- **`auroraomics.contracts`** — the shared contract values (container layout,
+  input-kind caps, result layout) as data, so nothing here re-types a number
+  the service also reads.
+
+## Install
+
+```
+pip install auroraomics
+```
+
+The core needs only numpy, h5py, OpenCV and Pillow. Extras add the API client
+(`client`), a local model runtime (`deepspotm`) and pyramidal slide reading
+(`slide`).
+
+## Pack tiles, then look at the report
+
+```python
+import auroraomics as ao
+
+report = ao.pack_tiles(tiles, "sample.zip", mpp=0.499, thumbnail=thumb)
+print(report.written, "tiles kept,", report.rejected, "dropped")
+print(report.rejected_by_reason)          # {'foreground_ratio': 12, ...}
+```
+
+`tiles` is any iterable of `ao.Tile(image, x, y)`, where `image` is an RGB
+`uint8` array and `x`/`y` are the tile's top-left position in full-resolution
+pixels. Tiles are quality-checked as they stream past, and only the ones that
+pass are written, so an iterable that reads a slide lazily never has to hold
+more than one tile in memory.
+
+## Validate an archive before trusting it
+
+```python
+archive = ao.read_archive("sample.zip")   # raises ArchiveError on anything odd
+for tile in archive.tiles():              # decoded one at a time
+    ...
+```
+
+`read_archive` checks the member names, the manifest, the tile geometry and the
+declared sizes *before* decoding a single pixel, and refuses an archive whose
+members do not match the container contract.
+
+## Write a result
+
+```python
+ao.write_result(
+    "result.h5ad",
+    obs=obs,                    # per-spot columns, as plain arrays
+    var=var,                    # per-gene columns, indexed by gene id
+    spatial=coords,             # (n_spots, 2) array -> obsm["spatial"]
+    x=batches,                  # an array, or an iterable of row batches
+    uns={"model": {"id": "..."}},
+    layers={"image_only": other_batches},
+)
+```
+
+The file reads back as an ordinary `AnnData` in anndata 0.10 and 0.11. Passing
+an iterable for `x` streams it: each batch is compressed into the file as it
+arrives and then dropped, which is what makes a matrix larger than memory
+writable.
+
+## Typing
+
+The package ships `py.typed`, so annotations are visible to type checkers in
+your project.
+
+## Licence
+
+The code in this package is licensed under
+[PolyForm Noncommercial 1.0.0](https://polyformproject.org/licenses/noncommercial/1.0.0),
+which permits use for any purpose that is not commercial. It is the same licence the
+model package this client is built for carries, so installing both puts you under one
+rule rather than two.
+
+The model weights are licensed separately by whoever publishes them, and access to them
+may be gated. Read those terms before you use a model: they are not this licence, and a
+permission granted here is not a permission granted there.
+

auroraomics-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,19 @@
+auroraomics/__init__.py,sha256=JkWGXnQTUFu362kVcQJpcybwZo6ycIYqgAOfwIt3XO4,2109
+auroraomics/contracts.py,sha256=YGn1FT4NFGDwm4a9SKETCd59DPUcWEJMqbsdaoqDzf8,5972
+auroraomics/h5ad.py,sha256=7Oq19u8vVyLBhvi4Io--hKBrUoFemq8ZBoNBJ5Ivnww,15939
+auroraomics/pack.py,sha256=ToxFmpfeC8TJOtrVkwbrOyZy-LfEezd_tz3S9bnpt7c,25422
+auroraomics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auroraomics/qc.py,sha256=f60ebJDhsc22OcoO3qTDMK3iSZuVR8rCqob-YVGrjzM,11773
+auroraomics/subsample.py,sha256=lojo6iJrq1CY2SMTyC6ifAUwD_Q2GRL6UVwXqVO22F0,5880
+auroraomics/_contracts/MANIFEST.json,sha256=IseYJJm-_Q8shHZvodOfFcsNOO1RVC3FEcxxEc_KbpA,782
+auroraomics/_contracts/public-api-counters.tokens.json,sha256=glRNScqQiXFyrVBk2q5FAIF1_HFSuOrWQRtJQI35l50,849
+auroraomics/_contracts/public-api-input-kinds.tokens.json,sha256=ZUtF90BIWsbne9P8j9DpG3RT2jjERbN69GC9ooA1EVg,2188
+auroraomics/_contracts/public-api.tokens.json,sha256=p35ItqrtjuQCD7_Zl5bb-23YGMpvsByeIQK09KB6POc,7499
+auroraomics/_contracts/qc-thresholds.tokens.json,sha256=1l3jwwbXWrZYijoT_t_i5WLIThKSHr7gj4EM2LC5rkc,1617
+auroraomics/_contracts/genes/gene-table.2026-09-05.json,sha256=Db-X9ps35P2xoT5cBQiMcX-PbOx_sExJpJh_jGSVpck,3827986
+auroraomics/_contracts/public-api/golden-16-tiles.manifest.json,sha256=LZP7_SqkVCzHXQwt6jTxmcbPh_USMgH5UrWN5LfRQJQ,7897
+auroraomics-0.1.0.dev0.dist-info/licenses/LICENSE,sha256=i_s2EEVLTyPBklHvoeFFrtXRyxN1A6u_SKohEXlDkYc,4595
+auroraomics-0.1.0.dev0.dist-info/METADATA,sha256=SUKCRgZZRICGGf52ex5kK-8mZbmumjCF2eBrCZKiBuk,5257
+auroraomics-0.1.0.dev0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+auroraomics-0.1.0.dev0.dist-info/top_level.txt,sha256=3Q7rafAR7MW37pdCm6DADeEIO_QkLMB-b3tAK_V1kjU,12
+auroraomics-0.1.0.dev0.dist-info/RECORD,,

auroraomics-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+