celltype-cli 0.1.0__py3-none-any.whl

ct/tools/remote_data.py

@@ -0,0 +1,179 @@
+"""
+Remote data query tool — queries the hosted ct Data API.
+
+Connects to a running ct Data API instance to query large datasets
+(PerturbAtlas, ChEMBL, scPerturb, etc.) that are too large for local download.
+
+Configure the endpoint with: ct config set api.data_endpoint http://host:8000
+Or set CT_DATA_ENDPOINT environment variable.
+"""
+
+import os
+import httpx
+from ct.tools import registry
+from ct.agent.config import Config
+
+
+def _get_endpoint() -> str | None:
+    """Get the configured data API endpoint."""
+    endpoint = os.environ.get("CT_DATA_ENDPOINT")
+    if endpoint:
+        return endpoint.rstrip("/")
+    cfg = Config.load()
+    val = cfg.get("api.data_endpoint")
+    return val.rstrip("/") if val else None
+
+
+def _no_endpoint_error() -> dict:
+    return {
+        "error": "Data API endpoint not configured.",
+        "summary": (
+            "No data API endpoint configured. Set with: "
+            "ct config set api.data_endpoint http://your-host:8000 "
+            "or set CT_DATA_ENDPOINT environment variable."
+        ),
+    }
+
+
+@registry.register(
+    name="remote_data.query",
+    description="Query a dataset on the hosted ct Data API (PerturbAtlas, ChEMBL, etc.)",
+    category="remote_data",
+    parameters={
+        "dataset": "Dataset name (e.g. 'perturbatlas', 'chembl')",
+        "gene": "Filter by gene symbol (optional)",
+        "compound": "Filter by compound name/ID (optional)",
+        "filters": "Additional column filters as dict (optional)",
+        "limit": "Max rows to return (default 100, max 10000)",
+    },
+    usage_guide=(
+        "You need to query a large dataset that's hosted on the data API (PerturbAtlas, ChEMBL, "
+        "scPerturb). Use when the dataset is too large for local download. "
+        "Requires api.data_endpoint to be configured."
+    ),
+)
+def query(dataset: str, gene: str = None, compound: str = None,
+          filters: dict = None, limit: int = 100, **kwargs) -> dict:
+    """Query a dataset on the hosted Data API."""
+    endpoint = _get_endpoint()
+    if not endpoint:
+        return _no_endpoint_error()
+
+    payload = {"dataset": dataset, "limit": limit}
+    if gene:
+        payload["gene"] = gene
+    if compound:
+        payload["compound"] = compound
+    if filters:
+        payload["filters"] = filters
+
+    try:
+        resp = httpx.post(
+            f"{endpoint}/query",
+            json=payload,
+            timeout=30,
+        )
+
+        if resp.status_code == 404:
+            return {
+                "error": f"Dataset '{dataset}' not found on the data API.",
+                "summary": f"Dataset '{dataset}' is not available. Use remote_data.list_datasets to see what's available.",
+            }
+        if resp.status_code == 503:
+            return {
+                "error": f"Dataset '{dataset}' files not found on disk.",
+                "summary": f"Dataset '{dataset}' is registered but files are missing on the server.",
+            }
+        if resp.status_code != 200:
+            return {
+                "error": f"Data API error: HTTP {resp.status_code}",
+                "summary": f"Data API returned HTTP {resp.status_code}: {resp.text[:200]}",
+            }
+
+        data = resp.json()
+        rows = data.get("data", [])
+        total = data.get("total_rows", len(rows))
+
+        # Build summary
+        filter_desc = []
+        if gene:
+            filter_desc.append(f"gene={gene}")
+        if compound:
+            filter_desc.append(f"compound={compound}")
+        filter_str = f" ({', '.join(filter_desc)})" if filter_desc else ""
+
+        summary = f"Query {dataset}{filter_str}: {total} rows returned"
+        if rows:
+            cols = list(rows[0].keys())
+            summary += f". Columns: {', '.join(cols[:8])}"
+
+        return {
+            "summary": summary,
+            "dataset": dataset,
+            "total_rows": total,
+            "columns": list(rows[0].keys()) if rows else [],
+            "data": rows,
+        }
+
+    except httpx.ConnectError:
+        return {
+            "error": f"Cannot connect to Data API at {endpoint}",
+            "summary": f"Data API unreachable at {endpoint}. Check the server is running.",
+        }
+    except httpx.HTTPError as e:
+        return {
+            "error": f"Data API request failed: {e}",
+            "summary": f"Failed to query Data API: {e}",
+        }
+
+
+@registry.register(
+    name="remote_data.list_datasets",
+    description="List datasets available on the hosted ct Data API",
+    category="remote_data",
+    parameters={},
+    usage_guide=(
+        "You want to see what datasets are available on the configured data API. "
+        "Run this first to discover available data before querying."
+    ),
+)
+def list_datasets(**kwargs) -> dict:
+    """List datasets available on the Data API."""
+    endpoint = _get_endpoint()
+    if not endpoint:
+        return _no_endpoint_error()
+
+    try:
+        resp = httpx.get(f"{endpoint}/datasets", timeout=10)
+
+        if resp.status_code != 200:
+            return {
+                "error": f"Data API error: HTTP {resp.status_code}",
+                "summary": f"Failed to list datasets: HTTP {resp.status_code}",
+            }
+
+        datasets = resp.json()
+        if not datasets:
+            return {
+                "summary": "No datasets available on the Data API.",
+                "datasets": [],
+            }
+
+        names = [d["name"] for d in datasets]
+        summary = f"Data API has {len(datasets)} datasets: {', '.join(names)}"
+
+        return {
+            "summary": summary,
+            "datasets": datasets,
+        }
+
+    except httpx.ConnectError:
+        return {
+            "error": f"Cannot connect to Data API at {endpoint}",
+            "summary": f"Data API unreachable at {endpoint}. Check the server is running.",
+        }
+    except httpx.HTTPError as e:
+        return {
+            "error": f"Data API request failed: {e}",
+            "summary": f"Failed to list datasets: {e}",
+        }

ct/tools/report.py

@@ -0,0 +1,181 @@
+"""
+Report utility tools for decision-ready communication outputs.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+import re
+
+from ct.tools import registry
+
+
+def _slug(text: str, max_len: int = 64) -> str:
+    slug = re.sub(r"[^a-zA-Z0-9]+", "_", str(text or "").strip().lower()).strip("_")
+    return (slug or "pharma_brief")[:max_len]
+
+
+def _extract_evidence_lines(evidence) -> list[str]:
+    lines: list[str] = []
+    if evidence is None:
+        return lines
+    if isinstance(evidence, str):
+        for line in evidence.splitlines():
+            line = line.strip()
+            if line:
+                lines.append(line)
+        return lines
+    if isinstance(evidence, dict):
+        if evidence.get("summary"):
+            lines.append(str(evidence["summary"]))
+        for key in ("key_evidence", "evidence", "findings", "signals"):
+            value = evidence.get(key)
+            if isinstance(value, list):
+                for item in value:
+                    lines.append(str(item))
+        return lines
+    if isinstance(evidence, list):
+        for item in evidence:
+            if isinstance(item, dict):
+                if "summary" in item:
+                    lines.append(str(item["summary"]))
+                else:
+                    lines.append(str(item))
+            else:
+                lines.append(str(item))
+    return [x.strip() for x in lines if str(x).strip()]
+
+
+@registry.register(
+    name="report.pharma_brief",
+    description="Generate a one-page pharma decision brief and optionally save as markdown/HTML",
+    category="report",
+    parameters={
+        "query": "Original research question or program objective",
+        "program_thesis": "Concise recommendation statement",
+        "target_rationale": "Mechanistic rationale (optional)",
+        "biomarker_strategy": "Biomarker/patient-selection strategy (optional)",
+        "safety_review": "Top liabilities and mitigation strategy (optional)",
+        "competitive_differentiation": "Differentiation thesis vs landscape (optional)",
+        "evidence": "Optional evidence payload (string/list/dict) to anchor key bullets",
+        "save": "Whether to save markdown brief to output directory (default True)",
+        "publish_html": "Whether to also publish a shareable HTML page (default True)",
+        "filename": "Optional output filename stem",
+    },
+    usage_guide=(
+        "Use at the end of an analysis to create a board/investor/pharma-partner-ready brief "
+        "with explicit thesis, risk, and differentiation framing."
+    ),
+)
+def pharma_brief(
+    query: str,
+    program_thesis: str = "",
+    target_rationale: str = "",
+    biomarker_strategy: str = "",
+    safety_review: str = "",
+    competitive_differentiation: str = "",
+    evidence=None,
+    save: bool = True,
+    publish_html: bool = True,
+    filename: str = "",
+    _session=None,
+    **kwargs,
+) -> dict:
+    """Create a decision-ready pharma brief and optionally persist it."""
+    del kwargs
+    query = (query or "").strip()
+    if not query:
+        return {"summary": "query is required.", "error": "missing_query"}
+
+    thesis = (program_thesis or "").strip() or "Recommendation pending deeper evidence synthesis."
+    target_rationale = (target_rationale or "").strip() or "Mechanism rationale not yet specified."
+    biomarker_strategy = (biomarker_strategy or "").strip() or "Biomarker strategy not yet specified."
+    safety_review = (safety_review or "").strip() or "Safety review pending."
+    competitive_differentiation = (
+        (competitive_differentiation or "").strip()
+        or "Differentiation statement pending competitor benchmarking."
+    )
+
+    evidence_lines = _extract_evidence_lines(evidence)[:12]
+
+    generated_at = datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC")
+    md_lines = [
+        f"# Pharma Brief: {query}",
+        "",
+        f"*Generated by celltype-cli on {generated_at}*",
+        "",
+        "## Program Thesis",
+        thesis,
+        "",
+        "## Target / Mechanism Rationale",
+        target_rationale,
+        "",
+        "## Biomarker / Patient Stratification",
+        biomarker_strategy,
+        "",
+        "## Safety / Liability Review",
+        safety_review,
+        "",
+        "## Competitive Landscape & Differentiation",
+        competitive_differentiation,
+        "",
+        "## Key Evidence Highlights",
+    ]
+
+    if evidence_lines:
+        for line in evidence_lines:
+            md_lines.append(f"- {line}")
+    else:
+        md_lines.append("- No structured evidence payload provided.")
+    md_lines.extend(
+        [
+            "",
+            "## Suggested Next Decisions",
+            "1. Confirm go/no-go assumptions with one orthogonal dataset.",
+            "2. Define a first-in-human stratification + endpoint strategy.",
+            "3. Quantify competitive differentiation against active Phase 2/3 programs.",
+        ]
+    )
+    markdown = "\n".join(md_lines)
+
+    output_md = None
+    output_html = None
+
+    if save:
+        output_base = None
+        if _session is not None and getattr(_session, "config", None) is not None:
+            output_base = _session.config.get("sandbox.output_dir")
+        out_dir = (
+            Path(output_base) / "reports"
+            if output_base
+            else Path.cwd() / "outputs" / "reports"
+        )
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+        stem = _slug(filename or query)
+        output_md = out_dir / f"{stem}_pharma_brief.md"
+        counter = 2
+        while output_md.exists():
+            output_md = out_dir / f"{stem}_pharma_brief_{counter}.md"
+            counter += 1
+        output_md.write_text(markdown, encoding="utf-8")
+
+        if publish_html:
+            from ct.reports.html import publish_report
+
+            output_html = publish_report(output_md)
+
+    summary = (
+        f"Generated pharma brief for '{query}'."
+        + (f" Saved: {output_md}" if output_md else "")
+        + (f" HTML: {output_html}" if output_html else "")
+    )
+
+    return {
+        "summary": summary,
+        "query": query,
+        "markdown": markdown,
+        "markdown_path": str(output_md) if output_md else None,
+        "html_path": str(output_html) if output_html else None,
+    }