e-mail entegration

Dockerfile.email

@@ -0,0 +1,43 @@
+# PULSE-7B Email ECG Processor Docker Container
+# Ubden® Team - Email-based ECG Analysis Service
+
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY email_ecg_processor.py .
+COPY start_email_processor.py .
+COPY utils.py .
+
+# Create logs directory
+RUN mkdir -p /app/logs
+
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+
+# Create non-root user
+RUN useradd --create-home --shell /bin/bash app
+RUN chown -R app:app /app
+USER app
+
+# Health check
+HEALTHCHECK --interval=5m --timeout=30s --start-period=1m --retries=3 \
+    CMD python -c "import email_ecg_processor; print('Service healthy')" || exit 1
+
+# Default command
+CMD ["python", "start_email_processor.py", "300"]

README.md

@@ -23,6 +23,8 @@ This repository provides a custom handler for deploying the **PULSE-7B** ECG ana
 
 **🚀 Enhanced with DeepSeek Integration**: This handler automatically translates PULSE-7B's English medical analysis into patient-friendly Turkish commentary using DeepSeek AI, providing bilingual ECG interpretation for Turkish healthcare professionals and patients.
 
+**📧 Automatic Email Processing**: When email configuration is provided, the system automatically processes ECG images sent via email and responds with analysis results, making it a complete email-to-analysis solution.
+
 ## 🚀 Quick Start
 
 ### Prerequisites
@@ -34,8 +36,9 @@ This repository provides a custom handler for deploying the **PULSE-7B** ECG ana
 
 ```
 pulse-hf/
-├── handler.py              # Custom inference handler with DeepSeek integration
+├── handler.py              # Custom inference handler with auto email processing
 ├── utils.py                # Performance monitoring and DeepSeek client
+├── email_ecg_processor.py  # Email processing module (auto-loaded by handler)
 ├── requirements.txt        # Python dependencies
 ├── generation_config.json  # Model generation configuration
 ├── test_requests.json      # Example request templates
@@ -68,17 +71,26 @@ pulse-hf/
 4. Click **"Create Endpoint"**
 5. Wait for the status to change from `Building` → `Initializing` → `Running`
 
-### Step 3: Configure DeepSeek API Key (Optional)
-
-To enable Turkish commentary feature:
+### Step 3: Configure Environment Variables
 
+#### 3.1 DeepSeek API Key (Optional - for Turkish commentary)
 1. Go to your endpoint's **"Environment"** tab
 2. In **"Secret Env"** section, add:
    - **Key**: `deep_key`
    - **Value**: Your DeepSeek API key
+
+#### 3.2 Email Processing (Optional - for automatic email processing)
+Add these additional environment variables:
+   - **Key**: `mail_host` | **Value**: `imap.gmail.com` (or your email provider)
+   - **Key**: `mail_username` | **Value**: Your email address
+   - **Key**: `mail_pw` | **Value**: Your email app password
+   - **Key**: `hf_key` | **Value**: Your HuggingFace token
+
 3. Click **"Update Endpoint"**
 
-**Note**: Without this configuration, the endpoint will work but without Turkish commentary.
+**Note**: 
+- Without DeepSeek key: Works but no Turkish commentary
+- Without email config: Works but no automatic email processing
 
 ### Step 4: Get Your Endpoint URL
 

docker-compose.email.yml

@@ -0,0 +1,78 @@
+version: '3.8'
+
+services:
+  pulse-email-processor:
+    build:
+      context: .
+      dockerfile: Dockerfile.email
+    container_name: pulse-ecg-email-processor
+    restart: unless-stopped
+    
+    environment:
+      # Email Configuration (Required)
+      - mail_host=${MAIL_HOST:-imap.gmail.com}
+      - mail_username=${MAIL_USERNAME}
+      - mail_pw=${MAIL_PASSWORD}
+      
+      # HuggingFace Configuration (Required)
+      - hf_key=${HF_TOKEN}
+      - PULSE_ENDPOINT_URL=${PULSE_ENDPOINT_URL}
+      
+      # DeepSeek Configuration (Optional)
+      - deep_key=${DEEPSEEK_API_KEY}
+      
+      # Processing Configuration
+      - CHECK_INTERVAL=${CHECK_INTERVAL:-300}
+      - LOG_LEVEL=${LOG_LEVEL:-INFO}
+    
+    volumes:
+      # Persist logs
+      - ./logs:/app/logs
+      
+      # Optional: Mount config files
+      - ./config:/app/config:ro
+    
+    # Resource limits
+    deploy:
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 512M
+        reservations:
+          cpus: '0.1'
+          memory: 128M
+    
+    # Health check
+    healthcheck:
+      test: ["CMD", "python", "-c", "import email_ecg_processor; print('healthy')"]
+      interval: 5m
+      timeout: 30s
+      retries: 3
+      start_period: 1m
+    
+    # Logging
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+# Optional: Add monitoring service
+  pulse-monitor:
+    image: prom/prometheus:latest
+    container_name: pulse-ecg-monitor
+    restart: unless-stopped
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro
+    profiles:
+      - monitoring
+
+volumes:
+  logs:
+    driver: local
+
+networks:
+  default:
+    name: pulse-ecg-network

email_ecg_processor.py

@@ -0,0 +1,532 @@
+"""
+PULSE-7B Email ECG Processor
+Ubden® Team - Email-based ECG Analysis System
+Automatically processes ECG images from emails and sends Turkish commentary
+"""
+
+import imaplib
+import smtplib
+import email
+import base64
+import os
+import time
+import re
+import requests
+from datetime import datetime
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.mime.image import MIMEImage
+from email.header import decode_header
+from typing import Dict, List, Any, Optional, Tuple
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('ecg_email_processor.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+class EmailECGProcessor:
+    """Email-based ECG analysis processor with retry logic and error handling"""
+    
+    def __init__(self):
+        """Initialize with environment variables"""
+        self.mail_host = os.getenv('mail_host', 'imap.gmail.com')
+        self.mail_username = os.getenv('mail_username')
+        self.mail_password = os.getenv('mail_pw')
+        self.hf_token = os.getenv('hf_key')
+        self.deepseek_key = os.getenv('deep_key')
+        
+        # PULSE endpoint configuration
+        self.endpoint_url = self._get_endpoint_url()
+        
+        # Email configuration
+        self.smtp_host = self.mail_host.replace('imap', 'smtp')
+        self.smtp_port = 587
+        self.imap_port = 993
+        
+        # Processing configuration
+        self.max_retries = 3
+        self.retry_delay = 60  # 1 minute
+        self.max_wait_time = 300  # 5 minutes for cold start
+        
+        # Supported image formats for ECG detection
+        self.supported_image_formats = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff']
+        
+        self._validate_configuration()
+        logger.info("📧 Email ECG Processor initialized successfully")
+    
+    def _get_endpoint_url(self) -> str:
+        """Get endpoint URL from environment or construct from HF space"""
+        # Try direct endpoint URL first
+        endpoint_url = os.getenv('PULSE_ENDPOINT_URL')
+        if endpoint_url:
+            return endpoint_url
+        
+        # Try to construct from HF space name
+        hf_space = os.getenv('HF_SPACE_NAME')
+        if hf_space:
+            return f"https://{hf_space}.hf.space"
+        
+        # If running as part of HF Inference Endpoint, try to detect automatically
+        hf_endpoint_name = os.getenv('ENDPOINT_NAME')
+        hf_region = os.getenv('AWS_DEFAULT_REGION', 'us-east-1')
+        if hf_endpoint_name:
+            return f"https://{hf_endpoint_name}.{hf_region}.aws.endpoints.huggingface.cloud"
+        
+        # Last resort - try localhost (for development)
+        if os.getenv('DEVELOPMENT_MODE'):
+            return "http://localhost:8000"
+        
+        raise ValueError("PULSE_ENDPOINT_URL, HF_SPACE_NAME, or ENDPOINT_NAME must be set in environment variables")
+    
+    def _validate_configuration(self):
+        """Validate required environment variables"""
+        required_vars = {
+            'mail_username': self.mail_username,
+            'mail_pw': self.mail_password,
+            'hf_key': self.hf_token
+        }
+        
+        missing_vars = [var for var, value in required_vars.items() if not value]
+        if missing_vars:
+            raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")
+        
+        logger.info("✅ Configuration validation passed")
+    
+    def connect_to_email(self) -> imaplib.IMAP4_SSL:
+        """Connect to email server"""
+        try:
+            mail = imaplib.IMAP4_SSL(self.mail_host, self.imap_port)
+            mail.login(self.mail_username, self.mail_password)
+            mail.select('INBOX')
+            logger.info(f"📧 Connected to email server: {self.mail_host}")
+            return mail
+        except Exception as e:
+            logger.error(f"❌ Failed to connect to email server: {e}")
+            raise
+    
+    def get_unread_emails(self, mail: imaplib.IMAP4_SSL) -> List[str]:
+        """Get list of unread email IDs"""
+        try:
+            # Search for unread emails
+            _, messages = mail.search(None, 'UNSEEN')
+            message_ids = messages[0].split() if messages[0] else []
+            logger.info(f"📬 Found {len(message_ids)} unread emails")
+            return message_ids
+        except Exception as e:
+            logger.error(f"❌ Failed to get unread emails: {e}")
+            return []
+    
+    def parse_email(self, mail: imaplib.IMAP4_SSL, message_id: str) -> Optional[Dict[str, Any]]:
+        """Parse email and extract relevant information"""
+        try:
+            _, msg_data = mail.fetch(message_id, '(RFC822)')
+            email_body = msg_data[0][1]
+            email_message = email.message_from_bytes(email_body)
+            
+            # Extract email headers
+            subject = decode_header(email_message['subject'])[0][0]
+            if isinstance(subject, bytes):
+                subject = subject.decode()
+            
+            sender = email_message['from']
+            date = email_message['date']
+            
+            # Extract body and attachments
+            body_text = ""
+            attachments = []
+            
+            if email_message.is_multipart():
+                for part in email_message.walk():
+                    if part.get_content_maintype() == 'multipart':
+                        continue
+                    elif part.get_content_maintype() == 'text':
+                        charset = part.get_content_charset() or 'utf-8'
+                        try:
+                            body_text += part.get_payload(decode=True).decode(charset)
+                        except:
+                            body_text += part.get_payload(decode=True).decode('utf-8', errors='ignore')
+                    elif part.get_content_maintype() == 'image':
+                        filename = part.get_filename()
+                        if filename and self._is_supported_image(filename):
+                            image_data = part.get_payload(decode=True)
+                            attachments.append({
+                                'filename': filename,
+                                'data': image_data,
+                                'content_type': part.get_content_type()
+                            })
+            else:
+                charset = email_message.get_content_charset() or 'utf-8'
+                try:
+                    body_text = email_message.get_payload(decode=True).decode(charset)
+                except:
+                    body_text = email_message.get_payload(decode=True).decode('utf-8', errors='ignore')
+            
+            return {
+                'message_id': message_id,
+                'subject': subject,
+                'sender': sender,
+                'date': date,
+                'body': body_text,
+                'attachments': attachments
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to parse email {message_id}: {e}")
+            return None
+    
+    def _is_supported_image(self, filename: str) -> bool:
+        """Check if the image has a supported format"""
+        filename_lower = filename.lower()
+        is_supported = any(filename_lower.endswith(ext) for ext in self.supported_image_formats)
+        
+        logger.info(f"🔍 Image format check for '{filename}': {is_supported}")
+        return is_supported
+    
+    def analyze_ecg_with_retry(self, image_data: bytes, query: str, content_type: str) -> Dict[str, Any]:
+        """Analyze ECG image with retry logic for cold start handling"""
+        start_time = time.time()
+        
+        for attempt in range(self.max_retries):
+            try:
+                logger.info(f"🔄 Analysis attempt {attempt + 1}/{self.max_retries}")
+                
+                # Convert image to base64
+                image_base64 = base64.b64encode(image_data).decode('utf-8')
+                mime_type = content_type or 'image/jpeg'
+                base64_string = f"data:{mime_type};base64,{image_base64}"
+                
+                # Prepare payload
+                payload = {
+                    "inputs": {
+                        "query": query,
+                        "image": base64_string
+                    },
+                    "parameters": {
+                        "max_new_tokens": 512,
+                        "temperature": 0.2,
+                        "top_p": 0.9,
+                        "repetition_penalty": 1.05,
+                        "enable_turkish_commentary": True,
+                        "deepseek_timeout": 30
+                    }
+                }
+                
+                headers = {
+                    "Authorization": f"Bearer {self.hf_token}",
+                    "Content-Type": "application/json"
+                }
+                
+                # Make request
+                response = requests.post(
+                    self.endpoint_url,
+                    headers=headers,
+                    json=payload,
+                    timeout=120
+                )
+                
+                if response.status_code == 200:
+                    result = response.json()[0]
+                    elapsed_time = time.time() - start_time
+                    logger.info(f"✅ ECG analysis completed in {elapsed_time:.1f} seconds")
+                    return result
+                    
+                elif response.status_code == 503:
+                    # Service Unavailable - Cold start
+                    elapsed_time = time.time() - start_time
+                    if elapsed_time < self.max_wait_time and attempt < self.max_retries - 1:
+                        wait_time = min(self.retry_delay, self.max_wait_time - elapsed_time)
+                        logger.info(f"⏳ Endpoint cold start detected. Waiting {wait_time} seconds...")
+                        time.sleep(wait_time)
+                        continue
+                    else:
+                        raise Exception("Endpoint startup timeout")
+                        
+                else:
+                    raise Exception(f"HTTP {response.status_code}: {response.text}")
+                    
+            except requests.exceptions.Timeout:
+                logger.warning(f"⏰ Request timeout on attempt {attempt + 1}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+                    continue
+                else:
+                    raise Exception("Analysis timeout after all retries")
+                    
+            except Exception as e:
+                logger.error(f"❌ Analysis error on attempt {attempt + 1}: {e}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+                    continue
+                else:
+                    raise
+        
+        raise Exception("Analysis failed after all retry attempts")
+    
+    def send_analysis_result(self, recipient: str, original_subject: str, 
+                           filename: str, analysis_result: Dict[str, Any]) -> bool:
+        """Send analysis result via email"""
+        try:
+            msg = MIMEMultipart()
+            msg['From'] = self.mail_username
+            msg['To'] = recipient
+            msg['Subject'] = f"🏥 EKG Sonucunuz: {filename}"
+            
+            # Extract sender name for personalization
+            sender_name = recipient.split('@')[0].title()
+            
+            # Prepare email body
+            english_analysis = analysis_result.get('generated_text', 'Analysis not available')
+            turkish_commentary = analysis_result.get('comment_text', 'Türkçe yorum mevcut değil')
+            
+            # Format the email body
+            body = f"""
+Sayın {sender_name},
+
+EKG görüntünüzün analizi tamamlanmıştır. Aşağıda detaylı sonuçları bulabilirsiniz:
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🔬 **İNGİLİZCE TEKNİK ANALİZ:**
+{english_analysis}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+{turkish_commentary}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+⚠️  **ÖNEMLİ UYARI:**
+Bu analiz sadece bilgilendirme amaçlıdır ve kesinlikle tıbbi tanı yerine geçmez. 
+Kesin tanı ve tedavi için mutlaka bir kardiyoloji uzmanına başvurunuz.
+
+🏥 **ACİL DURUMLARDA:**
+Göğüs ağrısı, nefes darlığı, çarpıntı gibi şikayetleriniz varsa 
+derhal en yakın acil servise başvurunuz veya 112'yi arayınız.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📊 **Analiz Detayları:**
+• Dosya: {filename}
+• Tarih: {datetime.now().strftime('%d.%m.%Y %H:%M')}
+• Model: PULSE-7B + DeepSeek AI
+• İşlem Durumu: {analysis_result.get('commentary_status', 'Başarılı')}
+
+Geçmiş olsun! 🙏
+
+---
+🤖 Bu e-posta PULSE-7B EKG Analiz Sistemi tarafından otomatik olarak gönderilmiştir.
+💡 Ubden® Team - AI-Powered Healthcare Solutions
+            """
+            
+            msg.attach(MIMEText(body, 'plain', 'utf-8'))
+            
+            # Send email
+            server = smtplib.SMTP(self.smtp_host, self.smtp_port)
+            server.starttls()
+            server.login(self.mail_username, self.mail_password)
+            server.send_message(msg)
+            server.quit()
+            
+            logger.info(f"✅ Analysis result sent to {recipient}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to send analysis result to {recipient}: {e}")
+            return False
+    
+    def send_error_notification(self, recipient: str, original_subject: str, 
+                              filename: str, error_message: str) -> bool:
+        """Send error notification via email"""
+        try:
+            msg = MIMEMultipart()
+            msg['From'] = self.mail_username
+            msg['To'] = recipient
+            msg['Subject'] = f"⚠️ EKG Analizi Hatası: {filename}"
+            
+            sender_name = recipient.split('@')[0].title()
+            
+            body = f"""
+Sayın {sender_name},
+
+Maalesef EKG görüntünüzün analizi sırasında bir hata oluştu.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📋 **Hata Detayları:**
+• Dosya: {filename}
+• Hata: {error_message}
+• Tarih: {datetime.now().strftime('%d.%m.%Y %H:%M')}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🔧 **Olası Çözümler:**
+1. EKG görüntüsünün net ve okunaklı olduğundan emin olun
+2. Desteklenen dosya formatlarını kullanın (JPG, PNG, GIF, BMP)
+3. Dosya boyutunun 10MB'dan küçük olduğundan emin olun
+4. Birkaç dakika sonra tekrar deneyin (sistem başlatılıyor olabilir)
+
+🔄 **Tekrar Deneme:**
+EKG görüntünüzü yeniden gönderebilirsiniz. Sistem otomatik olarak işleme alacaktır.
+
+📞 **Destek:**
+Problem devam ederse lütfen sistem yöneticisi ile iletişime geçin.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Özür dileriz! 🙏
+
+---
+🤖 Bu e-posta PULSE-7B EKG Analiz Sistemi tarafından otomatik olarak gönderilmiştir.
+💡 Ubden® Team - AI-Powered Healthcare Solutions
+            """
+            
+            msg.attach(MIMEText(body, 'plain', 'utf-8'))
+            
+            server = smtplib.SMTP(self.smtp_host, self.smtp_port)
+            server.starttls()
+            server.login(self.mail_username, self.mail_password)
+            server.send_message(msg)
+            server.quit()
+            
+            logger.info(f"📧 Error notification sent to {recipient}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to send error notification to {recipient}: {e}")
+            return False
+    
+    def mark_as_read(self, mail: imaplib.IMAP4_SSL, message_id: str) -> bool:
+        """Mark email as read"""
+        try:
+            mail.store(message_id, '+FLAGS', '\\Seen')
+            logger.info(f"📖 Email {message_id} marked as read")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Failed to mark email {message_id} as read: {e}")
+            return False
+    
+    def process_single_email(self, mail: imaplib.IMAP4_SSL, message_id: str) -> bool:
+        """Process a single email"""
+        logger.info(f"📧 Processing email {message_id}")
+        
+        try:
+            # Parse email
+            email_data = self.parse_email(mail, message_id)
+            if not email_data:
+                logger.warning(f"⚠️ Failed to parse email {message_id}")
+                return False
+            
+            logger.info(f"📬 Email from: {email_data['sender']}, Subject: {email_data['subject']}")
+            
+            # Process image attachments (assuming they are ECG images)
+            processed_any = False
+            for attachment in email_data['attachments']:
+                logger.info(f"🖼️ Processing image attachment: {attachment['filename']}")
+                
+                try:
+                    # Analyze image as ECG
+                    query = f"Analyze this ECG image from email. Subject: {email_data['subject']}. Context: {email_data['body'][:200]}..."
+                    
+                    analysis_result = self.analyze_ecg_with_retry(
+                        attachment['data'],
+                        query,
+                        attachment['content_type']
+                    )
+                    
+                    # Send result
+                    success = self.send_analysis_result(
+                        email_data['sender'],
+                        email_data['subject'],
+                        attachment['filename'],
+                        analysis_result
+                    )
+                    
+                    if success:
+                        processed_any = True
+                        logger.info(f"✅ Successfully processed {attachment['filename']}")
+                    
+                except Exception as e:
+                    logger.error(f"❌ Failed to analyze {attachment['filename']}: {e}")
+                    
+                    # Send error notification
+                    self.send_error_notification(
+                        email_data['sender'],
+                        email_data['subject'],
+                        attachment['filename'],
+                        str(e)
+                    )
+            
+            # Mark as read if we processed any attachments
+            if processed_any:
+                self.mark_as_read(mail, message_id)
+                return True
+            elif not email_data['attachments']:
+                # No image attachments found, mark as read to avoid reprocessing
+                logger.info(f"📭 No image attachments found in email {message_id}")
+                self.mark_as_read(mail, message_id)
+                return True
+            else:
+                logger.warning(f"⚠️ Failed to process any attachments in email {message_id}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ Error processing email {message_id}: {e}")
+            return False
+    
+    def run_email_processor(self, check_interval: int = 300) -> None:
+        """Main email processing loop"""
+        logger.info(f"🚀 Starting Email ECG Processor (check interval: {check_interval}s)")
+        
+        while True:
+            try:
+                logger.info("🔄 Checking for new emails...")
+                
+                # Connect to email
+                mail = self.connect_to_email()
+                
+                # Get unread emails
+                unread_emails = self.get_unread_emails(mail)
+                
+                if unread_emails:
+                    logger.info(f"📬 Processing {len(unread_emails)} unread emails")
+                    
+                    for message_id in unread_emails:
+                        self.process_single_email(mail, message_id)
+                        time.sleep(2)  # Brief pause between emails
+                else:
+                    logger.info("📭 No unread emails found")
+                
+                # Close connection
+                mail.close()
+                mail.logout()
+                
+                # Wait for next check
+                logger.info(f"⏰ Waiting {check_interval} seconds until next check...")
+                time.sleep(check_interval)
+                
+            except KeyboardInterrupt:
+                logger.info("🛑 Email processor stopped by user")
+                break
+            except Exception as e:
+                logger.error(f"❌ Error in main loop: {e}")
+                logger.info(f"⏰ Waiting {check_interval} seconds before retry...")
+                time.sleep(check_interval)
+
+def main():
+    """Main function to run the email processor"""
+    try:
+        processor = EmailECGProcessor()
+        processor.run_email_processor(check_interval=300)  # Check every 5 minutes
+    except Exception as e:
+        logger.error(f"❌ Failed to start email processor: {e}")
+        raise
+
+if __name__ == "__main__":
+    main()

handler.py

@@ -11,6 +11,8 @@ from io import BytesIO
 from PIL import Image
 import requests
 import time
+import threading
+import os
 
 # Import utilities if available
 try:
@@ -28,6 +30,16 @@ except ImportError:
     deepseek_client = None
     print("⚠️ Utils module not found - performance monitoring and DeepSeek integration disabled")
 
+# Import email processor if available
+try:
+    from email_ecg_processor import EmailECGProcessor
+    EMAIL_PROCESSOR_AVAILABLE = True
+    print("📧 Email ECG Processor module found - email processing will be enabled")
+except ImportError:
+    EMAIL_PROCESSOR_AVAILABLE = False
+    EmailECGProcessor = None
+    print("📭 Email ECG Processor module not found - email processing disabled")
+
 
 class EndpointHandler:
     def __init__(self, path=""):
@@ -45,6 +57,11 @@ class EndpointHandler:
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         print(f"🖥️ Running on: {self.device}")
         
+        # Initialize email processor
+        self.email_processor = None
+        self.email_thread = None
+        self._init_email_processor()
+        
         try:
             # First attempt - using pipeline (easiest and most stable way)
             from transformers import pipeline
@@ -107,6 +124,47 @@ class EndpointHandler:
         else:
             self.use_pipeline = True
 
+    def _init_email_processor(self):
+        """Initialize email processor in background thread"""
+        if not EMAIL_PROCESSOR_AVAILABLE:
+            print("📭 Email processor not available - skipping email initialization")
+            return
+        
+        # Check if email configuration is available
+        required_email_vars = ['mail_username', 'mail_pw', 'hf_key']
+        missing_vars = [var for var in required_email_vars if not os.getenv(var)]
+        
+        if missing_vars:
+            print(f"📭 Email processor disabled - missing environment variables: {', '.join(missing_vars)}")
+            return
+        
+        try:
+            print("📧 Initializing email processor...")
+            self.email_processor = EmailECGProcessor()
+            
+            # Start email processor in background thread
+            self.email_thread = threading.Thread(
+                target=self._run_email_processor,
+                daemon=True,
+                name="EmailProcessor"
+            )
+            self.email_thread.start()
+            print("✅ Email processor started successfully in background thread")
+            
+        except Exception as e:
+            print(f"❌ Failed to initialize email processor: {e}")
+            self.email_processor = None
+            self.email_thread = None
+    
+    def _run_email_processor(self):
+        """Run email processor in background thread"""
+        try:
+            if self.email_processor:
+                print("📧 Email processor thread started - checking emails every 5 minutes")
+                self.email_processor.run_email_processor(check_interval=300)
+        except Exception as e:
+            print(f"❌ Email processor thread error: {e}")
+
     def process_image_input(self, image_input):
         """
         Handle both URL and base64 image inputs like a champ!
@@ -229,14 +287,36 @@ class EndpointHandler:
     def health_check(self) -> Dict[str, Any]:
         """Health check endpoint"""
         if UTILS_AVAILABLE:
-            return create_health_check()
+            health = create_health_check()
         else:
-            return {
+            health = {
                 'status': 'healthy',
                 'model': 'PULSE-7B',
                 'timestamp': time.time(),
                 'handler_version': '2.0.0'
             }
+        
+        # Add email processor status
+        if EMAIL_PROCESSOR_AVAILABLE and self.email_processor:
+            health['email_processor'] = {
+                'status': 'running',
+                'thread_alive': self.email_thread.is_alive() if self.email_thread else False,
+                'configuration': 'configured'
+            }
+        elif EMAIL_PROCESSOR_AVAILABLE:
+            health['email_processor'] = {
+                'status': 'available_but_not_configured',
+                'thread_alive': False,
+                'configuration': 'missing_environment_variables'
+            }
+        else:
+            health['email_processor'] = {
+                'status': 'not_available',
+                'thread_alive': False,
+                'configuration': 'module_not_found'
+            }
+        
+        return health
 
     def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
         """

requirements.txt

@@ -19,4 +19,8 @@ typing-extensions>=4.0.0
 psutil>=5.8.0
 
 # HuggingFace Inference specific
-huggingface-hub>=0.16.0
+huggingface-hub>=0.16.0
+
+# Email processing dependencies
+email-validator>=2.0.0
+chardet>=5.0.0

start_email_processor.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+PULSE-7B Email ECG Processor Starter
+Ubden® Team - Email processor başlatıcı script
+"""
+
+import os
+import sys
+import signal
+import logging
+from email_ecg_processor import EmailECGProcessor
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class EmailProcessorService:
+    """Email processor service wrapper"""
+    
+    def __init__(self):
+        self.processor = None
+        self.running = False
+        
+        # Register signal handlers
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+    
+    def _signal_handler(self, signum, frame):
+        """Handle shutdown signals"""
+        logger.info(f"📡 Received signal {signum}, shutting down gracefully...")
+        self.running = False
+        sys.exit(0)
+    
+    def check_environment(self):
+        """Check required environment variables"""
+        required_vars = [
+            'mail_host',
+            'mail_username', 
+            'mail_pw',
+            'hf_key'
+        ]
+        
+        optional_vars = [
+            'deep_key',
+            'PULSE_ENDPOINT_URL',
+            'HF_SPACE_NAME'
+        ]
+        
+        logger.info("🔍 Checking environment configuration...")
+        
+        # Check required variables
+        missing_required = []
+        for var in required_vars:
+            if not os.getenv(var):
+                missing_required.append(var)
+            else:
+                logger.info(f"✅ {var}: {'*' * len(os.getenv(var))}")
+        
+        if missing_required:
+            logger.error(f"❌ Missing required environment variables: {', '.join(missing_required)}")
+            logger.info("\n📋 Required Environment Variables:")
+            logger.info("• mail_host: Email server (e.g., imap.gmail.com)")
+            logger.info("• mail_username: Email username")
+            logger.info("• mail_pw: Email password (App Password for Gmail)")
+            logger.info("• hf_key: HuggingFace API token")
+            logger.info("\n📋 Optional Environment Variables:")
+            logger.info("• deep_key: DeepSeek API key (for Turkish commentary)")
+            logger.info("• PULSE_ENDPOINT_URL: Direct endpoint URL")
+            logger.info("• HF_SPACE_NAME: HuggingFace space name")
+            return False
+        
+        # Check optional variables
+        for var in optional_vars:
+            value = os.getenv(var)
+            if value:
+                logger.info(f"✅ {var}: {'*' * min(len(value), 10)}")
+            else:
+                logger.warning(f"⚠️ {var}: Not set (optional)")
+        
+        return True
+    
+    def start(self, check_interval: int = 300):
+        """Start the email processor service"""
+        logger.info("🚀 Starting PULSE-7B Email ECG Processor Service")
+        logger.info("━" * 60)
+        
+        # Check environment
+        if not self.check_environment():
+            logger.error("❌ Environment check failed")
+            return False
+        
+        logger.info("━" * 60)
+        
+        try:
+            # Initialize processor
+            self.processor = EmailECGProcessor()
+            self.running = True
+            
+            logger.info(f"📧 Email processor initialized successfully")
+            logger.info(f"⏰ Check interval: {check_interval} seconds")
+            logger.info("🔄 Starting email monitoring...")
+            logger.info("━" * 60)
+            
+            # Start processing
+            self.processor.run_email_processor(check_interval)
+            
+        except KeyboardInterrupt:
+            logger.info("🛑 Service stopped by user")
+        except Exception as e:
+            logger.error(f"❌ Service error: {e}")
+            return False
+        finally:
+            logger.info("🔚 Email processor service stopped")
+            
+        return True
+
+def print_usage():
+    """Print usage information"""
+    print("""
+🏥 PULSE-7B Email ECG Processor Service
+
+Usage:
+    python start_email_processor.py [check_interval]
+
+Arguments:
+    check_interval    Check interval in seconds (default: 300 = 5 minutes)
+
+Examples:
+    python start_email_processor.py           # Check every 5 minutes
+    python start_email_processor.py 60        # Check every 1 minute
+    python start_email_processor.py 900       # Check every 15 minutes
+
+Environment Variables Required:
+    mail_host         Email IMAP server (e.g., imap.gmail.com)
+    mail_username     Email username
+    mail_pw          Email password (App Password for Gmail)
+    hf_key           HuggingFace API token
+
+Environment Variables Optional:
+    deep_key         DeepSeek API key (for Turkish commentary)
+    PULSE_ENDPOINT_URL  Direct endpoint URL
+    HF_SPACE_NAME    HuggingFace space name
+
+Gmail Setup:
+    1. Enable 2-Factor Authentication
+    2. Generate App Password: Google Account → Security → App passwords
+    3. Use App Password as mail_pw (not your regular password)
+
+HuggingFace Setup:
+    1. Create API token: HuggingFace → Settings → Access Tokens
+    2. Deploy PULSE-7B endpoint with this handler
+    3. Add DeepSeek API key to endpoint environment (deep_key)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💡 Ubden® Team - AI-Powered Healthcare Solutions
+    """)
+
+def main():
+    """Main function"""
+    # Parse command line arguments
+    check_interval = 300  # Default 5 minutes
+    
+    if len(sys.argv) > 1:
+        if sys.argv[1] in ['-h', '--help', 'help']:
+            print_usage()
+            return
+        
+        try:
+            check_interval = int(sys.argv[1])
+            if check_interval < 30:
+                logger.warning("⚠️ Check interval too low, setting to minimum 30 seconds")
+                check_interval = 30
+            elif check_interval > 3600:
+                logger.warning("⚠️ Check interval too high, setting to maximum 1 hour")
+                check_interval = 3600
+        except ValueError:
+            logger.error("❌ Invalid check interval. Must be a number in seconds.")
+            print_usage()
+            return
+    
+    # Start service
+    service = EmailProcessorService()
+    service.start(check_interval)
+
+if __name__ == "__main__":
+    main()