graphpop-cli 0.1.0__py3-none-any.whl

graphpop_cli/commands/dump.py

@@ -0,0 +1,210 @@
+"""graphpop dump/load — database dump and restore for sharing."""
+from __future__ import annotations
+
+import json
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+import click
+import yaml
+
+
+def _get_neo4j_home() -> Path:
+    """Get Neo4j home from config."""
+    config_path = Path.home() / ".graphpop" / "config.yaml"
+    if config_path.exists():
+        with open(config_path) as f:
+            cfg = yaml.safe_load(f) or {}
+        if "neo4j_home" in cfg:
+            return Path(cfg["neo4j_home"])
+    return Path.home() / "neo4j"
+
+
+@click.command()
+@click.option("--database", required=True, help="Database name to dump")
+@click.option("-o", "--output", "output_path", type=click.Path(),
+              help="Output dump file path (default: <database>_<date>.dump)")
+@click.option("--neo4j-home", type=click.Path(), help="Neo4j installation directory")
+@click.option("--manifest/--no-manifest", default=True,
+              help="Generate a JSON manifest with database metadata (default: yes)")
+def dump(database, output_path, neo4j_home, manifest):
+    """Dump a Neo4j database to a file for sharing.
+
+    Creates a neo4j-admin dump file that can be shared and loaded on another
+    machine. Optionally generates a JSON manifest with node/edge counts,
+    populations, chromosomes, and computed statistics metadata.
+
+    \b
+    Examples:
+      graphpop dump --database rice3k
+      graphpop dump --database rice3k -o rice3k_v1.dump
+      graphpop dump --database neo4j --no-manifest
+    """
+    home = Path(neo4j_home) if neo4j_home else _get_neo4j_home()
+    admin_bin = home / "bin" / "neo4j-admin"
+
+    if not admin_bin.exists():
+        click.echo(f"Error: neo4j-admin not found at {admin_bin}", err=True)
+        raise SystemExit(1)
+
+    # Default output path
+    if not output_path:
+        date_str = datetime.now().strftime("%Y%m%d")
+        output_path = f"graphpop_{database}_{date_str}.dump"
+
+    output_file = Path(output_path)
+
+    click.echo(f"Dumping database '{database}' to {output_file}...")
+
+    # Run neo4j-admin dump
+    cmd = [
+        str(admin_bin), "database", "dump",
+        f"--to-path={output_file.parent}",
+        database,
+    ]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        click.echo(f"Error: {result.stderr.strip()}", err=True)
+        click.echo("\nNote: Neo4j must be stopped before dumping.", err=True)
+        click.echo("Run 'graphpop stop' first, then retry.", err=True)
+        raise SystemExit(1)
+
+    # Rename if neo4j-admin used its own naming
+    expected_dump = output_file.parent / f"{database}.dump"
+    if expected_dump.exists() and expected_dump != output_file:
+        expected_dump.rename(output_file)
+
+    size = output_file.stat().st_size if output_file.exists() else 0
+    click.echo(f"Dump complete: {output_file} ({_format_size(size)})")
+
+    # Generate manifest
+    if manifest:
+        manifest_path = output_file.with_suffix(".manifest.json")
+        _generate_manifest(home, database, manifest_path, output_file)
+        click.echo(f"Manifest: {manifest_path}")
+
+
+@click.command()
+@click.option("--dump-file", required=True, type=click.Path(exists=True),
+              help="Path to the .dump file")
+@click.option("--database", required=True,
+              help="Name for the restored database")
+@click.option("--neo4j-home", type=click.Path(), help="Neo4j installation directory")
+@click.option("--overwrite", is_flag=True, help="Overwrite existing database")
+def load(dump_file, database, neo4j_home, overwrite):
+    """Load a database from a dump file.
+
+    Restores a previously dumped Neo4j database. The database name can be
+    different from the original.
+
+    \b
+    Examples:
+      graphpop load --dump-file rice3k_v1.dump --database rice3k
+      graphpop load --dump-file shared_db.dump --database myanalysis --overwrite
+    """
+    home = Path(neo4j_home) if neo4j_home else _get_neo4j_home()
+    admin_bin = home / "bin" / "neo4j-admin"
+
+    if not admin_bin.exists():
+        click.echo(f"Error: neo4j-admin not found at {admin_bin}", err=True)
+        raise SystemExit(1)
+
+    dump_path = Path(dump_file)
+    click.echo(f"Loading database '{database}' from {dump_path}...")
+
+    cmd = [
+        str(admin_bin), "database", "load",
+        f"--from-path={dump_path.parent}",
+    ]
+    if overwrite:
+        cmd.append("--overwrite-destination=true")
+    cmd.append(database)
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        click.echo(f"Error: {result.stderr.strip()}", err=True)
+        if "already exists" in result.stderr:
+            click.echo("Use --overwrite to replace the existing database.", err=True)
+        elif "running" in result.stderr.lower():
+            click.echo("Stop Neo4j first: graphpop stop", err=True)
+        raise SystemExit(1)
+
+    # Update config
+    config_path = Path.home() / ".graphpop" / "config.yaml"
+    cfg = {}
+    if config_path.exists():
+        with open(config_path) as f:
+            cfg = yaml.safe_load(f) or {}
+    cfg["database"] = database
+    with open(config_path, "w") as f:
+        yaml.dump(cfg, f, default_flow_style=False)
+
+    click.echo(f"Database '{database}' loaded successfully.")
+    click.echo(f"Config updated to use database '{database}'.")
+    click.echo(f"\nNext: graphpop start && graphpop db info")
+
+
+def _generate_manifest(neo4j_home: Path, database: str,
+                       manifest_path: Path, dump_path: Path):
+    """Generate a JSON manifest with database metadata."""
+    manifest = {
+        "database": database,
+        "date": datetime.now().isoformat(),
+        "dump_file": str(dump_path),
+        "dump_size_bytes": dump_path.stat().st_size if dump_path.exists() else 0,
+    }
+
+    # Try to query the database for node/edge counts
+    # (only works if Neo4j is running — otherwise just save basic info)
+    try:
+        from ..connection import load_config, get_driver
+        cfg = load_config()
+        driver = get_driver(cfg)
+        with driver.session(database=database) as session:
+            # Node counts
+            result = session.run(
+                "CALL db.labels() YIELD label "
+                "CALL { WITH label MATCH (n) WHERE label IN labels(n) "
+                "RETURN count(n) AS cnt } RETURN label, cnt"
+            )
+            manifest["node_counts"] = {r["label"]: r["cnt"] for r in result}
+
+            # Relationship counts
+            result = session.run(
+                "CALL db.relationshipTypes() YIELD relationshipType AS type "
+                "CALL { WITH type MATCH ()-[r]->() WHERE type(r) = type "
+                "RETURN count(r) AS cnt } RETURN type, cnt"
+            )
+            manifest["edge_counts"] = {r["type"]: r["cnt"] for r in result}
+
+            # Populations
+            result = session.run(
+                "MATCH (p:Population) RETURN p.populationId AS pop, "
+                "p.n_samples AS n ORDER BY n DESC"
+            )
+            manifest["populations"] = {r["pop"]: r["n"] for r in result}
+
+            # Chromosomes
+            result = session.run(
+                "MATCH (c:Chromosome) RETURN c.chromosomeId AS chr, "
+                "c.length AS len ORDER BY chr"
+            )
+            manifest["chromosomes"] = {r["chr"]: r["len"] for r in result}
+
+        driver.close()
+    except Exception:
+        manifest["note"] = "Neo4j not running; metadata not available"
+
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2, default=str)
+
+
+def _format_size(size_bytes: int) -> str:
+    """Format bytes as human-readable."""
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if abs(size_bytes) < 1024.0:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.1f} PB"

graphpop_cli/commands/export_bed.py

@@ -0,0 +1,170 @@
+"""graphpop export-bed — export high-scoring regions as BED format."""
+from __future__ import annotations
+
+import click
+
+from ..cli import pass_ctx
+
+
+# Statistics stored on GenomicWindow nodes vs Variant nodes
+WINDOW_STATS = {"fst", "pi", "tajima_d", "h12"}
+VARIANT_STATS = {"ihs", "xpehh", "nsl"}
+
+
+@click.command("export-bed")
+@click.option("--stat", required=True,
+              type=click.Choice(["fst", "pi", "tajima_d", "h12", "ihs", "xpehh", "nsl"]),
+              help="Statistic to threshold")
+@click.option("--threshold", required=True, type=float,
+              help="Minimum value to include (absolute value for ihs/xpehh/nsl)")
+@click.option("--pop", "population", required=True, help="Population name")
+@click.option("--pop2", help="Second population (required for xpehh)")
+@click.option("--chr", "chromosome", help="Chromosome filter (optional)")
+@click.option("--merge-distance", type=int, default=100000,
+              help="Merge variants within this distance into intervals (variant-based stats, default: 100000)")
+@click.option("-o", "--output", "output_path", required=True, help="Output BED file")
+@pass_ctx
+def export_bed(ctx, stat, threshold, population, pop2, chromosome,
+               merge_distance, output_path):
+    """Export regions exceeding a statistic threshold as BED format.
+
+    For window-based stats (fst, pi, tajima_d, h12), queries GenomicWindow
+    nodes directly. For variant-based stats (ihs, xpehh, nsl), merges
+    consecutive high-scoring variants into intervals using --merge-distance.
+
+    Output: standard 5-column BED (chr, start, end, name, score).
+
+    \b
+    Examples:
+      graphpop export-bed --stat fst --threshold 0.5 --pop EUR -o high_fst.bed
+      graphpop export-bed --stat ihs --threshold 2.5 --pop EUR --chr chr22 -o ihs_peaks.bed
+      graphpop export-bed --stat xpehh --threshold 3.0 --pop EUR --pop2 AFR -o xpehh.bed
+      graphpop export-bed --stat tajima_d --threshold -2.0 --pop GJ-tmp -o tajimad.bed
+    """
+    if stat == "xpehh" and not pop2:
+        click.echo("Error: --pop2 is required for xpehh.", err=True)
+        raise SystemExit(1)
+
+    bed_name = f"{stat}_{population}" if not pop2 else f"{stat}_{population}_{pop2}"
+
+    if stat in WINDOW_STATS:
+        records = _query_window_stat(ctx, stat, threshold, population, pop2, chromosome)
+        bed_lines = _windows_to_bed(records, stat, bed_name)
+    else:
+        records = _query_variant_stat(ctx, stat, threshold, population, pop2, chromosome)
+        bed_lines = _merge_variants_to_bed(records, merge_distance, bed_name)
+
+    if not bed_lines:
+        click.echo(f"No regions found exceeding threshold {threshold} for {stat}.", err=True)
+        return
+
+    with open(output_path, "w") as f:
+        for line in bed_lines:
+            f.write(line + "\n")
+
+    click.echo(f"Wrote {len(bed_lines)} BED intervals to {output_path}.", err=True)
+
+
+def _query_window_stat(ctx, stat, threshold, population, pop2, chromosome):
+    """Query GenomicWindow nodes for window-based statistics."""
+    params = {"population": population}
+    where_parts = ["w.population = $population"]
+    if chromosome:
+        where_parts.append("w.chr = $chromosome")
+        params["chromosome"] = chromosome
+
+    prop = stat
+    if stat == "fst" and pop2:
+        prop = f"fst_{population}_{pop2}"
+
+    # For Tajima's D, extreme negative values indicate selection
+    if stat == "tajima_d":
+        where_parts.append(f"w.{prop} <= {threshold}")
+    else:
+        where_parts.append(f"w.{prop} >= {threshold}")
+
+    cypher = (
+        f"MATCH (w:GenomicWindow) "
+        f"WHERE {' AND '.join(where_parts)} "
+        f"RETURN w.chr AS chr, w.start AS start, w.end AS end, "
+        f"w.{prop} AS score "
+        f"ORDER BY w.chr, w.start"
+    )
+    return ctx.run(cypher, params)
+
+
+def _query_variant_stat(ctx, stat, threshold, population, pop2, chromosome):
+    """Query Variant nodes for variant-based statistics."""
+    if stat == "xpehh":
+        prop = f"xpehh_{population}_{pop2}"
+    else:
+        prop = f"{stat}_{population}"
+
+    params = {}
+    where_parts = [f"v.{prop} IS NOT NULL", f"abs(v.{prop}) >= {threshold}"]
+    if chromosome:
+        where_parts.append("v.chr = $chromosome")
+        params["chromosome"] = chromosome
+
+    cypher = (
+        f"MATCH (v:Variant) "
+        f"WHERE {' AND '.join(where_parts)} "
+        f"RETURN v.chr AS chr, v.pos AS pos, v.{prop} AS score "
+        f"ORDER BY v.chr, v.pos"
+    )
+    return ctx.run(cypher, params)
+
+
+def _windows_to_bed(records, stat, bed_name):
+    """Convert window records directly to BED lines."""
+    lines = []
+    for r in records:
+        chrom = r.get("chr", "")
+        start = r.get("start", 0)
+        end = r.get("end", 0)
+        score = r.get("score", 0)
+        score_str = f"{score:.6g}" if isinstance(score, float) else str(score)
+        lines.append(f"{chrom}\t{start}\t{end}\t{bed_name}\t{score_str}")
+    return lines
+
+
+def _merge_variants_to_bed(records, merge_distance, bed_name):
+    """Merge consecutive high-scoring variants into BED intervals."""
+    if not records:
+        return []
+
+    intervals = []
+    current_chr = None
+    current_start = None
+    current_end = None
+    current_scores = []
+
+    for r in records:
+        chrom = r.get("chr", "")
+        pos = r.get("pos", 0)
+        score = r.get("score", 0)
+
+        if (current_chr is None or chrom != current_chr
+                or pos - current_end > merge_distance):
+            # Emit previous interval
+            if current_chr is not None:
+                mean_score = sum(current_scores) / len(current_scores)
+                intervals.append((current_chr, current_start, current_end, mean_score))
+            # Start new interval
+            current_chr = chrom
+            current_start = pos
+            current_end = pos
+            current_scores = [abs(score) if isinstance(score, (int, float)) else 0]
+        else:
+            current_end = pos
+            current_scores.append(abs(score) if isinstance(score, (int, float)) else 0)
+
+    # Emit last interval
+    if current_chr is not None:
+        mean_score = sum(current_scores) / len(current_scores)
+        intervals.append((current_chr, current_start, current_end, mean_score))
+
+    lines = []
+    for chrom, start, end, score in intervals:
+        lines.append(f"{chrom}\t{start}\t{end}\t{bed_name}\t{score:.6g}")
+    return lines

graphpop_cli/commands/export_windows.py

@@ -0,0 +1,91 @@
+"""graphpop export-windows — batch export GenomicWindow nodes to TSV."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from ..cli import pass_ctx
+from ..formatters import format_output
+
+
+@click.command("export-windows")
+@click.argument("chr", required=False)
+@click.argument("population", required=False)
+@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("--min-pi", type=float, help="Minimum pi filter")
+@click.option("--max-pi", type=float, help="Maximum pi filter")
+@click.option("--min-fst", type=float, help="Minimum Fst filter")
+@click.option("--min-tajima-d", type=float, help="Minimum Tajima's D filter")
+@click.option("--max-tajima-d", type=float, help="Maximum Tajima's D filter")
+@click.option("--run-id", help="Filter by specific run ID")
+@click.option("--limit", type=int, help="Maximum number of windows to return")
+@pass_ctx
+def export_windows(ctx, chr, population, output_path, fmt,
+                   min_pi, max_pi, min_fst, min_tajima_d, max_tajima_d,
+                   run_id, limit):
+    """Export GenomicWindow nodes from the graph as TSV.
+
+    Query persisted genome scan results (GenomicWindow nodes) with optional
+    filters. Without arguments, exports all windows. With CHR and POPULATION,
+    exports windows for that combination.
+
+    \b
+    Examples:
+      graphpop export-windows                          # all windows
+      graphpop export-windows chr22 EUR -o windows.tsv # specific region
+      graphpop export-windows --min-fst 0.5            # high-Fst windows
+      graphpop export-windows chr1 AFR --max-tajima-d -2  # negative Tajima's D
+    """
+    # Build Cypher query with parameterized values to prevent injection
+    where_clauses = []
+    params: dict = {}
+
+    if chr:
+        where_clauses.append("w.chr = $chr")
+        params["chr"] = chr
+    if population:
+        where_clauses.append("w.population = $population")
+        params["population"] = population
+    if min_pi is not None:
+        where_clauses.append(f"w.pi >= {min_pi}")
+    if max_pi is not None:
+        where_clauses.append(f"w.pi <= {max_pi}")
+    if min_fst is not None:
+        where_clauses.append(f"w.fst >= {min_fst}")
+    if min_tajima_d is not None:
+        where_clauses.append(f"w.tajima_d >= {min_tajima_d}")
+    if max_tajima_d is not None:
+        where_clauses.append(f"w.tajima_d <= {max_tajima_d}")
+    if run_id:
+        where_clauses.append("w.run_id = $run_id")
+        params["run_id"] = run_id
+
+    where = " AND ".join(where_clauses) if where_clauses else "TRUE"
+    limit_clause = " LIMIT $limit" if limit else ""
+    if limit:
+        params["limit"] = limit
+
+    cypher = (
+        f"MATCH (w:GenomicWindow) WHERE {where} "
+        f"RETURN w.windowId AS window_id, w.chr AS chr, "
+        f"w.start AS start, w.end AS end, "
+        f"w.population AS population, w.run_id AS run_id, "
+        f"w.n_variants AS n_variants, w.n_segregating AS n_segregating, "
+        f"w.pi AS pi, w.theta_w AS theta_w, w.tajima_d AS tajima_d, "
+        f"w.fst AS fst, w.fst_wc AS fst_wc, w.dxy AS dxy, "
+        f"w.pbs AS pbs, w.fay_wu_h AS fay_wu_h "
+        f"ORDER BY w.chr, w.start"
+        f"{limit_clause}"
+    )
+
+    records = ctx.run(cypher, params)
+
+    if not records:
+        click.echo("No windows found matching criteria.", err=True)
+        return
+
+    click.echo(f"Exporting {len(records)} windows...", err=True)
+    format_output(records, output_path, fmt, "export-windows",
+                  {"chr": chr, "population": population})