Upload 9 files

Lab_report_analysis.py

@@ -0,0 +1,72 @@
+import base64
+import os
+from huggingface_hub import InferenceClient
+from tkinter import Tk, filedialog
+
+def select_image():
+    
+    root = Tk()
+    root.withdraw() 
+    file_path = filedialog.askopenfilename(
+        title="Select a Lab Report Image",
+        filetypes=[("Image Files", "*.jpg;*.jpeg;*.png;*.bmp;*.tiff;*.webp")]
+    )
+    return file_path
+
+
+client = InferenceClient(
+    provider="nebius",
+    api_key=os.getenv("HUGGINGFACE_API_KEY", "your-api-key-here"),
+)
+img = select_image()
+
+with open(img, "rb") as f:
+    image_bytes = f.read()
+    image_b64 = base64.b64encode(image_bytes).decode("utf-8")
+
+prompt = """
+You are a medical analysis assistant.
+
+Analyze the following lab report image and give a structured, professional summary
+following these steps:
+
+1. Extract the results (with normal ranges if available).
+2. Highlight abnormal values clearly.
+3. Explain what the results suggest in simple terms.
+4. Provide an overall summary of health findings.
+5. End with the disclaimer:
+   "This analysis is for educational purposes only and should not replace professional medical advice."
+
+If the image is unreadable, respond: "The image text is unclear."
+"""
+
+completion = client.chat.completions.create(
+    model="google/gemma-3-27b-it",
+    messages=[
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": """
+Analyze this lab report and give me a brief, structured summary.
+
+Format your response as follows:
+
+Summary: (2–3 sentences explaining what the report shows)
+Key Findings: (3–5 bullet points with main abnormal or notable values)
+Interpretation: (1–2 sentences explaining what the findings suggest)
+Note: (One line disclaimer that it’s not medical advice)
+
+Keep it short, clear, and professional — like a medical summary written for quick review.
+"""},
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{image_b64}"
+                    }
+                }
+            ]
+        }
+    ],
+)
+
+print(completion.choices[0].message.content.strip())

README.md

@@ -1,10 +1,261 @@
----
-title: Lab Analyzer
-emoji: 🌖
-colorFrom: pink
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Lab Report Analysis API
+
+A FastAPI-based web service for analyzing lab report images using AI. This service accepts lab report images and provides structured medical analysis with key findings, interpretations, and health insights.
+
+## Features
+
+- 🖼️ Image upload support (JPG, PNG, BMP, TIFF, WEBP)
+- 🔍 AI-powered lab report analysis
+- 📊 Structured response with summary, key findings, and interpretation
+- 🌐 RESTful API with automatic documentation
+- 🧪 Built-in test client and web interface
+- ⚡ Async processing for better performance
+
+## Project Structure
+
+```
+Lab_analysis/
+├── main.py                     # FastAPI application
+├── lab_analyzer.py            # Core analysis logic
+├── models.py                  # Pydantic models
+├── test_client.py             # API test client
+├── index.html                 # Web interface
+├── requirements.txt           # Dependencies
+├── Lab_report_analysis.py     # Original script
+└── README.md                  # This file
+```
+
+## Installation
+
+1. **Clone or navigate to the project directory:**
+
+   ```bash
+   cd "e:\E-JUST Assignments\Projects\HealthCare\Lab_analysis"
+   ```
+
+2. **Create a virtual environment (recommended):**
+
+   ```bash
+   python -m venv venv
+   venv\Scripts\activate  # On Windows
+   ```
+
+3. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Running the API
+
+### Method 1: Using Python directly
+
+```bash
+python main.py
+```
+
+### Method 2: Using Uvicorn
+
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8000 --reload
+```
+
+The API will be available at:
+
+- **API Endpoints**: http://localhost:8000
+- **Interactive Docs**: http://localhost:8000/docs
+- **ReDoc**: http://localhost:8000/redoc
+
+## API Endpoints
+
+### Health Check
+
+- **GET** `/health`
+- Returns service status
+
+### Analyze Lab Report (File Upload)
+
+- **POST** `/analyze`
+- Upload an image file for analysis
+- Accepts: `multipart/form-data` with `file` field
+
+### Analyze Lab Report (Base64)
+
+- **POST** `/analyze-base64`
+- Send base64 encoded image for analysis
+- Accepts: JSON with `image` field containing base64 string
+
+## Usage Examples
+
+### Using cURL
+
+1. **Health check:**
+
+   ```bash
+   curl http://localhost:8000/health
+   ```
+
+2. **Analyze image file:**
+
+   ```bash
+   curl -X POST "http://localhost:8000/analyze" \
+        -H "accept: application/json" \
+        -H "Content-Type: multipart/form-data" \
+        -F "file=@your_lab_report.jpg"
+   ```
+
+3. **Analyze base64 image:**
+   ```bash
+   curl -X POST "http://localhost:8000/analyze-base64" \
+        -H "Content-Type: application/json" \
+        -d '{"image": "your_base64_encoded_image_here"}'
+   ```
+
+### Using Python Test Client
+
+```python
+from test_client import LabReportAPIClient
+
+client = LabReportAPIClient()
+
+# Health check
+health = client.health_check()
+print(health)
+
+# Analyze image
+result = client.analyze_image_file("path/to/your/lab_report.jpg")
+print(result)
+```
+
+### Using the Web Interface
+
+1. Start the API server
+2. Open `index.html` in your web browser
+3. Drag and drop or select a lab report image
+4. Click "Analyze Report" to get results
+
+## Response Format
+
+Successful analysis returns:
+
+```json
+{
+  "success": true,
+  "filename": "lab_report.jpg",
+  "analysis": {
+    "error": false,
+    "summary": "Brief summary of the lab report",
+    "key_findings": ["Finding 1", "Finding 2", "Finding 3"],
+    "interpretation": "Medical interpretation",
+    "note": "Disclaimer about medical advice",
+    "raw_response": "Complete AI response"
+  }
+}
+```
+
+## Configuration
+
+### Environment Variables
+
+You can set these environment variables to customize the behavior:
+
+- `API_HOST`: Host to bind to (default: "0.0.0.0")
+- `API_PORT`: Port to bind to (default: 8000)
+- `HF_API_KEY`: Hugging Face API key (currently hardcoded in `lab_analyzer.py`)
+
+### Updating API Key
+
+To use your own Hugging Face API key, modify the `lab_analyzer.py` file:
+
+```python
+self.client = InferenceClient(
+    provider="nebius",
+    api_key="your_api_key_here",  # Replace with your API key
+)
+```
+
+## Development
+
+### Running in Development Mode
+
+```bash
+uvicorn main:app --reload --host 0.0.0.0 --port 8000
+```
+
+### Testing
+
+Run the test client:
+
+```bash
+python test_client.py
+```
+
+### Adding New Features
+
+1. Add new endpoints to `main.py`
+2. Update models in `models.py` if needed
+3. Extend the analyzer in `lab_analyzer.py`
+4. Update documentation
+
+## Deployment
+
+### Docker (Optional)
+
+Create a `Dockerfile`:
+
+```dockerfile
+FROM python:3.9-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY . .
+
+EXPOSE 8000
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+```
+
+Build and run:
+
+```bash
+docker build -t lab-analysis-api .
+docker run -p 8000:8000 lab-analysis-api
+```
+
+### Production Considerations
+
+- Use environment variables for API keys
+- Set up proper CORS origins
+- Add rate limiting
+- Use HTTPS
+- Add authentication if needed
+- Set up logging and monitoring
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Import errors**: Make sure all dependencies are installed
+2. **Port conflicts**: Change the port in the uvicorn command
+3. **API key issues**: Verify your Hugging Face API key is valid
+4. **Image format errors**: Ensure images are in supported formats
+
+### Logs
+
+The application logs important events. Check console output for debugging information.
+
+## License
+
+This project is for educational purposes. Please ensure you have proper licenses for any AI models used.
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test thoroughly
+5. Submit a pull request
+
+---
+
+**Note**: This analysis is for educational purposes only and should not replace professional medical advice.

debug_analyzer.py

@@ -0,0 +1,43 @@
+import asyncio
+import sys
+import os
+
+# Add current directory to Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from lab_analyzer import LabReportAnalyzer
+
+async def test_analyzer():
+    """Test the analyzer with a dummy base64 string to see the response structure"""
+    analyzer = LabReportAnalyzer()
+    
+    # Create a small dummy base64 image (1x1 white pixel PNG)
+    dummy_image_b64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
+    
+    print("Testing analyzer with dummy image...")
+    try:
+        result = await analyzer.analyze_report(dummy_image_b64)
+        print("\nAnalysis result structure:")
+        print("=" * 50)
+        print(f"Result type: {type(result)}")
+        print(f"Keys: {result.keys() if isinstance(result, dict) else 'Not a dict'}")
+        print("\nFull result:")
+        print(result)
+        
+        # Check if it has the expected structure
+        if isinstance(result, dict):
+            print("\nStructure analysis:")
+            print(f"Has 'error' key: {'error' in result}")
+            print(f"Has 'summary' key: {'summary' in result}")
+            print(f"Has 'key_findings' key: {'key_findings' in result}")
+            print(f"Has 'interpretation' key: {'interpretation' in result}")
+            print(f"Has 'note' key: {'note' in result}")
+            print(f"Has 'raw_response' key: {'raw_response' in result}")
+            
+    except Exception as e:
+        print(f"Error testing analyzer: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(test_analyzer())

index.html

@@ -0,0 +1,585 @@
+<!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</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: 900px;
+        margin: 0 auto;
+        background: white;
+        border-radius: 15px;
+        box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
+        overflow: hidden;
+      }
+
+      .header {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+        color: white;
+        text-align: center;
+        padding: 30px 20px;
+      }
+
+      .header h1 {
+        font-size: 2.5rem;
+        margin-bottom: 10px;
+      }
+
+      .header p {
+        font-size: 1.1rem;
+        opacity: 0.9;
+      }
+
+      .content {
+        padding: 40px;
+      }
+
+      .upload-section {
+        text-align: center;
+        margin-bottom: 30px;
+      }
+
+      .upload-area {
+        border: 3px dashed #4facfe;
+        border-radius: 15px;
+        padding: 50px 20px;
+        margin-bottom: 20px;
+        background: #f8fbff;
+        transition: all 0.3s ease;
+        cursor: pointer;
+      }
+
+      .upload-area:hover {
+        background: #e8f4ff;
+        border-color: #0084ff;
+      }
+
+      .upload-area.dragover {
+        background: #e8f4ff;
+        border-color: #0084ff;
+        transform: scale(1.02);
+      }
+
+      .upload-icon {
+        font-size: 4rem;
+        color: #4facfe;
+        margin-bottom: 20px;
+      }
+
+      .upload-text {
+        font-size: 1.2rem;
+        color: #666;
+        margin-bottom: 20px;
+      }
+
+      .file-input {
+        display: none;
+      }
+
+      .btn {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+        color: white;
+        border: none;
+        padding: 15px 30px;
+        border-radius: 50px;
+        font-size: 1.1rem;
+        font-weight: 600;
+        cursor: pointer;
+        transition: all 0.3s ease;
+        margin: 10px;
+      }
+
+      .btn:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 5px 15px rgba(79, 172, 254, 0.4);
+      }
+
+      .btn:disabled {
+        background: #ccc;
+        cursor: not-allowed;
+        transform: none;
+        box-shadow: none;
+      }
+
+      .preview-section {
+        margin: 20px 0;
+        text-align: center;
+      }
+
+      .preview-image {
+        max-width: 100%;
+        max-height: 300px;
+        border-radius: 10px;
+        box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1);
+        margin-bottom: 15px;
+      }
+
+      .results-section {
+        margin-top: 30px;
+        display: none;
+      }
+
+      .loading {
+        text-align: center;
+        padding: 40px;
+        color: #4facfe;
+      }
+
+      .loading-spinner {
+        border: 4px solid #f3f3f3;
+        border-top: 4px solid #4facfe;
+        border-radius: 50%;
+        width: 50px;
+        height: 50px;
+        animation: spin 1s linear infinite;
+        margin: 0 auto 20px;
+      }
+
+      @keyframes spin {
+        0% {
+          transform: rotate(0deg);
+        }
+        100% {
+          transform: rotate(360deg);
+        }
+      }
+
+      .results-content {
+        background: #f8fbff;
+        border-radius: 15px;
+        padding: 30px;
+        border-left: 5px solid #4facfe;
+      }
+
+      .result-title {
+        color: #333;
+        font-size: 1.8rem;
+        margin-bottom: 25px;
+        display: flex;
+        align-items: center;
+        gap: 10px;
+      }
+
+      .analysis-block {
+        background: white;
+        border-radius: 10px;
+        padding: 20px;
+        margin-bottom: 20px;
+        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.05);
+      }
+
+      .analysis-block h3 {
+        color: #4facfe;
+        font-size: 1.3rem;
+        margin-bottom: 15px;
+        display: flex;
+        align-items: center;
+        gap: 10px;
+      }
+
+      .analysis-block p {
+        color: #555;
+        line-height: 1.6;
+        font-size: 1rem;
+      }
+
+      .findings-list {
+        list-style: none;
+        padding: 0;
+      }
+
+      .findings-list li {
+        background: #f0f8ff;
+        margin: 10px 0;
+        padding: 15px;
+        border-radius: 8px;
+        border-left: 4px solid #4facfe;
+        color: #333;
+      }
+
+      .findings-list li:before {
+        content: "•";
+        color: #4facfe;
+        font-weight: bold;
+        margin-right: 10px;
+      }
+
+      .error-message {
+        background: #ffe6e6;
+        color: #d63031;
+        padding: 20px;
+        border-radius: 10px;
+        border-left: 5px solid #d63031;
+        margin: 20px 0;
+      }
+
+      .success-message {
+        background: #e6ffe6;
+        color: #00b894;
+        padding: 20px;
+        border-radius: 10px;
+        border-left: 5px solid #00b894;
+        margin: 20px 0;
+      }
+
+      .disclaimer {
+        background: #fff3cd;
+        color: #856404;
+        padding: 15px;
+        border-radius: 8px;
+        border: 1px solid #ffeaa7;
+        margin-top: 20px;
+        font-style: italic;
+      }
+
+      .raw-response {
+        background: #f8f9fa;
+        border: 1px solid #e9ecef;
+        border-radius: 8px;
+        padding: 15px;
+        font-family: "Courier New", monospace;
+        font-size: 0.9rem;
+        white-space: pre-wrap;
+        max-height: 300px;
+        overflow-y: auto;
+      }
+
+      @media (max-width: 768px) {
+        .header h1 {
+          font-size: 2rem;
+        }
+
+        .content {
+          padding: 20px;
+        }
+
+        .upload-area {
+          padding: 30px 15px;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <div class="header">
+        <h1>🔬 Lab Report Analysis</h1>
+        <p>AI-powered medical lab report analysis service</p>
+      </div>
+
+      <div class="content">
+        <div class="upload-section">
+          <div
+            class="upload-area"
+            onclick="document.getElementById('fileInput').click()"
+          >
+            <div class="upload-icon">📄</div>
+            <div class="upload-text">
+              Drag and drop your lab report image here<br />
+              or click to select a file
+            </div>
+            <div class="supported-formats">
+              <small>Supports: JPG, PNG, BMP, TIFF, WEBP</small>
+            </div>
+          </div>
+
+          <input
+            type="file"
+            id="fileInput"
+            class="file-input"
+            accept="image/*"
+          />
+
+          <button
+            class="btn"
+            id="analyzeBtn"
+            disabled
+            onclick="analyzeReport()"
+          >
+            🔍 Analyze Lab Report
+          </button>
+        </div>
+
+        <div class="preview-section" id="previewSection" style="display: none">
+          <h3>Selected File:</h3>
+          <div id="imagePreview"></div>
+        </div>
+
+        <div class="results-section" id="resultsSection">
+          <div class="loading" id="loadingDiv" style="display: none">
+            <div class="loading-spinner"></div>
+            <h3>Analyzing your lab report...</h3>
+            <p>Please wait while our AI processes your image</p>
+          </div>
+
+          <div id="resultsContent"></div>
+        </div>
+      </div>
+    </div>
+
+    <script>
+      const API_URL = "http://localhost:8000";
+      let selectedFile = null;
+
+      // Get DOM elements
+      const fileInput = document.getElementById("fileInput");
+      const uploadArea = document.querySelector(".upload-area");
+      const analyzeBtn = document.getElementById("analyzeBtn");
+      const previewSection = document.getElementById("previewSection");
+      const imagePreview = document.getElementById("imagePreview");
+      const resultsSection = document.getElementById("resultsSection");
+      const loadingDiv = document.getElementById("loadingDiv");
+      const resultsContent = document.getElementById("resultsContent");
+
+      // Event listeners
+      fileInput.addEventListener("change", handleFileSelect);
+      uploadArea.addEventListener("dragover", handleDragOver);
+      uploadArea.addEventListener("dragleave", handleDragLeave);
+      uploadArea.addEventListener("drop", handleDrop);
+
+      function handleFileSelect(event) {
+        const file = event.target.files[0];
+        if (file && file.type.startsWith("image/")) {
+          selectedFile = file;
+          showPreview(file);
+          analyzeBtn.disabled = false;
+        } else {
+          showError("Please select a valid image file");
+        }
+      }
+
+      function handleDragOver(event) {
+        event.preventDefault();
+        uploadArea.classList.add("dragover");
+      }
+
+      function handleDragLeave(event) {
+        event.preventDefault();
+        uploadArea.classList.remove("dragover");
+      }
+
+      function handleDrop(event) {
+        event.preventDefault();
+        uploadArea.classList.remove("dragover");
+
+        const files = event.dataTransfer.files;
+        if (files.length > 0 && files[0].type.startsWith("image/")) {
+          selectedFile = files[0];
+          showPreview(files[0]);
+          analyzeBtn.disabled = false;
+        } else {
+          showError("Please drop a valid image file");
+        }
+      }
+
+      function showPreview(file) {
+        const reader = new FileReader();
+        reader.onload = function (e) {
+          imagePreview.innerHTML = `
+                    <img src="${
+                      e.target.result
+                    }" alt="Lab Report Preview" class="preview-image">
+                    <p><strong>File:</strong> ${file.name} (${(
+            file.size /
+            1024 /
+            1024
+          ).toFixed(2)} MB)</p>
+                `;
+          previewSection.style.display = "block";
+        };
+        reader.readAsDataURL(file);
+      }
+
+      async function analyzeReport() {
+        if (!selectedFile) {
+          showError("Please select an image file first");
+          return;
+        }
+
+        // Show loading
+        resultsSection.style.display = "block";
+        loadingDiv.style.display = "block";
+        resultsContent.innerHTML = "";
+        analyzeBtn.disabled = true;
+
+        try {
+          console.log("🔄 Sending file to API:", selectedFile.name);
+
+          const formData = new FormData();
+          formData.append("file", selectedFile);
+
+          const response = await fetch(`${API_URL}/analyze`, {
+            method: "POST",
+            body: formData,
+          });
+
+          console.log("📡 Response status:", response.status);
+          const responseData = await response.json();
+          console.log("📊 Full response data:", responseData);
+
+          loadingDiv.style.display = "none";
+
+          if (response.ok && responseData.success) {
+            console.log("✅ Analysis successful, displaying results");
+            displayResults(responseData.analysis);
+          } else {
+            console.error("❌ Analysis failed:", responseData);
+            showError(
+              responseData.detail || responseData.message || "Analysis failed"
+            );
+          }
+        } catch (error) {
+          console.error("🚨 Connection error:", error);
+          loadingDiv.style.display = "none";
+          showError(
+            `Connection error: ${error.message}. Make sure the API server is running on http://localhost:8000`
+          );
+        }
+
+        analyzeBtn.disabled = false;
+      }
+
+      function displayResults(analysis) {
+        console.log("🎨 Displaying analysis results:", analysis);
+
+        if (analysis.error) {
+          showError(analysis.message || "Analysis failed");
+          return;
+        }
+
+        let html = `
+                <div class="results-content">
+                    <h2 class="result-title">📋 Analysis Results</h2>
+            `;
+
+        // Summary
+        if (analysis.summary && analysis.summary.trim()) {
+          console.log("📝 Adding summary:", analysis.summary);
+          html += `
+                    <div class="analysis-block">
+                        <h3>📝 Summary</h3>
+                        <p>${analysis.summary}</p>
+                    </div>
+                `;
+        }
+
+        // Key Findings
+        if (
+          analysis.key_findings &&
+          Array.isArray(analysis.key_findings) &&
+          analysis.key_findings.length > 0
+        ) {
+          console.log("🔍 Adding key findings:", analysis.key_findings);
+          html += `
+                    <div class="analysis-block">
+                        <h3>🔍 Key Findings</h3>
+                        <ul class="findings-list">
+                            ${analysis.key_findings
+                              .map((finding) => `<li>${finding}</li>`)
+                              .join("")}
+                        </ul>
+                    </div>
+                `;
+        }
+
+        // Interpretation
+        if (analysis.interpretation && analysis.interpretation.trim()) {
+          console.log("💡 Adding interpretation:", analysis.interpretation);
+          html += `
+                    <div class="analysis-block">
+                        <h3>💡 Interpretation</h3>
+                        <p>${analysis.interpretation}</p>
+                    </div>
+                `;
+        }
+
+        // Note/Disclaimer
+        if (analysis.note && analysis.note.trim()) {
+          console.log("⚠️ Adding note:", analysis.note);
+          html += `
+                    <div class="disclaimer">
+                        <strong>⚠️ Important Note:</strong> ${analysis.note}
+                    </div>
+                `;
+        }
+
+        // If no structured data is available, show raw response
+        const hasStructuredData =
+          (analysis.summary && analysis.summary.trim()) ||
+          (analysis.key_findings && analysis.key_findings.length > 0) ||
+          (analysis.interpretation && analysis.interpretation.trim()) ||
+          (analysis.note && analysis.note.trim());
+
+        if (!hasStructuredData) {
+          console.log("📄 No structured data found, showing raw response");
+          html += `
+                    <div class="analysis-block">
+                        <h3>📄 Analysis Result</h3>
+                        <div class="raw-response">${
+                          analysis.raw_response ||
+                          JSON.stringify(analysis, null, 2)
+                        }</div>
+                    </div>
+                `;
+        } else {
+          // Always show raw response for debugging
+          if (analysis.raw_response) {
+            html += `
+                        <details style="margin-top: 20px;">
+                            <summary style="cursor: pointer; color: #666; font-size: 0.9rem;">🔧 Show Raw AI Response (Debug)</summary>
+                            <div class="raw-response" style="margin-top: 10px;">${analysis.raw_response}</div>
+                        </details>
+                    `;
+          }
+        }
+
+        html += "</div>";
+        resultsContent.innerHTML = html;
+        console.log("✨ Results displayed successfully");
+      }
+
+      function showError(message) {
+        console.error("❌ Showing error:", message);
+        resultsContent.innerHTML = `
+                <div class="error-message">
+                    <h3>❌ Error</h3>
+                    <p>${message}</p>
+                </div>
+            `;
+        resultsSection.style.display = "block";
+      }
+
+      // Check API health on page load
+      window.addEventListener("load", async () => {
+        try {
+          console.log("🏥 Checking API health...");
+          const response = await fetch(`${API_URL}/health`);
+          if (response.ok) {
+            const data = await response.json();
+            console.log("✅ API is healthy:", data);
+          } else {
+            console.warn("⚠️ API health check failed:", response.status);
+          }
+        } catch (error) {
+          console.warn("⚠️ Cannot connect to API:", error.message);
+          showError(
+            "Cannot connect to the API server. Please make sure the server is running on http://localhost:8000"
+          );
+        }
+      });
+    </script>
+  </body>
+</html>

lab_analyzer.py

@@ -0,0 +1,178 @@
+import base64
+import os
+from huggingface_hub import InferenceClient
+import asyncio
+from typing import Dict, Any
+import logging
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+class LabReportAnalyzer:
+    """Lab Report Analysis service using Hugging Face Inference Client"""
+    
+    def __init__(self):
+        """Initialize the analyzer with Hugging Face client"""
+        self.client = InferenceClient(
+            provider="nebius",
+            api_key=os.getenv("HUGGINGFACE_API_KEY", "your-api-key-here"),
+        )
+        self.model = "google/gemma-3-27b-it"
+        
+    async def analyze_report(self, image_b64: str) -> Dict[str, Any]:
+        """
+        Analyze a lab report image and return structured results
+        
+        Args:
+            image_b64: Base64 encoded image string
+            
+        Returns:
+            Dictionary containing structured analysis results
+        """
+        try:
+            prompt = self._get_analysis_prompt()
+            
+            # Run the inference in a thread pool to avoid blocking
+            loop = asyncio.get_event_loop()
+            completion = await loop.run_in_executor(
+                None, 
+                self._run_inference, 
+                image_b64, 
+                prompt
+            )
+            
+            # Extract and parse the response
+            analysis_text = completion.choices[0].message.content.strip()
+            
+            # Parse the structured response
+            parsed_result = self._parse_analysis_result(analysis_text)
+            
+            return parsed_result
+            
+        except Exception as e:
+            logger.error(f"Error in analyze_report: {str(e)}")
+            return {
+                "error": True,
+                "message": f"Analysis failed: {str(e)}",
+                "raw_response": ""
+            }
+    
+    def _run_inference(self, image_b64: str, prompt: str):
+        """Run the Hugging Face inference synchronously"""
+        return self.client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": prompt},
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{image_b64}"
+                            }
+                        }
+                    ]
+                }
+            ],
+        )
+    
+    def _get_analysis_prompt(self) -> str:
+        """Get the structured analysis prompt"""
+        return """
+You are a medical analysis assistant.
+
+Analyze the following lab report image and give a structured, professional summary
+following these steps:
+
+1. Extract the results (with normal ranges if available).
+2. Highlight abnormal values clearly.
+3. Explain what the results suggest in simple terms.
+4. Provide an overall summary of health findings.
+5. End with the disclaimer:
+   "This analysis is for educational purposes only and should not replace professional medical advice."
+
+If the image is unreadable, respond: "The image text is unclear."
+
+Format your response as follows:
+
+Summary: (2–3 sentences explaining what the report shows)
+Key Findings: (3–5 bullet points with main abnormal or notable values)
+Interpretation: (1–2 sentences explaining what the findings suggest)
+Note: (One line disclaimer that it's not medical advice)
+
+Keep it short, clear, and professional — like a medical summary written for quick review.
+"""
+    
+    def _parse_analysis_result(self, analysis_text: str) -> Dict[str, Any]:
+        """
+        Parse the structured analysis result into a dictionary
+        
+        Args:
+            analysis_text: Raw analysis text from the model
+            
+        Returns:
+            Structured dictionary with parsed components
+        """
+        try:
+            result = {
+                "error": False,
+                "summary": "",
+                "key_findings": [],
+                "interpretation": "",
+                "note": "",
+                "raw_response": analysis_text
+            }
+            
+            # Check if image is unreadable
+            if "The image text is unclear" in analysis_text:
+                result["error"] = True
+                result["message"] = "The image text is unclear or unreadable"
+                return result
+            
+            lines = analysis_text.split('\n')
+            current_section = None
+            
+            for line in lines:
+                line = line.strip()
+                if not line:
+                    continue
+                    
+                # Identify sections (handle both plain text and markdown formats)
+                if line.startswith('Summary:') or line.startswith('**Summary:**'):
+                    current_section = 'summary'
+                    result['summary'] = line.replace('**Summary:**', '').replace('Summary:', '').strip()
+                elif line.startswith('Key Findings:') or line.startswith('**Key Findings:**'):
+                    current_section = 'key_findings'
+                elif line.startswith('Interpretation:') or line.startswith('**Interpretation:**'):
+                    current_section = 'interpretation'
+                    result['interpretation'] = line.replace('**Interpretation:**', '').replace('Interpretation:', '').strip()
+                elif line.startswith('Note:') or line.startswith('**Note:**'):
+                    current_section = 'note'
+                    result['note'] = line.replace('**Note:**', '').replace('Note:', '').strip()
+                else:
+                    # Continue previous section
+                    if current_section == 'summary' and not result['summary']:
+                        result['summary'] = line
+                    elif current_section == 'key_findings' and (line.startswith(('•', '-', '*')) or line.strip().startswith('*')):
+                        # Handle both regular bullets and markdown-style bullets
+                        clean_line = line.lstrip('•-* ').strip()
+                        if clean_line:
+                            result['key_findings'].append(clean_line)
+                    elif current_section == 'interpretation' and not result['interpretation']:
+                        result['interpretation'] = line
+                    elif current_section == 'note' and not result['note']:
+                        result['note'] = line
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error parsing analysis result: {str(e)}")
+            return {
+                "error": True,
+                "message": f"Failed to parse analysis: {str(e)}",
+                "raw_response": analysis_text
+            }

main.py

@@ -0,0 +1,161 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import base64
+import io
+from PIL import Image
+from lab_analyzer import LabReportAnalyzer
+import logging
+
+# 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",
+    version="1.0.0"
+)
+
+# 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()
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {"message": "Lab Report Analysis API is running"}
+
+@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 and return structured results
+    
+    Args:
+        file: Uploaded image file (jpg, jpeg, png, bmp, tiff, webp)
+    
+    Returns:
+        JSON response with analysis results
+    """
+    try:
+        # Read file contents first
+        contents = await file.read()
+        if len(contents) == 0:
+            raise HTTPException(status_code=400, detail="Empty file uploaded")
+        
+        # Validate image can be opened (more reliable than content_type)
+        try:
+            image = Image.open(io.BytesIO(contents))
+            image.verify()  # Verify it's a valid image
+            
+            # Reset file pointer for re-reading
+            contents_for_analysis = contents
+            
+        except Exception as e:
+            # Check if content type suggests it might be an image
+            allowed_types = ['image/', 'application/octet-stream']
+            if file.content_type and not any(t in file.content_type for t in allowed_types):
+                raise HTTPException(
+                    status_code=400, 
+                    detail=f"File must be an image (jpg, jpeg, png, bmp, tiff, webp). Received: {file.content_type}"
+                )
+            else:
+                raise HTTPException(status_code=400, detail=f"Invalid image file: {str(e)}")
+        
+        # Convert to base64 for analysis
+        image_b64 = base64.b64encode(contents_for_analysis).decode("utf-8")
+        
+        # Analyze the lab report
+        logger.info(f"Analyzing lab report: {file.filename}")
+        analysis_result = await analyzer.analyze_report(image_b64)
+        
+        return JSONResponse(
+            status_code=200,
+            content={
+                "success": True,
+                "filename": file.filename,
+                "analysis": analysis_result
+            }
+        )
+        
+    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)}")
+
+@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")
+        
+        image_b64 = data['image']
+        
+        # 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 JSONResponse(
+            status_code=200,
+            content={
+                "success": True,
+                "analysis": analysis_result
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        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)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

models.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional, Any
+
+class AnalysisRequest(BaseModel):
+    """Request model for base64 image analysis"""
+    image: str = Field(..., description="Base64 encoded image string")
+
+class AnalysisResponse(BaseModel):
+    """Response model for lab report analysis"""
+    success: bool = Field(..., description="Whether the analysis was successful")
+    filename: Optional[str] = Field(None, description="Original filename if uploaded via file")
+    analysis: dict = Field(..., description="Analysis results")
+
+class ParsedAnalysis(BaseModel):
+    """Structured analysis result"""
+    error: bool = Field(False, description="Whether an error occurred")
+    summary: str = Field("", description="Summary of the lab report")
+    key_findings: List[str] = Field(default_factory=list, description="Key findings from the report")
+    interpretation: str = Field("", description="Medical interpretation")
+    note: str = Field("", description="Disclaimer note")
+    raw_response: str = Field("", description="Raw response from the AI model")
+    message: Optional[str] = Field(None, description="Error message if any")
+
+class HealthResponse(BaseModel):
+    """Health check response"""
+    status: str = Field(..., description="Service status")
+    service: str = Field(..., description="Service name")

requirements.txt

@@ -0,0 +1,14 @@
+transformers>=4.44.0
+huggingface-hub>=0.24.0
+torch>=2.2.0
+Pillow>=10.0.0
+opencv-python>=4.9.0
+numpy>=1.26.0
+requests>=2.31.0
+matplotlib>=3.9.0
+ipython>=8.25.0
+pandas>=2.2.0
+fastapi>=0.104.0
+uvicorn>=0.24.0
+python-multipart>=0.0.6
+pydantic>=2.4.0

test_client.py

@@ -0,0 +1,83 @@
+import requests
+import base64
+import json
+from pathlib import Path
+
+class LabReportAPIClient:
+    """Client for testing the Lab Report Analysis API"""
+    
+    def __init__(self, base_url: str = "http://localhost:8000"):
+        self.base_url = base_url.rstrip('/')
+    
+    def health_check(self):
+        """Check if the API is running"""
+        try:
+            response = requests.get(f"{self.base_url}/health")
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Failed to connect: {str(e)}"}
+    
+    def analyze_image_file(self, image_path: str):
+        """Analyze a lab report image file"""
+        try:
+            with open(image_path, 'rb') as f:
+                files = {'file': (Path(image_path).name, f, 'image/jpeg')}
+                response = requests.post(f"{self.base_url}/analyze", files=files)
+            
+            if response.status_code == 200:
+                return response.json()
+            else:
+                return {
+                    "error": True,
+                    "status_code": response.status_code,
+                    "message": response.text
+                }
+        except Exception as e:
+            return {"error": f"Failed to analyze image: {str(e)}"}
+    
+    def analyze_base64_image(self, image_path: str):
+        """Analyze a lab report using base64 encoding"""
+        try:
+            with open(image_path, 'rb') as f:
+                image_b64 = base64.b64encode(f.read()).decode('utf-8')
+            
+            data = {"image": image_b64}
+            response = requests.post(
+                f"{self.base_url}/analyze-base64",
+                json=data,
+                headers={'Content-Type': 'application/json'}
+            )
+            
+            if response.status_code == 200:
+                return response.json()
+            else:
+                return {
+                    "error": True,
+                    "status_code": response.status_code,
+                    "message": response.text
+                }
+        except Exception as e:
+            return {"error": f"Failed to analyze base64 image: {str(e)}"}
+
+def main():
+    """Test the API client"""
+    client = LabReportAPIClient()
+    
+    # Health check
+    print("🏥 Testing Lab Report Analysis API")
+    print("=" * 50)
+    
+    health = client.health_check()
+    print(f"Health Check: {health}")
+    print()
+    
+    # You can test with an actual image file
+    # Uncomment and modify the path below to test with your lab report image
+    
+    # image_path = "your_lab_report_image.jpg"  # Replace with actual path
+    # print(f"Analyzing image: {image_path}")
+    # result = client.analyze_image_file(image_path)
+    # print(json.dumps(result, indent=2))
+
+if __name__ == "__main__":
+    main()