seashell-cli 0.1.0__py3-none-any.whl

seashell/__init__.py

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

seashell/__main__.py

@@ -0,0 +1,2 @@
+from seashell.cli import main
+main()

seashell/cli.py

@@ -0,0 +1,234 @@
+"""Seashell CLI — interactive genomic query tool."""
+
+import getpass
+import json
+import sys
+import threading
+
+from seashell.client import SeashellClient
+from seashell.config import load_config, save_config, clear_config, DEFAULT_SERVER
+from seashell.display import display_result, print_job_progress
+from seashell.help import HELP_TEXT, welcome_banner, CYAN, BOLD, DIM, RESET, WHITE, BLUE
+
+
+def _prompt_login():
+    """Interactive login flow. Returns (client, config) or exits on failure."""
+    print(welcome_banner())
+
+    config = load_config()
+    server = config.get("server", DEFAULT_SERVER)
+
+    # Check for cached credentials
+    if config.get("api_key") and config.get("email"):
+        print(DIM + "  Reconnecting as %s (%s)..." % (config["email"], config.get("institution", "?")) + RESET)
+        client = SeashellClient(server, config["api_key"])
+        client.wake()  # pre-warm while we verify
+        health = client.health()
+        if health:
+            count = health.get("patient_count", "?")
+            print(BOLD + "  Ready." + RESET + " %s patients loaded.\n" % count)
+            return client, config
+        else:
+            print("  Server unreachable. Re-enter credentials.\n")
+
+    # Fresh login
+    api_key = input(CYAN + "  API Key: " + RESET).strip()
+    if not api_key:
+        print("  No API key provided. Exiting.")
+        sys.exit(1)
+
+    # Immediately start warming up the instance (API key identifies institution)
+    client = SeashellClient(server, api_key)
+    client.wake()
+
+    # Verify the key and get institution name
+    health = client.health()
+    if health:
+        inst = health.get("institution", "your institution")
+        print(DIM + "  Institution: %s " % inst + CYAN + "(warming up...)" + RESET)
+    else:
+        inst = "unknown"
+        print("  Could not reach server at %s" % server)
+        print("  Will retry on first query.\n")
+
+    email = input(CYAN + "  Username: " + RESET).strip()
+    password = getpass.getpass(CYAN + "  Password: " + RESET)
+
+    # Verify credentials
+    try:
+        resp = client.session.post(server + "/login", json={
+            "email": email,
+            "password": password,
+        }, timeout=15)
+        if resp.status_code != 200:
+            detail = ""
+            try:
+                detail = resp.json().get("detail", "")
+            except Exception:
+                pass
+            print("\n  Login failed: %s" % (detail or "invalid credentials"))
+            sys.exit(1)
+        login_data = resp.json()
+    except Exception as e:
+        print("\n  Connection error: %s" % str(e))
+        sys.exit(1)
+
+    # Save credentials
+    config = {
+        "server": server,
+        "api_key": api_key,
+        "institution": inst if inst != "unknown" else login_data.get("institution", ""),
+        "email": email,
+        "session_token": login_data.get("token", ""),
+    }
+    save_config(config)
+
+    # Check patient count
+    health = client.health()
+    count = health.get("patient_count", "?") if health else "?"
+    print("\n  " + BOLD + "Authenticated." + RESET + " %s patients loaded. Ready.\n" % count)
+    return client, config
+
+
+def _run_query(client, query_text, output_format="table"):
+    """Execute a single query and display the result."""
+    query_upper = query_text.strip().upper()
+
+    # Detect async operations (upload/export) that need job polling
+    is_upload = query_upper.startswith("UPLOAD ") or query_upper.startswith("INGEST ")
+    is_export = query_upper.startswith("EXPORT ")
+
+    try:
+        result = client.query(query_text)
+    except PermissionError as e:
+        sys.stderr.write("  Permission denied: %s\n" % str(e))
+        return
+    except RuntimeError as e:
+        sys.stderr.write("  %s\n" % str(e))
+        return
+    except Exception as e:
+        sys.stderr.write("  Error: %s\n" % str(e))
+        return
+
+    # Handle async jobs
+    job_id = result.get("job_id")
+    if job_id and (is_upload or is_export):
+        endpoint = "ingest_gql" if is_upload else "export"
+        print("  Job started: %s" % job_id)
+        print("  Patients: %s" % result.get("patients", result.get("num_patients", "?")))
+        print()
+        final = client.poll_job(endpoint, job_id, callback=print_job_progress)
+        print()
+        if final.get("errors"):
+            for err in final["errors"]:
+                sys.stderr.write("  Error: %s - %s\n" % (
+                    err.get("patient_id", "?"), err.get("error", "?")))
+        elapsed = final.get("completed_at", 0) - final.get("started_at", 0)
+        if elapsed > 0:
+            print("  Completed in %.1fs" % elapsed)
+        return
+
+    display_result(result, output_format)
+
+
+def _repl(client, config):
+    """Interactive REPL loop."""
+    while True:
+        try:
+            query = input(CYAN + "seashell> " + RESET).strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\n  Goodbye.")
+            break
+
+        if not query:
+            continue
+
+        lower = query.lower()
+
+        if lower in ("exit", "quit", "q"):
+            print("  Goodbye.")
+            break
+        elif lower == "help":
+            print(HELP_TEXT)
+        elif lower == "status":
+            print("  Server:      %s" % config.get("server", "?"))
+            print("  Institution: %s" % config.get("institution", "?"))
+            print("  User:        %s" % config.get("email", "?"))
+            health = client.health()
+            if health:
+                print("  Patients:    %s" % health.get("patient_count", "?"))
+                print("  Engine:      %s" % health.get("status", "?"))
+            else:
+                print("  Server:      unreachable")
+        elif lower == "logout":
+            clear_config()
+            print("  Credentials cleared. Run 'seashell' to log in again.")
+            break
+        else:
+            _run_query(client, query)
+
+
+def main():
+    """Entry point for the seashell CLI."""
+    args = sys.argv[1:]
+
+    # --help flag
+    if args and args[0] in ("--help", "-h"):
+        print("Usage:")
+        print("  seashell                              Interactive mode")
+        print("  seashell \"LIST PATIENTS\"               Single query")
+        print("  seashell --server URL                  Set server URL")
+        print("  seashell --format json \"LIST PATIENTS\" Output as JSON")
+        print()
+        print(HELP_TEXT)
+        return
+
+    # Parse flags
+    server_override = None
+    output_format = "table"
+    query_parts = []
+
+    i = 0
+    while i < len(args):
+        if args[i] == "--server" and i + 1 < len(args):
+            server_override = args[i + 1]
+            i += 2
+        elif args[i] == "--format" and i + 1 < len(args):
+            output_format = args[i + 1]
+            i += 2
+        elif args[i] == "--json":
+            output_format = "json"
+            i += 1
+        elif args[i] == "--tsv":
+            output_format = "tsv"
+            i += 1
+        else:
+            query_parts.append(args[i])
+            i += 1
+
+    # Apply server override
+    if server_override:
+        config = load_config()
+        config["server"] = server_override
+        save_config(config)
+
+    if query_parts:
+        # Single query mode
+        query_text = " ".join(query_parts)
+        config = load_config()
+        if not config.get("api_key"):
+            # Not logged in — prompt first
+            client, config = _prompt_login()
+        else:
+            client = SeashellClient(
+                config.get("server", DEFAULT_SERVER),
+                config["api_key"])
+        _run_query(client, query_text, output_format)
+    else:
+        # Interactive mode
+        client, config = _prompt_login()
+        _repl(client, config)
+
+
+if __name__ == "__main__":
+    main()

seashell/client.py

@@ -0,0 +1,81 @@
+"""HTTP client for the Seashell API."""
+
+import json
+import sys
+import threading
+import time
+
+import requests
+
+
+class SeashellClient(object):
+    def __init__(self, server_url, api_key):
+        self.server = server_url.rstrip("/")
+        self.api_key = api_key
+        self.session = requests.Session()
+        self.session.headers["X-API-Key"] = api_key
+
+    def query(self, query_text):
+        """Send a GQL query and return the result dict."""
+        resp = self.session.post(
+            self.server + "/query",
+            json={"query": query_text},
+            timeout=600,
+        )
+        if resp.status_code == 403:
+            raise PermissionError(resp.json().get("detail", "Access denied"))
+        if resp.status_code == 429:
+            retry = resp.headers.get("Retry-After", "60")
+            raise RuntimeError("Rate limited. Try again in %s seconds." % retry)
+        if resp.status_code != 200:
+            detail = ""
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            raise RuntimeError("Query failed (%d): %s" % (resp.status_code, detail))
+        return resp.json()
+
+    def health(self):
+        """Check server health. Returns dict with status, patient_count, etc."""
+        try:
+            resp = self.session.get(self.server + "/health", timeout=10)
+            if resp.status_code == 200:
+                return resp.json()
+        except Exception:
+            pass
+        return None
+
+    def wake(self):
+        """Pre-warm the institution's EC2 instance. Fire-and-forget."""
+        def _wake():
+            try:
+                self.session.post(self.server + "/wake", timeout=5)
+            except Exception:
+                pass
+        t = threading.Thread(target=_wake, daemon=True)
+        t.start()
+
+    def poll_job(self, endpoint, job_id, callback=None):
+        """Poll an async job (export/upload) until completion.
+
+        Args:
+            endpoint: "export" or "ingest_gql"
+            job_id: the job ID returned by the initial request
+            callback: optional function called with job dict on each poll
+        """
+        url = "%s/%s/%s" % (self.server, endpoint, job_id)
+        while True:
+            try:
+                resp = self.session.get(url, timeout=30)
+                if resp.status_code != 200:
+                    return {"status": "error", "detail": resp.text}
+                job = resp.json()
+                if callback:
+                    callback(job)
+                status = job.get("status", "")
+                if status in ("complete", "complete_with_errors", "error", "failed"):
+                    return job
+            except Exception as e:
+                sys.stderr.write("Poll error: %s\n" % str(e))
+            time.sleep(3)

seashell/config.py

@@ -0,0 +1,39 @@
+"""Configuration management — stores credentials in ~/.seashell/config.json."""
+
+import json
+import os
+import stat
+
+CONFIG_DIR = os.path.expanduser("~/.seashell")
+CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")
+
+DEFAULT_SERVER = "https://seashell.bio"
+
+
+def load_config():
+    """Load saved config, or return empty dict if none exists."""
+    if not os.path.exists(CONFIG_FILE):
+        return {}
+    try:
+        with open(CONFIG_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+
+def save_config(config):
+    """Save config to disk with owner-only permissions (contains API key)."""
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)
+    # Set file permissions to 600 (owner read/write only)
+    try:
+        os.chmod(CONFIG_FILE, stat.S_IRUSR | stat.S_IWUSR)
+    except OSError:
+        pass  # Windows doesn't support chmod
+
+
+def clear_config():
+    """Remove saved credentials."""
+    if os.path.exists(CONFIG_FILE):
+        os.remove(CONFIG_FILE)

seashell/display.py

@@ -0,0 +1,220 @@
+"""Output formatting for query results."""
+
+import json
+import sys
+
+
+def display_result(result, output_format="table"):
+    """Display a query result in the requested format."""
+    if "error" in result:
+        sys.stderr.write("Error: %s\n" % result["error"])
+        return
+
+    if output_format == "json":
+        print(json.dumps(result, indent=2))
+        return
+
+    if output_format == "tsv":
+        _print_tsv(result)
+        return
+
+    action = result.get("action", "")
+    latency = result.get("latency_ms", "?")
+
+    if action == "compare_patients":
+        _print_compare(result, latency)
+    elif action == "find_similar":
+        _print_similar(result, latency)
+    elif action in ("list_patients", "find_patients", "count_patients"):
+        _print_patients(result, action, latency)
+    elif action in ("find_variants", "count_variants"):
+        _print_variants(result, action, latency)
+    elif action == "list_genes":
+        print("\n  %s genes loaded" % result.get("count", "?"))
+        print("  %s ms" % latency)
+    elif action == "diff_patients":
+        _print_diff(result, latency)
+    elif action == "pca":
+        _print_pca(result, latency)
+    elif action in ("coverage", "qc", "pileup"):
+        _print_analytics(result, action, latency)
+    elif action == "delete_patient":
+        print("\n  Patient %s deleted." % result.get("patient_id", "?"))
+        print("  %s ms" % latency)
+    else:
+        print(json.dumps(result, indent=2))
+
+
+def _print_compare(result, latency):
+    print("\n  %s vs %s" % (result.get("patient_a", "?"), result.get("patient_b", "?")))
+    print("  Jaccard similarity:      %s" % result.get("jaccard_similarity", "?"))
+    shared = result.get("shared_variants_estimate", result.get("shared_variants", "?"))
+    print("  Shared variants (est):   %s" % shared)
+    unique_a = result.get("unique_to_a_estimate", result.get("unique_to_a", "?"))
+    unique_b = result.get("unique_to_b_estimate", result.get("unique_to_b", "?"))
+    print("  Unique to A (est):       %s" % unique_a)
+    print("  Unique to B (est):       %s" % unique_b)
+    if result.get("note"):
+        print("  Note: %s" % result["note"])
+    print("\n  %s ms" % latency)
+
+
+def _print_similar(result, latency):
+    print("\n  Most similar to %s:\n" % result.get("patient", "?"))
+    print("  %-15s %10s" % ("PATIENT", "JACCARD"))
+    print("  %s %s" % ("-" * 15, "-" * 10))
+    for r in result.get("results", []):
+        print("  %-15s %10s" % (r["patient_id"], r["jaccard_similarity"]))
+    print("\n  %s results | %s ms" % (result.get("count", 0), latency))
+
+
+def _print_patients(result, action, latency):
+    results = result.get("results", [])
+    count = result.get("count", 0)
+    total = result.get("total", count)
+
+    if action == "count_patients":
+        print("\n  %s of %s patients" % (count, total))
+        print("  %s ms" % latency)
+        return
+
+    if not results:
+        print("\n  0 patients found | %s ms" % latency)
+        return
+
+    has_variants = "variants" in results[0]
+    has_matching = "matching_variants" in results[0]
+    has_parent = "parent" in results[0]
+
+    print()
+    if has_variants and has_parent:
+        print("  %-15s %10s %-15s" % ("PATIENT", "VARIANTS", "PARENT"))
+        print("  %s %s %s" % ("-" * 15, "-" * 10, "-" * 15))
+        for r in results:
+            parent = r.get("parent") or "GRCh38"
+            print("  %-15s %10s %-15s" % (r["patient_id"], r["variants"], parent))
+    elif has_matching:
+        print("  %-15s %10s" % ("PATIENT", "MATCHING"))
+        print("  %s %s" % ("-" * 15, "-" * 10))
+        for r in results:
+            print("  %-15s %10s" % (r["patient_id"], r["matching_variants"]))
+    else:
+        print("  %-15s" % "PATIENT")
+        print("  %s" % ("-" * 15))
+        for r in results:
+            print("  %-15s" % r["patient_id"])
+
+    print("\n  %s patients | %s ms" % (count, latency))
+
+
+def _print_variants(result, action, latency):
+    results = result.get("results", [])
+    count = result.get("count", 0)
+
+    if action == "count_variants":
+        print("\n  %s variants" % count)
+        print("  %s ms" % latency)
+        return
+
+    if not results:
+        print("\n  0 variants found | %s ms" % latency)
+        return
+
+    has_sig = any("significance" in r for r in results)
+    has_gene = any("gene" in r for r in results)
+    has_rs = any("rs_id" in r for r in results)
+
+    print()
+    header = "  %-8s %12s %-6s %-6s" % ("CHROM", "POS", "REF", "ALT")
+    if has_gene:
+        header += " %-12s" % "GENE"
+    if has_sig:
+        header += " %-20s" % "SIGNIFICANCE"
+    if has_rs:
+        header += " %-15s" % "RS_ID"
+    print(header)
+    print("  %s" % ("-" * (len(header) - 2)))
+
+    for r in results:
+        line = "  %-8s %12s %-6s %-6s" % (
+            r.get("chrom", ""), r.get("pos", 0), r.get("ref", ""), r.get("alt", ""))
+        if has_gene:
+            line += " %-12s" % r.get("gene", "")
+        if has_sig:
+            line += " %-20s" % r.get("significance", "")
+        if has_rs:
+            line += " %-15s" % r.get("rs_id", "")
+        print(line)
+
+    print("\n  %s variants | %s ms" % (count, latency))
+
+
+def _print_diff(result, latency):
+    print("\n  %s vs %s" % (result.get("patient_a", "?"), result.get("patient_b", "?")))
+    print("  Only in A: %s variants" % result.get("only_in_a", "?"))
+    print("  Only in B: %s variants" % result.get("only_in_b", "?"))
+    print("  Shared:    %s variants" % result.get("shared", "?"))
+    print("\n  %s ms" % latency)
+
+
+def _print_pca(result, latency):
+    components = result.get("components", [])
+    print("\n  PCA (%s components, %s patients)\n" % (
+        result.get("n_components", "?"), result.get("n_patients", "?")))
+    print("  %-15s %10s %10s %10s" % ("PATIENT", "PC1", "PC2", "PC3"))
+    print("  %s %s %s %s" % ("-" * 15, "-" * 10, "-" * 10, "-" * 10))
+    for c in components:
+        coords = c.get("coordinates", [0, 0, 0])
+        pc1 = "%.4f" % coords[0] if len(coords) > 0 else ""
+        pc2 = "%.4f" % coords[1] if len(coords) > 1 else ""
+        pc3 = "%.4f" % coords[2] if len(coords) > 2 else ""
+        print("  %-15s %10s %10s %10s" % (c.get("patient_id", ""), pc1, pc2, pc3))
+    print("\n  %s ms" % latency)
+
+
+def _print_analytics(result, action, latency):
+    if action == "coverage":
+        print("\n  Coverage: %s" % result.get("mean_coverage", "?"))
+        print("  Region: %s" % result.get("region", "?"))
+    elif action == "qc":
+        for key in ("total_reads", "mapped_reads", "duplicate_reads", "mean_mapq",
+                     "mean_insert_size"):
+            if key in result:
+                print("  %s: %s" % (key, result[key]))
+    elif action == "pileup":
+        depths = result.get("depths", [])
+        print("\n  Pileup: %s positions" % len(depths))
+    print("\n  %s ms" % latency)
+
+
+def _print_tsv(result):
+    results = result.get("results", [])
+    if not results:
+        return
+    keys = list(results[0].keys())
+    print("\t".join(keys))
+    for r in results:
+        print("\t".join(str(r.get(k, "")) for k in keys))
+
+
+def print_job_progress(job):
+    """Print progress for async jobs (upload/export)."""
+    status = job.get("status", "?")
+    completed = job.get("patients_completed", 0)
+    total = job.get("patients_total", job.get("num_patients", "?"))
+    errors = len(job.get("errors", []))
+
+    line = "\r  Progress: %s/%s" % (completed, total)
+    if errors:
+        line += " (%s errors)" % errors
+    if status in ("complete", "complete_with_errors"):
+        line += " - Done"
+    sys.stdout.write(line)
+    sys.stdout.flush()
+
+    if status in ("complete", "complete_with_errors"):
+        print()  # newline after progress
+        if job.get("errors"):
+            for err in job["errors"]:
+                sys.stderr.write("  Error: %s — %s\n" % (
+                    err.get("patient_id", "?"), err.get("error", "?")))

seashell/help.py

@@ -0,0 +1,65 @@
+"""Help text for the Seashell CLI."""
+
+HELP_TEXT = """
+QUERY COMMANDS
+  FIND VARIANTS WHERE ...          Search variants by gene, significance, patient
+  FIND PATIENTS WHERE ...          Find patients matching criteria
+  COUNT VARIANTS WHERE ...         Count matching variants
+  COUNT PATIENTS WHERE ...         Count matching patients
+  LIST PATIENTS                    List all patients in your institution
+  COMPARE patient1 VS patient2     Compare variants between two patients
+  DIFF patient1 VS patient2        Exact variant-level differences
+  FIND SIMILAR patient TOP n       Find genetically similar patients
+  PCA                              Principal component analysis
+
+UPLOAD
+  UPLOAD PATIENT id CRAM s3://path VCF s3://path    Upload from aligned CRAM/BAM
+  UPLOAD PATIENT id FASTQ s3://R1 s3://R2           Upload from raw FASTQ
+  UPLOAD BATCH s3://manifest.json                   Batch upload from manifest
+
+EXPORT
+  EXPORT PATIENT id FORMAT CRAM                     Export as CRAM
+  EXPORT PATIENT id FORMAT BAM                      Export as BAM
+  EXPORT PATIENT id FORMAT BAM REGION chr17:41M-42M Export a region
+  EXPORT PATIENTS WHERE gene=BRCA1 FORMAT CRAM      Export by criteria
+
+ANALYTICS
+  COVERAGE patient chr:start-end   Read depth across a region
+  QC patient                       Quality control metrics
+  PILEUP patient chr:pos-pos       Base-level pileup
+
+MANAGEMENT
+  DELETE PATIENT id                Remove a patient (admin only)
+
+FILTERS
+  gene=BRCA1                       Gene name
+  significance=pathogenic          ClinVar significance
+  chromosome=chr17                 Chromosome
+  patient=NA12878                  Patient ID
+  age>50                           Phenotype filters (age, sex, ancestry)
+
+CLI COMMANDS
+  help          Show this message
+  status        Connection info and patient count
+  logout        Clear saved credentials and log out
+  exit          Quit Seashell
+""".strip()
+
+
+# ANSI color codes (work on macOS, Linux, and most Windows terminals)
+CYAN = "\033[36m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+RESET = "\033[0m"
+WHITE = "\033[97m"
+BLUE = "\033[34m"
+
+
+def welcome_banner():
+    """Return the colored welcome banner."""
+    lines = []
+    lines.append("")
+    lines.append(BOLD + WHITE + "  Welcome to Seashell" + RESET)
+    lines.append(DIM + "  Genomic data, compressed and queryable." + RESET)
+    lines.append("")
+    return "\n".join(lines)

seashell_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: seashell-cli
+Version: 0.1.0
+Summary: Seashell — Genomic data, compressed and queryable
+License: Proprietary
+Project-URL: Homepage, https://seashell.bio
+Project-URL: Documentation, https://seashell.bio/docs
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+
+# Seashell CLI
+
+Command-line tool for querying and managing genomic data on Seashell.
+
+## Install
+
+```bash
+pip install seashell-cli
+```
+
+## Quick Start
+
+```bash
+seashell
+```
+
+You'll be prompted for your API key (from your institution admin), username, and password. After login, you're in an interactive shell:
+
+```
+seashell> LIST PATIENTS
+seashell> FIND VARIANTS WHERE patient=NA12878 AND gene=BRCA1
+seashell> EXPORT PATIENT NA12878 FORMAT CRAM
+```
+
+## Single Query Mode
+
+```bash
+seashell "FIND PATIENTS WHERE gene=BRCA1 AND significance=pathogenic"
+seashell "COUNT VARIANTS WHERE patient=NA12878"
+seashell --format json "LIST PATIENTS"
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `FIND VARIANTS WHERE ...` | Search variants by gene, significance, patient |
+| `FIND PATIENTS WHERE ...` | Find patients matching criteria |
+| `COUNT VARIANTS/PATIENTS WHERE ...` | Count matches |
+| `LIST PATIENTS` | List all patients |
+| `COMPARE p1 VS p2` | Compare two patients |
+| `UPLOAD PATIENT id CRAM s3://...` | Upload from CRAM/BAM |
+| `UPLOAD PATIENT id FASTQ s3://R1 s3://R2` | Upload from raw FASTQ |
+| `EXPORT PATIENT id FORMAT CRAM` | Export as CRAM/BAM |
+| `DELETE PATIENT id` | Remove a patient |
+| `help` | Show all commands |
+
+## Requirements
+
+- Python 3.8+
+- A Seashell API key (contact your institution admin)
+
+## Documentation
+
+https://seashell.bio/docs

seashell_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+seashell/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+seashell/__main__.py,sha256=XhE9FKo-gIuxWH721IudDczuFdCoGbwAmOhdhsDWwN4,37
+seashell/cli.py,sha256=6QNyGBXSpl7ZWMGXG9VSOOB4jGbTuneop-_hIL_kozQ,7760
+seashell/client.py,sha256=lZFAvISGLA_lGkpQbwTPTXFLDZDDoIVoVO4s475goUs,2833
+seashell/config.py,sha256=5Xl7sjgIcweTXe11R9oLFomI5HsTz7f_Vbi8pwQwIqc,1092
+seashell/display.py,sha256=4tjLOv0cDyqvhFd801UfAo1ISjxlfro-RPhXpZgdafI,7902
+seashell/help.py,sha256=D3wkgzD8z6t0a2C0fie3OqNAZg-yGctnuHSn3KK10UM,2408
+seashell_cli-0.1.0.dist-info/METADATA,sha256=70KCWsm2NYNX8MpH-aC8FENkV_fYlezB3plHM19U-8Y,1908
+seashell_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+seashell_cli-0.1.0.dist-info/entry_points.txt,sha256=ycyg5TvPoD8-LuEi5sn2VuUyh1gBnfD7pyE3ffMuUyY,47
+seashell_cli-0.1.0.dist-info/top_level.txt,sha256=gnaGngHOk7Oq6LRNqnXNFbfS9koSGu_HMyM3rT4Tq3w,9
+seashell_cli-0.1.0.dist-info/RECORD,,

seashell_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
+

seashell_cli-0.1.0.dist-info/entry_points.txt

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

seashell_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+seashell