seashell-sdk 0.1.0__tar.gz

seashell_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: seashell-sdk
+Version: 0.1.0
+Summary: Seashell Python SDK — programmatic access to compressed genomic data
+License: MIT
+Project-URL: Homepage, https://seashell.bio
+Project-URL: Documentation, https://seashell.bio/docs/sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28

seashell_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "seashell-sdk"
+version = "0.1.0"
+description = "Seashell Python SDK — programmatic access to compressed genomic data"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+dependencies = ["requests>=2.28"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+Homepage = "https://seashell.bio"
+Documentation = "https://seashell.bio/docs/sdk"

seashell_sdk-0.1.0/seashell_sdk/__init__.py

@@ -0,0 +1,84 @@
+"""Seashell Python SDK.
+
+Quick start:
+    from seashell_sdk import connect
+
+    client = connect(
+        api_key="sk_...",
+        email="researcher@myinstitution.com",
+        password="...",
+    )
+
+    variants = client.find_variants("NA12878", gene="BRCA1", gnomad_af="<0.001")
+    for v in variants:
+        print(v["chrom"], v["pos"], v["ref"], v["alt"], v.get("gnomad_af"))
+
+Or use the raw GQL interface:
+    result = client.query("FIND VARIANTS WHERE patient=NA12878 AND lof=true")
+    print(result["count"], result["results"])
+"""
+
+from seashell_sdk.client import SeashellClient, WakeJob
+from seashell_sdk.config import DEFAULT_SERVER, load_config
+from seashell_sdk.exceptions import (
+    SeashellError, AuthError, RateLimitError, QueryError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "connect",
+    "SeashellClient",
+    "WakeJob",
+    "SeashellError",
+    "AuthError",
+    "RateLimitError",
+    "QueryError",
+    "__version__",
+]
+
+
+def connect(api_key=None, email=None, password=None, server=None):
+    """Create a SeashellClient, authenticate, and return it ready to query.
+
+    Args:
+        api_key:  Institution API key (sk_...). If None, reads from
+                  SEASHELL_API_KEY environment variable.
+        email:    Researcher email or username.
+        password: Researcher password.
+        server:   API server URL. Defaults to saved config or seashell.bio.
+
+    Returns:
+        Authenticated SeashellClient.
+
+    Raises:
+        AuthError: if credentials are invalid.
+        SeashellError: if the server is unreachable.
+
+    Example:
+        import os
+        client = connect(
+            api_key=os.environ["SEASHELL_API_KEY"],
+            email="researcher",
+            password="...",
+        )
+    """
+    import os
+
+    if api_key is None:
+        api_key = os.environ.get("SEASHELL_API_KEY")
+    if not api_key:
+        raise AuthError(
+            "No API key provided. Pass api_key= or set SEASHELL_API_KEY env var."
+        )
+
+    if server is None:
+        config = load_config()
+        server = config.get("server", DEFAULT_SERVER)
+
+    client = SeashellClient(server, api_key)
+
+    if email and password:
+        client.login(email, password)
+
+    return client

seashell_sdk-0.1.0/seashell_sdk/client.py

@@ -0,0 +1,506 @@
+"""HTTP client for the Seashell API.
+
+Low-level:
+  - SeashellClient.query(gql_string) → dict        raw GQL passthrough
+  - SeashellClient.login(email, password) → dict
+  - SeashellClient.health() → dict
+  - SeashellClient.wake() → WakeJob
+
+High-level convenience methods (build GQL, call query(), return results):
+  - find_variants(patient, gene=, **filters) → list[dict]
+  - count_variants(patient, **filters) → int
+  - list_patients() → list[dict]
+  - find_patients(**filters) → list[dict]
+  - count_patients(**filters) → int
+  - compare_patients(id1, id2) → dict
+  - diff_patients(id1, id2) → dict
+  - curate_variant(variant, classification, note=) → dict
+  - list_curations(**filters) → list[dict]
+  - show_curation_history(variant) → dict
+  - export_vcf(patient, region=) → dict
+  - export_cram(patient, region=) → dict
+  - find_similar(patient) → list[dict]
+  - pca_patients() → dict
+  - ancestry(patient) → dict
+  - qc(patient) → dict
+  - coverage(patient, region) → dict
+  - kinship(unexpected=False, limit=None) → dict
+  - mendelian_trio(mom, dad, child) → dict
+"""
+
+import sys
+import threading
+import time
+
+import requests
+
+from seashell_sdk.exceptions import (
+    AuthError, RateLimitError, QueryError, SeashellError,
+    PermissionError as SeashellPermissionError,
+)
+
+
+class WakeJob(object):
+    """Background-pollable wake-on-key job.
+
+    The CLI uses is_ready() and wait_until_ready() to block on the wake
+    completing. The poll runs in a daemon thread so it doesn't block stdin
+    while the user is typing a password.
+    """
+    def __init__(self, client, initial_state):
+        self.client = client
+        self.state = initial_state.get("status", "unknown")
+        self.eta = int(initial_state.get("eta", 30))
+        self.error = None
+        self._lock = threading.Lock()
+        self._done = threading.Event()
+        self._thread = None
+        if self.state == "running":
+            self._done.set()
+        if initial_state.get("mode") == "single_instance":
+            self.state = "running"
+            self._done.set()
+
+    def start_poll(self, max_seconds=120, interval=2.0):
+        """Start background polling thread. Idempotent."""
+        if self._thread is not None or self._done.is_set():
+            return
+        self._thread = threading.Thread(
+            target=self._poll, args=(max_seconds, interval), daemon=True)
+        self._thread.start()
+
+    def _poll(self, max_seconds, interval):
+        deadline = time.time() + max_seconds
+        wait = 1.0
+        while time.time() < deadline:
+            try:
+                resp = self.client.session.get(
+                    self.client.server + "/wake_status", timeout=5)
+                if resp.status_code == 200:
+                    j = resp.json()
+                    with self._lock:
+                        self.state = j.get("state", self.state)
+                    if j.get("state") == "running":
+                        self._done.set()
+                        return
+                elif resp.status_code == 404:
+                    self._done.set()
+                    return
+            except requests.exceptions.RequestException as e:
+                with self._lock:
+                    self.error = str(e)
+            time.sleep(min(wait, interval))
+            wait = min(wait * 1.5, interval)
+
+    def is_ready(self):
+        return self._done.is_set()
+
+    def wait_until_ready(self, timeout=None):
+        if not self._done.wait(timeout=timeout):
+            return False
+        return True
+
+
+def _build_filter_clause(filters):
+    """Convert a dict of filters to GQL AND clauses.
+
+    Handles two forms:
+      gene="BRCA1"         → "AND gene=BRCA1"
+      gnomad_af="<0.001"  → "AND gnomad_af<0.001"  (operator embedded in value)
+      lof=True             → "AND lof=true"
+    """
+    parts = []
+    for k, v in filters.items():
+        if v is None:
+            continue
+        v_str = str(v).lower() if isinstance(v, bool) else str(v)
+        # If value already starts with an operator, don't add =
+        if v_str and v_str[0] in ("<", ">", "!"):
+            parts.append("AND %s%s" % (k, v_str))
+        else:
+            parts.append("AND %s=%s" % (k, v_str))
+    return parts
+
+
+class SeashellClient(object):
+    def __init__(self, server_url, api_key):
+        self.server = server_url.rstrip("/")
+        self.api_key = api_key
+        self.session_token = None
+        self.session = requests.Session()
+        self.session.headers["X-API-Key"] = api_key
+
+    def set_session_token(self, token):
+        """Attach per-researcher session token to all subsequent requests."""
+        self.session_token = token
+        self.session.headers["X-Session-Token"] = token
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Core HTTP methods
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def query(self, query_text):
+        """Send a raw GQL query string and return the result dict.
+
+        This is the lowest-level method. All high-level methods call this.
+        Raises typed exceptions on error.
+        """
+        resp = self.session.post(
+            self.server + "/query",
+            json={"query": query_text},
+            timeout=600,
+        )
+        if resp.status_code == 401:
+            raise AuthError("Session expired or invalid credentials. Please log in again.")
+        if resp.status_code == 403:
+            raise SeashellPermissionError(resp.json().get("detail", "Access denied"))
+        if resp.status_code == 429:
+            retry = int(resp.headers.get("Retry-After", 60))
+            raise RateLimitError("Rate limited. Retry in %d seconds." % retry, retry_after=retry)
+        if resp.status_code != 200:
+            detail = ""
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            raise QueryError("Query failed (%d): %s" % (resp.status_code, detail))
+        result = resp.json()
+        if "error" in result:
+            raise QueryError(result["error"])
+        return result
+
+    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):
+        """Wake the institution's EC2. Returns WakeJob immediately (non-blocking)."""
+        try:
+            resp = self.session.post(self.server + "/wake", timeout=10)
+            if resp.status_code == 200:
+                return WakeJob(self, resp.json())
+            detail = ""
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            job = WakeJob(self, {"status": "error", "eta": 0})
+            job.error = "Wake failed (HTTP %d): %s" % (resp.status_code, detail[:200])
+            return job
+        except requests.exceptions.RequestException as e:
+            job = WakeJob(self, {"status": "error", "eta": 0})
+            job.error = "Cannot reach server at %s: %s" % (self.server, e)
+            return job
+
+    def login(self, email, password):
+        """Authenticate with email + password. Attaches session token for all future requests."""
+        resp = self.session.post(
+            self.server + "/auth/login",
+            json={"email": email, "password": password},
+            timeout=15,
+        )
+        if resp.status_code == 401:
+            raise AuthError("Invalid username or password.")
+        if resp.status_code != 200:
+            detail = ""
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            raise AuthError("Login failed (%d): %s" % (resp.status_code, detail))
+        body = resp.json()
+        token = body.get("token", "")
+        if not token:
+            raise AuthError("Login response missing session token")
+        self.set_session_token(token)
+        return body
+
+    def poll_job(self, endpoint, job_id, callback=None):
+        """Poll an async job (export/upload) until completion."""
+        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)
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Patient queries
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def list_patients(self):
+        """List all patients in your institution. Returns list of dicts."""
+        return self.query("LIST PATIENTS").get("results", [])
+
+    def list_genes(self):
+        """List all gene symbols in the database."""
+        return self.query("LIST GENES").get("results", [])
+
+    def find_patients(self, gene=None, disease=None, significance=None, limit=None, **filters):
+        """Find patients matching criteria.
+
+        Examples:
+          find_patients(gene="BRCA1", significance="pathogenic")
+          find_patients(disease="cardiomyopathy")
+          find_patients(gene="CFTR")
+        """
+        parts = ["FIND PATIENTS WHERE"]
+        if gene:
+            parts.append("gene=%s" % gene)
+        elif disease:
+            parts.append("disease=%s" % disease)
+        elif filters:
+            first_k, first_v = next(iter(filters.items()))
+            filters.pop(first_k)
+            parts.append("%s=%s" % (first_k, first_v))
+        else:
+            raise QueryError("find_patients requires at least one filter (gene=, disease=, etc.)")
+        parts.extend(_build_filter_clause(
+            {k: v for k, v in dict(significance=significance, **filters).items() if v is not None}
+        ))
+        q = " ".join(parts)
+        if limit:
+            q += " LIMIT %d" % limit
+        return self.query(q).get("results", [])
+
+    def count_patients(self, gene=None, significance=None, disease=None, **filters):
+        """Count patients matching criteria."""
+        parts = ["COUNT PATIENTS WHERE"]
+        if gene:
+            parts.append("gene=%s" % gene)
+        elif disease:
+            parts.append("disease=%s" % disease)
+        else:
+            raise QueryError("count_patients requires gene= or disease=")
+        if significance:
+            parts.append("AND significance=%s" % significance)
+        parts.extend(_build_filter_clause(filters))
+        return self.query(" ".join(parts)).get("count", 0)
+
+    def find_similar(self, patient, limit=10):
+        """Find patients genetically similar to the given patient."""
+        result = self.query("FIND SIMILAR TO patient=%s LIMIT %d" % (patient, limit))
+        return result.get("results", [])
+
+    def compare_patients(self, id1, id2):
+        """Jaccard similarity between two patients (fast, sketch-based)."""
+        return self.query("COMPARE PATIENTS %s AND %s" % (id1, id2))
+
+    def diff_patients(self, id1, id2):
+        """Exact variant differences between two patients."""
+        return self.query("DIFF PATIENTS %s AND %s" % (id1, id2))
+
+    def pca_patients(self):
+        """Principal component analysis across all patients."""
+        return self.query("PCA PATIENTS")
+
+    def kinship(self, unexpected=False, limit=None):
+        """Pairwise kinship pre-screen across cohort."""
+        q = "KINSHIP COHORT"
+        if unexpected:
+            q += " UNEXPECTED"
+        if limit:
+            q += " LIMIT %d" % limit
+        return self.query(q)
+
+    def mendelian_trio(self, mom, dad, child):
+        """De novo + inheritance partition for a declared trio."""
+        return self.query("MENDELIAN TRIO %s %s %s" % (mom, dad, child))
+
+    def delete_patient(self, patient_id):
+        """Soft-delete a patient (GDPR-compliant, preserves delta chain)."""
+        return self.query("DELETE PATIENT %s" % patient_id)
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Variant queries
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def find_variants(self, patient, gene=None, region=None, consequence=None,
+                      gnomad_af=None, gnomad_popmax=None, significance=None,
+                      lof=None, novel=None, rsid=None, curated=None,
+                      limit=None, **filters):
+        """Find variants for a patient with optional filters.
+
+        Examples:
+          find_variants("NA12878", gene="BRCA1")
+          find_variants("NA12878", gene="CFTR", gnomad_af="<0.001")
+          find_variants("NA12878", consequence="missense_variant", gnomad_af="<0.001")
+          find_variants("NA12878", lof=True)
+          find_variants("NA12878", curated="pathogenic")
+        """
+        parts = ["FIND VARIANTS WHERE patient=%s" % patient]
+        if gene:
+            parts.append("AND gene=%s" % gene)
+        if region:
+            parts.append("AND region=%s" % region)
+        if consequence:
+            parts.append("AND consequence=%s" % consequence)
+        if gnomad_af is not None:
+            v = str(gnomad_af)
+            parts.append("AND gnomad_af%s" % (v if v[0] in "<>!" else "=%s" % v))
+        if gnomad_popmax is not None:
+            v = str(gnomad_popmax)
+            parts.append("AND gnomad_popmax%s" % (v if v[0] in "<>!" else "=%s" % v))
+        if significance:
+            parts.append("AND significance=%s" % significance)
+        if lof is True:
+            parts.append("AND lof=true")
+        if novel is True:
+            parts.append("AND novel=true")
+        if rsid:
+            parts.append("AND rsid=%s" % rsid)
+        if curated:
+            parts.append("AND curated=%s" % curated)
+        parts.extend(_build_filter_clause(filters))
+        q = " ".join(parts)
+        if limit:
+            q += " LIMIT %d" % limit
+        return self.query(q).get("results", [])
+
+    def count_variants(self, patient, gene=None, gnomad_af=None, gnomad_popmax=None,
+                       consequence=None, lof=None, novel=None, significance=None,
+                       **filters):
+        """Count variants for a patient. Sub-millisecond for indexed filters.
+
+        Examples:
+          count_variants("NA12878")
+          count_variants("NA12878", gnomad_af="<0.001")
+          count_variants("NA12878", lof=True)
+          count_variants("NA12878", gene="BRCA1")
+        """
+        parts = ["COUNT VARIANTS WHERE patient=%s" % patient]
+        if gene:
+            parts.append("AND gene=%s" % gene)
+        if gnomad_af is not None:
+            v = str(gnomad_af)
+            parts.append("AND gnomad_af%s" % (v if v[0] in "<>!" else "=%s" % v))
+        if gnomad_popmax is not None:
+            v = str(gnomad_popmax)
+            parts.append("AND gnomad_popmax%s" % (v if v[0] in "<>!" else "=%s" % v))
+        if consequence:
+            parts.append("AND consequence=%s" % consequence)
+        if lof is True:
+            parts.append("AND lof=true")
+        if novel is True:
+            parts.append("AND novel=true")
+        if significance:
+            parts.append("AND significance=%s" % significance)
+        parts.extend(_build_filter_clause(filters))
+        return self.query(" ".join(parts)).get("count", 0)
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Curation
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def curate_variant(self, variant, classification, note=None):
+        """Classify a variant (pathogenic/likely_pathogenic/vus/likely_benign/benign).
+
+        Args:
+          variant: "chr17:43093011:G:GA" format
+          classification: "pathogenic", "likely_pathogenic", "vus", "likely_benign", "benign"
+          note: optional free-text note (e.g. ACMG criteria)
+        """
+        q = "CURATE VARIANT %s AS %s" % (variant, classification)
+        if note:
+            q += ' NOTE "%s"' % note.replace('"', "'")
+        return self.query(q)
+
+    def list_curations(self, gene=None, classification=None):
+        """List all curations for this institution, optionally filtered."""
+        parts = ["LIST CURATIONS"]
+        filters = {}
+        if gene:
+            filters["gene"] = gene
+        if classification:
+            filters["classification"] = classification
+        if filters:
+            first = True
+            for k, v in filters.items():
+                parts.append("WHERE" if first else "AND")
+                parts.append("%s=%s" % (k, v))
+                first = False
+        return self.query(" ".join(parts)).get("results", [])
+
+    def show_curation_history(self, variant):
+        """Full audit trail for a variant's curation history."""
+        return self.query("SHOW CURATION HISTORY %s" % variant)
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # QC / analytics
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def qc(self, patient):
+        """Quality-control metrics for a patient."""
+        return self.query("QC PATIENT %s" % patient)
+
+    def ancestry(self, patient):
+        """Predict super-population (EUR/EAS/SAS/AFR/AMR) for a patient."""
+        return self.query("ANCESTRY PATIENT %s" % patient)
+
+    def coverage(self, patient, region):
+        """Coverage statistics in a region (e.g. 'chr17:43044295-43125483')."""
+        return self.query("COVERAGE PATIENT %s REGION %s" % (patient, region))
+
+    def pileup(self, patient, position):
+        """Per-base pileup at one position (e.g. 'chr22:28698027')."""
+        return self.query("PILEUP PATIENT %s POSITION %s" % (patient, position))
+
+    def flagstat(self, patient):
+        """samtools flagstat equivalent (byte-identical, no decompression)."""
+        return self.query("FLAGSTAT PATIENT %s" % patient)
+
+    def sexcheck(self, patient):
+        """Infer biological sex from chrX/chrY coverage."""
+        return self.query("SEXCHECK PATIENT %s" % patient)
+
+    def insert_size(self, patient):
+        """Insert size distribution."""
+        return self.query("INSERT_SIZE PATIENT %s" % patient)
+
+    def cycle_quality(self, patient):
+        """Per-cycle base quality decay."""
+        return self.query("CYCLE_QUALITY PATIENT %s" % patient)
+
+    def contamination(self, patient):
+        """Sample-swap / contamination pre-screen."""
+        return self.query("CONTAMINATION PATIENT %s" % patient)
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Export
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def export_vcf(self, patient, region=None):
+        """Export variants as VCF. Returns dict with download URL."""
+        q = "EXPORT PATIENT %s FORMAT VCF" % patient
+        if region:
+            q += " REGION %s" % region
+        return self.query(q)
+
+    def export_cram(self, patient, region=None):
+        """Export as CRAM (requires CRAM upload). Returns dict with download URL."""
+        q = "EXPORT PATIENT %s FORMAT CRAM" % patient
+        if region:
+            q += " REGION %s" % region
+        return self.query(q)
+
+    def export_bam(self, patient, region=None):
+        """Export as BAM (requires CRAM upload). Returns dict with download URL."""
+        q = "EXPORT PATIENT %s FORMAT BAM" % patient
+        if region:
+            q += " REGION %s" % region
+        return self.query(q)

seashell_sdk-0.1.0/seashell_sdk/config.py

@@ -0,0 +1,43 @@
+"""Configuration management — stores server URL in ~/.seashell/config.json.
+
+Shared between seashell-sdk and seashell-cli so both tools read from the
+same location. Credentials (API key, session token) are never persisted —
+they live only in process memory.
+"""
+
+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."""
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)
+    try:
+        os.chmod(CONFIG_FILE, stat.S_IRUSR | stat.S_IWUSR)
+    except OSError:
+        pass  # Windows doesn't support chmod
+
+
+def clear_config():
+    """Remove saved config file."""
+    if os.path.exists(CONFIG_FILE):
+        os.remove(CONFIG_FILE)

seashell_sdk-0.1.0/seashell_sdk/exceptions.py

@@ -0,0 +1,28 @@
+"""Typed exceptions for the Seashell SDK."""
+
+
+class SeashellError(Exception):
+    """Base class for all Seashell SDK errors."""
+    pass
+
+
+class AuthError(SeashellError):
+    """Authentication failed — bad credentials or expired session token."""
+    pass
+
+
+class RateLimitError(SeashellError):
+    """Rate limit exceeded. Check the retry_after attribute."""
+    def __init__(self, message, retry_after=60):
+        super().__init__(message)
+        self.retry_after = retry_after
+
+
+class QueryError(SeashellError):
+    """Query failed — syntax error, invalid filter, or engine error."""
+    pass
+
+
+class PermissionError(SeashellError):
+    """Access denied — institution mismatch or insufficient role."""
+    pass

seashell_sdk-0.1.0/seashell_sdk.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: seashell-sdk
+Version: 0.1.0
+Summary: Seashell Python SDK — programmatic access to compressed genomic data
+License: MIT
+Project-URL: Homepage, https://seashell.bio
+Project-URL: Documentation, https://seashell.bio/docs/sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28

seashell_sdk-0.1.0/seashell_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+seashell_sdk/__init__.py
+seashell_sdk/client.py
+seashell_sdk/config.py
+seashell_sdk/exceptions.py
+seashell_sdk.egg-info/PKG-INFO
+seashell_sdk.egg-info/SOURCES.txt
+seashell_sdk.egg-info/dependency_links.txt
+seashell_sdk.egg-info/requires.txt
+seashell_sdk.egg-info/top_level.txt

seashell_sdk-0.1.0/seashell_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

seashell_sdk-0.1.0/seashell_sdk.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28

seashell_sdk-0.1.0/seashell_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+seashell_sdk

seashell_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+