aimedicalcoding 0.3.1__py3-none-any.whl

aimedicalcoding/systems/snomed/patterns.py

@@ -0,0 +1,166 @@
+"""Per-pattern SNOMED gap classification + parsers.
+
+Key difference from LOINC: SNOMED is the *concept* (answer). Depending on the
+slot it lives either in the observation **value** (problem/reaction/social/…) or
+in the node's **code** (procedure/allergen substance). We read the right slot per
+context, then classify.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Optional
+
+from ...core.checkdigits import is_valid_sctid
+from ...core.models import ClinicalStatement, CodingCandidate, Gap, System
+from ...core.system_registry import HL7_STRUCTURAL
+from . import qualifiers as Q
+from .hierarchy import SNOMED_CONTEXTS, hierarchy_for, resolve_hierarchy
+
+# contexts where the SNOMED concept is the observation VALUE (answer slot)
+VALUE_SLOT_CONTEXTS = {
+    "problem", "family_history", "allergy_reaction",
+    "social_history", "result_organism", "functional_status",
+}
+# the rest (procedure, allergy_substance, body_site, specimen) carry it on the CODE
+
+STRUCTURAL = HL7_STRUCTURAL | {System.NULLFLAVOR}
+ICD_SYSTEMS = {System.ICD10CM, System.ICD9CM, System.ICD10PCS}
+
+
+class SnomedGapPattern(str, Enum):
+    LOCAL_CODE_ONLY = "LOCAL_CODE_ONLY"   # a local/other clinical code (incl. CPT), no SNOMED
+    ICD_ONLY = "ICD_ONLY"                 # ICD-9/10 only -> ICD↔SNOMED crosswalk
+    NULLFLAVOR = "NULLFLAVOR"
+    DISPLAY_ONLY = "DISPLAY_ONLY"
+    NARRATIVE_ONLY = "NARRATIVE_ONLY"
+    BAD_CODE = "BAD_CODE"                 # SCTID-shaped but Verhoeff fails
+
+
+def is_snomed_expected(stmt: ClinicalStatement) -> bool:
+    return (
+        stmt.context in SNOMED_CONTEXTS
+        and (stmt.raw_text is not None or stmt.value is not None or stmt.codings)
+    )
+
+
+def concept_coding(stmt: ClinicalStatement) -> Optional[CodingCandidate]:
+    """The coding that represents the clinical concept for this slot.
+
+    For value-slot contexts, scan all value codings (root + translations) and
+    prefer a SNOMED coding (so a SNOMED translation is found even when another
+    system is primary); else fall back to the first real coding present.
+    """
+    if stmt.context in VALUE_SLOT_CONTEXTS:
+        codings = stmt.value.codings if stmt.value else []
+        snomed = next((c for c in codings
+                       if c.system == System.SNOMEDCT and c.code), None)
+        if snomed:
+            return snomed
+        other = next((c for c in codings
+                      if c.code and c.system not in STRUCTURAL), None)
+        return other or (stmt.value.coded_value if stmt.value else None)
+    # code-slot: first non-structural coding with a code
+    return next((c for c in stmt.codings
+                 if c.code and c.system not in STRUCTURAL), None)
+
+
+def concept_term(stmt: ClinicalStatement) -> Optional[str]:
+    """The human label of the concept (value display for value-slots, code
+    display for code-slots), falling back to recovered value originalText."""
+    cc = concept_coding(stmt)
+    if cc and cc.display:
+        return cc.display
+    if stmt.context in VALUE_SLOT_CONTEXTS and stmt.value:
+        return stmt.value.original_text or stmt.value.raw
+    return stmt.raw_text
+
+
+def concept_labels(stmt: ClinicalStatement) -> tuple[Optional[str], Optional[str]]:
+    """(display_name, original_text) for the concept's own slot."""
+    if stmt.context in VALUE_SLOT_CONTEXTS:
+        cc = stmt.value.coded_value if stmt.value else None
+        display = cc.display if (cc and cc.code) else None
+        ot = stmt.value.original_text if stmt.value else None
+        return display, ot
+    # code-slot (procedure / allergen substance): the node's own code labels
+    cc = concept_coding(stmt)
+    return (cc.display if cc else stmt.display_name), stmt.original_text
+
+
+def _has_nullflavor(stmt: ClinicalStatement) -> bool:
+    if any(c.system == System.NULLFLAVOR for c in stmt.codings):
+        return True
+    cv = stmt.value.coded_value if stmt.value else None
+    return bool(cv and cv.system == System.NULLFLAVOR)
+
+
+def classify(stmt: ClinicalStatement) -> Optional[SnomedGapPattern]:
+    if not is_snomed_expected(stmt):
+        return None
+
+    cc = concept_coding(stmt)
+
+    if cc and cc.system == System.SNOMEDCT and cc.code:
+        # valid SNOMED present -> no gap (active/hierarchy checks need the DB)
+        return None if is_valid_sctid(cc.code) else SnomedGapPattern.BAD_CODE
+
+    if cc and cc.code and cc.system in ICD_SYSTEMS:
+        return SnomedGapPattern.ICD_ONLY
+    if cc and cc.code and cc.system not in STRUCTURAL:
+        return SnomedGapPattern.LOCAL_CODE_ONLY   # CPT / local / other
+
+    # no usable concept code
+    if _has_nullflavor(stmt):
+        return SnomedGapPattern.NULLFLAVOR
+    if stmt.raw_text:
+        if "/text" in (stmt.source_ref or ""):
+            return SnomedGapPattern.NARRATIVE_ONLY
+        return SnomedGapPattern.DISPLAY_ONLY
+    return None
+
+
+# --------------------------------------------------------------------------
+
+def _base(stmt, pattern, label, ecl, term) -> Gap:
+    return Gap(
+        type=pattern.value,
+        match_key=Q.build_match_key(stmt, label, term),
+        evidence=Q.evidence_packet(stmt, label, ecl, term),
+    )
+
+
+def parse_gap(stmt: ClinicalStatement, pattern: SnomedGapPattern) -> Gap:
+    term = concept_term(stmt)
+    # semantic tag in the term (e.g. "... (procedure)") overrides the section
+    # default so a Problem-List procedure/situation isn't forced to Clinical finding.
+    label, ecl = resolve_hierarchy(stmt.context, term) or ("?", "?")
+    gap = _base(stmt, pattern, label, ecl, term)
+    # concept labels come from the value slot for value-slot contexts
+    dn, ot = concept_labels(stmt)
+    gap.evidence["display_name"] = dn
+    gap.evidence["original_text"] = ot
+    cc = concept_coding(stmt)
+
+    if pattern == SnomedGapPattern.LOCAL_CODE_ONLY and cc:
+        gap.evidence["local_code"] = cc.code
+        gap.evidence["local_system"] = cc.raw_system
+        gap.note = ("Crosswalk (system, code) → SNOMED first (e.g. CPT/local map); "
+                    "else hierarchy-constrained text search, then LLM.")
+    elif pattern == SnomedGapPattern.ICD_ONLY and cc:
+        gap.evidence["icd_code"] = cc.code
+        gap.evidence["icd_system"] = (cc.system.value if cc.system else None)
+        gap.note = ("Use the official ICD↔SNOMED map (NLM/UMLS) — deterministic; "
+                    "LLM only to choose among multiple map targets.")
+    elif pattern == SnomedGapPattern.BAD_CODE and cc:
+        gap.evidence["malformed_code"] = cc.code
+        gap.note = "SCTID-shaped but Verhoeff check failed; resolve via text + hierarchy."
+    elif pattern == SnomedGapPattern.NULLFLAVOR:
+        nf = next((c for c in stmt.codings if c.system == System.NULLFLAVOR), None)
+        gap.evidence["null_flavor"] = nf.raw_system if nf else None
+        gap.note = "Label recovered from originalText; hierarchy-constrained text search."
+    elif pattern == SnomedGapPattern.DISPLAY_ONLY:
+        gap.note = "Display text only; hierarchy-constrained text search."
+    elif pattern == SnomedGapPattern.NARRATIVE_ONLY:
+        gap.note = "Narrative-table text; resolve via hierarchy-constrained search (low priority)."
+    return gap

aimedicalcoding/systems/snomed/qualifiers.py

@@ -0,0 +1,90 @@
+"""SNOMED disambiguation: term normalization, qualifier extraction, match key.
+
+SNOMED's analog of LOINC's axes is: hierarchy (from section) + qualifiers
+(laterality, severity, clinical course, context/negation) parsed from the text.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from ...core.models import ClinicalStatement
+
+_PUNCT = re.compile(r"[^\w\s]")
+_WS = re.compile(r"\s+")
+
+_LATERALITY = ["bilateral", "left", "right"]
+_SEVERITY = ["mild", "moderate", "severe"]
+_COURSE = ["acute", "chronic", "acute on chronic"]
+_CONTEXT = {
+    "family history": "family-history",
+    "history of": "history-of",
+    "no known": "absent",
+    "denies": "absent",
+    "negative for": "absent",
+    "suspected": "suspected",
+}
+
+
+def normalize_term(text: Optional[str]) -> Optional[str]:
+    if not text:
+        return None
+    t = _PUNCT.sub(" ", text.lower())
+    t = _WS.sub(" ", t).strip()
+    return t or None
+
+
+def _find(text: str, options: list[str]) -> Optional[str]:
+    for o in options:
+        if re.search(rf"\b{re.escape(o)}\b", text):
+            return o
+    return None
+
+
+def extract_qualifiers(stmt: ClinicalStatement, term: Optional[str] = None) -> dict:
+    text = ((term or stmt.raw_text or "")).lower()
+    ctx = None
+    for kw, val in _CONTEXT.items():
+        if kw in text:
+            ctx = val
+            break
+    return {
+        "laterality": _find(text, _LATERALITY),
+        "severity": _find(text, _SEVERITY),
+        "course": _find(text, _COURSE),
+        "negation_context": ctx,
+    }
+
+
+def build_match_key(stmt: ClinicalStatement, hierarchy_label: str,
+                    term: Optional[str] = None) -> str:
+    """component | hierarchy | laterality | severity | course | context."""
+    term = term or stmt.raw_text
+    q = extract_qualifiers(stmt, term)
+    parts = [
+        f"component:{normalize_term(term) or '?'}",
+        f"hierarchy:{hierarchy_label or '?'}",
+        f"laterality:{q['laterality'] or '-'}",
+        f"severity:{q['severity'] or '-'}",
+        f"course:{q['course'] or '-'}",
+        f"context:{q['negation_context'] or 'current'}",
+    ]
+    return " | ".join(parts)
+
+
+def evidence_packet(stmt: ClinicalStatement, hierarchy_label: str, ecl: str,
+                    term: Optional[str] = None) -> dict:
+    term = term or stmt.raw_text
+    q = extract_qualifiers(stmt, term)
+    return {
+        "term": term,
+        "term_normalized": normalize_term(term),
+        "target_hierarchy": hierarchy_label,
+        "ecl": ecl,
+        "laterality": q["laterality"],
+        "severity": q["severity"],
+        "course": q["course"],
+        "context": q["negation_context"] or "current",
+        "section_context": stmt.context,
+    }

aimedicalcoding/terminology/__init__.py

@@ -0,0 +1,3 @@
+from .service import TerminologyService
+
+__all__ = ["TerminologyService"]

aimedicalcoding/terminology/service.py

@@ -0,0 +1,31 @@
+"""Terminology DB service — PLACEHOLDER.
+
+Will wrap the local terminology database: exact lookup, existence/deprecation,
+free-text candidate search (returning a constrained set), axis/attribute
+retrieval, crosswalks. Loaders for Loinc.csv / SNOMED RF2 / RxNorm RRF / ICD
+files will live under terminology/loaders/.
+See ARCHITECTURE.md §5.4.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from ..core.models import System
+
+
+class TerminologyService:
+    def lookup(self, system: System, code: str) -> Optional[dict[str, Any]]:
+        raise NotImplementedError("DB layer is a placeholder (parsing-first phase).")
+
+    def is_deprecated(self, system: System, code: str) -> bool:
+        raise NotImplementedError("DB layer is a placeholder (parsing-first phase).")
+
+    def search_candidates(
+        self, system: System, match_key: str, limit: int = 10
+    ) -> list[dict[str, Any]]:
+        """Free-text + axis-filtered candidate search for the recovery layer."""
+        raise NotImplementedError("DB layer is a placeholder (parsing-first phase).")
+
+    def crosswalk(self, from_system: System, code: str, to_system: System) -> list[str]:
+        raise NotImplementedError("DB layer is a placeholder (parsing-first phase).")

aimedicalcoding-0.3.1.dist-info/METADATA

@@ -0,0 +1,276 @@
+Metadata-Version: 2.4
+Name: aimedicalcoding
+Version: 0.3.1
+Summary: Detect missing/broken clinical codes (LOINC / SNOMED CT / RxNorm / ICD-10-CM / CVX) in CCDA and FHIR documents, with recovery evidence
+Author: Aakash Kag, Vinay Shankar Miryala, Siva Karthik, Mohammed Rayaan
+License: MIT
+Keywords: loinc snomed rxnorm icd-10-cm cvx ccda fhir clinical-terminology medical-coding interoperability
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml>=4.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# aimedicalcoding
+
+**Find every missing or broken standard clinical code in a CCDA or FHIR document — with the evidence needed to fix it.**
+
+`aimedicalcoding` parses a clinical document (CCDA XML or FHIR R4 Bundle JSON),
+inspects every coded clinical item — labs, vitals, problems, medications,
+immunizations, allergies, procedures, social history — and reports the ones
+whose standard terminology code (**LOINC · SNOMED CT · RxNorm · ICD-10-CM ·
+CVX**) is missing, local-only, crosswalkable, or malformed. Each finding (a
+*gap*) is emitted as a self-contained JSON record carrying the classification,
+the document facts, and a ready-made recovery plan (search terms, axis filters,
+crosswalk candidates, check-digit corrections).
+
+Items that are already correctly coded produce no output — the result is a
+work list, not an inventory.
+
+---
+
+## Installation
+
+```bash
+pip install aimedicalcoding
+```
+
+Requires Python 3.10+. The only runtime dependency is `lxml`.
+
+---
+
+## Quick start (CLI)
+
+The input format is **auto-detected** — the same command works for CCDA XML
+and FHIR JSON, and the output schema is identical for both.
+
+```bash
+# human-readable gap report (card view)
+aimedicalcoding patient.xml
+
+# FHIR R4 Bundle — same flags, same output
+aimedicalcoding bundle.json --table
+
+# counts only
+aimedicalcoding patient.xml --summary --table
+
+# machine-readable JSON, written to a file as UTF-8
+aimedicalcoding patient.xml --out gaps.json
+
+# restrict to one terminology and/or certain contexts
+aimedicalcoding patient.xml --system loinc --contexts result,vital
+```
+
+If the entry point is not on your PATH, `python -m aimedicalcoding <file> [flags]`
+is equivalent.
+
+### CLI flags
+
+| Flag | Meaning |
+|---|---|
+| `--system` | `loinc` \| `snomed` \| `rxnorm` \| `icd10cm` \| `cvx` \| `all` (default `all`) |
+| `--contexts` | comma-separated contexts to include, e.g. `result,vital,problem` |
+| `--table` | compact one-line-per-gap table |
+| `--json` | print the JSON report to stdout |
+| `-o, --out FILE` | write the JSON report to FILE as UTF-8 (implies `--json`) |
+| `--summary` | counts only |
+| `--include-narrative` | also report narrative-table-only items (CCDA; off by default) |
+| `--apply-dict` | expand lab abbreviations (BUN → urea nitrogen) in search terms |
+| `--json-full` | dump the complete internal representation (debugging) |
+
+---
+
+## Quick start (Python)
+
+```python
+from aimedicalcoding import extract_gaps
+
+result = extract_gaps("patient.xml")        # CCDA — auto-detected
+result = extract_gaps("bundle.json")        # FHIR R4 Bundle — auto-detected
+result = extract_gaps(raw_bytes,            # bytes / str / path / file-like
+                      systems=("loinc", "snomed", "rxnorm", "icd10cm", "cvx"))
+
+len(result)           # number of gaps
+result.by_target      # {"LOINC": 17, "SNOMED-CT": 30, "RxNorm": 4, ...}
+result.by_pattern     # {"LOCAL_CODE_ONLY": 15, "NULLFLAVOR": 32, ...}
+result.gaps           # list[dict] — one record per (item, missing terminology)
+result.to_json()      # the same JSON the CLI emits
+```
+
+Lower-level access — parse to the intermediate representation without gap
+analysis:
+
+```python
+from aimedicalcoding.pipeline import parse_document
+
+statements = parse_document(open("bundle.json", "rb").read())
+for s in statements:
+    print(s.context, s.raw_text, [(c.system, c.code) for c in s.codings])
+```
+
+---
+
+## How it works
+
+The library is built on two independent axes that meet at a format-agnostic
+intermediate representation (IR):
+
+```
+ FORMAT axis (adapters)              TERMINOLOGY axis (extractors)
+   CCDA XML  ──┐                       LOINC      SNOMED CT
+   FHIR R4  ───┤──►  ClinicalStatement ──►  RxNorm   ICD-10-CM   CVX
+               │         (the IR)
+   (auto-detected)                    (identical for every input format)
+```
+
+1. **Detect** — XML with a `<ClinicalDocument>` root → CCDA adapter; JSON with
+   `"resourceType": "Bundle"` → FHIR adapter.
+2. **Parse to IR** — the adapter walks the document and emits one
+   `ClinicalStatement` per clinical item: every coding found on the item (root
+   code *plus* all translations / `coding[]` entries, each canonicalized by
+   system), the human labels, the value (quantity or coded answer), specimen,
+   panel membership, timestamps.
+3. **Extract gaps** — each terminology extractor examines the statements
+   relevant to it (labs/vitals for LOINC, problems/procedures/reactions for
+   SNOMED, medications for RxNorm, diagnoses for ICD-10-CM, immunizations for
+   CVX), validates any code present (check digits, format), and classifies
+   everything else into a gap pattern.
+4. **Serialize** — one JSON record per (item × missing terminology), identical
+   schema for CCDA and FHIR input.
+
+### What each adapter understands
+
+**CCDA**: document/section/entry structure, `<code>` + `<translation>`
+scan-and-identify, `nullFlavor`, `<originalText>` reference resolution into the
+narrative, organizer → panel linkage, specimen, interpretation and reference
+ranges, narrative-table fallback for sections without structured entries.
+
+**FHIR R4 Bundle**: routing by resource type + `Observation.category` (with
+section-tag fallback), `CodeableConcept.coding[]` as primary + translations,
+`valueQuantity` / `valueCodeableConcept` / `valueString` / `dataAbsentReason`,
+`hasMember` / `DiagnosticReport.result` panel linkage (children inherit context
+and specimen), `medicationReference → Medication.code` and
+`specimen → Specimen.type` resolution across the Bundle, per-reaction allergy
+statements, and normalization of `"unknown"` null-marker strings.
+
+---
+
+## Gap patterns
+
+Each record's `pattern` says *why* the code is missing — which determines how
+to fix it:
+
+| Pattern | What's wrong | Recovery route |
+|---|---|---|
+| `LOCAL_CODE_ONLY` | a local/in-house/CPT code, no standard code | crosswalk local → target, else text search |
+| `NULLFLAVOR` | code explicitly declared unknown (`nullFlavor`, `"unknown"`, `dataAbsentReason`) | resolve the recovered label |
+| `DISPLAY_ONLY` | only a display name, no code and no absence marker | resolve the label |
+| `NARRATIVE_ONLY` | exists only as narrative table text (CCDA, opt-in) | text search, low priority |
+| `BAD_CODE` | right shape, fails validation (LOINC Luhn · SNOMED Verhoeff · ICD format) | check-digit / format correction (suggested fix included) |
+| `ICD_ONLY` | ICD present, SNOMED missing | official ICD ↔ SNOMED map |
+| `SNOMED_ONLY` | SNOMED present, ICD-10-CM missing | official SNOMED → ICD-10-CM map |
+| `NDC_ONLY` | NDC present, RxNorm/CVX missing | NDC ↔ RxNorm / CDC NDC ↔ CVX table |
+| `RXNORM_ONLY` | RxNorm vaccine product, CVX missing | CVX ↔ RxNorm map |
+| `MULTUM_ONLY` / `FDB_ONLY` / `MEDISPAN_ONLY` | proprietary drug vocabulary, RxNorm missing | vendor ↔ RxNorm via UMLS |
+
+---
+
+## Output
+
+The JSON envelope:
+
+```jsonc
+{
+  "source": "patient.xml",
+  "source_format": "ccda",              // or "fhir" — auto-detected
+  "targets_checked": ["LOINC", "SNOMED-CT", "RxNorm", "ICD-10-CM", "CVX"],
+  "gap_count": 4,
+  "by_pattern": { "LOCAL_CODE_ONLY": 1, "NULLFLAVOR": 3 },
+  "by_target":  { "LOINC": 1, "SNOMED-CT": 3 },
+  "gaps": [ ... ]
+}
+```
+
+Each gap record separates four concerns — the classification, the facts, the
+plan, and the (pending) answer:
+
+```jsonc
+{
+  "id": 1,
+  "target":  { "system": "LOINC", "slot": "code" },   // what's missing, and in which slot
+  "pattern": "LOCAL_CODE_ONLY",                        // why
+  "section": { "code": "30954-2", "name": "Results", "system": "LOINC" },
+
+  "observation": {                                     // the facts, verbatim
+    "code": {
+      "display_text": "LIPID PANEL",
+      "original_text": "LIPID PANEL",
+      "codings": [
+        { "code": null,    "system": "LOINC", "system_raw": "http://loinc.org" },
+        { "code": "80061", "system": "CPT",   "system_raw": "http://www.ama-assn.org/go/cpt" }
+      ]
+    },
+    "value": null,
+    "qualifiers": { "specimen": { "value": "Bld", "confidence": "low" }, "...": "..." }
+  },
+
+  "recovery": {                                        // the plan
+    "search_terms": ["LIPID PANEL", "lipid panel"],
+    "match_key": "component:LIPID PANEL | specimen:Bld | property:? | scale:? | method:-",
+    "crosswalk": { "from_system": "http://www.ama-assn.org/go/cpt", "from_code": "80061" },
+    "suggested_action": "Try (source_system, local_code) crosswalk FIRST; ..."
+  },
+
+  "provenance": { "location": { "type": "fhirpath", "path": "..." } },
+  "resolution": { "status": "pending", "code": null, "...": "..." }  // filled by your recovery step
+}
+```
+
+Reading it: this lab was coded with CPT `80061` but its LOINC slot is empty
+(`code: null` — the source wrote a null marker). The record hands you the CPT
+crosswalk candidate, the text to search with, and the LOINC axis hints
+(specimen/property/scale) to constrain candidates — everything a
+crosswalk-database or LLM step needs to fill `resolution`.
+
+---
+
+## Scope and status
+
+- Emits **gap detections + recovery evidence**. It does not itself query
+  terminology databases or LLMs — `resolution` is intentionally left `pending`
+  for your downstream step.
+- Terminologies checked today: LOINC, SNOMED CT, RxNorm, ICD-10-CM, CVX.
+  CPT / HCPCS / ICD-10-PCS are planned.
+- Validation included: LOINC Luhn check digits, SNOMED Verhoeff check digits
+  (incl. long-format extension SCTIDs), ICD-10-CM format rules, CVX shape.
+- Code-system identification covers HL7 OIDs, FHIR URIs, `urn:oid:` forms and
+  free-text names for 20+ vocabularies (Epic/local OIDs are recognized as
+  local codes, HL7 structural vocabularies are excluded from gap detection).
+
+## License
+
+MIT — © 2026 Trove Health.

aimedicalcoding-0.3.1.dist-info/RECORD

@@ -0,0 +1,57 @@
+aimedicalcoding/__init__.py,sha256=viWad5P5w8ZOXDVhZZ2kXMpTTkUt-f4A28IZqDfHJm8,1182
+aimedicalcoding/__main__.py,sha256=swkEmrnXebaTGwsIKonb6XfrAi_Movq0uKbU91wb8oE,12586
+aimedicalcoding/api.py,sha256=bADfs8Nm0bARYDxDcLb2ML3Mn2yNkgehhCKzznhwEpA,6128
+aimedicalcoding/serialize.py,sha256=3BaJIJj32tYGhcciSwBnwq4lPcs6nBNeofvw84TD4To,10644
+aimedicalcoding/adapters/__init__.py,sha256=XKnZJyHCIkjLTKHKUfalztZt87KYRNRyOY4zGRxDmgc,64
+aimedicalcoding/adapters/base.py,sha256=gMfYxK3nho2LjL7h1Y14HrTZ0KqRDAGeQicBEBKo5ug,790
+aimedicalcoding/adapters/ccda/__init__.py,sha256=PbdC_mmRW5BrxKsWS4JlE9H5psPAvhRprmZfOQ3Gzo8,63
+aimedicalcoding/adapters/ccda/adapter.py,sha256=J7xcjZF4KVqxAVoZAuWGhflHxJ7qkS6wicGLx9BWH2A,12687
+aimedicalcoding/adapters/ccda/codes.py,sha256=gYDZP5jVWR7gUrUzP-jB9j62U_9JDdqWiC-k3FH3Kfo,7125
+aimedicalcoding/adapters/ccda/narrative.py,sha256=7tC5TCtj3WbmeWXmbXPMLRby0foE9Vn5xBlYEuXsAoI,4162
+aimedicalcoding/adapters/ccda/sections.py,sha256=TnKXVUtS6XsxhZZYEMAwv3YciXsmIcUIJeGJoFwkZ3M,2145
+aimedicalcoding/adapters/custom_json/__init__.py,sha256=QPsWZfo1hSTCOp64UiAbmfjtIULKDyjrlSUDVH9YYVc,75
+aimedicalcoding/adapters/custom_json/adapter.py,sha256=8cVT8dFeB1YlKJUmDCGr28I-xmo3LGfF5_kPfJLATWg,1017
+aimedicalcoding/adapters/fhir/__init__.py,sha256=RDoieLHyrnWqf6dqs0UVwQ-JY8ukm5Ds9kxrGsXsJBY,63
+aimedicalcoding/adapters/fhir/adapter.py,sha256=8b68P2hNQEKrmyHmE2_EHo7M5gQSYnBFir3yvHuEbIY,14955
+aimedicalcoding/adapters/fhir/codes.py,sha256=w-eDA5OMJS2duBIHwI01phwZBhjPDmFrMOBXnYK_g28,8368
+aimedicalcoding/adapters/fhir/mapping.py,sha256=dtESD28QZ3q1ze_E77yYkTWxEOg-WMC1TfRHr-hy0u4,3056
+aimedicalcoding/core/__init__.py,sha256=cMtmrbXfZir5v-9_6bzf94wdmyKVFReJvZ4QKGcPAgw,694
+aimedicalcoding/core/checkdigits.py,sha256=54vcbScOxG21ngGK7tsaS7d0ZjD-LppUuXvkxBJjO4s,3615
+aimedicalcoding/core/models.py,sha256=VlRYtkNJQeF_vdc9TVT9BP4OU3JaKbNxwVfASdp1Pdw,6654
+aimedicalcoding/core/system_registry.py,sha256=vgtUzsW8006ohxYR5bRh04C4InPzxGDrDQ6QXDOYmNs,8024
+aimedicalcoding/pipeline/__init__.py,sha256=KGE1IpfLT62r9Iv1MGEhrutYRO6_q4lKv36vOnIjS3I,108
+aimedicalcoding/pipeline/orchestrator.py,sha256=p-PbGhM5KXWW9f-Ocy8Ds-FMglV--9MirSB7QsOFriQ,1136
+aimedicalcoding/recovery/__init__.py,sha256=kDE5TkBDET4ZyQ4aNsDYCnXUGhZ7PuNnG6gfkmgyt6I,68
+aimedicalcoding/recovery/engine.py,sha256=-Ec8H6n2RN2ZfzgKkao091E5QBujN3nXiFXH_a4W8u4,620
+aimedicalcoding/systems/__init__.py,sha256=clo-oaRc880EXmUrAtdGQ29Fam88r7Ad3joi4MyjLgI,74
+aimedicalcoding/systems/base.py,sha256=-ZugvfiyOLU7NXogAB1bujoaY_s6JbH5EbX3cRXjg18,1419
+aimedicalcoding/systems/cvx/__init__.py,sha256=7y8Tf7hUR1E478oD7blqrGo-h82A89foK0V6eKcgKak,710
+aimedicalcoding/systems/cvx/handler.py,sha256=JOobyneuFF3vJXxK-aF6WEpxE7pEHOhq8zwfmSdfEQM,1969
+aimedicalcoding/systems/cvx/normalize.py,sha256=FrHn8s3Sajdo0DX0DGJzbC6IyxQWOSyuDomLBdNOpQk,2343
+aimedicalcoding/systems/cvx/patterns.py,sha256=y5n8_noaWxetMRugH_AHTeZi76tCda4oYVPW2Y9DQ-8,5391
+aimedicalcoding/systems/icd10cm/__init__.py,sha256=bAlE4-1qctHJKiut_uQsEkOu0MLxfGTAEL4nimyHV8s,647
+aimedicalcoding/systems/icd10cm/handler.py,sha256=S6vs634eGEiaJguKFQldQRAXZ56QEai-iGTiwivpwZI,1999
+aimedicalcoding/systems/icd10cm/icdformat.py,sha256=t81aq7YiaKzfuYtjSk8GQFcd3XXAc5790M-A-FKEyGQ,1422
+aimedicalcoding/systems/icd10cm/patterns.py,sha256=JgjmpT5AGJoyQF6VFueIUolqJzLzLgEtS3mwKDX1s80,5446
+aimedicalcoding/systems/loinc/__init__.py,sha256=OimAW2Mz1u6P0v1-SRN_rYYpZoltJprjkxg3mR4VTFE,573
+aimedicalcoding/systems/loinc/axes.py,sha256=YD8m2tvlHp0xQDuWDgDU1OjhpkXhpnPPX8f9YYYDV5c,8715
+aimedicalcoding/systems/loinc/handler.py,sha256=2x1VI1YqxIg0pa4vapSWC533pJ8AK8lyBvFI6mXnhEo,3207
+aimedicalcoding/systems/loinc/normalize.py,sha256=M6KGYuvSgIipMgsP4I7LW49aR7Owpw_kOS5Z6UEdmWE,2545
+aimedicalcoding/systems/loinc/patterns.py,sha256=dG8_Cf9hq2xdQFYLfhWvF28V1Oyo9bVSqFodw9pZeoU,6714
+aimedicalcoding/systems/rxnorm/__init__.py,sha256=JOz1CgTTgFRDAW82HYzWYdcc1vRNPW-DXlF52613Al4,611
+aimedicalcoding/systems/rxnorm/handler.py,sha256=FpBYBhovnHfTyXMMiXFHKgJFb_OvHLaMGOpWW7SkZaM,1991
+aimedicalcoding/systems/rxnorm/normalize.py,sha256=UJDu50yMKbLpmasI8oTlpH7GEQOXBZEGzDg5qjytK9c,3034
+aimedicalcoding/systems/rxnorm/patterns.py,sha256=cCJ-27q3_1ITaGHxwrFXDMNFK8uO7GSYR8KjrfUdAkI,6064
+aimedicalcoding/systems/snomed/__init__.py,sha256=I0X2Oc5-jZ4mHKdvSN4xlxucwYwHUmDirvp7X5TeMxI,715
+aimedicalcoding/systems/snomed/handler.py,sha256=NI4zpIBvnysd_hKPjVNyyMWulZwhuBw9yZa8HfZn9ks,2208
+aimedicalcoding/systems/snomed/hierarchy.py,sha256=vNFMCXmOlvWt0WZqeaXLZNf9uV1e8OPQDSQzxY1Ohss,3954
+aimedicalcoding/systems/snomed/patterns.py,sha256=YU6ZpHo-Kw7BFsG5QZJ2AW2nGIYH7qxehyZiMxvsjMw,7341
+aimedicalcoding/systems/snomed/qualifiers.py,sha256=zz_CCx7vW7cAz_dc7aWPtibtiMC7-oLQPtE7sUdXwOw,2815
+aimedicalcoding/terminology/__init__.py,sha256=KVoIA1CCQn_v-1elbVEqDhy1j3oTPuxoQk9uRKTUv1k,77
+aimedicalcoding/terminology/service.py,sha256=9EllY7NhWKFAgu6akhLEG4oMmqjCqKfrAe93KCT8I0Q,1289
+aimedicalcoding-0.3.1.dist-info/licenses/LICENSE,sha256=K6yywBLgHo248RJhXjwoW1n9bDoYgyItdlBixb6iwGY,1069
+aimedicalcoding-0.3.1.dist-info/METADATA,sha256=1DEr1j7M3HO9-U96MGdDQrPM47lKmw2_Ze7G43VUjg4,11418
+aimedicalcoding-0.3.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+aimedicalcoding-0.3.1.dist-info/entry_points.txt,sha256=qYa-Olxsrca0nMczzXgmvRh1KKgI2xBBLbsM-IGst1g,66
+aimedicalcoding-0.3.1.dist-info/top_level.txt,sha256=Oyr7k6Ihz10OEQ5Cw_uOCPFbOE14KCcMeTtjbX4MHi0,16
+aimedicalcoding-0.3.1.dist-info/RECORD,,

aimedicalcoding-0.3.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aimedicalcoding-0.3.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aimedicalcoding = aimedicalcoding.__main__:main

aimedicalcoding-0.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Trove Health
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aimedicalcoding-0.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+aimedicalcoding