Upload 29 files

.gitignore

@@ -0,0 +1,30 @@
+.idea
+.ipynb_checkpoints
+.mypy_cache
+.vscode
+__pycache__
+.pytest_cache
+htmlcov
+dist
+site
+.coverage*
+coverage.xml
+.netlify
+test.db
+log.txt
+Pipfile.lock
+env3.*
+env
+docs_build
+site_build
+venv
+docs.zip
+archive.zip
+
+# vim temporary files
+*~
+.*.sw?
+.cache
+
+# macOS
+.DS_Store

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.10-slim
+
+WORKDIR /code
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt && \
+    pip install --no-cache-dir google-generativeai
+
+# Copy the rest of the application
+COPY . .
+
+# Command to run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app/api/models.py

@@ -0,0 +1,19 @@
+# app/api/models.py
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+class TraditionalRequest(BaseModel):
+    symptoms: List[str] = Field(..., min_items=1, description="List of symptoms")
+    age: int = Field(..., gt=0, lt=121)
+    gender: str
+    duration: str
+    additional_info: Optional[str] = None
+
+class BodyBasedRequest(BaseModel):
+    age: int = Field(..., gt=0, lt=121)
+    gender: str
+    body_parts: List[str] = Field(..., min_items=1, description="List of affected body parts")
+    symptom_types: List[str] = Field(..., min_items=1, description="List of symptom types")
+    severity: str
+    duration: str
+    description: str = Field(..., min_length=10, max_length=500)

app/api/routes.py

@@ -0,0 +1,32 @@
+from fastapi import APIRouter, HTTPException
+from ..core.analyzer import SymptomAnalyzer
+from .models import TraditionalRequest, BodyBasedRequest
+
+router = APIRouter()
+analyzer = SymptomAnalyzer()
+
+@router.post("/analyze/traditional")
+async def analyze_traditional(request: TraditionalRequest):
+    try:
+        result = await analyzer.analyze_traditional(
+            request.symptoms,
+            request.age,
+            request.gender,
+            request.duration
+        )
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/analyze/body-based")
+async def analyze_body_based(request: BodyBasedRequest):
+    try:
+        data = request.dict()
+        result = await analyzer.analyze_body_based(data)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/health")
+async def health_check():
+    return {"status": "healthy", "message": "Server is running"}

app/core/analyzer.py

@@ -0,0 +1,53 @@
+from typing import Dict, List
+import json
+import google.generativeai as genai
+from fastapi import HTTPException
+from ..utils.prompt_templates import generate_traditional_prompt, generate_body_based_prompt
+
+class SymptomAnalyzer:
+    def __init__(self):
+        self.model = genai.GenerativeModel('gemini-1.5-flash')
+        
+    async def analyze_traditional(self, symptoms: List[str], age: int, gender: str, duration: str) -> Dict:
+        try:
+            prompt = generate_traditional_prompt(symptoms, age, gender, duration)
+            response = self.model.generate_content(prompt)
+            
+            try:
+                parsed_response = json.loads(response.text)
+                return parsed_response
+            except json.JSONDecodeError as e:
+                cleaned_response = response.text.strip().strip('`').strip('json')
+                try:
+                    parsed_response = json.loads(cleaned_response)
+                    return parsed_response
+                except json.JSONDecodeError:
+                    raise HTTPException(
+                        status_code=500,
+                        detail="Failed to parse response into valid JSON"
+                    )
+                
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Analysis error: {str(e)}")
+
+    async def analyze_body_based(self, data: Dict) -> Dict:
+        try:
+            prompt = generate_body_based_prompt(data)
+            response = self.model.generate_content(prompt)
+            
+            try:
+                parsed_response = json.loads(response.text)
+                return parsed_response
+            except json.JSONDecodeError as e:
+                cleaned_response = response.text.strip().strip('`').strip('json')
+                try:
+                    parsed_response = json.loads(cleaned_response)
+                    return parsed_response
+                except json.JSONDecodeError:
+                    raise HTTPException(
+                        status_code=500,
+                        detail="Failed to parse response into valid JSON"
+                    )
+                
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Analysis error: {str(e)}")

app/core/config.py

@@ -0,0 +1,17 @@
+# app/core/config.py
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+def init_config():
+    # Load environment variables
+    load_dotenv()
+    
+    # Get API key
+    api_key = os.getenv('GEMINI_API_KEY')
+    
+    if not api_key:
+        raise ValueError("GEMINI_API_KEY not found in environment variables")
+        
+    # Configure Gemini
+    genai.configure(api_key=api_key)

app/utils/prompt_templates.py

@@ -0,0 +1,183 @@
+from typing import List
+
+def generate_traditional_prompt(symptoms: List[str], age: int, gender: str, duration: str) -> str:
+    return f"""
+        As a medical information assistant, analyze these symptoms and provide a response in valid JSON format.
+        
+        Patient Information:
+        - Age: {age}
+        - Gender: {gender}
+        - Duration of Symptoms: {duration}
+        - Reported Symptoms: {', '.join(symptoms)}
+        
+        Format your response as a valid JSON object with the following structure. 
+        Ensure all values are properly quoted strings or arrays and the JSON is properly formatted:
+        
+        {{
+            "initial_assessment": {{
+                "summary": "string",
+                "primary_symptoms": ["string"],
+                "duration_analysis": "string"
+            }},
+            "possible_conditions": {{
+                "primary_possibilities": [
+                    {{
+                        "name": "string",
+                        "likelihood": "string",
+                        "description": "string",
+                        "typical_duration": "string",
+                        "complications": ["string"]
+                    }}
+                ],
+                "differential_diagnoses": ["string"]
+            }},
+            "severity_indicators": {{
+                "current_level": "string",
+                "explanation": "string",
+                "warning_signs": ["string"],
+                "emergency_indicators": ["string"]
+            }},
+            "recommendations": {{
+                "immediate_steps": ["string"],
+                "home_care": ["string"],
+                "medications": {{
+                    "over_the_counter": ["string"],
+                    "precautions": ["string"]
+                }},
+                "lifestyle_changes": ["string"]
+            }},
+            "when_to_seek_care": {{
+                "emergency_care": ["string"],
+                "urgent_care": ["string"],
+                "routine_care": ["string"]
+            }},
+            "prevention": {{
+                "immediate_actions": ["string"],
+                "long_term_strategies": ["string"]
+            }},
+            "follow_up": {{
+                "monitoring": ["string"],
+                "timeline": "string",
+                "documentation": ["string"]
+            }},
+            "education": {{
+                "condition_info": ["string"],
+                "myths_facts": ["string"],
+                "additional_resources": ["string"]
+            }},
+            "disclaimers": {{
+                "medical_advice": "string",
+                "limitations": ["string"],
+                "emergency_notice": "string"
+            }}
+        }}
+
+        Return ONLY the JSON object with no additional text or formatting.
+        """
+
+def generate_body_based_prompt(data: dict) -> str:
+    body_parts = ', '.join(data['body_parts'])
+    symptom_types = ', '.join(data['symptom_types'])
+    
+    return f"""
+        As a medical information assistant, analyze these multiple body-related symptoms and provide a response in valid JSON format.
+        
+        Patient Information:
+        - Age: {data['age']}
+        - Gender: {data['gender']}
+        - Affected Areas: {body_parts}
+        - Symptom Types: {symptom_types}
+        - Severity: {data['severity']}
+        - Duration: {data['duration']}
+        - Description: {data['description']}
+        
+        Format your response as a valid JSON object with the following structure.
+        Ensure all values are properly quoted strings or arrays and the JSON is properly formatted:
+        
+        {{
+            "symptom_analysis": {{
+                "locations": [
+                    {{
+                        "area": "string",
+                        "involved_structures": ["string"],
+                        "radiation_patterns": ["string"],
+                        "specific_symptoms": ["string"]
+                    }}
+                ],
+                "characteristics": {{
+                    "primary_symptoms": ["string"],
+                    "quality": ["string"],
+                    "severity": "string",
+                    "pattern": "string",
+                    "aggravating_factors": ["string"],
+                    "relieving_factors": ["string"]
+                }}
+            }},
+            "clinical_considerations": {{
+                "possible_conditions": [
+                    {{
+                        "name": "string",
+                        "likelihood": "string",
+                        "description": "string",
+                        "typical_progression": "string",
+                        "affected_areas": ["string"]
+                    }}
+                ],
+                "risk_factors": ["string"],
+                "red_flags": ["string"]
+            }},
+            "diagnostic_approach": {{
+                "key_questions": [
+                    {{
+                        "question": "string",
+                        "reason": "string",
+                        "significance": "string"
+                    }}
+                ],
+                "physical_findings": ["string"],
+                "suggested_monitoring": ["string"]
+            }},
+            "management_recommendations": {{
+                "immediate_care": {{
+                    "actions": ["string"],
+                    "restrictions": ["string"],
+                    "positioning": "string"
+                }},
+                "pain_management": {{
+                    "medications": ["string"],
+                    "physical_measures": ["string"],
+                    "precautions": ["string"]
+                }},
+                "activity_modification": {{
+                    "restricted_activities": ["string"],
+                    "permitted_activities": ["string"],
+                    "gradual_progression": "string"
+                }}
+            }},
+            "care_guidance": {{
+                "self_care": ["string"],
+                "medical_care": {{
+                    "when_to_seek": ["string"],
+                    "type_of_care": "string",
+                    "urgency": "string"
+                }}
+            }},
+            "prevention_education": {{
+                "recurrence_prevention": ["string"],
+                "lifestyle_modifications": ["string"],
+                "ergonomic_advice": ["string"]
+            }},
+            "prognosis": {{
+                "expected_course": "string",
+                "recovery_timeline": "string",
+                "complications": ["string"]
+            }},
+            "disclaimers": {{
+                "medical_advice": "string",
+                "limitations": ["string"],
+                "emergency_notice": "string"
+            }}
+        }}
+
+        Return ONLY the JSON object with no additional text or formatting.
+        """

main.py

@@ -0,0 +1,28 @@
+# main.py
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.core.config import init_config
+from app.api.routes import router
+
+# Initialize configuration before creating the app
+init_config()
+
+app = FastAPI(
+    title="Symptom Analysis System",
+    description="AI-powered symptom analysis system",
+    version="1.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(router)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

requirements.txt

@@ -0,0 +1,24 @@
+annotated-types==0.7.0
+anyio==4.7.0
+click==8.1.7
+colorama==0.4.6
+fastapi==0.115.6
+h11==0.14.0
+idna==3.10
+joblib==1.4.2
+numpy==2.2.0
+pandas==2.2.3
+pydantic==2.10.3
+pydantic_core==2.27.1
+python-dateutil==2.9.0.post0
+python-multipart==0.0.19
+pytz==2024.2
+scikit-learn==1.0.2
+scipy==1.14.1
+six==1.17.0
+sniffio==1.3.1
+starlette==0.41.3
+threadpoolctl==3.5.0
+typing_extensions==4.12.2
+tzdata==2024.2
+uvicorn==0.32.1