latest

app/app.py

@@ -0,0 +1,50 @@
+from contextlib import asynccontextmanager
+
+from fastapi import Depends, FastAPI
+
+from .db import User, create_db_and_tables
+from .schemas import UserCreate, UserRead, UserUpdate
+from .users import auth_backend, current_active_user, fastapi_users
+from .llm import *
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Not needed if you setup a migration system like Alembic
+    await create_db_and_tables()
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+
+app.include_router(
+    fastapi_users.get_auth_router(auth_backend), prefix="/auth/jwt", tags=["auth"]
+)
+app.include_router(
+  llm_router,
+  tags=["llm"]
+)
+app.include_router(
+    fastapi_users.get_register_router(UserRead, UserCreate),
+    prefix="/auth",
+    tags=["auth"],
+)
+app.include_router(
+    fastapi_users.get_reset_password_router(),
+    prefix="/auth",
+    tags=["auth"],
+)
+app.include_router(
+    fastapi_users.get_verify_router(UserRead),
+    prefix="/auth",
+    tags=["auth"],
+)
+app.include_router(
+    fastapi_users.get_users_router(UserRead, UserUpdate),
+    prefix="/users",
+    tags=["users"],
+)
+
+
+@app.get("/authenticated-route")
+async def authenticated_route(user: User = Depends(current_active_user)):
+    return {"message": f"Hello {user.email}!"}

app/db.py

@@ -0,0 +1,49 @@
+from typing import AsyncGenerator
+from app import app
+from fastapi import Depends
+from fastapi_users.db import SQLAlchemyBaseUserTableUUID, SQLAlchemyUserDatabase
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase
+
+from sqlalchemy import URL
+
+db_url = URL.create(
+    "postgresql",
+    username="avnadmin",
+    password="AVNS_u12fHxoNLBbzD8TGpqN",  # plain (unescaped) text
+    host="pg-opengenai-opengenai.b.aivencloud.com",
+    database="defaultdb",
+    port=14535,
+)
+
+
+DATABASE_URL = db_url
+#DATABASE_URL = "sqlite+aiosqlite:///./test.db"
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class User(SQLAlchemyBaseUserTableUUID, Base):
+    pass
+
+
+engine = create_async_engine(DATABASE_URL)
+async_session_maker = async_sessionmaker(engine, expire_on_commit=False)
+
+
+async def create_db_and_tables():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session_maker() as session:
+        yield session
+
+
+async def get_user_db(session: AsyncSession = Depends(get_async_session)):
+    yield SQLAlchemyUserDatabase(session, User)
+
+

app/schemas.py

@@ -0,0 +1,15 @@
+import uuid
+
+from fastapi_users import schemas
+
+
+class UserRead(schemas.BaseUser[uuid.UUID]):
+    pass
+
+
+class UserCreate(schemas.BaseUserCreate):
+    pass
+
+
+class UserUpdate(schemas.BaseUserUpdate):
+    pass

app/users.py

@@ -0,0 +1,56 @@
+import uuid
+from typing import Optional
+
+from fastapi import Depends, Request
+from fastapi_users import BaseUserManager, FastAPIUsers, UUIDIDMixin
+from fastapi_users.authentication import (
+    AuthenticationBackend,
+    BearerTransport,
+    JWTStrategy,
+)
+from fastapi_users.db import SQLAlchemyUserDatabase
+
+from app.db import User, get_user_db
+
+SECRET = "SECRET"
+
+
+class UserManager(UUIDIDMixin, BaseUserManager[User, uuid.UUID]):
+    reset_password_token_secret = SECRET
+    verification_token_secret = SECRET
+
+    async def on_after_register(self, user: User, request: Optional[Request] = None):
+        print(f"User {user.id} has registered.")
+
+    async def on_after_forgot_password(
+        self, user: User, token: str, request: Optional[Request] = None
+    ):
+        print(f"User {user.id} has forgot their password. Reset token: {token}")
+
+    async def on_after_request_verify(
+        self, user: User, token: str, request: Optional[Request] = None
+    ):
+        print(f"Verification requested for user {user.id}. Verification token: {token}")
+
+
+async def get_user_manager(user_db: SQLAlchemyUserDatabase = Depends(get_user_db)):
+    yield UserManager(user_db)
+
+
+bearer_transport = BearerTransport(tokenUrl="auth/jwt/login")
+
+
+def get_jwt_strategy() -> JWTStrategy:
+    return JWTStrategy(secret=SECRET, lifetime_seconds=3600)
+
+
+auth_backend = AuthenticationBackend(
+    name="jwt",
+    transport=bearer_transport,
+    get_strategy=get_jwt_strategy,
+)
+
+fastapi_users = FastAPIUsers[User, uuid.UUID](get_user_manager, [auth_backend])
+
+current_active_user = fastapi_users.current_user(active=True)
+

config.py

@@ -1,8 +0,0 @@
-import os
-#from pydantic import BaseSettings, Field
-from pydantic_settings import BaseSettings
-from pydantic import Field
-class Settings(BaseSettings):
-    db_url: str = Field(..., env='DATABASE_URL')
-
-settings = Settings()

crud.py

@@ -1,37 +0,0 @@
-from sqlalchemy.orm import Session
-
-import models
-import schemas
-
-
-def get_user(db: Session, user_id: int):
-    return db.query(models.User).filter(models.User.id == user_id).first()
-
-
-def get_user_by_email(db: Session, email: str):
-    return db.query(models.User).filter(models.User.email == email).first()
-
-
-def get_users(db: Session, skip: int = 0, limit: int = 100):
-    return db.query(models.User).offset(skip).limit(limit).all()
-
-
-def create_user(db: Session, user: schemas.UserCreate):
-    fake_hashed_password = user.password + "notreallyhashed"
-    db_user = models.User(email=user.email, hashed_password=fake_hashed_password)
-    db.add(db_user)
-    db.commit()
-    db.refresh(db_user)
-    return db_user
-
-
-def get_items(db: Session, skip: int = 0, limit: int = 100):
-    return db.query(models.Item).offset(skip).limit(limit).all()
-
-
-def create_user_item(db: Session, item: schemas.ItemCreate, user_id: int):
-    db_item = models.Item(**item.model_dump(), owner_id=user_id)
-    db.add(db_item)
-    db.commit()
-    db.refresh(db_item)
-    return db_item

database.py

@@ -1,28 +0,0 @@
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-#from config import settings
-
-import os
-#db_url = os.environ.get("DATABASE_URL", "")
-
-from sqlalchemy import URL
-
-db_url = URL.create(
-    "postgresql",
-    username="avnadmin",
-    password="AVNS_u12fHxoNLBbzD8TGpqN",  # plain (unescaped) text
-    host="pg-opengenai-opengenai.b.aivencloud.com",
-    database="defaultdb",
-    port=14535,
-)
-#database = databases.Database(settings.db_url)
-SQLALCHEMY_DATABASE_URL = db_url # "ibmabdulsalam.mysql.pythonanywhere-services.com"  #"sqlite:///./sql_app.db"
-#SQLALCHEMY_DATABASE_URL = db_url #"postgresql://user:password@postgresserver/db"
-
-engine = create_engine(
-    SQLALCHEMY_DATABASE_URL, pool_size=10
-)#, connect_args={"check_same_thread": False}
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-Base = declarative_base()

docker-compose.yml

@@ -1,39 +0,0 @@
-version: "3"
-
-services:
-  backend:
-    build: ./app/Dockerfile
-    command: uvicorn main:app --host 0.0.0.0
-    networks:
-      - caw
-    ports:
-      - "7860:7860"
-    volumes:
-      - ./config.yaml:/app/config.yaml
-    environment:
-      DATABASE_URL: postgresql://postgres:postgres@postgres:5432/postgres
-  database:
-    image: postgres:latest
-    networks:
-      - caw
-    environment:
-      POSTGRES_DB: postgres
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-    volumes:
-      - database:/var/lib/postgresql/data
-    ports:
-      - "5432:5432"
-  cache:
-    image: redis:latest
-    networks:
-      - caw
-    ports:
-      - "6379:6379"
-
-volumes:
-  database:
-
-
-networks:
-  caw:

main.py

@@ -1,62 +1,5 @@
-from fastapi import Depends, FastAPI, HTTPException
-from sqlalchemy.orm import Session
-import crud
-import models
-import schemas
-from database import SessionLocal, engine
-from app import llm_router
-from fastapi import APIRouter, FastAPI
-models.Base.metadata.create_all(bind=engine)
 
-# Dependency
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-user_router = APIRouter(prefix="/user")
-
-@user_router.post("/users/", response_model=schemas.User, tags=["users"])
-def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
-    db_user = crud.get_user_by_email(db, email=user.email)
-    if db_user:
-        raise HTTPException(status_code=400, detail="Email already registered")
-    return crud.create_user(db=db, user=user)
-
-
-@user_router.get("/users/", response_model=list[schemas.User], tags=["users"])
-def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
-    users = crud.get_users(db, skip=skip, limit=limit)
-    return users
-
-
-@user_router.get("/users/{user_id}", response_model=schemas.User, tags=["users"] )
-def read_user(user_id: int, db: Session = Depends(get_db)):
-    db_user = crud.get_user(db, user_id=user_id)
-    if db_user is None:
-        raise HTTPException(status_code=404, detail="User not found")
-    return db_user
-
-
-@user_router.post("/users/{user_id}/items/", response_model=schemas.Item, tags=["users"] )
-def create_item_for_user(
-        user_id: int, item: schemas.ItemCreate, db: Session = Depends(get_db)
-):
-    return crud.create_user_item(db=db, item=item, user_id=user_id)
-
-
-@user_router.get("/items/", response_model=list[schemas.Item], tags=["users"] )
-def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
-    items = crud.get_items(db, skip=skip, limit=limit)
-    return items
-
-
-app = FastAPI(
-    docs_url="/",
-    title="OpenGenAI",
-    description="Your Excellect AI Physician")
-
-app.include_router(user_router)
-app.include_router(llm_router)
+import uvicorn
+#from app.app import app
+if __name__ == "__main__":
+    uvicorn.run("app.app:app", host="0.0.0.0", log_level="info")

models.py

@@ -1,26 +0,0 @@
-from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
-from sqlalchemy.orm import relationship
-
-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)
-    is_active = Column(Boolean, default=True)
-
-    items = relationship("Item", back_populates="owner")
-
-
-class Item(Base):
-    __tablename__ = "items"
-
-    id = Column(Integer, primary_key=True, index=True)
-    title = Column(String, index=True)
-    description = Column(String, index=True)
-    owner_id = Column(Integer, ForeignKey("users.id"))
-
-    owner = relationship("User", back_populates="items")

requirements.txt

@@ -5,4 +5,4 @@ pymysql
 mysqlclient==1.3.12
 tensorflow
 transformers
-psycopg2-binary
+psycopg2-binary

schemas.py

@@ -1,36 +0,0 @@
-from typing import Union
-from pydantic import BaseModel
-
-
-class ItemBase(BaseModel):
-    title: str
-    description: Union[str, None] = None
-
-
-class ItemCreate(ItemBase):
-    pass
-
-
-class Item(ItemBase):
-    id: int
-    owner_id: int
-
-    class Config:
-        from_attributes = True
-
-
-class UserBase(BaseModel):
-    email: str
-
-
-class UserCreate(UserBase):
-    password: str
-
-
-class User(UserBase):
-    id: int
-    is_active: bool
-    items: list[Item] = []
-
-    class Config:
-        from_attributes = True