Add file upload functionality for provider notes

requirements.txt

@@ -1,6 +1,6 @@
 fastapi==0.104.1
-uvicorn[standard]==0.24.0
-groq==0.11.0
-pydantic==2.5.0
+uvicorn==0.24.0
 python-dotenv==1.0.0
-httpx==0.27.0
+groq==0.4.1
+pydantic==2.5.0
+python-multipart==0.0.6

src/api/routes.py

@@ -1,34 +1,97 @@
-from fastapi import APIRouter, HTTPException
-import sys
-import os
-
-# Add parent directory to path for imports
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from models.request_models import ProviderNotesRequest
+from fastapi import APIRouter, HTTPException, UploadFile, File
+from models.request_models import ProviderNotesRequest, FileUploadResponse
 from models.response_models import CodingResponse
 from services.groq_service import groq_service
+from services.file_service import file_service
+import logging
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
 
-router = APIRouter(prefix="/api/v1", tags=["Medical Coding"])
 
-@router.post("/analyze", response_model=CodingResponse)
+# EXISTING ENDPOINT - DO NOT CHANGE
+@router.post("/coding", response_model=CodingResponse)
 async def analyze_provider_notes(request: ProviderNotesRequest):
     """
-    Analyze provider notes and return ICD-10 and CPT codes with explanations.
+    Analyze provider notes and extract ICD-10 and CPT codes
     
-    - **provider_notes**: The medical provider notes to analyze
-    
-    Returns ICD-10 codes, CPT codes, and explanations for each.
+    This endpoint accepts provider notes as text input.
     """
     try:
-        result = await groq_service.analyze_provider_notes(request.provider_notes)
-        return CodingResponse(**result)
-    except ValueError as e:
-        raise HTTPException(status_code=422, detail=str(e))
+        logger.info("Received coding request")
+        
+        # Get provider notes from request
+        provider_notes = request.provider_notes
+        
+        if not provider_notes or len(provider_notes.strip()) < 10:
+            raise HTTPException(
+                status_code=400,
+                detail="Provider notes must be at least 10 characters long"
+            )
+        
+        # Process through Groq service
+        result = await groq_service.analyze_notes(provider_notes)
+        
+        logger.info("Successfully processed coding request")
+        return result
+        
+    except HTTPException:
+        raise
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+        logger.error(f"Error in analyze_provider_notes: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing request: {str(e)}"
+        )
+
 
-@router.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {"status": "healthy", "service": "ICD-CPT Coding API"}
+# NEW ENDPOINT - File Upload
+@router.post("/upload-file", response_model=FileUploadResponse)
+async def upload_provider_notes_file(file: UploadFile = File(...)):
+    """
+    Upload a TXT file containing provider notes and extract ICD-10 and CPT codes
+    
+    This endpoint accepts a TXT file, extracts the text, and processes it through the LLM.
+    
+    Args:
+        file: TXT file containing provider notes
+        
+    Returns:
+        FileUploadResponse with extracted codes and explanations
+    """
+    try:
+        logger.info(f"Received file upload request: {file.filename}")
+        
+        # Step 1: Extract text from uploaded file
+        extraction_result = await file_service.extract_text_from_file(file)
+        
+        extracted_text = extraction_result["text"]
+        filename = extraction_result["filename"]
+        text_length = extraction_result["text_length"]
+        
+        logger.info(f"Extracted {text_length} characters from {filename}")
+        
+        # Step 2: Process extracted text through Groq LLM
+        coding_result = await groq_service.analyze_notes(extracted_text)
+        
+        logger.info(f"Successfully processed file: {filename}")
+        
+        # Step 3: Return combined response
+        return FileUploadResponse(
+            success=True,
+            filename=filename,
+            extracted_text_length=text_length,
+            cpt_codes=coding_result.cpt_codes,
+            cpt_explanation=coding_result.cpt_explanation,
+            icd_codes=coding_result.icd_codes,
+            icd_explanation=coding_result.icd_explanation
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in upload_provider_notes_file: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing uploaded file: {str(e)}"
+        )

src/main.py

@@ -1,19 +1,17 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-import sys
-import os
-
-# Add current directory to path
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
 from api.routes import router
+import uvicorn
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 app = FastAPI(
-    title="ICD-10 and CPT Coding API",
-    description="Analyzes medical provider notes and returns appropriate ICD-10 and CPT codes with explanations",
-    version="1.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc"
+    title="ICD-10 & CPT Code Analyzer",
+    description="AI-powered medical coding assistant",
+    version="1.1.0"
 )
 
 # CORS middleware
@@ -25,17 +23,24 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Include routers
-app.include_router(router)
+# Include API routes
+app.include_router(router, prefix="/api")
 
 @app.get("/")
 async def root():
     return {
-        "message": "ICD-10 and CPT Coding API",
-        "docs": "/docs",
-        "health": "/api/v1/health"
+        "message": "ICD-10 & CPT Code Analyzer API",
+        "version": "1.1.0",
+        "endpoints": {
+            "text_input": "/api/coding",
+            "file_upload": "/api/upload-file",
+            "docs": "/docs"
+        }
     }
 
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
 if __name__ == "__main__":
-    import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

src/models/request_models.py

@@ -22,4 +22,29 @@ class CodingResponse(BaseModel):
     cpt_codes: list
     cpt_explanation: str
     icd_codes: list
-    icd_explanation: str
+    icd_explanation: str
+
+
+# NEW: File upload response model
+class FileUploadResponse(BaseModel):
+    """Response model for file upload endpoint"""
+    success: bool = Field(description="Whether file processing was successful")
+    filename: str = Field(description="Name of uploaded file")
+    extracted_text_length: int = Field(description="Length of extracted text")
+    cpt_codes: list = Field(description="List of CPT codes")
+    cpt_explanation: str = Field(description="Explanation of CPT codes")
+    icd_codes: list = Field(description="List of ICD codes")
+    icd_explanation: str = Field(description="Explanation of ICD codes")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "success": True,
+                "filename": "provider_notes.txt",
+                "extracted_text_length": 450,
+                "cpt_codes": ["99213", "93000"],
+                "cpt_explanation": "Office visit and EKG",
+                "icd_codes": ["I20.0", "R07.9"],
+                "icd_explanation": "Unstable angina and chest pain"
+            }
+        }

src/services/file_service.py

@@ -0,0 +1,109 @@
+from fastapi import UploadFile, HTTPException
+import os
+from typing import Dict
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class FileService:
+    """Service to handle file uploads and text extraction"""
+    
+    ALLOWED_EXTENSIONS = {'.txt'}
+    MAX_FILE_SIZE = 10 * 1024 * 1024  # 10 MB
+    
+    @staticmethod
+    def validate_file(file: UploadFile) -> None:
+        """
+        Validate uploaded file
+        
+        Args:
+            file: Uploaded file object
+            
+        Raises:
+            HTTPException: If file is invalid
+        """
+        # Check if file exists
+        if not file:
+            raise HTTPException(status_code=400, detail="No file provided")
+        
+        # Check file extension
+        file_ext = os.path.splitext(file.filename)[1].lower()
+        if file_ext not in FileService.ALLOWED_EXTENSIONS:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Invalid file type. Only {', '.join(FileService.ALLOWED_EXTENSIONS)} files are allowed"
+            )
+    
+    @staticmethod
+    async def extract_text_from_file(file: UploadFile) -> Dict[str, any]:
+        """
+        Extract text content from uploaded file
+        
+        Args:
+            file: Uploaded file object
+            
+        Returns:
+            Dictionary containing extracted text and metadata
+        """
+        try:
+            # Validate file
+            FileService.validate_file(file)
+            
+            # Read file content
+            content = await file.read()
+            
+            # Check file size
+            file_size = len(content)
+            if file_size > FileService.MAX_FILE_SIZE:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"File too large. Maximum size is {FileService.MAX_FILE_SIZE / (1024*1024)} MB"
+                )
+            
+            # Decode text
+            try:
+                text = content.decode('utf-8')
+            except UnicodeDecodeError:
+                try:
+                    text = content.decode('latin-1')
+                except Exception as e:
+                    raise HTTPException(
+                        status_code=400,
+                        detail="Unable to decode file. Please ensure it's a valid text file"
+                    )
+            
+            # Validate extracted text
+            if not text.strip():
+                raise HTTPException(
+                    status_code=400,
+                    detail="File is empty or contains no readable text"
+                )
+            
+            if len(text.strip()) < 10:
+                raise HTTPException(
+                    status_code=400,
+                    detail="Extracted text is too short. Please provide more detailed provider notes"
+                )
+            
+            logger.info(f"Successfully extracted {len(text)} characters from {file.filename}")
+            
+            return {
+                "text": text,
+                "filename": file.filename,
+                "file_size": file_size,
+                "text_length": len(text)
+            }
+            
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"Error extracting text from file: {str(e)}")
+            raise HTTPException(
+                status_code=500,
+                detail=f"Error processing file: {str(e)}"
+            )
+
+
+# Singleton instance
+file_service = FileService()

tests/test_api.py

@@ -1,11 +1,13 @@
 from fastapi.testclient import TestClient
 from src.main import app
+from io import BytesIO
 
 client = TestClient(app)
 
 def test_coding_endpoint():
+    """Test existing text input endpoint"""
     provider_notes = {
-        "notes": "Patient has a fever and cough."
+        "provider_notes": "Patient has a fever and cough."
     }
     
     response = client.post("/api/coding", json=provider_notes)
@@ -13,9 +15,56 @@ def test_coding_endpoint():
     assert response.status_code == 200
     data = response.json()
     
-    assert "CPT" in data
-    assert "ICD" in data
-    assert isinstance(data["CPT"], list)
-    assert isinstance(data["ICD"], list)
-    assert "explanation" in data["CPT"][0]
-    assert "explanation" in data["ICD"][0]
+    assert "cpt_codes" in data
+    assert "icd_codes" in data
+    assert isinstance(data["cpt_codes"], list)
+    assert isinstance(data["icd_codes"], list)
+
+
+def test_file_upload_endpoint():
+    """Test new file upload endpoint"""
+    # Create a sample TXT file
+    file_content = b"Patient John Doe presents with acute bronchitis. Cough for 5 days, productive with yellow sputum. Lung exam reveals diffuse wheezing."
+    
+    files = {
+        "file": ("provider_notes.txt", BytesIO(file_content), "text/plain")
+    }
+    
+    response = client.post("/api/upload-file", files=files)
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert data["success"] is True
+    assert data["filename"] == "provider_notes.txt"
+    assert data["extracted_text_length"] > 0
+    assert "cpt_codes" in data
+    assert "icd_codes" in data
+    assert isinstance(data["cpt_codes"], list)
+    assert isinstance(data["icd_codes"], list)
+
+
+def test_file_upload_invalid_extension():
+    """Test file upload with invalid file type"""
+    file_content = b"Some content"
+    
+    files = {
+        "file": ("document.pdf", BytesIO(file_content), "application/pdf")
+    }
+    
+    response = client.post("/api/upload-file", files=files)
+    
+    assert response.status_code == 400
+
+
+def test_file_upload_empty_file():
+    """Test file upload with empty file"""
+    file_content = b""
+    
+    files = {
+        "file": ("empty.txt", BytesIO(file_content), "text/plain")
+    }
+    
+    response = client.post("/api/upload-file", files=files)
+    
+    assert response.status_code == 400