graphpop-cli 0.1.0__py3-none-any.whl

graphpop_cli/commands/sfs.py

@@ -0,0 +1,38 @@
+"""graphpop sfs — site frequency spectrum."""
+import click
+from ..cli import pass_ctx
+from ..config import build_options_map, build_cypher
+from ..formatters import format_output
+
+
+@click.command()
+@click.argument("chr")
+@click.argument("start", type=int)
+@click.argument("end", type=int)
+@click.argument("population")
+@click.option("--unfolded", is_flag=True, default=False,
+              help="Compute unfolded SFS (requires ancestral allele)")
+@click.option("-o", "--output", "output_path", help="Output file (default: stdout)")
+@click.option("--format", "fmt", default="tsv", type=click.Choice(["tsv", "csv", "json"]))
+@click.option("--consequence", help="Filter by VEP consequence type")
+@click.option("--pathway", help="Filter by pathway name")
+@click.option("--gene", help="Filter by gene name")
+@click.option("--min-af", type=float, help="Minimum allele frequency")
+@click.option("--max-af", type=float, help="Maximum allele frequency")
+@pass_ctx
+def sfs(ctx, chr, start, end, population, unfolded, output_path, fmt,
+         consequence, pathway, gene, min_af, max_af):
+    """Compute the site frequency spectrum."""
+    opts = build_options_map(consequence=consequence, pathway=pathway, gene=gene,
+                             min_af=min_af, max_af=max_af)
+    cypher = build_cypher(
+        "graphpop.sfs",
+        [f"'{chr}'", str(start), str(end), f"'{population}'",
+         "true" if unfolded else "false"],
+        options=opts if opts else None,
+        yield_cols=["sfs", "n_variants", "max_ac", "n_polarized"],
+    )
+    records = ctx.run(cypher)
+    format_output(records, output_path, fmt, "sfs",
+                  {"chr": chr, "start": start, "end": end, "pop": population,
+                   "unfolded": unfolded})

graphpop_cli/commands/validate.py

@@ -0,0 +1,167 @@
+"""graphpop validate — check graph database integrity and completeness."""
+from __future__ import annotations
+
+import click
+
+from ..cli import pass_ctx
+
+
+@click.command()
+@click.option("--fix", is_flag=True, help="Attempt to fix issues (create missing indexes)")
+@pass_ctx
+def validate(ctx, fix):
+    """Validate the graph database structure and completeness.
+
+    Checks that required node labels, indexes, and GraphPop procedures
+    are present. Reports any issues found.
+
+    \b
+    Checks performed:
+      - Required node labels (Variant, Sample, Population, Chromosome)
+      - Optional node labels (Gene, Pathway, GOTerm, GenomicWindow)
+      - Required indexes (Variant.chr+pos, Population.populationId)
+      - GraphPop procedures installed
+      - Variant node properties (pop_ids, ac, an, af, gt_packed)
+      - Sample-Population relationships
+    """
+    issues = []
+    ok = []
+
+    click.echo(f"Validating database: {ctx.database}\n")
+
+    # Check node labels
+    click.echo("Node labels:")
+    try:
+        records = ctx.run(
+            "CALL db.labels() YIELD label "
+            "CALL { WITH label MATCH (n) WHERE label IN labels(n) "
+            "RETURN count(n) AS cnt } RETURN label, cnt ORDER BY cnt DESC"
+        )
+        label_counts = {r["label"]: r["cnt"] for r in records}
+    except Exception as e:
+        click.echo(f"  Error: Cannot query database: {e}", err=True)
+        raise SystemExit(1)
+
+    required_labels = ["Variant", "Sample", "Population", "Chromosome"]
+    optional_labels = ["Gene", "Pathway", "GOTerm", "GenomicWindow"]
+
+    for label in required_labels:
+        count = label_counts.get(label, 0)
+        if count > 0:
+            ok.append(f"{label}: {count:,}")
+            click.echo(f"  [OK]   {label}: {count:,}")
+        else:
+            issues.append(f"Required label '{label}' missing or empty")
+            click.echo(f"  [FAIL] {label}: MISSING")
+
+    for label in optional_labels:
+        count = label_counts.get(label, 0)
+        if count > 0:
+            click.echo(f"  [OK]   {label}: {count:,}")
+        else:
+            click.echo(f"  [--]   {label}: not present (optional)")
+
+    # Check indexes
+    click.echo("\nIndexes:")
+    try:
+        records = ctx.run(
+            "SHOW INDEXES YIELD name, labelsOrTypes, properties, state "
+            "RETURN name, labelsOrTypes, properties, state"
+        )
+        indexes = {
+            (tuple(r["labelsOrTypes"]), tuple(r["properties"])): r["state"]
+            for r in records
+        }
+    except Exception:
+        indexes = {}
+
+    required_indexes = [
+        (("Variant",), ("chr", "pos")),
+        (("Population",), ("populationId",)),
+        (("Sample",), ("sampleId",)),
+    ]
+
+    for labels, props in required_indexes:
+        state = indexes.get((labels, props), None)
+        if state == "ONLINE":
+            click.echo(f"  [OK]   {labels[0]}({', '.join(props)})")
+        elif state:
+            click.echo(f"  [WARN] {labels[0]}({', '.join(props)}): {state}")
+        else:
+            msg = f"Index on {labels[0]}({', '.join(props)}) missing"
+            issues.append(msg)
+            click.echo(f"  [FAIL] {msg}")
+            if fix:
+                idx_name = f"idx_{labels[0].lower()}_{'_'.join(props)}"
+                cypher = (
+                    f"CREATE INDEX {idx_name} IF NOT EXISTS "
+                    f"FOR (n:{labels[0]}) ON ({', '.join(f'n.{p}' for p in props)})"
+                )
+                try:
+                    ctx.run(cypher)
+                    click.echo(f"         Fixed: created index {idx_name}")
+                except Exception as e:
+                    click.echo(f"         Fix failed: {e}", err=True)
+
+    # Check procedures
+    click.echo("\nGraphPop procedures:")
+    try:
+        records = ctx.run(
+            "SHOW PROCEDURES YIELD name WHERE name STARTS WITH 'graphpop' "
+            "RETURN name ORDER BY name"
+        )
+        proc_names = [r["name"] for r in records]
+    except Exception:
+        proc_names = []
+
+    expected_procs = [
+        "graphpop.diversity", "graphpop.divergence", "graphpop.sfs",
+        "graphpop.joint_sfs", "graphpop.genome_scan", "graphpop.pop_summary",
+        "graphpop.ld", "graphpop.ihs", "graphpop.xpehh",
+        "graphpop.nsl", "graphpop.roh", "graphpop.garud_h",
+    ]
+
+    for proc in expected_procs:
+        if proc in proc_names:
+            click.echo(f"  [OK]   {proc}")
+        else:
+            issues.append(f"Procedure '{proc}' not installed")
+            click.echo(f"  [FAIL] {proc}: NOT INSTALLED")
+
+    # Check Variant properties
+    click.echo("\nVariant node properties:")
+    try:
+        rec = ctx.run(
+            "MATCH (v:Variant) WITH v LIMIT 1 "
+            "RETURN keys(v) AS props"
+        )
+        if rec:
+            props = set(rec[0]["props"])
+            required_props = ["chr", "pos", "ref", "alt", "pop_ids", "ac", "an", "af"]
+            optional_props = ["gt_packed", "phase_packed", "ancestral_allele", "is_polarized"]
+
+            for p in required_props:
+                if p in props:
+                    click.echo(f"  [OK]   {p}")
+                else:
+                    issues.append(f"Variant property '{p}' missing")
+                    click.echo(f"  [FAIL] {p}: MISSING")
+
+            for p in optional_props:
+                if p in props:
+                    click.echo(f"  [OK]   {p}")
+                else:
+                    click.echo(f"  [--]   {p}: not present (optional)")
+    except Exception as e:
+        click.echo(f"  Error checking properties: {e}", err=True)
+
+    # Summary
+    click.echo(f"\n{'='*40}")
+    if issues:
+        click.echo(f"VALIDATION: {len(issues)} issue(s) found")
+        for issue in issues:
+            click.echo(f"  - {issue}")
+        if not fix:
+            click.echo("\nRun with --fix to attempt automatic fixes.")
+    else:
+        click.echo("VALIDATION: All checks passed")

graphpop_cli/commands/xpehh.py

@@ -0,0 +1,31 @@
+"""graphpop xpehh — cross-population extended haplotype homozygosity."""
+import click
+from ..cli import pass_ctx
+from ..config import build_options_map, build_cypher
+from ..formatters import format_output
+
+
+@click.command()
+@click.argument("chr")
+@click.argument("pop1")
+@click.argument("pop2")
+@click.option("--min-af", type=float, help="Minimum allele frequency filter")
+@click.option("--persist", is_flag=True, default=False,
+              help="Write XP-EHH scores to Variant nodes")
+@click.option("-o", "--output", "output_path", help="Output file (default: stdout)")
+@click.option("--format", "fmt", default="tsv", type=click.Choice(["tsv", "csv", "json"]))
+@pass_ctx
+def xpehh(ctx, chr, pop1, pop2, min_af, persist, output_path, fmt):
+    """Compute cross-population extended haplotype homozygosity (XP-EHH)."""
+    opts = build_options_map(min_af=min_af, persist=persist)
+    cypher = build_cypher(
+        "graphpop.xpehh",
+        [f"'{chr}'", f"'{pop1}'", f"'{pop2}'"],
+        options=opts if opts else None,
+        yield_cols=["variantId", "pos", "af_pop1", "af_pop2",
+                     "xpehh_unstd", "xpehh"],
+    )
+    records = ctx.run(cypher)
+    format_output(records, output_path, fmt, "xpehh",
+                  {"chr": chr, "pop1": pop1, "pop2": pop2,
+                   "min_af": min_af, "persist": persist})

graphpop_cli/config.py

@@ -0,0 +1,57 @@
+"""Shared options and Cypher builders for GraphPop CLI."""
+from __future__ import annotations
+
+
+def build_options_map(consequence: str | None = None,
+                      pathway: str | None = None,
+                      gene: str | None = None,
+                      min_af: float | None = None,
+                      max_af: float | None = None,
+                      variant_type: str | None = None,
+                      **extra) -> dict:
+    """Build the options map passed to GraphPop procedures."""
+    opts = {}
+    if consequence:
+        opts["consequence"] = consequence
+    if pathway:
+        opts["pathway"] = pathway
+    if gene:
+        opts["gene"] = gene
+    if min_af is not None:
+        opts["min_af"] = min_af
+    if max_af is not None:
+        opts["max_af"] = max_af
+    if variant_type:
+        opts["variant_type"] = variant_type
+    opts.update({k: v for k, v in extra.items() if v is not None})
+    return opts
+
+
+def build_cypher(procedure: str, positional: list[str],
+                 options: dict | None = None,
+                 yield_cols: list[str] | None = None) -> str:
+    """Build a CALL ... YIELD Cypher statement."""
+    args = ", ".join(positional)
+    if options:
+        opts_str = ", ".join(
+            f"{k}: {_cypher_literal(v)}" for k, v in options.items()
+        )
+        args += f", {{{opts_str}}}"
+    cypher = f"CALL {procedure}({args})"
+    if yield_cols:
+        cypher += " YIELD " + ", ".join(yield_cols)
+    return cypher
+
+
+def _cypher_literal(v) -> str:
+    """Convert Python value to Cypher literal."""
+    if isinstance(v, str):
+        return f"'{v}'"
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, (int, float)):
+        return str(v)
+    if isinstance(v, list):
+        inner = ", ".join(_cypher_literal(x) for x in v)
+        return f"[{inner}]"
+    return f"'{v}'"

graphpop_cli/connection.py

@@ -0,0 +1,52 @@
+"""Neo4j connection management for GraphPop CLI."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import yaml
+from neo4j import GraphDatabase
+
+
+_DEFAULT_CONFIG_PATH = Path.home() / ".graphpop" / "config.yaml"
+
+
+def load_config(config_path: Path | None = None) -> dict:
+    """Load connection config from file, env vars, or defaults."""
+    cfg = {
+        "uri": "bolt://localhost:7687",
+        "user": "neo4j",
+        "password": "neo4j",
+        "database": "neo4j",
+    }
+
+    # Config file
+    path = config_path or _DEFAULT_CONFIG_PATH
+    if path.exists():
+        with open(path) as f:
+            file_cfg = yaml.safe_load(f) or {}
+        cfg.update({k: v for k, v in file_cfg.items() if v is not None})
+
+    # Env vars override
+    if v := os.environ.get("GRAPHPOP_URI"):
+        cfg["uri"] = v
+    if v := os.environ.get("GRAPHPOP_USER"):
+        cfg["user"] = v
+    if v := os.environ.get("GRAPHPOP_PASSWORD"):
+        cfg["password"] = v
+    if v := os.environ.get("GRAPHPOP_DATABASE"):
+        cfg["database"] = v
+
+    return cfg
+
+
+def get_driver(cfg: dict):
+    """Create a Neo4j driver from config dict."""
+    return GraphDatabase.driver(cfg["uri"], auth=(cfg["user"], cfg["password"]))
+
+
+def run_procedure(driver, database: str, cypher: str, **params) -> list[dict]:
+    """Run a Cypher procedure call and return list of record dicts."""
+    with driver.session(database=database) as session:
+        result = session.run(cypher, **params)
+        return [record.data() for record in result]

graphpop_cli/formatters.py

@@ -0,0 +1,81 @@
+"""Output formatters for GraphPop CLI."""
+from __future__ import annotations
+
+import csv
+import io
+import json
+import sys
+from typing import TextIO
+
+
+def write_header_comment(out: TextIO, command: str, args: dict):
+    """Write a comment header with command info."""
+    parts = [f"# graphpop {command}"]
+    for k, v in args.items():
+        if v is not None and v is not False:
+            parts.append(f"# {k}: {v}")
+    out.write("\n".join(parts) + "\n")
+
+
+def write_tsv(records: list[dict], out: TextIO, header: bool = True):
+    """Write records as TSV."""
+    if not records:
+        return
+    keys = list(records[0].keys())
+    if header:
+        out.write("\t".join(keys) + "\n")
+    for rec in records:
+        vals = []
+        for k in keys:
+            v = rec[k]
+            if isinstance(v, float):
+                vals.append(f"{v:.6g}")
+            elif isinstance(v, list):
+                vals.append(",".join(str(x) for x in v))
+            elif v is None:
+                vals.append("NA")
+            else:
+                vals.append(str(v))
+        out.write("\t".join(vals) + "\n")
+
+
+def write_csv(records: list[dict], out: TextIO):
+    """Write records as CSV."""
+    if not records:
+        return
+    writer = csv.DictWriter(out, fieldnames=records[0].keys())
+    writer.writeheader()
+    for rec in records:
+        writer.writerow({k: (f"{v:.6g}" if isinstance(v, float) else v)
+                         for k, v in rec.items()})
+
+
+def write_json(records: list[dict], out: TextIO):
+    """Write records as JSON."""
+    json.dump(records, out, indent=2, default=str)
+    out.write("\n")
+
+
+def get_output(output_path: str | None) -> TextIO:
+    """Get output file handle (stdout if None)."""
+    if output_path:
+        return open(output_path, "w")
+    return sys.stdout
+
+
+def format_output(records: list[dict], output_path: str | None,
+                  fmt: str = "tsv", command: str = "", args: dict | None = None):
+    """Format and write records to output."""
+    out = get_output(output_path)
+    try:
+        if args and output_path:
+            write_header_comment(out, command, args)
+        if fmt == "tsv":
+            write_tsv(records, out)
+        elif fmt == "csv":
+            write_csv(records, out)
+        elif fmt == "json":
+            write_json(records, out)
+    finally:
+        if output_path and out is not sys.stdout:
+            out.close()

graphpop_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: graphpop-cli
+Version: 0.1.0
+Summary: Graph database-native population genomics CLI with O(V*K) complexity
+Author: Jianfeng Mao
+License: MIT
+Project-URL: Homepage, https://github.com/jfmao/GraphPop
+Project-URL: Repository, https://github.com/jfmao/GraphPop
+Project-URL: Issues, https://github.com/jfmao/GraphPop/issues
+Keywords: population-genomics,graph-database,neo4j,bioinformatics,genetics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+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.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0
+Requires-Dist: neo4j>=5.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.5; extra == "plot"
+Requires-Dist: numpy>=1.22; extra == "plot"
+
+# GraphPop CLI
+
+Command-line interface for **GraphPop** — a graph database-native population genomics engine that reduces summary statistic complexity from O(V×N) to O(V×K), independent of sample count.
+
+## Quick Start
+
+```bash
+pip install graphpop-cli
+graphpop setup --password mypass    # Downloads Neo4j + procedures plugin
+graphpop start                      # Start the database
+```
+
+**Prerequisites:** Python 3.10+, Java 21+ (for Neo4j runtime).
+
+## Features
+
+- **60 commands** across 11 functional domains
+- **12 population genetics procedures**: diversity, Fst, SFS, iHS, XP-EHH, nSL, ROH, Garud's H, LD, genome scan, pop summary, joint SFS
+- **Annotation conditioning**: `--consequence`, `--pathway`, `--gene` flags on any procedure
+- **Persistent analytical records**: `--persist` writes results to graph nodes
+- **Publication-ready plots**: 11 visualization types following Nature Methods guidelines
+
+## Usage
+
+```bash
+# Population diversity
+graphpop diversity chr1 1 50000000 EUR -o diversity.tsv
+
+# Annotation-conditioned analysis
+graphpop diversity chr1 1 43270923 GJ-tmp --consequence missense_variant
+
+# Selection scan
+graphpop ihs chr22 EUR --persist -o ihs.tsv
+
+# Multi-statistic convergence
+graphpop converge --stats ihs,xpehh,h12 --thresholds 2,2,0.3 --pop EUR
+```
+
+## Documentation
+
+- [Full documentation](https://github.com/jfmao/GraphPop)
+- [Rice 3K vignette](https://github.com/jfmao/GraphPop/blob/main/graphpop-cli/vignettes/rice-3k-analysis.md)
+- [Human 1000G vignette](https://github.com/jfmao/GraphPop/blob/main/graphpop-cli/vignettes/human-1000g-analysis.md)
+
+## License
+
+MIT

graphpop_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+graphpop_cli/__init__.py,sha256=TGu9i13Y7A-Fm-12ozUMTprGa0O-QrYqr7neUWkPEwg,106
+graphpop_cli/cli.py,sha256=pbsPGkcTk-tep6dNq7ZwdCr6Maf_i2sLKoOCzx78NhE,5190
+graphpop_cli/config.py,sha256=oHnmdIZ_lstTPDMfBCdxdfPcE1BWlg5lSkgoJFzPhbE,1874
+graphpop_cli/connection.py,sha256=6ZE3og3BsZDckG_E0PAx6-ow5ngpFPtE_1AxOk400cA,1538
+graphpop_cli/formatters.py,sha256=dXH0YSJY51fFCS8qDSwSIxk1ZCBrS77tlHORT1ciSiw,2400
+graphpop_cli/commands/__init__.py,sha256=ug95sIrk2eYKO-K29eRdpmMezey2qL8bcvnbCZWo6vg,36
+graphpop_cli/commands/aggregate.py,sha256=VhtJuL-QMo33CQu8St0S18rhDisABF7c479dXRD1di4,8174
+graphpop_cli/commands/batch.py,sha256=oietajzJ9SzvhEDyuWVcJsOL0txHURMs698qM94VPkA,6021
+graphpop_cli/commands/compare.py,sha256=IKaKfRti13CPaHVYRvWDwIfRoZkHe7aZq_Jwzu52jwg,4492
+graphpop_cli/commands/config_cmd.py,sha256=hUZKlPDhfoncRGAsaCEkaznq-5MQCHGppTlR_yhS3ng,3365
+graphpop_cli/commands/converge.py,sha256=K2Vk1saJiUPsZ4Sd9j8ol9tJPMVlGewV8N1RdqBQGsQ,6202
+graphpop_cli/commands/db.py,sha256=Ybg5Z6lRofw-Dpq66GuOx1xS0UTXqcdNIGUps9GbHS0,6424
+graphpop_cli/commands/divergence.py,sha256=9BDu2AFwhl4VrNjiyx15FPIcQ9XPULfh3owuR-hFPj4,1652
+graphpop_cli/commands/diversity.py,sha256=r14-qjWxaiPyLwqBt_hDIBoGzPdgyPtVuIMT_6NA2Vo,1734
+graphpop_cli/commands/dump.py,sha256=MlS8f4q2WRyl_ZZWPLOdLufraJJUHjllD1bnqo0C2wo,7830
+graphpop_cli/commands/export_bed.py,sha256=43O51yk8isNDOBCswS1pKae3ULWB7ZwwBbfwklUpgLg,6381
+graphpop_cli/commands/export_windows.py,sha256=ti6H1diRnSYDSpNQS9A8cUI5LSFQwM2So6FYLcfRk2E,3651
+graphpop_cli/commands/extract.py,sha256=fyCt5oAll63KlkOZ2xzFPtyUXoyM5_QZOhL9X2iFOSc,11680
+graphpop_cli/commands/filter_results.py,sha256=ySmWHL9IINplehz409w9kwVv4DKwldk37cDLF3Asblo,6574
+graphpop_cli/commands/garud_h.py,sha256=qWvhdFpHNhE_9dQZyLDopwfqEDPN8S2qNPFY0Peua7c,1338
+graphpop_cli/commands/genome_scan.py,sha256=q76OOWxCi3fJw0H0RMYhX1AO6eU5s-1PjIeiPV1xF0c,2025
+graphpop_cli/commands/ihs.py,sha256=8uBoHF2eIRsBImOrw_1DUCcezezYdd4H8G2JD-6i_Uk,1225
+graphpop_cli/commands/import_data.py,sha256=akQq4_HmuykPK_9l7UP4rDhcquI9SYyOsf_kgnW1d7M,10767
+graphpop_cli/commands/inventory.py,sha256=b6brcO_sWd-qwyvtf7mkHn7OGR7UxA_TlXS8rkC3XAI,6040
+graphpop_cli/commands/joint_sfs.py,sha256=aYMrzJt2n7IpnRaN83YCPEjroQfsrrSxhAENXCGVnkE,1804
+graphpop_cli/commands/ld.py,sha256=dyxH1_suR0zNwOmTAYrGrrBQQapf6KvD8uR9Rs34m7A,1519
+graphpop_cli/commands/lookup.py,sha256=42mcLHTKD8TCPNPGMuY33O-QOBqWXG6dkWchJXEpeyI,7032
+graphpop_cli/commands/neighbors.py,sha256=M67nLlEoypceWLW2WLcMMnWsx0oHrSL8UJOLrAjxPIo,6757
+graphpop_cli/commands/nsl.py,sha256=I2vQVUfpNMeRL5_uXEep8sha9B1he4f9XTFyTiEhvS4,1227
+graphpop_cli/commands/plot.py,sha256=E4RgSpQODRT14x3AbVsr2YIb3NFAWTRNlC0zwWOta50,39453
+graphpop_cli/commands/pop_summary.py,sha256=SX7Wdxq-G7j3DMfvBKKWt6nqAzc0_SvmSJgL1QRM3f0,1361
+graphpop_cli/commands/query.py,sha256=5jrQmKiQjryLf-w6YbH6c7Ss4FVxBAmPZUanndjdwl4,589
+graphpop_cli/commands/rank_genes.py,sha256=3fQXeG_8cW7aZg4_NlbEg-vgFwFbyUjo0In6W2L8WE0,6817
+graphpop_cli/commands/report.py,sha256=I1bue4HwpFsNl_Rm83UpV2SQQ7lFm3e335r2PEAiMo0,7938
+graphpop_cli/commands/roh.py,sha256=-gSsZaecLxpRs_kepnVIGNa12aVDw3qP_hd1qg8v4M0,1287
+graphpop_cli/commands/run_all.py,sha256=O0AqnjD59deldPfcCnoy0-RR1H57T2f1j9gBrdOSlWc,11789
+graphpop_cli/commands/server.py,sha256=vPZwSy7R5nIbXuxdtnr64-P5jP3UfJcpgGaStzmsVBM,3561
+graphpop_cli/commands/setup.py,sha256=Ei5jGrnaR0wZSKzy6cKhgK_EE9hphwbWZk4I-t8x5pw,10895
+graphpop_cli/commands/sfs.py,sha256=0pIIRYAENJsYbH248e9Ql5Lw0s9Dn-n2Rp_lXRUypc8,1739
+graphpop_cli/commands/validate.py,sha256=hrv4gjk6ZKfJwQcDZYGBpdUUNesfHt80BgwEod0n22U,5898
+graphpop_cli/commands/xpehh.py,sha256=kENF8xmt-RpGI8eru_WlTOwDFlf50znZBoshUtJJorw,1338
+graphpop_cli-0.1.0.dist-info/METADATA,sha256=6kK9rZLyhJH8CHiJU65wfkgHM6ljAnq669arvOOU-B4,2644
+graphpop_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+graphpop_cli-0.1.0.dist-info/entry_points.txt,sha256=fAtumzONXTTCKMKvafi_AJtLeX8U9aeBpBvtIXV9jjU,51
+graphpop_cli-0.1.0.dist-info/top_level.txt,sha256=noQV0fnJye3OHhLQNeph2SIlrIm8QzIz4lOFAHsaBmc,13
+graphpop_cli-0.1.0.dist-info/RECORD,,

graphpop_cli-0.1.0.dist-info/WHEEL

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

graphpop_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+graphpop = graphpop_cli.cli:main

graphpop_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+graphpop_cli