agentdata 0.3.26__py3-none-any.whl

agentdata/esg/paris_mou.py

@@ -0,0 +1,240 @@
+"""paris_mou — Paris MoU port state control (THETIS public REST, EMSA portal) provider (keyless).
+
+esg port-state supervision axis (2026-10-29, 0.3.5 batch): parismou.org itself is all iframe shells; the real
+data door is the EMSA Liferay portlet same-origin REST `portal.emsa.europa.eu/o/portlet-public/rest/*`
+(contextRoot is emitted by the inline JS of the portlet page; the full endpoint table lives in the 160KB ExtJS
+bundle thetis-public.js). Measured shape (2026-10-29):
+- The three GET snapshot faces share the envelope `{results, total, success}`.
+  - Detentions: detention/getCurrentDetentions 53 rows (daily rolling — the 10-20 probe saw 48 rows).
+  - Bans: ban/getBanShips 486 rows ~1MB, with **ismCompany{id/imoNumber/name/address/city/countryCode}
+    embedded = the official ship x management-company edge** (310 rows carry a company IMO number).
+  - Low-performance ISM companies: companyperformance/getLowPerformance6MonthsISMCompanies 65 rows
+    (**100% carry an IMO company number**, a zero-padded 7-digit string; companyPerformance is mostly LOW with a few MEDIUM).
+- Historical inspections: inspection/getPublicInspections **POST form-encoded** — a JSON body is silently
+  dropped upstream (200 + total=0, a poisoned empty-window response, measured 2026-10-29) -> the op declares
+  `urlencoded: True` (transport extension 7).
+  Params: pscInspectionRegime=1 is mandatory (PSC default); periodMin/periodMax dd/mm/yyyy, window <= 3 years;
+  **page is the paging switch** — without page the limit is ignored and the whole window is dumped (measured
+  limit=25 returned 1,202 rows); with page+start+limit it is start-offset paging (page1/page2 measured zero
+  overlap); ismCompanyName/ismCompanyImoNumber query a company directly (+resume window stats
+  ships/inspections/detentions/ismDeficiencies/bans).
+TTL: detentions 1h (daily rolling); bans/low-performance 6h; inspections 30min (window query replay).
+Politeness tier 0.5 rps.
+"""
+from ..errors import SdkError
+
+provider = {
+    "id": "paris_mou",
+    "baseUrl": "https://portal.emsa.europa.eu",
+    "rate": {"rps": 0.5, "burst": 2},
+    "ops": {
+        "detentions": {"path": "/o/portlet-public/rest/detention/getCurrentDetentions.json"},
+        "bans": {"path": "/o/portlet-public/rest/ban/getBanShips.json", "timeout": 45.0},  # ~1MB in one response, the default 20s timed out as measured
+        "low_performance": {"path": "/o/portlet-public/rest/companyperformance/getLowPerformance6MonthsISMCompanies.json"},
+        "inspections": {
+            "path": "/o/portlet-public/rest/inspection/getPublicInspections.json",
+            "method": "POST",
+            "urlencoded": True,   # extension 7: the body is standard form encoding (a JSON body = silently 0 rows, a poisoned response)
+            "idempotent": True,   # read-semantics POST (a search), retryable
+        },
+    },
+    "ttl": {"detentions": 3600, "bans": 21600, "low_performance": 21600, "inspections": 1800},
+}
+
+
+def _flag(d):
+    return {"code": d.get("code"), "name": d.get("description")} if isinstance(d, dict) else {"code": None, "name": None}
+
+
+def _ism_company(c):
+    """Embedded ISM management company -> flat row keys (the zero-padded 7-digit official imoNumber string is kept as-is)."""
+    if not isinstance(c, dict):
+        return {"company_imo_number": None, "company_name": None, "company_address": None,
+                "company_city": None, "company_country_code": None, "company_country_name": None}
+    return {
+        "company_imo_number": c.get("imoNumber"),
+        "company_name": c.get("name"),
+        "company_address": c.get("address"),
+        "company_city": c.get("city"),
+        "company_country_code": c.get("countryCode"),
+        "company_country_name": c.get("countryDescription"),
+    }
+
+
+def detentions_from_upstream(data):
+    """Detentions snapshot -> rows (pure function, offline-testable)."""
+    rows = [{
+        "id": d.get("id"),
+        "imo_number": d.get("imoNumber"),               # ship IMO number (asset key)
+        "ship_name": d.get("shipName"),
+        "ship_type": (d.get("shipType") or {}).get("description") if isinstance(d.get("shipType"), dict) else None,
+        "flag_code": _flag(d.get("flag"))["code"],
+        "flag_name": _flag(d.get("flag"))["name"],
+        "detention_date": d.get("detentionDate"),        # dd/mm/yyyy
+        "detention_port": (d.get("detentionPort") or {}).get("name") if isinstance(d.get("detentionPort"), dict) else None,
+        "detention_country_code": ((d.get("detentionPort") or {}).get("country") or {}).get("code") if isinstance(d.get("detentionPort"), dict) else None,
+        "reporting_authority": _flag(d.get("detentionReportingAuthority"))["name"],
+    } for d in ((data or {}).get("results") or []) if isinstance(d, dict)]
+    return {"rows": rows, "count": len(rows)}
+
+
+def bans_from_upstream(data):
+    """Bans face -> rows (the embedded ismCompany is flattened into a ship x management-company edge)."""
+    rows = []
+    for b in ((data or {}).get("results") or []):
+        if not isinstance(b, dict):
+            continue
+        rows.append({
+            "id": b.get("id"),
+            "imo_number": b.get("imoNumber"),
+            "ship_name": b.get("shipName"),
+            "flag_code": _flag(b.get("flag"))["code"],
+            "flag_name": _flag(b.get("flag"))["name"],
+            "ban_date": b.get("banDate"),                 # dd/mm/yyyy
+            "ban_occurrence": b.get("banOccurrence"),
+            "ban_order_status": b.get("banOrderStatus"),
+            "ban_reason": b.get("banReason"),
+            "minimum_duration": b.get("minimumDuration"),
+            "banning_authority": _flag(b.get("banningAuthority"))["name"],
+            **_ism_company(b.get("ismCompany")),
+        })
+    return {"rows": rows, "count": len(rows)}
+
+
+def low_performance_from_upstream(data):
+    """Low-performance ISM company list -> rows (rolling 6-month window; 100% carry an IMO company number)."""
+    rows = [{
+        "id": c.get("id"),
+        "imo_number": c.get("imoNumber"),                # IMO company number (zero-padded 7-digit string)
+        "name": c.get("name"),
+        "address": c.get("address"),
+        "city": c.get("city"),
+        "country_code": c.get("countryCode"),
+        "country_name": c.get("countryDescription"),
+        "performance": c.get("companyPerformance"),       # mostly LOW, with a few MEDIUM
+        "effect_date": c.get("effectDate"),               # dd/mm/yyyy (listing date)
+        "expiry_date": c.get("expiryDate"),
+        "status": c.get("ismCompanyStatus"),              # ACTIVE/null
+    } for c in ((data or {}).get("results") or []) if isinstance(c, dict)]
+    return {"rows": rows, "count": len(rows)}
+
+
+def inspections_from_upstream(data, params):
+    """Historical inspections -> rows + resume window stats (envelope {results, total, resume, success})."""
+    rows = [{
+        "id": i.get("id"),                                # -> getInspectionDetail?inspectionId= key for the full per-inspection record
+        "imo_number": i.get("imoNumber"),
+        "ship_name": i.get("shipName"),
+        "ship_type": i.get("shipTypeDescription"),
+        "flag_code": _flag(i.get("flag"))["code"],
+        "flag_name": _flag(i.get("flag"))["name"],
+        "age": i.get("age"),
+        "inspection_date": i.get("inspectionDate"),        # dd/mm/yyyy
+        "inspection_type": (i.get("inspectionType") or {}).get("description") if isinstance(i.get("inspectionType"), dict) else None,
+        "member_state": i.get("memberStateDescription"),
+        "port_name": i.get("portName"),
+        "port_and_ms": i.get("portAndMS"),                 # "Slovenia - Koper"
+        "ndeficiencies": i.get("ndeficiencies"),
+        "results_desc": i.get("resultsDesc"),
+    } for i in ((data or {}).get("results") or []) if isinstance(i, dict)]
+    resume = (data or {}).get("resume") or {}
+    return {
+        "rows": rows,
+        "count": len(rows),
+        "total": (data or {}).get("total"),
+        "resume": {
+            "ships": resume.get("ships"),
+            "inspections": resume.get("inspections"),
+            "detentions": resume.get("detentions"),
+            "ism_deficiencies": resume.get("ismDeficiencies"),
+            "non_ism_deficiencies": resume.get("nonISMDeficiencies"),
+            "bans": resume.get("bans"),
+        } if isinstance(resume, dict) else None,
+        "paging": {"page": params.get("page"), "start": params.get("start"), "limit": params.get("limit")},
+    }
+
+
+def _check_date(s, label):
+    """Strict dd/mm/yyyy validation (the upstream format really is day/month/year — a wrong order silently returns empty)."""
+    from datetime import datetime
+    try:
+        return datetime.strptime(s, "%d/%m/%Y")
+    except (TypeError, ValueError):
+        raise SdkError("usage_error", provider=provider["id"],
+                       detail=f"{label} must be dd/mm/yyyy (e.g. 01/01/2026) — {s!r} does not match as measured")
+
+
+def detentions_raw(*, cache=None, no_cache=False):
+    """0.3.5 flat face internals: the current detentions snapshot in one request (upstream has no filter params).
+
+    -> {rows[], count, params, _meta} — params={} (zero upstream params)."""
+    from ..transport import call_provider
+
+    params = {}
+    r = call_provider(provider, "detentions", params, cache=cache, no_cache=no_cache)
+    return {**detentions_from_upstream(r["data"]), "params": params, "_meta": r}
+
+
+def bans_raw(*, cache=None, no_cache=False):
+    """0.3.5 flat face internals: the bans register in one request (upstream has no filter params).
+
+    -> {rows[], count, params, _meta}."""
+    from ..transport import call_provider
+
+    params = {}
+    r = call_provider(provider, "bans", params, cache=cache, no_cache=no_cache)
+    return {**bans_from_upstream(r["data"]), "params": params, "_meta": r}
+
+
+def low_performance_raw(*, cache=None, no_cache=False):
+    """0.3.5 flat face internals: the low-performance ISM company list in one request (rolling 6-month window, upstream has no filter params).
+
+    -> {rows[], count, params, _meta}."""
+    from ..transport import call_provider
+
+    params = {}
+    r = call_provider(provider, "low_performance", params, cache=cache, no_cache=no_cache)
+    return {**low_performance_from_upstream(r["data"]), "params": params, "_meta": r}
+
+
+def inspections_raw(*, period_min, period_max, psc_inspection_regime=1, page=1, start=0, limit=50,
+                    ism_company_name=None, ism_company_imo_number=None,
+                    cache=None, no_cache=False):
+    """0.3.5 flat face internals: historical PSC inspection window search (form-encoded POST).
+
+    -> {rows[], count, total, resume, paging, params, _meta}. The <= 3 year window is validated locally first
+    (upstream silently returns empty beyond it); **page always travels with the request** (without page the whole
+    window is dumped and the limit is void — the face pins the paging semantics). 0.3.20 audit truths (probed
+    2026-11-02): pscInspectionRegime=1 is the only live value (0 -> poisoned empty, 2 -> HTTP 500 — walled locally
+    with evidence); the 500 limit cap is a **local politeness tier** (upstream honors 1000 — measured 1,000 rows
+    of a 1,395-total Jan-2026 window); ismCompanyImoNumber accepts both the zero-padded 7-digit and the unpadded
+    form (measured 52193 and 0052193 both -> total=1) — passed verbatim, no normalization."""
+    from ..transport import call_provider
+
+    d1, d2 = _check_date(period_min, "period_min"), _check_date(period_max, "period_max")
+    if d2 < d1:
+        raise SdkError("usage_error", provider=provider["id"],
+                       detail=f"period_max({period_max}) is earlier than period_min({period_min}) — inverted window")
+    if (d2 - d1).days > 366 * 3:
+        raise SdkError("usage_error", provider=provider["id"],
+                       detail=f"the search window of {(d2 - d1).days} days exceeds the 3-year cap (an upstream limit) — split the search")
+    if int(psc_inspection_regime) != 1:
+        # 0.3.20 audit (probed 2026-11-02, Jan-2026 window): regime=1 is the only live value — 0 returns
+        # 200 success with total=0 (a poisoned empty), 2 returns HTTP 500. Wall it with the evidence instead
+        # of letting either silent shape through.
+        raise SdkError("usage_error", provider=provider["id"],
+                       detail=f"psc_inspection_regime={psc_inspection_regime!r} is not a live upstream value — 1 (PSC) is the "
+                              "only regime the public endpoint serves (measured: 0 -> 200 poisoned-empty total=0, "
+                              "2 -> HTTP 500)")
+    params = {
+        "pscInspectionRegime": int(psc_inspection_regime),  # mandatory (1 = PSC default regime; without it = 200 empty)
+        "periodMin": period_min,
+        "periodMax": period_max,
+        "page": max(1, int(page)),
+        "start": max(0, int(start)),
+        "limit": min(500, max(1, int(limit))),
+        "ismCompanyName": ism_company_name,
+        "ismCompanyImoNumber": ism_company_imo_number,
+    }
+    r = call_provider(provider, "inspections", params, cache=cache, no_cache=no_cache)
+    return {**inspections_from_upstream(r["data"], params), "params": params, "_meta": r}

agentdata/esg/thetis_mrv.py

@@ -0,0 +1,67 @@
+"""thetis_mrv — EU MRV ship emissions reporting (THETIS-MRV, EMSA) versioned bulk-file catalog provider (keyless).
+
+esg port-state emissions axis (2026-10-29, 0.3.5 batch): mrv.emsa.europa.eu is an ExtJS shell (app.json ->
+a 9.5MB app.js was reverse-engineered) that yielded the `/api/public-emission-report/` family of 19 endpoints;
+this face adopts the **reporting-period x versioned-publication listing** query (the XLSX bodies, ~9.5MB per
+file, still go through the batch pipeline; this SDK does not proxy large-file downloads — same posture as eutl).
+Measured shape (2026-10-29):
+- `reporting-periods` -> `[{value: 2018..2025}]`, eight years (2018 is the first reporting year).
+- `downloadable-files` -> `{results: [{reportingPeriod, version, generationDate "DD-MM-YYYY HH:MM:SS",
+  fileName}], total}` — **versioned rolling regeneration** (the 2025 file was v76 at the 10-20 probe and had
+  already jumped to v76/v254 by 10-29; the 2024 file is v254) — reconcile against the listing, never guess
+  file names; generationDate is mostly an early-morning batch (05:2x).
+- The download path is the template `reporting-period-document/binary/{year}/{version}` (an XLSX attachment;
+  Range is ignored and the full 200 body comes back — mind this in the batch pipeline). The file schema gains
+  columns year by year (no CH₄/N₂O columns before 2024).
+TTL 1 day (the version ledger rolls with the daily batch); politeness tier 0.5 rps.
+"""
+
+provider = {
+    "id": "thetis_mrv",
+    "baseUrl": "https://mrv.emsa.europa.eu",
+    "rate": {"rps": 0.5, "burst": 2},
+    "ops": {
+        "periods": {"path": "/api/public-emission-report/reporting-periods"},  # [{value: year}] in one response
+        "files": {"path": "/api/public-emission-report/downloadable-files"},   # {results, total} version ledger
+    },
+    "ttl": {"periods": 86400, "files": 86400},
+}
+
+_BINARY_PATH = "/api/public-emission-report/reporting-period-document/binary/{period}/{version}"
+
+
+def datasets_from_upstream(periods_data, files_data):
+    """Two op responses -> datasets face result (pure function, offline-testable).
+
+    rows are sorted by reportingPeriod descending (newest reporting period first); download_path is a template
+    path (the batch pipeline assembles the download URL from it)."""
+    periods = [p.get("value") for p in (periods_data or []) if isinstance(p, dict) and p.get("value") is not None]
+    rows = []
+    for f in ((files_data or {}).get("results") or []):
+        if not isinstance(f, dict):
+            continue
+        period, version = f.get("reportingPeriod"), f.get("version")
+        rows.append({
+            "reporting_period": period,
+            "version": version,
+            "generation_date": f.get("generationDate"),   # "DD-MM-YYYY HH:MM:SS" (early-morning batch timestamp)
+            "file_name": f.get("fileName"),               # "2025-v76-29102026-EU MRV Publication of information"
+            "download_path": _BINARY_PATH.format(period=period, version=version) if period is not None and version is not None else None,
+        })
+    rows.sort(key=lambda r: (r["reporting_period"] or 0, r["version"] or 0), reverse=True)
+    return {"rows": rows, "count": len(rows), "reporting_periods": periods}
+
+
+def datasets_raw(*, cache=None, no_cache=False):
+    """0.3.5 flat face internals: two requests merged into the reporting-period + version ledger (upstream has no filter params — the client filters rows locally).
+
+    -> {rows[], count, reporting_periods[], params, _meta} — params={} (zero upstream params);
+    _meta is the round trip of the files op (the main ledger surface); a failing periods op is a hard
+    usage-level error (the whole result is untrustworthy)."""
+    from ..transport import call_provider
+
+    params = {}
+    periods = call_provider(provider, "periods", params, cache=cache, no_cache=no_cache)
+    files = call_provider(provider, "files", params, cache=cache, no_cache=no_cache)
+    out = datasets_from_upstream(periods["data"], files["data"])
+    return {**out, "params": params, "_meta": files}

agentdata/healthcare/__init__.py

@@ -0,0 +1,7 @@
+"""healthcare domain package — flat provider adapters (one file per source) + faces/cli (domain reorg in 0.2.6).
+
+One domain per package: provider adapters laid flat (one source per file) + faces/cli.
+"""
+from . import (ctgov, dailymed, epmc, eudamed, gudid, mesh,  # noqa: F401
+               fda_crl, fda_devices, fda_drugs, fda_recalls, rxnav, shortages, au_tga, gb_mhra,
+               ca_dpd, ca_mdall, rasff, safety_gate)

agentdata/healthcare/au_tga.py

@@ -0,0 +1,142 @@
+"""au_tga — Australian TGA eBS public face provider (a Domino .nsf site family; keyless).
+
+Wave 6 of the healthcare domain: related
+kind=artg_register / mis_manufacturers — the Australian therapeutic goods register ARTG, 97,988 product × sponsor
+company edges, plus the Australian manufacturer licence register MIS with 444 licence × manufacturer rows.
+Shapes measured 2026-10-23:
+Host gating is split by host: ebs.tga.gov.au is fully open (both the curl and undici stacks), www.tga.gov.au hangs after connecting from this egress (do not probe the main site).
+ARTG search: GET /ebs/ANZTPAR/PublicWeb.nsf/luPortalRegisterPublic?SearchView=&Query="Sun Pharma ANZ Pty Ltd"&Count=N&Start=M&charset=utf-8
+  — an **HTML surface** (SearchView does not honour outputformat=json, it was measured returning text/html): the op passes the raw text through with accept:'text'.
+  Query semantics: a quoted phrase = an exact phrase (measured Sun Pharma ANZ 100/100 hits); bare words = AND across all fields.
+  Row columns Name|ARTG|PI/CMI|Type|Sponsor (rows carry an OpenDocument detail link, and the row also starts with a sort-icon td that is not a data column);
+  Count=100 gives a 100-row page; Start = the number of rows to skip (skip semantics). Field-level search ([Sponsor] CONTAINS …) is bounced back to the search form — not done.
+ARTG enumeration (the raw bulk line): the same view ?ReadViewEntries&outputformat=json&Count≤15000&Start=N (count=100000 → 500 OOM).
+MIS licences: GET /ebs/ANZTPAR/PublicWeb.nsf/luPortalManufacturers?ReadViewEntries&outputformat=json&count=500 → JSON,
+  @toplevelentries=444; row columns Issue Date|Licence Number|Manufacturer ID|Address|**SiteState**|Manufacturer
+  (the state column's real name is SiteState, not the portal config's ColTitles «State» — the column name is the viewentry @name).
+TTL: the register is on a daily cadence → 24h; no published quota → polite tier 1 rps.
+"""
+import re
+
+from ..errors import SdkError
+
+provider = {
+    "id": "au_tga",
+    "baseUrl": "https://www.ebs.tga.gov.au/ebs/ANZTPAR/PublicWeb.nsf",
+    "rate": {"rps": 1, "burst": 2},
+    "ops": {
+        "search": {"path": "/luPortalRegisterPublic", "accept": "text"},  # params: SearchView/Query/Count/Start/charset → HTML
+        "manufacturers": {"path": "/luPortalManufacturers"},              # params: ReadViewEntries/outputformat/count/charset → JSON
+    },
+    "ttl": {"search": 24 * 3600, "manufacturers": 24 * 3600},
+}
+
+_TR_RE = re.compile(r"<tr[\s\S]*?</tr>", re.I)
+_TD_RE = re.compile(r"<td[^>]*>([\s\S]*?)</td>", re.I)
+_DOC_RE = re.compile(r'href="([^"]*OpenDocument[^"]*)"', re.I)
+_TAG_RE = re.compile(r"<[^>]+>")
+_IMG_RE = re.compile(r"<img", re.I)
+_A_RE = re.compile(r"<a[\s>]", re.I)
+
+
+def _cell_text(h):
+    s = _TAG_RE.sub(" ", str(h or ""))
+    s = (s.replace("&amp;", "&").replace("&quot;", '"')
+          .replace("&#39;", "'").replace("&rsquo;", "'").replace("&nbsp;", " "))
+    return re.sub(r"\s+", " ", s).strip()
+
+
+def rows_from_search_html(html):
+    """SearchView HTML → ARTG rows (pure function, testable offline): only rows with an OpenDocument detail link count; pure icon tds are stripped (measured 6 td → 5 data tds)."""
+    rows = []
+    for m in _TR_RE.finditer(str(html or "")):
+        tr = m.group(0)
+        if "OpenDocument" not in tr:
+            continue
+        cells = [c for c in _TD_RE.findall(tr)
+                 if not (_IMG_RE.search(c) and not _A_RE.search(c) and not _TAG_RE.sub("", c).strip())]
+        if len(cells) < 5:
+            continue
+        href = _DOC_RE.search(tr)
+        rows.append({
+            "product_name": _cell_text(cells[0]) or None,
+            "artg_id": _cell_text(cells[1]) or None,
+            "pi_cmi": _cell_text(cells[2]) or None,
+            "product_type": _cell_text(cells[3]) or None,
+            "sponsor": _cell_text(cells[4]) or None,   # company edge, primary column (the registrant = the entity accountable for the Australian market)
+            "doc_url": ("https://www.ebs.tga.gov.au" + href.group(1).replace("&amp;", "&")) if href else None,
+        })
+    return rows
+
+
+def _entry_val(d):
+    if not d:
+        return None
+    # Domino value-object shape {"0": "..."} (mirrors the d.text[0] property access on the Node side)
+    if d.get("text"):
+        return d["text"].get("0") or None
+    if d.get("number") is not None:
+        return str(d["number"].get("0"))
+    if d.get("datetime") is not None:
+        return re.sub(r"^(\d{4})(\d{2})(\d{2}).*$", r"\1-\2-\3", str(d["datetime"].get("0")))
+    return None
+
+
+def rows_from_view_json(data):
+    """ReadViewEntries JSON (the Domino viewentry shape) → MIS licence rows (pure function, testable offline); datetime→YYYY-MM-DD, the state column's real name is SiteState."""
+    out = []
+    for e in (data or {}).get("viewentry") or []:
+        col = {d.get("@name"): d for d in e.get("entrydata") or []}
+        out.append({
+            "issue_date": _entry_val(col.get("Issue Date")),
+            "licence_number": _entry_val(col.get("Licence Number")),
+            "manufacturer_id": _entry_val(col.get("Manufacturer ID")),
+            "address": _entry_val(col.get("Address")),
+            "state": _entry_val(col.get("SiteState")),
+            "manufacturer": _entry_val(col.get("Manufacturer")),  # company edge, primary column (the licence holder)
+        })
+    return out
+
+
+def build_search_query(sponsor=None, query=None):
+    """Domino Query assembly (pure function, testable offline): sponsor → a quoted phrase (measured exact);
+    query → passed through as given (a quoted phrase is upstream-native syntax; since 0.3.0 the quotes are not stripped — stripping them would make the exact Sponsor match unreachable)."""
+    sp, q = str(sponsor or "").strip(), str(query or "").strip()
+    if not sp and not q:
+        raise SdkError("usage_error", provider="au_tga", detail="sponsor or query is required (a bare query would enumerate the whole 98,000-row register, so it is refused)")
+    if sp:
+        return '"' + sp.replace('"', "") + '"'
+    return q
+
+
+def search_art_register(sponsor=None, query=None, *, limit=20, skip=0, cache=None, no_cache=False):
+    """→ {rows[], count, skip, limit_applied, has_more, query, _meta}; has_more is a full-page heuristic (Domino does not return the hit total)."""
+    from ..transport import call_provider
+
+    q = build_search_query(sponsor, query)
+    size = min(max(1, int(limit or 20)), 100)  # SearchView Count measured 100/page
+    sk = max(0, int(skip or 0))
+    params = {"SearchView": "", "Query": q, "Count": size, "charset": "utf-8"}
+    if sk:
+        params["Start"] = sk  # Start = the number of rows to skip (skip semantics; measured Start=100 continues onto the next page)
+    r = call_provider(provider, "search", params, cache=cache, no_cache=no_cache)
+    rows = rows_from_search_html(r.get("data"))
+    return {"rows": rows, "count": len(rows), "skip": sk, "limit_applied": size,
+            "has_more": len(rows) == size, "query": q, "_meta": r}
+
+
+def list_manufacturers(state=None, *, limit=100, cache=None, no_cache=False):
+    """→ {rows[], total, count, limit_applied, _meta} — the MIS licence register: 444 licences in one full shot (count=500 on a single page) + the state filter."""
+    from ..transport import call_provider
+
+    size = min(max(1, int(limit or 100)), 500)
+    r = call_provider(provider, "manufacturers",
+                      {"ReadViewEntries": "", "outputformat": "json", "count": 500, "charset": "utf-8"},
+                      cache=cache, no_cache=no_cache)
+    data = r.get("data") or {}
+    total = int(data.get("@toplevelentries") or 0)
+    rows = rows_from_view_json(data)
+    if state:
+        rows = [x for x in rows if (x.get("state") or "").upper() == str(state).strip().upper()]
+    return {"rows": rows[:size], "total": total, "count": min(len(rows), size),
+            "limit_applied": size, "_meta": r}

agentdata/healthcare/ca_dpd.py

@@ -0,0 +1,123 @@
+"""ca_dpd — Health Canada Drug Product Database open API face provider
+(health-products.canada.ca/api/drug/; keyless).
+
+healthcare domain (0.3.19; admitted 2026-11-02, probed). Shapes verified by first-hand live probing
+2026-11-02 (the probe corpus lives in tmp/probe-ca-eu-faces/):
+GET /api/drug/company/?lang=en&type=json
+  → the full company register in ONE shot (no pagination surface on this host — 5,253 rows
+    measured 2026-11-02; rows carry company_code (the DPD join key) + company_name +
+    company_type (DIN OWNER / …) + the full postal address).
+    **Pit nailed: the Read Me page (GET /api/drug/ — the HTML index of the API family) is the
+    only enum documentation; the naive guess "status codes endpoint" (/api/drug/status) returns
+    the per-drug status *history* table (10.3MB), not the enum.**
+GET /api/drug/drugproduct/?status=<n>&lang=en&type=json
+  → drug products filtered by market status. **status is a closed set 1|2|3|4|6 per the Read Me
+    page — 1=Approved, 2=Marketed, 3=Cancelled Pre-Market, 4=Cancelled Post-Market, 6=Dormant
+    (no 5 in the official set); any other value is silently ignored and the endpoint dumps the
+    whole unfiltered register (15MB, ~55k rows — the silent-filter-ignored trap, same family as
+    the Socrata ones), so status is REQUIRED here and validated against the closed set.**
+    Rows carry drug_code + drug_identification_number (DIN) + brand_name + company_name inline
+    (company_code is NOT echoed on this face — join via company_name or run the company face);
+    the row does not echo the requested status either.
+  Measured: status=3 → 4,116 rows (2026-11-02).
+Param-minimalism pitfall (this host publishes no per-endpoint docs beyond the Read Me links):
+unprobed param combinations → either silent no-op or a full dump — this face accepts only the
+documented lang/type/status family, do not widen it.
+Local row slicing (limit/skip) is a post-slice over the single cached full shot — the upstream
+has no paging, and the register itself is the payload (a monthly static extract).
+TTL 7 days (the DPD monthly extract changes slowly); polite rate 1 rps (the host publishes no
+quota — conservative; the same host also serves ca_mdall, the shared host bucket coordinates them).
+"""
+from ..errors import SdkError
+
+provider = {
+    "id": "ca_dpd",
+    "baseUrl": "https://health-products.canada.ca",
+    "rate": {"rps": 1, "burst": 2},
+    "ops": {
+        "companies": {"path": "/api/drug/company/"},        # params: lang/type fixed for this face
+        "drug_products": {"path": "/api/drug/drugproduct/"},  # params: lang/type fixed + status (required, closed set)
+    },
+    "ttl": {"companies": 7 * 86400, "drug_products": 7 * 86400},
+}
+
+_STATUS = {1: "Approved", 2: "Marketed", 3: "Cancelled Pre-Market",
+           4: "Cancelled Post-Market", 6: "Dormant"}  # the Read Me closed set (measured: no 5 in the family links)
+
+
+def companies_from_upstream(data):
+    """Upstream company array → company rows (pure function, offline-testable)."""
+    rows = [{
+        "company_code": r.get("company_code"),          # the DPD join key
+        "company_name": r.get("company_name"),
+        "company_type": r.get("company_type"),          # e.g. DIN OWNER
+        "address": {k: r.get(k) for k in ("street_name", "city_name", "province_name",
+                                          "country_name", "postal_code")},
+    } for r in (data or []) if isinstance(r, dict)]
+    return {"rows": rows, "count": len(rows)}
+
+
+def drug_products_from_upstream(data, status):
+    """Upstream drug-product array → product rows (pure function, offline-testable)."""
+    rows = [{
+        "drug_code": r.get("drug_code"),
+        "din": r.get("drug_identification_number"),     # the 8-digit DIN (the dispensed-product key)
+        "brand_name": r.get("brand_name"),
+        "class_name": r.get("class_name"),              # Human / Veterinary
+        "company_name": r.get("company_name"),          # inline on this face; company_code is NOT echoed
+        "number_of_ais": r.get("number_of_ais"),
+        "ai_group_no": r.get("ai_group_no"),
+        "last_update_date": r.get("last_update_date"),
+    } for r in (data or []) if isinstance(r, dict)]
+    return {"rows": rows, "count": len(rows), "total": len(rows),
+            "status": int(status), "status_label": _STATUS[int(status)]}
+
+
+def _slice(rows, limit, skip):
+    """Local post-slice over the single cached full shot (the upstream has no paging surface)."""
+    off = int(skip) if skip is not None else 0
+    if off < 0:
+        raise SdkError("usage_error", provider="ca_dpd", detail=f"skip must be >=0, got \"{skip}\"")
+    size = int(limit) if limit is not None else 200
+    if size < 1:
+        raise SdkError("usage_error", provider="ca_dpd", detail=f"limit must be >=1 (local post-slice, no upstream cap), got \"{limit}\"")
+    return rows[off:off + size]
+
+
+def companies_raw(*, limit=200, skip=0, cache=None, no_cache=False):
+    """Flat-panel low-level face: the DPD company register, one full shot (5,253 rows measured
+    2026-11-02) cached whole; limit/skip is a local post-slice.
+
+    → {rows[], count, total, params, _meta} — total = the whole register size (not the page)."""
+    from ..transport import call_provider
+
+    params = {"lang": "en", "type": "json"}
+    r = call_provider(provider, "companies", params, cache=cache, no_cache=no_cache)
+    out = companies_from_upstream(r["data"])
+    rows = _slice(out["rows"], limit, skip)
+    return {"rows": rows, "count": len(rows), "total": out["count"],
+            "params": params, "_meta": r}
+
+
+def drug_products_raw(status, *, limit=200, skip=0, cache=None, no_cache=False):
+    """Flat-panel low-level face: DPD drug products by market status.
+
+    status = the Read Me closed set 1|2|3|4|6 (1=Approved 2=Marketed 3=Cancelled Pre-Market
+    4=Cancelled Post-Market 6=Dormant) — REQUIRED and validated: any other value is silently
+    ignored upstream and dumps the whole 15MB register (the silent-filter trap).
+    → {rows[], count, total, status, status_label, params, _meta}."""
+    from ..transport import call_provider
+
+    try:
+        st = int(status)
+    except (TypeError, ValueError):
+        raise SdkError("usage_error", provider="ca_dpd",
+                       detail=f"status must be one of the Read Me closed set {sorted(_STATUS)} (1=Approved 2=Marketed 3=Cancelled Pre-Market 4=Cancelled Post-Market 6=Dormant), got \"{status}\"")
+    if st not in _STATUS:
+        raise SdkError("usage_error", provider="ca_dpd",
+                       detail=f"status must be one of {sorted(_STATUS)} ({'; '.join(f'{k}={v}' for k, v in sorted(_STATUS.items()))}) — an unknown value is silently ignored upstream and dumps the whole 15MB register, got \"{status}\"")
+    params = {"lang": "en", "type": "json", "status": st}
+    r = call_provider(provider, "drug_products", params, cache=cache, no_cache=no_cache)
+    out = drug_products_from_upstream(r["data"], st)
+    rows = _slice(out["rows"], limit, skip)
+    return {**out, "rows": rows, "count": len(rows), "params": params, "_meta": r}