Medical Device Integration: IoT, Real-Time Monitoring, and Data Ingestion

from datetime import datetime
from typing import Dict, List
import json

class MedicalDeviceManager:
    """Manage medical devices"""
    
    def __init__(self, db_connection):
        self.db = db_connection
        self.devices = {}
    
    def register_device(self, device_id: str, device_type: str,
                       patient_id: str, location: str) -> dict:
        """Register medical device"""
        
        device = {
            'device_id': device_id,
            'device_type': device_type,
            'patient_id': patient_id,
            'location': location,
            'status': 'active',
            'registered_at': datetime.now(),
            'last_reading': None,
            'battery_level': 100
        }
        
        self.db.insert('medical_devices', device)
        self.devices[device_id] = device
        
        return device
    
    def ingest_reading(self, device_id: str, reading: Dict) -> dict:
        """Ingest device reading"""
        
        if device_id not in self.devices:
            return {'success': False, 'error': 'Device not found'}
        
        # Validate reading
        if not self._validate_reading(reading):
            return {'success': False, 'error': 'Invalid reading'}
        
        # Store reading
        self.db.insert('device_readings', {
            'device_id': device_id,
            'reading_type': reading['type'],
            'value': reading['value'],
            'unit': reading['unit'],
            'timestamp': datetime.now(),
            'quality': reading.get('quality', 'good')
        })
        
        # Check for alerts
        alerts = self._check_alerts(device_id, reading)
        
        return {
            'success': True,
            'alerts': alerts
        }
    
    def _validate_reading(self, reading: Dict) -> bool:
        """Validate device reading"""
        
        required_fields = ['type', 'value', 'unit']
        
        for field in required_fields:
            if field not in reading:
                return False
        
        # Validate value range
        if reading['type'] == 'heart_rate':
            return 30 <= reading['value'] <= 200
        elif reading['type'] == 'blood_pressure':
            return 40 <= reading['value'] <= 250
        elif reading['type'] == 'temperature':
            return 95 <= reading['value'] <= 105
        
        return True
    
    def _check_alerts(self, device_id: str, reading: Dict) -> List[dict]:
        """Check for clinical alerts"""
        
        alerts = []
        
        # Heart rate alert
        if reading['type'] == 'heart_rate':
            if reading['value'] < 40 or reading['value'] > 120:
                alerts.append({
                    'type': 'abnormal_heart_rate',
                    'severity': 'high',
                    'value': reading['value']
                })
        
        # Temperature alert
        elif reading['type'] == 'temperature':
            if reading['value'] > 101.5:
                alerts.append({
                    'type': 'fever',
                    'severity': 'medium',
                    'value': reading['value']
                })
        
        return alerts

# Usage
device_manager = MedicalDeviceManager(db)

# Register device
device = device_manager.register_device(
    device_id='pulse_ox_001',
    device_type='pulse_oximeter',
    patient_id='patient_123',
    location='ICU_Room_101'
)

# Ingest reading
result = device_manager.ingest_reading('pulse_ox_001', {
    'type': 'heart_rate',
    'value': 85,
    'unit': 'bpm',
    'quality': 'good'
})

class RealTimeMonitor:
    """Real-time health monitoring"""
    
    def __init__(self, db_connection):
        self.db = db_connection
        self.thresholds = {
            'heart_rate': {'min': 40, 'max': 120},
            'blood_pressure': {'min': 60, 'max': 180},
            'temperature': {'min': 95, 'max': 101.5}
        }
    
    def monitor_patient(self, patient_id: str) -> dict:
        """Monitor patient health"""
        
        # Get latest readings
        readings = self.db.query(
            """SELECT * FROM device_readings 
               WHERE device_id IN (SELECT device_id FROM medical_devices WHERE patient_id = ?)
               ORDER BY timestamp DESC LIMIT 10""",
            (patient_id,)
        )
        
        # Analyze readings
        status = 'normal'
        alerts = []
        
        for reading in readings:
            threshold = self.thresholds.get(reading['reading_type'])
            
            if threshold:
                if reading['value'] < threshold['min'] or reading['value'] > threshold['max']:
                    status = 'abnormal'
                    alerts.append({
                        'type': reading['reading_type'],
                        'value': reading['value'],
                        'threshold': threshold
                    })
        
        return {
            'patient_id': patient_id,
            'status': status,
            'alerts': alerts,
            'readings': readings
        }

# Usage
monitor = RealTimeMonitor(db)
status = monitor.monitor_patient('patient_123')