VigiAccess Integration

class VigiAccessScraper:
    def __init__(self, base_url: str | None = None, timeout: float = 15.0, max_retries: int = 2):
        """
        Scraper that mimics browser behavior:
        1) GET "/" → cookies (ASLBSA, ASLBSACORS)
        2) POST /protocol/IProtocol/search (JSON → msgpack)
        3) POST /protocol/IProtocol/distribution (JSON → msgpack)
        """
        default_base = "https://www.vigiaccess.org"
        self.base_url = (base_url or default_base).rstrip("/")
        self.timeout = timeout
        self.max_retries = max_retries
        
        self.client = httpx.Client(
            base_url=self.base_url,
            timeout=self.timeout,
            headers={
                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/142.0.0.0",
                "Accept": "*/*",
                "Accept-Encoding": "gzip, deflate, br, zstd",
                "Accept-Language": "es-ES,es;q=0.9",
            },
        )
    
    def scrape_drug(self, term: str) -> Dict[str, Any]:
        """
        Main entry point for drug scraping.
        Returns: {
            "drug": label,
            "token": encrypted_token,
            "total_reports": int,
            "soc_rows": [{soc, percent, adr_count}, ...],
            "source": "VigiAccess (scraper no-oficial)"
        }
        """
        term = term.strip()
        if not term:
            raise VigiAccessError("Debe indicar el nombre del fármaco")
        
        # 1) Search for drug candidates
        candidates = self._search_drug(term)
        chosen = self._pick_candidate(term, candidates)
        logger.info("[VigiAccess] candidato elegido: label=%s token=%s",
                    chosen["label"], chosen["token"])
        
        # 2) Fetch distribution data
        raw_dist = self._fetch_distribution_raw(chosen["token"])
        
        # 3) Parse to SOC rows
        soc_rows = self._parse_distribution_to_soc_rows(raw_dist)
        
        return {
            "drug": chosen["label"],
            "token": chosen["token"],
            "total_reports": sum(r.adr_count or 0 for r in soc_rows),
            "soc_rows": [
                {"soc": r.soc, "percent": r.percent, "adr_count": r.adr_count}
                for r in soc_rows
            ],
            "source": "VigiAccess (scraper no-oficial)",
        }

API_BASE = "https://api.who-umc.org/vigibase/icsrstatistics"
API_KEY = os.getenv("VIGIACCESS_API_KEY", "")

async def get_dashboard_tables_for_tradename(tradename: str) -> Dict[str, Any]:
    """
    Fetch distribution tables from WHO-UMC API.
    
    Returns:
        {
            "query": tradename,
            "geo": [{label, count, percent}, ...],
            "sex": [{label, count, percent}, ...],
            "age": [{label, count, percent}, ...],
            "year": [{label, count, percent}, ...],
            "errors": {key: error_msg, ...}
        }
    """
    t = (tradename or "").strip()
    if not t:
        raise WhoUmcVigiAccessError("tradename vacío")
    
    mapping = {
        "geo": "dimensions/continent",
        "sex": "dimensions/sex",
        "age": "dimensions/agegroup",
        "year": "dimensions/year",
    }
    
    out = {"query": t, "geo": [], "sex": [], "age": [], "year": []}
    errors: Dict[str, str] = {}
    
    for key, path in mapping.items():
        try:
            js = await _get_json(path, params={"tradename": t})
            out[key] = _normalize_rows(js)
        except Exception as e:
            errors[key] = str(e)
    
    if errors and all(len(out[k]) == 0 for k in ("geo", "sex", "age", "year")):
        raise WhoUmcVigiAccessError(f"No pude obtener tablas. Detalle: {errors}")
    
    out["errors"] = errors
    return out

async def _get_json(path: str, params: Optional[Dict[str, Any]] = None) -> Any:
    url = f"{API_BASE}/{path.lstrip('/')}"
    async with httpx.AsyncClient(timeout=30.0) as client:
        r = await client.get(url, headers=_headers(), params=params or {})
        if r.status_code >= 400:
            raise WhoUmcVigiAccessError(
                f"WHO-UMC API {r.status_code} url={url} params={params} body={r.text[:200]}"
            )
        return r.json()

def _headers() -> Dict[str, str]:
    if not API_KEY:
        raise WhoUmcVigiAccessError("Falta VIGIACCESS_API_KEY en .env")
    return {
        "Accept": "application/json",
        "X-API-Key": API_KEY,
        "Ocp-Apim-Subscription-Key": API_KEY,
    }