app.py

"""
app.py
------
FastAPI web application for the Climate Visibility project — matches
the "Final Project Demo" screenshots in the PPT: a form with
DRYBULBTEMPF, RelativeHumidity, WindSpeed, WindDirection,
SeaLevelPressure, a "Predict the Climate Visibility" button, and a
/predict page showing "Predicted Visibility: X.XXX km".

Also exposes /train to kick off the training pipeline (equivalent to
running `python main.py`), matching the "End to End Pipeline Run"
step in the project flow.

Run with:
    uvicorn app:app --host 127.0.0.1 --port 8062 --reload
Or:
    python app.py
"""
import os
import sys

from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
import uvicorn
from typing import Optional, cast

from src.constant.training_pipeline import APP_HOST, APP_PORT
from src.exception import ClimateVisibilityException
from src.logger import logging
from src.pipeline.prediction_pipeline import VisibilityData, predict_visibility
from src.pipeline.training_pipeline import TrainingPipeline

app = FastAPI(title="Climate Visibility Prediction")

BASE_DIR = os.path.dirname(__file__)
app.mount("/static", StaticFiles(directory=os.path.join(BASE_DIR, "static")), name="static")
templates = Jinja2Templates(directory=os.path.join(BASE_DIR, "templates"))


@app.get("/", response_class=HTMLResponse)
async def index(request: Request):
    return templates.TemplateResponse(
        request=request,
        name="index.html",
        context={"request": request},
    )

@app.get("/train")
async def train_route():
    """Kicks off the full training pipeline (data ingestion -> model pusher)."""
    try:
        artifact = TrainingPipeline().run_pipeline()
        return {
            "status": "success",
            "message": "Training pipeline completed successfully.",
            "model_path": artifact.model_file_path,
        }
    except Exception as e:
        raise ClimateVisibilityException(e, sys) from e


@app.post("/predict", response_class=HTMLResponse)
async def predict_route(
    request: Request,
    DRYBULBTEMPF: Optional[float] = None,
    RelativeHumidity: Optional[float] = None,
    WindSpeed: Optional[float] = None,
    WindDirection: Optional[float] = None,
    SeaLevelPressure: Optional[float] = None,
):
    form = await request.form()
    try:
        input_data = VisibilityData(
            DRYBULBTEMPF=float(cast(str, form.get("DRYBULBTEMPF"))),
            RelativeHumidity=float(cast(str, form.get("RelativeHumidity"))),
            WindSpeed=float(cast(str, form.get("WindSpeed"))),
            WindDirection=float(cast(str, form.get("WindDirection"))),
            SeaLevelPressure=float(cast(str, form.get("SeaLevelPressure"))),
        )
        prediction = predict_visibility(input_data)

        return templates.TemplateResponse(
            request=request,
            name="result.html",
            context={
                "request": request,
                "prediction": prediction,
            },
        )
    except FileNotFoundError:
        logging.warning("No trained model found — run /train (or `python main.py`) first.")
        return templates.TemplateResponse(
            request=request,
            name="index.html",
            context={
                "request": request,
                "error": (
                    "No trained model found yet. Please run the training "
                    "pipeline first (GET /train or `python main.py`)."
                ),
            },
        )
    except Exception as e:
        raise ClimateVisibilityException(e, sys) from e


@app.get("/health")
async def health():
    return {"status": "ok"}


if __name__ == "__main__":
    uvicorn.run("app:app", host=APP_HOST, port=APP_PORT, reload=True)