Converted to pure FastAPI with beautiful web interface - Flutter compatible

Dockerfile

@@ -8,7 +8,6 @@ WORKDIR /app
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
-    software-properties-common \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements and install Python dependencies
@@ -18,11 +17,11 @@ RUN pip install --no-cache-dir -r requirements.txt
 # Copy application files
 COPY . .
 
-# Expose port
+# Expose port 7860 (Hugging Face Spaces default)
 EXPOSE 7860
 
 # Health check
-HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
+HEALTHCHECK CMD curl --fail http://localhost:7860/health
 
-# Run the application
-CMD ["python", "app.py"]
+# Run the FastAPI application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,19 +1,18 @@
 ---
-title: Lab Report Analysis AI
+title: Lab Report Analysis API
 emoji: 🏥
 colorFrom: blue
 colorTo: green
-sdk: gradio
-sdk_version: 4.44.0
-app_file: app.py
+sdk: docker
+app_port: 7860
 pinned: false
 license: apache-2.0
-short_description: AI-powered lab report analysis using Google AI Studio
+short_description: AI-powered lab report analysis API using Google AI Studio
 ---
 
-# 🏥 Lab Report Analysis AI
+# 🏥 Lab Report Analysis API
 
-An intelligent lab report analysis system that uses Google AI Studio's Gemini model to analyze medical lab reports and provide structured interpretations.
+A powerful FastAPI-based web service for analyzing medical lab reports using Google AI Studio's Gemini model. Provides both a beautiful web interface and REST API endpoints for programmatic access.
 
 ## ✨ Features
 
@@ -22,26 +21,65 @@ An intelligent lab report analysis system that uses Google AI Studio's Gemini mo
 - 📊 **Structured Output**: Provides organized summary, key findings, and interpretations
 - ⚡ **Fast Processing**: Quick analysis with real-time results
 - 🔒 **Secure**: Images are processed securely and not stored
-- 🌐 **Web Interface**: Easy-to-use Gradio interface
+- 🌐 **Web Interface**: Beautiful HTML interface for manual testing
+- 📱 **Flutter Compatible**: Full REST API support for mobile apps
 
 ## 🚀 How to Use
 
-1. **Upload Image**: Click on the upload area and select your lab report image
-2. **Analyze**: Click the "Analyze Report" button
-3. **Review Results**: Get structured analysis with:
-   - Summary of the report
-   - Key findings and abnormal values
-   - Medical interpretation
-   - Important disclaimers
+### Web Interface
+1. Visit the main page
+2. **Upload Image**: Click on the upload area and select your lab report image
+3. **Analyze**: Click the "Analyze Report" button
+4. **Review Results**: Get structured analysis with summary, key findings, and interpretations
+
+### API Endpoints
+- **POST** `/analyze` - Upload file analysis
+- **POST** `/analyze-base64` - Base64 image analysis
+- **POST** `/api/analyze-lab` - Flutter-friendly file upload
+- **POST** `/api/analyze-lab-base64` - Flutter-friendly base64 analysis
+- **GET** `/health` - Health check endpoint
+- **GET** `/docs` - Interactive API documentation
+- **GET** `/redoc` - ReDoc documentation
 
 ## 🛠️ Technology Stack
 
-- **Frontend**: Gradio for interactive web interface
-- **Backend**: FastAPI for robust API handling
+- **Backend**: FastAPI for high-performance API
+- **Frontend**: Custom HTML/CSS/JavaScript interface
 - **AI Model**: Google AI Studio (Gemini 2.0 Flash)
 - **Image Processing**: PIL for image handling
 - **Deployment**: Docker containerization for Hugging Face Spaces
 
+## 📱 Flutter Integration
+
+Perfect for Flutter apps! All endpoints return consistent JSON responses:
+
+```dart
+// File upload
+POST /api/analyze-lab
+Content-Type: multipart/form-data
+
+// Base64 upload  
+POST /api/analyze-lab-base64
+Content-Type: application/json
+{
+  "image": "base64_encoded_image_string"
+}
+
+// Response format
+{
+  "success": true,
+  "filename": "lab_report.jpg",
+  "analysis": {
+    "error": false,
+    "summary": "Analysis summary",
+    "key_findings": ["Finding 1", "Finding 2"],
+    "interpretation": "Medical interpretation",
+    "note": "Disclaimer about medical advice",
+    "raw_response": "Full AI response"
+  }
+}
+```
+
 ## ⚠️ Important Disclaimer
 
 **This tool is for educational and informational purposes only. It should not be used as a substitute for professional medical advice, diagnosis, or treatment. Always consult with qualified healthcare professionals for medical concerns.**
@@ -66,14 +104,23 @@ An intelligent lab report analysis system that uses Google AI Studio's Gemini mo
    ```
 4. Run the application:
    ```bash
-   python app.py
+   uvicorn app:app --host 0.0.0.0 --port 7860 --reload
    ```
 
+### Docker Development
+
+```bash
+# Build the image
+docker build -t lab-analysis-api .
+
+# Run the container
+docker run -p 7860:7860 -e GOOGLE_AI_STUDIO_API_KEY=your_key lab-analysis-api
+```
+
 ## 📁 Project Structure
 
 ```
-├── app.py                 # Main Gradio application
-├── main.py               # FastAPI server
+├── app.py                 # Main FastAPI application with web interface
 ├── lab_analyzer.py       # Core analysis logic
 ├── models.py            # Data models
 ├── requirements.txt     # Python dependencies
@@ -81,8 +128,20 @@ An intelligent lab report analysis system that uses Google AI Studio's Gemini mo
 └── README.md           # Documentation
 ```
 
+## 🎯 Endpoints Overview
+
+| Method | Endpoint | Description | Use Case |
+|--------|----------|-------------|----------|
+| GET | `/` | Web interface | Manual testing |
+| POST | `/analyze` | File upload analysis | General API usage |
+| POST | `/analyze-base64` | Base64 analysis | Web applications |
+| POST | `/api/analyze-lab` | Flutter file upload | Mobile apps |
+| POST | `/api/analyze-lab-base64` | Flutter base64 | Mobile apps |
+| GET | `/health` | Health check | Monitoring |
+| GET | `/docs` | OpenAPI docs | API reference |
+
 ## 🙏 Acknowledgments
 
 - Google AI Studio for providing the Gemini API
 - Hugging Face for Spaces hosting
-- Gradio for the web interface framework
+- FastAPI for the excellent web framework

app.py

@@ -1,177 +1,478 @@
-import gradio as gr
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
 import base64
-import asyncio
-import os
-from lab_analyzer import LabReportAnalyzer
-from PIL import Image
 import io
+from PIL import Image
+from lab_analyzer import LabReportAnalyzer
 import logging
+import os
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# Initialize FastAPI app
+app = FastAPI(
+    title="Lab Report Analysis API",
+    description="AI-powered lab report analysis service using Google AI Studio",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure this properly for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 # Initialize the lab analyzer
 analyzer = LabReportAnalyzer()
 
-async def analyze_lab_report(image):
+@app.get("/health")
+async def health_check():
+    """Health check endpoint for monitoring"""
+    return {"status": "healthy", "service": "lab-report-analyzer"}
+
+@app.post("/analyze")
+async def analyze_lab_report(file: UploadFile = File(...)):
     """
-    Analyze a lab report image using the LabReportAnalyzer
+    Analyze a lab report image and return structured results
     
     Args:
-        image: PIL Image from Gradio interface
-        
+        file: Uploaded image file (jpg, jpeg, png, bmp, tiff, webp)
+    
     Returns:
-        Formatted analysis results
+        JSON response with analysis results
     """
     try:
-        if image is None:
-            return "❌ Please upload an image first."
+        # Validate file type
+        if not file.content_type.startswith('image/'):
+            raise HTTPException(
+                status_code=400, 
+                detail="File must be an image (jpg, jpeg, png, bmp, tiff, webp)"
+            )
         
-        # Convert PIL image to base64
-        buffer = io.BytesIO()
-        image.save(buffer, format="JPEG")
-        image_b64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        # Read and validate image
+        contents = await file.read()
+        if len(contents) == 0:
+            raise HTTPException(status_code=400, detail="Empty file uploaded")
+        
+        # Validate image can be opened
+        try:
+            image = Image.open(io.BytesIO(contents))
+            image.verify()  # Verify it's a valid image
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Invalid image file: {str(e)}")
+        
+        # Convert to base64 for analysis
+        image_b64 = base64.b64encode(contents).decode("utf-8")
         
         # Analyze the lab report
+        logger.info(f"Analyzing lab report: {file.filename}")
         analysis_result = await analyzer.analyze_report(image_b64)
         
-        if analysis_result.get("error", False):
-            return f"❌ Error: {analysis_result.get('message', 'Unknown error occurred')}"
+        return JSONResponse(
+            status_code=200,
+            content={
+                "success": True,
+                "filename": file.filename,
+                "analysis": analysis_result
+            }
+        )
         
-        # Format the results for display
-        formatted_result = f"""
-## 📊 Lab Report Analysis Results
-
-### 📋 Summary
-{analysis_result.get('summary', 'No summary available')}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error analyzing lab report: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
-### 🔍 Key Findings
-"""
+@app.post("/analyze-base64")
+async def analyze_lab_report_base64(data: dict):
+    """
+    Analyze a lab report from base64 encoded image
+    
+    Args:
+        data: JSON with 'image' key containing base64 encoded image
+    
+    Returns:
+        JSON response with analysis results
+    """
+    try:
+        if 'image' not in data:
+            raise HTTPException(status_code=400, detail="Missing 'image' field in request body")
         
-        key_findings = analysis_result.get('key_findings', [])
-        if key_findings:
-            for finding in key_findings:
-                formatted_result += f"• {finding}\n"
-        else:
-            formatted_result += "• No specific findings identified\n"
+        image_b64 = data['image']
         
-        formatted_result += f"""
-### 💡 Interpretation
-{analysis_result.get('interpretation', 'No interpretation available')}
-
-### ⚠️ Important Note
-{analysis_result.get('note', 'This analysis is for educational purposes only and should not replace professional medical advice.')}
-
----
-*Analysis powered by Google AI Studio (Gemini 2.0 Flash)*
-"""
+        # Remove data:image/...;base64, prefix if present
+        if image_b64.startswith('data:image'):
+            image_b64 = image_b64.split(',')[1]
+        
+        # Validate base64 and image
+        try:
+            image_bytes = base64.b64decode(image_b64)
+            image = Image.open(io.BytesIO(image_bytes))
+            image.verify()
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Invalid base64 image: {str(e)}")
+        
+        # Analyze the lab report
+        logger.info("Analyzing lab report from base64 data")
+        analysis_result = await analyzer.analyze_report(image_b64)
         
-        return formatted_result
+        return JSONResponse(
+            status_code=200,
+            content={
+                "success": True,
+                "analysis": analysis_result
+            }
+        )
         
+    except HTTPException:
+        raise
     except Exception as e:
-        logger.error(f"Error in analyze_lab_report: {str(e)}")
-        return f"❌ Analysis failed: {str(e)}"
-
-def analyze_wrapper(image):
-    """Wrapper function to run async analysis in Gradio"""
-    return asyncio.run(analyze_lab_report(image))
-
-# Create Gradio interface
-with gr.Blocks(
-    theme=gr.themes.Soft(),
-    title="Lab Report Analysis AI",
-    css="""
-    .gradio-container {
-        max-width: 1200px !important;
-    }
-    .analysis-output {
-        font-family: 'Georgia', serif;
-        line-height: 1.6;
-    }
-    """
-) as demo:
-    
-    gr.Markdown("""
-    # 🏥 Lab Report Analysis AI
-    
-    Upload a lab report image and get an AI-powered analysis with key findings and interpretations.
-    
-    **Features:**
-    - 📸 Image-to-text analysis using advanced AI
-    - 🔍 Structured medical report interpretation
-    - ⚡ Fast and accurate results
-    - 🔒 Secure processing (images are not stored)
-    
-    **Supported formats:** JPG, JPEG, PNG, BMP, TIFF, WEBP
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 📤 Upload Lab Report")
-            image_input = gr.Image(
-                type="pil",
-                label="Lab Report Image",
-                height=400
-            )
-            
-            analyze_btn = gr.Button(
-                "🔬 Analyze Report",
-                variant="primary",
-                size="lg"
-            )
-            
-            gr.Markdown("""
-            ### 📝 Instructions:
-            1. Upload a clear image of your lab report
-            2. Click "Analyze Report" button
-            3. Wait for AI analysis results
-            4. Review the structured findings
+        logger.error(f"Error analyzing base64 lab report: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+# Flutter-friendly endpoint aliases
+@app.post("/api/analyze-lab")
+async def analyze_lab_api(file: UploadFile = File(...)):
+    """Flutter-friendly endpoint for lab analysis"""
+    return await analyze_lab_report(file)
+
+@app.post("/api/analyze-lab-base64")
+async def analyze_lab_base64_api(data: dict):
+    """Flutter-friendly endpoint for base64 lab analysis"""
+    return await analyze_lab_report_base64(data)
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Main page with upload interface"""
+    return """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>🏥 Lab Report Analysis AI</title>
+        <style>
+            * { margin: 0; padding: 0; box-sizing: border-box; }
+            body { 
+                font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; 
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                min-height: 100vh;
+                padding: 20px;
+            }
+            .container { 
+                max-width: 1200px; 
+                margin: 0 auto; 
+                background: white; 
+                border-radius: 20px; 
+                box-shadow: 0 20px 60px rgba(0,0,0,0.1);
+                overflow: hidden;
+            }
+            .header { 
+                background: linear-gradient(45deg, #2196F3, #21CBF3);
+                color: white; 
+                padding: 40px; 
+                text-align: center; 
+            }
+            .header h1 { font-size: 2.5em; margin-bottom: 10px; }
+            .header p { font-size: 1.2em; opacity: 0.9; }
+            .content { padding: 40px; }
+            .upload-area { 
+                border: 3px dashed #2196F3; 
+                border-radius: 15px; 
+                padding: 40px; 
+                text-align: center; 
+                margin: 20px 0;
+                transition: all 0.3s ease;
+                cursor: pointer;
+            }
+            .upload-area:hover { 
+                border-color: #1976D2; 
+                background-color: #f5f5f5; 
+            }
+            .upload-area.dragover { 
+                border-color: #4CAF50; 
+                background-color: #e8f5e8; 
+            }
+            input[type="file"] { display: none; }
+            .btn { 
+                background: linear-gradient(45deg, #2196F3, #21CBF3);
+                color: white; 
+                border: none; 
+                padding: 15px 30px; 
+                border-radius: 25px; 
+                cursor: pointer; 
+                font-size: 16px;
+                margin: 10px;
+                transition: transform 0.2s ease;
+            }
+            .btn:hover { transform: translateY(-2px); }
+            .btn:disabled { 
+                background: #ccc; 
+                cursor: not-allowed; 
+                transform: none;
+            }
+            .result { 
+                margin-top: 30px; 
+                padding: 20px; 
+                border-radius: 10px; 
+                background: #f8f9fa;
+                border-left: 5px solid #2196F3;
+            }
+            .loading { 
+                text-align: center; 
+                color: #2196F3; 
+                font-size: 18px;
+            }
+            .error { 
+                background: #ffebee; 
+                border-left-color: #f44336; 
+                color: #c62828;
+            }
+            .success { 
+                background: #e8f5e8; 
+                border-left-color: #4CAF50; 
+            }
+            .api-info {
+                background: #f0f4f8;
+                padding: 30px;
+                margin-top: 40px;
+                border-radius: 15px;
+            }
+            .endpoint {
+                background: #fff;
+                padding: 15px;
+                margin: 10px 0;
+                border-radius: 8px;
+                border-left: 4px solid #2196F3;
+            }
+            .method {
+                background: #2196F3;
+                color: white;
+                padding: 4px 8px;
+                border-radius: 4px;
+                font-weight: bold;
+                font-size: 12px;
+            }
+            pre {
+                background: #2d3748;
+                color: #e2e8f0;
+                padding: 15px;
+                border-radius: 8px;
+                overflow-x: auto;
+                margin: 10px 0;
+            }
+            .features {
+                display: grid;
+                grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+                gap: 20px;
+                margin: 30px 0;
+            }
+            .feature {
+                text-align: center;
+                padding: 20px;
+                border-radius: 10px;
+                background: #f8f9fa;
+            }
+            .feature-icon {
+                font-size: 2em;
+                margin-bottom: 10px;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="header">
+                <h1>🏥 Lab Report Analysis AI</h1>
+                <p>AI-powered medical lab report analysis using Google AI Studio</p>
+            </div>
             
-            **Note:** This tool is for educational purposes only. 
-            Always consult healthcare professionals for medical advice.
-            """)
-        
-        with gr.Column(scale=2):
-            gr.Markdown("### 📊 Analysis Results")
-            analysis_output = gr.Markdown(
-                "Upload an image and click 'Analyze Report' to see results here.",
-                elem_classes=["analysis-output"]
-            )
-    
-    # Event handlers
-    analyze_btn.click(
-        fn=analyze_wrapper,
-        inputs=[image_input],
-        outputs=[analysis_output],
-        show_progress=True
-    )
-    
-    # Example images section
-    gr.Markdown("""
-    ---
-    ### 🎯 Example Lab Reports
-    Try uploading sample lab reports to see how the analysis works!
-    """)
-    
-    # Footer
-    gr.Markdown("""
-    ---
-    **Powered by:**
-    - 🤖 Google AI Studio (Gemini 2.0 Flash)
-    - ⚡ FastAPI Backend
-    - 🎨 Gradio Interface
-    - 🐳 Docker Containerization
-    
-    **Privacy:** Your images are processed securely and not stored permanently.
-    """)
+            <div class="content">
+                <div class="features">
+                    <div class="feature">
+                        <div class="feature-icon">📸</div>
+                        <h3>Image Upload</h3>
+                        <p>Support for JPG, PNG, TIFF, and more</p>
+                    </div>
+                    <div class="feature">
+                        <div class="feature-icon">🤖</div>
+                        <h3>AI Analysis</h3>
+                        <p>Google Gemini 2.0 Flash model</p>
+                    </div>
+                    <div class="feature">
+                        <div class="feature-icon">📊</div>
+                        <h3>Structured Results</h3>
+                        <p>Summary, findings, and interpretations</p>
+                    </div>
+                    <div class="feature">
+                        <div class="feature-icon">⚡</div>
+                        <h3>Fast Processing</h3>
+                        <p>Real-time analysis results</p>
+                    </div>
+                </div>
+
+                <div class="upload-area" onclick="document.getElementById('fileInput').click()">
+                    <h3>📤 Upload Lab Report Image</h3>
+                    <p>Click here or drag and drop your lab report image</p>
+                    <input type="file" id="fileInput" accept="image/*">
+                </div>
+                
+                <div style="text-align: center;">
+                    <button class="btn" onclick="analyzeImage()" id="analyzeBtn" disabled>
+                        🔬 Analyze Report
+                    </button>
+                    <button class="btn" onclick="clearResults()">
+                        🗑️ Clear
+                    </button>
+                </div>
+                
+                <div id="result"></div>
+
+                <div class="api-info">
+                    <h2>🔧 API Documentation</h2>
+                    <p>This service provides RESTful API endpoints for programmatic access:</p>
+                    
+                    <div class="endpoint">
+                        <span class="method">POST</span> <strong>/analyze</strong>
+                        <p>Upload lab report image file for analysis</p>
+                    </div>
+                    
+                    <div class="endpoint">
+                        <span class="method">POST</span> <strong>/analyze-base64</strong>
+                        <p>Analyze lab report from base64 encoded image</p>
+                    </div>
+                    
+                    <div class="endpoint">
+                        <span class="method">POST</span> <strong>/api/analyze-lab</strong>
+                        <p>Flutter-friendly endpoint for file upload</p>
+                    </div>
+                    
+                    <div class="endpoint">
+                        <span class="method">POST</span> <strong>/api/analyze-lab-base64</strong>
+                        <p>Flutter-friendly endpoint for base64 analysis</p>
+                    </div>
+
+                    <p><strong>📚 Interactive Documentation:</strong></p>
+                    <button class="btn" onclick="window.open('/docs', '_blank')">
+                        📖 OpenAPI Docs
+                    </button>
+                    <button class="btn" onclick="window.open('/redoc', '_blank')">
+                        📘 ReDoc
+                    </button>
+                </div>
+
+                <div style="text-align: center; margin-top: 40px; color: #666;">
+                    <p>⚠️ This tool is for educational purposes only. Always consult healthcare professionals for medical advice.</p>
+                </div>
+            </div>
+        </div>
+
+        <script>
+            let selectedFile = null;
+
+            document.getElementById('fileInput').addEventListener('change', function(e) {
+                selectedFile = e.target.files[0];
+                if (selectedFile) {
+                    document.querySelector('.upload-area h3').innerHTML = '✅ ' + selectedFile.name;
+                    document.getElementById('analyzeBtn').disabled = false;
+                }
+            });
+
+            // Drag and drop functionality
+            const uploadArea = document.querySelector('.upload-area');
+            uploadArea.addEventListener('dragover', (e) => {
+                e.preventDefault();
+                uploadArea.classList.add('dragover');
+            });
+            uploadArea.addEventListener('dragleave', () => {
+                uploadArea.classList.remove('dragover');
+            });
+            uploadArea.addEventListener('drop', (e) => {
+                e.preventDefault();
+                uploadArea.classList.remove('dragover');
+                const files = e.dataTransfer.files;
+                if (files.length > 0) {
+                    selectedFile = files[0];
+                    document.querySelector('.upload-area h3').innerHTML = '✅ ' + selectedFile.name;
+                    document.getElementById('analyzeBtn').disabled = false;
+                }
+            });
+
+            async function analyzeImage() {
+                if (!selectedFile) {
+                    alert('Please select an image first');
+                    return;
+                }
+
+                const resultDiv = document.getElementById('result');
+                resultDiv.innerHTML = '<div class="result loading">🔄 Analyzing lab report...</div>';
+                
+                const analyzeBtn = document.getElementById('analyzeBtn');
+                analyzeBtn.disabled = true;
+                analyzeBtn.innerHTML = '⏳ Processing...';
+
+                const formData = new FormData();
+                formData.append('file', selectedFile);
+
+                try {
+                    const response = await fetch('/analyze', {
+                        method: 'POST',
+                        body: formData
+                    });
+
+                    const data = await response.json();
+
+                    if (data.success) {
+                        const analysis = data.analysis;
+                        resultDiv.innerHTML = `
+                            <div class="result success">
+                                <h3>📊 Analysis Results</h3>
+                                <h4>📋 Summary</h4>
+                                <p>${analysis.summary || 'No summary available'}</p>
+                                
+                                <h4>🔍 Key Findings</h4>
+                                <ul>
+                                    ${analysis.key_findings?.map(finding => `<li>${finding}</li>`).join('') || '<li>No specific findings identified</li>'}
+                                </ul>
+                                
+                                <h4>💡 Interpretation</h4>
+                                <p>${analysis.interpretation || 'No interpretation available'}</p>
+                                
+                                <h4>⚠️ Important Note</h4>
+                                <p><em>${analysis.note || 'This analysis is for educational purposes only and should not replace professional medical advice.'}</em></p>
+                            </div>
+                        `;
+                    } else {
+                        resultDiv.innerHTML = `<div class="result error">❌ Error: ${data.error || 'Analysis failed'}</div>`;
+                    }
+                } catch (error) {
+                    resultDiv.innerHTML = `<div class="result error">❌ Error: ${error.message}</div>`;
+                } finally {
+                    analyzeBtn.disabled = false;
+                    analyzeBtn.innerHTML = '🔬 Analyze Report';
+                }
+            }
+
+            function clearResults() {
+                document.getElementById('result').innerHTML = '';
+                document.getElementById('fileInput').value = '';
+                document.querySelector('.upload-area h3').innerHTML = '📤 Upload Lab Report Image';
+                document.getElementById('analyzeBtn').disabled = true;
+                selectedFile = null;
+            }
+        </script>
+    </body>
+    </html>
+    """
 
-# Launch the app
 if __name__ == "__main__":
-    # For Hugging Face Spaces, use the default port 7860
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True
-    )
+    import uvicorn
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=True)

requirements.txt

@@ -1,9 +1,8 @@
-gradio>=4.0.0
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+python-multipart>=0.0.6
 Pillow>=10.0.0
 numpy>=1.26.0
 requests>=2.31.0
-fastapi>=0.104.0
-uvicorn>=0.24.0
-python-multipart>=0.0.6
 pydantic>=2.4.0
 aiofiles>=23.1.0