support forwarding vitals and syncing patients to multiple configurable URLs

Dockerfile

@@ -1,6 +1,7 @@
 FROM python:3.12-slim
 
 WORKDIR /app
+ENV PYTHONPATH=/app
 
 # Install dependencies
 COPY requirements.txt .

api_client.py

@@ -1,5 +1,7 @@
 import httpx
 import logging
+import asyncio
+import os
 from typing import Optional
 from schemas import NormalizedVitals
 from config import settings
@@ -12,18 +14,21 @@ def get_http_client() -> httpx.AsyncClient:
     global _http_client
     if _http_client is None or _http_client.is_closed:
         _http_client = httpx.AsyncClient(
-            timeout=httpx.Timeout(connect=3.0, read=5.0, write=3.0, pool=3.0),
-            limits=httpx.Limits(max_keepalive_connections=5, max_connections=10)
+            timeout=httpx.Timeout(connect=5.0, read=5.0, write=5.0, pool=10.0),
+            limits=httpx.Limits(max_keepalive_connections=20, max_connections=50)
         )
     return _http_client
 
+def get_cloud_base_url() -> str:
+    url = getattr(settings, "cloud_api_url", None) or os.getenv("CLOUD_API_URL") or "https://services-api.a2zhealth.in/v1/contec-monitor"
+    return url.rstrip("/")
+
 async def forward_vitals_to_api(vitals: NormalizedVitals) -> bool:
     """
     Attempts to POST the normalized vitals to the configured target API
-    and to the Render cloud database.
+    and to the Cloud server concurrently.
     Returns True if at least one forward succeeds.
     """
-    import os
     headers = {"Content-Type": "application/json"}
     
     # Strip heavy wave sample arrays before REST transmission (cloud APIs only ingest vital signs)
@@ -31,51 +36,91 @@ async def forward_vitals_to_api(vitals: NormalizedVitals) -> bool:
     payload.pop("ecg_wave", None)
     payload.pop("pleth_wave", None)
     
+    if not payload.get("patient_id"):
+        payload["patient_id"] = "UNKNOWN"
+        
     client = get_http_client()
     
-    # 1. Forward to primary target API (e.g. Injomo Dev Workflow)
-    primary_url = settings.target_api_url
-    primary_success = False
-    if primary_url:
+    async def _post_target(url: str, label: str) -> bool:
+        if not url:
+            return False
+        curr_port = os.getenv("PORT", "8000")
+        if f":{curr_port}" in url and ("localhost" in url or "127.0.0.1" in url):
+            return False
         try:
-            primary_headers = headers.copy()
+            req_headers = headers.copy()
             if settings.api_token:
-                primary_headers["Authorization"] = f"Bearer {settings.api_token}"
-            response = await client.post(
-                primary_url,
-                json=payload,
-                headers=primary_headers
-            )
+                req_headers["Authorization"] = f"Bearer {settings.api_token}"
+            url_to_call = url
+            if settings.api_token and "?" not in url and "/api/push-vitals" in url:
+                url_to_call = f"{url}?api_key={settings.api_token}"
+            response = await client.post(url_to_call, json=payload, headers=req_headers)
             response.raise_for_status()
-            logger.info(f"Successfully forwarded vitals to primary API for device {vitals.device_id}")
-            primary_success = True
+            logger.info(f"Successfully forwarded vitals to {label} ({url}) for device {vitals.device_id}")
+            return True
         except Exception as e:
             err_msg = str(e).strip() or "timeout / connection reset"
-            logger.warning(f"Error forwarding to primary API: {type(e).__name__} ({err_msg})")
+            logger.warning(f"Error forwarding to {label} ({url}): {type(e).__name__} ({err_msg})")
+            return False
 
-    # 2. Forward to Render Cloud Server
-    render_url = "https://contectfiveparamonitor.onrender.com/api/push-vitals"
-    render_success = False
-    
-    # Detect if we are already running on Render to prevent an infinite loop
-    is_on_render = os.getenv("RENDER") is not None or os.getenv("PORT") == "10000" or "render.local" in os.getenv("HOSTNAME", "")
-    
-    if not is_on_render:
+    targets = []
+    if settings.target_api_url:
+        targets.append((settings.target_api_url, "Primary Target API"))
+
+    cloud_base = get_cloud_base_url()
+    is_on_cloud = os.getenv("RENDER") is not None or os.getenv("PORT") == "10000" or "render.local" in os.getenv("HOSTNAME", "")
+    if not (is_on_cloud and "onrender.com" in cloud_base):
+        cloud_push_url = f"{cloud_base}/api/push-vitals" if not cloud_base.endswith("/api/push-vitals") else cloud_base
+        if cloud_push_url not in [t[0] for t in targets]:
+            targets.append((cloud_push_url, "Cloud Server"))
+
+    for extra_url in getattr(settings, "forward_urls", []):
+        if extra_url and extra_url not in [t[0] for t in targets]:
+            targets.append((extra_url, "Configured Forward URL"))
+
+    tasks = [_post_target(url, lbl) for url, lbl in targets]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    return any(r is True for r in results if not isinstance(r, Exception))
+
+
+async def sync_patient_assignment_to_cloud(patient_data: dict, device_id: str) -> bool:
+    """
+    Synchronizes patient demographics assignment to Cloud and LAN servers.
+    Ensures local and remote dashboards always show the exact same patient.
+    """
+    client = get_http_client()
+    payload = {
+        "device_id": device_id,
+        "mrn": patient_data.get("mrn") or patient_data.get("patient_id") or "",
+        "name": patient_data.get("name") or patient_data.get("patient_name") or "Unknown",
+        "dob": patient_data.get("dob") or patient_data.get("patient_dob"),
+        "gender": patient_data.get("gender") or patient_data.get("patient_gender"),
+        "bed_id": patient_data.get("bed_id"),
+        "patient_type": patient_data.get("patient_type")
+    }
+
+    targets = []
+    cloud_base = get_cloud_base_url()
+    targets.append(f"{cloud_base}/api/patient/assign")
+
+    for extra_url in getattr(settings, "forward_urls", []):
+        if "/api/push-vitals" in extra_url:
+            assign_url = extra_url.replace("/api/push-vitals", "/api/patient/assign")
+            if assign_url not in targets:
+                targets.append(assign_url)
+
+    async def _sync_one(url: str) -> bool:
         try:
-            url_with_key = render_url
+            url_with_key = url
             if settings.api_token:
-                url_with_key = f"{render_url}?api_key={settings.api_token}"
-                
-            response = await client.post(
-                url_with_key,
-                json=payload,
-                headers=headers
-            )
-            response.raise_for_status()
-            logger.info(f"Successfully forwarded vitals to Render Cloud for device {vitals.device_id}")
-            render_success = True
+                url_with_key = f"{url}?api_key={settings.api_token}"
+            resp = await client.post(url_with_key, json=payload, headers={"Content-Type": "application/json"})
+            resp.raise_for_status()
+            logger.info(f"Successfully synced patient {payload['mrn']} to {url} for {device_id}")
+            return True
         except Exception as e:
-            err_msg = str(e).strip() or "timeout / connection reset"
-            logger.warning(f"Error forwarding to Render Cloud: {type(e).__name__} ({err_msg})")
-            
-    return primary_success or render_success
+            logger.warning(f"Could not sync patient assignment to {url}: {type(e).__name__} ({e})")
+            return False
+
+    results = await asyncio.gather(*[_sync_one(u) for u in targets], return_exceptions=True)
+    return any(r is True for r in results if not isinstance(r, Exception))

background_tasks.py

@@ -79,3 +79,91 @@ async def retry_failed_transmissions():
             logger.error(f"Error in retry background task: {e}")
             
         await asyncio.sleep(settings.retry_interval_seconds)
+
+
+async def sync_cloud_state():
+    """
+    Periodically syncs all assigned patients and their latest non-null vitals to Render Cloud.
+    Ensures that whenever Render restarts or deploys with an empty DB, the cloud dashboard
+    is immediately populated with the same data as localhost.
+    """
+    import os
+    if os.getenv("RENDER") is not None or os.getenv("PORT") == "10000" or "render.local" in os.getenv("HOSTNAME", ""):
+        return  # Do not run sync loop if we are running inside Render
+
+    from models import Patient
+    from api_client import sync_patient_assignment_to_cloud, forward_vitals_to_api
+    from datetime import datetime, timezone
+    from sqlalchemy import or_
+
+    logger.info("Starting background task for periodic cloud state sync to Render...")
+    await asyncio.sleep(5)
+
+    while True:
+        try:
+            db = SessionLocal()
+            try:
+                patients = db.query(Patient).filter(
+                    Patient.patient_id != "UNKNOWN",
+                    Patient.mrn != "UNKNOWN"
+                ).all()
+
+                for p in patients:
+                    if not p.device_id:
+                        continue
+
+                    # 1. Sync patient demographics assignment to Render
+                    p_data = {
+                        "mrn": p.mrn or p.patient_id,
+                        "name": p.name,
+                        "gender": p.gender,
+                        "dob": p.dob,
+                        "bed_id": p.bed_id,
+                        "patient_type": getattr(p, "patient_type", None)
+                    }
+                    await sync_patient_assignment_to_cloud(p_data, p.device_id)
+
+                    # 2. Forward latest non-null vitals to Render (Option B)
+                    from sqlalchemy import or_
+                    from datetime import datetime, timezone
+                    patient_filters = or_(
+                        VitalReading.patient_id == p.mrn,
+                        VitalReading.patient_id == p.patient_id,
+                        VitalReading.device_id == p.device_id
+                    )
+                    hr_r = db.query(VitalReading.heart_rate).filter(patient_filters, VitalReading.heart_rate != None).order_by(VitalReading.timestamp.desc()).first()
+                    spo2_r = db.query(VitalReading.spo2).filter(patient_filters, VitalReading.spo2 != None).order_by(VitalReading.timestamp.desc()).first()
+                    bp_r = db.query(VitalReading.systolic_bp, VitalReading.diastolic_bp, VitalReading.map_bp).filter(patient_filters, VitalReading.systolic_bp != None).order_by(VitalReading.timestamp.desc()).first()
+                    temp_r = db.query(VitalReading.temperature).filter(patient_filters, VitalReading.temperature != None).order_by(VitalReading.timestamp.desc()).first()
+                    temp2_r = db.query(VitalReading.temperature2).filter(patient_filters, VitalReading.temperature2 != None).order_by(VitalReading.timestamp.desc()).first()
+                    temp_diff_r = db.query(VitalReading.temperature_diff).filter(patient_filters, VitalReading.temperature_diff != None).order_by(VitalReading.timestamp.desc()).first()
+                    rr_r = db.query(VitalReading.respiratory_rate).filter(patient_filters, VitalReading.respiratory_rate != None).order_by(VitalReading.timestamp.desc()).first()
+
+                    if hr_r or spo2_r or temp_r or bp_r:
+                        merged = NormalizedVitals(
+                            device_id=p.device_id,
+                            patient_id=p.mrn or p.patient_id,
+                            patient_name=p.name,
+                            patient_gender=p.gender,
+                            patient_dob=p.dob,
+                            bed_id=p.bed_id,
+                            patient_type=getattr(p, "patient_type", None),
+                            timestamp=datetime.now(timezone.utc),
+                            heart_rate=hr_r[0] if hr_r else None,
+                            spo2=spo2_r[0] if spo2_r else None,
+                            systolic_bp=bp_r[0] if bp_r else None,
+                            diastolic_bp=bp_r[1] if bp_r else None,
+                            map_bp=bp_r[2] if bp_r else None,
+                            temperature=temp_r[0] if temp_r else None,
+                            temperature2=temp2_r[0] if temp2_r else None,
+                            temperature_diff=temp_diff_r[0] if temp_diff_r else None,
+                            respiratory_rate=rr_r[0] if rr_r else None
+                        )
+                        await forward_vitals_to_api(merged)
+            finally:
+                db.close()
+        except Exception as e:
+            logger.error(f"Error in sync_cloud_state background task: {e}")
+
+        await asyncio.sleep(15)
+

config.json

@@ -1,13 +1,18 @@
 {
   "hl7_host": "0.0.0.0",
   "hl7_port": 6060,
-  "contec_ports": [511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 8001, 8002, 8300, 9000, 9100, 9200, 10008, 12345],
+  "contec_ports": [511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 8001, 8002, 8300, 9000, 9100, 9200, 10008, 12345, 61501],
   "monitor_ip": "",
   "monitor_model": "CMS8500",
   "device_models": {
     "192.168.100.120": "CMS7000PLUS"
   },
-  "target_api_url": "https://innov-dev.beta.injomo.com/workflow.trigger/69b2712a7866bf86ca0060c3",
+  "target_api_url": "https://services-api.a2zhealth.in/v1/contec-monitor",
+  "cloud_api_url": "https://services-api.a2zhealth.in/v1/contec-monitor",
+  "forward_urls": [
+    "http://192.168.100.104:10000/api/push-vitals",
+    "https://services-api.a2zhealth.in/v1/contec-monitor"
+  ],
   "api_token": "",
   "retry_interval_seconds": 60,
   "log_file": "hl7_forwarder.log",

config.py

@@ -5,17 +5,23 @@ from pydantic_settings import BaseSettings
 class Settings(BaseSettings):
     hl7_host: str = "0.0.0.0"
     hl7_port: int = 6060
-    contec_ports: list = [511, 515, 516, 517, 518, 519, 520]
+    contec_ports: list = [511, 515, 516, 517, 518, 519, 520, 61501]
     monitor_ip: str = ""
     monitor_model: str = "CMS7000PLUS"
     device_models: dict = {}
-    target_api_url: str = "https://api.example.com/vitals"
+    target_api_url: str = "https://services-api.a2zhealth.in/v1/contec-monitor"
+    cloud_api_url: str = "https://services-api.a2zhealth.in/v1/contec-monitor"
+    forward_urls: list = [
+        "http://192.168.100.104:10000/api/push-vitals",
+        "https://services-api.a2zhealth.in/v1/contec-monitor"
+    ]
     api_token: str = ""
     retry_interval_seconds: int = 60
     log_file: str = "hl7_forwarder.log"
     database_url: str = "sqlite:///./hl7_forwarder.db"
 
     class Config:
+        
         env_file = ".env"
 
 def get_settings() -> Settings:

contec_parser.py

@@ -58,13 +58,14 @@ CONTEC_PARAM_MAP = {
     # Temperature
     "TEMP": "temperature",
     "TEMP1": "temperature",
-    "TEMP2": "temperature",
+    "TEMP2": "temperature2",
     "T1": "temperature",
-    "T2": "temperature",
+    "T2": "temperature2",
     "BODY_TEMP": "temperature",
     "TEMP-1": "temperature",
-    "TEMP-2": "temperature",
+    "TEMP-2": "temperature2",
     "BODYTEMP": "temperature",
+    "TD": "temperature_diff",
 }
 
 # Sentinel value used by Contec to mark an invalid/disconnected parameter
@@ -164,6 +165,10 @@ def parse_contec_hl7_text(raw_text: str, client_ip: str) -> Optional[NormalizedV
                 if len(fields) > 8 and fields[8]:
                     vitals_dict["patient_gender"] = fields[8].strip().upper()
 
+                # PID-35: Patient Category (ADULT / PEDIATRIC / NEONATAL)
+                if len(fields) > 35 and fields[35]:
+                    vitals_dict["patient_type"] = fields[35].strip()
+
             elif seg_name == "PV1":
                 # PV1-3: Assigned Patient Location  (Room^Bed^...)
                 if len(fields) > 3 and fields[3]:
@@ -173,6 +178,10 @@ def parse_contec_hl7_text(raw_text: str, client_ip: str) -> Optional[NormalizedV
                     if bed:
                         vitals_dict["bed_id"] = bed
 
+                # PV1-18: Patient Type
+                if len(fields) > 18 and fields[18]:
+                    vitals_dict["patient_type"] = fields[18].strip()
+
             elif seg_name == "OBX":
                 if len(fields) > 5:
                     obs_val = fields[5].strip()
@@ -278,6 +287,7 @@ def _parse_45_byte_packet(data: bytes, vitals_dict: dict) -> bool:
     if "present_fields" not in vitals_dict:
         vitals_dict["present_fields"] = []
 
+    logger.debug("DEBUG_NIBP_PKT len=%d nibp_hex=%s", len(data), data[8:24].hex())
     nibp_sys = read_u16_le(data, 15)
     nibp_dia = read_u16_le(data, 17)
     nibp_map = read_u16_le(data, 19)
@@ -304,7 +314,7 @@ def _parse_45_byte_packet(data: bytes, vitals_dict: dict) -> bool:
 
 def _parse_56_byte_packet(data: bytes, vitals_dict: dict) -> bool:
     """
-    Parse 56-byte packet (Subtype 23) — contains float32 Temperature values.
+    Parse 56-byte packet (Subtype 23) — contains float32 Temperature values for T1 and T2.
     
     Verified layout:
       [8-11]   Temperature 1 (float32)
@@ -318,8 +328,6 @@ def _parse_56_byte_packet(data: bytes, vitals_dict: dict) -> bool:
     if "present_fields" not in vitals_dict:
         vitals_dict["present_fields"] = []
 
-    found = False
-
     temp1 = read_f32_le(data, 8)
     temp2 = read_f32_le(data, 12)
 
@@ -327,24 +335,24 @@ def _parse_56_byte_packet(data: bytes, vitals_dict: dict) -> bool:
         # Disconnected sentinel is 9999.0 or 3276.7 (0x7FFF)
         return t is not None and is_valid_f32(t) and abs(t - 3276.7) > 1.0 and 20.0 < t < 45.0
 
-    if is_real_temp(temp1):
-        vitals_dict["temperature"] = round(temp1, 1)
-        if "temperature" not in vitals_dict["present_fields"]:
-            vitals_dict["present_fields"].append("temperature")
-        found = True
-    elif is_real_temp(temp2):
-        vitals_dict["temperature"] = round(temp2, 1)
-        if "temperature" not in vitals_dict["present_fields"]:
-            vitals_dict["present_fields"].append("temperature")
-        found = True
-    elif temp1 is not None or temp2 is not None:
-        # Sensor disconnected / off
-        vitals_dict["temperature"] = None
-        if "temperature" not in vitals_dict["present_fields"]:
-            vitals_dict["present_fields"].append("temperature")
-        found = True
+    t1_val = round(temp1, 1) if is_real_temp(temp1) else None
+    t2_val = round(temp2, 1) if is_real_temp(temp2) else None
 
-    return found
+    vitals_dict["temperature"] = t1_val
+    vitals_dict["temperature2"] = t2_val
+    if t1_val is not None and t2_val is not None:
+        vitals_dict["temperature_diff"] = round(abs(t1_val - t2_val), 1)
+    else:
+        vitals_dict["temperature_diff"] = None
+
+    if "temperature" not in vitals_dict["present_fields"]:
+        vitals_dict["present_fields"].append("temperature")
+    if "temperature2" not in vitals_dict["present_fields"]:
+        vitals_dict["present_fields"].append("temperature2")
+    if "temperature_diff" not in vitals_dict["present_fields"]:
+        vitals_dict["present_fields"].append("temperature_diff")
+
+    return (t1_val is not None or t2_val is not None)
 
 
 def _parse_spo2_waveform_packet(data: bytes, vitals_dict: dict) -> bool:
@@ -364,42 +372,26 @@ def _parse_spo2_waveform_packet(data: bytes, vitals_dict: dict) -> bool:
     if "pleth_wave" not in vitals_dict["present_fields"]:
         vitals_dict["present_fields"].append("pleth_wave")
 
-    found = False
-
     # Check SpO2 at standard offset 264
     spo2_val = read_u16_le(data, 264)
 
-    # If 264 is disconnected sentinel, probe is NOT connected / off-finger
-    if spo2_val in (None, 65535, 32767, 255, 9999, 0):
-        vitals_dict["spo2"] = None
-        vitals_dict["heart_rate"] = None
-        if "spo2" not in vitals_dict["present_fields"]:
-            vitals_dict["present_fields"].append("spo2")
-        if "heart_rate" not in vitals_dict["present_fields"]:
-            vitals_dict["present_fields"].append("heart_rate")
-        return True
-
-    if 50 <= spo2_val <= 100:
+    if spo2_val is not None and 50 <= spo2_val <= 100:
         vitals_dict["spo2"] = float(spo2_val)
         if "spo2" not in vitals_dict["present_fields"]:
             vitals_dict["present_fields"].append("spo2")
-        found = True
 
-        # ECG HR is at offset 266 in the 286-byte SpO2 waveform packet footer.
-        # Offset 268 is the SpO2 HIGH ALARM LIMIT (always 100) — NOT pulse rate!
-        # So we read ECG HR at 266 only.
+        # Pulse Rate / ECG HR is at offset 266 in the footer
         ecg_hr = read_u16_le(data, 266)
-
-        logger.info(
-            f"SpO2 pkt: SpO2[264]={spo2_val}  ECG_HR[266]={ecg_hr}  alarm_hi[268]={read_u16_le(data,268)}  alarm_lo[270]={read_u16_le(data,270) if len(data)>=272 else 'N/A'}"
-        )
-
         if ecg_hr is not None and ecg_hr not in (9999, 65535, 32767, 0) and 20 <= ecg_hr <= 300:
             vitals_dict["heart_rate"] = float(ecg_hr)
             if "heart_rate" not in vitals_dict["present_fields"]:
                 vitals_dict["present_fields"].append("heart_rate")
 
-    return found
+        logger.info(
+            f"SpO2 pkt: SpO2[264]={spo2_val}  ECG_HR[266]={ecg_hr}  alarm_hi[268]={read_u16_le(data,268)}  alarm_lo[270]={read_u16_le(data,270) if len(data)>=272 else 'N/A'}"
+        )
+
+    return True
 
 
 def _parse_286_byte_packet(data: bytes, vitals_dict: dict) -> bool:
@@ -435,13 +427,13 @@ def _parse_989_byte_packet(data: bytes, vitals_dict: dict) -> bool:
     if "ecg_wave" not in vitals_dict["present_fields"]:
         vitals_dict["present_fields"].append("ecg_wave")
 
+    logger.debug("DEBUG_ECG_PKT len=%d tail_hex=%s", len(data), data[890:989].hex())
     hr_val = read_u16_le(data, 904)
-    if hr_val is not None and hr_val not in (65535, 9999, 0) and 20 <= hr_val <= 300:
-        # Only use ECG HR if SpO2-probe PR has NOT already set heart_rate.
-        # SpO2 PR (from the pleth packet) matches the monitor display and wins.
-        if "heart_rate" not in vitals_dict.get("present_fields", []):
+    if hr_val is not None and hr_val not in (65535, 32767, 9999, 0) and 20 <= hr_val <= 300:
+        if vitals_dict.get("heart_rate") is None:
             vitals_dict["heart_rate"] = float(hr_val)
-            vitals_dict.setdefault("present_fields", []).append("heart_rate")
+            if "heart_rate" not in vitals_dict.setdefault("present_fields", []):
+                vitals_dict["present_fields"].append("heart_rate")
 
     return True
 
@@ -479,9 +471,7 @@ def _find_vitals_block_in_stream(data: bytes, client_ip: str) -> Optional[Normal
                 elif pkt_len == 989:
                     if _parse_989_byte_packet(pkt_data, vitals_dict):
                         found_any = True
-                elif 100 < pkt_len < 600:
-                    if _parse_spo2_waveform_packet(pkt_data, vitals_dict):
-                        found_any = True
+                # Handled specifically by known packet sizes above
 
             i += max(pkt_len, 4)
         else:

contec_server.py

@@ -58,25 +58,58 @@ TELEMETRY_WORDS = {
 }
 
 
+def is_telemetry_word(s_lower: str) -> bool:
+    """Check if string matches hardware telemetry or alarm words."""
+    if s_lower in TELEMETRY_WORDS:
+        return True
+    tokens = set(re.findall(r'[a-zA-Z0-9]+', s_lower))
+    alarm_tokens = {
+        'sensor', 'alarm', 'lead', 'leads', 'searching', 'pulse', 'cuff', 'probe',
+        'off', 'fall', 'leak', 'motion', 'weak', 'arr', 'asystole', 'vfib', 'vtac',
+        'pvc', 'brady', 'tachy', 'error', 'ecg', 'spo2', 'nibp', 'resp', 'temp',
+        'mv', 'bpm', 'mmhg'
+    }
+    if any(tok in alarm_tokens for tok in tokens):
+        return True
+    return False
+
+
 def extract_demographics_from_packet(data: bytes, client_ip: str) -> dict:
     """
-    Extracts real patient demographics from Contec CMS8500 / CMS7000 binary packets.
+    Extracts real patient demographics from Contec packets.
     Only extracts clean, legitimate patient fields — strictly rejects sensor alarms,
     waveform noise, and hardware telemetry.
     """
+    patient_type = None
+    data_upper = data.upper()
+    if b'PEDIATRIC' in data_upper or b'PED' in data_upper:
+        patient_type = 'Pediatric'
+    elif b'NEONATE' in data_upper or b'NEONATAL' in data_upper or b'NEO' in data_upper:
+        patient_type = 'Neonatal'
+    elif b'ADULT' in data_upper or b'ADU' in data_upper:
+        patient_type = 'Adult'
+
+    # Strictly reject binary waveform/measurement packets from generating false patient records.
+    # Patient MRN/Name extraction requires an authentic HL7 message with PID or MSH.
+    if b'PID|' not in data and b'MSH|' not in data:
+        if patient_type:
+            return {"patient_type": patient_type}
+        return None
+
     clean = []
-    for m in re.finditer(rb'[a-zA-Z0-9_\-\.]{2,}', data):
+    # Match strings of printable alphanumeric and reasonable characters, allowing single spaces
+    for m in re.finditer(rb'[a-zA-Z0-9_\-\.]{2,}(?:\s+[a-zA-Z0-9_\-\.]{2,})*', data):
         s = m.group(0).decode('latin1', errors='ignore').strip()
         if not s or len(s) < 2:
             continue
         s_lower = s.lower()
-        if any(kw in s_lower for kw in TELEMETRY_WORDS):
+        if is_telemetry_word(s_lower):
             continue
         if len(set(s)) == 1:
             continue
         if set(s).issubset({'.', '-', '_', '/', '\\'}):
             continue
-        if len(s) > 8 and re.match(r'^[A-Za-z]+$', s):
+        if len(s) > 6 and re.match(r'^[A-Za-z0-9]+$', s):
             diffs = [abs(ord(s[i]) - ord(s[i-1])) for i in range(1, len(s))]
             if sum(1 for d in diffs if d <= 2) / len(diffs) > 0.6:
                 continue
@@ -84,7 +117,7 @@ def extract_demographics_from_packet(data: bytes, client_ip: str) -> dict:
             continue
         clean.append(s)
 
-    if not clean:
+    if not clean and not patient_type:
         return None
 
     name = None
@@ -95,9 +128,8 @@ def extract_demographics_from_packet(data: bytes, client_ip: str) -> dict:
     for s in clean:
         s_up = s.upper()
         s_low = s.lower()
-        if s_low in TELEMETRY_WORDS:
-            continue
 
+        # Check gender first
         if s_up in ('MALE', 'FEMALE') and not gender:
             gender = 'Male' if s_up == 'MALE' else 'Female'
             continue
@@ -105,52 +137,75 @@ def extract_demographics_from_packet(data: bytes, client_ip: str) -> dict:
             gender = 'Male' if s_up == 'M' else 'Female'
             continue
 
-        # Date of birth: 4-digit birth year between 1920 and 2024, or YYYY-MM-DD
-        if re.match(r'^(19\d\d|20[01]\d|202[0-4])$', s) and not dob:
+        if is_telemetry_word(s_low):
+            continue
+
+        # Date of birth: 4-digit birth year between 1920 and 2026, or YYYY-MM-DD
+        if re.match(r'^(19\d\d|20[01]\d|202[0-6])$', s) and not dob:
             dob = s
             continue
         elif re.match(r'^\d{4}[-/]\d{2}[-/]\d{2}$', s) and not dob:
             dob = s
             continue
 
-        # Name candidate: strictly at least 3 letters, has a vowel, not telemetry
-        if re.search(r'^[A-Za-z\s\.\-]{3,30}$', s) and re.search(r'[aeiouyAEIOUY]', s) and not name:
-            if s_low not in TELEMETRY_WORDS:
+        # Name candidate: contains letters and a vowel, length between 3 and 40
+        if re.search(r'^[A-Za-z\s\.\-]{3,40}$', s) and re.search(r'[aeiouyAEIOUY]', s) and not name:
+            if not is_telemetry_word(s_low):
                 name = s
                 continue
 
-        # MRN candidate: numeric or alphanumeric ID, at least 2 chars, not a year, not telemetry
-        if not mrn and re.match(r'^[A-Za-z0-9\-]{2,15}$', s) and s_low not in TELEMETRY_WORDS:
+        # MRN candidate: numeric or alphanumeric ID, 2..15 chars, not a birth year
+        if not mrn and re.match(r'^[A-Za-z0-9\-]{2,15}$', s) and not is_telemetry_word(s_low):
             if not (s.isdigit() and 1920 <= int(s) <= 2030):
+                if s.isdigit() and len(s) > 10:
+                    continue
                 mrn = s
                 continue
 
-    # Only accept when BOTH real name and real MRN/DOB are present together
-    if name and (mrn or dob):
+    # Accept if valid MRN or Name was detected
+    if mrn or name:
+        clean_mrn = mrn or name
+        clean_name = name or f"Patient {clean_mrn}"
         return {
-            "name": name,
-            "mrn": mrn or name,
-            "patient_id": mrn or name,
+            "name": clean_name,
+            "mrn": clean_mrn,
+            "patient_id": clean_mrn,
             "dob": dob,
             "gender": gender,
+            "patient_type": patient_type,
+        }
+    elif patient_type:
+        return {
+            "patient_type": patient_type,
         }
     return None
 
 
 async def apply_auto_demographics(client_ip: str, demo: dict):
     from config import settings
+    from api_client import sync_patient_assignment_to_cloud
     model = settings.device_models.get(client_ip, settings.monitor_model)
     device_id = f"{model}_{client_ip}"
     name = demo.get("name")
     mrn = demo.get("mrn")
     dob = demo.get("dob")
     gender = demo.get("gender")
+    patient_type = demo.get("patient_type")
 
     current = device_patient_map.get(device_id, {})
-    if current.get("name") == name and current.get("mrn") == mrn and current.get("dob") == dob and current.get("gender") == gender:
+    # If only patient_type updated
+    if not mrn and not name:
+        if patient_type and current.get("patient_type") != patient_type:
+            current["patient_type"] = patient_type
+            device_patient_map[device_id] = current
         return
 
-    logger.info(f"*** REAL PATIENT DEMOGRAPHICS DETECTED FROM MACHINE ({client_ip}): Name={name}, MRN={mrn}, DOB={dob}, Gender={gender} ***")
+    if (current.get("name") == name and current.get("mrn") == mrn and 
+        current.get("dob") == dob and current.get("gender") == gender and 
+        current.get("patient_type") == patient_type):
+        return
+
+    logger.info(f"*** REAL PATIENT DEMOGRAPHICS DETECTED FROM MACHINE ({client_ip}): Name={name}, MRN={mrn}, DOB={dob}, Gender={gender}, Type={patient_type} ***")
 
     bed_id = "1" if "192.168.100.106" in client_ip else "2"
     p_data = {
@@ -159,7 +214,8 @@ async def apply_auto_demographics(client_ip: str, demo: dict):
         "name": name,
         "gender": gender,
         "dob": dob,
-        "bed_id": bed_id
+        "bed_id": bed_id,
+        "patient_type": patient_type or current.get("patient_type"),
     }
     device_patient_map[device_id] = p_data
 
@@ -218,11 +274,15 @@ async def apply_auto_demographics(client_ip: str, demo: dict):
             "gender": gender,
             "patient_dob": dob,
             "dob": dob,
-            "bed_id": bed_id
+            "bed_id": bed_id,
+            "patient_type": p_data.get("patient_type"),
         })
     except Exception as e:
         logger.debug(f"Failed to broadcast auto patient: {e}")
 
+    # Forward to Render Cloud Server so remote is kept in sync
+    asyncio.create_task(sync_patient_assignment_to_cloud(p_data, device_id))
+
 
 async def handle_contec_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter, port: int):
     """
@@ -251,8 +311,13 @@ async def handle_contec_client(reader: asyncio.StreamReader, writer: asyncio.Str
                 logger.info(f"Contec client {client_ip}:{client_port} on port {port} sent EOF (0 bytes)")
                 break
 
-            if client_ip != "127.0.0.1":
-                logger.info(f"TCP READ from {client_ip}: {len(data)} bytes, hex: {data[:24].hex()}")
+            # Dynamically extract and apply patient demographics sent from the machine
+            try:
+                demo = extract_demographics_from_packet(data, client_ip)
+                if demo:
+                    await apply_auto_demographics(client_ip, demo)
+            except Exception as ex:
+                logger.debug(f"Demographics extraction error: {ex}")
 
             buffer += data
 
@@ -376,6 +441,7 @@ def get_assigned_patient(device_id: str):
                 "gender": patient.gender,
                 "dob": patient.dob,
                 "bed_id": patient.bed_id,
+                "patient_type": getattr(patient, "patient_type", None),
             }
             device_patient_map[device_id] = p_data
             return p_data
@@ -396,6 +462,7 @@ def set_assigned_patient(device_id: str, patient_data: dict):
         cached.patient_gender = patient_data.get("gender")
         cached.patient_dob = patient_data.get("dob")
         cached.bed_id = patient_data.get("bed_id")
+        cached.patient_type = patient_data.get("patient_type")
 
 
 async def process_vitals(vitals):
@@ -416,6 +483,7 @@ async def process_vitals(vitals):
         vitals.patient_gender = assigned.get("gender")
         vitals.patient_dob = assigned.get("dob")
         vitals.bed_id = assigned.get("bed_id")
+        vitals.patient_type = assigned.get("patient_type")
     elif vitals.patient_name and vitals.patient_name != "Unknown":
         # Monitor sent fresh demographics via HL7 PID segment!
         device_patient_map[device_id] = {
@@ -425,6 +493,7 @@ async def process_vitals(vitals):
             "gender": vitals.patient_gender,
             "dob": vitals.patient_dob,
             "bed_id": vitals.bed_id,
+            "patient_type": getattr(vitals, "patient_type", None),
         }
 
     # Check if incoming packet has fresh waveforms
@@ -453,21 +522,22 @@ async def process_vitals(vitals):
                 if value is not None:
                     active_fields.append(field)
                     
-        # Update cache & record timestamps
+        # Update cache & record timestamps for present values
         for field in active_fields:
             val = getattr(vitals, field, None)
-            setattr(cached, field, val)
             if val is not None:
+                setattr(cached, field, val)
                 device_field_timestamps[device_id][field] = now
             else:
+                setattr(cached, field, None)
                 device_field_timestamps[device_id].pop(field, None)
             
         # Clean up stale fields:
-        # Live vitals (HR, SpO2, Temp, RR) have a 60-second window because monitor cycles take ~24s
-        # NIBP (BP, MAP) has a 1-hour window because it is measured intermittently
+        # Live vitals (HR, SpO2, Temp, RR) have a 15-second window
+        # NIBP (BP, MAP) has a 15-minute window because it is measured intermittently
         for field in list(device_field_timestamps[device_id].keys()):
             last_updated = device_field_timestamps[device_id][field]
-            timeout = 3600.0 if field in ("systolic_bp", "diastolic_bp", "map_bp") else 60.0
+            timeout = 900.0 if field in ("systolic_bp", "diastolic_bp", "map_bp") else 15.0
             if (now - last_updated).total_seconds() > timeout:
                 setattr(cached, field, None)
                 device_field_timestamps[device_id].pop(field, None)
@@ -506,6 +576,7 @@ async def process_vitals(vitals):
         vitals_dict["gender"] = vitals.patient_gender
         vitals_dict["dob"] = vitals.patient_dob
         vitals_dict["bed_id"] = vitals.bed_id
+        vitals_dict["patient_type"] = getattr(vitals, "patient_type", None)
         await ws_manager.broadcast_vitals(vitals_dict)
     except Exception as e:
         logger.debug(f"WebSocket broadcast failed: {e}")
@@ -569,6 +640,7 @@ async def _persist_and_forward_bg(vitals, should_persist):
                         gender=vitals.patient_gender,
                         dob=vitals.patient_dob,
                         bed_id=vitals.bed_id,
+                        patient_type=getattr(vitals, "patient_type", None),
                         device_id=vitals.device_id
                     )
                     db.add(patient)
@@ -584,12 +656,27 @@ async def _persist_and_forward_bg(vitals, should_persist):
                     patient.dob = vitals.patient_dob
                 if vitals.bed_id:
                     patient.bed_id = vitals.bed_id
+                if getattr(vitals, "patient_type", None):
+                    patient.patient_type = vitals.patient_type
                 if vitals.device_id:
                     patient.device_id = vitals.device_id
+            if patient:
+                if not vitals.patient_id or vitals.patient_id == "UNKNOWN":
+                    vitals.patient_id = patient.mrn or patient.patient_id
+                if not vitals.patient_name or vitals.patient_name == "Unknown":
+                    vitals.patient_name = patient.name
+                if not vitals.patient_gender and patient.gender:
+                    vitals.patient_gender = patient.gender
+                if not vitals.patient_dob and patient.dob:
+                    vitals.patient_dob = patient.dob
+                if not vitals.bed_id and patient.bed_id:
+                    vitals.bed_id = patient.bed_id
+                if not getattr(vitals, "patient_type", None) and getattr(patient, "patient_type", None):
+                    vitals.patient_type = patient.patient_type
 
             reading = VitalReading(
                 device_id=vitals.device_id,
-                patient_id=vitals.patient_id,
+                patient_id=vitals.patient_id or (patient.mrn if patient else "UNKNOWN"),
                 timestamp=vitals.timestamp,
                 heart_rate=vitals.heart_rate,
                 spo2=vitals.spo2,
@@ -598,6 +685,8 @@ async def _persist_and_forward_bg(vitals, should_persist):
                 map_bp=vitals.map_bp,
                 respiratory_rate=vitals.respiratory_rate,
                 temperature=vitals.temperature,
+                temperature2=vitals.temperature2,
+                temperature_diff=vitals.temperature_diff,
                 transmitted=False
             )
             db.add(reading)

database.py

@@ -3,9 +3,11 @@ from sqlalchemy.pool import NullPool
 from sqlalchemy.orm import sessionmaker, declarative_base
 from config import settings
 
+connect_args = {"check_same_thread": False} if settings.database_url.startswith("sqlite") else {}
+
 engine = create_engine(
     settings.database_url,
-    connect_args={"check_same_thread": False},
+    connect_args=connect_args,
     poolclass=NullPool
 )
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

fiveparaminte-main/.dockerignore

@@ -1,17 +0,0 @@
-__pycache__/
-*.py[cod]
-*.db
-*.sqlite3
-*.log
-*.bin
-.env
-venv/
-.venv/
-build/
-dist/
-*.spec
-scratch/
-captures/
-.git/
-.idea/
-.vscode/

fiveparaminte-main/.gitignore

@@ -1,37 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# PyInstaller
-build/
-dist/
-*.spec
-
-# Databases
-*.db
-*.sqlite3
-
-# Logs
-*.log
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Scratch / debug
-scratch/
-captures/
-*.bin
-
-# IDE / OS
-.idea/
-.vscode/
-*.swp
-*.swo
-.DS_Store

fiveparaminte-main/Dockerfile

@@ -1,15 +0,0 @@
-FROM python:3.12-slim
-
-WORKDIR /app
-
-# Install dependencies
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application code
-COPY . .
-
-# Render sets PORT env var (default 10000)
-EXPOSE 10000
-
-CMD uvicorn main:app --host 0.0.0.0 --port ${PORT:-10000}

fiveparaminte-main/Procfile

@@ -1 +0,0 @@
-web: python3 -m uvicorn main:app --host 0.0.0.0 --port $PORT

fiveparaminte-main/api_client.py

@@ -1,63 +0,0 @@
-import httpx
-import logging
-from typing import Optional
-from schemas import NormalizedVitals
-from config import settings
-
-logger = logging.getLogger(__name__)
-
-async def forward_vitals_to_api(vitals: NormalizedVitals) -> bool:
-    """
-    Attempts to POST the normalized vitals to the configured target API
-    and to the Render cloud database.
-    Returns True if at least one forward succeeds.
-    """
-    import os
-    headers = {"Content-Type": "application/json"}
-    
-    # 1. Forward to primary target API (e.g. Injomo Dev Workflow)
-    primary_url = settings.target_api_url
-    primary_success = False
-    if primary_url:
-        try:
-            primary_headers = headers.copy()
-            if settings.api_token:
-                primary_headers["Authorization"] = f"Bearer {settings.api_token}"
-            async with httpx.AsyncClient(timeout=10.0) as client:
-                response = await client.post(
-                    primary_url,
-                    json=vitals.model_dump(mode="json"),
-                    headers=primary_headers
-                )
-                response.raise_for_status()
-                logger.info(f"Successfully forwarded vitals to primary API for device {vitals.device_id}")
-                primary_success = True
-        except Exception as e:
-            logger.error(f"Error forwarding to primary API: {e}")
-
-    # 2. Forward to Render Cloud Server
-    render_url = "https://contectfiveparamonitor.onrender.com/api/push-vitals"
-    render_success = False
-    
-    # Detect if we are already running on Render to prevent an infinite loop
-    is_on_render = os.getenv("RENDER") is not None or os.getenv("PORT") == "10000" or "render.local" in os.getenv("HOSTNAME", "")
-    
-    if not is_on_render:
-        try:
-            url_with_key = render_url
-            if settings.api_token:
-                url_with_key = f"{render_url}?api_key={settings.api_token}"
-                
-            async with httpx.AsyncClient(timeout=10.0) as client:
-                response = await client.post(
-                    url_with_key,
-                    json=vitals.model_dump(mode="json"),
-                    headers=headers
-                )
-                response.raise_for_status()
-                logger.info(f"Successfully forwarded vitals to Render Cloud for device {vitals.device_id}")
-                render_success = True
-        except Exception as e:
-            logger.error(f"Error forwarding to Render Cloud: {e}")
-            
-    return primary_success or render_success

fiveparaminte-main/background_tasks.py

@@ -1,67 +0,0 @@
-import asyncio
-import logging
-from database import SessionLocal
-from models import VitalReading, TransmissionLog
-from schemas import NormalizedVitals
-from api_client import forward_vitals_to_api
-from config import settings
-
-logger = logging.getLogger(__name__)
-
-async def retry_failed_transmissions():
-    """
-    Background task that periodically checks for untransmitted vital readings
-    and attempts to forward them to the API.
-    """
-    logger.info("Starting background task for retrying failed transmissions...")
-    
-    while True:
-        try:
-            db = SessionLocal()
-            try:
-                # Get readings that haven't been transmitted
-                failed_readings = db.query(VitalReading).filter(VitalReading.transmitted == False).limit(50).all()
-                
-                for reading in failed_readings:
-                    vitals = NormalizedVitals(
-                        device_id=reading.device_id,
-                        patient_id=reading.patient_id,
-                        timestamp=reading.timestamp,
-                        heart_rate=reading.heart_rate,
-                        spo2=reading.spo2,
-                        systolic_bp=reading.systolic_bp,
-                        diastolic_bp=reading.diastolic_bp,
-                        map_bp=reading.map_bp,
-                        respiratory_rate=reading.respiratory_rate,
-                        temperature=reading.temperature
-                    )
-                    
-                    success = await forward_vitals_to_api(vitals)
-                    
-                    if success:
-                        reading.transmitted = True
-                        log_entry = TransmissionLog(
-                            reading_id=reading.id,
-                            status="success",
-                            response_code=200
-                        )
-                        db.add(log_entry)
-                        logger.info(f"Successfully re-transmitted reading {reading.id}")
-                    else:
-                        # Log the failure but don't mark as transmitted
-                        log_entry = TransmissionLog(
-                            reading_id=reading.id,
-                            status="failed",
-                            error_message="Retry failed"
-                        )
-                        db.add(log_entry)
-                        
-                if failed_readings:
-                    db.commit()
-            finally:
-                db.close()
-                
-        except Exception as e:
-            logger.error(f"Error in retry background task: {e}")
-            
-        await asyncio.sleep(settings.retry_interval_seconds)

fiveparaminte-main/build.bat

@@ -1,29 +0,0 @@
-@echo off
-echo Building Mindray HL7 Forwarder Executable...
-
-REM Clean previous builds
-rmdir /s /q build
-rmdir /s /q dist
-
-REM Run PyInstaller with necessary hidden imports for FastAPI, Uvicorn, and SQLAlchemy
-pyinstaller -F --clean ^
- --name "MindrayHL7Forwarder" ^
- --hidden-import uvicorn.logging ^
- --hidden-import uvicorn.loops ^
- --hidden-import uvicorn.loops.auto ^
- --hidden-import uvicorn.protocols ^
- --hidden-import uvicorn.protocols.http ^
- --hidden-import uvicorn.protocols.http.auto ^
- --hidden-import uvicorn.protocols.websockets ^
- --hidden-import uvicorn.protocols.websockets.auto ^
- --hidden-import uvicorn.lifespan ^
- --hidden-import uvicorn.lifespan.on ^
- --hidden-import uvicorn.lifespan.off ^
- --hidden-import fastapi ^
- --hidden-import pydantic ^
- --hidden-import sqlalchemy ^
- --hidden-import hl7 ^
- main.py
-
-echo Build complete! Executable is located in the dist/ folder.
-pause

fiveparaminte-main/build.sh

@@ -1,28 +0,0 @@
-#!/bin/bash
-echo "Building Mindray HL7 Forwarder Executable for Linux..."
-
-# Clean previous builds
-rm -rf build
-rm -rf dist
-
-# Run PyInstaller with necessary hidden imports for FastAPI, Uvicorn, and SQLAlchemy
-pyinstaller -F --clean \
- --name "MindrayHL7Forwarder" \
- --hidden-import uvicorn.logging \
- --hidden-import uvicorn.loops \
- --hidden-import uvicorn.loops.auto \
- --hidden-import uvicorn.protocols \
- --hidden-import uvicorn.protocols.http \
- --hidden-import uvicorn.protocols.http.auto \
- --hidden-import uvicorn.protocols.websockets \
- --hidden-import uvicorn.protocols.websockets.auto \
- --hidden-import uvicorn.lifespan \
- --hidden-import uvicorn.lifespan.on \
- --hidden-import uvicorn.lifespan.off \
- --hidden-import fastapi \
- --hidden-import pydantic \
- --hidden-import sqlalchemy \
- --hidden-import hl7 \
- main.py
-
-echo "Build complete! Executable is located in the dist/ folder."

fiveparaminte-main/config.json

@@ -1,15 +0,0 @@
-{
-  "hl7_host": "0.0.0.0",
-  "hl7_port": 6060,
-  "contec_ports": [511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 8001, 8002, 8300, 9000, 9100, 9200, 10008, 12345],
-  "monitor_ip": "",
-  "monitor_model": "CMS8500",
-  "device_models": {
-    "192.168.100.120": "CMS7000PLUS"
-  },
-  "target_api_url": "https://innov-dev.beta.injomo.com/workflow.trigger/69b2712a7866bf86ca0060c3",
-  "api_token": "",
-  "retry_interval_seconds": 60,
-  "log_file": "hl7_forwarder.log",
-  "database_url": "sqlite:///./hl7_forwarder.db"
-}

fiveparaminte-main/config.py

@@ -1,45 +0,0 @@
-import json
-import os
-from pydantic_settings import BaseSettings
-
-class Settings(BaseSettings):
-    hl7_host: str = "0.0.0.0"
-    hl7_port: int = 6060
-    contec_ports: list = [511, 515, 516, 517, 518, 519, 520]
-    monitor_ip: str = ""
-    monitor_model: str = "CMS7000PLUS"
-    device_models: dict = {}
-    target_api_url: str = "https://api.example.com/vitals"
-    api_token: str = ""
-    retry_interval_seconds: int = 60
-    log_file: str = "hl7_forwarder.log"
-    database_url: str = "sqlite:///./hl7_forwarder.db"
-
-    class Config:
-        env_file = ".env"
-
-def get_settings() -> Settings:
-    base_dir = os.path.dirname(os.path.abspath(__file__))
-    config_file = os.path.join(base_dir, "config.json")
-    
-    settings_obj = Settings()
-    
-    if os.path.exists(config_file):
-        with open(config_file, "r") as f:
-            try:
-                data = json.load(f)
-                for k, v in data.items():
-                    setattr(settings_obj, k, v)
-            except json.JSONDecodeError:
-                pass
-
-    if settings_obj.database_url.startswith("sqlite:///./"):
-        db_name = settings_obj.database_url.split("sqlite:///./")[1]
-        settings_obj.database_url = f"sqlite:///{os.path.join(base_dir, db_name)}"
-        
-    if not os.path.isabs(settings_obj.log_file):
-        settings_obj.log_file = os.path.join(base_dir, settings_obj.log_file)
-        
-    return settings_obj
-
-settings = get_settings()

fiveparaminte-main/contec_discovery.py

@@ -1,246 +0,0 @@
-"""
-Contec CMS7000PLUS / CMS9200PLUS Discovery Tool
-==================================
-This script listens on multiple TCP ports simultaneously to discover
-what data the CMS7000PLUS / CMS9200PLUS patient monitor sends over the network.
-
-Usage:
-    python contec_discovery.py
-
-It will listen on ports: 511, 515, 516, 517, 518, 519, 520, 6060
-and display all received data in hex + ASCII format for protocol analysis.
-
-IMPORTANT: Run as Administrator (required for port 511 on Windows)
-"""
-
-import asyncio
-import logging
-import sys
-import os
-from datetime import datetime
-
-# --- Configuration ---
-LISTEN_HOST = "0.0.0.0"
-DISCOVERY_PORTS = [511, 515, 516, 517, 518, 519, 520, 6060]
-LOG_DIR = "captures"
-
-# --- Setup Logging ---
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s [%(levelname)s] %(message)s',
-    handlers=[logging.StreamHandler(sys.stdout)]
-)
-logger = logging.getLogger("contec_discovery")
-
-
-def hex_dump(data: bytes, width: int = 16) -> str:
-    """Format bytes as a hex dump with ASCII representation."""
-    lines = []
-    for i in range(0, len(data), width):
-        chunk = data[i:i + width]
-        hex_part = ' '.join(f'{b:02x}' for b in chunk)
-        ascii_part = ''.join(chr(b) if 32 <= b < 127 else '.' for b in chunk)
-        lines.append(f"  {i:04x}  {hex_part:<{width * 3}}  |{ascii_part}|")
-    return '\n'.join(lines)
-
-
-def try_decode_hl7(data: bytes) -> str | None:
-    """Attempt to decode the data as an HL7 message."""
-    try:
-        # Strip MLLP framing if present
-        cleaned = data
-        if cleaned.startswith(b'\x0b'):
-            cleaned = cleaned[1:]
-        if b'\x1c\x0d' in cleaned:
-            cleaned = cleaned[:cleaned.find(b'\x1c\x0d')]
-
-        text = cleaned.decode('utf-8', errors='ignore').strip()
-        if 'MSH|' in text or 'MSH' in text[:20]:
-            return text
-    except Exception:
-        pass
-    return None
-
-
-async def handle_discovery_client(
-    reader: asyncio.StreamReader,
-    writer: asyncio.StreamWriter,
-    port: int,
-    capture_file
-):
-    """Handle a single incoming connection and dump all data."""
-    client_ip, client_port = writer.get_extra_info('peername')
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
-
-    print("\n" + "=" * 80)
-    print(f"  NEW CONNECTION on port {port}")
-    print(f"  From: {client_ip}:{client_port}")
-    print(f"  Time: {timestamp}")
-    print("=" * 80)
-
-    capture_file.write(f"\n{'='*80}\n")
-    capture_file.write(f"Connection on port {port} from {client_ip}:{client_port} at {timestamp}\n")
-    capture_file.write(f"{'='*80}\n")
-    capture_file.flush()
-
-    packet_count = 0
-
-    try:
-        while True:
-            data = await asyncio.wait_for(reader.read(8192), timeout=30.0)
-            if not data:
-                break
-
-            packet_count += 1
-            recv_time = datetime.now().strftime("%H:%M:%S.%f")
-
-            print(f"\n--- Packet #{packet_count} on port {port} [{recv_time}] ({len(data)} bytes) ---")
-            print(hex_dump(data))
-
-            # Try to decode as HL7
-            hl7_text = try_decode_hl7(data)
-            if hl7_text:
-                print(f"\n  >>> HL7 MESSAGE DETECTED <<<")
-                segments = hl7_text.replace('\n', '\r').split('\r')
-                for seg in segments:
-                    seg = seg.strip()
-                    if seg:
-                        print(f"    {seg}")
-
-                        # Extract vital signs from OBX segments
-                        if seg.startswith("OBX|"):
-                            fields = seg.split('|')
-                            if len(fields) > 5:
-                                obs_id = fields[3] if len(fields) > 3 else "?"
-                                obs_value = fields[5] if len(fields) > 5 else "?"
-                                obs_unit = fields[6] if len(fields) > 6 else ""
-                                print(f"         -> Vital: {obs_id} = {obs_value} {obs_unit}")
-
-            # Also try plain text decode
-            try:
-                text = data.decode('utf-8', errors='ignore')
-                printable_ratio = sum(1 for c in text if c.isprintable() or c in '\r\n\t') / max(len(text), 1)
-                if printable_ratio > 0.7 and not hl7_text:
-                    print(f"\n  [Text representation]:")
-                    for line in text.split('\r'):
-                        line = line.strip()
-                        if line:
-                            print(f"    {line}")
-            except Exception:
-                pass
-
-            # Write to capture file
-            capture_file.write(f"\nPacket #{packet_count} [{recv_time}] ({len(data)} bytes)\n")
-            capture_file.write(hex_dump(data) + "\n")
-            if hl7_text:
-                capture_file.write(f"HL7: {hl7_text}\n")
-            capture_file.write(f"Raw bytes: {data.hex()}\n")
-            capture_file.flush()
-
-    except asyncio.TimeoutError:
-        print(f"  [Timeout - no data for 30s on port {port}]")
-    except asyncio.CancelledError:
-        pass
-    except ConnectionResetError:
-        print(f"  [Connection reset by {client_ip} on port {port}]")
-    except Exception as e:
-        print(f"  [Error on port {port}: {e}]")
-    finally:
-        print(f"\n  Connection closed on port {port} from {client_ip} ({packet_count} packets received)")
-        writer.close()
-        try:
-            await writer.wait_closed()
-        except Exception:
-            pass
-
-
-async def start_port_listener(port: int, capture_file):
-    """Start a TCP server on a specific port."""
-    async def client_handler(reader, writer):
-        await handle_discovery_client(reader, writer, port, capture_file)
-
-    try:
-        server = await asyncio.start_server(client_handler, LISTEN_HOST, port)
-        logger.info(f"  ✓ Listening on port {port}")
-        return server
-    except PermissionError:
-        logger.error(f"  ✗ Port {port} - Permission denied (try running as Administrator)")
-        return None
-    except OSError as e:
-        if "already in use" in str(e).lower() or e.errno == 10048:
-            logger.error(f"  ✗ Port {port} - Already in use by another application")
-        else:
-            logger.error(f"  ✗ Port {port} - {e}")
-        return None
-
-
-async def main():
-    print(r"""
-    ╔══════════════════════════════════════════════════════════════╗
-    ║     Contec CMS7000PLUS / CMS9200PLUS Discovery Tool        ║
-    ║                                                            ║
-    ║  This tool listens for incoming data from your patient     ║
-    ║  monitor to discover its communication protocol.           ║
-    ║                                                            ║
-    ║  SETUP REQUIRED:                                           ║
-    ║  1. Connect monitor to your PC via Ethernet                ║
-    ║  2. Set your PC's Ethernet IP to: 192.168.1.50             ║
-    ║     (or whatever subnet your monitor uses)                 ║
-    ║  3. On the monitor, set CMS/Server IP to YOUR PC's IP      ║
-    ║  4. Run this script as Administrator                       ║
-    ║                                                            ║
-    ║  Press Ctrl+C to stop                                      ║
-    ╚══════════════════════════════════════════════════════════════╝
-    """)
-
-    # Create captures directory
-    os.makedirs(LOG_DIR, exist_ok=True)
-    capture_filename = os.path.join(
-        LOG_DIR,
-        f"capture_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
-    )
-    capture_file = open(capture_filename, 'w', encoding='utf-8')
-    logger.info(f"Capture log: {capture_filename}")
-
-    # Show current network config hint
-    print("\nStarting listeners on all discovery ports...")
-    print("(If port 511 fails, run PowerShell as Administrator)\n")
-
-    servers = []
-    for port in DISCOVERY_PORTS:
-        server = await start_port_listener(port, capture_file)
-        if server:
-            servers.append(server)
-
-    if not servers:
-        logger.error("No ports could be opened! Check permissions and existing services.")
-        capture_file.close()
-        return
-
-    active_ports = [s.sockets[0].getsockname()[1] for s in servers if s.sockets]
-    print(f"\n{'─' * 60}")
-    print(f"  Active on ports: {active_ports}")
-    print(f"  Waiting for data from CMS7000PLUS / CMS9200PLUS...")
-    print(f"  Make sure the monitor's CMS/Server IP points to this PC")
-    print(f"{'─' * 60}\n")
-
-    try:
-        # Keep running until Ctrl+C
-        await asyncio.Event().wait()
-    except asyncio.CancelledError:
-        pass
-    finally:
-        print("\nShutting down...")
-        for server in servers:
-            server.close()
-        for server in servers:
-            await server.wait_closed()
-        capture_file.close()
-        print(f"Capture saved to: {capture_filename}")
-
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        print("\n\nDiscovery stopped by user.")

fiveparaminte-main/contec_parser.py

@@ -1,605 +0,0 @@
-import logging
-from datetime import datetime, timezone
-from typing import Optional, List
-import struct
-
-from schemas import NormalizedVitals
-from config import settings
-
-logger = logging.getLogger(__name__)
-
-# Contec CMS7000PLUS / CMS8000 / CMS9200PLUS OBX identifiers mapping to schema fields
-CONTEC_PARAM_MAP = {
-    # Heart Rate / Pulse Rate
-    "HR": "heart_rate",
-    "HEART_RATE": "heart_rate",
-    "ECG_HR": "heart_rate",
-    "PR": "heart_rate",
-    "PULSE_RATE": "heart_rate",
-    "SPO2_PR": "heart_rate",
-    "ECGHR": "heart_rate",
-    "ECG-HR": "heart_rate",
-    "PULSERATE": "heart_rate",
-    
-    # SpO2
-    "SPO2": "spo2",
-    "SAO2": "spo2",
-    "SPO2_PCT": "spo2",
-    "OXYGEN_SAT": "spo2",
-    "SPO2_VAL": "spo2",
-    "O2SAT": "spo2",
-    
-    # Blood Pressure (NIBP)
-    "NIBP_SYS": "systolic_bp",
-    "NIBP_DIA": "diastolic_bp",
-    "NIBP_MEAN": "map_bp",
-    "NIBP_MAP": "map_bp",
-    "SYS": "systolic_bp",
-    "DIA": "diastolic_bp",
-    "MAP": "map_bp",
-    "NBP_S": "systolic_bp",
-    "NBP_D": "diastolic_bp",
-    "NBP_M": "map_bp",
-    "NIBP-S": "systolic_bp",
-    "NIBP-D": "diastolic_bp",
-    "NIBP-M": "map_bp",
-    "BP_SYS": "systolic_bp",
-    "BP_DIA": "diastolic_bp",
-    "BP_MEAN": "map_bp",
-    
-    # Respiratory Rate
-    "RESP": "respiratory_rate",
-    "RESP_RATE": "respiratory_rate",
-    "RR": "respiratory_rate",
-    "BR": "respiratory_rate",
-    "RESPRATE": "respiratory_rate",
-    "RESP-RATE": "respiratory_rate",
-    
-    # Temperature
-    "TEMP": "temperature",
-    "TEMP1": "temperature",
-    "TEMP2": "temperature",
-    "T1": "temperature",
-    "T2": "temperature",
-    "BODY_TEMP": "temperature",
-    "TEMP-1": "temperature",
-    "TEMP-2": "temperature",
-    "BODYTEMP": "temperature",
-}
-
-# Sentinel value used by Contec to mark an invalid/disconnected parameter
-INVALID_SENTINEL_U16 = 9999  # 0x270F
-INVALID_SENTINEL_F32 = 9999.0
-
-
-def safe_float(value: str) -> Optional[float]:
-    try:
-        return float(value)
-    except (ValueError, TypeError):
-        return None
-
-
-def is_valid_u16(val: Optional[int]) -> bool:
-    return val is not None and val != INVALID_SENTINEL_U16 and val != 255 and val != 65535
-
-
-def is_valid_f32(val: Optional[float]) -> bool:
-    return val is not None and abs(val - INVALID_SENTINEL_F32) > 1.0
-
-
-def read_u16_le(buf: bytes, offset: int) -> Optional[int]:
-    if offset + 2 <= len(buf):
-        return struct.unpack_from('<H', buf, offset)[0]
-    return None
-
-
-def read_f32_le(buf: bytes, offset: int) -> Optional[float]:
-    if offset + 4 <= len(buf):
-        return struct.unpack_from('<f', buf, offset)[0]
-    return None
-
-
-def parse_contec_hl7_text(raw_text: str, client_ip: str) -> Optional[NormalizedVitals]:
-    """
-    Lightweight, native parser for Contec HL7 messages.
-    Splits segments and fields manually, avoiding third-party library dependencies.
-    """
-    try:
-        # Strip MLLP framing if present (VT=0x0b, FS=0x1c, CR=0x0d)
-        clean_text = raw_text.strip()
-        if clean_text.startswith("\x0b"):
-            clean_text = clean_text[1:]
-        if "\x1c\x0d" in clean_text:
-            clean_text = clean_text.split("\x1c\x0d")[0]
-        
-        # Split into segments by CR or LF
-        segments = [seg.strip() for seg in clean_text.replace("\n", "\r").split("\r") if seg.strip()]
-        
-        if not segments or not segments[0].startswith("MSH"):
-            return None
-
-        # Parse MSH segment
-        model = settings.device_models.get(client_ip, settings.monitor_model)
-        msh_fields = segments[0].split("|")
-        device_id = msh_fields[2] if len(msh_fields) > 2 and msh_fields[2] else f"{model}_{client_ip}"
-        
-        patient_id = "UNKNOWN"
-        vitals_dict = {
-            "device_id": device_id,
-            "patient_id": patient_id,
-            "timestamp": datetime.now(timezone.utc),
-            "ip_address": client_ip,
-        }
-        
-        found_any = False
-
-        # Parse PID, PV1 and OBX segments
-        for seg in segments[1:]:
-            fields = seg.split("|")
-            if not fields:
-                continue
-                
-            seg_name = fields[0]
-            
-            if seg_name == "PID":
-                # PID-3: MRN / Patient ID
-                if len(fields) > 3 and fields[3]:
-                    patient_id = fields[3].split("^")[0].strip()
-                    vitals_dict["patient_id"] = patient_id
-
-                # PID-5: Patient Name  (format: FamilyName^GivenName^...)
-                if len(fields) > 5 and fields[5]:
-                    name_parts = fields[5].split("^")
-                    family = name_parts[0].strip() if len(name_parts) > 0 else ""
-                    given  = name_parts[1].strip() if len(name_parts) > 1 else ""
-                    full_name = f"{given} {family}".strip() or family or given
-                    if full_name:
-                        vitals_dict["patient_name"] = full_name
-
-                # PID-7: Date of Birth  (YYYYMMDD or YYYY-MM-DD)
-                if len(fields) > 7 and fields[7]:
-                    vitals_dict["patient_dob"] = fields[7].strip()
-
-                # PID-8: Administrative Sex  (M / F / U / O)
-                if len(fields) > 8 and fields[8]:
-                    vitals_dict["patient_gender"] = fields[8].strip().upper()
-
-            elif seg_name == "PV1":
-                # PV1-3: Assigned Patient Location  (Room^Bed^...)
-                if len(fields) > 3 and fields[3]:
-                    location_parts = fields[3].split("^")
-                    # Use second component (Bed) if present, else first (Room)
-                    bed = location_parts[1].strip() if len(location_parts) > 1 else location_parts[0].strip()
-                    if bed:
-                        vitals_dict["bed_id"] = bed
-
-            elif seg_name == "OBX":
-                if len(fields) > 5:
-                    obs_val = fields[5].strip()
-                    
-                    if not obs_val or obs_val == "---":
-                        continue
-                        
-                    val_float = safe_float(obs_val)
-                    if val_float is None:
-                        continue
-                    
-                    # Split OBX-3 (Observation Identifier) by '^' and check all parts for parameter matches
-                    obs_parts = [p.strip().upper() for p in fields[3].split("^") if p.strip()]
-                    
-                    matched = False
-                    for param_key, mapped_field in CONTEC_PARAM_MAP.items():
-                        for part in obs_parts:
-                            if param_key == part or param_key in part:
-                                vitals_dict[mapped_field] = val_float
-                                found_any = True
-                                logger.info(f"Parsed Contec HL7 Vital: {mapped_field} = {val_float} (from OBX-3: {fields[3]})")
-                                matched = True
-                                break
-                        if matched:
-                            break
-                            
-        return NormalizedVitals(**vitals_dict) if found_any else None
-
-    except Exception as e:
-        logger.error(f"Error parsing Contec HL7 text: {e}")
-        return None
-
-
-def _extract_vitals_block(data: bytes, offset: int, client_ip: str) -> Optional[NormalizedVitals]:
-    """
-    Extract vitals from a Contec vitals block starting at the given offset.
-    
-    Known Contec CMS7000PLUS binary vitals block layout (confirmed from packet captures):
-    
-    PACKET TYPE B (header bytes [xx][00][04][46] or [xx][yy][04][46]):
-    -----------------------------------------------------------------------
-    Bytes 8-11   : float32 LE  → NIBP Systolic  (9999.0 = invalid)
-    Bytes 12-15  : float32 LE  → NIBP Diastolic (9999.0 = invalid)
-    Bytes 16-19  : float32 LE  → NIBP MAP       (9999.0 = invalid)
-    Bytes 20-23  : float32 LE  → Temperature 1  (°C, 9999.0 = invalid)
-    Bytes 24-27  : float32 LE  → Temperature 2  (°C, 9999.0 = invalid)
-    
-    Vitals summary block (at data[offset] position, found by scanning for SpO2+HR pattern):
-    Offset +0    : uint16 LE   → SpO2 (%)       (9999 = invalid)
-    Offset +2    : uint16 LE   → Heart Rate (bpm)(9999 = invalid, ECG not connected)
-    Offset +4    : uint16 LE   → Pulse Rate (bpm)(from SpO2 probe, also 9999 if invalid)
-    Offset +6    : uint16 LE   → (SpO2 alarm/threshold)
-    Offset +8    : uint16 LE   → (mode flags)
-    Offset +10   : uint16 LE   → NIBP Systolic  (9999 = invalid)
-    Offset +12   : uint16 LE   → NIBP Diastolic (9999 = invalid)
-    """
-    model = settings.device_models.get(client_ip, settings.monitor_model)
-    vitals_dict = {
-        "device_id": f"{model}_{client_ip}",
-        "patient_id": "UNKNOWN",
-        "timestamp": datetime.now(timezone.utc),
-        "ip_address": client_ip,
-    }
-    found = False
-
-    spo2 = read_u16_le(data, offset)
-    hr_ecg = read_u16_le(data, offset + 2)
-    hr_spo2 = read_u16_le(data, offset + 4)
-
-    # SpO2 value: valid range 50–100
-    if spo2 is not None and 50 <= spo2 <= 100:
-        vitals_dict["spo2"] = float(spo2)
-        found = True
-
-    # Heart rate: prefer ECG HR; fall back to SpO2-derived PR if ECG invalid
-    if is_valid_u16(hr_ecg) and 20 <= hr_ecg <= 300:
-        vitals_dict["heart_rate"] = float(hr_ecg)
-        found = True
-    elif is_valid_u16(hr_spo2) and 20 <= hr_spo2 <= 300:
-        vitals_dict["heart_rate"] = float(hr_spo2)
-        found = True
-
-    return NormalizedVitals(**vitals_dict) if found else None
-
-
-def _parse_45_byte_packet(data: bytes, vitals_dict: dict) -> bool:
-    """
-    Parse 45-byte packet (Subtype 22) — contains NIBP values and alarm limits.
-    
-    Verified layout:
-      [0-1]   Packet length LE u16 = 45
-      [2-3]   Marker: 01 46
-      [4-7]   Sub-header (00 00 16 00)
-      [8-9]   Year LE u16
-      [10]    Month, [11] Day, [12] Hour, [13] Minute, [14] Seconds
-      [15-16] NIBP Systolic (LE u16, 9999 = no measurement)
-      [17-18] NIBP Diastolic (LE u16, 9999 = no measurement)
-      [19-20] NIBP MAP (LE u16, 9999 = no measurement)
-    """
-    if len(data) < 22:
-        return False
-
-    if "present_fields" not in vitals_dict:
-        vitals_dict["present_fields"] = []
-
-    nibp_sys = read_u16_le(data, 15)
-    nibp_dia = read_u16_le(data, 17)
-    nibp_map = read_u16_le(data, 19)
-
-    found = False
-
-    # Mark NIBP fields as present so cache can clear them if 9999
-    for f in ["systolic_bp", "diastolic_bp", "map_bp"]:
-        if f not in vitals_dict["present_fields"]:
-            vitals_dict["present_fields"].append(f)
-
-    if nibp_sys is not None and nibp_sys != 9999 and 40 < nibp_sys < 250:
-        vitals_dict["systolic_bp"] = float(nibp_sys)
-        found = True
-    else:
-        vitals_dict["systolic_bp"] = None
-
-    if nibp_dia is not None and nibp_dia != 9999 and 20 < nibp_dia < 200:
-        vitals_dict["diastolic_bp"] = float(nibp_dia)
-        found = True
-    else:
-        vitals_dict["diastolic_bp"] = None
-
-    if nibp_map is not None and nibp_map != 9999 and 20 < nibp_map < 250:
-        vitals_dict["map_bp"] = float(nibp_map)
-        found = True
-    else:
-        vitals_dict["map_bp"] = None
-
-    return found
-
-
-def _parse_56_byte_packet(data: bytes, vitals_dict: dict) -> bool:
-    """
-    Parse 56-byte packet (Subtype 23) — contains float32 Temperature values.
-    
-    Verified layout:
-      [8-11]   Temperature 1 (float32)
-      [12-15]  Temperature 2 (float32)
-      [20-23]  Temp 1 Alarm High Limit (float32)
-      [24-27]  Temp 1 Alarm Low Limit (float32)
-    """
-    if len(data) < 16:
-        return False
-
-    if "present_fields" not in vitals_dict:
-        vitals_dict["present_fields"] = []
-    if "temperature" not in vitals_dict["present_fields"]:
-        vitals_dict["present_fields"].append("temperature")
-    vitals_dict.setdefault("temperature", None)
-
-    found = False
-
-    temp1 = read_f32_le(data, 8)
-    temp2 = read_f32_le(data, 12)
-
-    # 9999.0 is sentinel
-    if temp1 is not None and is_valid_f32(temp1) and 10.0 < temp1 < 50.0:
-        vitals_dict["temperature"] = round(temp1, 1)
-        found = True
-    elif temp2 is not None and is_valid_f32(temp2) and 10.0 < temp2 < 50.0:
-        vitals_dict["temperature"] = round(temp2, 1)
-        found = True
-
-    return found
-
-
-def _parse_286_byte_packet(data: bytes, vitals_dict: dict) -> bool:
-    """
-    Parse 286-byte waveform packet (Subtype 21).
-    
-    Verified layout:
-      [8..263]  Pleth waveform samples (8-bit unsigned, 256 samples)
-      [264-265] SpO2% (LE u16) — live oxygen saturation percentage
-                255 / 65535 = sensor disconnected
-      [266-267] ECG HR via SpO2 PR (LE u16) — 9999 / 65535 = not available
-    """
-    if len(data) < 270:
-        return False
-
-    if "present_fields" not in vitals_dict:
-        vitals_dict["present_fields"] = []
-    if "spo2" not in vitals_dict["present_fields"]:
-        vitals_dict["present_fields"].append("spo2")
-    if "pleth_wave" not in vitals_dict["present_fields"]:
-        vitals_dict["present_fields"].append("pleth_wave")
-    vitals_dict.setdefault("spo2", None)
-
-    found = False
-
-    # Extract Pleth waveform samples (bytes 8..263)
-    raw_pleth = list(data[8:264])
-    # Only store if not all-zeroes or all-sentinel (flatline = disconnected)
-    if any(v not in (0x00, 0x7F, 0x3A, 0x92, 0xFF) for v in raw_pleth[:10]):
-        vitals_dict["pleth_wave"] = raw_pleth
-    else:
-        vitals_dict["pleth_wave"] = raw_pleth  # Always send so frontend can show flatline too
-
-    # Offset 264: SpO2 percentage
-    spo2_val = read_u16_le(data, 264)
-    if spo2_val is not None and spo2_val != 65535 and spo2_val != 255 and 50 <= spo2_val <= 100:
-        vitals_dict["spo2"] = float(spo2_val)
-        found = True
-
-    # Offset 266: HR from SpO2 PR (only add to present fields if valid to prevent overriding ECG HR)
-    hr_val = read_u16_le(data, 266)
-    if hr_val is not None and hr_val != 65535 and hr_val != 9999 and 20 <= hr_val <= 300:
-        vitals_dict["heart_rate"] = float(hr_val)
-        if "heart_rate" not in vitals_dict["present_fields"]:
-            vitals_dict["present_fields"].append("heart_rate")
-        found = True
-
-    return found
-
-
-def _parse_288_byte_packet(data: bytes, vitals_dict: dict) -> bool:
-    """
-    Parse 288-byte waveform packet (Subtype 21 for CMS8500).
-    
-    Layout:
-      [8..263]  Pleth waveform samples (8-bit unsigned, 256 samples)
-      [264-265] SpO2% (LE u16) — live oxygen saturation percentage
-      [266-267] PR (LE u16) — pulse rate
-    """
-    if len(data) < 270:
-        return False
-
-    if "present_fields" not in vitals_dict:
-        vitals_dict["present_fields"] = []
-    if "spo2" not in vitals_dict["present_fields"]:
-        vitals_dict["present_fields"].append("spo2")
-    if "pleth_wave" not in vitals_dict["present_fields"]:
-        vitals_dict["present_fields"].append("pleth_wave")
-    vitals_dict.setdefault("spo2", None)
-
-    found = False
-
-    # Extract Pleth waveform samples (bytes 8..263)
-    vitals_dict["pleth_wave"] = list(data[8:264])
-
-    # Offset 264: SpO2 percentage
-    spo2_val = read_u16_le(data, 264)
-    if spo2_val is not None and spo2_val != 65535 and spo2_val != 255 and 50 <= spo2_val <= 100:
-        vitals_dict["spo2"] = float(spo2_val)
-        found = True
-
-    # Offset 266: PR from SpO2 PR
-    hr_val = read_u16_le(data, 266)
-    if hr_val is not None and hr_val != 65535 and hr_val != 9999 and 20 <= hr_val <= 300:
-        vitals_dict["heart_rate"] = float(hr_val)
-        if "heart_rate" not in vitals_dict["present_fields"]:
-            vitals_dict["present_fields"].append("heart_rate")
-        found = True
-
-    return found
-
-
-def _parse_341_byte_packet(data: bytes, vitals_dict: dict) -> bool:
-    """
-    Parse 341-byte waveform packet. Same tail layout as 286-byte.
-    """
-    if len(data) < 270:
-        return False
-
-    if "present_fields" not in vitals_dict:
-        vitals_dict["present_fields"] = []
-    if "spo2" not in vitals_dict["present_fields"]:
-        vitals_dict["present_fields"].append("spo2")
-    vitals_dict.setdefault("spo2", None)
-
-    found = False
-
-    spo2_val = read_u16_le(data, 264)
-    if spo2_val is not None and spo2_val != 65535 and spo2_val != 255 and 50 <= spo2_val <= 100:
-        vitals_dict["spo2"] = float(spo2_val)
-        found = True
-
-    hr_val = read_u16_le(data, 266)
-    if hr_val is not None and hr_val != 65535 and hr_val != 9999 and 20 <= hr_val <= 300:
-        vitals_dict["heart_rate"] = float(hr_val)
-        if "heart_rate" not in vitals_dict["present_fields"]:
-            vitals_dict["present_fields"].append("heart_rate")
-        found = True
-
-    return found
-
-
-def _parse_989_byte_packet(data: bytes, vitals_dict: dict) -> bool:
-    """
-    Parse 989-byte waveform packet (Subtype 20 / 14h).
-    
-    Verified layout:
-      [8..903]  ECG waveform samples (8-bit unsigned, 896 samples @ ~250Hz)
-      [904-905] ECG Heart Rate (LE u16)
-                65535 or 9999 = invalid/disconnected
-    """
-    if len(data) < 906:
-        return False
-
-    if "present_fields" not in vitals_dict:
-        vitals_dict["present_fields"] = []
-    if "heart_rate" not in vitals_dict["present_fields"]:
-        vitals_dict["present_fields"].append("heart_rate")
-    if "ecg_wave" not in vitals_dict["present_fields"]:
-        vitals_dict["present_fields"].append("ecg_wave")
-    vitals_dict.setdefault("heart_rate", None)
-
-    found = False
-
-    # Extract ECG waveform samples (bytes 8..903), downsample to 200 points for efficiency
-    raw_ecg = list(data[8:904])
-    # Downsample by factor of 4 -> ~224 points (still high-resolution enough)
-    vitals_dict["ecg_wave"] = raw_ecg[::4]
-
-    hr_val = read_u16_le(data, 904)
-    if hr_val is not None and hr_val != 65535 and hr_val != 9999 and 20 <= hr_val <= 300:
-        vitals_dict["heart_rate"] = float(hr_val)
-        found = True
-
-    return found
-
-
-def _find_vitals_block_in_stream(data: bytes, client_ip: str) -> Optional[NormalizedVitals]:
-    """
-    Scan the data stream for Contec CMS7000PLUS sub-packets and parse them
-    deterministically based on packet length.
-    
-    Packet types (verified by raw hex analysis):
-      45 bytes  (Subtype 22): NIBP Sys/Dia/MAP (u16 LE starting at offset 15)
-      56 bytes  (Subtype 23): Float32 Temperature (offset 8/12)
-      286 bytes (Subtype 21): SpO2% at offset 264
-      341 bytes (Subtype 21): SpO2% at offset 264
-      989 bytes (Subtype 20): ECG Heart Rate at offset 904
-    """
-    model = settings.device_models.get(client_ip, settings.monitor_model)
-    vitals_dict = {
-        "device_id": f"{model}_{client_ip}",
-        "patient_id": "UNKNOWN",
-        "timestamp": datetime.now(timezone.utc),
-        "ip_address": client_ip,
-    }
-    found_any = False
-
-    i = 0
-    while i < len(data) - 8:
-        if (data[i + 2] == 0x04 or data[i + 2] == 0x01 or data[i + 2] == 0x00) and data[i + 3] == 0x46:
-            pkt_len = struct.unpack_from('<H', data, i)[0]
-
-            if 30 < pkt_len < 1050 and i + pkt_len <= len(data):
-                pkt_data = data[i:i + pkt_len]
-                
-                if pkt_len in (45, 47):
-                    _parse_45_byte_packet(pkt_data, vitals_dict)
-                    found_any = True
-                elif pkt_len == 56:
-                    _parse_56_byte_packet(pkt_data, vitals_dict)
-                    found_any = True
-                elif pkt_len == 286:
-                    _parse_286_byte_packet(pkt_data, vitals_dict)
-                    found_any = True
-                elif pkt_len == 288:
-                    _parse_288_byte_packet(pkt_data, vitals_dict)
-                    found_any = True
-                elif pkt_len == 341:
-                    _parse_341_byte_packet(pkt_data, vitals_dict)
-                    found_any = True
-                elif pkt_len == 989:
-                    _parse_989_byte_packet(pkt_data, vitals_dict)
-                    found_any = True
-
-            i += max(pkt_len, 4)
-        else:
-            i += 1
-
-    return NormalizedVitals(**vitals_dict) if found_any else None
-
-
-def parse_contec_binary_packet(data: bytes, client_ip: str) -> Optional[NormalizedVitals]:
-    """
-    Decodes the Contec CMS7000PLUS proprietary binary protocol.
-    
-    The monitor sends two alternating TCP packets:
-    - Packet A (991 bytes): ECG waveform + SpO2 waveform + vitals footer  
-    - Packet B (397 bytes): Resp waveform + vitals summary + param block
-    
-    Both have the structure: [len_lo][len_hi][04][46][subtype][00][sublen][00]...[payload]...
-    """
-    try:
-        return _find_vitals_block_in_stream(data, client_ip)
-    except Exception as e:
-        logger.error(f"Error parsing Contec binary packet: {e}")
-        return None
-
-
-def parse_contec_data(raw_data: bytes, client_ip: str) -> Optional[NormalizedVitals]:
-    """
-    Unified entry point for parsing data from a Contec CMS7000PLUS monitor.
-    Attempts HL7 text parsing first, falling back to proprietary binary parsing.
-    """
-    if not raw_data:
-        return None
-        
-    # Attempt 1: HL7 Text Decoding
-    try:
-        text = raw_data.decode("utf-8", errors="ignore").strip()
-        if "MSH" in text or "\x0bMSH" in text:
-            vitals = parse_contec_hl7_text(text, client_ip)
-            if vitals:
-                return vitals
-            else:
-                logger.warning(f"HL7 message detected but failed to parse. Content: {repr(text)}")
-    except Exception as e:
-        logger.warning(f"Failed decoding/parsing HL7: {e}")
-
-    # Attempt 2: Binary Parsing (Contec proprietary protocol)
-    vitals = parse_contec_binary_packet(raw_data, client_ip)
-    if vitals:
-        return vitals
-
-    # Logging fallback
-    logger.warning(
-        f"Data packet from {client_ip} unrecognized. "
-        f"Len: {len(raw_data)}, Hex head: {raw_data[:32].hex()}"
-    )
-    return None

fiveparaminte-main/contec_server.py

@@ -1,356 +0,0 @@
-import asyncio
-import logging
-from datetime import datetime, timezone
-
-from contec_parser import parse_contec_data
-from database import SessionLocal
-from models import Device, Patient, VitalReading, TransmissionLog
-from api_client import forward_vitals_to_api
-from terminal_display import get_terminal_display
-
-logger = logging.getLogger(__name__)
-
-# Constants for MLLP framing (used on port 511 for Contec HL7 text)
-VT = b'\x0b'
-FS_CR = b'\x1c\x0d'
-
-
-def generate_ack(received_msg: str) -> str:
-    """Generates a simple HL7 ACK message to satisfy the monitor's TCP client."""
-    try:
-        segments = received_msg.split('\r')
-        msh = segments[0] if segments else ""
-        if not msh.startswith("MSH|"):
-            return ""
-            
-        fields = msh.split('|')
-        if len(fields) < 10:
-            return ""
-            
-        sending_app = fields[2]
-        sending_fac = fields[3]
-        rec_app = fields[4]
-        rec_fac = fields[5]
-        msg_control_id = fields[9]
-        
-        now_str = datetime.now().strftime("%Y%m%d%H%M%S")
-        
-        ack_msh = f"MSH|^~\\&|{rec_app}|{rec_fac}|{sending_app}|{sending_fac}|{now_str}||ACK^R01|{msg_control_id}|P|2.3.1\r"
-        ack_msa = f"MSA|AA|{msg_control_id}\r"
-        
-        return ack_msh + ack_msa
-    except Exception as e:
-        logger.debug(f"Could not generate ACK: {e}")
-        return ""
-
-
-async def handle_contec_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter, port: int):
-    """
-    TCP server handler for Contec CMS7000PLUS client connections.
-    Directs incoming traffic to the unified parse_contec_data handler.
-    """
-    client_ip, client_port = writer.get_extra_info('peername')
-    logger.info(f"Accepted Contec CMS7000PLUS connection from {client_ip}:{client_port} on port {port}")
-    
-    display = get_terminal_display()
-    display.connection_opened(client_ip, port)
-
-    buffer = b""
-
-    try:
-        while True:
-            data = await reader.read(8192)
-            if not data:
-                logger.info(f"Contec client {client_ip}:{client_port} on port {port} sent EOF (0 bytes)")
-                break
-
-            buffer += data
-            logger.debug(f"Received {len(data)} bytes from {client_ip}:{client_port} on port {port} (buf={len(buffer)})")
-
-            # ---------------------------------------------------------------
-            # MLLP / HL7 text path (typically port 511)
-            # ---------------------------------------------------------------
-            if VT in buffer and FS_CR in buffer and b"MSH|" in buffer:
-                while True:
-                    start_idx = buffer.find(VT)
-                    end_idx = buffer.find(FS_CR)
-                    if start_idx != -1 and end_idx != -1 and start_idx < end_idx:
-                        raw_hl7 = buffer[start_idx + 1:end_idx].decode('utf-8', errors='ignore')
-                        buffer = buffer[end_idx + 2:]
-                        logger.info(f"Contec MLLP message detected on port {port}")
-                        vitals = parse_contec_data(raw_hl7.encode('utf-8'), client_ip)
-                        if vitals:
-                            await process_vitals(vitals)
-                            ack_msg = generate_ack(raw_hl7)
-                            if ack_msg:
-                                writer.write(VT + ack_msg.encode('utf-8') + FS_CR)
-                                await writer.drain()
-                    else:
-                        break
-                continue  # Go back to reading more data
-
-            # ---------------------------------------------------------------
-            # Binary Contec proprietary protocol (port 514)
-            # Packets are framed as: [len_lo][len_hi][04][46] ... payload ...
-            # The monitor sends each packet as a complete TCP write,
-            # but we buffer anyway in case of TCP segmentation.
-            # ---------------------------------------------------------------
-            consumed = 0
-            while consumed < len(buffer) - 4:
-                b0 = buffer[consumed]
-                b1 = buffer[consumed + 1]
-                b2 = buffer[consumed + 2]
-                b3 = buffer[consumed + 3]
-
-                if (b2 == 0x04 or b2 == 0x01 or b2 == 0x00) and b3 == 0x46:
-                    pkt_len = b0 | (b1 << 8)
-                    pkt_end = consumed + pkt_len
-
-                    if pkt_len < 5 or pkt_len > 8192:
-                        # Bad length — skip one byte and keep scanning
-                        consumed += 1
-                        continue
-
-                    if pkt_end > len(buffer):
-                        # Don't have the full packet yet — wait for more data
-                        break
-
-                    # Parse the complete packet
-                    pkt = buffer[consumed:pkt_end]
-                    vitals = parse_contec_data(pkt, client_ip)
-                    if vitals:
-                        logger.info(
-                            f"[PORT {port}] Vitals from {client_ip}: "
-                            f"SpO2={vitals.spo2}%, HR={vitals.heart_rate}bpm "
-                            f"BP={vitals.systolic_bp}/{vitals.diastolic_bp} "
-                            f"Temp={vitals.temperature}C"
-                        )
-                        await process_vitals(vitals)
-
-                    consumed = pkt_end
-
-                elif (b2 == 0x04 or b2 == 0x01) and b3 == 0x47:
-                    # End-of-frame marker — skip 4 bytes
-                    consumed += 4
-
-                else:
-                    # Not a recognised frame start — advance one byte
-                    consumed += 1
-
-            # Discard consumed bytes from front of buffer
-            buffer = buffer[consumed:]
-
-            # Safety valve
-            if len(buffer) > 32768:
-                logger.warning(f"Buffer too large ({len(buffer)} bytes) on port {port}, resetting")
-                buffer = b""
-
-    except asyncio.CancelledError:
-        pass
-    except ConnectionResetError:
-        logger.info(f"Contec CMS7000PLUS connection reset from {client_ip} on port {port}")
-    except Exception as e:
-        logger.error(f"Error in Contec client handler (port {port}): {e}")
-    finally:
-        logger.info(f"Closing Contec CMS7000PLUS connection from {client_ip}:{client_port} on port {port}")
-        display.connection_closed(client_ip, port)
-        writer.close()
-        try:
-            await writer.wait_closed()
-        except Exception:
-            pass
-
-
-# Cache to hold merged vitals per device to prevent fragmentation
-device_cache = {}
-device_field_timestamps = {}  # {device_id: {field_name: datetime}}
-last_db_write = {}
-
-
-async def process_vitals(vitals):
-    """
-    Log, database, WebSocket broadcast, and REST forward parsed vitals.
-    """
-    device_id = vitals.device_id
-    now = datetime.now(timezone.utc)
-    
-    if device_id not in device_field_timestamps:
-        device_field_timestamps[device_id] = {}
-
-    # Check if incoming packet has fresh waveforms
-    has_fresh_waveforms = (vitals.ecg_wave is not None) or (vitals.pleth_wave is not None)
-
-    # 1. Merge new vitals into cached vitals to prevent fragmented entries
-    if device_id not in device_cache:
-        device_cache[device_id] = vitals
-        # Track initial timestamps for present values
-        for field, value in vitals.model_dump().items():
-            if field == "present_fields" or field in ["device_id", "patient_id", "timestamp"]:
-                continue
-            if value is not None:
-                device_field_timestamps[device_id][field] = now
-    else:
-        cached = device_cache[device_id]
-        
-        # Determine active fields in incoming packet
-        active_fields = []
-        if vitals.present_fields is not None:
-            active_fields = vitals.present_fields
-        else:
-            for field, value in vitals.model_dump().items():
-                if field == "present_fields" or field in ["device_id", "patient_id", "timestamp"]:
-                    continue
-                if value is not None:
-                    active_fields.append(field)
-                    
-        # Update cache & record timestamps
-        for field in active_fields:
-            val = getattr(vitals, field)
-            setattr(cached, field, val)
-            device_field_timestamps[device_id][field] = now
-            
-        # Clean up stale fields (older than 15 seconds)
-        for field in list(device_field_timestamps[device_id].keys()):
-            last_updated = device_field_timestamps[device_id][field]
-            if (now - last_updated).total_seconds() > 15.0:
-                setattr(cached, field, None)
-                device_field_timestamps[device_id].pop(field, None)
-                
-        cached.timestamp = vitals.timestamp
-        vitals = cached
-
-    # 2. Update console display banner
-    display = get_terminal_display()
-    display.update_vitals(vitals)
-    
-    logger.info(
-        f"Vitals for Device {vitals.device_id}, Patient {vitals.patient_id}: "
-        f"HR={vitals.heart_rate}, SpO2={vitals.spo2}, "
-        f"BP={vitals.systolic_bp}/{vitals.diastolic_bp}, "
-        f"RR={vitals.respiratory_rate}, Temp={vitals.temperature}"
-    )
-    
-    # 3. Broadcast to live WebSockets dashboard in real-time
-    try:
-        from routers.dashboard import get_ws_manager
-        ws_manager = get_ws_manager()
-        await ws_manager.broadcast_vitals(vitals.model_dump(mode="json"))
-    except Exception as e:
-        logger.debug(f"WebSocket broadcast failed: {e}")
-    
-    # 4. Throttled Database & REST forwarding (at most once every 5 seconds)
-    # Note: If we have fresh waveforms, we bypass throttle for REST forwarding to keep cloud graphs real-time
-    now = datetime.now(timezone.utc)
-    should_write_db = False
-    if device_id not in last_db_write or (now - last_db_write[device_id]).total_seconds() >= 5.0:
-        should_write_db = True
-        last_db_write[device_id] = now
-
-    if should_write_db:
-        # Save to SQLite database and REST forward
-        db = SessionLocal()
-        try:
-            # 1. Device tracking
-            device = db.query(Device).filter(Device.device_id == vitals.device_id).first()
-            if not device:
-                device = Device(
-                    device_id=vitals.device_id,
-                    ip_address=vitals.ip_address or "unknown",
-                    status="active"
-                )
-                db.add(device)
-            else:
-                if vitals.ip_address:
-                    device.ip_address = vitals.ip_address
-                device.status = "active"
-                device.last_seen = datetime.now(timezone.utc)
-                    
-            # 2. Patient tracking — store/update demographics from HL7
-            if vitals.patient_id == "UNKNOWN":
-                last_known_reading = (
-                    db.query(VitalReading)
-                    .filter(VitalReading.device_id == vitals.device_id)
-                    .filter(VitalReading.patient_id != "UNKNOWN")
-                    .order_by(VitalReading.timestamp.desc())
-                    .first()
-                )
-                if last_known_reading:
-                    vitals.patient_id = last_known_reading.patient_id
-
-            patient = db.query(Patient).filter(Patient.patient_id == vitals.patient_id).first()
-            if not patient:
-                patient = Patient(
-                    patient_id=vitals.patient_id,
-                    mrn=vitals.patient_id,
-                    name=vitals.patient_name or "Unknown",
-                    gender=vitals.patient_gender,
-                    dob=vitals.patient_dob,
-                    bed_id=vitals.bed_id,
-                )
-                db.add(patient)
-            else:
-                # Refresh demographics whenever monitor sends updated PID fields
-                if vitals.patient_name:
-                    patient.name = vitals.patient_name
-                if vitals.patient_gender:
-                    patient.gender = vitals.patient_gender
-                if vitals.patient_dob:
-                    patient.dob = vitals.patient_dob
-                if vitals.bed_id:
-                    patient.bed_id = vitals.bed_id
-
-                    
-            # 3. Create Reading Entry
-            reading = VitalReading(
-                device_id=vitals.device_id,
-                patient_id=vitals.patient_id,
-                timestamp=vitals.timestamp,
-                heart_rate=vitals.heart_rate,
-                spo2=vitals.spo2,
-                systolic_bp=vitals.systolic_bp,
-                diastolic_bp=vitals.diastolic_bp,
-                map_bp=vitals.map_bp,
-                respiratory_rate=vitals.respiratory_rate,
-                temperature=vitals.temperature,
-                transmitted=False
-            )
-            db.add(reading)
-            db.commit()
-            db.refresh(reading)
-            
-            # 4. REST forwarding
-            success = await forward_vitals_to_api(vitals)
-            
-            if success:
-                reading.transmitted = True
-                log_entry = TransmissionLog(
-                    reading_id=reading.id,
-                    status="success",
-                    response_code=200
-                )
-            else:
-                log_entry = TransmissionLog(
-                    reading_id=reading.id,
-                    status="failed",
-                    error_message="Immediate REST forward failed"
-                )
-                    
-            db.add(log_entry)
-            db.commit()
-            
-        except Exception as e:
-            logger.error(f"Database operation failed: {e}")
-            db.rollback()
-        finally:
-            db.close()
-    elif has_fresh_waveforms:
-        # Bypass throttle for REST forwarding to keep cloud graphs real-time
-        try:
-            await forward_vitals_to_api(vitals)
-        except Exception as e:
-            logger.error(f"Real-time REST forwarding failed: {e}")
-
-    # Clear waveforms from cache to prevent repetition in subsequent non-waveform sub-packets
-    if device_id in device_cache:
-        device_cache[device_id].ecg_wave = None
-        device_cache[device_id].pleth_wave = None

fiveparaminte-main/database.py

@@ -1,17 +0,0 @@
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker, declarative_base
-from config import settings
-
-engine = create_engine(
-    settings.database_url, connect_args={"check_same_thread": False}
-)
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-Base = declarative_base()
-
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()

fiveparaminte-main/main.py

@@ -1,189 +0,0 @@
-import asyncio
-import logging
-import multiprocessing
-import socket
-from contextlib import asynccontextmanager
-from functools import partial
-
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
-import uvicorn
-
-from config import settings
-from database import engine, Base
-from contec_server import handle_contec_client
-from background_tasks import retry_failed_transmissions
-from routers import dashboard
-from routers.dashboard import get_ws_manager
-
-# Setup Logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler(settings.log_file),
-        logging.StreamHandler()
-    ]
-)
-logger = logging.getLogger(__name__)
-
-# Create database tables if they don't exist
-Base.metadata.create_all(bind=engine)
-
-
-def _make_contec_handler(port: int):
-    """Create a connection handler closure for a specific Contec port."""
-    async def handler(reader, writer):
-        await handle_contec_client(reader, writer, port)
-    return handler
-
-
-def _get_local_ips():
-    """Get all local IP addresses for this machine."""
-    ips = []
-    try:
-        for info in socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET):
-            ip = info[4][0]
-            if ip not in ips and not ip.startswith('127.'):
-                ips.append(ip)
-    except Exception:
-        pass
-    # Also try connecting to an external address to find the primary IP
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        s.connect(('8.8.8.8', 80))
-        primary_ip = s.getsockname()[0]
-        s.close()
-        if primary_ip not in ips:
-            ips.insert(0, primary_ip)
-    except Exception:
-        pass
-    return ips if ips else ['Could not detect — check ipconfig']
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    servers = []
-
-    # === Start Contec CMS7000PLUS TCP Servers ===
-    logger.info("Starting Contec CMS7000PLUS listeners...")
-    for port in settings.contec_ports:
-        try:
-            contec_server = await asyncio.start_server(
-                _make_contec_handler(port),
-                settings.hl7_host,
-                port
-            )
-            servers.append(contec_server)
-            logger.info(f"  [OK] Contec listener on port {port}")
-        except PermissionError:
-            logger.warning(
-                f"  [FAIL] Port {port} - Permission denied. "
-                f"Run as Administrator for ports below 1024."
-            )
-        except OSError as e:
-            if "already in use" in str(e).lower() or getattr(e, 'errno', 0) == 10048:
-                logger.warning(f"  [FAIL] Port {port} - Already in use")
-            else:
-                logger.warning(f"  [FAIL] Port {port} - {e}")
-    
-    if servers:
-        active_ports = []
-        for s in servers:
-            for sock in s.sockets:
-                active_ports.append(sock.getsockname()[1])
-        app.state.active_ports = active_ports
-        logger.info(f"  Active listener ports: {active_ports}")
-    else:
-        app.state.active_ports = []
-        logger.error("No servers could be started! Check port availability and permissions.")
-
-    # === Print startup banner ===
-    import os
-    port = int(os.environ.get("PORT", 8000))
-    local_ips = _get_local_ips()
-    model = settings.monitor_model
-    print("\n" + "=" * 65)
-    print(f"  Contec {model} Patient Monitor - Vital Signs Forwarder")
-    print("=" * 65)
-    print(f"  DASHBOARD:      http://localhost:{port}/api/dashboard")
-    print(f"  API Docs:       http://localhost:{port}/docs")
-    print(f"  Contec Ports:   {settings.contec_ports}")
-    print(f"  Monitor Model:  {model}")
-    print(f"  API Target:     {settings.target_api_url}")
-    print(f"  Database:       {settings.database_url}")
-    print(f"  ---------------------------------------------------------")
-    print(f"  YOUR PC's IP ADDRESSES (configure on your monitor):")
-    for ip in local_ips:
-        print(f"     ->  {ip}")
-    print("=" * 65)
-    print(f"  Waiting for {model} connections...")
-    print(f"  On your monitor: System Setup > Network > CMS Settings")
-    print(f"  Set Server IP = one of the IPs above, Port = {settings.contec_ports[0] if settings.contec_ports else 511}")
-    print("=" * 65 + "\n")
-    
-    # Startup: Start the background retry task
-    retry_task = asyncio.create_task(retry_failed_transmissions())
-    
-    yield
-    
-    # Shutdown
-    logger.info("Shutting down servers...")
-    retry_task.cancel()
-    for server in servers:
-        server.close()
-    for server in servers:
-        await server.wait_closed()
-
-
-# Initialize FastAPI app
-app = FastAPI(
-    title="Contec CMS7000PLUS Vital Signs Forwarder",
-    description="Service to receive vital signs from Contec CMS7000PLUS patient monitors and forward them to a REST API",
-    version="2.0.0",
-    lifespan=lifespan
-)
-
-# Enable CORS for cross-origin app integrations (e.g. Electron apps, local dev servers)
-from fastapi.middleware.cors import CORSMiddleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Include dashboard routes
-app.include_router(dashboard.router, prefix="/api")
-
-# Serve static folder
-from fastapi.staticfiles import StaticFiles
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-
-# === WebSocket endpoint for live vitals ===
-@app.websocket("/ws/vitals")
-async def websocket_vitals(websocket: WebSocket):
-    manager = get_ws_manager()
-    await manager.connect(websocket)
-    try:
-        while True:
-            # Keep connection alive, listen for any client messages
-            await websocket.receive_text()
-    except WebSocketDisconnect:
-        manager.disconnect(websocket)
-    except Exception:
-        manager.disconnect(websocket)
-
-
-if __name__ == "__main__":
-    # Required for Windows when building with PyInstaller using multiprocessing (uvicorn workers)
-    multiprocessing.freeze_support()
-    
-    logger.info("Initializing Application...")
-    
-    # Run the FastAPI server. 
-    # Notice we run on port 8000 (or PORT env var) for the REST Dashboard, while HL7 is on settings.hl7_port (e.g. 6060)
-    import os
-    port = int(os.environ.get("PORT", 8000))
-    uvicorn.run(app, host="0.0.0.0", port=port)

fiveparaminte-main/models.py

@@ -1,45 +0,0 @@
-from sqlalchemy import Column, Integer, String, Float, Boolean, DateTime
-from datetime import datetime, timezone
-from database import Base
-
-class Device(Base):
-    __tablename__ = "devices"
-    id = Column(Integer, primary_key=True, index=True)
-    device_id = Column(String, unique=True, index=True)
-    ip_address = Column(String)
-    status = Column(String, default="active")
-    last_seen = Column(DateTime, default=lambda: datetime.now(timezone.utc))
-
-class Patient(Base):
-    __tablename__ = "patients"
-    id         = Column(Integer, primary_key=True, index=True)
-    patient_id = Column(String, unique=True, index=True)  # MRN from monitor PID-3
-    mrn        = Column(String, index=True, nullable=True)   # explicit MRN (same as patient_id)
-    name       = Column(String, nullable=True)               # full name from PID-5
-    gender     = Column(String, nullable=True)               # M/F/U from PID-8
-    dob        = Column(String, nullable=True)               # YYYYMMDD from PID-7
-    bed_id     = Column(String, nullable=True)               # bed from PV1-3
-
-class VitalReading(Base):
-    __tablename__ = "vital_readings"
-    id = Column(Integer, primary_key=True, index=True)
-    device_id = Column(String, index=True)
-    patient_id = Column(String, index=True)
-    timestamp = Column(DateTime, index=True)
-    heart_rate = Column(Float, nullable=True)
-    spo2 = Column(Float, nullable=True)
-    systolic_bp = Column(Float, nullable=True)
-    diastolic_bp = Column(Float, nullable=True)
-    map_bp = Column(Float, nullable=True)
-    respiratory_rate = Column(Float, nullable=True)
-    temperature = Column(Float, nullable=True)
-    transmitted = Column(Boolean, default=False, index=True)
-
-class TransmissionLog(Base):
-    __tablename__ = "transmission_logs"
-    id = Column(Integer, primary_key=True, index=True)
-    reading_id = Column(Integer, index=True)
-    status = Column(String)
-    response_code = Column(Integer, nullable=True)
-    error_message = Column(String, nullable=True)
-    timestamp = Column(DateTime, default=lambda: datetime.now(timezone.utc))

fiveparaminte-main/render.yaml

@@ -1,15 +0,0 @@
-services:
-  - type: web
-    name: contec-monitor-api
-    runtime: python
-    buildCommand: pip install -r requirements.txt
-    startCommand: python3 -m uvicorn main:app --host 0.0.0.0 --port $PORT
-    envVars:
-      - key: PORT
-        value: 10000
-      - key: PYTHON_VERSION
-        value: 3.12.0
-      - key: TARGET_API_URL
-        sync: false
-      - key: API_TOKEN
-        sync: false

fiveparaminte-main/requirements.txt

@@ -1,9 +0,0 @@
-fastapi
-uvicorn
-sqlalchemy
-pydantic
-pydantic-settings
-httpx
-gunicorn
-rich
-websockets

fiveparaminte-main/run.sh

@@ -1,21 +0,0 @@
-#!/bin/bash
-set -e
-
-echo "=== Mindray HL7 Forwarder ==="
-
-# 1. Create a virtual environment if it doesn't exist
-if [ ! -d "venv" ]; then
-    echo "Creating Python virtual environment..."
-    python3 -m venv venv
-fi
-
-# 2. Activate the virtual environment
-source venv/bin/activate
-
-# 3. Install dependencies quietly
-echo "Checking and installing dependencies..."
-pip install -r requirements.txt -q
-
-# 4. Start the server
-echo "Starting the application..."
-python main.py

fiveparaminte-main/runtime.txt

@@ -1 +0,0 @@
-python-3.12.0

fiveparaminte-main/schemas.py

@@ -1,45 +0,0 @@
-from pydantic import BaseModel
-from typing import Optional, List
-from datetime import datetime
-
-class NormalizedVitals(BaseModel):
-    device_id: str
-    patient_id: str
-    timestamp: datetime
-    ip_address: Optional[str] = None
-    heart_rate: Optional[float] = None
-    spo2: Optional[float] = None
-    systolic_bp: Optional[float] = None
-    diastolic_bp: Optional[float] = None
-    map_bp: Optional[float] = None
-    respiratory_rate: Optional[float] = None
-    temperature: Optional[float] = None
-    present_fields: Optional[list] = None
-    # Raw waveform sample arrays (8-bit unsigned, 0-255)
-    ecg_wave:   Optional[List[int]] = None   # ECG waveform samples from 989-byte packet
-    pleth_wave: Optional[List[int]] = None   # Pleth/SpO2 waveform samples from 286/288-byte packet
-    # Patient demographics parsed from HL7 PID/PV1 segments
-    patient_name:   Optional[str] = None   # PID-5: "Given Family"
-    patient_gender: Optional[str] = None   # PID-8: M / F / U
-    patient_dob:    Optional[str] = None   # PID-7: YYYYMMDD
-    bed_id:         Optional[str] = None   # PV1-3: bed / room ID
-
-class DeviceStatus(BaseModel):
-    device_id: str
-    ip_address: str
-    status: str
-    last_seen: datetime
-    
-    class Config:
-        from_attributes = True
-
-class TransmissionLogResponse(BaseModel):
-    id: int
-    reading_id: int
-    status: str
-    response_code: Optional[int]
-    error_message: Optional[str]
-    timestamp: datetime
-
-    class Config:
-        from_attributes = True

fiveparaminte-main/setup_service.sh

@@ -1,50 +0,0 @@
-#!/bin/bash
-
-# Exit on error
-set -e
-
-SERVICE_NAME="contec-forwarder"
-SERVICE_FILE="/etc/systemd/system/${SERVICE_NAME}.service"
-WORKING_DIR="/home/prathiyuman/Prathiyuman/ContecMonitor/fiveparaminte-main"
-PYTHON_EXEC="${WORKING_DIR}/venv/bin/python"
-SCRIPT_PATH="${WORKING_DIR}/main.py"
-
-echo "=== Creating systemd service file ==="
-sudo bash -c "cat > ${SERVICE_FILE}" <<EOF
-[Unit]
-Description=Contec Patient Monitor Vital Signs Forwarder
-After=network.target
-
-[Service]
-Type=simple
-User=root
-WorkingDirectory=${WORKING_DIR}
-Environment=PORT=8006
-ExecStart=${PYTHON_EXEC} ${SCRIPT_PATH}
-Restart=always
-RestartSec=5
-StandardOutput=journal
-StandardError=journal
-
-[Install]
-WantedBy=multi-user.target
-EOF
-
-echo "=== Reloading systemd daemon ==="
-sudo systemctl daemon-reload
-
-echo "=== Enabling ${SERVICE_NAME} to start on boot ==="
-sudo systemctl enable ${SERVICE_NAME}
-
-echo "=== Starting ${SERVICE_NAME} service ==="
-sudo systemctl restart ${SERVICE_NAME}
-
-echo "=== Service Status ==="
-sudo systemctl status ${SERVICE_NAME} --no-pager
-
-echo ""
-echo "=========================================================="
-echo "SUCCESS: Contec Forwarder is now running in the background!"
-echo "To check live service logs, run:"
-echo "  sudo journalctl -u contec-forwarder -f"
-echo "=========================================================="

fiveparaminte-main/terminal_display.py

@@ -1,246 +0,0 @@
-"""
-Terminal Display for Live Vital Signs
-======================================
-Provides a rich, color-coded terminal dashboard showing real-time
-vital signs received from patient monitors.
-
-Works with both Mindray uMEC 100 and Contec CMS9200PLUS monitors.
-"""
-
-import logging
-from datetime import datetime, timezone
-from typing import Optional
-from schemas import NormalizedVitals
-
-logger = logging.getLogger(__name__)
-
-# Try to use 'rich' for beautiful output, fall back to basic print
-try:
-    from rich.console import Console
-    from rich.table import Table
-    from rich.panel import Panel
-    from rich.text import Text
-    from rich.layout import Layout
-    from rich.live import Live
-    from rich import box
-    HAS_RICH = True
-except ImportError:
-    HAS_RICH = False
-    logger.info("'rich' library not installed. Using basic terminal output.")
-
-
-# === Normal Range Definitions ===
-VITAL_RANGES = {
-    "heart_rate":       {"low": 60,  "high": 100, "critical_low": 40,  "critical_high": 150, "unit": "bpm",  "label": "Heart Rate"},
-    "spo2":             {"low": 95,  "high": 100, "critical_low": 90,  "critical_high": 101, "unit": "%",    "label": "SpO2"},
-    "systolic_bp":      {"low": 90,  "high": 140, "critical_low": 70,  "critical_high": 180, "unit": "mmHg", "label": "BP Systolic"},
-    "diastolic_bp":     {"low": 60,  "high": 90,  "critical_low": 40,  "critical_high": 120, "unit": "mmHg", "label": "BP Diastolic"},
-    "map_bp":           {"low": 70,  "high": 105, "critical_low": 60,  "critical_high": 130, "unit": "mmHg", "label": "MAP"},
-    "respiratory_rate": {"low": 12,  "high": 20,  "critical_low": 8,   "critical_high": 30,  "unit": "/min", "label": "Resp Rate"},
-    "temperature":      {"low": 36.1,"high": 37.2,"critical_low": 35.0,"critical_high": 39.0,"unit": "C",    "label": "Temperature"},
-}
-
-
-def get_vital_color(param_name: str, value: Optional[float]) -> str:
-    """Return a color name based on whether the value is normal, warning, or critical."""
-    if value is None:
-        return "dim"
-    
-    ranges = VITAL_RANGES.get(param_name)
-    if not ranges:
-        return "white"
-    
-    if value <= ranges["critical_low"] or value >= ranges["critical_high"]:
-        return "bold red"
-    elif value < ranges["low"] or value > ranges["high"]:
-        return "yellow"
-    else:
-        return "bold green"
-
-
-def format_vital_value(param_name: str, value: Optional[float]) -> str:
-    """Format a vital sign value with its unit."""
-    if value is None:
-        return "---"
-    
-    ranges = VITAL_RANGES.get(param_name, {})
-    unit = ranges.get("unit", "")
-    
-    # Format based on typical precision
-    if param_name == "temperature":
-        return f"{value:.1f} {unit}"
-    elif param_name == "spo2":
-        return f"{value:.0f} {unit}"
-    else:
-        return f"{value:.0f} {unit}"
-
-
-class TerminalDisplay:
-    """Manages the live terminal display of vital signs."""
-    
-    def __init__(self):
-        self._latest_vitals: dict[str, NormalizedVitals] = {}  # keyed by device_id
-        self._last_update: Optional[datetime] = None
-        self._connection_count: int = 0
-        self._message_count: int = 0
-        
-        if HAS_RICH:
-            self.console = Console()
-        else:
-            self.console = None
-    
-    def update_vitals(self, vitals: NormalizedVitals):
-        """Update the display with new vital signs data."""
-        self._latest_vitals[vitals.device_id] = vitals
-        self._last_update = datetime.now(timezone.utc)
-        self._message_count += 1
-        self._print_vitals(vitals)
-    
-    def connection_opened(self, client_ip: str, port: int):
-        """Track a new connection."""
-        self._connection_count += 1
-        if HAS_RICH:
-            self.console.print(
-                f"  [bold cyan]Connected:[/] {client_ip} on port {port} "
-                f"(total connections: {self._connection_count})"
-            )
-        else:
-            print(f"  Connected: {client_ip} on port {port}")
-    
-    def connection_closed(self, client_ip: str, port: int):
-        """Track a closed connection."""
-        if HAS_RICH:
-            self.console.print(f"  [dim]Disconnected:[/dim] {client_ip} on port {port}")
-        else:
-            print(f"  Disconnected: {client_ip} on port {port}")
-    
-    def _print_vitals(self, vitals: NormalizedVitals):
-        """Print vital signs to terminal."""
-        if HAS_RICH:
-            self._print_vitals_rich(vitals)
-        else:
-            self._print_vitals_basic(vitals)
-    
-    def _print_vitals_rich(self, vitals: NormalizedVitals):
-        """Print vital signs using rich library for beautiful output."""
-        table = Table(
-            title=f"Live Vitals -- Device: {vitals.device_id} | Patient: {vitals.patient_id}",
-            box=box.HEAVY_EDGE,
-            show_header=True,
-            header_style="bold white on dark_blue",
-            title_style="bold white",
-            border_style="blue",
-            padding=(0, 2),
-        )
-        
-        table.add_column("Parameter", style="bold white", width=16)
-        table.add_column("Value", justify="right", width=14)
-        table.add_column("Status", justify="center", width=10)
-        table.add_column("Normal Range", justify="center", style="dim", width=14)
-        
-        vital_params = [
-            ("heart_rate", vitals.heart_rate),
-            ("spo2", vitals.spo2),
-            ("systolic_bp", vitals.systolic_bp),
-            ("diastolic_bp", vitals.diastolic_bp),
-            ("map_bp", vitals.map_bp),
-            ("respiratory_rate", vitals.respiratory_rate),
-            ("temperature", vitals.temperature),
-        ]
-        
-        for param_name, value in vital_params:
-            ranges = VITAL_RANGES.get(param_name, {})
-            color = get_vital_color(param_name, value)
-            formatted = format_vital_value(param_name, value)
-            label = ranges.get("label", param_name)
-            
-            # Status indicator
-            if value is None:
-                status = "[dim]-[/dim]"
-            elif color == "bold green":
-                status = "[green]Normal[/green]"
-            elif color == "yellow":
-                status = "[yellow]Warning[/yellow]"
-            elif color == "bold red":
-                status = "[red]ALERT[/red]"
-            else:
-                status = "[dim]-[/dim]"
-            
-            # Normal range
-            low = ranges.get("low", "?")
-            high = ranges.get("high", "?")
-            unit = ranges.get("unit", "")
-            range_str = f"{low}-{high} {unit}"
-            
-            table.add_row(
-                label,
-                f"[{color}]{formatted}[/{color}]",
-                status,
-                range_str,
-            )
-        
-        self.console.print()
-        self.console.print(table)
-        
-        # Timestamp footer
-        time_str = vitals.timestamp.strftime("%Y-%m-%d %H:%M:%S UTC") if vitals.timestamp else "N/A"
-        self.console.print(
-            f"  [dim]Last update: {time_str} | "
-            f"Messages received: {self._message_count} | "
-            f"Active connections: {self._connection_count}[/dim]"
-        )
-    
-    def _print_vitals_basic(self, vitals: NormalizedVitals):
-        """Fallback plain-text vital signs display."""
-        print("\n" + "=" * 65)
-        print(f"  LIVE VITALS — Device: {vitals.device_id} | Patient: {vitals.patient_id}")
-        print("=" * 65)
-        
-        vital_params = [
-            ("Heart Rate",  vitals.heart_rate,       "bpm"),
-            ("SpO2",        vitals.spo2,             "%"),
-            ("BP Systolic", vitals.systolic_bp,       "mmHg"),
-            ("BP Diastolic",vitals.diastolic_bp,      "mmHg"),
-            ("MAP",         vitals.map_bp,            "mmHg"),
-            ("Resp Rate",   vitals.respiratory_rate,  "/min"),
-            ("Temperature", vitals.temperature,       "C"),
-        ]
-        
-        for label, value, unit in vital_params:
-            if value is not None:
-                if "temp" in label.lower():
-                    val_str = f"{value:.1f} {unit}"
-                else:
-                    val_str = f"{value:.0f} {unit}"
-                
-                # Simple text status
-                ranges = VITAL_RANGES.get(label.lower().replace(" ", "_"), {})
-                if ranges:
-                    if value < ranges.get("critical_low", 0) or value > ranges.get("critical_high", 999):
-                        status = " *** CRITICAL ***"
-                    elif value < ranges.get("low", 0) or value > ranges.get("high", 999):
-                        status = " ! WARNING"
-                    else:
-                        status = " OK"
-                else:
-                    status = ""
-                
-                print(f"  {label:<16} {val_str:>12}{status}")
-            else:
-                print(f"  {label:<16} {'---':>12}")
-        
-        time_str = vitals.timestamp.strftime("%H:%M:%S") if vitals.timestamp else "N/A"
-        print(f"\n  Time: {time_str}  |  Messages: {self._message_count}")
-        print("-" * 65)
-
-
-# Global singleton
-_display: Optional[TerminalDisplay] = None
-
-
-def get_terminal_display() -> TerminalDisplay:
-    """Get or create the global terminal display instance."""
-    global _display
-    if _display is None:
-        _display = TerminalDisplay()
-    return _display

main.py

@@ -11,7 +11,7 @@ import uvicorn
 from config import settings
 from database import engine, Base
 from contec_server import handle_contec_client
-from background_tasks import retry_failed_transmissions
+from background_tasks import retry_failed_transmissions, sync_cloud_state
 from routers import dashboard
 from routers.dashboard import get_ws_manager
 
@@ -62,6 +62,22 @@ def _get_local_ips():
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
+    # Protect against Windows IOCP Proactor crashes (WinError 64 / 121 / 10054 on accept)
+    import sys
+    if sys.platform == "win32":
+        try:
+            loop = asyncio.get_running_loop()
+            def silence_windows_iocp_errors(loop, context):
+                msg = str(context.get("message", ""))
+                exc = context.get("exception")
+                winerr = getattr(exc, "winerror", None)
+                if winerr in (64, 121, 10054) or "Accept failed on a socket" in msg or "The specified network name is no longer available" in msg:
+                    return
+                loop.default_exception_handler(context)
+            loop.set_exception_handler(silence_windows_iocp_errors)
+        except Exception:
+            pass
+
     servers = []
 
     # === Start Contec CMS7000PLUS TCP Servers ===
@@ -111,6 +127,7 @@ async def lifespan(app: FastAPI):
     print(f"  Contec Ports:   {settings.contec_ports}")
     print(f"  Monitor Model:  {model}")
     print(f"  API Target:     {settings.target_api_url}")
+    print(f"  Cloud Sync:     {getattr(settings, 'cloud_api_url', settings.target_api_url)}")
     print(f"  Database:       {settings.database_url}")
     print(f"  ---------------------------------------------------------")
     print(f"  YOUR PC's IP ADDRESSES (configure on your monitor):")
@@ -122,8 +139,9 @@ async def lifespan(app: FastAPI):
     print(f"  Set Server IP = one of the IPs above, Port = {settings.contec_ports[0] if settings.contec_ports else 511}")
     print("=" * 65 + "\n")
     
-    # Startup: Start the background retry task
+    # Startup: Start background retry and cloud state sync tasks
     retry_task = asyncio.create_task(retry_failed_transmissions())
+    cloud_sync_task = asyncio.create_task(sync_cloud_state())
     
     # Startup: Start bore tunnel for remote monitors if available and not already running
     bore_proc = None
@@ -154,6 +172,7 @@ async def lifespan(app: FastAPI):
         except Exception:
             pass
     retry_task.cancel()
+    cloud_sync_task.cancel()
     for server in servers:
         server.close()
     for server in servers:
@@ -178,23 +197,42 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Include dashboard routes
+# Include dashboard routes under multiple prefixes so reverse proxies (Nginx)
+# work whether they strip /v1/contec-monitor or forward it as-is
 app.include_router(dashboard.router, prefix="/api")
+app.include_router(dashboard.router)
+app.include_router(dashboard.router, prefix="/v1/contec-monitor/api")
+app.include_router(dashboard.router, prefix="/v1/contec-monitor")
 
-# Also serve dashboard at root and /dashboard directly for convenience
+# Also serve dashboard directly for convenience across various path styles
 from fastapi.responses import HTMLResponse
 @app.get("/", response_class=HTMLResponse)
 @app.get("/dashboard", response_class=HTMLResponse)
+@app.get("/v1/contec-monitor", response_class=HTMLResponse)
+@app.get("/v1/contec-monitor/dashboard", response_class=HTMLResponse)
+@app.get("/v1/contec-monitor/api/dashboard", response_class=HTMLResponse)
 def serve_dashboard_root():
     return dashboard.serve_dashboard()
 
 # Serve static folder
 from fastapi.staticfiles import StaticFiles
 app.mount("/static", StaticFiles(directory="static"), name="static")
+app.mount("/v1/contec-monitor/static", StaticFiles(directory="static"), name="static_subpath")
+
+from fastapi.responses import Response
+@app.get("/favicon.ico", include_in_schema=False)
+@app.get("/v1/contec-monitor/favicon.ico", include_in_schema=False)
+async def favicon():
+    return Response(status_code=204, media_type="image/x-icon")
+
+
 
 
 # === WebSocket endpoint for live vitals ===
 @app.websocket("/ws/vitals")
+@app.websocket("/api/ws/vitals")
+@app.websocket("/v1/contec-monitor/ws/vitals")
+@app.websocket("/v1/contec-monitor/api/ws/vitals")
 async def websocket_vitals(websocket: WebSocket):
     manager = get_ws_manager()
     await manager.connect(websocket)

models.py

@@ -18,8 +18,9 @@ class Patient(Base):
     name       = Column(String, nullable=True)               # full name from PID-5
     gender     = Column(String, nullable=True)               # M/F/U from PID-8
     dob        = Column(String, nullable=True)               # YYYYMMDD from PID-7
-    bed_id     = Column(String, nullable=True)               # bed from PV1-3
-    device_id  = Column(String, nullable=True, index=True)   # assigned machine / device_id
+    bed_id       = Column(String, nullable=True)               # bed from PV1-3
+    patient_type = Column(String, nullable=True)               # Adult / Pediatric / Neonatal
+    device_id    = Column(String, nullable=True, index=True)   # assigned machine / device_id
 
 class VitalReading(Base):
     __tablename__ = "vital_readings"
@@ -34,6 +35,8 @@ class VitalReading(Base):
     map_bp = Column(Float, nullable=True)
     respiratory_rate = Column(Float, nullable=True)
     temperature = Column(Float, nullable=True)
+    temperature2 = Column(Float, nullable=True)
+    temperature_diff = Column(Float, nullable=True)
     transmitted = Column(Boolean, default=False, index=True)
 
 class TransmissionLog(Base):

render.yaml

@@ -5,6 +5,8 @@ services:
     buildCommand: pip install -r requirements.txt
     startCommand: python3 -m uvicorn main:app --host 0.0.0.0 --port $PORT
     envVars:
+      - key: PYTHONPATH
+        value: /opt/render/project/src
       - key: PORT
         value: 10000
       - key: PYTHON_VERSION

routers/dashboard.py

@@ -11,6 +11,7 @@ from fastapi import APIRouter, Depends, HTTPException, WebSocket, WebSocketDisco
 from fastapi.responses import HTMLResponse
 from sqlalchemy.orm import Session
 from sqlalchemy import or_
+from datetime import datetime, timezone, timedelta
 from database import get_db
 from models import Device, Patient, VitalReading, TransmissionLog
 
@@ -24,6 +25,7 @@ class PatientAssignRequest(BaseModel):
     dob: Optional[str] = None
     gender: Optional[str] = None
     bed_id: Optional[str] = None
+    patient_type: Optional[str] = None
 
 # === WebSocket Manager for real-time vitals push ===
 class VitalsWebSocketManager:
@@ -70,7 +72,14 @@ def serve_dashboard():
     dashboard_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "static", "dashboard.html")
     try:
         with open(dashboard_path, "r", encoding="utf-8") as f:
-            return HTMLResponse(content=f.read())
+            return HTMLResponse(
+                content=f.read(),
+                headers={
+                    "Cache-Control": "no-cache, no-store, must-revalidate",
+                    "Pragma": "no-cache",
+                    "Expires": "0"
+                }
+            )
     except FileNotFoundError:
         return HTMLResponse(content="<h1>Dashboard not found</h1><p>static/dashboard.html is missing</p>", status_code=404)
 
@@ -112,26 +121,30 @@ def get_latest_readings(
     if device_id:
         query = query.filter(VitalReading.device_id == device_id)
 
-    patient_filters = []
+    patient_criteria = []
     if mrn:
         mrn_clean = mrn.strip()
-        patient_filters.append(Patient.mrn == mrn_clean)
-        patient_filters.append(Patient.patient_id == mrn_clean)
+        patient_criteria.append(or_(Patient.mrn == mrn_clean, Patient.patient_id == mrn_clean))
     if name:
         name_clean = name.strip()
-        patient_filters.append(Patient.name.ilike(f"%{name_clean}%"))
+        patient_criteria.append(Patient.name.ilike(f"%{name_clean}%"))
     if dob:
-        dob_clean = dob.strip()
-        patient_filters.append(Patient.dob.ilike(f"%{dob_clean}%"))
+        dob_clean = dob.strip().replace("-", "").replace("/", "")
+        patient_criteria.append(or_(
+            Patient.dob.ilike(f"%{dob.strip()}%"),
+            Patient.dob.ilike(f"%{dob_clean}%"),
+            Patient.dob.ilike(f"%{dob.strip()[:4]}%") if len(dob.strip()) >= 4 else False
+        ))
 
-    if patient_filters:
-        matching_patients = db.query(Patient).filter(or_(*patient_filters)).all()
+    if patient_criteria:
+        from sqlalchemy import and_
+        matching_patients = db.query(Patient).filter(and_(*patient_criteria)).all()
+        if not matching_patients:
+            return []
         matching_dev_ids = [p.device_id for p in matching_patients if p.device_id]
         matching_mrns = [p.mrn for p in matching_patients if p.mrn] + [p.patient_id for p in matching_patients if p.patient_id]
 
         conds = []
-        if mrn:
-            conds.append(VitalReading.patient_id == mrn.strip())
         if matching_mrns:
             conds.append(VitalReading.patient_id.in_(matching_mrns))
         if matching_dev_ids:
@@ -139,6 +152,8 @@ def get_latest_readings(
 
         if conds:
             query = query.filter(or_(*conds))
+        else:
+            return []
 
     readings = query.order_by(VitalReading.timestamp.desc()).limit(limit).all()
     return readings
@@ -147,24 +162,121 @@ def get_latest_readings(
 def list_patients(db: Session = Depends(get_db)):
     """
     List all patients with their assigned device and latest vitals readings.
+    Strictly enforce live data timeouts:
+    - Continuous parameters (HR, SpO2, RR, Temp): max 25 seconds age.
+    - Intermittent parameters (NIBP): max 15 minutes age.
+    - Never backfill from stale historical readings.
     """
     patients = db.query(Patient).filter(Patient.patient_id != "UNKNOWN", Patient.mrn != "UNKNOWN").all()
     results = []
+    now = datetime.now(timezone.utc)
+    live_cutoff = now - timedelta(seconds=25)
+    nibp_cutoff = now - timedelta(minutes=15)
+
     for p in patients:
-        # Find latest vitals for this patient or this patient's assigned device
-        latest_reading = (
-            db.query(VitalReading)
-            .filter(
-                or_(
-                    VitalReading.patient_id == p.mrn,
-                    VitalReading.patient_id == p.patient_id,
-                    (VitalReading.device_id == p.device_id) if p.device_id else False
-                )
+        merged_vitals = None
+
+        # Primary source: in-memory live cache if running locally with active machine stream
+        try:
+            from contec_server import device_cache, device_field_timestamps
+            if p.device_id and p.device_id in device_cache:
+                cached = device_cache[p.device_id]
+                field_ts = device_field_timestamps.get(p.device_id, {})
+                cached_time = cached.timestamp
+                if cached_time:
+                    if cached_time.tzinfo is None:
+                        cached_time = cached_time.replace(tzinfo=timezone.utc)
+                    if (now - cached_time).total_seconds() <= 25:
+                        merged_vitals = {
+                            "heart_rate": cached.heart_rate if (field_ts.get("heart_rate") and (now - field_ts["heart_rate"]).total_seconds() <= 25) else None,
+                            "spo2": cached.spo2 if (field_ts.get("spo2") and (now - field_ts["spo2"]).total_seconds() <= 25) else None,
+                            "respiratory_rate": cached.respiratory_rate if (field_ts.get("respiratory_rate") and (now - field_ts["respiratory_rate"]).total_seconds() <= 25) else None,
+                            "temperature": cached.temperature if (field_ts.get("temperature") and (now - field_ts["temperature"]).total_seconds() <= 25) else None,
+                            "temperature2": getattr(cached, 'temperature2', None) if (field_ts.get("temperature2") and (now - field_ts["temperature2"]).total_seconds() <= 25) else None,
+                            "temperature_diff": getattr(cached, 'temperature_diff', None) if (field_ts.get("temperature_diff") and (now - field_ts["temperature_diff"]).total_seconds() <= 25) else None,
+                            "systolic_bp": cached.systolic_bp if (field_ts.get("systolic_bp") and (now - field_ts["systolic_bp"]).total_seconds() <= 900) else None,
+                            "diastolic_bp": cached.diastolic_bp if (field_ts.get("diastolic_bp") and (now - field_ts["diastolic_bp"]).total_seconds() <= 900) else None,
+                            "map_bp": cached.map_bp if (field_ts.get("map_bp") and (now - field_ts["map_bp"]).total_seconds() <= 900) else None,
+                            "timestamp": cached_time.isoformat()
+                        }
+        except Exception as e:
+            logger.debug(f"Could not read from device_cache: {e}")
+
+        # Fallback or cloud/Render mode: query DB
+        if merged_vitals is None:
+            patient_filters = or_(
+                VitalReading.patient_id == p.mrn,
+                VitalReading.patient_id == p.patient_id,
+                (VitalReading.device_id == p.device_id) if p.device_id else False
             )
-            .order_by(VitalReading.timestamp.desc())
-            .first()
-        )
-        
+            # 1. Try to find readings within the live cutoff window (last 25 seconds)
+            recent_readings = (
+                db.query(VitalReading)
+                .filter(patient_filters, VitalReading.timestamp >= live_cutoff)
+                .order_by(VitalReading.timestamp.desc())
+                .limit(20)
+                .all()
+            )
+            # 2. Option B: If no live reading in last 25s, retain latest recorded readings from DB
+            if not recent_readings:
+                recent_readings = (
+                    db.query(VitalReading)
+                    .filter(patient_filters)
+                    .order_by(VitalReading.timestamp.desc())
+                    .limit(20)
+                    .all()
+                )
+
+            if recent_readings:
+                ts_iso = recent_readings[0].timestamp.isoformat() if recent_readings[0].timestamp else None
+                if ts_iso and not ts_iso.endswith('Z') and '+' not in ts_iso:
+                    ts_iso += 'Z'
+                merged_vitals = {
+                    "heart_rate": None,
+                    "spo2": None,
+                    "systolic_bp": None,
+                    "diastolic_bp": None,
+                    "map_bp": None,
+                    "respiratory_rate": None,
+                    "temperature": None,
+                    "temperature2": None,
+                    "temperature_diff": None,
+                    "timestamp": ts_iso,
+                }
+                for r in reversed(recent_readings):
+                    if r.heart_rate is not None: merged_vitals["heart_rate"] = r.heart_rate
+                    if r.spo2 is not None: merged_vitals["spo2"] = r.spo2
+                    if r.respiratory_rate is not None: merged_vitals["respiratory_rate"] = r.respiratory_rate
+                    if r.temperature is not None: merged_vitals["temperature"] = r.temperature
+                    if getattr(r, 'temperature2', None) is not None: merged_vitals["temperature2"] = r.temperature2
+                    if getattr(r, 'temperature_diff', None) is not None: merged_vitals["temperature_diff"] = r.temperature_diff
+                    if r.systolic_bp is not None: merged_vitals["systolic_bp"] = r.systolic_bp
+                    if r.diastolic_bp is not None: merged_vitals["diastolic_bp"] = r.diastolic_bp
+                    if r.map_bp is not None: merged_vitals["map_bp"] = r.map_bp
+
+            # Check NIBP separately if not already populated
+            if not merged_vitals or merged_vitals.get("systolic_bp") is None:
+                r_bp = (
+                    db.query(VitalReading.systolic_bp, VitalReading.diastolic_bp, VitalReading.map_bp, VitalReading.timestamp)
+                    .filter(patient_filters, VitalReading.systolic_bp != None)
+                    .order_by(VitalReading.timestamp.desc())
+                    .first()
+                )
+                if r_bp:
+                    if merged_vitals is None:
+                        ts_bp = r_bp[3].isoformat() if r_bp[3] else None
+                        if ts_bp and not ts_bp.endswith('Z') and '+' not in ts_bp:
+                            ts_bp += 'Z'
+                        merged_vitals = {
+                            "heart_rate": None, "spo2": None, "respiratory_rate": None,
+                            "temperature": None, "temperature2": None, "temperature_diff": None,
+                            "timestamp": ts_bp
+                        }
+                    merged_vitals["systolic_bp"] = r_bp[0]
+                    merged_vitals["diastolic_bp"] = r_bp[1]
+                    merged_vitals["map_bp"] = r_bp[2]
+
+
         device = db.query(Device).filter(Device.device_id == p.device_id).first() if p.device_id else None
 
         results.append({
@@ -178,16 +290,7 @@ def list_patients(db: Session = Depends(get_db)):
             "device_id": p.device_id,
             "device_status": device.status if device else "unassigned",
             "device_ip": device.ip_address if device else None,
-            "latest_vitals": {
-                "heart_rate": latest_reading.heart_rate if latest_reading else None,
-                "spo2": latest_reading.spo2 if latest_reading else None,
-                "systolic_bp": latest_reading.systolic_bp if latest_reading else None,
-                "diastolic_bp": latest_reading.diastolic_bp if latest_reading else None,
-                "map_bp": latest_reading.map_bp if latest_reading else None,
-                "respiratory_rate": latest_reading.respiratory_rate if latest_reading else None,
-                "temperature": latest_reading.temperature if latest_reading else None,
-                "timestamp": latest_reading.timestamp.isoformat() if (latest_reading and latest_reading.timestamp) else None,
-            } if latest_reading else None
+            "latest_vitals": merged_vitals
         })
     return results
 
@@ -235,6 +338,8 @@ async def assign_patient(req: PatientAssignRequest, db: Session = Depends(get_db
             })
         except Exception:
             pass
+        from api_client import sync_patient_assignment_to_cloud
+        asyncio.create_task(sync_patient_assignment_to_cloud({"mrn": "UNKNOWN", "name": "Unassigned Patient"}, device_id))
         return {
             "status": "success",
             "message": f"Device {device_id} unassigned successfully"
@@ -256,6 +361,7 @@ async def assign_patient(req: PatientAssignRequest, db: Session = Depends(get_db
             gender=req.gender,
             dob=req.dob,
             bed_id=req.bed_id,
+            patient_type=req.patient_type,
             device_id=device_id
         )
         db.add(patient)
@@ -270,6 +376,8 @@ async def assign_patient(req: PatientAssignRequest, db: Session = Depends(get_db
             patient.dob = req.dob
         if req.bed_id is not None:
             patient.bed_id = req.bed_id
+        if req.patient_type is not None:
+            patient.patient_type = req.patient_type
         patient.device_id = device_id
 
     # 3. Associate recent readings for this device that were marked "UNKNOWN"
@@ -289,6 +397,7 @@ async def assign_patient(req: PatientAssignRequest, db: Session = Depends(get_db
         "gender": patient.gender,
         "dob": patient.dob,
         "bed_id": patient.bed_id,
+        "patient_type": patient.patient_type,
     }
     set_assigned_patient(device_id, p_data)
 
@@ -306,10 +415,14 @@ async def assign_patient(req: PatientAssignRequest, db: Session = Depends(get_db
             "patient_dob": patient.dob,
             "dob": patient.dob,
             "bed_id": patient.bed_id,
+            "patient_type": patient.patient_type,
         })
     except Exception as e:
         logger.debug(f"Broadcast of patient_assigned failed: {e}")
 
+    from api_client import sync_patient_assignment_to_cloud
+    asyncio.create_task(sync_patient_assignment_to_cloud(p_data, device_id))
+
     return {
         "status": "success",
         "message": f"Patient {patient.name} ({mrn}) assigned to device {device_id}",
@@ -445,6 +558,7 @@ def get_network_info():
     primary_ip = None
     try:
         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.settimeout(0.5)
         s.connect(('8.8.8.8', 80))
         primary_ip = s.getsockname()[0]
         s.close()
@@ -468,3 +582,117 @@ def get_network_info():
             f"6. The dashboard will show data automatically"
         ]
     }
+
+
+# === Push Vitals Endpoint (for local-to-cloud sync) ===
+from schemas import NormalizedVitals
+from datetime import datetime, timezone
+
+@router.post("/push-vitals")
+async def push_vitals(vitals: NormalizedVitals, api_key: Optional[str] = None, db: Session = Depends(get_db)):
+    """
+    Receive vitals pushed from a local instance and store + broadcast them to connected WebSocket clients.
+    """
+    from config import settings
+    if settings.api_token and api_key != settings.api_token:
+        raise HTTPException(status_code=401, detail="Invalid or missing api_key")
+
+    try:
+        now = datetime.now(timezone.utc)
+
+        # 1. Device tracking
+        device = db.query(Device).filter(Device.device_id == vitals.device_id).first()
+        if not device:
+            device = Device(
+                device_id=vitals.device_id,
+                ip_address=vitals.ip_address or "remote-push",
+                status="active",
+                last_seen=now
+            )
+            db.add(device)
+        else:
+            if vitals.ip_address:
+                device.ip_address = vitals.ip_address
+            device.status = "active"
+            device.last_seen = now
+
+        # 2. Patient tracking
+        mrn = vitals.patient_id
+        patient = None
+        if mrn and mrn != "UNKNOWN":
+            patient = db.query(Patient).filter(or_(Patient.mrn == mrn, Patient.patient_id == mrn)).first()
+            if not patient:
+                patient = Patient(
+                    patient_id=mrn,
+                    mrn=mrn,
+                    name=vitals.patient_name or "Unknown",
+                    gender=vitals.patient_gender,
+                    dob=vitals.patient_dob,
+                    bed_id=vitals.bed_id,
+                    device_id=vitals.device_id
+                )
+                db.add(patient)
+            else:
+                if vitals.patient_name and vitals.patient_name != "Unknown":
+                    patient.name = vitals.patient_name
+                if vitals.patient_gender:
+                    patient.gender = vitals.patient_gender
+                if vitals.patient_dob:
+                    patient.dob = vitals.patient_dob
+                if vitals.bed_id:
+                    patient.bed_id = vitals.bed_id
+                patient.device_id = vitals.device_id
+        elif vitals.device_id:
+            # Check if there's already a patient assigned to this device
+            patient = db.query(Patient).filter(Patient.device_id == vitals.device_id, Patient.patient_id != "UNKNOWN").first()
+            if patient:
+                mrn = patient.mrn or patient.patient_id
+
+        # 3. Create VitalReading
+        reading = VitalReading(
+            device_id=vitals.device_id,
+            patient_id=mrn or "UNKNOWN",
+            timestamp=vitals.timestamp or now,
+            heart_rate=vitals.heart_rate,
+            spo2=vitals.spo2,
+            systolic_bp=vitals.systolic_bp,
+            diastolic_bp=vitals.diastolic_bp,
+            map_bp=vitals.map_bp,
+            respiratory_rate=vitals.respiratory_rate,
+            temperature=vitals.temperature,
+            temperature2=getattr(vitals, 'temperature2', None),
+            temperature_diff=getattr(vitals, 'temperature_diff', None),
+            transmitted=True
+        )
+        db.add(reading)
+        db.commit()
+        db.refresh(reading)
+
+        # 4. Broadcast to WebSocket clients
+        vitals_dict = vitals.model_dump(mode="json")
+        vitals_dict["mrn"] = mrn or (patient.mrn if patient else None)
+        vitals_dict["patient_id"] = vitals_dict["mrn"] or vitals.patient_id
+        vitals_dict["name"] = vitals.patient_name or (patient.name if patient else None)
+        vitals_dict["patient_name"] = vitals_dict["name"]
+        vitals_dict["gender"] = vitals.patient_gender or (patient.gender if patient else None)
+        vitals_dict["patient_gender"] = vitals_dict["gender"]
+        vitals_dict["dob"] = vitals.patient_dob or (patient.dob if patient else None)
+        vitals_dict["patient_dob"] = vitals_dict["dob"]
+        vitals_dict["bed_id"] = vitals.bed_id or (patient.bed_id if patient else None)
+        vitals_dict["patient_type"] = getattr(vitals, "patient_type", None)
+
+        await ws_manager.broadcast_vitals(vitals_dict)
+
+        return {
+            "status": "ok",
+            "reading_id": reading.id,
+            "device_id": vitals.device_id,
+            "patient_id": vitals_dict["patient_id"]
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Push-vitals error: {e}")
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Failed to store vitals: {str(e)}")
+

schemas.py

@@ -14,6 +14,8 @@ class NormalizedVitals(BaseModel):
     map_bp: Optional[float] = None
     respiratory_rate: Optional[float] = None
     temperature: Optional[float] = None
+    temperature2: Optional[float] = None
+    temperature_diff: Optional[float] = None
     present_fields: Optional[list] = None
     # Raw waveform sample arrays (8-bit unsigned, 0-255)
     ecg_wave:   Optional[List[int]] = None   # ECG waveform samples from 989-byte packet
@@ -23,6 +25,7 @@ class NormalizedVitals(BaseModel):
     patient_gender: Optional[str] = None   # PID-8: M / F / U
     patient_dob:    Optional[str] = None   # PID-7: YYYYMMDD
     bed_id:         Optional[str] = None   # PV1-3: bed / room ID
+    patient_type:   Optional[str] = None   # Patient category: Adult / Pediatric / Neonatal
 
 class DeviceStatus(BaseModel):
     device_id: str

setup_service.sh

@@ -5,11 +5,42 @@ set -e
 
 SERVICE_NAME="contec-forwarder"
 SERVICE_FILE="/etc/systemd/system/${SERVICE_NAME}.service"
-WORKING_DIR="/home/prathiyuman/Prathiyuman/ContecMonitor/fiveparaminte-main"
+
+# Auto-detect script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ -f "${SCRIPT_DIR}/main.py" ]; then
+    WORKING_DIR="${SCRIPT_DIR}"
+else
+    WORKING_DIR="${PWD}"
+fi
+
+echo "=== Detected Working Directory: ${WORKING_DIR} ==="
+
+# Ensure virtual environment exists
+if [ ! -f "${WORKING_DIR}/venv/bin/python" ]; then
+    echo "=== Virtual environment not found. Creating venv... ==="
+    python3 -m venv "${WORKING_DIR}/venv" || sudo apt-get update && sudo apt-get install -y python3-venv python3-pip && python3 -m venv "${WORKING_DIR}/venv"
+fi
+
 PYTHON_EXEC="${WORKING_DIR}/venv/bin/python"
 SCRIPT_PATH="${WORKING_DIR}/main.py"
 
-echo "=== Creating systemd service file ==="
+# Ensure dependencies are installed
+if [ -f "${WORKING_DIR}/requirements.txt" ]; then
+    echo "=== Installing/verifying dependencies ==="
+    "${WORKING_DIR}/venv/bin/pip" install --upgrade pip
+    "${WORKING_DIR}/venv/bin/pip" install -r "${WORKING_DIR}/requirements.txt"
+fi
+
+# Open firewall ports for Contec monitor (Port 511, 61501) and Web API (Port 8006)
+if command -v ufw >/dev/null 2>&1; then
+    echo "=== Configuring firewall (UFW) for Port 511, 61501, and 8006 ==="
+    sudo ufw allow 511/tcp comment "Contec Patient Monitor CMS TCP 511" || true
+    sudo ufw allow 61501/tcp comment "Contec Patient Monitor CMS TCP 61501" || true
+    sudo ufw allow 8006/tcp comment "Contec Forwarder HTTP API" || true
+fi
+
+echo "=== Creating systemd service file: ${SERVICE_FILE} ==="
 sudo bash -c "cat > ${SERVICE_FILE}" <<EOF
 [Unit]
 Description=Contec Patient Monitor Vital Signs Forwarder
@@ -20,6 +51,7 @@ Type=simple
 User=root
 WorkingDirectory=${WORKING_DIR}
 Environment=PORT=8006
+Environment=PYTHONPATH=${WORKING_DIR}
 ExecStart=${PYTHON_EXEC} ${SCRIPT_PATH}
 Restart=always
 RestartSec=5
@@ -36,7 +68,7 @@ sudo systemctl daemon-reload
 echo "=== Enabling ${SERVICE_NAME} to start on boot ==="
 sudo systemctl enable ${SERVICE_NAME}
 
-echo "=== Starting ${SERVICE_NAME} service ==="
+echo "=== Restarting ${SERVICE_NAME} service ==="
 sudo systemctl restart ${SERVICE_NAME}
 
 echo "=== Service Status ==="
@@ -45,6 +77,7 @@ sudo systemctl status ${SERVICE_NAME} --no-pager
 echo ""
 echo "=========================================================="
 echo "SUCCESS: Contec Forwarder is now running in the background!"
-echo "To check live service logs, run:"
-echo "  sudo journalctl -u contec-forwarder -f"
+echo "Port 511 is open and listening for the Contec physical monitor."
+echo "To check live logs, run:"
+echo "  sudo journalctl -u ${SERVICE_NAME} -f"
 echo "=========================================================="