| """Loaders for the package's core data layers. |
| |
| All loaders accept an optional ``root`` (package root directory). When |
| omitted, the root is located by walking upward from the current working |
| directory looking for ``core/basis/basis_registry.json``. |
| |
| Contracts (docs/DATA_DICTIONARY.md): every matrix is row-aligned to its |
| sibling ``*_compounds.parquet`` (positional alignment is the join key); |
| usage column j is program P{j+1} of the pinned basis; gene symbols come |
| only from the harmonized panel file. |
| """ |
|
|
| from __future__ import annotations |
|
|
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| CONTEXTS = ( |
| "zel024_hek293", |
| "zel024_h1650", |
| "zel028_hek293", |
| "zel028_a549", |
| "zel028_h1650", |
| "zel031_a549", |
| "zel031_thp1", |
| "zel039_aec7", |
| ) |
|
|
| CONTROL_CONTEXTS = ( |
| "zic008_a549", |
| "zic008_aec7", |
| "zic008_h1650", |
| "zic008_hek293", |
| "zic008_hek293clone", |
| ) |
|
|
| _ROOT_MARKERS = ("core/basis/basis_registry.json", "core/recipes.parquet") |
|
|
|
|
| def find_root(start: str | Path | None = None) -> Path: |
| """Locate the package root by walking upward from ``start`` (default: |
| the current working directory).""" |
| here = Path(start or Path.cwd()).resolve() |
| for candidate in (here, *here.parents): |
| if all((candidate / marker).exists() for marker in _ROOT_MARKERS): |
| return candidate |
| raise FileNotFoundError( |
| "could not locate the package root (no core/basis/basis_registry.json " |
| "found upward from " |
| f"{here}); pass root= explicitly") |
|
|
|
|
| def _resolve(root: str | Path | None) -> Path: |
| return Path(root).resolve() if root is not None else find_root() |
|
|
|
|
| def _check_context(context: str) -> str: |
| if context not in CONTEXTS: |
| raise ValueError( |
| f"unknown context {context!r}; expected one of {', '.join(CONTEXTS)}") |
| return context |
|
|
|
|
| def load_usages(context: str, root: str | Path | None = None): |
| """Return (usages, compounds) for a context: usages is float32 |
| (n_compounds, 32), compounds is the aligned single-column |
| public_compound_id frame. Row i of the matrix is row i of the frame.""" |
| root = _resolve(root) |
| _check_context(context) |
| usages = np.load(root / "core" / "usages" / f"usages_{context}.npy") |
| compounds = pd.read_parquet( |
| root / "core" / "usages" / f"usages_{context}_compounds.parquet") |
| if usages.shape[0] != len(compounds): |
| raise ValueError( |
| f"row-alignment broken for {context}: {usages.shape[0]} usage rows " |
| f"vs {len(compounds)} compound rows") |
| return usages, compounds |
|
|
|
|
| def load_surface(context: str, root: str | Path | None = None): |
| """Return (surface, compounds) for a context: surface is float32 |
| (n_compounds, 6000) on the harmonized panel, compounds is the aligned |
| single-column public_compound_id frame.""" |
| root = _resolve(root) |
| _check_context(context) |
| surface = np.load(root / "core" / "surfaces" / f"surfaces_{context}.npy") |
| compounds = pd.read_parquet( |
| root / "core" / "surfaces" / f"{context}_compounds.parquet") |
| if surface.shape[0] != len(compounds): |
| raise ValueError( |
| f"row-alignment broken for {context}: {surface.shape[0]} surface rows " |
| f"vs {len(compounds)} compound rows") |
| return surface, compounds |
|
|
|
|
| def load_basis(k: int = 32, root: str | Path | None = None) -> np.ndarray: |
| """Return the pinned shared basis as float32 (k, 6000). k is 32 |
| (shared_program_basis_v1) or 12 (shared_program_basis_k12_v1).""" |
| root = _resolve(root) |
| if k not in (12, 32): |
| raise ValueError("k must be 32 or 12") |
| return np.load(root / "core" / "basis" / f"shared_basis_k{k}.npy") |
|
|
|
|
| def load_recipes(root: str | Path | None = None) -> pd.DataFrame: |
| """Return the building-block grammar table: one row per |
| public_compound_id, columns bb0..bb4 (null = absent position) and |
| n_positions_occupied.""" |
| root = _resolve(root) |
| return pd.read_parquet(root / "core" / "recipes.parquet") |
|
|
|
|
| def load_folds(root: str | Path | None = None) -> pd.DataFrame: |
| """Return fold assignments: context, public_compound_id, fold |
| (fold = SHA256(public_compound_id) mod 5). Basis and reference model |
| were fit with fold 0 held out.""" |
| root = _resolve(root) |
| return pd.read_parquet(root / "core" / "splits" / "fold_assignments.parquet") |
|
|
|
|
| def panel_genes(root: str | Path | None = None) -> pd.DataFrame: |
| """Return the harmonized 6,000-gene panel definition |
| (panel_position, gene_index, gene). The only authoritative mapping of |
| panel columns to gene symbols.""" |
| root = _resolve(root) |
| return pd.read_parquet(root / "core" / "surfaces" / "harmonized_6000_genes.parquet") |
|
|
|
|
| def _check_control_context(context: str) -> str: |
| if context not in CONTROL_CONTEXTS: |
| raise ValueError( |
| f"unknown control context {context!r}; expected one of " |
| f"{', '.join(CONTROL_CONTEXTS)}") |
| return context |
|
|
|
|
| def load_control_surface(context: str, root: str | Path | None = None): |
| """Return (surface, controls) for a control context: surface is |
| float32 (35, 6000) on the harmonized panel, controls is the aligned |
| frame (public_compound_id, control_name, n_wells, n_devices, |
| total_umis). Row i of the matrix is row i of the frame.""" |
| root = _resolve(root) |
| _check_control_context(context) |
| surface = np.load(root / "annex_controls" / f"control_surfaces_{context}.npy") |
| controls = pd.read_parquet( |
| root / "annex_controls" / f"control_surfaces_{context}_compounds.parquet") |
| if surface.shape[0] != len(controls): |
| raise ValueError( |
| f"row-alignment broken for {context}: {surface.shape[0]} surface rows " |
| f"vs {len(controls)} control rows") |
| return surface, controls |
|
|
|
|
| def load_control_pseudobulks(context: str, root: str | Path | None = None): |
| """Return (counts, pseudobulks) for a control context: counts is |
| float32 (n_pseudobulks, 6000) summed UMI counts (raw, not |
| normalized) on the harmonized panel, pseudobulks is the aligned |
| frame (public_compound_id, control_name, batch_id, n_wells, |
| total_umis). Normalize as log1p(counts / total_umis * 1e4).""" |
| root = _resolve(root) |
| _check_control_context(context) |
| counts = np.load( |
| root / "annex_controls" / f"control_pseudobulk_counts_{context}.npy") |
| pseudobulks = pd.read_parquet( |
| root / "annex_controls" / f"control_pseudobulks_{context}.parquet") |
| if counts.shape[0] != len(pseudobulks): |
| raise ValueError( |
| f"row-alignment broken for {context}: {counts.shape[0]} count rows " |
| f"vs {len(pseudobulks)} pseudobulk rows") |
| return counts, pseudobulks |
|
|
|
|
| def load_control_usages(root: str | Path | None = None) -> pd.DataFrame: |
| """Return the per-control 32-program usage table (175 rows: |
| control_context, public_compound_id, control_name, n_wells, |
| u_P01..u_P32). Column u_P0j is program Pj of the pinned basis.""" |
| root = _resolve(root) |
| return pd.read_parquet(root / "annex_controls" / "control_usages_k32.parquet") |
|
|
