open-pharma-plugins 2.2.0__py3-none-any.whl

open_pharma_plugins_competitive_intelligence/tools/ci_extract_events.py

@@ -0,0 +1,247 @@
+"""ci_extract_events — extract CI events from user-provided documents."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ExtractEventsArgs(BaseModel):
+    file_path: str = Field(description="Path to document: PDF, DOCX, TXT, CSV, or MD")
+    focus: list[str] | None = Field(
+        default=None,
+        description="Focus areas: trial_readout, regulatory, label_change, pricing, market_access, partnership",
+    )
+    therapeutic_area: str | None = Field(
+        default=None,
+        description="Therapeutic area context for relevance filtering",
+    )
+    max_pages: int = Field(default=50, ge=1, le=200, description="Max pages to process (PDF only)")
+
+
+TOOL: dict[str, Any] = {
+    "name": "ci_extract_events",
+    "description": (
+        "Extract structured competitive intelligence events from a document "
+        "(PDF, DOCX, TXT, CSV, Markdown). Uses heuristic pattern matching "
+        "to identify dates, company names, drug names, and event types. "
+        "Returns events in the common CIEvent schema."
+    ),
+    "args": ExtractEventsArgs,
+}
+
+_PHARMA_COMPANIES = {
+    "pfizer",
+    "merck",
+    "roche",
+    "novartis",
+    "johnson & johnson",
+    "j&j",
+    "astrazeneca",
+    "bristol-myers squibb",
+    "bms",
+    "eli lilly",
+    "lilly",
+    "abbvie",
+    "amgen",
+    "gilead",
+    "sanofi",
+    "gsk",
+    "glaxosmithkline",
+    "bayer",
+    "takeda",
+    "regeneron",
+    "biogen",
+    "moderna",
+    "vertex",
+    "seagen",
+    "incyte",
+    "jazz",
+    "daiichi sankyo",
+    "astellas",
+    "boehringer ingelheim",
+    "merck kgaa",
+    "shire",
+    "alexion",
+}
+
+_EVENT_PATTERNS = {
+    "approval": re.compile(r"(?:FDA|EMA|NMPA|PMDA|TGA)\s+(?:approved|grants?\s+approval|clearance)", re.IGNORECASE),
+    "trial_readout": re.compile(
+        r"(?:phase\s+[I1-4]+|pivotal)\s+(?:trial|study)\s+(?:met|missed|results?|data|readout)", re.IGNORECASE
+    ),
+    "regulatory_submission": re.compile(
+        r"(?:filed|submitted|submission|sNDA|sBLA|MAA|NDA|BLA)\s+(?:to|with|for)?\s*(?:FDA|EMA)?", re.IGNORECASE
+    ),
+    "label_change": re.compile(
+        r"label\s+(?:change|update|revision|expansion)|new\s+indication|supplemental\s+approval", re.IGNORECASE
+    ),
+    "partnership": re.compile(
+        r"(?:partnership|collaboration|licensing|co-development|acquisition|merger|deal)\s+(?:with|between|agreement)?",
+        re.IGNORECASE,
+    ),
+    "pricing": re.compile(
+        r"(?:list\s+price|WAC|launch\s+price|pricing\s+(?:strategy|decision|announcement)|reimbursement\s+(?:decision|approval))",
+        re.IGNORECASE,
+    ),
+    "discontinuation": re.compile(
+        r"(?:discontinue|terminate|halt|suspend|withdraw)\w*\s+(?:trial|study|program|development)", re.IGNORECASE
+    ),
+}
+
+_DATE_PATTERN = re.compile(
+    r"(?:(?:January|February|March|April|May|June|July|August|September|October|November|December)"
+    r"\s+\d{1,2},?\s+\d{4})"
+    r"|(?:\d{1,2}\s+(?:January|February|March|April|May|June|July|August|September|October|November|December)"
+    r"\s+\d{4})"
+    r"|(?:\d{4}-\d{2}-\d{2})"
+    r"|(?:\d{1,2}/\d{1,2}/\d{4})",
+    re.IGNORECASE,
+)
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    import json
+    import os
+
+    file_path = arguments["file_path"]
+    focus = arguments.get("focus")
+    therapeutic_area = arguments.get("therapeutic_area")
+    max_pages = arguments.get("max_pages", 50)
+
+    if not os.path.isfile(file_path):
+        return [{"type": "text", "text": json.dumps({"error": f"File not found: {file_path}"})}]
+
+    ext = os.path.splitext(file_path)[1].lower()
+    pages = _extract_text(file_path, ext, max_pages)
+
+    events = []
+    for page in pages:
+        page_events = _extract_events_from_text(page["text"], page["page_number"], os.path.basename(file_path), focus)
+        events.extend(page_events)
+
+    if therapeutic_area:
+        for e in events:
+            e["therapeutic_area"] = therapeutic_area
+
+    events.sort(key=lambda e: e.get("date") or "", reverse=True)
+
+    output = {
+        "file": os.path.basename(file_path),
+        "pages_processed": len(pages),
+        "total_events": len(events),
+        "therapeutic_area": therapeutic_area,
+        "events": events,
+    }
+    return [{"type": "text", "text": json.dumps(output, indent=2)}]
+
+
+def _extract_text(file_path: str, ext: str, max_pages: int) -> list[dict[str, Any]]:
+    if ext == ".pdf":
+        return _extract_pdf(file_path, max_pages)
+    if ext in (".docx", ".doc"):
+        return _extract_docx(file_path)
+    return _extract_plain(file_path)
+
+
+def _extract_pdf(file_path: str, max_pages: int) -> list[dict[str, Any]]:
+    try:
+        import pypdfium2 as pdfium
+    except ImportError:
+        return [{"page_number": 1, "text": _read_file_text(file_path)}]
+
+    doc = pdfium.PdfDocument(file_path)
+    pages = []
+    for i in range(min(len(doc), max_pages)):
+        textpage = doc[i].get_textpage()
+        text = textpage.get_text_bounded()
+        textpage.close()
+        if text.strip():
+            pages.append({"page_number": i + 1, "text": text})
+    doc.close()
+    return pages
+
+
+def _extract_docx(file_path: str) -> list[dict[str, Any]]:
+    try:
+        from docx import Document
+    except ImportError:
+        return [{"page_number": 1, "text": _read_file_text(file_path)}]
+
+    doc = Document(file_path)
+    text = "\n".join(p.text for p in doc.paragraphs if p.text.strip())
+    return [{"page_number": 1, "text": text}]
+
+
+def _extract_plain(file_path: str) -> list[dict[str, Any]]:
+    return [{"page_number": 1, "text": _read_file_text(file_path)}]
+
+
+def _read_file_text(file_path: str) -> str:
+    try:
+        with open(file_path, encoding="utf-8", errors="replace") as f:
+            return f.read()
+    except Exception:
+        return ""
+
+
+def _extract_events_from_text(
+    text: str, page_number: int, source: str, focus: list[str] | None
+) -> list[dict[str, Any]]:
+    if not text or len(text) < 20:
+        return []
+
+    sentences = re.split(r"[.!?\n]+", text)
+    events = []
+
+    for sentence in sentences:
+        sentence = sentence.strip()
+        if len(sentence) < 20:
+            continue
+
+        event_type = None
+        for etype, pattern in _EVENT_PATTERNS.items():
+            if pattern.search(sentence):
+                event_type = etype
+                break
+
+        if event_type is None:
+            continue
+
+        if focus and event_type not in focus:
+            continue
+
+        competitor = _find_competitor(sentence)
+        date = _find_date(sentence)
+
+        events.append(
+            {
+                "event_type": event_type,
+                "date": date,
+                "competitor": competitor or "Unknown",
+                "product": None,
+                "description": sentence[:300],
+                "source": source,
+                "source_page": page_number,
+                "confidence": "medium" if competitor else "low",
+            }
+        )
+
+    return events
+
+
+def _find_competitor(text: str) -> str | None:
+    text_lower = text.lower()
+    for company in _PHARMA_COMPANIES:
+        if company in text_lower:
+            return company.title()
+    return None
+
+
+def _find_date(text: str) -> str | None:
+    m = _DATE_PATTERN.search(text)
+    if m:
+        return m.group(0)
+    return None

open_pharma_plugins_competitive_intelligence/tools/ci_landscape.py

@@ -0,0 +1,195 @@
+"""ci_landscape — competitive landscape matrix for a therapeutic area."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class LandscapeArgs(BaseModel):
+    therapeutic_area: str = Field(description="Therapeutic area or indication, e.g. 'NSCLC', 'Type 2 Diabetes'")
+    competitors: list[str] | None = Field(
+        default=None,
+        description="Specific competitors to include. If omitted, discovers top sponsors from trial data.",
+    )
+    phases: list[str] | None = Field(
+        default=None,
+        description="Trial phases to include: phase1, phase2, phase3, approved. Default: all.",
+    )
+    include_approved: bool = Field(
+        default=True,
+        description="Include already-approved products from FDA label data.",
+    )
+    max_competitors: int = Field(
+        default=15,
+        ge=1,
+        le=50,
+        description="Maximum number of competitors in the landscape.",
+    )
+
+
+TOOL: dict[str, Any] = {
+    "name": "ci_landscape",
+    "description": (
+        "Build a competitive landscape matrix for a therapeutic area by "
+        "querying ClinicalTrials.gov and OpenFDA, cross-referencing trials "
+        "with approved products, deduplicating, and ranking by phase. "
+        "Returns a structured landscape with competitor, product, mechanism, "
+        "phase, key trials, and expected milestones."
+    ),
+    "args": LandscapeArgs,
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    from datetime import datetime, timezone
+
+    from .ci_scan_trials import handle as scan_trials
+
+    therapeutic_area = arguments["therapeutic_area"]
+    target_competitors = arguments.get("competitors")
+    include_approved = arguments.get("include_approved", True)
+    max_competitors = arguments.get("max_competitors", 15)
+
+    trial_result = json.loads(scan_trials({"query": therapeutic_area, "max_results": 50})[0]["text"])
+    trials = trial_result.get("trials", [])
+
+    sponsor_products: dict[str, dict[str, dict[str, Any]]] = {}
+
+    for t in trials:
+        sponsor = t.get("sponsor", "Unknown")
+        if target_competitors and not any(c.lower() in sponsor.lower() for c in target_competitors):
+            continue
+
+        for intervention in t.get("interventions", []):
+            key = f"{sponsor}|{intervention}"
+            if key not in sponsor_products.get(sponsor, {}):
+                sponsor_products.setdefault(sponsor, {})[intervention] = {
+                    "sponsor": sponsor,
+                    "product": intervention,
+                    "phase": t.get("phase", ""),
+                    "status": t.get("status", ""),
+                    "conditions": t.get("conditions", []),
+                    "key_trials": [t.get("nct_id", "")],
+                    "enrollment": t.get("enrollment"),
+                    "completion_date": t.get("completion_date", ""),
+                    "start_date": t.get("start_date", ""),
+                }
+            else:
+                entry = sponsor_products[sponsor][intervention]
+                if t.get("nct_id") and t["nct_id"] not in entry["key_trials"]:
+                    entry["key_trials"].append(t["nct_id"])
+                new_phase = _phase_rank(t.get("phase", ""))
+                if new_phase > _phase_rank(entry["phase"]):
+                    entry["phase"] = t.get("phase", "")
+                    entry["status"] = t.get("status", "")
+
+    approved_products: dict[str, dict[str, Any]] = {}
+    if include_approved:
+        from .ci_scan_regulatory import handle as scan_reg
+
+        reg_result = json.loads(scan_reg({"drug_name": therapeutic_area, "max_results": 30})[0]["text"])
+        for event in reg_result.get("events", []):
+            if event.get("type") == "approval":
+                brand = event.get("brand_name", "")
+                sponsor = event.get("generic_name", brand)
+                if brand and brand not in approved_products:
+                    approved_products[brand] = {
+                        "sponsor": sponsor,
+                        "product": brand,
+                        "phase": "APPROVED",
+                        "status": "marketed",
+                        "conditions": [],
+                        "key_trials": [],
+                        "approval_date": event.get("date", ""),
+                    }
+
+    entries = []
+    for sponsor_data in sponsor_products.values():
+        for entry in sponsor_data.values():
+            milestones = []
+            if entry.get("completion_date"):
+                milestones.append({"event": "Primary completion", "date": entry["completion_date"]})
+            entries.append(
+                {
+                    "competitor": entry["sponsor"],
+                    "product": entry["product"],
+                    "mechanism": None,
+                    "phase": entry["phase"],
+                    "status": entry["status"],
+                    "indications": entry.get("conditions", [])[:3],
+                    "key_trials": entry["key_trials"][:3],
+                    "expected_milestones": milestones,
+                    "differentiators": [],
+                    "approval_date": None,
+                }
+            )
+
+    for brand, info in approved_products.items():
+        generic = info.get("sponsor", "").lower()
+        existing = any(
+            e["product"].lower() == brand.lower()
+            or e["product"].lower() == generic
+            or brand.lower() in e["product"].lower()
+            for e in entries
+        )
+        if not existing:
+            entries.append(
+                {
+                    "competitor": info["sponsor"],
+                    "product": info["product"],
+                    "mechanism": None,
+                    "phase": "APPROVED",
+                    "status": "marketed",
+                    "indications": [],
+                    "key_trials": [],
+                    "expected_milestones": [],
+                    "differentiators": [],
+                    "approval_date": info.get("approval_date"),
+                }
+            )
+
+    entries.sort(key=lambda e: _phase_rank(e["phase"]), reverse=True)
+    entries = entries[:max_competitors]
+
+    phase_dist: dict[str, int] = {}
+    for e in entries:
+        p = e["phase"] or "Unknown"
+        phase_dist[p] = phase_dist.get(p, 0) + 1
+
+    output = {
+        "therapeutic_area": therapeutic_area,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "total_entries": len(entries),
+        "phase_distribution": phase_dist,
+        "entries": entries,
+        "data_sources": ["ClinicalTrials.gov", "OpenFDA"],
+        "metadata": {
+            "total_trials_scanned": len(trials),
+            "total_approved_found": len(approved_products),
+        },
+    }
+    return [{"type": "text", "text": json.dumps(output, indent=2)}]
+
+
+def _phase_rank(phase: str) -> int:
+    p = phase.upper().replace(", ", "").replace(" ", "")
+    if "APPROVED" in p:
+        return 10
+    if "PHASE4" in p:
+        return 9
+    if "PHASE3" in p:
+        return 8
+    if "PHASE2" in p and "PHASE3" in p:
+        return 7
+    if "PHASE2" in p:
+        return 6
+    if "PHASE1" in p and "PHASE2" in p:
+        return 5
+    if "PHASE1" in p:
+        return 4
+    if "EARLY" in p:
+        return 3
+    return 1

open_pharma_plugins_competitive_intelligence/tools/ci_refresh.py

@@ -0,0 +1,101 @@
+"""ci_refresh — collect one immutable evidence run for tracked entities."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from .._runs import RunIntegrityError, create_run
+from .._watchlist import WatchlistError, load_tracked_entities
+from ..models import RefreshRequest, SectionName, aggregate_coverage
+
+
+class RefreshArgs(BaseModel):
+    entities: list[str] | None = Field(
+        default=None,
+        description="Optional tracked entity names; omit to refresh the full watchlist",
+    )
+    include_sections: list[SectionName] = Field(
+        default_factory=lambda: ["trials", "regulatory", "news", "publications"]
+    )
+    news_days_back: int = Field(default=90, ge=1, le=365)
+    publication_days_back: int = Field(default=365, ge=1, le=1825)
+
+
+TOOL: dict[str, Any] = {
+    "name": "ci_refresh",
+    "description": (
+        "Collect one immutable, evidence-bearing Competitive Intelligence run "
+        "for selected tracked entities or the full watchlist."
+    ),
+    "args": RefreshArgs,
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    args = RefreshArgs.model_validate(arguments)
+    try:
+        watchlist = load_tracked_entities()
+    except WatchlistError as error:
+        return _error("invalid_watchlist", str(error))
+
+    selected = watchlist
+    if args.entities is not None:
+        by_name = {entity.name.casefold(): entity for entity in watchlist}
+        requested = list(dict.fromkeys(name.strip().casefold() for name in args.entities if name.strip()))
+        unknown = [name for name in args.entities if name.strip().casefold() not in by_name]
+        if unknown:
+            return _error(
+                "unknown_entity",
+                "Track each entity with ci_track action=add and an explicit drug or company type before refresh.",
+                entities=list(dict.fromkeys(unknown)),
+            )
+        selected = [by_name[name] for name in requested]
+    if not selected:
+        return _error(
+            "empty_watchlist",
+            "Track at least one explicit drug or company with ci_track action=add before refresh.",
+        )
+
+    request = RefreshRequest(
+        entities=selected,
+        include_sections=args.include_sections,
+        news_days_back=args.news_days_back,
+        publication_days_back=args.publication_days_back,
+    )
+    try:
+        run = create_run(request)
+    except RunIntegrityError as error:
+        return _error("run_persistence_failed", str(error))
+
+    coverage = [
+        {
+            "entity": snapshot.entity.name,
+            "source": result.source.value,
+            "status": result.status.value,
+            "record_count": len(result.records),
+            "limitations": result.limitations,
+        }
+        for snapshot in run.entities
+        for result in snapshot.sources.values()
+    ]
+    status = aggregate_coverage([result.status for snapshot in run.entities for result in snapshot.sources.values()])
+    output = {
+        "success": True,
+        "run_id": run.run_id,
+        "manifest_path": run.manifest_path,
+        "records_sha256": run.records_sha256,
+        "entities": [snapshot.entity.name for snapshot in run.entities],
+        "include_sections": run.request.include_sections,
+        "coverage_status": status.value,
+        "coverage": coverage,
+        "limitations": run.limitations,
+    }
+    return [{"type": "text", "text": json.dumps(output, indent=2)}]
+
+
+def _error(code: str, message: str, **details: Any) -> list[dict[str, Any]]:
+    payload = {"error": {"code": code, "message": message, **details}}
+    return [{"type": "text", "text": json.dumps(payload, indent=2)}]