import joblib
import pickle
import json
from sklearn.ensemble import RandomForestClassifier
import numpy as np

# Train a simple model
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X, y)

# app.py
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import numpy as np

app = FastAPI(title="Iris Classifier API", version="1.0")

# Load model at startup (not per-request!)
model = joblib.load("iris_model.pkl")

class PredictionRequest(BaseModel):
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float

class PredictionResponse(BaseModel):
    prediction: int
    class_name: str
    confidence: float

CLASSES = ["setosa", "versicolor", "virginica"]

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

@app.post("/predict", response_model=PredictionResponse)
def predict(request: PredictionRequest):
    features = np.array([[
        request.sepal_length,
        request.sepal_width,
        request.petal_length,
        request.petal_width
    ]])
    
    pred = model.predict(features)[0]
    proba = model.predict_proba(features)[0]
    
    return PredictionResponse(
        prediction=int(pred),
        class_name=CLASSES[pred],
        confidence=round(float(proba[pred]), 4)
    )

# Install dependencies
pip install fastapi uvicorn scikit-learn joblib

# Start the server
uvicorn app:app --host 0.0.0.0 --port 8000 --reload

# Test it
curl -X POST "http://localhost:8000/predict" \
  -H "Content-Type: application/json" \
  -d '{"sepal_length": 5.1, "sepal_width": 3.5,
       "petal_length": 1.4, "petal_width": 0.2}'

# Dockerfile
FROM python:3.11-slim

# Set working directory
WORKDIR /app

# Install dependencies first (layer caching!)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY app.py .
COPY iris_model.pkl .

# Expose port
EXPOSE 8000

# Health check
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8000/health || exit 1

# Start the app
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# Build the image
docker build -t iris-classifier:v1 .

# Run the container
docker run -d \
  --name iris-api \
  -p 8000:8000 \
  iris-classifier:v1

# Check it's running
docker ps
docker logs iris-api

# Push to a registry
docker tag iris-classifier:v1 myregistry/iris-classifier:v1
docker push myregistry/iris-classifier:v1

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

mlflow.set_experiment("iris-classifier")

with mlflow.start_run(run_name="rf-v1"):
    X, y = load_iris(return_X_y=True)
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    
    # Log parameters
    params = {"n_estimators": 100, "max_depth": 5}
    mlflow.log_params(params)
    
    # Train
    model = RandomForestClassifier(**params, random_state=42)
    model.fit(X_train, y_train)
    
    # Log metrics
    preds = model.predict(X_test)
    mlflow.log_metric("accuracy", accuracy_score(y_test, preds))
    mlflow.log_metric("f1_score", f1_score(y_test, preds, average="macro"))
    
    # Log model   
    mlflow.sklearn.log_model(
    sk_model=model,
    name="model",
    registered_model_name="IrisClassifier",
    skops_trusted_types=["sklearn.tree._tree.Tree"]
)

# Start MLflow UI
mlflow ui --port 5000

# View at http://localhost:5000

# Load a specific version from the registry
import mlflow.pyfunc

# Load by version number
model_v1 = mlflow.pyfunc.load_model("models:/IrisClassifier/1")

# Load by stage (Staging, Production)
prod_model = mlflow.pyfunc.load_model("models:/IrisClassifier/Production")

# Make predictions
predictions = prod_model.predict(X_test)

import logging
import json
from datetime import datetime
from fastapi import FastAPI, Request
import time

app = FastAPI()
logger = logging.getLogger("ml_api")

@app.middleware("http")
async def log_requests(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    duration = time.time() - start_time
    
    logger.info(json.dumps({
        "timestamp": datetime.utcnow().isoformat(),
        "path": request.url.path,
        "method": request.method,
        "status_code": response.status_code,
        "duration_ms": round(duration * 1000, 2)
    }))
    return response

@app.post("/predict")
def predict(request: PredictionRequest):
    features = [request.sepal_length, request.sepal_width,
                request.petal_length, request.petal_width]
    pred = model.predict([features])[0]
    confidence = float(model.predict_proba([features])[0].max())
    
    # Log for drift detection
    logger.info(json.dumps({
        "event": "prediction",
        "input": features,
        "output": int(pred),
        "confidence": confidence,
        "timestamp": datetime.utcnow().isoformat()
    }))
    
    return {"prediction": int(pred), "confidence": confidence}

from evidently.report import Report
from evidently.metrics import DataDriftPreset
import pandas as pd

# Reference data (training distribution)
reference_data = pd.read_csv("training_data.csv")

# Current production data (last 7 days of inputs)
current_data = pd.read_csv("production_logs_last_7d.csv")

# Generate drift report
report = Report(metrics=[DataDriftPreset()])
snapshot=report.run(
    reference_data=reference_data[feature_cols],
    current_data=current_data[feature_cols]
)

# Save HTML report
snapshot.save_html("drift_report.html")

# Check programmatically
result = snapshot.as_dict()
drift_detected = result["metrics"][0]["result"]["dataset_drift"]

if drift_detected:
    send_alert("⚠️ Data drift detected! Consider retraining.")

## Pre-deployment Checklist

- [ ] Model serialized and version-tagged
- [ ] API tested with valid and invalid inputs  
- [ ] Docker image builds successfully
- [ ] Health check endpoint works
- [ ] Latency measured and acceptable (p99 < SLA)
- [ ] Logging captures inputs, outputs, latency
- [ ] Drift detection baseline established
- [ ] Rollback plan documented
- [ ] Load test passed
- [ ] Secrets managed via env vars (not hardcoded!)