statgen 0.2.0__tar.gz → 0.2.1__tar.gz

{statgen-0.2.0 → statgen-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statgen
-Version: 0.2.0
+Version: 0.2.1
 Summary: Statistical genetics data objects and loaders for Python and MATLAB/Octave.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{statgen-0.2.0 → statgen-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "statgen"
-version = "0.2.0"
+version = "0.2.1"
 description = "Statistical genetics data objects and loaders for Python and MATLAB/Octave."
 readme = "README.md"
 requires-python = ">=3.10"

statgen-0.2.1/statgen/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.1"

{statgen-0.2.0 → statgen-0.2.1}/statgen/_ld_npz.py

@@ -19,30 +19,51 @@ from ._ld_schema import (
 
 def validate_npz_distribution(path, check_payload_structure=False) -> dict:
     path = Path(path)
+    if not path.is_dir():
+        raise ValueError("validate_npz_distribution: path must identify a panel root directory")
+
+    manifest = read_manifest(path / "ld_manifest.json", expected_runtime=PY_RUNTIME_FORMAT)
+    runtime = manifest["runtime_format"]
+    seen_reference_bim = set()
+    for entry in manifest["shards"]:
+        shard_path = path / entry["file"]
+        require_file(shard_path)
+        file_md5 = md5_file(shard_path)
+        if file_md5 != entry.get("file_md5"):
+            raise ValueError(f"{shard_path}: file_md5 does not match manifest")
+        _ld_r, _a1freq, meta = read_npz_shard(
+            shard_path,
+            check_payload_structure=check_payload_structure,
+        )
+        validate_manifest_entry_agreement(entry, meta, shard_path)
+        reference_key = (
+            entry["reference_bim"],
+            entry["chr"],
+            int(entry["num_snp"]),
+            entry["reference_checksum"],
+        )
+        if reference_key not in seen_reference_bim:
+            _validate_bundled_reference(root=path, entry=entry)
+            seen_reference_bim.add(reference_key)
+
+    return {"ok": True}
 
-    if path.is_dir():
-        manifest = read_manifest(path / "ld_manifest.json", expected_runtime=PY_RUNTIME_FORMAT)
-        runtime = manifest["runtime_format"]
-        for entry in manifest["shards"]:
-            shard_path = path / entry["file"]
-            require_file(shard_path)
-            file_md5 = md5_file(shard_path)
-            if file_md5 != entry.get("file_md5"):
-                raise ValueError(f"{shard_path}: file_md5 does not match manifest")
-            _ld_r, _a1freq, meta = read_npz_shard(
-                shard_path,
-                check_payload_structure=check_payload_structure,
-            )
-            validate_manifest_entry_agreement(entry, meta, shard_path)
-    else:
-        runtime = runtime_from_suffix(path)
-        if runtime != PY_RUNTIME_FORMAT:
-            raise ValueError(f"{path}: unsupported LD runtime {runtime!r}")
-        read_npz_shard(path, check_payload_structure=check_payload_structure)
 
+def validate_npz_shard_file(path, check_payload_structure=False) -> dict:
+    path = Path(path)
+    runtime = runtime_from_suffix(path)
+    if runtime != PY_RUNTIME_FORMAT:
+        raise ValueError(f"{path}: unsupported LD runtime {runtime!r}")
+    read_npz_shard(path, check_payload_structure=check_payload_structure)
     return {"ok": True}
 
 
+def _validate_bundled_reference(*, root: Path, entry: dict) -> None:
+    from ._ld_reference import validate_bundled_reference_bim
+
+    validate_bundled_reference_bim(root / entry["reference_bim"], entry, target="manifest")
+
+
 def read_npz_shard(path: Path, check_payload_structure: bool):
     require_file(path)
     with np.load(path, allow_pickle=False) as data:

statgen-0.2.1/statgen/_ld_reference.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+
+from ._ld_schema import require_file
+from ._utils import validate_requested_shards
+from .reference import ReferencePanel, load_reference
+
+
+def validate_bundled_reference_bim(path, entry: dict, *, target: str):
+    path = Path(path)
+    require_file(path)
+    panel = load_reference(path)
+    ref_shards = panel.shards
+    if len(ref_shards) != 1:
+        raise ValueError(f"{path}: bundled reference_bim must contain exactly one shard")
+    ref = ref_shards[0]
+    validate_reference_shard_for_ld_entry(ref, entry, path, target=target)
+    return ref
+
+
+def validate_reference_shard_for_ld_entry(ref_shard, entry: dict, path, *, target: str) -> None:
+    path = Path(path)
+    if ref_shard.label != entry["chr"]:
+        raise ValueError(f"{path}: bundled reference_bim chr does not match {target}")
+    if ref_shard.num_snp != int(entry["num_snp"]):
+        raise ValueError(f"{path}: bundled reference_bim num_snp does not match {target}")
+    if ref_shard.checksum != entry["reference_checksum"]:
+        raise ValueError(f"{path}: bundled reference_bim reference_checksum does not match {target}")
+
+
+def load_bundled_reference_panel(root, manifest: dict, shards, *, where: str) -> ReferencePanel:
+    root = Path(root)
+    available = _manifest_chr_labels(manifest)
+    selected = validate_requested_shards(shards, available, where)
+    entries_by_chr = {}
+    for entry in manifest["shards"]:
+        entries_by_chr.setdefault(entry["chr"], []).append(entry)
+
+    ref_shards = []
+    for label in selected:
+        entries = entries_by_chr[label]
+        reference_path = root / entries[0]["reference_bim"]
+        ref_shard = validate_bundled_reference_bim(reference_path, entries[0], target="manifest")
+        for entry in entries[1:]:
+            validate_reference_shard_for_ld_entry(ref_shard, entry, reference_path, target="manifest")
+        ref_shards.append(ref_shard)
+    return ReferencePanel(ref_shards)
+
+
+def _manifest_chr_labels(manifest: dict) -> list[str]:
+    labels = []
+    seen = set()
+    for entry in manifest["shards"]:
+        label = entry["chr"]
+        if label not in seen:
+            labels.append(label)
+            seen.add(label)
+    return labels

{statgen-0.2.0 → statgen-0.2.1}/statgen/_ld_schema.py

@@ -33,17 +33,30 @@ def read_manifest(path: Path, expected_runtime: str | None) -> dict:
         raise ValueError(f"{path}: shards must be a non-empty list")
 
     seen = set()
+    reference_bim_by_chr = {}
     for i, entry in enumerate(shards):
         validate_manifest_entry(entry, f"{path}:shards[{i}]")
         key = (entry["chr"], entry["sex"])
         if key in seen:
             raise ValueError(f"{path}: duplicate manifest entry for chr {key[0]} sex {key[1]!r}")
         seen.add(key)
+        prior_reference_bim = reference_bim_by_chr.setdefault(entry["chr"], entry["reference_bim"])
+        if entry["reference_bim"] != prior_reference_bim:
+            raise ValueError(f"{path}: manifest entries for chr {entry['chr']} must share reference_bim")
     return manifest
 
 
 def validate_manifest_entry(entry: dict, where: str) -> None:
-    required = {"chr", "sex", "file", "file_md5", "num_snp", "nnz", "reference_checksum"}
+    required = {
+        "chr",
+        "sex",
+        "file",
+        "file_md5",
+        "num_snp",
+        "nnz",
+        "reference_checksum",
+        "reference_bim",
+    }
     missing = sorted(required.difference(entry))
     if missing:
         raise ValueError(f"{where}: missing required fields: {', '.join(missing)}")
@@ -58,6 +71,7 @@ def validate_manifest_entry(entry: dict, where: str) -> None:
         raise ValueError(f"{where}: reference_checksum must be a non-empty string")
     if not isinstance(entry["file_md5"], str) or len(entry["file_md5"]) != 32:
         raise ValueError(f"{where}: file_md5 must be a lowercase MD5 hex string")
+    validate_reference_bim_filename(entry["reference_bim"], f"{where}: reference_bim")
 
 
 def validate_shard_metadata(meta: dict, path: Path, expected_format: str) -> None:
@@ -73,6 +87,8 @@ def validate_shard_metadata(meta: dict, path: Path, expected_format: str) -> Non
         "diagonal",
         "value",
         "reference_checksum",
+        "reference_bim",
+        "num_monomorphic_snps",
     }
     missing = sorted(required.difference(meta))
     if missing:
@@ -86,6 +102,12 @@ def validate_shard_metadata(meta: dict, path: Path, expected_format: str) -> Non
     validate_chr_sex(meta["chr"], meta["sex"], f"{path}: metadata")
     validate_positive_int(meta["num_snp"], f"{path}: metadata num_snp")
     validate_nonnegative_int(meta["nnz"], f"{path}: metadata nnz")
+    validate_nonnegative_int(
+        meta["num_monomorphic_snps"],
+        f"{path}: metadata num_monomorphic_snps",
+    )
+    if int(meta["num_monomorphic_snps"]) > int(meta["num_snp"]):
+        raise ValueError(f"{path}: metadata num_monomorphic_snps must not exceed num_snp")
     if int(meta["nnz"]) >= 2**31:
         raise ValueError(f"{path}: CSC32 metadata nnz must be < 2^31")
     if meta["matrix"] != "symmetric":
@@ -96,6 +118,7 @@ def validate_shard_metadata(meta: dict, path: Path, expected_format: str) -> Non
         raise ValueError(f"{path}: metadata value must be 'r'")
     if not isinstance(meta["reference_checksum"], str) or meta["reference_checksum"] == "":
         raise ValueError(f"{path}: metadata reference_checksum must be a non-empty string")
+    validate_reference_bim_filename(meta["reference_bim"], f"{path}: metadata reference_bim")
     if expected_format == NPZ_FORMAT:
         if meta.get("sparse_layout") != "csc":
             raise ValueError(f"{path}: metadata sparse_layout must be 'csc'")
@@ -119,7 +142,7 @@ def validate_chrx_sex(sex, where: str) -> str:
 
 
 def validate_manifest_entry_agreement(entry: dict, meta: dict, path: Path) -> None:
-    for key in ("chr", "sex", "num_snp", "nnz", "reference_checksum"):
+    for key in ("chr", "sex", "num_snp", "nnz", "reference_checksum", "reference_bim"):
         if entry.get(key) != meta.get(key):
             raise ValueError(f"{path}: manifest/per-file metadata mismatch for {key}")
     suffix_runtime = runtime_from_suffix(path)
@@ -127,6 +150,19 @@ def validate_manifest_entry_agreement(entry: dict, meta: dict, path: Path) -> No
         raise ValueError(f"{path}: manifest file extension and metadata format disagree")
 
 
+def default_reference_bim_filename(chr_label: str) -> str:
+    return f"reference_chr{chr_label}.bim"
+
+
+def validate_reference_bim_filename(value, where: str) -> str:
+    if not isinstance(value, str) or value == "":
+        raise ValueError(f"{where} must be a non-empty filename")
+    path = Path(value)
+    if path.is_absolute() or len(path.parts) != 1 or value in {".", ".."} or ".." in value:
+        raise ValueError(f"{where} must be a plain relative filename")
+    return value
+
+
 def runtime_from_suffix(path: Path) -> str:
     if path.suffix == ".npz":
         return PY_RUNTIME_FORMAT

{statgen-0.2.0 → statgen-0.2.1}/statgen/_ld_writer.py

@@ -14,11 +14,14 @@ from ._ld_schema import (
     NPZ_REQUIRED,
     PY_RUNTIME_FORMAT,
     SHARD_SCHEMA,
+    default_reference_bim_filename,
     md5_file,
     validate_chr_sex,
     validate_positive_int,
+    validate_reference_bim_filename,
     validate_shard_metadata,
 )
+from ._ld_reference import validate_bundled_reference_bim
 from ._utils import CHR_RANK
 
 
@@ -70,8 +73,14 @@ def write_ld_npz_shards(root, shard_specs) -> list[dict]:
             raise ValueError(f"duplicate LD shard output file: {file_key}")
         seen_files.add(file_key)
 
-        shard_payload = {k: v for k, v in normalized.items() if k != "file"}
+        shard_payload = {
+            k: v
+            for k, v in normalized.items()
+            if k not in {"file", "reference_shard"}
+        }
         meta = _write_ld_npz_shard(path, **shard_payload)
+        reference_bim = meta["reference_bim"]
+        _ensure_reference_bim(root / reference_bim, normalized["reference_shard"], meta)
         records.append(
             {
                 "chr": meta["chr"],
@@ -81,6 +90,7 @@ def write_ld_npz_shards(root, shard_specs) -> list[dict]:
                 "num_snp": meta["num_snp"],
                 "nnz": meta["nnz"],
                 "reference_checksum": meta["reference_checksum"],
+                "reference_bim": reference_bim,
             }
         )
     return records
@@ -131,6 +141,7 @@ def _ld_npz_manifest_record(path: Path, root: Path) -> dict:
         "num_snp": meta["num_snp"],
         "nnz": meta["nnz"],
         "reference_checksum": meta["reference_checksum"],
+        "reference_bim": _require_reference_bim(root, meta),
     }
 
 
@@ -155,6 +166,7 @@ def _normalize_ld_shard_write_spec(spec: dict) -> dict:
         "build_metadata",
         "extra_metadata",
         "file",
+        "reference_bim",
     }
     unknown = sorted(set(spec).difference(allowed))
     if unknown:
@@ -178,12 +190,26 @@ def _normalize_ld_shard_write_spec(spec: dict) -> dict:
     reference_checksum = spec.get("reference_checksum", getattr(ref, "checksum", None))
     if not isinstance(reference_checksum, str) or reference_checksum == "":
         raise ValueError("LD shard write spec reference_checksum must be a non-empty string")
+    reference_bim = validate_reference_bim_filename(
+        spec.get("reference_bim", default_reference_bim_filename(chr_label)),
+        "LD shard write spec reference_bim",
+    )
+    if ref is None:
+        raise ValueError("LD shard write spec must provide reference_shard so reference_bim can be bundled")
+    if getattr(ref, "label", None) != chr_label:
+        raise ValueError("LD shard write spec reference_shard label must match chr")
+    if getattr(ref, "num_snp", None) != num_snp:
+        raise ValueError("LD shard write spec reference_shard num_snp must match num_snp")
+    if getattr(ref, "checksum", None) != reference_checksum:
+        raise ValueError("LD shard write spec reference_shard checksum must match reference_checksum")
 
     return {
         "chr_label": chr_label,
         "sex": sex,
         "num_snp": num_snp,
         "reference_checksum": reference_checksum,
+        "reference_shard": ref,
+        "reference_bim": reference_bim,
         "a1freq": _coerce_a1freq(spec.get("a1freq"), num_snp),
         "ld_pairs": spec.get("ld_pairs"),
         "build_metadata": dict(spec.get("build_metadata", {})),
@@ -199,6 +225,7 @@ def _write_ld_npz_shard(
     sex,
     num_snp,
     reference_checksum,
+    reference_bim,
     a1freq,
     ld_pairs,
     build_metadata=None,
@@ -217,7 +244,9 @@ def _write_ld_npz_shard(
         sex=sex,
         num_snp=num_snp,
         nnz=nnz,
+        num_monomorphic_snps=int(np.count_nonzero((a1freq == 0.0) | (a1freq == 1.0))),
         reference_checksum=reference_checksum,
+        reference_bim=reference_bim,
         build_metadata=build_metadata,
         extra_metadata=extra_metadata,
     )
@@ -337,7 +366,9 @@ def _ld_npz_metadata(
     sex,
     num_snp,
     nnz,
+    num_monomorphic_snps,
     reference_checksum,
+    reference_bim,
     build_metadata=None,
     extra_metadata=None,
 ) -> dict:
@@ -354,7 +385,9 @@ def _ld_npz_metadata(
         "matrix": "symmetric",
         "diagonal": "explicit_unit",
         "value": "r",
+        "num_monomorphic_snps": int(num_monomorphic_snps),
         "reference_checksum": reference_checksum,
+        "reference_bim": reference_bim,
     }
     build = dict(LD_BUILD_METADATA_DEFAULTS)
     if build_metadata:
@@ -362,6 +395,17 @@ def _ld_npz_metadata(
     meta.update(build)
     if extra_metadata:
         meta.update(extra_metadata)
+    meta.update(
+        {
+            "chr": chr_label,
+            "sex": sex,
+            "num_snp": int(num_snp),
+            "nnz": int(nnz),
+            "num_monomorphic_snps": int(num_monomorphic_snps),
+            "reference_checksum": reference_checksum,
+            "reference_bim": reference_bim,
+        }
+    )
     validate_shard_metadata(meta, Path("<generated>"), expected_format=NPZ_FORMAT)
     return meta
 
@@ -372,6 +416,37 @@ def _default_ld_shard_filename(chr_label: str, sex, suffix: str) -> str:
     return f"ld_chr{chr_label}{suffix}"
 
 
+def _ensure_reference_bim(path: Path, reference_shard, meta: dict) -> None:
+    if path.exists():
+        _validate_existing_reference_bim(path, meta)
+        return
+    _write_reference_bim_from_shard(path, reference_shard)
+    _validate_existing_reference_bim(path, meta)
+
+
+def _write_reference_bim_from_shard(path: Path, reference_shard) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8", newline="") as f:
+        for chr_label, snp, bp, a1, a2 in zip(
+            reference_shard.chr,
+            reference_shard.snp,
+            reference_shard.bp,
+            reference_shard.a1,
+            reference_shard.a2,
+        ):
+            f.write(f"{chr_label}\t{snp}\t0\t{int(bp)}\t{a1}\t{a2}\n")
+
+
+def _validate_existing_reference_bim(path: Path, meta: dict) -> None:
+    validate_bundled_reference_bim(path, meta, target="LD shard")
+
+
+def _require_reference_bim(root: Path, meta: dict) -> str:
+    reference_bim = meta["reference_bim"]
+    _validate_existing_reference_bim(root / reference_bim, meta)
+    return reference_bim
+
+
 def _write_deterministic_npz(path: Path, arrays: dict[str, np.ndarray]) -> None:
     with zipfile.ZipFile(path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
         for name, array in arrays.items():

{statgen-0.2.0 → statgen-0.2.1}/statgen/annotations.py

@@ -1,5 +1,4 @@
 import json
-import io
 from pathlib import Path
 
 import numpy as np
@@ -12,27 +11,6 @@ from ._utils import validate_requested_shards
 _CACHE_SCHEMA = "annotations_cache/0.1"
 
 
-def _is_ignored_bed_line(line: str) -> bool:
-    return (
-        line == ""
-        or line.startswith("#")
-        or line.startswith("track ")
-        or line.startswith("browser ")
-    )
-
-
-def _read_bed_payload(path: Path) -> str:
-    kept = []
-    with open(path, "r", encoding="utf-8") as f:
-        for raw in f:
-            line = raw.rstrip("\r\n")
-            if _is_ignored_bed_line(line):
-                continue
-            kept.append(line)
-    if not kept:
-        raise ValueError(f"{path}: BED file is empty")
-    return "\n".join(kept) + "\n"
-
 
 def _as_sparse_binary(mat) -> sparse.csr_matrix:
     if sparse.issparse(mat):
@@ -94,14 +72,16 @@ def _annotation_name_from_path(path: Path) -> str:
 
 
 def _parse_bed(path: Path) -> dict[str, np.ndarray]:
-    payload = _read_bed_payload(path)
+    # Lines beginning with '#' and blank lines are skipped natively.
+    # 'track'/'browser' metadata lines are not supported; prefix with '#' if present.
     try:
         df = pd.read_csv(
-            io.StringIO(payload),
-            sep=r"\s+",
+            path,
+            sep="\t",
             header=None,
             dtype=str,
-            engine="python",
+            comment="#",
+            skip_blank_lines=True,
             keep_default_na=False,
             na_filter=False,
         )
@@ -113,7 +93,7 @@ def _parse_bed(path: Path) -> dict[str, np.ndarray]:
     if df.shape[0] == 0:
         raise ValueError(f"{path}: BED file is empty")
     if df.shape[1] < 3:
-        raise ValueError(f"{path}: BED must have at least 3 whitespace-separated columns")
+        raise ValueError(f"{path}: BED must have at least 3 tab-separated columns")
 
     chr_col = df.iloc[:, 0]
     start_raw = df.iloc[:, 1]

{statgen-0.2.0 → statgen-0.2.1}/statgen/ld.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+import warnings
 
 import numpy as np
 from scipy import sparse
@@ -15,7 +16,16 @@ from ._utils import validate_requested_shards
 
 
 class LDShard:
-    def __init__(self, chr_label, sex, num_snp, ld_r, a1freq, reference_checksum):
+    def __init__(
+        self,
+        chr_label,
+        sex,
+        num_snp,
+        ld_r,
+        a1freq,
+        reference_checksum,
+        num_monomorphic_snps=0,
+    ):
         self._chr = str(chr_label)
         self._sex = sex
         self._num_snp = int(num_snp)
@@ -23,6 +33,7 @@ class LDShard:
         self._ld_r2 = _build_ld_r2(self._ld_r)
         self._a1freq = np.asarray(a1freq, dtype=np.float32).reshape(-1)
         self._reference_checksum = str(reference_checksum)
+        self._num_monomorphic_snps = int(num_monomorphic_snps)
 
     @property
     def chr(self) -> str:
@@ -56,11 +67,16 @@ class LDShard:
     def checksum(self) -> str:
         return self._reference_checksum
 
+    @property
+    def num_monomorphic_snps(self) -> int:
+        return self._num_monomorphic_snps
+
 
 class LDPanel:
-    def __init__(self, shard_groups, default_chrX_sex="female"):
+    def __init__(self, shard_groups, default_chrX_sex="female", reference=None):
         self._shard_groups = [list(g) for g in shard_groups]
         self._default_chrX_sex = validate_chrx_sex(default_chrX_sex, "default_chrX_sex")
+        self._reference = reference
         self._shard_offsets = []
         pos = 0
         for group in self._shard_groups:
@@ -77,6 +93,8 @@ class LDPanel:
             )
             pos += first.num_snp
         self._num_snp = pos
+        if self._reference is not None:
+            self._validate_reference_shape()
         self._validate_default_chrX_sex()
 
     @property
@@ -108,6 +126,10 @@ class LDPanel:
     def default_chrX_sex(self) -> str:
         return self._default_chrX_sex
 
+    @property
+    def reference(self):
+        return self._reference
+
     def a1freq(self, chrX_sex=None) -> np.ndarray:
         shards = [shard for shard, _start, _stop in self.iter_shards_with_offsets(chrX_sex)]
         if not shards:
@@ -118,7 +140,8 @@ class LDPanel:
         available = [group[0].label for group in self._shard_groups]
         selected = validate_requested_shards(shards, available, "LDPanel.select_shards")
         by_label = {group[0].label: group for group in self._shard_groups}
-        return LDPanel([by_label[label] for label in selected], self._default_chrX_sex)
+        reference = None if self._reference is None else self._reference.select_shards(selected)
+        return LDPanel([by_label[label] for label in selected], self._default_chrX_sex, reference)
 
     def multiply_r2(self, M, chrX_sex=None):
         if sparse.issparse(M):
@@ -156,6 +179,17 @@ class LDPanel:
                         f"got {self._default_chrX_sex!r}, present {sorted(present)!r}"
                     )
 
+    def _validate_reference_shape(self) -> None:
+        ref_shards = list(self._reference.shards)
+        if len(ref_shards) != len(self._shard_groups):
+            raise ValueError("LDPanel reference shard count must match LD shard groups")
+        for ref_shard, group in zip(ref_shards, self._shard_groups):
+            first = group[0]
+            if ref_shard.label != first.label:
+                raise ValueError("LDPanel reference shard labels must match LD shard groups")
+            if ref_shard.num_snp != first.num_snp:
+                raise ValueError("LDPanel reference shard sizes must match LD shard groups")
+
     def _multiply_r2_dense(self, M, chrX_sex=None):
         arr = np.asarray(M)
         if arr.ndim == 1:
@@ -213,26 +247,32 @@ class LDPanel:
         return sparse.vstack(parts, format=M.getformat()).astype(out_dtype)
 
 
-def load_ld(path, reference, default_chrX_sex=None) -> LDPanel:
+def load_ld(path, reference=None, shards=None, default_chrX_sex=None) -> LDPanel:
     default_chrX_sex = validate_chrx_sex(
         "female" if default_chrX_sex is None else default_chrX_sex,
         "default_chrX_sex",
     )
     path = Path(path)
+    if not path.is_dir():
+        raise ValueError("load_ld: path must identify a panel root directory")
+
+    manifest = read_manifest(path / "ld_manifest.json", expected_runtime=PY_RUNTIME_FORMAT)
+    if reference is None:
+        reference = _load_bundled_reference(path, manifest, shards)
+    elif shards is not None:
+        reference = reference.select_shards(shards)
+
     ref_shards = list(reference.shards)
     if not ref_shards:
         raise ValueError("load_ld: reference must contain at least one shard")
 
-    if path.is_dir():
-        manifest = read_manifest(path / "ld_manifest.json", expected_runtime=PY_RUNTIME_FORMAT)
-        groups = _load_panel_root(path, manifest, ref_shards)
-    else:
-        groups = _load_single_shard(path, ref_shards)
-
-    return LDPanel(groups, default_chrX_sex=default_chrX_sex)
+    groups = _load_panel_root(path, manifest, ref_shards)
+    return LDPanel(groups, default_chrX_sex=default_chrX_sex, reference=reference)
 
 
 def validate_ld_distribution(path, check_payload_structure=False) -> dict:
+    if not Path(path).is_dir():
+        raise ValueError("validate_ld_distribution: path must identify a panel root directory")
     return validate_npz_distribution(path, check_payload_structure=check_payload_structure)
 
 
@@ -311,6 +351,12 @@ def _write_ld_npz_distribution(*args, **kwargs):
     return write_ld_npz_distribution(*args, **kwargs)
 
 
+def _load_bundled_reference(root: Path, manifest: dict, shards):
+    from ._ld_reference import load_bundled_reference_panel
+
+    return load_bundled_reference_panel(root, manifest, shards, where="load_ld")
+
+
 def _load_panel_root(root: Path, manifest: dict, ref_shards: list) -> list[list[LDShard]]:
     entries = list(manifest["shards"])
     groups = []
@@ -346,22 +392,6 @@ def _load_panel_root(root: Path, manifest: dict, ref_shards: list) -> list[list[
     return groups
 
 
-def _load_single_shard(path: Path, ref_shards: list) -> list[list[LDShard]]:
-    shard, _meta = _load_npz_shard(path)
-    if len(ref_shards) != 1:
-        raise ValueError(
-            "single-shard LD loads require a single-shard reference; "
-            f"reference has {len(ref_shards)} shards"
-        )
-    if ref_shards[0].label != shard.chr:
-        raise ValueError(
-            "single-shard LD chromosome does not match single-shard reference: "
-            f"LD chr {shard.chr!r}, reference chr {ref_shards[0].label!r}"
-        )
-    _validate_reference_compatibility(shard, ref_shards[0], path)
-    return [[shard]]
-
-
 def _load_npz_shard(path: Path) -> tuple[LDShard, dict]:
     require_file(path)
     ld_r, a1freq, meta = read_npz_shard(path, check_payload_structure=False)
@@ -372,7 +402,15 @@ def _load_npz_shard(path: Path) -> tuple[LDShard, dict]:
         ld_r,
         a1freq,
         meta["reference_checksum"],
+        int(meta["num_monomorphic_snps"]),
     )
+    if shard.num_monomorphic_snps:
+        warnings.warn(
+            f"{path}: LD shard contains {shard.num_monomorphic_snps} monomorphic SNPs; "
+            "LD involving those SNPs is undefined and represented by omitted off-diagonal entries",
+            RuntimeWarning,
+            stacklevel=2,
+        )
     return shard, meta
 
 

{statgen-0.2.0 → statgen-0.2.1}/statgen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statgen
-Version: 0.2.0
+Version: 0.2.1
 Summary: Statistical genetics data objects and loaders for Python and MATLAB/Octave.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{statgen-0.2.0 → statgen-0.2.1}/statgen.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 statgen/__init__.py
 statgen/_ld_npz.py
+statgen/_ld_reference.py
 statgen/_ld_schema.py
 statgen/_ld_writer.py
 statgen/_utils.py

statgen-0.2.0/statgen/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.0"