from fastapi import FastAPI, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.orm import sessionmaker
from pydantic import BaseModel, EmailStr
import bcrypt

app = FastAPI()

# Database setup
engine = create_async_engine("postgresql+asyncpg://user:pass@localhost/db")
AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

# Dependency
async def get_db():
    async with AsyncSessionLocal() as session:
        yield session

# Pydantic models
class UserCreate(BaseModel):
    email: EmailStr
    password: str
    name: str

class UserResponse(BaseModel):
    id: int
    email: str
    name: str

# Create user endpoint
@app.post("/api/users", response_model=UserResponse, status_code=201)
async def create_user(user: UserCreate, db: AsyncSession = Depends(get_db)):
    # Hash password
    hashed = bcrypt.hashpw(user.password.encode(), bcrypt.gensalt())

    # Create user
    new_user = User(
        email=user.email,
        password=hashed.decode(),
        name=user.name
    )
    db.add(new_user)
    await db.commit()
    await db.refresh(new_user)

    return new_user

from datetime import datetime, timedelta
from jose import JWTError, jwt
from fastapi import HTTPException, Depends
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

def create_access_token(data: dict, expires_delta: timedelta = None):
    to_encode = data.copy()
    expire = datetime.utcnow() + (expires_delta or timedelta(hours=1))
    to_encode.update({"exp": expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm="HS256")

async def get_current_user(token: str = Depends(oauth2_scheme)):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        user_id: str = payload.get("sub")
        if user_id is None:
            raise HTTPException(status_code=401, detail="Invalid token")
        return user_id
    except JWTError:
        raise HTTPException(status_code=401, detail="Invalid token")

import pandas as pd
from fastapi import UploadFile

@app.post("/api/upload-csv")
async def process_csv(file: UploadFile):
    # Read CSV
    df = pd.read_csv(file.file)

    # Data validation
    required_columns = ['id', 'name', 'email']
    if not all(col in df.columns for col in required_columns):
        raise HTTPException(400, "Missing required columns")

    # Clean data
    df = df.dropna(subset=['email'])
    df['email'] = df['email'].str.lower().str.strip()

    # Process
    results = {
        "total_rows": len(df),
        "unique_emails": df['email'].nunique(),
        "summary": df.describe().to_dict()
    }

    return results

from celery import Celery

celery_app = Celery('tasks', broker='redis://localhost:6379/0')

@celery_app.task
def send_email_task(user_id: int):
    # Long-running email task
    send_email(user_id)

# From FastAPI endpoint
@app.post("/api/send-email/{user_id}")
async def trigger_email(user_id: int):
    send_email_task.delay(user_id)
    return {"message": "Email queued"}

import pickle
import numpy as np

# Load model at startup
with open('model.pkl', 'rb') as f:
    model = pickle.load(f)

class PredictionRequest(BaseModel):
    features: list[float]

@app.post("/api/predict")
async def predict(request: PredictionRequest):
    # Convert to numpy array
    X = np.array([request.features])

    # Predict
    prediction = model.predict(X)
    probability = model.predict_proba(X)

    return {
        "prediction": int(prediction[0]),
        "probability": float(probability[0][1])
    }