aimedicalcoding 0.3.1__py3-none-any.whl

aimedicalcoding/adapters/fhir/adapter.py

@@ -0,0 +1,326 @@
+"""FHIR R4 Bundle adapter (Trove flavor).
+
+Walks a single R4 Bundle in two passes: first build the reference index
+(fullUrl + ``ResourceType/id``) and the ``hasMember``/``DiagnosticReport.result``
+member->panel map, then emit one ``ClinicalStatement`` per coded clinical
+resource. Slot rules mirror the CCDA adapter exactly:
+
+  Observation.code            -> codings (question slot), value[x] -> value
+  Condition / FamilyMemberHistory concept -> value.codings (value-slot contexts)
+  Medication* / Immunization / Procedure / allergy substance -> codings
+  AllergyIntolerance reaction manifestations -> separate allergy_reaction
+  statements with the concept in value.codings
+
+Trove's literal ``"unknown"`` null marker is normalized in ``codes.py``.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Iterable, Optional
+
+from ...core.models import (
+    ClinicalStatement,
+    CodingCandidate,
+    System,
+    ValueInfo,
+    NOM,
+)
+from ..base import FormatAdapter
+from ..ccda.codes import best_loinc
+from . import codes as C
+from . import mapping as M
+
+
+class FhirAdapter(FormatAdapter):
+    format_key = "fhir"
+
+    # ------------------------------------------------------------------ #
+    def detect(self, document: str | bytes) -> bool:
+        try:
+            obj = json.loads(document)
+        except (ValueError, TypeError):
+            return False
+        return isinstance(obj, dict) and obj.get("resourceType") == "Bundle"
+
+    def parse(self, document: str | bytes) -> Iterable[ClinicalStatement]:
+        bundle = json.loads(document)
+        entries = bundle.get("entry") or []
+
+        # pass 1: reference index + member->panel map
+        self._index: dict[str, dict] = {}
+        self._refs: list[tuple[str, dict]] = []   # (fullUrl, resource) for suffix match
+        for i, entry in enumerate(entries):
+            res = entry.get("resource") or {}
+            full_url = entry.get("fullUrl")
+            if full_url:
+                self._index[full_url] = res
+                self._refs.append((full_url, res))
+            rt, rid = res.get("resourceType"), res.get("id")
+            if rt and rid:
+                self._index[f"{rt}/{rid}"] = res
+
+        panels = self._build_panel_map(entries)
+
+        # pass 2: emit statements
+        statements: list[ClinicalStatement] = []
+        for i, entry in enumerate(entries):
+            res = entry.get("resource") or {}
+            ref = entry.get("fullUrl") or f"Bundle.entry[{i}]"
+            rt = res.get("resourceType")
+            if not rt or rt in M.SKIP_RESOURCES:
+                continue
+            if rt == "Observation":
+                statements.append(self._observation(res, ref, panels))
+            elif rt == "Condition":
+                statements.append(self._condition(res, ref))
+            elif rt in ("MedicationRequest", "MedicationAdministration",
+                        "MedicationStatement", "MedicationDispense"):
+                statements.append(self._medication(res, ref, rt))
+            elif rt == "Immunization":
+                statements.append(self._immunization(res, ref))
+            elif rt == "Procedure":
+                statements.append(self._procedure(res, ref))
+            elif rt == "AllergyIntolerance":
+                statements.extend(self._allergy(res, ref))
+            elif rt == "FamilyMemberHistory":
+                statements.extend(self._family_history(res, ref))
+        return statements
+
+    # ------------------------------------------------------------------ #
+    # reference / panel plumbing
+    # ------------------------------------------------------------------ #
+    def _resolve(self, reference: Optional[dict]) -> Optional[dict]:
+        """Resolve a Reference across the Bundle: exact fullUrl or Type/id,
+        else a fullUrl whose path ends with the relative reference."""
+        if not reference:
+            return None
+        ref = reference.get("reference")
+        if not ref:
+            return None
+        hit = self._index.get(ref)
+        if hit is not None:
+            return hit
+        return next((r for url, r in self._refs if url.endswith("/" + ref)), None)
+
+    def _build_panel_map(self, entries: list) -> dict[str, dict]:
+        """member reference -> {panel, context, hint, specimen} from parent
+        Observations (hasMember) and DiagnosticReports (result[])."""
+        panels: dict[str, dict] = {}
+        for entry in entries:
+            res = entry.get("resource") or {}
+            rt = res.get("resourceType")
+            if rt == "Observation" and res.get("hasMember"):
+                members = res["hasMember"]
+                concept = res.get("code")
+                context, hint = M.route_observation(self._category_codes(res),
+                                                    self._meta_tag(res)[0])
+            elif rt == "DiagnosticReport" and res.get("result"):
+                members = res["result"]
+                concept = res.get("code")
+                context, hint = ("result", System.LOINC)
+            else:
+                continue
+            codings, _ = C.concept_codings(concept)
+            panel = best_loinc(codings) or next(
+                (c for c in codings if c.code), None)
+            info = {
+                "panel": panel,
+                "context": context,
+                "hint": hint,
+                "specimen": self._specimen(res),
+            }
+            for member in members:
+                ref = member.get("reference")
+                if ref:
+                    panels[ref] = info
+                    # index rows are keyed by relative Type/id too
+                    resolved = self._resolve(member)
+                    if resolved and resolved.get("id"):
+                        panels[f"{resolved['resourceType']}/{resolved['id']}"] = info
+        return panels
+
+    def _specimen(self, res: dict) -> Optional[dict]:
+        spec = self._resolve(res.get("specimen"))
+        if not spec:
+            return None
+        codings, text = C.concept_codings(spec.get("type"))
+        primary = next((c for c in codings if c.code), None)
+        display = C.best_label(codings, text)
+        if not primary and not display:
+            return None
+        return {"code": primary.code if primary else None, "display": display}
+
+    # ------------------------------------------------------------------ #
+    # shared statement assembly
+    # ------------------------------------------------------------------ #
+    @staticmethod
+    def _category_codes(res: dict) -> list[str]:
+        return [C.clean(c.get("code")) for cat in res.get("category") or []
+                for c in cat.get("coding") or [] if C.clean(c.get("code"))]
+
+    @staticmethod
+    def _meta_tag(res: dict) -> tuple[Optional[str], Optional[str]]:
+        """(code, display) of the CCDA-section LOINC Trove stamps in meta.tag."""
+        for tag in (res.get("meta") or {}).get("tag") or []:
+            code = C.clean(tag.get("code"))
+            if code:
+                return code, C.clean(tag.get("display"))
+        return None, None
+
+    def _section(self, res: dict) -> tuple[Optional[str], Optional[str], Optional[str]]:
+        """(section_code, section_name, section_system) from meta.tag, else the
+        Observation category as a lower-fidelity stand-in."""
+        code, display = self._meta_tag(res)
+        if code:
+            return code, display, "LOINC"
+        cats = self._category_codes(res)
+        if cats:
+            return cats[0], cats[0].replace("-", " ").title(), None
+        return None, None, None
+
+    def _statement(self, res: dict, ref: str, context: str,
+                   hint: Optional[System], codings: list[CodingCandidate],
+                   text: Optional[str], value: Optional[ValueInfo] = None,
+                   companion: Optional[dict] = None,
+                   panel: Optional[CodingCandidate] = None) -> ClinicalStatement:
+        sec_code, sec_name, sec_system = self._section(res)
+        display_name = next(
+            (c.display for c in codings if not c.from_translation and c.display), None)
+        return ClinicalStatement(
+            source_format=self.format_key,
+            source_ref=ref,
+            context=context,
+            section_code=sec_code,
+            section_name=sec_name,
+            section_system=sec_system,
+            role="value",
+            target_system_hint=hint,
+            raw_text=C.best_label(codings, text),
+            display_name=display_name,
+            original_text=text,
+            codings=codings,
+            value=value,
+            effective_time=C.extract_effective_time(res),
+            panel=panel,
+            companion=companion or {},
+        )
+
+    # ------------------------------------------------------------------ #
+    # per-resource emitters
+    # ------------------------------------------------------------------ #
+    def _observation(self, res: dict, ref: str,
+                     panels: dict[str, dict]) -> ClinicalStatement:
+        parent = panels.get(f"Observation/{res.get('id')}") or panels.get(ref)
+        cats = self._category_codes(res)
+        if cats:
+            context, hint = M.route_observation(cats, self._meta_tag(res)[0])
+        elif parent:
+            # derived panel child (no category, no meta.tag): inherit the panel's
+            context, hint = parent["context"], parent["hint"]
+        else:
+            context, hint = M.route_observation([], self._meta_tag(res)[0])
+
+        codings, text = C.concept_codings(res.get("code"))
+        value = C.extract_value(res)
+        companion = C.extract_companion(res)
+        specimen = self._specimen(res) or (parent["specimen"] if parent else None)
+        if specimen:
+            companion["specimen"] = specimen.get("display")
+            companion["specimen_code"] = specimen.get("code")
+
+        return self._statement(res, ref, context, hint, codings, text,
+                               value=value, companion=companion,
+                               panel=parent["panel"] if parent else None)
+
+    def _condition(self, res: dict, ref: str) -> ClinicalStatement:
+        # value-slot context: the SNOMED/ICD concept goes into value.codings
+        codings, text = C.concept_codings(res.get("code"))
+        coded = next((c for c in codings if not c.from_translation),
+                     codings[0] if codings else None)
+        value = ValueInfo(type=NOM, raw=C.best_label(codings, text),
+                          coded_value=coded, codings=codings, original_text=text)
+        context, hint = M.RESOURCE_ROUTING["Condition"]
+        stmt = self._statement(res, ref, context, hint, codings=[], text=text,
+                               value=value)
+        stmt.raw_text = value.raw          # concept label lives on the value slot
+        return stmt
+
+    def _medication(self, res: dict, ref: str, rt: str) -> ClinicalStatement:
+        # drug concept: inline medicationCodeableConcept, or on the referenced
+        # Medication resource's code
+        concept = res.get("medicationCodeableConcept")
+        if concept is None:
+            med = self._resolve(res.get("medicationReference"))
+            concept = (med or {}).get("code")
+            if concept is None:
+                # display on the reference is the only label we have
+                mref = res.get("medicationReference") or {}
+                concept = {"text": mref.get("display")} if mref.get("display") else None
+        codings, text = C.concept_codings(concept)
+        companion = {}
+        if res.get("doNotPerform") or res.get("status") == "not-done":
+            companion["negation"] = True
+        context, hint = M.RESOURCE_ROUTING[rt]
+        return self._statement(res, ref, context, hint, codings, text,
+                               companion=companion)
+
+    def _immunization(self, res: dict, ref: str) -> ClinicalStatement:
+        codings, text = C.concept_codings(res.get("vaccineCode"))
+        companion = {}
+        if res.get("status") == "not-done":
+            companion["negation"] = True
+        context, hint = M.RESOURCE_ROUTING["Immunization"]
+        return self._statement(res, ref, context, hint, codings, text,
+                               companion=companion)
+
+    def _procedure(self, res: dict, ref: str) -> ClinicalStatement:
+        codings, text = C.concept_codings(res.get("code"))
+        context, hint = M.RESOURCE_ROUTING["Procedure"]
+        return self._statement(res, ref, context, hint, codings, text)
+
+    def _allergy(self, res: dict, ref: str) -> list[ClinicalStatement]:
+        out: list[ClinicalStatement] = []
+        codings, text = C.concept_codings(res.get("code"))
+        if codings or text:
+            out.append(self._statement(res, ref, "allergy_substance",
+                                       System.RXNORM, codings, text))
+        for i, reaction in enumerate(res.get("reaction") or []):
+            for j, manifestation in enumerate(reaction.get("manifestation") or []):
+                m_codings, m_text = C.concept_codings(manifestation)
+                if not m_codings and not m_text:
+                    continue
+                coded = next((c for c in m_codings if not c.from_translation),
+                             m_codings[0] if m_codings else None)
+                value = ValueInfo(type=NOM, raw=C.best_label(m_codings, m_text),
+                                  coded_value=coded, codings=m_codings,
+                                  original_text=m_text)
+                stmt = self._statement(
+                    res, f"{ref}/reaction[{i}]/manifestation[{j}]",
+                    "allergy_reaction", System.SNOMEDCT, codings=[],
+                    text=m_text, value=value)
+                stmt.raw_text = value.raw
+                out.append(stmt)
+        return out
+
+    def _family_history(self, res: dict, ref: str) -> list[ClinicalStatement]:
+        out: list[ClinicalStatement] = []
+        rel_codings, rel_text = C.concept_codings(res.get("relationship"))
+        relationship = C.best_label(rel_codings, rel_text)
+        context, hint = M.RESOURCE_ROUTING["FamilyMemberHistory"]
+        for i, cond in enumerate(res.get("condition") or []):
+            codings, text = C.concept_codings(cond.get("code"))
+            if not codings and not text:
+                continue
+            coded = next((c for c in codings if not c.from_translation),
+                         codings[0] if codings else None)
+            value = ValueInfo(type=NOM, raw=C.best_label(codings, text),
+                              coded_value=coded, codings=codings,
+                              original_text=text)
+            stmt = self._statement(res, f"{ref}/condition[{i}]", context, hint,
+                                   codings=[], text=text, value=value)
+            stmt.raw_text = value.raw
+            if relationship:
+                stmt.companion["relationship"] = relationship
+            out.append(stmt)
+        return out

aimedicalcoding/adapters/fhir/codes.py

@@ -0,0 +1,211 @@
+"""CodeableConcept / value[x] extraction for FHIR resources.
+
+FHIR mirror of ``adapters/ccda/codes.py`` (scan-and-identify): enumerate every
+``coding[]`` entry, canonicalize each system, and let downstream pick.
+
+THE Trove quirk handled here: the literal string ``"unknown"`` is Trove's null
+marker — it appears in ``code``, ``display``, ``system`` and ``text`` wherever a
+value is missing. Every ``"unknown"`` is normalized to ``None``; a CodeableConcept
+left with no real code yields a ``System.NULLFLAVOR`` candidate (the CCDA
+``nullFlavor`` equivalent) so the gap extractors classify it correctly.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from ...core.checkdigits import is_valid_loinc, is_valid_sctid
+from ...core.models import (
+    CodingCandidate,
+    System,
+    ValueInfo,
+    QN,
+    ORD,
+    NOM,
+    NAR,
+)
+from ...core.system_registry import canonicalize
+
+_UNKNOWN = "unknown"
+
+# same ordinal cue list the CCDA adapter uses for CD/CE values
+_ORDINAL_WORDS = {"positive", "negative", "reactive", "non-reactive",
+                  "detected", "not detected", "present", "absent"}
+
+
+def clean(s: Optional[str]) -> Optional[str]:
+    """Normalize Trove's ``"unknown"`` null marker (and empty strings) to None."""
+    if not isinstance(s, str):
+        return s
+    s = s.strip()
+    if not s or s.lower() == _UNKNOWN:
+        return None
+    return s
+
+
+def coding_to_candidate(coding: dict, from_translation: bool) -> CodingCandidate:
+    raw_system = clean(coding.get("system"))
+    system = canonicalize(raw_system)
+    code = clean(coding.get("code"))
+    cand = CodingCandidate(
+        raw_system=raw_system,
+        system=system,
+        code=code,
+        display=clean(coding.get("display")),
+        from_translation=from_translation,
+        user_selected=bool(coding.get("userSelected")),
+    )
+    if code:
+        if system == System.LOINC:
+            cand.check_digit_valid = is_valid_loinc(code)
+        elif system == System.SNOMEDCT:
+            cand.check_digit_valid = is_valid_sctid(code)
+    return cand
+
+
+def concept_codings(cc: Optional[dict]) -> tuple[list[CodingCandidate], Optional[str]]:
+    """Return (codings, text) for a CodeableConcept.
+
+    The primary coding (``userSelected`` if any, else the first) gets
+    ``from_translation=False``; the rest are translations — the FHIR analog of
+    CCDA root ``<code>`` + ``<translation>`` children. If no coding carries a
+    real code but the concept explicitly said ``"unknown"``, a NULLFLAVOR
+    candidate is appended so the absence stays an explicit signal.
+    """
+    if not cc:
+        return [], None
+    text = clean(cc.get("text"))
+    raw_codings = cc.get("coding") or []
+
+    saw_unknown = (cc.get("text") == _UNKNOWN)
+    kept: list[tuple[CodingCandidate, bool]] = []   # (candidate, user_selected)
+    for coding in raw_codings:
+        if coding.get("code") == _UNKNOWN or coding.get("system") == _UNKNOWN \
+                or coding.get("display") == _UNKNOWN:
+            saw_unknown = True
+        cand = coding_to_candidate(coding, from_translation=True)
+        if cand.code is None and cand.display is None and cand.raw_system is None:
+            continue   # fully-null coding ({"system":"unknown","code":"unknown"})
+        kept.append((cand, bool(coding.get("userSelected"))))
+
+    # primary = userSelected among the SURVIVING codings, else the first one
+    # (so a dropped all-"unknown" first coding doesn't leave only translations)
+    out = [cand for cand, _ in kept]
+    if out:
+        primary_idx = next((i for i, (_c, sel) in enumerate(kept) if sel), 0)
+        out[primary_idx].from_translation = False
+
+    if saw_unknown and not any(c.code for c in out):
+        out.append(CodingCandidate(system=System.NULLFLAVOR, raw_system=_UNKNOWN,
+                                   from_translation=False))
+    return out, text
+
+
+def best_label(codings: list[CodingCandidate], text: Optional[str]) -> Optional[str]:
+    """raw_text priority, mirroring CCDA: primary display -> text -> any display."""
+    primary = next((c for c in codings if not c.from_translation and c.display), None)
+    if primary:
+        return primary.display
+    if text:
+        return text
+    return next((c.display for c in codings if c.display), None)
+
+
+# --------------------------------------------------------------------------
+# value[x] extraction
+# --------------------------------------------------------------------------
+
+def _quantity_value(qty: dict) -> ValueInfo:
+    raw = qty.get("value")
+    unit = clean(qty.get("code")) or clean(qty.get("unit"))
+    return ValueInfo(
+        type=QN,
+        raw=(str(raw) if raw is not None else None),
+        num=_to_float(raw),
+        unit=unit,
+        unit_system="UCUM" if unit else None,
+    )
+
+
+def extract_value(resource: dict) -> Optional[ValueInfo]:
+    """Map FHIR ``value[x]`` (or ``dataAbsentReason``) to a ValueInfo."""
+    if "valueQuantity" in resource:
+        return _quantity_value(resource["valueQuantity"])
+    if "valueInteger" in resource:
+        raw = resource["valueInteger"]
+        return ValueInfo(type=QN, raw=str(raw), num=_to_float(raw))
+    if "valueCodeableConcept" in resource:
+        codings, text = concept_codings(resource["valueCodeableConcept"])
+        coded = next((c for c in codings if not c.from_translation),
+                     codings[0] if codings else None)
+        label = best_label(codings, text)
+        vtype = ORD if (label or "").lower() in _ORDINAL_WORDS else NOM
+        return ValueInfo(type=vtype, raw=label, coded_value=coded,
+                         codings=codings, original_text=text)
+    if "valueString" in resource:
+        return ValueInfo(type=NAR, raw=clean(resource["valueString"]))
+    if "valueBoolean" in resource:
+        return ValueInfo(type=ORD, raw=str(resource["valueBoolean"]))
+    if "valueDateTime" in resource:
+        return ValueInfo(type=NAR, raw=resource["valueDateTime"])
+    if "valueRange" in resource:
+        low = (resource["valueRange"].get("low") or {})
+        return _quantity_value(low) if low else None
+    # value explicitly absent — FHIR's nullFlavor for the value slot
+    dar = resource.get("dataAbsentReason")
+    if dar:
+        reason = None
+        for coding in dar.get("coding") or []:
+            reason = clean(coding.get("code")) or reason
+        reason = reason or clean(dar.get("text")) or "unknown"
+        return ValueInfo(type=None,
+                         coded_value=CodingCandidate(system=System.NULLFLAVOR,
+                                                     raw_system=reason))
+    return None
+
+
+# --------------------------------------------------------------------------
+# companion extraction
+# --------------------------------------------------------------------------
+
+def extract_companion(resource: dict) -> dict:
+    """interpretation + reference range (Observation-shaped resources)."""
+    out: dict[str, Any] = {}
+    for interp in resource.get("interpretation") or []:
+        code = next((clean(c.get("code")) for c in interp.get("coding") or []
+                     if clean(c.get("code"))), None)
+        if code:
+            out["interpretation"] = code
+            break
+    for rr in resource.get("referenceRange") or []:
+        low, high = rr.get("low") or {}, rr.get("high") or {}
+        if low or high:
+            lo = low.get("value", "")
+            hi = high.get("value", "")
+            unit = clean(low.get("unit")) or clean(high.get("unit")) or \
+                clean(low.get("code")) or clean(high.get("code"))
+            out["reference_range"] = f"{lo}-{hi}" + (f" {unit}" if unit else "")
+            break
+        if clean(rr.get("text")):
+            out["reference_range"] = clean(rr.get("text"))
+            break
+    return out
+
+
+def extract_effective_time(resource: dict) -> Optional[str]:
+    for key in ("effectiveDateTime", "occurrenceDateTime", "performedDateTime",
+                "onsetDateTime", "authoredOn", "recordedDate"):
+        if resource.get(key):
+            return resource[key]
+    for key in ("effectivePeriod", "performedPeriod"):
+        period = resource.get(key)
+        if period and period.get("start"):
+            return period["start"]
+    return None
+
+
+def _to_float(v) -> Optional[float]:
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return None

aimedicalcoding/adapters/fhir/mapping.py

@@ -0,0 +1,68 @@
+"""FHIR routing: resource type / Observation.category / meta.tag -> context.
+
+The FHIR analog of ``adapters/ccda/sections.py``. Trove bundles are generated
+from CCDA, and every directly-extracted resource carries the *original CCDA
+section LOINC code* in ``meta.tag`` — so we reuse the CCDA ``SECTION_ROUTING``
+table verbatim as a fallback router. Primary routing is by resource type and
+``Observation.category`` (meta.tag is absent on derived resources such as
+``hasMember`` panel children).
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ...core.models import System
+from ..ccda.sections import route_section  # keyed by section LOINC — shared knowledge
+
+# Observation.category code -> (context, target_system_hint)
+CATEGORY_ROUTING: dict[str, tuple[str, Optional[System]]] = {
+    "laboratory": ("result", System.LOINC),
+    "vital-signs": ("vital", System.LOINC),
+    "social-history": ("social_history", System.LOINC),
+    "survey": ("survey", System.LOINC),
+    "functional-status": ("functional_status", System.LOINC),
+    "exam": ("exam", None),          # not a gap-extractor context; kept for provenance
+    "imaging": ("imaging", None),
+    "procedure": ("procedure_note", None),  # Observation-flavored, not a Procedure act
+    "activity": ("activity", None),
+    "therapy": ("therapy", None),
+}
+
+# non-Observation resource type -> (context, target_system_hint)
+RESOURCE_ROUTING: dict[str, tuple[str, Optional[System]]] = {
+    "Condition": ("problem", System.SNOMEDCT),
+    "MedicationRequest": ("medication", System.RXNORM),
+    "MedicationAdministration": ("medication", System.RXNORM),
+    "MedicationStatement": ("medication", System.RXNORM),
+    "MedicationDispense": ("medication", System.RXNORM),
+    "Immunization": ("immunization", System.CVX),
+    "Procedure": ("procedure", System.CPT),
+    "FamilyMemberHistory": ("family_history", System.SNOMEDCT),
+    # AllergyIntolerance handled specially: allergy_substance + allergy_reaction
+}
+
+# administrative / non-coded resources the adapter never emits statements for
+SKIP_RESOURCES = frozenset({
+    "Patient", "Encounter", "Organization", "Practitioner", "PractitionerRole",
+    "Location", "Coverage", "RelatedPerson", "CareTeam", "CarePlan",
+    "ServiceRequest", "DocumentReference", "Provenance", "Communication",
+    "Specimen", "Medication",   # consumed via references, not emitted directly
+    "DiagnosticReport",         # used only to build the member->panel map
+})
+
+
+def route_observation(
+    category_codes: list[str],
+    meta_tag_code: Optional[str] = None,
+) -> tuple[str, Optional[System]]:
+    """Route an Observation: category first, else the CCDA section LOINC that
+    Trove stamps into meta.tag, else a neutral context no extractor touches."""
+    for code in category_codes:
+        if code in CATEGORY_ROUTING:
+            return CATEGORY_ROUTING[code]
+    if meta_tag_code:
+        context, hint = route_section(meta_tag_code)
+        if context != "section":
+            return (context, hint)
+    return ("observation", None)