Improved DBI

app.py

@@ -3,7 +3,7 @@ from typing import Dict, Any
 from datetime import datetime
 
 from brand_to_generic import brand_lookup
-from dbi_mcp import dbi_mcp
+from dbi_mcp import dbi_mcp, dbi_mcp_mixed_routes
 from clinical_calculators import (
     cockcroft_gault_creatinine_clearance,
     ckd_epi_egfr,
@@ -53,6 +53,12 @@ def _dbi_mcp_gradio(text_block: str, route: str = "oral"):
     return standardize_response(result, "dbi_calculator")
 
 
+@with_error_handling
+def _dbi_mcp_mixed_routes_gradio(text_block: str):
+    result = dbi_mcp_mixed_routes(text_block, ref_csv="dbi_reference_by_route.csv")
+    return standardize_response(result, "dbi_calculator_mixed_routes")
+
+
 @with_error_handling
 def _cockcroft_gault_gradio(
     age: int, weight_kg: float, serum_creatinine: float, is_female: bool
@@ -249,6 +255,29 @@ def calculate_drug_burden_index_mcp(drug_list: str, route: str = "oral") -> str:
     return format_json_output(result)
 
 
+@with_error_handling
+def calculate_drug_burden_index_mixed_routes_mcp(drug_list: str) -> str:
+    """
+    Calculate Drug Burden Index (DBI) from a list of medications with automatic route detection.
+    
+    This enhanced version automatically detects the route of administration for each medication
+    (oral, transdermal patches, parenteral injections, etc.) and uses the appropriate reference
+    data for each route. Perfect for mixed medication lists.
+
+    Args:
+        drug_list (str): Drug list (one per line, include dose and frequency - also write "prn" if the drug is a PRN medication)
+                        Examples:
+                        - "Fentanyl 25mcg/hr patch daily"
+                        - "Amitriptyline 25mg tablet twice daily"
+                        - "Morphine 10mg injection PRN"
+
+    Returns:
+        str: JSON string with DBI calculation results broken down by route and individual drug contributions
+    """
+    result = _dbi_mcp_mixed_routes_gradio(drug_list)
+    return format_json_output(result)
+
+
 @with_error_handling
 def calculate_creatinine_clearance_mcp(
     age: str, weight_kg: str, serum_creatinine: str, is_female: str
@@ -739,11 +768,26 @@ dbi_calculator_ui = gr.Interface(
         gr.Text(label="Route of Administration", value="oral"),
     ],
     outputs=gr.JSON(label="DBI Calculation"),
-    title="DBI Calculator",
+    title="DBI Calculator (Single Route)",
     api_name="dbi_calculator",
     description="Calculate Drug Burden Index (DBI) from a list of medications. Supports PRN and various dose formats.",
 )
 
+dbi_mixed_routes_ui = gr.Interface(
+    fn=calculate_drug_burden_index_mixed_routes_mcp,
+    inputs=[
+        gr.Textbox(
+            label="Drug List (one per line, include dose and frequency)",
+            lines=10,
+            placeholder="e.g., Fentanyl 25mcg/hr patch daily\nAmitriptyline 25mg tablet twice daily\nMorphine 10mg injection PRN",
+        ),
+    ],
+    outputs=gr.JSON(label="DBI Calculation with Route Detection"),
+    title="DBI Calculator (Mixed Routes)",
+    api_name="dbi_calculator_mixed_routes",
+    description="Enhanced DBI calculator that automatically detects routes (oral, patches, injections, etc.) and uses appropriate reference data for each medication.",
+)
+
 cockcroft_gault_ui = gr.Interface(
     fn=calculate_creatinine_clearance_mcp,
     inputs=[
@@ -850,6 +894,7 @@ demo = gr.TabbedInterface(
         livertox_ui,
         brand_generic_ui,
         dbi_calculator_ui,
+        dbi_mixed_routes_ui,
         cockcroft_gault_ui,
         ckd_epi_ui,
         child_pugh_ui,
@@ -868,6 +913,7 @@ demo = gr.TabbedInterface(
         "LiverTox",
         "Brand to Generic",
         "DBI Calculator",
+        "DBI Mixed Routes",
         "Creatinine CL",
         "eGFR",
         "Child-Pugh",

dbi_mcp.py

@@ -18,9 +18,13 @@ except ImportError:
 
 __all__ = [
     "load_reference",
+    "load_all_routes_reference",
     "load_patient_meds",
     "calculate_dbi",
     "print_report",
+    "detect_route_from_text",
+    "dbi_mcp",
+    "dbi_mcp_mixed_routes",
 ]
 
 PatientInput = Union[
@@ -29,12 +33,69 @@ PatientInput = Union[
     Mapping[str, float],
 ]
 
+# Route detection patterns
+ROUTE_PATTERNS = {
+    'transdermal': [
+        r'\bpatch(es)?\b',
+        r'\btransdermal\b',
+        r'\bmcg/hr\b',
+        r'\bμg/hr\b',
+        r'\bmicrograms?/hr\b',
+        r'\bmicrograms?/hour\b',
+    ],
+    'parenteral': [
+        r'\binjection\b',
+        r'\biv\b',
+        r'\bim\b',
+        r'\bsc\b',
+        r'\bsubcut\b',
+        r'\bsubcutaneous\b',
+        r'\bintravenous\b',
+        r'\bintramuscular\b',
+        r'\bparenteral\b',
+    ],
+    'sublingual_buccal': [
+        r'\bsublingual\b',
+        r'\bbuccal\b',
+        r'\bsl\b',
+        r'\bunder.?tongue\b',
+    ],
+    'oral': [
+        r'\btab(let)?s?\b',
+        r'\bcap(sule)?s?\b',
+        r'\boral\b',
+        r'\bpo\b',
+        r'\bby.?mouth\b',
+        r'\bliquid\b',
+        r'\bsyrup\b',
+        r'\bsolution\b',
+        r'\bsuspension\b',
+    ]
+}
+
 
 def _normalise_name(name: str) -> str:
     """Strip/-lower a drug name for key matching."""
     return name.strip().lower()
 
 
+def detect_route_from_text(text: str) -> str:
+    """
+    Detect the most likely route of administration from medication text.
+    Returns the detected route or 'oral' as default.
+    """
+    text_lower = text.lower()
+    
+    # Check each route pattern
+    for route, patterns in ROUTE_PATTERNS.items():
+        for pattern in patterns:
+            if re.search(pattern, text_lower):
+                return route
+    
+    # Default to oral if no specific route detected
+    return 'oral'
+
+
 def load_reference(
     ref_path: Path,
     *,
@@ -72,6 +133,51 @@ def load_reference(
 
     return ref
 
+
+def load_all_routes_reference(
+    ref_path: Path,
+    *,
+    use_pandas: bool | None = None,
+) -> Dict[str, Dict[str, Tuple[float, str]]]:
+    """
+    Load reference data for all routes.
+    Returns mapping: route → {generic → (δ, drug_class)}
+    """
+    if use_pandas is None:
+        use_pandas = pd is not None
+
+    all_routes: Dict[str, Dict[str, Tuple[float, str]]] = {}
+
+    if use_pandas:
+        df = pd.read_csv(ref_path)
+        for _, row in df.iterrows():
+            route = row["route"].strip().lower()
+            generic = _normalise_name(row["generic_name"])
+            
+            if route not in all_routes:
+                all_routes[route] = {}
+            
+            all_routes[route][generic] = (
+                float(row["min_daily_dose_mg"]),
+                row["drug_class"].strip().lower(),
+            )
+    else:
+        with ref_path.open(newline="") as f:
+            rdr = csv.DictReader(f)
+            for row in rdr:
+                route = row["route"].strip().lower()
+                generic = _normalise_name(row["generic_name"])
+                
+                if route not in all_routes:
+                    all_routes[route] = {}
+                
+                all_routes[route][generic] = (
+                    float(row["min_daily_dose_mg"]),
+                    row["drug_class"].strip().lower(),
+                )
+
+    return all_routes
+
 def calculate_dbi(
     patient_meds: Mapping[str, float],
     reference: Mapping[str, Tuple[float, str]],
@@ -141,7 +247,7 @@ def _freq_to_per_day(token: str) -> float:
         return 24 / hrs if hrs else 1
     return 1
 
-Parsed = Tuple[str, float, bool]
+Parsed = Tuple[str, float, bool, str]  # Added route detection
 
 @functools.lru_cache(maxsize=2048)
 def _parse_line(line: str) -> Optional[Parsed]:
@@ -150,13 +256,15 @@ def _parse_line(line: str) -> Optional[Parsed]:
         return None
 
     is_prn = "prn" in original.lower()
+    detected_route = detect_route_from_text(original)
 
     m_patch = PATCH_PAT.search(original)
     if m_patch:
         mcg_hr = float(m_patch.group("val").replace(",", "."))
         mg_day = (mcg_hr * 24) / 1_000  # µg/hr → mg/day
         name_part = PATCH_PAT.sub("", original).split()[0]
-        return (name_part, mg_day, is_prn)
+        # Override route detection for patches
+        return (name_part, mg_day, is_prn, "transdermal")
 
     m_conc = CONC_PAT.search(original)
     m_vol  = VOL_PAT.search(original)
@@ -175,7 +283,7 @@ def _parse_line(line: str) -> Optional[Parsed]:
             freq = _freq_to_per_day(m_freq.group(0))
         mg_day = mg_per_dose * freq
         name_part = CONC_PAT.split(original)[0].strip()
-        return (name_part, mg_day, is_prn)
+        return (name_part, mg_day, is_prn, detected_route)
 
     m = UNIT_PAT.search(original)
     if m:
@@ -192,30 +300,35 @@ def _parse_line(line: str) -> Optional[Parsed]:
         name_part = original[:m.start()].strip()
         name_part = re.sub(r"[^A-Za-z0-9\s]", " ", name_part)
         name_part = re.sub(r"\s+", " ", name_part).strip()
-        return (name_part, mg_day, is_prn)
+        return (name_part, mg_day, is_prn, detected_route)
 
     logger.debug("unhandled line: %s", original)
     return None
 
-def _smart_drug_lookup(raw_name: str, reference_data: dict) -> str:
+def _smart_drug_lookup(raw_name: str, all_routes_reference: Dict[str, Dict[str, Tuple[float, str]]]) -> str:
     """
     Smart drug name resolution that avoids unnecessary API calls.
+    Works with multi-route reference data.
     
-    1. First checks if the name (or close variant) exists in reference data
+    1. First checks if the name (or close variant) exists in any route's reference data
     2. Only calls brand_lookup API if not found in reference
     3. Returns the best generic name match
     """
     clean_name = raw_name.strip().lower()
     
-    if clean_name in reference_data:
-        logger.debug(f"Direct match found for '{raw_name}' in reference data")
-        return clean_name
+    # Check all routes for direct match
+    for route_data in all_routes_reference.values():
+        if clean_name in route_data:
+            logger.debug(f"Direct match found for '{raw_name}' in reference data")
+            return clean_name
     
-    for ref_name in reference_data.keys():
-        if len(clean_name) >= 4 and len(ref_name) >= 4:
-            if clean_name in ref_name or ref_name in clean_name:
-                logger.debug(f"Partial match found: '{raw_name}' -> '{ref_name}' in reference data")
-                return ref_name
+    # Check all routes for partial match
+    for route_data in all_routes_reference.values():
+        for ref_name in route_data.keys():
+            if len(clean_name) >= 4 and len(ref_name) >= 4:
+                if clean_name in ref_name or ref_name in clean_name:
+                    logger.debug(f"Partial match found: '{raw_name}' -> '{ref_name}' in reference data")
+                    return ref_name
     
     common_variations = {
         'acetaminophen': 'paracetamol',
@@ -228,9 +341,11 @@ def _smart_drug_lookup(raw_name: str, reference_data: dict) -> str:
     
     if clean_name in common_variations:
         alt_name = common_variations[clean_name]
-        if alt_name in reference_data:
-            logger.debug(f"Found common variation: '{raw_name}' -> '{alt_name}' in reference data")
-            return alt_name
+        # Check all routes for the alternative name
+        for route_data in all_routes_reference.values():
+            if alt_name in route_data:
+                logger.debug(f"Found common variation: '{raw_name}' -> '{alt_name}' in reference data")
+                return alt_name
     
     logger.debug(f"'{raw_name}' not found in reference data, trying brand lookup API")
     try:
@@ -263,8 +378,11 @@ def dbi_mcp(text_block: str, *, ref_csv: Union[str, Path] = "dbi_reference_by_ro
     meds_with: Dict[str, float] = {}
     meds_without: Dict[str, float] = {}
 
-    for raw_name, mg_day, is_prn in parsed:
-        generic = _smart_drug_lookup(raw_name, ref)
+    # Load all routes for smart lookup (backward compatibility)
+    all_routes_ref = load_all_routes_reference(Path(ref_csv))
+
+    for raw_name, mg_day, is_prn, detected_route in parsed:
+        generic = _smart_drug_lookup(raw_name, all_routes_ref)
         
         meds_with[generic] = meds_with.get(generic, 0.0) + mg_day
         if not is_prn:
@@ -286,6 +404,116 @@ def dbi_mcp(text_block: str, *, ref_csv: Union[str, Path] = "dbi_reference_by_ro
     }
 
 
+def dbi_mcp_mixed_routes(text_block: str, *, ref_csv: Union[str, Path] = "dbi_reference_by_route.csv") -> dict:
+    """
+    Enhanced DBI calculator that handles mixed routes automatically.
+    
+    This function:
+    1. Detects the route for each medication from the text
+    2. Uses the appropriate reference data for each route
+    3. Provides detailed breakdown by route and medication
+    """
+    all_routes_ref = load_all_routes_reference(Path(ref_csv))
+    
+    parsed: List[Parsed] = []
+    unmatched: List[str] = []
+    route_stats: Dict[str, int] = {}
+    
+    for ln in text_block.splitlines():
+        res = _parse_line(ln)
+        if res:
+            parsed.append(res)
+            route = res[3]  # detected route
+            route_stats[route] = route_stats.get(route, 0) + 1
+        else:
+            unmatched.append(ln)
+
+    # Organize medications by route and PRN status
+    meds_by_route_with: Dict[str, Dict[str, float]] = {}
+    meds_by_route_without: Dict[str, Dict[str, float]] = {}
+    medication_details: List[Dict] = []
+
+    for raw_name, mg_day, is_prn, detected_route in parsed:
+        generic = _smart_drug_lookup(raw_name, all_routes_ref)
+        
+        # Initialize route dictionaries if needed
+        if detected_route not in meds_by_route_with:
+            meds_by_route_with[detected_route] = {}
+            meds_by_route_without[detected_route] = {}
+        
+        # Add to appropriate dictionaries
+        meds_by_route_with[detected_route][generic] = meds_by_route_with[detected_route].get(generic, 0.0) + mg_day
+        if not is_prn:
+            meds_by_route_without[detected_route][generic] = meds_by_route_without[detected_route].get(generic, 0.0) + mg_day
+        
+        # Store medication details
+        medication_details.append({
+            "original_text": f"{raw_name} {mg_day}mg/day",
+            "generic_name": generic,
+            "dose_mg_day": mg_day,
+            "detected_route": detected_route,
+            "is_prn": is_prn
+        })
+
+    # Calculate DBI for each route
+    route_results = {}
+    total_dbi_with = 0.0
+    total_dbi_without = 0.0
+    all_details_with = []
+    all_details_without = []
+
+    for route in meds_by_route_with.keys():
+        if route in all_routes_ref:
+            route_ref = all_routes_ref[route]
+            
+            # Calculate DBI for this route
+            dbi_with, details_with = calculate_dbi(meds_by_route_with[route], route_ref)
+            dbi_without, details_without = calculate_dbi(meds_by_route_without[route], route_ref)
+            
+            total_dbi_with += dbi_with
+            total_dbi_without += dbi_without
+            
+            # Format details
+            def _format_details(details, route_name):
+                formatted = []
+                for g, d, delta, dbi in details:
+                    formatted.append({
+                        "generic_name": g,
+                        "dose_mg_day": d,
+                        "delta_mg": delta,
+                        "dbi_component": dbi,
+                        "route": route_name
+                    })
+                return formatted
+            
+            route_details_with = _format_details(details_with, route)
+            route_details_without = _format_details(details_without, route)
+            
+            all_details_with.extend(route_details_with)
+            all_details_without.extend(route_details_without)
+            
+            route_results[route] = {
+                "dbi_with_prn": round(dbi_with, 2),
+                "dbi_without_prn": round(dbi_without, 2),
+                "details_with_prn": route_details_with,
+                "details_without_prn": route_details_without,
+                "medication_count": route_stats.get(route, 0)
+            }
+
+    return {
+        "mixed_routes": True,
+        "total_dbi_without_prn": round(total_dbi_without, 2),
+        "total_dbi_with_prn": round(total_dbi_with, 2),
+        "routes_detected": list(route_stats.keys()),
+        "route_statistics": route_stats,
+        "route_breakdown": route_results,
+        "all_details_without_prn": all_details_without,
+        "all_details_with_prn": all_details_with,
+        "medication_details": medication_details,
+        "unmatched_input": unmatched,
+    }
+
+
 if __name__ == "__main__":
     import sys
     import pprint

dbi_reference_by_route.csv

@@ -117,3 +117,7 @@ trimipramine,oral,37.5,both
 triprolidine,oral,10,both
 zuclopenthixol,oral,20,both
 zuclopenthixol,parenteral,11.4,both
+fentanyl,transdermal,0.3,sedative
+buprenorphine,transdermal,0.12,sedative
+clonidine,transdermal,0.1,both
+scopolamine,transdermal,0.5,both