initial commit

Dockerfile

@@ -0,0 +1,29 @@
+ARG PYTHON_VER=3.10
+
+FROM python:${PYTHON_VER} AS base
+
+WORKDIR /app
+
+ENV PYTHONUNBUFFERED=1
+
+# Install Poetry
+RUN curl -sSL https://install.python-poetry.org | POETRY_HOME=/opt/poetry python && \
+    cd /usr/local/bin && \
+    ln -s /opt/poetry/bin/poetry && \
+    poetry config virtualenvs.create false
+
+COPY ./pyproject.toml ./poetry.lock* /app/
+
+RUN poetry install --no-root
+
+COPY . /app
+
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY --from=base /app /app
+COPY --from=base /usr/local/lib/python3.10/site-packages /usr/local/lib/python3.10/site-packages
+COPY --from=base /usr/local/bin /usr/local/bin
+
+CMD uvicorn --host 0.0.0.0 --port 7860 main:app

alembic.ini

@@ -0,0 +1,100 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = alembic
+
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to alembic/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator"
+# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. Valid values are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os  # default: use os.pathsep
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

alembic/env.py

@@ -0,0 +1,80 @@
+from logging.config import fileConfig
+
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+
+# models import is necessary for autogenerate to work
+from app import models
+from app.core.config import settings
+from app.db import Base
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+config.set_section_option("alembic", "sqlalchemy.url", settings.DATABASE_URL)
+
+
+def run_migrations_offline():
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

alembic/script.py.mako

@@ -0,0 +1,25 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import fastapi_users_db_sqlalchemy
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}

alembic/versions/d8d827ad33ee_init_db.py

@@ -0,0 +1,66 @@
+"""init db
+
+Revision ID: d8d827ad33ee
+Revises: 
+Create Date: 2023-07-14 04:15:22.710735
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import fastapi_users_db_sqlalchemy
+
+
+# revision identifiers, used by Alembic.
+revision = 'd8d827ad33ee'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('user',
+    sa.Column('created', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
+    sa.Column('id', fastapi_users_db_sqlalchemy.generics.GUID(), nullable=False),
+    sa.Column('email', sa.String(length=320), nullable=False),
+    sa.Column('hashed_password', sa.String(length=1024), nullable=False),
+    sa.Column('is_active', sa.Boolean(), nullable=False),
+    sa.Column('is_superuser', sa.Boolean(), nullable=False),
+    sa.Column('is_verified', sa.Boolean(), nullable=False),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_user_email'), 'user', ['email'], unique=True)
+    op.create_table('document',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('user_id', fastapi_users_db_sqlalchemy.generics.GUID(), nullable=False),
+    sa.Column('name', sa.String(), nullable=False),
+    sa.Column('created', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
+    sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_table('oauth_account',
+    sa.Column('id', fastapi_users_db_sqlalchemy.generics.GUID(), nullable=False),
+    sa.Column('user_id', fastapi_users_db_sqlalchemy.generics.GUID(), nullable=False),
+    sa.Column('oauth_name', sa.String(length=100), nullable=False),
+    sa.Column('access_token', sa.String(length=1024), nullable=False),
+    sa.Column('expires_at', sa.Integer(), nullable=True),
+    sa.Column('refresh_token', sa.String(length=1024), nullable=True),
+    sa.Column('account_id', sa.String(length=320), nullable=False),
+    sa.Column('account_email', sa.String(length=320), nullable=False),
+    sa.ForeignKeyConstraint(['user_id'], ['user.id'], ondelete='cascade'),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_oauth_account_account_id'), 'oauth_account', ['account_id'], unique=False)
+    op.create_index(op.f('ix_oauth_account_oauth_name'), 'oauth_account', ['oauth_name'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_oauth_account_oauth_name'), table_name='oauth_account')
+    op.drop_index(op.f('ix_oauth_account_account_id'), table_name='oauth_account')
+    op.drop_table('oauth_account')
+    op.drop_table('document')
+    op.drop_index(op.f('ix_user_email'), table_name='user')
+    op.drop_table('user')
+    # ### end Alembic commands ###

app/api/__init__.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from app.api import users, utils, queries, documents
+
+api_router = APIRouter()
+
+api_router.include_router(utils.router, tags=["utils"])
+api_router.include_router(users.router, tags=["users"])
+api_router.include_router(queries.router, tags=["queries"])
+api_router.include_router(documents.router, tags=["documents"])

app/api/documents.py

@@ -0,0 +1,75 @@
+from typing import Any
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File
+from starlette.responses import Response
+from app.schemas.document import UpsertResponse
+from app.parser.parser import get_document_from_file
+from app.parser.chunk import chunk_text
+import requests
+
+from app.deps.users import current_user
+from app.models.user import User
+from app.parser.parser import get_document_from_file
+from sqlalchemy.ext.asyncio.session import AsyncSession
+from app.deps.db import get_async_session
+
+from app.models.document import Document
+from uuid import uuid4
+
+from app.vectorstore.qdrant import QdrantManager
+from app.openai.base import OpenAiManager
+from sqlalchemy.future import select
+
+
+router = APIRouter(prefix="/documents")
+
+
+@router.post(
+    "/upsert-file",
+    response_model=UpsertResponse,
+)
+async def upsert_file(
+    file: UploadFile = File(...),
+    session: AsyncSession = Depends(get_async_session),
+    user: User = Depends(current_user),
+):
+    document = await get_document_from_file(file)
+    chunks = chunk_text(document.text, max_size=2000)
+    db_document = Document(user_id=str(user.id).replace("-", ""), name=file.filename)
+    session.add(db_document)
+
+    await session.commit()
+
+    openai_manager = OpenAiManager()
+    ids = [uuid4().hex for chunk in chunks]
+    payloads = [
+        {
+            "user_id": str(user.id).replace("-", ""),
+            "document_id": db_document.id,
+            "chunk": chunk,
+        }
+        for chunk in chunks
+    ]
+    embeddings = openai_manager.get_embeddings(chunks)
+
+    vector_manager = QdrantManager()
+    response = vector_manager.upsert_points(ids, payloads, embeddings)
+
+    return UpsertResponse(id=db_document.id)
+
+
+@router.get("/")
+async def get_documents(
+    session: AsyncSession = Depends(get_async_session),
+    user: User = Depends(current_user),
+):
+    statement = select(Document).where(
+        Document.user_id == str(user.id).replace("-", "")
+    )
+    db_documents = await session.execute(statement)
+
+    documents = [
+        {"id": document.id, "name": document.name}
+        for document in db_documents.scalars().all()
+    ]
+
+    return {"documents": documents}

app/api/queries.py

@@ -0,0 +1,92 @@
+from typing import Any
+from fastapi import APIRouter, Depends, HTTPException
+from starlette.responses import Response
+import requests
+
+
+from app.deps.users import current_user
+from app.models.user import User
+
+from app.vectorstore.qdrant import qdrant_manager
+from app.openai.base import openai_manager
+from app.openai.core import ask, filter, summarize
+
+from pydantic import BaseModel
+
+
+class QueryRequest(BaseModel):
+    query: str
+    document_id: int
+
+
+class QueryResponse(BaseModel):
+    answer: str
+    document_id: int
+
+
+router = APIRouter(prefix="/queries")
+
+
+@router.post("/")
+async def query(
+    query_request: QueryRequest,
+    response: Response,
+    user: User = Depends(current_user),
+) -> QueryResponse:
+    # add check that this user actually owns this document
+
+    query_vector = openai_manager.get_embedding(query_request.query)
+
+    # print(">>>>>>>>>>>>")
+    # print("query vector")
+    # print(query_vector)
+
+    # print(">>>>>>>>>>>>>>>")
+    # print("document_id: ", query_request.document_id)
+    # print("--------------")
+
+    # print(">>>>>>>>>>>>")
+    # print("user_id")
+    # print(user.id.hex)
+
+    points = qdrant_manager.search_point(
+        query_vector=query_vector,
+        user_id=str(user.id.hex),
+        document_id=int(query_request.document_id),
+        limit=1000,
+    )
+
+    # print(">>>>>>>>>>>>")
+    # print("points")
+    # print(points)
+
+    context = "\n\n\n".join([point.payload["chunk"] for point in points])
+    # print(">>>>>>>>>>>>")
+    # print("context")
+    # print(context)
+
+    # filter_response = filter(context, query_request.query, openai_manager)
+    # print(">>>>>>>>>>>>>>>>")
+    # print("filter resopnse")
+    # print(filter_response)
+    # print("----------------")
+    # remove later
+    filter_response = True
+    if filter_response:
+        answer = ask(
+            context,
+            query_request.query,
+            openai_manager,
+        )
+
+        query_response = QueryResponse(
+            answer=answer, document_id=query_request.document_id
+        )
+
+    else:
+        query_response = QueryResponse(
+            answer="Sorry, Your question is out of Context!",
+            document_id=query_request.document_id,
+        )
+
+    return query_response

app/api/users.py

@@ -0,0 +1,30 @@
+from typing import Any, List
+
+from fastapi.params import Depends
+from fastapi.routing import APIRouter
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio.session import AsyncSession
+from starlette.responses import Response
+
+from app.deps.db import get_async_session
+from app.deps.users import current_superuser
+from app.models.user import User
+from app.schemas.user import UserRead
+
+router = APIRouter()
+
+
+@router.get("/users", response_model=List[UserRead])
+async def get_users(
+    response: Response,
+    session: AsyncSession = Depends(get_async_session),
+    user: User = Depends(current_superuser),
+    skip: int = 0,
+    limit: int = 100,
+) -> Any:
+    total = await session.scalar(select(func.count(User.id)))
+    users = (
+        (await session.execute(select(User).offset(skip).limit(limit))).scalars().all()
+    )
+    response.headers["Content-Range"] = f"{skip}-{skip + len(users)}/{total}"
+    return users

app/api/utils.py

@@ -0,0 +1,17 @@
+from typing import Any
+
+from fastapi import APIRouter
+
+from app.schemas.msg import Msg
+
+router = APIRouter()
+
+
+@router.get(
+    "/hello-world",
+    response_model=Msg,
+    status_code=200,
+    include_in_schema=False,
+)
+def test_hello_world() -> Any:
+    return {"msg": "Hello world!"}

app/core/config.py

@@ -0,0 +1,52 @@
+import sys
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseSettings, HttpUrl, PostgresDsn, validator
+from pydantic.networks import AnyHttpUrl
+
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "QueryX"
+
+    SENTRY_DSN: Optional[HttpUrl] = None
+
+    API_PATH: str = "/api/v1"
+
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 7 * 24 * 60  # 7 days
+
+    BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = [
+        "http://0.0.0.0:9000",
+        "http://0.0.0.0:8000",
+    ]
+
+    # The following variables need to be defined in environment
+
+    TEST_DATABASE_URL: Optional[PostgresDsn]
+    DATABASE_URL: PostgresDsn
+    ASYNC_DATABASE_URL: Optional[PostgresDsn]
+
+    @validator("DATABASE_URL", pre=True)
+    def build_test_database_url(cls, v: Optional[str], values: Dict[str, Any]):
+        """Overrides DATABASE_URL with TEST_DATABASE_URL in test environment."""
+        url = v
+        if "pytest" in sys.modules:
+            if not values.get("TEST_DATABASE_URL"):
+                raise Exception(
+                    "pytest detected, but TEST_DATABASE_URL is not set in environment"
+                )
+            url = values["TEST_DATABASE_URL"]
+        if url:
+            return url.replace("postgres://", "postgresql://")
+        return url
+
+    @validator("ASYNC_DATABASE_URL")
+    def build_async_database_url(cls, v: Optional[str], values: Dict[str, Any]):
+        """Builds ASYNC_DATABASE_URL from DATABASE_URL."""
+        v = values["DATABASE_URL"]
+        return v.replace("postgresql", "postgresql+asyncpg", 1) if v else v
+
+    SECRET_KEY: str
+    #  END: required environment variables
+
+
+settings = Settings()

app/core/logger.py

@@ -0,0 +1,4 @@
+import logging
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)

app/db.py

@@ -0,0 +1,20 @@
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase
+
+from app.core.config import settings
+
+async_engine = create_async_engine(str(settings.ASYNC_DATABASE_URL), pool_pre_ping=True)
+
+async_session_maker = async_sessionmaker(
+    async_engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autocommit=False,
+    autoflush=False,
+)
+
+
+class Base(DeclarativeBase):
+    id: Any

app/deps/db.py

@@ -0,0 +1,11 @@
+from typing import AsyncGenerator
+
+from sqlalchemy.ext.asyncio.session import AsyncSession
+
+from app.db import async_session_maker
+
+
+async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session_maker() as session:
+        yield session
+        await session.close()

app/deps/qdrant.py

@@ -0,0 +1,5 @@
+import qdrant_client
+
+
+def get_qdrant_client():
+    return qdrant_client.QdrantClient(host=host, port=port, api_key=qdrant_api_key)

app/deps/request_params.py

@@ -0,0 +1,46 @@
+import json
+from typing import Callable, Optional, Type
+
+from fastapi import HTTPException, Query
+from sqlalchemy import UnaryExpression, asc, desc
+
+from app.db import Base
+from app.schemas.request_params import RequestParams
+
+
+def parse_react_admin_params(model: Type[Base]) -> Callable:
+    """Parses sort and range parameters coming from a react-admin request"""
+
+    def inner(
+        sort_: Optional[str] = Query(
+            None,
+            alias="sort",
+            description='Format: `["field_name", "direction"]`',
+            example='["id", "ASC"]',
+        ),
+        range_: Optional[str] = Query(
+            None,
+            alias="range",
+            description="Format: `[start, end]`",
+            example="[0, 10]",
+        ),
+    ) -> RequestParams:
+        skip, limit = 0, 10
+        if range_:
+            start, end = json.loads(range_)
+            skip, limit = start, (end - start + 1)
+
+        order_by: UnaryExpression = desc(model.id)
+        if sort_:
+            sort_column, sort_order = json.loads(sort_)
+            if sort_order.lower() == "asc":
+                direction = asc
+            elif sort_order.lower() == "desc":
+                direction = desc
+            else:
+                raise HTTPException(400, f"Invalid sort direction {sort_order}")
+            order_by = direction(model.__table__.c[sort_column])
+
+        return RequestParams(skip=skip, limit=limit, order_by=order_by)
+
+    return inner

app/deps/users.py

@@ -0,0 +1,51 @@
+import uuid
+
+from fastapi import Depends
+from fastapi_users import FastAPIUsers
+from fastapi_users.authentication import (
+    AuthenticationBackend,
+    BearerTransport,
+    JWTStrategy,
+)
+from fastapi_users.manager import BaseUserManager, UUIDIDMixin
+from fastapi_users_db_sqlalchemy import SQLAlchemyUserDatabase
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.config import settings
+from app.deps.db import get_async_session
+from app.models.user import OAuthAccount, User as UserModel
+
+bearer_transport = BearerTransport(tokenUrl="auth/jwt/login")
+
+
+def get_jwt_strategy() -> JWTStrategy:
+    return JWTStrategy(
+        secret=settings.SECRET_KEY,
+        lifetime_seconds=settings.ACCESS_TOKEN_EXPIRE_MINUTES * 60,
+    )
+
+
+jwt_authentication = AuthenticationBackend(
+    name="jwt",
+    transport=bearer_transport,
+    get_strategy=get_jwt_strategy,
+)
+
+
+class UserManager(UUIDIDMixin, BaseUserManager[UserModel, uuid.UUID]):
+    reset_password_token_secret = settings.SECRET_KEY
+    verification_token_secret = settings.SECRET_KEY
+
+
+def get_user_db(session: AsyncSession = Depends(get_async_session)):
+    yield SQLAlchemyUserDatabase(session, UserModel, OAuthAccount)
+
+
+def get_user_manager(user_db=Depends(get_user_db)):
+    yield UserManager(user_db)
+
+
+fastapi_users = FastAPIUsers(get_user_manager, [jwt_authentication])
+
+current_user = fastapi_users.current_user(active=True)
+current_superuser = fastapi_users.current_user(active=True, superuser=True)

app/email/send_mail.py

@@ -0,0 +1,2 @@
+def send_email():
+    raise NotImplementedError

app/factory.py

@@ -0,0 +1,116 @@
+from fastapi import FastAPI
+from fastapi.routing import APIRoute
+from fastapi.staticfiles import StaticFiles
+from fastapi_users import FastAPIUsers
+from starlette.middleware.cors import CORSMiddleware
+from starlette.requests import Request
+from starlette.responses import FileResponse
+
+from app.api import api_router
+from app.core.config import settings
+from app.deps.users import fastapi_users, jwt_authentication
+from app.schemas.user import UserCreate, UserRead, UserUpdate
+import os
+
+
+from httpx_oauth.clients.google import GoogleOAuth2  # google client
+
+# for dev only
+os.environ["OAUTHLIB_INSECURE_TRANSPORT"] = "1"
+
+
+def create_app():
+    description = f"{settings.PROJECT_NAME} API"
+    app = FastAPI(
+        title=settings.PROJECT_NAME,
+        openapi_url=f"{settings.API_PATH}/openapi.json",
+        docs_url="/docs/",
+        description=description,
+        redoc_url=None,
+    )
+    setup_routers(app, fastapi_users)
+    setup_cors_middleware(app)
+    serve_static_app(app)
+    return app
+
+
+def setup_routers(app: FastAPI, fastapi_users: FastAPIUsers) -> None:
+    app.include_router(api_router, prefix=settings.API_PATH)
+    app.include_router(
+        fastapi_users.get_auth_router(
+            jwt_authentication,
+            requires_verification=False,
+        ),
+        prefix=f"{settings.API_PATH}/auth/jwt",
+        tags=["auth"],
+    )
+    app.include_router(
+        fastapi_users.get_register_router(UserRead, UserCreate),
+        prefix=f"{settings.API_PATH}/auth",
+        tags=["auth"],
+    )
+    app.include_router(
+        fastapi_users.get_users_router(
+            UserRead, UserUpdate, requires_verification=False
+        ),
+        prefix=f"{settings.API_PATH}/users",
+        tags=["users"],
+    )
+
+    google_oauth_client = GoogleOAuth2(
+        os.getenv("GOOGLE_OAUTH_CLIENT_ID", ""),
+        os.getenv("GOOGLE_OAUTH_CLIENT_SECRET", ""),
+    )
+
+    app.include_router(
+        fastapi_users.get_oauth_router(
+            google_oauth_client, jwt_authentication, "SECRET"
+        ),
+        prefix="/auth/google",
+        tags=["auth"],
+    )
+    # The following operation needs to be at the end of this function
+    use_route_names_as_operation_ids(app)
+
+
+def serve_static_app(app):
+    app.mount("/", StaticFiles(directory="static"), name="static")
+
+    @app.middleware("http")
+    async def _add_404_middleware(request: Request, call_next):
+        """Serves static assets on 404"""
+        response = await call_next(request)
+        path = request["path"]
+        if path.startswith(settings.API_PATH) or path.startswith("/docs"):
+            return response
+        if response.status_code == 404:
+            return FileResponse("static/index.html")
+        return response
+
+
+def setup_cors_middleware(app):
+    if settings.BACKEND_CORS_ORIGINS:
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=[str(origin) for origin in settings.BACKEND_CORS_ORIGINS],
+            allow_credentials=True,
+            allow_methods=["*"],
+            expose_headers=["Content-Range", "Range"],
+            allow_headers=["Authorization", "Range", "Content-Range"],
+        )
+
+
+def use_route_names_as_operation_ids(app: FastAPI) -> None:
+    """
+    Simplify operation IDs so that generated API clients have simpler function
+    names.
+
+    Should be called only after all routes have been added.
+    """
+    route_names = set()
+    for route in app.routes:
+        if isinstance(route, APIRoute):
+            if route.name in route_names:
+                raise Exception("Route function names should be unique")
+            route.operation_id = route.name
+            route_names.add(route.name)

app/models/__init__.py

@@ -0,0 +1,3 @@
+# Import all models here so alembic can discover them
+from app.models.user import User
+from app.models.document import Document

app/models/document.py

@@ -0,0 +1,27 @@
+from datetime import datetime
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from fastapi_users_db_sqlalchemy import GUID
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql.functions import func
+from sqlalchemy.sql.schema import ForeignKey
+from sqlalchemy.sql.sqltypes import DateTime
+
+from app.db import Base
+
+if TYPE_CHECKING:
+    from app.models.user import User
+
+
+class Document(Base):
+    __tablename__ = "document"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_id: Mapped[UUID] = mapped_column(GUID, ForeignKey("user.id"))
+    user: Mapped["User"] = relationship(back_populates="documents")
+    name: Mapped[str]
+
+    created: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )

app/models/user.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+from typing import TYPE_CHECKING, List
+
+
+from fastapi_users_db_sqlalchemy import (
+    SQLAlchemyBaseUserTableUUID,
+    SQLAlchemyBaseOAuthAccountTableUUID,
+)
+
+from sqlalchemy import DateTime
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql.functions import func
+
+from app.db import Base
+
+
+if TYPE_CHECKING:
+    from app.models.document import Document
+
+
+class OAuthAccount(SQLAlchemyBaseOAuthAccountTableUUID, Base):
+    pass
+
+
+class User(SQLAlchemyBaseUserTableUUID, Base):
+    __tablename__ = "user"
+
+    oauth_accounts: Mapped[List[OAuthAccount]] = relationship(
+        "OAuthAccount", lazy="joined"
+    )
+
+    created: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+
+    documents: Mapped["Document"] = relationship(
+        back_populates="user", cascade="all, delete"
+    )
+
+    def __repr__(self):
+        return f"User(id={self.id!r}, name={self.email!r})"
+
+
+# add activated column

app/openai/base.py

@@ -0,0 +1,82 @@
+import os
+
+# from dotenv import load_dotenv
+import openai
+
+
+class OpenAiManager:
+    def __init__(self):
+        # load_dotenv()
+        openai.api_key = os.getenv("OPENAI_API_KEY")
+
+    def get_completion(
+        self,
+        prompt,
+        model="text-davinci-003",
+        max_tokens=128,
+        temperature=0,
+    ):
+        response = None
+        try:
+            response = openai.Completion.create(
+                prompt=prompt,
+                max_tokens=max_tokens,
+                model=model,
+                temperature=temperature,
+            )["choices"][0]["text"]
+
+        except Exception as err:
+            print(f"Sorry, There was a problem \n\n {err}")
+
+        return response
+
+    def get_chat_completion(self, prompt, model="gpt-3.5-turbo"):
+        response = None
+        try:
+            response = (
+                openai.ChatCompletion.create(
+                    model=model,
+                    messages=[
+                        {
+                            "role": "system",
+                            "content": prompt,
+                        }
+                    ],
+                )
+                .choices[0]
+                .message.content.strip()
+            )
+
+        except Exception as err:
+            print(f"Sorry, There was a problem \n\n {err}")
+
+        return response
+
+    def get_embedding(self, prompt, model="text-embedding-ada-002"):
+        prompt = prompt.replace("\n", " ")
+
+        embedding = None
+        try:
+            embedding = openai.Embedding.create(input=[prompt], model=model)["data"][0][
+                "embedding"
+            ]
+
+        except Exception as err:
+            print(f"Sorry, There was a problem {err}")
+
+        return embedding
+
+    def get_embeddings(self, prompts, model="text-embedding-ada-002"):
+        prompts = [prompt.replace("\n", " ") for prompt in prompts]
+
+        embeddings = None
+        try:
+            embeddings = openai.Embedding.create(input=prompts, model=model)["data"]
+
+        except Exception as err:
+            print(f"Sorry, There was a problem {err}")
+
+        return [embedding["embedding"] for embedding in embeddings]
+
+
+openai_manager = OpenAiManager()