open-dpc-jp 0.1.0__py3-none-any.whl

open_dpc/__init__.py

@@ -0,0 +1,3 @@
+"""DPC readers independent of application storage, GUI and study profiles."""
+__version__ = "0.1.0"
+CONTRACT_VERSION = "1"

open_dpc/discovery.py

@@ -0,0 +1,78 @@
+"""DPC file discovery for case-scoped lazy loading."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+DPC_KINDS = ["ff1", "efn", "efg"]
+
+
+def classify_dpc_file(path: Path) -> str | None:
+    """Classify DPC file kind by lower-cased filename prefix."""
+    name = path.name.lower()
+    for kind in DPC_KINDS:
+        if name.startswith(f"{kind}_"):
+            return kind
+    return None
+
+
+def _month_tokens(case_context: dict[str, Any]) -> list[str]:
+    tokens: list[str] = []
+    for key in ["event_date", "encounter_start_date", "encounter_end_date"]:
+        raw = str(case_context.get(key) or "")
+        if len(raw) >= 6 and raw[:6].isdigit():
+            tokens.append(raw[:6])
+            tokens.append(raw[2:6])
+    return tokens
+
+
+def _identifier_tokens(case_context: dict[str, Any]) -> list[str]:
+    tokens: list[str] = []
+    for key in ["research_id", "data_identifier"]:
+        value = str(case_context.get(key) or "").strip().lower()
+        if value:
+            tokens.append(value)
+    return list(dict.fromkeys(tokens))
+
+
+def discover_dpc_files_for_case(dpc_dir: Path, case_context: dict[str, Any]) -> dict[str, Any]:
+    """Find DPC candidate files for a case without reading file contents."""
+    result: dict[str, list[str]] = {kind: [] for kind in DPC_KINDS}
+    warnings: list[dict[str, Any]] = []
+    if not dpc_dir.exists():
+        return {
+            "dpc_files": result,
+            "has_dpc": False,
+            "warnings": [{"status": "dpc_dir_not_found", "path": str(dpc_dir)}],
+        }
+    if not dpc_dir.is_dir():
+        return {
+            "dpc_files": result,
+            "has_dpc": False,
+            "warnings": [{"status": "dpc_path_not_directory", "path": str(dpc_dir)}],
+        }
+
+    identifier_tokens = _identifier_tokens(case_context)
+    month_tokens = [token.lower() for token in _month_tokens(case_context)]
+    if not identifier_tokens:
+        warnings.append({"status": "no_case_identifier_tokens"})
+        return {"dpc_files": result, "has_dpc": False, "warnings": warnings}
+
+    for path in sorted(dpc_dir.rglob("*")):
+        if not path.is_file():
+            continue
+        kind = classify_dpc_file(path)
+        if kind is None:
+            continue
+        haystack = str(path).lower()
+        if any(token in haystack for token in identifier_tokens):
+            result[kind].append(str(path))
+
+    return {
+        "dpc_files": result,
+        "has_dpc": any(result.values()),
+        "match_tokens": identifier_tokens,
+        "month_tokens": month_tokens,
+        "warnings": warnings,
+    }

open_dpc/disease_master.py

@@ -0,0 +1,188 @@
+"""Load the SSK disease-name master and resolve receipt codes to ICD-10."""
+
+from __future__ import annotations
+
+import csv
+import re
+from dataclasses import dataclass, field
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+MASTER_FILENAME_PATTERN = re.compile(r"^b_(\d{8})\.txt$", re.IGNORECASE)
+EXPECTED_COLUMN_COUNT = 46
+
+
+def normalize_icd10(value: Any) -> str:
+    if value is None:
+        return ""
+    return str(value).strip().upper().replace(".", "").replace("-", "")
+
+
+@dataclass(frozen=True)
+class DiseaseMasterEntry:
+    disease_code: str
+    disease_name: str
+    icd10_primary: str
+    icd10_secondary: str
+
+
+@dataclass(frozen=True)
+class DiagnosisCodeResolution:
+    icd10: str
+    source: str
+    disease_code: str
+    dpc_icd10: str
+    master_icd10: str
+    master_icd10_secondary: str
+    master_disease_name: str
+
+    def event_metadata(self) -> dict[str, str]:
+        return {
+            "icd10_source": self.source,
+            "dpc_icd10": self.dpc_icd10,
+            "master_icd10": self.master_icd10,
+            "master_icd10_secondary": self.master_icd10_secondary,
+            "master_disease_name": self.master_disease_name,
+        }
+
+
+@dataclass
+class DiseaseMaster:
+    entries: dict[str, DiseaseMasterEntry] = field(default_factory=dict)
+    status: str = "missing"
+    file_name: str | None = None
+    version: str | None = None
+    warnings: list[dict[str, Any]] = field(default_factory=list)
+
+    def resolve(self, disease_code: Any, dpc_icd10: Any = None) -> DiagnosisCodeResolution:
+        code = str(disease_code or "").strip()
+        source_icd10 = normalize_icd10(dpc_icd10)
+        receipt_fallback = normalize_icd10(code)
+        # EFg currently carries the receipt code in its icd10 slot. Treat that as
+        # a fallback code rather than claiming it was supplied as a real ICD-10.
+        if source_icd10 == receipt_fallback and code.isdigit() and len(code) == 7:
+            source_icd10 = ""
+        entry = self.entries.get(code)
+        master_icd10 = entry.icd10_primary if entry else ""
+        if master_icd10:
+            resolved = master_icd10
+            source = "master"
+        elif source_icd10:
+            resolved = source_icd10
+            source = "dpc"
+        else:
+            resolved = receipt_fallback or "-"
+            source = "receipt_code"
+        return DiagnosisCodeResolution(
+            icd10=resolved,
+            source=source,
+            disease_code=code,
+            dpc_icd10=source_icd10,
+            master_icd10=master_icd10,
+            master_icd10_secondary=entry.icd10_secondary if entry else "",
+            master_disease_name=entry.disease_name if entry else "",
+        )
+
+    def summary(self) -> dict[str, Any]:
+        return {
+            "status": self.status,
+            "file_name": self.file_name,
+            "version": self.version,
+            "record_count": len(self.entries),
+            "warnings": self.warnings,
+        }
+
+
+def _latest_master_path(reference_dir: Path) -> tuple[Path | None, str | None]:
+    candidates: list[tuple[str, Path]] = []
+    if reference_dir.is_dir():
+        for path in reference_dir.iterdir():
+            match = MASTER_FILENAME_PATTERN.match(path.name)
+            if path.is_file() and match:
+                candidates.append((match.group(1), path))
+    if not candidates:
+        return None, None
+    version, path = max(candidates, key=lambda item: item[0])
+    return path, version
+
+
+@lru_cache(maxsize=8)
+def _read_master_cached(
+    path_string: str, size: int, mtime_ns: int
+) -> tuple[dict[str, DiseaseMasterEntry], tuple[dict[str, Any], ...]]:
+    _ = size, mtime_ns
+    with Path(path_string).open("r", encoding="cp932", newline="") as handle:
+        return _parse_master_rows(csv.reader(handle))
+
+
+def _parse_master_rows(rows):
+    entries: dict[str, DiseaseMasterEntry] = {}
+    invalid_rows = 0
+    invalid_samples: list[int] = []
+    for line_no, row in enumerate(rows, start=1):
+        if (
+            len(row) != EXPECTED_COLUMN_COUNT
+            or row[1].upper() != "B"
+            or len(row[2]) != 7
+            or not row[2].isdigit()
+        ):
+            invalid_rows += 1
+            if len(invalid_samples) < 5:
+                invalid_samples.append(line_no)
+            continue
+        code = row[2]
+        entries[code] = DiseaseMasterEntry(
+            disease_code=code,
+            disease_name=row[5].strip(),
+            icd10_primary=normalize_icd10(row[15]),
+            icd10_secondary=normalize_icd10(row[16]),
+        )
+    warnings: list[dict[str, Any]] = []
+    if invalid_rows:
+        warnings.append(
+            {
+                "status": "invalid_disease_master_rows",
+                "count": invalid_rows,
+                "sample_lines": invalid_samples,
+            }
+        )
+    return entries, tuple(warnings)
+
+
+def load_disease_master(reference_dir: Path | None, *, file_name: str | None = None) -> DiseaseMaster:
+    """Return the newest usable disease master without making it a blocking dependency."""
+    if reference_dir is None or not reference_dir.is_dir():
+        return DiseaseMaster(
+            warnings=[{"status": "disease_master_reference_dir_missing"}]
+        )
+    if file_name is not None:
+        match = MASTER_FILENAME_PATTERN.fullmatch(file_name)
+        if not match:
+            return DiseaseMaster(status="error", warnings=[{"status": "invalid_master_file_name"}])
+        path, version = reference_dir / file_name, match.group(1)
+    else:
+        path, version = _latest_master_path(reference_dir)
+    if path is None:
+        return DiseaseMaster(
+            warnings=[{"status": "disease_master_file_missing"}]
+        )
+    try:
+        stat = path.stat()
+        entries, warnings = _read_master_cached(
+            str(path.resolve()), stat.st_size, stat.st_mtime_ns
+        )
+    except (OSError, UnicodeError, csv.Error) as exc:
+        return DiseaseMaster(
+            status="error",
+            file_name=path.name,
+            version=version,
+            warnings=[{"status": "disease_master_read_failed", "error": str(exc)}],
+        )
+    return DiseaseMaster(
+        entries=entries,
+        status="warning" if warnings else "ok",
+        file_name=path.name,
+        version=version,
+        warnings=list(warnings),
+    )

open_dpc/ef.py

@@ -0,0 +1,294 @@
+"""Reader for DPC EF integrated files (EFn/EFg)."""
+
+from __future__ import annotations
+
+import csv
+from calendar import monthrange
+from datetime import datetime
+import math
+import unicodedata
+from pathlib import Path
+from typing import Any
+
+from open_dpc.medication_periods import derive_medication_period
+
+from open_dpc.schemas import legacy_schema as _legacy_schema
+_legacy_ef = _legacy_schema()['ef']
+EF_COLUMNS = _legacy_ef['columns']
+
+EF_FIXED_WIDTHS = _legacy_ef['widths']
+
+DATA_CATEGORY_LABELS = _legacy_ef['category_labels']
+
+
+HEADER_MARKER_COLUMN = "データ識別番号"
+
+def _normalize_column_name(name: str) -> str:
+    return unicodedata.normalize("NFKC", name).strip()
+
+
+def _normalize_columns(row: list[str]) -> list[str]:
+    return [_normalize_column_name(value) for value in row]
+
+
+def _is_header_row(row: list[str]) -> bool:
+    if len(row) < 2:
+        return False
+    return _normalize_column_name(row[1]) == HEADER_MARKER_COLUMN
+
+
+def _resolve_columns(rows: list[list[str]]) -> tuple[list[str], list[list[str]]]:
+    if rows and _is_header_row(rows[0]):
+        return _normalize_columns(rows[0]), rows[1:]
+    return EF_COLUMNS, rows
+
+
+def _field_value(record: dict[str, str], *names: str) -> str:
+    for name in names:
+        value = record.get(name)
+        if value:
+            return value
+    return record.get(names[0], "") if names else ""
+
+
+def _to_number(raw: Any) -> float | None:
+    value = str(raw or "").strip().replace(",", "")
+    if not value:
+        return None
+    try:
+        numeric = float(value)
+    except ValueError:
+        return None
+    return numeric if math.isfinite(numeric) else None
+
+
+def normalize_ef_date(raw: Any) -> dict[str, str]:
+    """Normalize EF date strings for timeline coordinates while preserving precision."""
+    raw_date = str(raw or "").strip()
+    digits = "".join(ch for ch in raw_date if ch.isdigit())
+    if len(digits) < 8:
+        return {"date": digits, "raw_date": raw_date, "date_precision": "unknown"}
+    digits = digits[:8]
+    year = digits[:4]
+    month = digits[4:6]
+    day = digits[6:8]
+    if month == "00" and day == "00":
+        return {"date": f"{year}0101", "raw_date": raw_date, "date_precision": "year"}
+    if day == "00":
+        return {"date": f"{year}{month}01", "raw_date": raw_date, "date_precision": "month"}
+    return {"date": digits, "raw_date": raw_date, "date_precision": "day"}
+
+
+def ef_period_end_date(normalized_date: str, date_precision: str) -> str:
+    """Return an EF precision-span end without raising on malformed calendar data."""
+    normalized_date = str(normalized_date or "")
+    date_precision = str(date_precision or "")
+    if not (len(normalized_date) == 8 and normalized_date.isdigit()):
+        return normalized_date
+    try:
+        year = int(normalized_date[:4])
+        month = int(normalized_date[4:6])
+        day = int(normalized_date[6:8])
+        if date_precision == "year":
+            datetime(year, 1, 1)
+            return f"{year:04d}1231"
+        if date_precision == "month":
+            datetime(year, month, 1)
+            return f"{year:04d}{month:02d}{monthrange(year, month)[1]:02d}"
+        datetime(year, month, day)
+    except ValueError:
+        return normalized_date
+    return normalized_date
+
+
+def _truthy_detail_no(value: str) -> bool:
+    return value.isdigit() and value != "000"
+
+
+def is_ef_parent_row(record: dict[str, Any]) -> bool:
+    """Return whether an EF record is an E-derived parent row, not a detail row."""
+    detail_no = str(_field_value(record, "行為明細番号", "detail_no") or "").strip()
+    ef17 = str(_field_value(record, "行為明細区分情報") or "").strip().upper()
+    return detail_no == "000" or ef17 == "NULL"
+
+
+def is_comment_row(record: dict[str, Any]) -> bool:
+    """Return whether an EF record is a receipt comment row."""
+    code = str(_field_value(record, "レセプト電算処理システム用コード", "standardCode") or "")
+    return code.startswith("8")
+
+
+def is_efg_diagnosis_row(record: dict[str, Any]) -> bool:
+    """Return whether an EFg record is an SY diagnosis row."""
+    return str(_field_value(record, "データ区分", "data_kubun") or "").upper() == "SY"
+
+
+def split_ef17(raw: dict[str, Any] | str, source_kind: str) -> dict[str, Any]:
+    """Split EF-17 flags according to EFn or EFg semantics."""
+    if isinstance(raw, dict):
+        value = str(_field_value(raw, "行為明細区分情報") or "").strip()
+    else:
+        value = str(raw or "").strip()
+    result: dict[str, Any] = {"ef17_raw": value, "ef17_valid": len(value) >= 7 and value.isdigit()}
+    if not result["ef17_valid"]:
+        return result
+
+    source_kind = source_kind.lower()
+    if source_kind == "efg":
+        result.update(
+            {
+                "outside_prescription_flag": value[0],
+                "generic_prescription_flag": value[1],
+                "sex_code": value[2],
+                "outcome_code": value[3],
+                "main_disease_flag": value[4],
+                "inclusive_management_flag": value[5],
+                "refill_prescription_flag": value[6],
+            }
+        )
+    else:
+        result.update(
+            {
+                "discharge_prescription_flag": value[0],
+                "inclusive_item_flag": value[1],
+                "brought_in_drug_flag": value[2],
+                "brought_in_prescriber_flag": value[3],
+                "dpc_applicability_flag": value[4],
+                "basic_lab_xray_inclusive_flag": value[5],
+            }
+        )
+    return result
+
+
+def normalize_ef_record(record: dict[str, Any], source_kind: str) -> dict[str, Any]:
+    """Attach source-kind-specific aliases while preserving the original EF columns."""
+    source_kind = source_kind.lower()
+    data_kubun = str(_field_value(record, "データ区分") or "")
+    detail_no = str(_field_value(record, "行為明細番号") or "")
+    usage_raw = _field_value(record, "使用量")
+    action_count_raw = _field_value(record, "行為回数")
+    event_date_info = normalize_ef_date(
+        _field_value(record, "実施年月日", "実施年月日・診療開始日")
+    )
+    normalized: dict[str, Any] = {
+        **record,
+        "sourceKind": source_kind,
+        "facility_code": _field_value(record, "施設コード"),
+        "patient_id": _field_value(record, "データ識別番号"),
+        "data_kubun": data_kubun,
+        "categoryLabel": DATA_CATEGORY_LABELS.get(data_kubun, data_kubun),
+        "order_no": _field_value(record, "順序番号"),
+        "detail_no": detail_no,
+        "hospital_item_code": _field_value(record, "病院点数マスタコード"),
+        "receipt_code": _field_value(
+            record, "レセプト電算処理システム用コード", "レセプト電算コード"
+        ),
+        "interpretation_code": _field_value(record, "解釈番号"),
+        "item_name": _field_value(record, "診療明細名称"),
+        "usage_value_raw": usage_raw,
+        "usage_value_num": _to_number(usage_raw),
+        "unit_code": _field_value(record, "基準単位"),
+        "amount_or_points": _field_value(record, "明細点数・金額"),
+        "yen_point_kubun": _field_value(record, "円・点区分"),
+        "fee_for_service_points": _field_value(record, "出来高実績点数"),
+        "action_count": action_count_raw,
+        "action_count_num": _to_number(action_count_raw),
+        "receipt_type_code": _field_value(record, "レセプト種別コード"),
+        "receipt_department_code": _field_value(record, "レセプト科区分"),
+        "department_code": _field_value(record, "診療科区分"),
+        "eventDate": event_date_info["date"],
+        "raw_date": event_date_info["raw_date"],
+        "date_precision": event_date_info["date_precision"],
+        "standardCode": _field_value(
+            record, "レセプト電算処理システム用コード", "レセプト電算コード"
+        ),
+        "masterCode": _field_value(record, "病院点数マスタコード"),
+        "interpretationCode": _field_value(record, "解釈番号"),
+        "name": _field_value(record, "診療明細名称"),
+        "quantity": usage_raw,
+        "unitCode": _field_value(record, "基準単位"),
+    }
+    normalized.update(split_ef17(record, source_kind))
+    normalized["is_parent_row"] = is_ef_parent_row(normalized)
+    normalized["is_comment_row"] = is_comment_row(normalized)
+    normalized["is_diagnosis_row"] = source_kind == "efg" and is_efg_diagnosis_row(normalized)
+    if source_kind == "efg":
+        normalized.update(
+            {
+                "birth_date": _field_value(record, "退院年月日"),
+                "visit_date": _field_value(record, "入院年月日"),
+                "visit_month": _field_value(record, "入院年月日")[:6],
+                "service_date": event_date_info["date"],
+                "raw_service_date": event_date_info["raw_date"],
+                "service_date_precision": event_date_info["date_precision"],
+            }
+        )
+    else:
+        normalized.update(
+            {
+                "admission_date": _field_value(record, "入院年月日"),
+                "discharge_date": _field_value(record, "退院年月日"),
+                "service_date": event_date_info["date"],
+                "raw_service_date": event_date_info["raw_date"],
+                "service_date_precision": event_date_info["date_precision"],
+            }
+        )
+    normalized.update(derive_medication_period(normalized))
+    return normalized
+
+
+def _split_fixed_width(line: str) -> list[str]:
+    values: list[str] = []
+    offset = 0
+    for width in EF_FIXED_WIDTHS:
+        values.append(line[offset : offset + width].strip())
+        offset += width
+    return values
+
+
+def _iter_rows(path: Path, *, encoding: str, delimiter: str | None) -> list[list[str]]:
+    with path.open("r", encoding=encoding, newline="") as f:
+        if delimiter:
+            return list(csv.reader(f, delimiter=delimiter))
+        rows: list[list[str]] = []
+        for raw in f:
+            line = raw.rstrip("\r\n")
+            if "\t" in line:
+                rows.append(next(csv.reader([line], delimiter="\t")))
+            elif "," in line:
+                rows.append(next(csv.reader([line])))
+            else:
+                rows.append(_split_fixed_width(line))
+        return rows
+
+
+def _to_record(row: list[str], source_kind: str, columns: list[str]) -> dict[str, Any]:
+    padded = row + [""] * max(0, len(columns) - len(row))
+    record = {column: padded[index].strip() for index, column in enumerate(columns)}
+    return normalize_ef_record(record, source_kind)
+
+
+def read_ef_file(
+    path: Path,
+    *,
+    source_kind: str | None = None,
+    encoding: str = "cp932",
+    delimiter: str | None = None,
+    limit: int | None = None,
+) -> dict[str, Any]:
+    """Read EFn/EFg source records without study classification or GUI projections."""
+    inferred_kind = source_kind or path.name[:3].lower()
+    rows = _iter_rows(path, encoding=encoding, delimiter=delimiter)
+    columns, data_rows = _resolve_columns(rows)
+    records = [_to_record(row, inferred_kind, columns) for row in data_rows]
+    if limit is not None:
+        records = records[:limit]
+    return {
+        "sourcePath": str(path),
+        "sourceKind": inferred_kind,
+        "columns": columns,
+        "recordCount": len(records),
+        "records": records,
+    }
+
+