Upload 23 files

Dockerfile

@@ -0,0 +1,23 @@
+# Use a lightweight Python image
+FROM python:3.10-slim
+
+# Create app directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y ffmpeg && rm -rf /var/lib/apt/lists/*
+
+# Copy dependency files
+COPY requirements.txt .
+
+# Install Python deps
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Copy the source code
+COPY . .
+
+# Expose port (default for Hugging Face Spaces)
+EXPOSE 7860
+
+# Run app using Uvicorn
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

Readme.md

@@ -0,0 +1,7 @@
+# Dubsway Video AI
+
+This FastAPI app handles authentication, video uploads, and PDF analysis using Whisper and Transformers.
+
+- 🔐 Auth with email
+- 📤 Upload any video file
+- 📄 Generates summary PDFs

app/auth.py

@@ -0,0 +1,73 @@
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from passlib.context import CryptContext
+from jose import jwt
+from pydantic import BaseModel, EmailStr
+from app.database import get_db  # Updated: use the correct async session dependency
+from app.models import User
+import os
+import logging
+from dotenv import load_dotenv
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+# Load secret key and JWT algorithm
+SECRET_KEY = os.getenv("SECRET_KEY", "secret")
+ALGORITHM = "HS256"
+
+# Password hashing config
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+# Request Schemas
+class SignUp(BaseModel):
+    email: EmailStr
+    password: str
+
+
+class Login(BaseModel):
+    email: EmailStr
+    password: str
+
+
+@router.post("/auth/signup")
+async def signup(data: SignUp, db: AsyncSession = Depends(get_db)):
+    # Check if user already exists
+    result = await db.execute(select(User).where(User.email == data.email))
+    existing_user = result.scalar_one_or_none()
+
+    if existing_user:
+        raise HTTPException(status_code=400, detail="Email already exists")
+
+    hashed_password = pwd_context.hash(data.password)
+    new_user = User(email=data.email, hashed_password=hashed_password)
+
+    try:
+        db.add(new_user)
+        await db.commit()
+        await db.refresh(new_user)
+        return {"message": "User created", "user_id": new_user.id}
+    except Exception as e:
+        await db.rollback()
+        logger.error(f"Signup error: {e}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+
+
+@router.post("/auth/login")
+async def login(data: Login, db: AsyncSession = Depends(get_db)):
+    result = await db.execute(select(User).where(User.email == data.email))
+    user = result.scalar_one_or_none()
+
+    if not user or not pwd_context.verify(data.password, user.hashed_password):
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+
+    token = jwt.encode({"user_id": user.id}, SECRET_KEY, algorithm=ALGORITHM)
+    return {
+        "access_token": token,
+        "token_type": "bearer",
+        "user": {"id": user.id, "email": user.email},
+    }

app/dashboard.py

@@ -0,0 +1,41 @@
+from fastapi import APIRouter, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy import desc
+from app.database import engine
+from app.models import VideoUpload
+
+router = APIRouter()
+
+# Create async DB session
+async_session = sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)
+
+
+@router.get("/dashboard/{user_id}")
+async def get_user_dashboard(user_id: int):
+    try:
+        async with async_session() as session:
+            query = (
+                select(VideoUpload)
+                .where(VideoUpload.user_id == user_id)
+                .order_by(desc(VideoUpload.created_at))
+            )
+            result = await session.execute(query)
+            uploads = result.scalars().all()
+
+            # Convert SQLAlchemy objects to dicts for response
+            return [
+                {
+                    "id": upload.id,
+                    "video_url": upload.video_url,
+                    "pdf_url": upload.pdf_url,
+                    "status": upload.status,
+                    "created_at": upload.created_at,
+                }
+                for upload in uploads
+            ]
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Error fetching dashboard data: {str(e)}"
+        )

app/database.py

@@ -0,0 +1,32 @@
+import os
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker, declarative_base
+from dotenv import load_dotenv
+
+# Load .env variables
+load_dotenv()
+
+# Ensure your DATABASE_URL is in correct asyncpg format
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+if not DATABASE_URL:
+    raise RuntimeError("DATABASE_URL is not set in environment.")
+
+# Create the async engine
+engine = create_async_engine(
+    DATABASE_URL, echo=True, future=True  # Set echo=False in production
+)
+
+# Session factory
+AsyncSessionLocal = sessionmaker(
+    bind=engine, class_=AsyncSession, expire_on_commit=False
+)
+
+# Base class for models
+Base = declarative_base()
+
+
+# Dependency for routes to get the async session
+async def get_db():
+    async with AsyncSessionLocal() as session:
+        yield session

app/main.py

@@ -0,0 +1,43 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import logging
+
+from app.auth import router as auth_router
+from app.upload import router as upload_router
+from app.dashboard import router as dashboard_router
+
+# Initialize logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="Dubsway Video AI",
+    description="Production-ready API for auth, video upload, and analysis",
+    version="1.0.0",
+    docs_url="/docs",  # Optional: secure this in prod
+    redoc_url=None,
+)
+
+# Allow frontend (adjust in prod!)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # REPLACE with frontend URL in production!
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include API routes
+app.include_router(auth_router, prefix="/api", tags=["Auth"])
+app.include_router(upload_router, prefix="/api", tags=["Upload"])
+app.include_router(dashboard_router, prefix="/api", tags=["Dashboard"])
+
+
+@app.on_event("startup")
+async def startup_event():
+    logger.info("✅ FastAPI app started")
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    logger.info("🛑 FastAPI app shutdown")

app/models.py

@@ -0,0 +1,21 @@
+from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime
+from sqlalchemy.sql import func
+from .database import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+
+
+class VideoUpload(Base):
+    __tablename__ = "video_uploads"
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    video_url = Column(Text)
+    pdf_url = Column(Text)
+    status = Column(String, default="pending")  # pending, processing, completed
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())

app/run_once.py

@@ -0,0 +1,13 @@
+# run_once.py
+from app.database import Base, engine
+from app import models
+
+
+async def init():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+import asyncio
+
+asyncio.run(init())

app/testdb.py

@@ -0,0 +1,13 @@
+# test_db.py
+from app.database import engine
+from sqlalchemy import text
+import asyncio
+
+
+async def test_connection():
+    async with engine.connect() as conn:
+        result = await conn.execute(text("SELECT 1"))
+        print("DB Connection OK:", result.scalar())
+
+
+asyncio.run(test_connection())

app/upload.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, UploadFile, Form, HTTPException, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from app.database import get_db
+from app.models import VideoUpload
+from .utils.s3 import upload_to_s3
+import uuid
+import os
+
+router = APIRouter()
+
+# Accept any video file
+ALLOWED_VIDEO_MIME_TYPES = {
+    "video/mp4",
+    "video/x-matroska",  # mkv
+    "video/quicktime",  # mov
+    "video/x-msvideo",  # avi
+    "video/webm",
+    "video/mpeg",
+}
+
+
+@router.post("/upload")
+async def upload_video(
+    user_id: int = Form(...),
+    file: UploadFile = Form(...),
+    db: AsyncSession = Depends(get_db),
+):
+    if file.content_type not in ALLOWED_VIDEO_MIME_TYPES:
+        raise HTTPException(
+            status_code=400, detail=f"Unsupported file type: {file.content_type}"
+        )
+
+    try:
+        uid = str(uuid.uuid4())
+        s3_key = f"videos/{uid}/{file.filename}"
+        video_url = upload_to_s3(file, s3_key)
+
+        new_video = VideoUpload(
+            user_id=user_id,
+            video_url=video_url,
+            pdf_url="",  # will be set after analysis
+            status="pending",
+        )
+        db.add(new_video)
+        await db.commit()
+        await db.refresh(new_video)
+
+        return {"status": "uploaded", "video_url": video_url, "video_id": new_video.id}
+
+    except Exception as e:
+        await db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))

app/utils/pdf.py

@@ -0,0 +1,15 @@
+from reportlab.pdfgen import canvas
+from io import BytesIO
+
+
+def generate(transcription: str, summary: str):
+    buffer = BytesIO()
+    c = canvas.Canvas(buffer)
+    c.drawString(100, 800, "📄 Video Summary Report")
+    c.drawString(100, 770, "Transcription:")
+    c.drawString(100, 750, transcription[:1000])
+    c.drawString(100, 700, "Summary:")
+    c.drawString(100, 680, summary[:1000])
+    c.save()
+    buffer.seek(0)
+    return buffer.read()

app/utils/s3.py

@@ -0,0 +1,20 @@
+import boto3, os
+from dotenv import load_dotenv
+
+s3 = boto3.client(
+    "s3",
+    aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+    aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+    region_name=os.getenv("AWS_REGION"),
+)
+bucket = os.getenv("S3_BUCKET")
+
+
+def upload_to_s3(file, key):
+    s3.upload_fileobj(file.file, bucket, key)
+    return f"https://{bucket}.s3.amazonaws.com/{key}"
+
+
+def upload_pdf_bytes(data: bytes, key: str):
+    s3.put_object(Bucket=bucket, Key=key, Body=data, ContentType="application/pdf")
+    return f"https://{bucket}.s3.amazonaws.com/{key}"

app/utils/whisper_llm.py

@@ -0,0 +1,22 @@
+import whisper
+from transformers import pipeline
+import requests
+import tempfile
+
+
+def analyze(video_url: str):
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
+    with requests.get(video_url, stream=True) as r:
+        for chunk in r.iter_content(8192):
+            tmp.write(chunk)
+    tmp.close()
+
+    model = whisper.load_model("base")
+    result = model.transcribe(tmp.name)
+    text = result["text"]
+
+    summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
+    summary = summarizer(text, max_length=512, min_length=128, do_sample=False)[0][
+        "summary_text"
+    ]
+    return text, summary