@hongmaple0820/med-scale-research-os 0.43.0

package/target-research-platform/src/analysis/stage4_business/pipeline.py

@@ -0,0 +1,284 @@
+"""
+阶段4 Pipeline：商业计划书与里程碑规划
+汇总前三阶段数据，生成完整的商业规划
+"""
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from .milestone_planner import MilestonePlanner
+from .business_plan import BusinessPlanGenerator
+from ...utils.logger import get_logger
+
+
+class Stage4Pipeline:
+    """阶段4 Pipeline：商业计划书与里程碑规划"""
+
+    logger = get_logger("stage4")
+
+    def __init__(
+        self,
+        output_dir: str = "./output/stage4",
+        cache_dir: str = "./cache"
+    ):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # 初始化分析器
+        self.milestone_planner = MilestonePlanner()
+        self.business_plan_generator = BusinessPlanGenerator()
+
+    def run(
+        self,
+        target_name: str,
+        disease: Optional[str] = None,
+        stage1_data: Optional[dict] = None,
+        stage2_data: Optional[dict] = None,
+        stage3_data: Optional[dict] = None,
+        modality: str = "small_molecule",
+        risk_level: str = "medium",
+        company_info: Optional[dict] = None
+    ) -> dict:
+        """
+        执行完整的阶段4分析
+
+        Args:
+            target_name: 靶点名称
+            disease: 疾病名称
+            stage1_data: 阶段1数据
+            stage2_data: 阶段2数据
+            stage3_data: 阶段3数据
+            modality: 药物形式
+            risk_level: 风险等级
+            company_info: 公司信息
+
+        Returns:
+            完整的商业规划结果
+        """
+        self.logger.info(f"=" * 60)
+        self.logger.info(f"阶段4 Pipeline: {target_name}")
+        if disease:
+            self.logger.info(f"疾病: {disease}")
+        self.logger.info(f"药物形式: {modality}")
+        self.logger.info(f"风险等级: {risk_level}")
+        self.logger.info(f"=" * 60)
+
+        results = {
+            "target": target_name,
+            "disease": disease,
+            "modality": modality,
+            "risk_level": risk_level,
+            "timestamp": datetime.now().isoformat(),
+            "stages": {}
+        }
+
+        # 1. 生成里程碑规划（传入前序阶段数据以动态调整成功率）
+        self.logger.info("[1/3] 生成里程碑规划...")
+        milestone_result = self._generate_milestones(
+            target_name, disease, modality, risk_level,
+            stage1_data=stage1_data,
+            stage2_data=stage2_data,
+            stage3_data=stage3_data
+        )
+        results["stages"]["milestones"] = milestone_result
+
+        # 2. 生成商业计划书
+        self.logger.info("[2/3] 生成商业计划书...")
+        business_plan_result = self._generate_business_plan(
+            target_name, disease,
+            stage1_data, stage2_data, stage3_data,
+            milestone_result, company_info
+        )
+        results["stages"]["business_plan"] = business_plan_result
+
+        # 3. 生成Markdown报告
+        self.logger.info("[3/3] 生成报告...")
+        if business_plan_result.get("success"):
+            markdown_report = self.business_plan_generator.to_markdown(
+                business_plan_result.get("data", {})
+            )
+            results["stages"]["markdown_report"] = {
+                "success": True,
+                "content": markdown_report
+            }
+
+        # 生成摘要
+        results["summary"] = self._generate_summary(results)
+
+        # 保存结果
+        self._save_results(target_name, disease, results)
+
+        self.logger.info(f"{'=' * 60}")
+        self.logger.info("阶段4分析完成!")
+        self.logger.info(f"结果保存至: {self.output_dir}")
+        self.logger.info(f"{'=' * 60}")
+
+        return results
+
+    def _generate_milestones(
+        self,
+        target_name: str,
+        disease: Optional[str],
+        modality: str,
+        risk_level: str,
+        stage1_data: Optional[dict] = None,
+        stage2_data: Optional[dict] = None,
+        stage3_data: Optional[dict] = None
+    ) -> dict:
+        """生成里程碑（透传前序阶段数据以动态调整成功率）"""
+        self.logger.debug("  - 计算开发时间线（含动态成功率调整）...")
+
+        milestone_result = self.milestone_planner.generate_milestones(
+            target_name=target_name,
+            disease=disease,
+            modality=modality,
+            risk_level=risk_level,
+            stage1_data=stage1_data,
+            stage2_data=stage2_data,
+            stage3_data=stage3_data
+        )
+
+        return {
+            "success": milestone_result.get("success", False),
+            "data": milestone_result
+        }
+
+    def _generate_business_plan(
+        self,
+        target_name: str,
+        disease: Optional[str],
+        stage1_data: Optional[dict],
+        stage2_data: Optional[dict],
+        stage3_data: Optional[dict],
+        milestone_result: dict,
+        company_info: Optional[dict]
+    ) -> dict:
+        """生成商业计划书"""
+        self.logger.debug("  - 整合各阶段数据...")
+
+        milestone_data = milestone_result.get("data", {}) if milestone_result.get("success") else None
+
+        plan = self.business_plan_generator.generate(
+            target_name=target_name,
+            disease=disease,
+            stage1_data=stage1_data,
+            stage2_data=stage2_data,
+            stage3_data=stage3_data,
+            milestone_data=milestone_data,
+            company_info=company_info
+        )
+
+        return {
+            "success": plan.get("success", False),
+            "data": plan
+        }
+
+    def _generate_summary(self, results: dict) -> dict:
+        """生成摘要"""
+        target = results["target"]
+        disease = results.get("disease")
+        stages = results.get("stages", {})
+
+        summary = {
+            "target": target,
+            "disease": disease,
+            "analysis_status": "completed",
+            "key_outputs": [],
+            "milestones": {},
+            "funding": {}
+        }
+
+        # 里程碑摘要
+        milestones = stages.get("milestones", {})
+        if milestones.get("success"):
+            milestone_data = milestones.get("data", {})
+            summary["milestones"] = {
+                "total_duration": f"{milestone_data.get('total_duration_months', 0)}个月",
+                "total_cost": f"${milestone_data.get('total_cost_estimate', 0)}M",
+                "success_rate": f"{milestone_data.get('overall_success_rate', 0) * 100:.1f}%",
+                "estimated_completion": milestone_data.get("estimated_completion", "")
+            }
+            summary["key_outputs"].append("里程碑规划")
+
+        # 商业计划书摘要
+        business_plan = stages.get("business_plan", {})
+        if business_plan.get("success"):
+            plan_data = business_plan.get("data", {})
+            funding = plan_data.get("sections", {}).get("funding_requirements", {})
+            summary["funding"] = {
+                "total_requirement": funding.get("total_requirement", {}).get("amount", ""),
+                "rounds": len(funding.get("funding_rounds", []))
+            }
+            summary["key_outputs"].append("商业计划书")
+
+        # Markdown报告
+        if stages.get("markdown_report", {}).get("success"):
+            summary["key_outputs"].append("Markdown报告")
+
+        return summary
+
+    def _save_results(
+        self,
+        target_name: str,
+        disease: Optional[str],
+        results: dict
+    ):
+        """保存结果"""
+        # 生成文件名
+        filename = target_name
+        if disease:
+            filename += f"_{disease}"
+
+        # 保存JSON
+        json_path = self.output_dir / f"{filename}_stage4_results.json"
+        with open(json_path, 'w', encoding='utf-8') as f:
+            json.dump(results, f, ensure_ascii=False, indent=2, default=str)
+
+        # 保存Markdown报告
+        markdown_content = results.get("stages", {}).get("markdown_report", {}).get("content", "")
+        if markdown_content:
+            md_path = self.output_dir / f"{filename}_business_plan.md"
+            with open(md_path, 'w', encoding='utf-8') as f:
+                f.write(markdown_content)
+
+        # 保存里程碑数据
+        milestones = results.get("stages", {}).get("milestones", {}).get("data", {})
+        if milestones:
+            milestones_path = self.output_dir / f"{filename}_milestones.json"
+            with open(milestones_path, 'w', encoding='utf-8') as f:
+                json.dump(milestones, f, ensure_ascii=False, indent=2, default=str)
+
+    def validate_inputs(
+        self,
+        target_name: str
+    ) -> tuple[bool, list[str]]:
+        """验证输入"""
+        issues = []
+
+        if not target_name:
+            issues.append("靶点名称不能为空")
+
+        # 验证药物形式
+        valid_modalities = [
+            "small_molecule", "antibody", "bispecific_antibody",
+            "adc", "cell_therapy", "gene_therapy", "rna"
+        ]
+
+        return len(issues) == 0, issues
+
+    def get_milestone_summary(
+        self,
+        target_name: str,
+        disease: Optional[str] = None
+    ) -> dict:
+        """获取里程碑摘要"""
+        return self.milestone_planner.get_summary(target_name, disease)
+
+    def get_business_plan_summary(
+        self,
+        target_name: str,
+        disease: Optional[str] = None
+    ) -> dict:
+        """获取商业计划书摘要"""
+        return self.business_plan_generator.get_summary(target_name, disease)

package/target-research-platform/src/api_clients/__init__.py

@@ -0,0 +1,29 @@
+"""
+API客户端模块
+"""
+from .base_client import BaseAPIClient, APIResponse
+from .gtex_client import GTExClient
+from .tcga_client import TCGAClient
+from .hpa_client import HPAClient
+from .timer_client import TIMERClient
+from .pubmed_client import PubMedClient
+from .aminer_client import AMinerClient
+from .opentargets_client import OpenTargetsClient
+from .geo_client import GEOClient
+from .clinicaltrials_client import ClinicalTrialsClient
+from .immune_data_manager import ImmuneDataManager
+
+__all__ = [
+    "BaseAPIClient",
+    "APIResponse",
+    "GTExClient",
+    "TCGAClient",
+    "HPAClient",
+    "TIMERClient",
+    "PubMedClient",
+    "AMinerClient",
+    "OpenTargetsClient",
+    "GEOClient",
+    "ClinicalTrialsClient",
+    "ImmuneDataManager"
+]

package/target-research-platform/src/api_clients/aminer_client.py

@@ -0,0 +1,163 @@
+"""
+AMiner 开放平台客户端（精简版）
+
+用于论文稿件生成时补充引用链、期刊与学者质量信号。
+Token: https://open.aminer.cn/open/board?tab=control
+"""
+from __future__ import annotations
+
+import json
+import os
+import random
+import time
+from typing import Any, Optional
+
+import requests
+
+
+class AMinerClient:
+    """AMiner 学术数据 API — 论文搜索 + 详情 + 引用关系。"""
+
+    BASE_URL = "https://datacenter.aminer.cn/gateway/open_platform"
+    RETRYABLE_STATUS = {408, 429, 500, 502, 503, 504}
+
+    def __init__(self, token: str | None = None, timeout: int = 30, max_retries: int = 3):
+        self.token = token or os.environ.get("AMINER_TOKEN") or os.environ.get("AMINER_API_TOKEN")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._session = requests.Session()
+
+    @property
+    def available(self) -> bool:
+        return bool(self.token)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict | None = None,
+        body: dict | None = None,
+    ) -> dict[str, Any]:
+        if not self.token:
+            return {"success": False, "error": "missing_aminer_token"}
+
+        url = f"{self.BASE_URL}{path}"
+        headers = {
+            "Authorization": self.token,
+            "Content-Type": "application/json;charset=utf-8",
+        }
+
+        for attempt in range(1, self.max_retries + 1):
+            try:
+                if method.upper() == "GET":
+                    resp = self._session.get(url, headers=headers, params=params, timeout=self.timeout)
+                else:
+                    resp = self._session.post(url, headers=headers, json=body, timeout=self.timeout)
+                if resp.status_code in self.RETRYABLE_STATUS and attempt < self.max_retries:
+                    time.sleep((2 ** (attempt - 1)) + random.uniform(0, 0.3))
+                    continue
+                resp.raise_for_status()
+                data = resp.json()
+                if isinstance(data, dict):
+                    data.setdefault("success", True)
+                return data if isinstance(data, dict) else {"success": True, "data": data}
+            except Exception as exc:
+                if attempt < self.max_retries:
+                    time.sleep((2 ** (attempt - 1)) + random.uniform(0, 0.3))
+                    continue
+                return {"success": False, "error": str(exc)}
+        return {"success": False, "error": "max_retries_exceeded"}
+
+    def paper_search(self, title: str, *, size: int = 3) -> dict[str, Any]:
+        return self._request(
+            "GET",
+            "/api/paper/search",
+            params={"title": title, "page": 0, "size": size},
+        )
+
+    def paper_detail(self, paper_id: str) -> dict[str, Any]:
+        return self._request("GET", "/api/paper/detail", params={"id": paper_id})
+
+    def paper_relation(self, paper_id: str) -> dict[str, Any]:
+        return self._request("GET", "/api/paper/relation", params={"id": paper_id})
+
+    def enrich_by_title(self, title: str) -> dict[str, Any]:
+        """
+        按标题检索论文并提取引用数、期刊、关键词等补充字段。
+        失败时返回空 dict，不阻断主流程。
+        """
+        if not self.available or not title.strip():
+            return {}
+
+        search = self.paper_search(title)
+        items = self._extract_paper_list(search)
+        if not items:
+            search = self._request(
+                "GET",
+                "/api/paper/search/pro",
+                params={"title": title, "page": 0, "size": 3, "order": "n_citation"},
+            )
+            items = self._extract_paper_list(search)
+        if not items:
+            return {"aminer_matched": False}
+
+        best = items[0]
+        paper_id = best.get("id") or best.get("paper_id")
+        if not paper_id:
+            return {"aminer_matched": False}
+
+        detail = self.paper_detail(str(paper_id))
+        relation = self.paper_relation(str(paper_id))
+        detail_data = self._unwrap(detail)
+        relation_data = self._unwrap(relation)
+
+        cited_by = relation_data.get("cited_by") or relation_data.get("citations") or []
+        if isinstance(cited_by, dict):
+            cited_by = cited_by.get("data") or cited_by.get("items") or []
+
+        return {
+            "aminer_matched": True,
+            "aminer_paper_id": str(paper_id),
+            "aminer_citation_count": (
+                detail_data.get("n_citation")
+                or best.get("n_citation")
+                or (len(cited_by) if isinstance(cited_by, list) else None)
+            ),
+            "aminer_venue": detail_data.get("venue") or best.get("venue"),
+            "aminer_keywords": (detail_data.get("keywords") or best.get("keywords") or [])[:10],
+            "aminer_authors_top": [
+                a.get("name") if isinstance(a, dict) else str(a)
+                for a in (detail_data.get("authors") or best.get("authors") or [])[:5]
+            ],
+            "aminer_cited_by_sample": [
+                (c.get("title") or "")[:80]
+                for c in (cited_by[:3] if isinstance(cited_by, list) else [])
+                if isinstance(c, dict)
+            ],
+        }
+
+    @staticmethod
+    def _unwrap(payload: dict) -> dict:
+        if not payload:
+            return {}
+        data = payload.get("data")
+        if isinstance(data, list) and data:
+            return data[0] if isinstance(data[0], dict) else {}
+        if isinstance(data, dict):
+            return data
+        return payload
+
+    @staticmethod
+    def _extract_paper_list(payload: dict) -> list[dict]:
+        if not payload or payload.get("success") is False:
+            return []
+        data = payload.get("data")
+        if isinstance(data, list):
+            return [x for x in data if isinstance(x, dict)]
+        if isinstance(data, dict):
+            for key in ("items", "papers", "data", "list"):
+                val = data.get(key)
+                if isinstance(val, list):
+                    return [x for x in val if isinstance(x, dict)]
+        return []

package/target-research-platform/src/api_clients/base_client.py

@@ -0,0 +1,186 @@
+"""
+API客户端基类
+所有数据源客户端必须继承此类，确保统一的接口和数据溯源
+"""
+import json
+import time
+import hashlib
+from abc import ABC, abstractmethod
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Optional
+import requests
+
+
+class APIResponse:
+    """标准化API响应"""
+
+    def __init__(
+        self,
+        success: bool,
+        data: Any,
+        source: str,
+        endpoint: str,
+        params: dict,
+        timestamp: str,
+        raw_response: Optional[str] = None,
+        error: Optional[str] = None
+    ):
+        self.success = success
+        self.data = data
+        self.source = source
+        self.endpoint = endpoint
+        self.params = params
+        self.timestamp = timestamp
+        self.raw_response = raw_response
+        self.error = error
+
+    def to_dict(self) -> dict:
+        return {
+            "success": self.success,
+            "source": self.source,
+            "endpoint": self.endpoint,
+            "params": self.params,
+            "timestamp": self.timestamp,
+            "error": self.error,
+            "data": self.data
+        }
+
+    def get_provenance(self) -> dict:
+        """获取数据溯源信息"""
+        return {
+            "source": self.source,
+            "endpoint": self.endpoint,
+            "params": self.params,
+            "timestamp": self.timestamp,
+            "request_hash": hashlib.md5(
+                f"{self.endpoint}{json.dumps(self.params, sort_keys=True)}".encode()
+            ).hexdigest()
+        }
+
+
+class BaseAPIClient(ABC):
+    """API客户端基类"""
+
+    def __init__(self, cache_dir: Optional[str] = None, rate_limit: float = 0.34):
+        """
+        Args:
+            cache_dir: 缓存目录路径
+            rate_limit: 请求间隔（秒），默认0.34秒（约3次/秒）
+        """
+        self.cache_dir = Path(cache_dir) if cache_dir else Path("./cache")
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.rate_limit = rate_limit
+        self._last_request_time = 0
+        self._session = requests.Session()
+        self._session.headers.update({
+            "User-Agent": "TargetResearchPlatform/1.0"
+        })
+
+    @property
+    @abstractmethod
+    def source_name(self) -> str:
+        """数据源名称"""
+        pass
+
+    @property
+    @abstractmethod
+    def base_url(self) -> str:
+        """API基础URL"""
+        pass
+
+    def _wait_for_rate_limit(self):
+        """遵守速率限制"""
+        elapsed = time.time() - self._last_request_time
+        if elapsed < self.rate_limit:
+            time.sleep(self.rate_limit - elapsed)
+        self._last_request_time = time.time()
+
+    def _get_cache_key(self, endpoint: str, params: dict) -> str:
+        """生成缓存键"""
+        key_str = f"{self.source_name}:{endpoint}:{json.dumps(params, sort_keys=True)}"
+        return hashlib.md5(key_str.encode()).hexdigest()
+
+    def _get_from_cache(self, cache_key: str) -> Optional[dict]:
+        """从缓存读取"""
+        cache_file = self.cache_dir / f"{cache_key}.json"
+        if cache_file.exists():
+            try:
+                with open(cache_file, 'r', encoding='utf-8') as f:
+                    cached = json.load(f)
+                    # 缓存有效期24小时
+                    cached_time = datetime.fromisoformat(cached.get('timestamp', '2000-01-01'))
+                    if (datetime.now() - cached_time).total_seconds() < 86400:
+                        return cached
+            except (json.JSONDecodeError, ValueError):
+                pass
+        return None
+
+    def _save_to_cache(self, cache_key: str, response: APIResponse):
+        """保存到缓存"""
+        cache_file = self.cache_dir / f"{cache_key}.json"
+        with open(cache_file, 'w', encoding='utf-8') as f:
+            json.dump(response.to_dict(), f, ensure_ascii=False, indent=2)
+
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[dict] = None,
+        json_data: Optional[dict] = None,
+        use_cache: bool = True
+    ) -> APIResponse:
+        """发起HTTP请求"""
+        # 检查缓存
+        cache_key = self._get_cache_key(endpoint, params or {})
+        if use_cache:
+            cached = self._get_from_cache(cache_key)
+            if cached:
+                return APIResponse(**cached)
+
+        # 速率限制
+        self._wait_for_rate_limit()
+
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+
+        try:
+            if method.upper() == "GET":
+                response = self._session.get(url, params=params, timeout=30)
+            elif method.upper() == "POST":
+                response = self._session.post(url, params=params, json=json_data, timeout=30)
+            else:
+                raise ValueError(f"不支持的HTTP方法: {method}")
+
+            response.raise_for_status()
+
+            api_response = APIResponse(
+                success=True,
+                data=response.json() if response.content else None,
+                source=self.source_name,
+                endpoint=endpoint,
+                params=params or {},
+                timestamp=datetime.now().isoformat(),
+                raw_response=response.text[:1000]  # 只保存前1000字符
+            )
+
+            # 保存缓存
+            if use_cache:
+                self._save_to_cache(cache_key, api_response)
+
+            return api_response
+
+        except requests.exceptions.RequestException as e:
+            return APIResponse(
+                success=False,
+                data=None,
+                source=self.source_name,
+                endpoint=endpoint,
+                params=params or {},
+                timestamp=datetime.now().isoformat(),
+                error=str(e)
+            )
+
+    @abstractmethod
+    def health_check(self) -> bool:
+        """检查API可用性"""
+        pass