svphaser 2.0.4__py3-none-any.whl → 2.1.0__py3-none-any.whl

svphaser/phasing/algorithms.py

@@ -3,6 +3,12 @@
 1) Exact binomial tail for small depth (N ≤ 200).
 2) Continuity-corrected normal approximation for deep coverage (N > 200).
 3) Phred GQ capped at 99.
+
+Step B semantics:
+- `min_support` is interpreted as a *total ALT-support* threshold (n1+n2).
+- Near-ties are treated as *ambiguous* (./.), not homozygous ALT.
+  Homozygous ALT (1|1) should come from the caller's genotype (input VCF),
+  not from a balance test.
 """
 
 from __future__ import annotations
@@ -45,27 +51,39 @@ def classify_haplotype(
     n2: int,
     *,
     min_support: int = 10,
-    major_delta: float = 0.70,
-    equal_delta: float = 0.25,
+    major_delta: float = 0.60,
+    equal_delta: float = 0.10,
 ) -> tuple[str, int]:
-    """Return (GT, GQ) using ratio thresholds and an overflow-safe GQ."""
-    total = n1 + n2
+    """Classify which haplotype carries the ALT allele.
+
+    Returns:
+      - GT: "1|0" (ALT on hap1) or "0|1" (ALT on hap2) or "./." (ambiguous)
+      - GQ: phred-scaled confidence based on haplotype imbalance
 
-    if n1 < min_support and n2 < min_support:
+    Notes:
+      - `min_support` is applied to total ALT-support reads.
+      - Near-ties (<= equal_delta) are treated as ambiguous (./.).
+    """
+
+    total = n1 + n2
+    if total <= 0:
         return "./.", 0
-    if total == 0:
+    if total < min_support:
         return "./.", 0
 
     gq = phasing_gq(n1, n2)
+
+    # 1) near-tie → ambiguous
+    if abs(n1 - n2) / total <= equal_delta:
+        return "./.", gq
+
+    # 2) strong majority → heterozygous phased
     r1 = n1 / total
     r2 = n2 / total
-
     if r1 >= major_delta:
-        gt = "1|0"
-    elif r2 >= major_delta:
-        gt = "0|1"
-    elif abs(n1 - n2) / total <= equal_delta:
-        gt = "1|1"
-    else:
-        gt = "./."
-    return gt, gq
+        return "1|0", gq
+    if r2 >= major_delta:
+        return "0|1", gq
+
+    # 3) otherwise ambiguous
+    return "./.", gq

svphaser/phasing/io.py

@@ -1,30 +1,56 @@
-"""
-svphaser.phasing.io
+"""svphaser.phasing.io
 ===================
 High-level “engine” – orchestrates per-chromosome workers, merges results,
-applies the global depth filter, then writes CSV + VCF.
+applies the global support filter, then writes CSV + VCF.
+
+Step B update (biological correctness):
+- `min_support` is interpreted as a *total ALT-support* threshold (n1+n2).
+  The filter drops an SV only if (n1+n2) < min_support.
 
-Workers receive only simple (pickle-safe) arguments; each worker opens its
-own BAM/VCF to avoid sharing handles between processes.
+Step A fixes retained:
+- collision-resistant VCF record matching using (CHROM, POS, ID, END, ALT)
+- correct INFO composition (no duplicated keys; proper FLAG handling)
+- typing fixes to satisfy Pylance/Mypy
 """
 
 from __future__ import annotations
 
 import logging
+import math
 import multiprocessing as mp
 from pathlib import Path
+from typing import Any, TypedDict
 
 import pandas as pd
 from cyvcf2 import Reader
 
 from ._workers import _phase_chrom_worker
-from .types import GQBin, WorkerOpts
+from .types import GQBin, SVKey, SVKeyLegacy, WorkerOpts
 
 __all__ = ["phase_vcf"]
 
 logger = logging.getLogger(__name__)
 
 
+class VcfRec(TypedDict):
+    REF: str
+    ALT: str
+    QUAL: object
+    FILTER: str
+    INFO: dict[str, Any]
+
+
+def _is_missing_scalar(x: Any) -> bool:
+    """True for None / NaN / empty string."""
+    if x is None:
+        return True
+    if isinstance(x, float) and math.isnan(x):
+        return True
+    if isinstance(x, str) and x.strip() == "":
+        return True
+    return False
+
+
 def phase_vcf(
     sv_vcf: Path,
     bam: Path,
@@ -56,7 +82,7 @@ def phase_vcf(
                 thr_s, lbl = thr_lbl.split(":")
             except ValueError as err:
                 raise ValueError(
-                    f"Invalid gq-bin specifier: '{thr_lbl}'. " "Use '30:High,10:Moderate'."
+                    f"Invalid gq-bin specifier: '{thr_lbl}'. Use '30:High,10:Moderate'."
                 ) from err
             bins.append((int(thr_s), lbl))
         bins.sort(key=lambda x: x[0], reverse=True)
@@ -89,7 +115,6 @@ def phase_vcf(
         ctx = mp.get_context("spawn")
 
     if threads == 1:
-        # Serial path is handy for debugging
         for args in worker_args:
             df = _phase_chrom_worker(*args)
             dataframes.append(df)
@@ -102,16 +127,29 @@ def phase_vcf(
                 chrom = df.iloc[0]["chrom"] if not df.empty else "?"
                 logger.info("chr %-6s ✔ phased %5d SVs", chrom, len(df))
 
-    # 5 ─ Merge & apply *global* depth filter
+    # 5 ─ Merge & apply *global* support filter (Step B: total ALT-support)
     if dataframes:
         merged = pd.concat(dataframes, ignore_index=True)
     else:
         merged = pd.DataFrame(
-            columns=["chrom", "pos", "id", "svtype", "n1", "n2", "gt", "gq", "gq_label"]
+            columns=[
+                "chrom",
+                "pos",
+                "end",
+                "id",
+                "alt",
+                "svtype",
+                "n1",
+                "n2",
+                "gt",
+                "gq",
+                "gq_label",
+            ]
         )
 
     pre = len(merged)
-    keep = ~((merged["n1"] < min_support) & (merged["n2"] < min_support))
+    total_support = merged["n1"].astype(int) + merged["n2"].astype(int)
+    keep = total_support >= int(min_support)
 
     stem = sv_vcf.name.removesuffix(".vcf.gz").removesuffix(".vcf")
 
@@ -122,7 +160,7 @@ def phase_vcf(
 
     kept = merged.loc[keep].reset_index(drop=True)
     if dropped := pre - len(kept):
-        logger.info("Depth filter removed %d SVs", dropped)
+        logger.info("Support filter removed %d SVs", dropped)
 
     # 6 ─ Write CSV
     out_csv = out_dir / f"{stem}_phased.csv"
@@ -138,32 +176,54 @@ def phase_vcf(
 # ──────────────────────────────────────────────────────────────────────
 #  Small helpers to keep complexity down
 # ──────────────────────────────────────────────────────────────────────
+
+
 def _vcf_info_lookup(
     in_vcf: Path,
-) -> tuple[dict[tuple[str, int, str], dict[str, object]], list[str], str]:
-    """Scan input VCF once: return (lookup, raw_header_lines, sample_name)."""
+) -> tuple[dict[SVKey, VcfRec], dict[SVKeyLegacy, list[SVKey]], list[str], str]:
+    """Scan input VCF once.
+
+    Returns:
+      - full_lookup: maps (CHROM, POS, ID, END, ALT) -> record components
+      - legacy_index: maps (CHROM, POS, ID) -> list of full keys (fallback)
+      - raw_header_lines
+      - sample_name
+    """
     rdr = Reader(str(in_vcf))
     raw_header_lines = rdr.raw_header.strip().splitlines()
     sample_name = rdr.samples[0] if rdr.samples else "SAMPLE"
 
-    lookup: dict[tuple[str, int, str], dict[str, object]] = {}
+    full_lookup: dict[SVKey, VcfRec] = {}
+    legacy_index: dict[SVKeyLegacy, list[SVKey]] = {}
+
     for rec in rdr:
-        key = (rec.CHROM, rec.POS, rec.ID or ".")
-        info_dict: dict[str, object] = {}
+        chrom = rec.CHROM
+        pos = int(rec.POS)
+        vid = rec.ID or "."
+        end = int(rec.end) if getattr(rec, "end", None) is not None else int(pos)
+        alt = ",".join(rec.ALT) if rec.ALT else "<N>"
+
+        info_dict: dict[str, Any] = {}
         for k in rec.INFO:
             info_key = k[0] if isinstance(k, tuple) else k
             v = rec.INFO.get(info_key)
             if v is not None:
                 info_dict[info_key] = v
-        lookup[key] = {
+
+        fkey: SVKey = (chrom, pos, vid, end, alt)
+        lkey: SVKeyLegacy = (chrom, pos, vid)
+
+        full_lookup[fkey] = {
             "REF": rec.REF,
-            "ALT": ",".join(rec.ALT) if rec.ALT else "<N>",
+            "ALT": alt,
             "QUAL": rec.QUAL if rec.QUAL is not None else ".",
             "FILTER": rec.FILTER if rec.FILTER else "PASS",
             "INFO": info_dict,
         }
+        legacy_index.setdefault(lkey, []).append(fkey)
+
     rdr.close()
-    return lookup, raw_header_lines, sample_name
+    return full_lookup, legacy_index, raw_header_lines, sample_name
 
 
 def _write_headers(
@@ -196,25 +256,62 @@ def _write_headers(
     out.write("#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\t" + sample_name + "\n")
 
 
-def _compose_info_str(orig_info: dict[str, object], svtype: object, gq_label: object) -> str:
-    """Compose the INFO string with SVTYPE first, original keys (no duplicate), then GQBIN."""
+def _compose_info_str(orig_info: dict[str, Any], svtype: Any, gq_label: Any) -> str:
+    """Compose INFO with SVTYPE first, proper FLAG handling, then GQBIN."""
     items: list[str] = []
+
+    if svtype:
+        items.append(f"SVTYPE={svtype}")
+
     for k, v in orig_info.items():
         if k == "SVTYPE":
             continue
-        items.append(f"{k}={v}")
-        # treat boolean True as a FLAG (bare key). Keep everything else as k=v.
+        if v is None:
+            continue
+        # cyvcf2 represents INFO flags as boolean True
         if v is True:
-            items.append(k)
+            items.append(str(k))
         else:
             items.append(f"{k}={v}")
-    if svtype:
-        items.insert(0, f"SVTYPE={svtype}")
-    if gq_label is not None and pd.notnull(gq_label):
+
+    if not _is_missing_scalar(gq_label):
         items.append(f"GQBIN={gq_label}")
+
     return ";".join(items) if items else "."
 
 
+def _select_info_record(
+    full_lookup: dict[SVKey, VcfRec],
+    legacy_index: dict[SVKeyLegacy, list[SVKey]],
+    *,
+    chrom: str,
+    pos: int,
+    vid: str,
+    end: int | None,
+    alt: str | None,
+) -> VcfRec | None:
+    """Pick the best matching input VCF record for this phased row."""
+    if end is not None and alt is not None:
+        hit = full_lookup.get((chrom, pos, vid, int(end), str(alt)))
+        if hit is not None:
+            return hit
+
+    candidates = legacy_index.get((chrom, pos, vid), [])
+    if not candidates:
+        return None
+
+    if len(candidates) == 1:
+        return full_lookup[candidates[0]]
+
+    if end is not None:
+        end_matches = [k for k in candidates if k[3] == int(end)]
+        if len(end_matches) == 1:
+            return full_lookup[end_matches[0]]
+
+    # Still ambiguous: refuse to guess
+    return None
+
+
 def _write_phased_vcf(
     out_vcf: Path,
     in_vcf: Path,
@@ -223,7 +320,7 @@ def _write_phased_vcf(
     gqbin_in_header: bool,
 ) -> None:
     """Write a phased VCF: tab-delimited, compliant, with ensured GT/GQ (and GQBIN if used)."""
-    lookup, raw_header_lines, sample_name = _vcf_info_lookup(in_vcf)
+    full_lookup, legacy_index, raw_header_lines, sample_name = _vcf_info_lookup(in_vcf)
 
     with open(out_vcf, "w", newline="") as out:
         _write_headers(out, raw_header_lines, sample_name, gqbin_in_header=gqbin_in_header)
@@ -232,14 +329,26 @@ def _write_phased_vcf(
             chrom = str(getattr(row, "chrom", "."))
             pos = int(getattr(row, "pos", 0))
             vid = str(getattr(row, "id", "."))
+
+            end = getattr(row, "end", None)
+            alt = getattr(row, "alt", None)
+
             gt = str(getattr(row, "gt", "./."))
             gq = str(getattr(row, "gq", "0"))
             svtype = getattr(row, "svtype", None)
             gq_label = getattr(row, "gq_label", None)
 
-            info = lookup.get((chrom, pos, vid))
+            info = _select_info_record(
+                full_lookup,
+                legacy_index,
+                chrom=chrom,
+                pos=pos,
+                vid=vid,
+                end=int(end) if end is not None else None,
+                alt=str(alt) if alt is not None else None,
+            )
             if info is None:
-                logger.warning("Could not find VCF info for %s:%s %s", chrom, pos, vid)
+                logger.warning("Could not uniquely match VCF record for %s:%s %s", chrom, pos, vid)
                 continue
 
             info_str = _compose_info_str(info["INFO"], svtype, gq_label)

svphaser/phasing/types.py

@@ -1,7 +1,8 @@
 """svphaser.phasing.types
 ========================
-Central place for common type aliases & lightweight data classes.
-Keeping them here avoids circular imports and MyPy noise.
+Common type aliases & small data structures.
+
+We keep this module light to avoid circular imports.
 """
 
 from __future__ import annotations
@@ -9,8 +10,14 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import NamedTuple
 
-SVKey = tuple[str, int, str]  # (chrom, POS, ID) – ID is "." if empty
-GQBin = tuple[int, str]  # (threshold, label), e.g. (30, "High")
+# Legacy key (older writer used this; can collide when ID='.' or same POS repeats)
+SVKeyLegacy = tuple[str, int, str]  # (CHROM, POS, ID)
+
+# Collision-resistant key for matching phased rows back to original VCF records
+SVKey = tuple[str, int, str, int, str]  # (CHROM, POS, ID, END, ALT)
+
+# GQ bin spec: (threshold, label)
+GQBin = tuple[int, str]  # e.g. (30, "High")
 
 
 @dataclass(slots=True, frozen=True)
@@ -20,7 +27,7 @@ class WorkerOpts:
     min_support: int
     major_delta: float
     equal_delta: float
-    gq_bins: list[GQBin]  # already parsed by cli → phase_vcf
+    gq_bins: list[GQBin]
 
 
 class CallTuple(NamedTuple):

svphaser-2.1.0.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: svphaser
+Version: 2.1.0
+Summary: Structural-variant phasing from HP-tagged long-read BAMs
+Project-URL: Homepage, https://github.com/SFGLab/SvPhaser
+Project-URL: Issues, https://github.com/SFGLab/SvPhaser/issues
+Project-URL: Source, https://github.com/SFGLab/SvPhaser
+Author-email: SvPhaser Team <you@lab.org>
+License: MIT
+License-File: LICENSE
+Keywords: BAM,ONT,VCF,genomics,long-reads,phasing,structural-variants
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.9
+Requires-Dist: cyvcf2>=0.30
+Requires-Dist: pandas>=2.1
+Requires-Dist: pysam>=0.23
+Requires-Dist: typer>=0.14
+Provides-Extra: bench
+Requires-Dist: py-spy>=0.3; extra == 'bench'
+Requires-Dist: pytest-benchmark>=4.0; extra == 'bench'
+Provides-Extra: dev
+Requires-Dist: black>=24.3; extra == 'dev'
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: hypothesis>=6.90; extra == 'dev'
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pandas-stubs>=2.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.6; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest-xdist>=3.5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Requires-Dist: tox>=4.10; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: plots
+Requires-Dist: matplotlib>=3.7; extra == 'plots'
+Description-Content-Type: text/markdown
+
+# SvPhaser
+
+> **Haplotype-aware structural-variant (SV) genotyper for long-read data**
+
+[![PyPI version](https://img.shields.io/pypi/v/svphaser.svg?logo=pypi)](https://pypi.org/project/svphaser/)
+[![Python](https://img.shields.io/pypi/pyversions/svphaser.svg)](https://pypi.org/project/svphaser/)
+[![License](https://img.shields.io/github/license/SFGLab/SvPhaser.svg)](LICENSE)
+
+---
+
+**SvPhaser** phases **pre-called structural variants (SVs)** using **HP-tagged** long-read alignments (PacBio HiFi, ONT Q20+, …).
+
+Think of it as *WhatsHap* for insertions/deletions/duplications:
+- **we do not discover SVs**
+- **we assign haplotype genotypes** (`0|1`, `1|0`, `1|1`, or `./.`)
+- and compute a **Genotype Quality (GQ)** score
+
+All in a single, embarrassingly-parallel pass over the genome.
+
+## Highlights
+
+- **Fast per-chromosome multiprocessing** (scale-out on multi-core CPUs).
+- **Deterministic Δ-based decision logic** (no MCMC / HMM).
+- **CLI + Python API**.
+- **Non-destructive VCF augmentation**: injects phasing fields while preserving the original header and records.
+- **Configurable confidence bins** + optional plots.
+
+## Installation
+
+### From PyPI (recommended)
+
+```bash
+# Requires Python >= 3.9
+pip install svphaser
+````
+
+Optional extras (if you use them):
+
+```bash
+pip install "svphaser[plots]"
+pip install "svphaser[bench]"
+pip install "svphaser[dev]"
+```
+
+### From source
+
+```bash
+git clone https://github.com/SFGLab/SvPhaser.git
+cd SvPhaser
+pip install -e .
+```
+
+## Inputs & requirements
+
+SvPhaser expects:
+
+1. **Unphased SV VCF** (`.vcf` / `.vcf.gz`)
+
+   * SVs should already be called by your preferred SV caller.
+
+2. **HP-tagged BAM** (long-read alignments)
+
+   * Reads must contain haplotype tags (e.g., `HP`) produced by an upstream phasing pipeline.
+
+If your BAM is not HP-tagged, SvPhaser cannot assign haplotypes.
+
+## Quick start (CLI)
+
+```bash
+svphaser phase \
+    sample_unphased.vcf.gz \
+    sample.sorted_phased.bam \
+    --out-dir results/ \
+    --min-support 10 \
+    --major-delta 0.70 \
+    --equal-delta 0.25 \
+    --gq-bins "30:High,10:Moderate" \
+    --threads 32
+```
+
+### Outputs
+
+Inside `results/`:
+
+* `*_phased.vcf` — your original VCF with additional INFO fields:
+
+  * `HP_GT` — phased genotype
+  * `HP_GQ` — genotype quality score
+  * `HP_GQBIN` — confidence bin label (based on your `--gq-bins`)
+* `*_phased.csv` — tidy table for plotting / downstream analysis
+
+For algorithmic details, see: **`docs/methodology.md`**.
+
+## Python API
+
+```python
+from pathlib import Path
+from svphaser.phasing.io import phase_vcf
+
+phase_vcf(
+    Path("sample.vcf.gz"),
+    Path("sample.bam"),
+    out_dir=Path("results"),
+    min_support=10,
+    major_delta=0.70,
+    equal_delta=0.25,
+    gq_bins="30:High,10:Moderate",
+    threads=8,
+)
+```
+
+The phased table can also be loaded from the generated CSV for custom analytics.
+
+## Repository structure (high level)
+
+```
+SvPhaser/
+├─ src/svphaser/         # importable package
+├─ tests/                # test suite + small fixtures (if present)
+├─ docs/                 # methodology + notes
+├─ notebooks/            # experiments / analysis (if present)
+├─ figures/              # plots & diagrams (if present)
+├─ pyproject.toml
+└─ CHANGELOG.md
+```
+
+## Development
+
+```bash
+git clone https://github.com/SFGLab/SvPhaser.git
+cd SvPhaser
+
+python -m venv .venv
+source .venv/bin/activate
+
+pip install -e ".[dev]"
+pytest -q
+mypy src/svphaser
+```
+
+See `CONTRIBUTING.md` for contribution guidelines.
+
+## Citing SvPhaser
+
+If SvPhaser contributed to your research, please cite:
+
+```bibtex
+@software{svphaser2025,
+  author  = {Pranjul Mishra and Sachin Gadakh},
+  title   = {SvPhaser: Haplotype-aware structural-variant genotyping from HP-tagged long-read BAMs},
+  version = {2.0.6},
+  year    = {2025},
+  month   = nov,
+  url     = {https://github.com/SFGLab/SvPhaser},
+  note    = {PyPI: https://pypi.org/project/svphaser/}
+}
+```
+
+(If you need maximum rigor for a paper, cite a specific git commit hash too.)
+
+## License
+
+SvPhaser is released under the **MIT License** — see [LICENSE](LICENSE).
+
+## Contact
+
+Developed by **Team 5 (BioAI Hackathon)**.
+
+* Pranjul Mishra — [pranjul.mishra@proton.me](mailto:pranjul.mishra@proton.me)
+* Sachin Gadakh — [s.gadakh@cent.uw.edu.pl](mailto:s.gadakh@cent.uw.edu.pl)
+
+Issues and feature requests: please open a GitHub issue.
+
+```
+
+### Two hard notes (don’t ignore)
+- If you **don’t actually have CI set up**, don’t show a CI badge. A fake badge is worse than no badge.
+- If your repo layout doesn’t include `notebooks/figures/tests fixtures`, either adjust that tree block or remove it to avoid “template smell.”
+
+If you want, paste your **current `.github/workflows` filenames** (or tell me if you have none) and I’ll add the *correct* CI badge line too—without guessing.
+::contentReference[oaicite:1]{index=1}
+```
+
+[1]: https://pypi.org/project/svphaser/ "svphaser · PyPI"

svphaser-2.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+svphaser/__init__.py,sha256=h4eLAi05OsAqs9Evii526TVr2CUo3dW-iHO-RjXtv_E,2599
+svphaser/__main__.py,sha256=lWe9boXc4JIpJEknv9dXqSsjS1Glk_FnYV9eBzUEzA0,86
+svphaser/_version.py,sha256=6G8yJbldQAMT0M9ZiFAqGo5OVqUMxGB1aeWeKmrwNIE,704
+svphaser/cli.py,sha256=w8LwEYBWwjJWuLA1AE-XuyMVCzgjS2DjBwCBJHjq0EA,4509
+svphaser/logging.py,sha256=yw7Z8az-sZL-x4qhvPmu7aGVLbhSOYiSdrNqCO8bVtw,841
+svphaser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+svphaser/phasing/__init__.py,sha256=RcXg2EGc7Dyuq8wDP-bJmtVNKs8f3YqByjTel0mMujM,464
+svphaser/phasing/_workers.py,sha256=8RGBuT5ZMxGpnFu18KqJKJmic7gFRAAGI_HtcClle84,12375
+svphaser/phasing/algorithms.py,sha256=Z7ARpvIXXRtu87qxnumNQBy9haWkO_GGJhTPKYG1TDg,2374
+svphaser/phasing/io.py,sha256=wEV8ZsNpCBzwq-bLM0J1alVTARtYWGH7Qhe5PVXkohg,11676
+svphaser/phasing/types.py,sha256=fux_thtaqT9U8DxVreyyz25g12URdm6fUDej2u3O0J0,981
+svphaser-2.1.0.dist-info/METADATA,sha256=TbiBzv9FUANVWzPKCEq6YJcD4Xlp-hLqhtE5LdsKsd8,6847
+svphaser-2.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+svphaser-2.1.0.dist-info/entry_points.txt,sha256=YFeRJLvcvTc4dazgyVOg3HJ4fNrvBrVDaPX6ULapqeU,46
+svphaser-2.1.0.dist-info/licenses/LICENSE,sha256=qsY5iOcewwIwvhQbj7naSP6tpJAc05Mv0DfhrouPoBU,1102
+svphaser-2.1.0.dist-info/RECORD,,

{svphaser-2.0.4.dist-info → svphaser-2.1.0.dist-info}/WHEEL

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