Add deployment files (Dockerfile, app, requirements)

Dockerfile

@@ -1,20 +1,29 @@
-FROM python:3.13.5-slim
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
 
-WORKDIR /app
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+# Create working directory
+WORKDIR /app
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Install system dependencies (git for huggingface repo usage)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
 
-RUN pip3 install -r requirements.txt
+# Copy requirements and app
+COPY requirements.txt /app/requirements.txt
+RUN pip install --upgrade pip
+RUN pip install --no-cache-dir -r /app/requirements.txt
 
-EXPOSE 8501
+# Copy application files
+COPY app.py /app/app.py
+COPY README.md /app/README.md
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Expose port (the app will run on this)
+EXPOSE 7860
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# By default, run the app
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,164 @@
+# app.py
+import os
+import io
+import pandas as pd
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from pydantic import BaseModel
+from typing import List, Optional, Any
+from huggingface_hub import hf_hub_download, login
+import joblib
+import uvicorn
+from contextlib import asynccontextmanager # Added this import
+
+MODEL_REPO_ID = "sumitsinha2603/TourismPackagePredictionAnalysisModel"
+MODEL_FILENAME = "TourismPackagePredictionAnalysisModel_v1.joblib"
+HF_TOKEN = userdata.get('hf_token')
+api = HfApi(token=HF_TOKEN)
+DOWNLOAD_DIR = "/tmp/hf_model"
+
+# -------- Initialize FastAPI --------
+app = FastAPI(
+    title="Tourism Prediction Model Serving",
+    description="Load model from HF Hub, accept inputs, return predictions and save inputs to a DataFrame",
+    version="0.1"
+)
+
+model = None
+label_encoders = {}  
+
+def ensure_logged_in():
+    if HF_TOKEN:
+        login(token=HF_TOKEN)
+    else:
+        pass
+
+def load_model_from_hf():
+    """Download model file from HF Hub and load with joblib"""
+    global model
+    os.makedirs(DOWNLOAD_DIR, exist_ok=True)
+    ensure_logged_in()
+    try:
+        # Downloads file to local cache and returns full path
+        local_path = hf_hub_download(
+            repo_id=MODEL_REPO_ID,
+            filename=MODEL_FILENAME,
+            repo_type="model",
+            token=HF_TOKEN
+        )
+    except Exception as e:
+        raise RuntimeError(f"Failed to download model from HF Hub: {e}")
+
+    # Load with joblib
+    model_obj = joblib.load(local_path)
+    model = model_obj
+    return model
+
+# Load model on startup
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    print("Loading model...")
+    global model
+    model = joblib.load("TourismPackagePredictionAnalysisModel_v1.joblib")
+    app.state.model = model
+    yield
+    print("Shutting down...")
+
+# Re-initialize FastAPI to include lifespan, ensuring it's only defined once
+app = FastAPI(
+    title="Tourism Prediction Model Serving",
+    description="Load model from HF Hub, accept inputs, return predictions and save inputs to a DataFrame",
+    version="0.1",
+    lifespan=lifespan # Pass the lifespan context manager here
+)
+
+class PredictRequest(BaseModel):
+    records: List[dict]
+
+# -------- Helper to coerce inputs into DataFrame --------
+def inputs_to_dataframe_from_file(file: UploadFile) -> pd.DataFrame:
+    # Accept CSV uploads
+    contents = file.file.read()
+    try:
+        df = pd.read_csv(io.BytesIO(contents))
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to parse CSV: {e}")
+    return df
+
+def inputs_to_dataframe_from_json(records: List[dict]) -> pd.DataFrame:
+    try:
+        df = pd.DataFrame(records)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Invalid JSON records: {e}")
+    return df
+
+# -------- Endpoint: predict --------
+@app.post("/predict")
+async def predict(payload: Optional[PredictRequest] = None, file: Optional[UploadFile] = File(None)):
+    """
+    Provide either:
+    - JSON body: {"records": [{...}, {...}]}
+    - or upload CSV file as form data
+    Returns predictions and the input dataframe saved as CSV inside container.
+    """
+    if payload is None and file is None:
+        raise HTTPException(status_code=400, detail="No input provided. Send JSON 'records' or upload a CSV file.")
+
+    # Convert input to dataframe
+    if file is not None:
+        df_in = inputs_to_dataframe_from_file(file)
+    else:
+        df_in = inputs_to_dataframe_from_json(payload.records)
+
+    current_model = app.state.model
+
+    if current_model is None:
+        # This block might be reached if lifespan failed or for debugging, but ideally model is always loaded
+        try:
+            load_model_from_hf()
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Model not loaded: {e}")
+        current_model = model # Update if load_model_from_hf was called
+
+    try:
+        preds = current_model.predict(df_in)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {e}")
+
+    # Save inputs
+    save_path = os.path.join("/app", "inputs.csv")
+    try:
+        # Append if file exists
+        if os.path.exists(save_path):
+            existing = pd.read_csv(save_path)
+            newdf = pd.concat([existing, df_in], ignore_index=True)
+            newdf.to_csv(save_path, index=False)
+        else:
+            df_in.to_csv(save_path, index=False)
+    except Exception as e:
+        # Non-fatal; continue
+        print("Warning: failed to save inputs:", e)
+
+    return {
+        "predictions": preds.tolist(),
+        "n_records": len(df_in),
+        "saved_to": save_path
+    }
+
+# -------- Endpoint: save raw inputs only (optional) --------
+@app.post("/save_inputs")
+async def save_inputs(payload: PredictRequest):
+    df_in = inputs_to_dataframe_from_json(payload.records)
+    save_path = os.path.join("/app", "inputs.csv")
+    if os.path.exists(save_path):
+        existing = pd.read_csv(save_path)
+        newdf = pd.concat([existing, df_in], ignore_index=True)
+        newdf.to_csv(save_path, index=False)
+    else:
+        df_in.to_csv(save_path, index=False)
+    return {"saved_to": save_path, "n_records": len(df_in)}
+
+# -------- Health check --------
+@app.get("/health")
+def health():
+    # Access model state via app.state
+    return {"status": "ok", "model_loaded": app.state.model is not None}

requirements.txt

@@ -1,3 +1,7 @@
-altair
-pandas
-streamlit
+pandas==2.2.2
+huggingface_hub==0.32.6
+streamlit==1.43.2
+joblib==1.5.1
+scikit-learn==1.6.0
+xgboost==2.1.4
+mlflow==3.0.1