graphpop-cli 0.1.0__py3-none-any.whl

graphpop_cli/commands/config_cmd.py

@@ -0,0 +1,117 @@
+"""graphpop config — manage GraphPop configuration."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+import yaml
+
+
+CONFIG_PATH = Path.home() / ".graphpop" / "config.yaml"
+
+DEFAULTS = {
+    "uri": "bolt://localhost:7687",
+    "user": "neo4j",
+    "password": "",
+    "database": "neo4j",
+    "neo4j_home": str(Path.home() / "neo4j"),
+}
+
+
+@click.group()
+def config():
+    """Manage GraphPop configuration."""
+    pass
+
+
+@config.command()
+def init():
+    """Create a new GraphPop config file interactively."""
+    if CONFIG_PATH.exists():
+        if not click.confirm(f"{CONFIG_PATH} already exists. Overwrite?"):
+            return
+
+    cfg = {}
+    cfg["uri"] = click.prompt("Neo4j URI", default=DEFAULTS["uri"])
+    cfg["user"] = click.prompt("Neo4j user", default=DEFAULTS["user"])
+    cfg["password"] = click.prompt("Neo4j password", hide_input=True)
+    cfg["database"] = click.prompt("Default database", default=DEFAULTS["database"])
+    cfg["neo4j_home"] = click.prompt("Neo4j home directory",
+                                      default=DEFAULTS["neo4j_home"])
+
+    CONFIG_PATH.parent.mkdir(exist_ok=True)
+    with open(CONFIG_PATH, "w") as f:
+        yaml.dump(cfg, f, default_flow_style=False)
+    CONFIG_PATH.chmod(0o600)  # Restrict permissions (contains password)
+
+    click.echo(f"\nConfig written to {CONFIG_PATH}")
+    click.echo("Permissions set to owner-only (600).")
+
+
+@config.command()
+def show():
+    """Display the current configuration."""
+    if not CONFIG_PATH.exists():
+        click.echo(f"No config file found at {CONFIG_PATH}")
+        click.echo("Run 'graphpop config init' to create one.")
+        return
+
+    with open(CONFIG_PATH) as f:
+        cfg = yaml.safe_load(f) or {}
+
+    click.echo(f"Config: {CONFIG_PATH}\n")
+    for key, value in cfg.items():
+        if key == "password":
+            display = "****" if value else "(not set)"
+        else:
+            display = value
+        click.echo(f"  {key}: {display}")
+
+    # Show env var overrides
+    import os
+    overrides = []
+    if os.environ.get("GRAPHPOP_URI"):
+        overrides.append(f"  GRAPHPOP_URI={os.environ['GRAPHPOP_URI']}")
+    if os.environ.get("GRAPHPOP_USER"):
+        overrides.append(f"  GRAPHPOP_USER={os.environ['GRAPHPOP_USER']}")
+    if os.environ.get("GRAPHPOP_PASSWORD"):
+        overrides.append("  GRAPHPOP_PASSWORD=****")
+    if os.environ.get("GRAPHPOP_DATABASE"):
+        overrides.append(f"  GRAPHPOP_DATABASE={os.environ['GRAPHPOP_DATABASE']}")
+    if overrides:
+        click.echo("\nEnvironment overrides:")
+        for o in overrides:
+            click.echo(o)
+
+
+@config.command()
+@click.argument("key")
+@click.argument("value")
+def set(key, value):
+    """Set a configuration value.
+
+    \b
+    Examples:
+      graphpop config set database rice3k
+      graphpop config set pagecache 20g
+      graphpop config set neo4j_home /opt/neo4j
+    """
+    cfg = {}
+    if CONFIG_PATH.exists():
+        with open(CONFIG_PATH) as f:
+            cfg = yaml.safe_load(f) or {}
+
+    old = cfg.get(key, "(not set)")
+    cfg[key] = value
+
+    CONFIG_PATH.parent.mkdir(exist_ok=True)
+    with open(CONFIG_PATH, "w") as f:
+        yaml.dump(cfg, f, default_flow_style=False)
+
+    click.echo(f"{key}: {old} → {value}")
+
+
+@config.command()
+def path():
+    """Print the config file path."""
+    click.echo(str(CONFIG_PATH))

graphpop_cli/commands/converge.py

@@ -0,0 +1,156 @@
+"""graphpop converge — find regions where multiple selection statistics converge."""
+from __future__ import annotations
+
+import click
+
+from ..cli import pass_ctx
+from ..formatters import format_output
+
+
+# Statistics stored on Variant nodes vs GenomicWindow nodes
+VARIANT_STATS = {"ihs", "xpehh", "nsl"}
+WINDOW_STATS = {"h12", "fst", "pi", "tajima_d"}
+
+
+@click.command("converge")
+@click.option("--stats", required=True,
+              help="Comma-separated statistic names (ihs, xpehh, nsl, h12, fst, pi, tajima_d)")
+@click.option("--thresholds", required=True,
+              help="Comma-separated threshold values (matched positionally to stats)")
+@click.option("--chr", "chromosome", help="Chromosome (optional, all if not specified)")
+@click.option("--pop", "population", required=True, help="Population name")
+@click.option("--pop2", help="Second population (for xpehh, fst)")
+@click.option("--window", type=int, default=0,
+              help="Aggregate into windows of this size (default: per-variant)")
+@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("--limit", type=int, default=10000, help="Maximum rows (default: 10000)")
+@pass_ctx
+def converge(ctx, stats, thresholds, chromosome, population, pop2,
+             window, output_path, fmt, limit):
+    """Find genomic regions where multiple statistics exceed thresholds.
+
+    Identifies convergent selection signals by requiring multiple persisted
+    statistics to simultaneously exceed user-defined thresholds.
+
+    \b
+    For variant-based stats (ihs, xpehh, nsl): queries Variant nodes.
+    For window-based stats (h12, fst, pi, tajima_d): queries GenomicWindow nodes.
+    If mixed, runs two queries and merges results by position.
+
+    \b
+    Examples:
+      graphpop converge --stats ihs,xpehh --thresholds 2.0,2.0 --pop EUR --pop2 AFR
+      graphpop converge --stats ihs,nsl --thresholds 2.0,2.0 --chr chr22 --pop EUR -o conv.tsv
+      graphpop converge --stats h12,fst --thresholds 0.3,0.5 --pop GJ-tmp --window 100000
+      graphpop converge --stats ihs,xpehh,h12,fst --thresholds 2.0,2.0,0.3,0.5 --pop EUR --pop2 AFR
+    """
+    stat_list = [s.strip() for s in stats.split(",")]
+    thresh_list = [float(t.strip()) for t in thresholds.split(",")]
+
+    if len(stat_list) != len(thresh_list):
+        click.echo("Error: --stats and --thresholds must have the same number of items.", err=True)
+        raise SystemExit(1)
+
+    requested_variant = [s for s in stat_list if s in VARIANT_STATS]
+    requested_window = [s for s in stat_list if s in WINDOW_STATS]
+    unknown = [s for s in stat_list if s not in VARIANT_STATS and s not in WINDOW_STATS]
+    if unknown:
+        click.echo(f"Warning: unknown statistics ignored: {unknown}", err=True)
+
+    stat_thresh = dict(zip(stat_list, thresh_list))
+
+    results = []
+
+    # --- Query variant-based stats ---
+    if requested_variant:
+        where_parts = []
+        params: dict = {"limit": limit}
+        if chromosome:
+            where_parts.append("v.chr = $chromosome")
+            params["chromosome"] = chromosome
+
+        return_cols = [
+            "v.variantId AS variant_id",
+            "v.chr AS chr",
+            "v.pos AS pos",
+        ]
+
+        for stat in requested_variant:
+            prop = _prop_name(stat, population, pop2)
+            if prop is None:
+                click.echo(f"Warning: skipping {stat} (need --pop2 for xpehh)", err=True)
+                continue
+            thresh = stat_thresh[stat]
+            where_parts.append(f"abs(v.{prop}) >= {thresh}")
+            return_cols.append(f"v.{prop} AS {stat}")
+
+        # Join to gene annotation
+        cypher = (
+            f"MATCH (v:Variant) "
+            f"WHERE {' AND '.join(where_parts)} "
+            f"OPTIONAL MATCH (v)-[:HAS_CONSEQUENCE]->(g:Gene) "
+            f"RETURN DISTINCT {', '.join(return_cols)}, "
+            f"g.symbol AS gene "
+            f"ORDER BY v.pos LIMIT $limit"
+        )
+        variant_records = ctx.run(cypher, params)
+        results.extend(variant_records)
+
+    # --- Query window-based stats ---
+    if requested_window:
+        where_parts = ["w.population = $population"]
+        params = {"population": population, "limit": limit}
+        if chromosome:
+            where_parts.append("w.chr = $chromosome")
+            params["chromosome"] = chromosome
+
+        return_cols = [
+            "w.windowId AS window_id",
+            "w.chr AS chr",
+            "w.start AS start",
+            "w.end AS end",
+        ]
+
+        for stat in requested_window:
+            prop = stat
+            thresh = stat_thresh[stat]
+            if stat == "fst" and pop2:
+                prop = f"fst_{population}_{pop2}"
+            if stat in ("h12",):
+                where_parts.append(f"w.{prop} >= {thresh}")
+            elif stat in ("tajima_d",):
+                # Tajima's D: extreme negative = selection
+                where_parts.append(f"w.{prop} <= -{thresh}")
+            else:
+                where_parts.append(f"w.{prop} >= {thresh}")
+            return_cols.append(f"w.{prop} AS {stat}")
+
+        cypher = (
+            f"MATCH (w:GenomicWindow) "
+            f"WHERE {' AND '.join(where_parts)} "
+            f"RETURN {', '.join(return_cols)} "
+            f"ORDER BY w.start LIMIT $limit"
+        )
+        window_records = ctx.run(cypher, params)
+        results.extend(window_records)
+
+    if not results:
+        click.echo("No convergent signals found with the given thresholds.", err=True)
+        return
+
+    click.echo(f"Found {len(results)} convergent records.", err=True)
+    format_output(results, output_path, fmt, "converge",
+                  {"stats": stats, "thresholds": thresholds,
+                   "chr": chromosome, "pop": population, "pop2": pop2})
+
+
+def _prop_name(stat: str, population: str, pop2: str | None) -> str | None:
+    """Build the Neo4j property name for a given statistic."""
+    if stat in ("ihs", "nsl"):
+        return f"{stat}_{population}"
+    elif stat == "xpehh":
+        if not pop2:
+            return None
+        return f"xpehh_{population}_{pop2}"
+    return stat

graphpop_cli/commands/db.py

@@ -0,0 +1,188 @@
+"""graphpop db — database management (list, create, switch, drop, info)."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+import yaml
+
+from ..cli import pass_ctx
+
+
+@click.group()
+def db():
+    """Manage Neo4j databases for GraphPop."""
+    pass
+
+
+@db.command()
+@pass_ctx
+def list(ctx):
+    """List all databases with sizes and status."""
+    cypher = "SHOW DATABASES YIELD name, currentStatus, sizeOnDisk ORDER BY name"
+    try:
+        records = ctx.run(cypher)
+    except Exception:
+        # Fallback for Neo4j Community (SHOW DATABASES may not return sizeOnDisk)
+        try:
+            records = ctx.run("SHOW DATABASES YIELD name, currentStatus ORDER BY name")
+        except Exception as e:
+            click.echo(f"Error: {e}", err=True)
+            raise SystemExit(1)
+
+    if not records:
+        click.echo("No databases found.")
+        return
+
+    # Show current active database
+    config_path = Path.home() / ".graphpop" / "config.yaml"
+    active_db = "neo4j"
+    if config_path.exists():
+        with open(config_path) as f:
+            cfg = yaml.safe_load(f) or {}
+        active_db = cfg.get("database", "neo4j")
+
+    click.echo(f"{'Database':<25} {'Status':<12} {'Size':<15} {'Active'}")
+    click.echo("-" * 60)
+    for rec in records:
+        name = rec.get("name", "?")
+        status = rec.get("currentStatus", "?")
+        size = rec.get("sizeOnDisk", "")
+        if isinstance(size, (int, float)) and size > 0:
+            size = _format_size(size)
+        active = " *" if name == active_db else ""
+        click.echo(f"{name:<25} {status:<12} {str(size):<15}{active}")
+
+
+@db.command()
+@click.argument("name")
+@pass_ctx
+def create(ctx, name):
+    """Create a new database."""
+    click.echo(f"Creating database '{name}'...")
+    try:
+        # Must run against system database
+        from neo4j import GraphDatabase
+        driver = GraphDatabase.driver(ctx.cfg["uri"],
+                                       auth=(ctx.cfg["user"], ctx.cfg["password"]))
+        with driver.session(database="system") as session:
+            session.run(f"CREATE DATABASE `{name}` IF NOT EXISTS")
+        driver.close()
+        click.echo(f"Database '{name}' created.")
+        click.echo(f"Switch to it with: graphpop db switch {name}")
+    except Exception as e:
+        if "Unsupported" in str(e) or "Enterprise" in str(e):
+            click.echo(
+                "Error: CREATE DATABASE requires Neo4j Enterprise Edition.\n"
+                "With Community Edition, use 'neo4j' as the default database\n"
+                "or create databases via neo4j-admin.",
+                err=True,
+            )
+        else:
+            click.echo(f"Error: {e}", err=True)
+        raise SystemExit(1)
+
+
+@db.command()
+@click.argument("name")
+def switch(name):
+    """Set the active database in GraphPop 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 {}
+    old = cfg.get("database", "neo4j")
+    cfg["database"] = name
+    config_path.parent.mkdir(exist_ok=True)
+    with open(config_path, "w") as f:
+        yaml.dump(cfg, f, default_flow_style=False)
+    click.echo(f"Active database: {old} → {name}")
+    click.echo(f"All graphpop commands will now use database '{name}'.")
+
+
+@db.command()
+@click.argument("name")
+@click.option("--force", is_flag=True, help="Skip confirmation prompt")
+@pass_ctx
+def drop(ctx, name, force):
+    """Drop a database (requires confirmation)."""
+    if name in ("neo4j", "system"):
+        click.echo(f"Error: Cannot drop the '{name}' system database.", err=True)
+        raise SystemExit(1)
+
+    if not force:
+        click.confirm(f"Drop database '{name}'? This cannot be undone", abort=True)
+
+    try:
+        from neo4j import GraphDatabase
+        driver = GraphDatabase.driver(ctx.cfg["uri"],
+                                       auth=(ctx.cfg["user"], ctx.cfg["password"]))
+        with driver.session(database="system") as session:
+            session.run(f"DROP DATABASE `{name}` IF EXISTS")
+        driver.close()
+        click.echo(f"Database '{name}' dropped.")
+    except Exception as e:
+        if "Unsupported" in str(e) or "Enterprise" in str(e):
+            click.echo(
+                "Error: DROP DATABASE requires Neo4j Enterprise Edition.\n"
+                "With Community Edition, use neo4j-admin to manage databases.",
+                err=True,
+            )
+        else:
+            click.echo(f"Error: {e}", err=True)
+        raise SystemExit(1)
+
+
+@db.command()
+@pass_ctx
+def info(ctx):
+    """Show detailed information about the current database."""
+    click.echo(f"Database: {ctx.database}\n")
+
+    # Node counts
+    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"
+        )
+        if records:
+            click.echo("Node counts:")
+            for rec in records:
+                click.echo(f"  {rec['label']:<20} {rec['cnt']:>12,}")
+
+        # Relationship counts
+        records = ctx.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 ORDER BY cnt DESC"
+        )
+        if records:
+            click.echo("\nRelationship counts:")
+            for rec in records:
+                click.echo(f"  {rec['type']:<25} {rec['cnt']:>12,}")
+
+        # Check GraphPop procedures
+        records = ctx.run(
+            "SHOW PROCEDURES YIELD name WHERE name STARTS WITH 'graphpop' "
+            "RETURN name ORDER BY name"
+        )
+        if records:
+            click.echo(f"\nGraphPop procedures ({len(records)}):")
+            for rec in records:
+                click.echo(f"  {rec['name']}")
+        else:
+            click.echo("\nGraphPop procedures: NONE INSTALLED")
+
+    except Exception as e:
+        click.echo(f"Error querying database: {e}", err=True)
+
+
+def _format_size(size_bytes: int | float) -> str:
+    """Format bytes as human-readable size."""
+    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/divergence.py

@@ -0,0 +1,37 @@
+"""graphpop divergence — Fst, Dxy, Da, PBS."""
+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("pop1")
+@click.argument("pop2")
+@click.option("--pop3", help="Third population for PBS computation")
+@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")
+@pass_ctx
+def divergence(ctx, chr, start, end, pop1, pop2, pop3, output_path, fmt,
+               consequence, pathway, gene, min_af):
+    """Compute Hudson Fst, W&C Fst, Dxy, Da, and optionally PBS."""
+    opts = build_options_map(consequence=consequence, pathway=pathway, gene=gene,
+                             min_af=min_af)
+    positional = [f"'{chr}'", str(start), str(end), f"'{pop1}'", f"'{pop2}'"]
+    if pop3:
+        positional.append(f"'{pop3}'")
+    cypher = build_cypher(
+        "graphpop.divergence", positional,
+        options=opts if opts else None,
+        yield_cols=["fst_hudson", "fst_wc", "dxy", "da", "pbs", "n_variants"],
+    )
+    records = ctx.run(cypher)
+    format_output(records, output_path, fmt, "divergence",
+                  {"chr": chr, "pop1": pop1, "pop2": pop2, "pop3": pop3})

graphpop_cli/commands/diversity.py

@@ -0,0 +1,36 @@
+"""graphpop diversity — nucleotide diversity, theta, Tajima's D, Fay & Wu's H."""
+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("-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 diversity(ctx, chr, start, end, population, output_path, fmt,
+              consequence, pathway, gene, min_af, max_af):
+    """Compute nucleotide diversity, theta_W, Tajima's D, Fay & Wu's H."""
+    opts = build_options_map(consequence=consequence, pathway=pathway, gene=gene,
+                             min_af=min_af, max_af=max_af)
+    cypher = build_cypher(
+        "graphpop.diversity",
+        [f"'{chr}'", str(start), str(end), f"'{population}'"],
+        options=opts if opts else None,
+        yield_cols=["pi", "theta_w", "tajima_d", "fay_wu_h", "fay_wu_h_norm",
+                     "het_exp", "het_obs", "fis", "n_variants", "n_segregating",
+                     "n_polarized"],
+    )
+    records = ctx.run(cypher)
+    format_output(records, output_path, fmt, "diversity",
+                  {"chr": chr, "start": start, "end": end, "pop": population})