ADD: FastAPI server for HF Spaces API endpoints

Added api_server.py - FastAPI backend with REST endpoints
/process-reviews endpoint for frontend integration
/health endpoint for status checking
Updated Dockerfile to run FastAPI server
Added FastAPI, uvicorn, pydantic to requirements
CORS enabled for frontend connections

Frontend can now connect: POST /process-reviews
Status: API architecture complete, ready for testing

Dockerfile

@@ -20,6 +20,7 @@ COPY requirements-docker.txt ./requirements.txt
 # Install Python dependencies (optimized for Docker)
 RUN pip install --no-cache-dir --upgrade pip && \
     pip install --no-cache-dir -r requirements.txt && \
+    pip install --no-cache-dir fastapi uvicorn pydantic && \
     python -m spacy download en_core_web_sm
 
 # Copy the rest of the application
@@ -43,5 +44,5 @@ EXPOSE 7860
 # Health check
 HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
 
-# Run the Streamlit app
-ENTRYPOINT ["streamlit", "run", "app_enhanced.py", "--server.port=7860", "--server.address=0.0.0.0"]
+# Run the FastAPI server (which also starts Streamlit)
+ENTRYPOINT ["python", "api_server.py"]

api_server.py

@@ -0,0 +1,142 @@
+"""
+FastAPI backend wrapper for HF Spaces
+Provides REST API endpoints while keeping Streamlit UI
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Dict, List, Any, Optional
+import pandas as pd
+import sys
+import os
+import uvicorn
+from threading import Thread
+import subprocess
+
+# Add src to path for imports
+current_dir = os.path.dirname(os.path.abspath(__file__))
+src_path = os.path.join(current_dir, 'src')
+if src_path not in sys.path:
+    sys.path.insert(0, src_path)
+
+from utils.data_processor import DataProcessor
+
+app = FastAPI(title="ABSA ML Backend API", version="1.0.0")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize processor (cached)
+processor = None
+
+def get_processor():
+    global processor
+    if processor is None:
+        processor = DataProcessor()
+    return processor
+
+class ReviewData(BaseModel):
+    id: int
+    reviews_title: str
+    review: str
+    date: str
+    user_id: str
+
+class ProcessRequest(BaseModel):
+    data: List[ReviewData]
+    options: Optional[Dict[str, Any]] = {}
+
+class ProcessResponse(BaseModel):
+    status: str
+    data: Optional[Dict[str, Any]] = None
+    message: Optional[str] = None
+
+@app.get("/")
+async def root():
+    return {"message": "ABSA ML Backend API", "status": "running"}
+
+@app.get("/health")
+async def health_check():
+    try:
+        proc = get_processor()
+        return {
+            "status": "healthy",
+            "translation_service": "available" if hasattr(proc.translator, 'model') else "unavailable",
+            "absa_service": "available" if hasattr(proc.absa_processor, 'aspect_extractor') else "unavailable"
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@app.post("/process-reviews", response_model=ProcessResponse)
+async def process_reviews(request: ProcessRequest):
+    try:
+        # Convert request data to DataFrame
+        data_list = [item.dict() for item in request.data]
+        df = pd.DataFrame(data_list)
+        
+        # Process data
+        proc = get_processor()
+        results = proc.process_uploaded_data(df)
+        
+        if 'error' in results:
+            raise HTTPException(status_code=400, detail=results['error'])
+        
+        # Serialize for API response
+        serialized_results = serialize_for_api(results)
+        
+        return ProcessResponse(
+            status="success",
+            data=serialized_results
+        )
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+def serialize_for_api(results: Dict) -> Dict:
+    """Convert complex objects to JSON-serializable format."""
+    serialized = {}
+    
+    for key, value in results.items():
+        if key == 'processed_data':
+            # Convert DataFrame to dict
+            serialized[key] = value.to_dict('records') if hasattr(value, 'to_dict') else value
+        elif key == 'aspect_network':
+            # Convert NetworkX graph to dict
+            import networkx as nx
+            if hasattr(value, 'nodes'):
+                serialized[key] = nx.node_link_data(value)
+            else:
+                serialized[key] = value
+        elif hasattr(value, 'to_dict'):
+            # Convert DataFrames
+            serialized[key] = value.to_dict('records')
+        elif isinstance(value, pd.DataFrame):
+            serialized[key] = value.to_dict('records')
+        else:
+            # Keep as is for basic types
+            serialized[key] = value
+    
+    return serialized
+
+def run_streamlit():
+    """Run Streamlit in a separate thread"""
+    subprocess.run([
+        "streamlit", "run", "app_enhanced.py", 
+        "--server.port=8502", 
+        "--server.address=0.0.0.0"
+    ])
+
+if __name__ == "__main__":
+    # Start Streamlit in background
+    streamlit_thread = Thread(target=run_streamlit, daemon=True)
+    streamlit_thread.start()
+    
+    # Start FastAPI
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements-docker.txt

@@ -33,4 +33,7 @@ pillow>=10.0.0,<10.2.0
 requests>=2.31.0
 faker>=18.0.0
 openpyxl>=3.1.0
-reportlab>=4.0.0
+reportlab>=4.0.0
+fastapi>=0.104.0
+uvicorn>=0.24.0
+pydantic>=2.0.0