users, transactions crud apis

.dockerignore

@@ -1,5 +1,3 @@
 __pycache__
 storage
-data/*
-venv
-myvenv
+data/*

.env.example

@@ -43,11 +43,3 @@ APP_HOST=0.0.0.0
 
 # The port to start the backend app.
 APP_PORT=8000
-
-# Postgres database configuration
-POSTGRES_USER=postgres
-POSTGRES_PASSWORD=postgres
-POSTGRES_DB_NAME=postgres
-POSTGRES_DB_HOST=localhost
-POSTGRES_DB_PORT=5432
-SQLALCHEMY_DATABASE_URL=postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_DB_HOST}:${POSTGRES_DB_PORT}/${POSTGRES_DB_NAME}

.gitignore

@@ -1,5 +1,4 @@
 __pycache__
 storage
 .env
-venv
-myvenv
+data/*

.vscode/settings.json

@@ -1,11 +1,3 @@
 {
-    "jupyter.notebookFileRoot": "${workspaceFolder}",
-    "[python]": {
-        "editor.defaultFormatter": "ms-python.black-formatter",
-        "editor.formatOnSave": true,
-    },
-    "ms-python.black-formatter.args": [
-        "--line-length",
-        "119"
-    ]
+    "jupyter.notebookFileRoot": "${workspaceFolder}"
 }

Dockerfile

@@ -25,13 +25,4 @@ COPY . .
 # Make port 8000 available to the world outside this container
 EXPOSE 8000
 
-ENV POSTGRES_USER codepath_project_owner
-ENV POSTGRES_PASSWORD 03EdiworgCJz
-ENV POSTGRES_DB_NAME codepath_project
-ENV POSTGRES_DB_HOST ep-icy-cloud-a5m4mcgo.us-east-2.aws.neon.tech
-ENV POSTGRES_DB_PORT 5432
-
-# Run migrations
-RUN alembic upgrade head
-
 CMD ["python", "main.py"]

Dockerfile.local.postgres

@@ -1,23 +0,0 @@
-# Pull the official PostgreSQL 16 image
-FROM postgres:16
-
-# Create a directory for the database files
-RUN mkdir -p /var/lib/postgresql/data
-
-# Change the ownership of the data directory
-RUN chown -R postgres:postgres /var/lib/postgresql/data
-
-# Copy the configuration files into the data directory
-# NOTE: the [f] suffix is to ensure that the COPY command will not fail if the files don't exist
-COPY ./pg_hba.con[f] /var/lib/postgresql/data/pg_hba.conf
-COPY ./postgresql.con[f] /var/lib/postgresql/data/postgresql.conf
-
-# Include environment variables for the PostgreSQL user and password
-ENV POSTGRES_USER=${POSTGRES_USER}
-ENV POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
-
-# Expose the default PostgreSQL port
-EXPOSE 5432
-
-# Start the PostgreSQL server
-CMD ["postgres", "-c", "config_file=/var/lib/postgresql/data/postgresql.conf"]

Makefile

@@ -1,14 +0,0 @@
-
-include .env
-
-build-postgres:
-	docker build -t codepath_project_postgres -f Dockerfile.local.postgres .
-
-run-postgres:
-	docker run -d -p 5432:5432 -e POSTGRES_PASSWORD=${POSTGRES_PASSWORD} -e POSTGRES_USER=${POSTGRES_USER} --name ${POSTGRES_DB_NAME} codepath_project_postgres
-
-run-migrations:
-	alembic upgrade head
-
-generate-migrations:
-	alembic revision --autogenerate -m "$(migration_title)"

README.md

@@ -69,36 +69,6 @@ The API allows CORS for all origins to simplify development. You can change this
 ENVIRONMENT=prod python main.py
 ```
 
-## Local Postgres database setup
-
-To setup a local postgres database, run:
-
-1. Build the docker image:
-
-```bash
-make build-postgres
-```
-
-2. Start the docker container:
-
-```bash
-make run-postgres
-```
-
-## Running Migrations
-
-To generate new migrations, run:
-
-```bash
-make generate-migrations migration_title="<name_for_migration>"
-```
-
-To locally verify your changes, run:
-
-```bash
-make run-migrations
-```
-
 ## Using Docker
 
 1. Build an image for the FastAPI app:

alembic.ini

@@ -1,116 +0,0 @@
-# A generic, single database configuration.
-
-[alembic]
-# path to migration scripts
-script_location = migration
-
-# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
-# Uncomment the line below if you want the files to be prepended with date and time
-# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
-# for all available tokens
-# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(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>=3.9 or backports.zoneinfo library.
-# Any required deps can installed by adding `alembic[tz]` to the pip requirements
-# string value is passed to ZoneInfo()
-# 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 migration/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" below.
-# version_locations = %(here)s/bar:%(here)s/bat:migration/versions
-
-# version path separator; As mentioned above, this is the character used to split
-# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
-# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
-# Valid values for version_path_separator are:
-#
-# version_path_separator = :
-# version_path_separator = ;
-# version_path_separator = space
-version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
-
-# set to 'true' to search source files recursively
-# in each "version_locations" directory
-# new in Alembic version 1.10
-# recursive_version_locations = false
-
-# 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
-
-# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
-# hooks = ruff
-# ruff.type = exec
-# ruff.executable = %(here)s/.venv/bin/ruff
-# ruff.options = --fix 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

app/api/routers/chat.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel
 from typing import List, Any, Optional, Dict, Tuple
 from fastapi import APIRouter, Depends, HTTPException, Request, status
 from llama_index.core.chat_engine.types import BaseChatEngine
@@ -19,8 +19,9 @@ class _Message(BaseModel):
 
 class _ChatData(BaseModel):
     messages: List[_Message]
-    model_config = ConfigDict(
-        json_schema_extra={
+
+    class Config:
+        json_schema_extra = {
             "example": {
                 "messages": [
                     {
@@ -30,7 +31,6 @@ class _ChatData(BaseModel):
                 ]
             }
         }
-    )
 
 
 class _SourceNodes(BaseModel):
@@ -121,7 +121,12 @@ async def chat(
         yield VercelStreamResponse.convert_data(
             {
                 "type": "sources",
-                "data": {"nodes": [_SourceNodes.from_source_node(node).dict() for node in response.source_nodes]},
+                "data": {
+                    "nodes": [
+                        _SourceNodes.from_source_node(node).dict()
+                        for node in response.source_nodes
+                    ]
+                },
             }
         )
 

app/api/routers/file_upload.py

@@ -1,43 +0,0 @@
-from typing import Annotated
-from fastapi import APIRouter, UploadFile, Depends
-from app.categorization.file_processing import process_file, save_results
-from app.schema.index import FileUploadCreate
-import asyncio
-import os
-import csv
-
-from app.engine.postgresdb import get_db_session
-from sqlalchemy.ext.asyncio import AsyncSession
-
-file_upload_router = r = APIRouter(prefix="/api/v1/file_upload", tags=["file_upload"])
-
-@r.post(
-    "/",
-    responses={
-        200: {"description": "File successfully uploaded"},
-        400: {"description": "Bad request"},
-        500: {"description": "Internal server error"},
-    },
-)
-async def create_file(input_file: UploadFile, db: AsyncSession = Depends(get_db_session)):
-    try:
-         # Create directory to store all uploaded .csv files
-        file_upload_directory_path = "data/tx_data/input"
-        if not os.path.exists(file_upload_directory_path):
-            os.makedirs(file_upload_directory_path)
-
-        # Write items of .csv filte to directory
-        with open(os.path.join(file_upload_directory_path, input_file.filename)) as output_file:
-            [output_file.write(" ".join(row)+'\n') for row in csv.reader(input_file)]
-        output_file.close()
-
-        # With the newly created file and it's path, process and save it for embedding
-        processed_file = process_file(os.path.realpath(input_file.filename))
-        result = await asyncio.gather(processed_file)
-        await save_results(db, result)
-
-    except Exception:
-        return {"message": "There was an error uploading this file. Ensure you have a .csv file with the following columns:"
-        "\n transaction_date, type, category, name_description, amount"}
-
-    return {"message": f"Successfully uploaded {input_file.filename}"}

app/api/routers/income_statement.py

@@ -1,64 +0,0 @@
-from typing import List
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.model.transaction import Transaction as TransactionModel
-from app.model.income_statement import IncomeStatement as IncomeStatementModel
-from app.schema.index import IncomeStatementCreateRequest, IncomeStatementResponse
-from app.engine.postgresdb import get_db_session
-from app.service.income_statement import call_llm_to_create_income_statement
-
-income_statement_router = r = APIRouter(prefix="/api/v1/income_statement", tags=["income_statement"])
-
-
-@r.post(
-    "/",
-    responses={
-        200: {"description": "New transaction created"},
-        400: {"description": "Bad request"},
-        500: {"description": "Internal server error"},
-    },
-)
-async def create_income_statement(payload: IncomeStatementCreateRequest, db: AsyncSession = Depends(get_db_session)) -> None:
-    try:
-        await call_llm_to_create_income_statement(payload, db)
-
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@r.get(
-    "/user/{user_id}",
-    response_model=List[IncomeStatementResponse],
-    responses={
-        200: {"description": "New user created"},
-        400: {"description": "Bad request"},
-        204: {"description": "No content"},
-        500: {"description": "Internal server error"},
-    },
-)
-async def get_income_statements(
-    user_id: int, db: AsyncSession = Depends(get_db_session)
-) -> List[IncomeStatementResponse]:
-    """
-    Retrieve all income statements.
-    """
-    result = await IncomeStatementModel.get_by_user(db, user_id)
-    if len(result) == 0:
-        raise HTTPException(status_code=status.HTTP_204_NO_CONTENT, detail="No income statements found for this user")
-    return result
-
-
-@r.get(
-    "/report/{report_id}",
-    response_model=IncomeStatementResponse,
-    responses={
-        200: {"description": "Income statement found"},
-        404: {"description": "Income statement not found"},
-        500: {"description": "Internal server error"},
-    },
-)
-async def get_income_statement(report_id: int, db: AsyncSession = Depends(get_db_session)) -> IncomeStatementResponse:
-    income_statement = await IncomeStatementModel.get(db, id=report_id)
-    if not income_statement:
-        raise HTTPException(status_code=404, detail="Income statement not found")
-    return income_statement

app/api/routers/transaction.py

@@ -1,30 +0,0 @@
-import os
-from typing import List
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.model.transaction import Transaction as TransactionModel
-from app.schema.index import TransactionResponse
-from app.engine.postgresdb import get_db_session
-
-transaction_router = r = APIRouter(prefix="/api/v1/transactions", tags=["transactions"])
-
-
-@r.get(
-    "/{user_id}",
-    response_model=List[TransactionResponse],
-    responses={
-        200: {"description": "New user created"},
-        400: {"description": "Bad request"},
-        204: {"description": "No content"},
-        500: {"description": "Internal server error"},
-    },
-)
-async def get_transactions(user_id: int, db: AsyncSession = Depends(get_db_session)):
-    """
-    Retrieve all transactions.
-    """
-    result = await TransactionModel.get_by_user(db, user_id)
-    all_rows = result.all()
-    if len(all_rows) == 0:
-        raise HTTPException(status_code=status.HTTP_204_NO_CONTENT, detail="No transactions found for this user")
-    return all_rows

app/api/routers/user.py

@@ -1,89 +0,0 @@
-import logging
-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.engine.postgresdb import get_db_session
-from app.schema.index import UserCreate, User as UserSchema, UserResponse, UserUpdate
-from app.model.user import User as UserModel
-
-
-user_router = r = APIRouter(prefix="/api/v1/users", tags=["users"])
-logger = logging.getLogger(__name__)
-
-
-@r.post(
-    "/",
-    response_model=UserResponse,
-    responses={
-        200: {"description": "New user created"},
-        400: {"description": "Bad request"},
-        409: {"description": "Conflict"},
-        500: {"description": "Internal server error"},
-    },
-)
-async def create_user(user: UserCreate, db: AsyncSession = Depends(get_db_session)):
-    try:
-        db_user = await UserModel.get(db, email=user.email)
-        if db_user and not db_user.is_deleted:
-            raise HTTPException(status_code=409, detail="User already exists")
-
-        await UserModel.create(db, **user.model_dump())
-        user = await UserModel.get(db, email=user.email)
-        return user
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@r.get(
-    "/{email}",
-    response_model=UserResponse,
-    responses={
-        200: {"description": "User found"},
-        404: {"description": "User not found"},
-        500: {"description": "Internal server error"},
-    },
-)
-async def get_user(email: str, db: AsyncSession = Depends(get_db_session)):
-    user = await UserModel.get(db, email=email)
-    if not user:
-        raise HTTPException(status_code=404, detail="User not found")
-    return user
-
-
-@r.put(
-    "/{email}",
-    response_model=UserResponse,
-    responses={
-        200: {"description": "User updated"},
-        404: {"description": "User not found"},
-        500: {"description": "Internal server error"},
-    },
-)
-async def update_user(email: str, user_payload: UserUpdate, db: AsyncSession = Depends(get_db_session)):
-    try:
-        user = await UserModel.get(db, email=email)
-        if not user:
-            raise HTTPException(status_code=404, detail="User not found")
-        await UserModel.update(db, id=user.id, **user_payload.model_dump())
-        user = await UserModel.get(db, email=email)
-        return user
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@r.delete(
-    "/{email}",
-    response_model=UserResponse,
-    responses={
-        200: {"description": "User deleted"},
-        404: {"description": "User not found"},
-        500: {"description": "Internal server error"},
-    },
-)
-async def delete_user(email: str, db: AsyncSession = Depends(get_db_session)):
-    user = await UserModel.get(db, email=email)
-    if not user:
-        raise HTTPException(status_code=404, detail="User not found")
-    await UserModel.delete(db, email=email)
-    user = await UserModel.get(db, email=email)
-    return user

app/categorization/file_processing.py

@@ -11,11 +11,6 @@ from dateparser import parse
 
 from app.categorization.categorizer_list import categorize_list
 from app.categorization.config import RESULT_OUTPUT_FILE, CATEGORY_REFERENCE_OUTPUT_FILE
-from app.model.transaction import Transaction
-from app.schema.index import TransactionCreate
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
 
 # Read file and process it (e.g. categorize transactions)
 async def process_file(file_path: str) -> Dict[str, Union[str, pd.DataFrame]]:
@@ -27,27 +22,28 @@ async def process_file(file_path: str) -> Dict[str, Union[str, pd.DataFrame]]:
 
     Returns:
         Dict[str, Union[str, pd.DataFrame]]: Dictionary containing the file name, processed output, and error information if any
-    """
+    """  
 
     file_name = os.path.basename(file_path)
-    result = {"file_name": file_name, "output": pd.DataFrame(), "error": ""}
+    result= {'file_name': file_name, 'output': pd.DataFrame(), 'error': ''}
     try:
-        # Read file into standardized tx format: source, date, type, category, description, amount
+        # Read file into standardized tx format: source, date, type, category, description, amount 
         tx_list = standardize_csv_file(file_path)
 
         # Categorize transactions
-        result["output"] = await categorize_list(tx_list)
-        print(f"File processed sucessfully: {file_name}")
+        result['output'] = await categorize_list(tx_list)
+        print(f'File processed sucessfully: {file_name}')
 
     except Exception as e:
         # Return an error indicator and exception info
         logging.log(logging.ERROR, f"| File: {file_name} | Unexpected Error: {e}")
-        print(f"ERROR processing file {file_name}: {e}")
-        result["error"] = str(e)
-
+        print(f'ERROR processing file {file_name}: {e}')
+        result['error'] = str(e)
+    
     return result
 
 
+
 def standardize_csv_file(file_path: str) -> pd.DataFrame:
     """
     Read and prepare the data from the input file.
@@ -59,21 +55,21 @@ def standardize_csv_file(file_path: str) -> pd.DataFrame:
         pd.DataFrame: Prepared transaction data.
     """
 
-    tx_list = pd.read_csv(file_path, index_col=False)
-    tx_list.attrs["file_name"] = file_path
+    tx_list = pd.read_csv(file_path, index_col=False)    
+    tx_list.attrs['file_name'] = file_path
     tx_list.columns = tx_list.columns.str.lower().str.strip()
 
     # Standardize dates to YYYY/MM/DD format
-    tx_list["date"] = pd.to_datetime(tx_list["date"]).dt.strftime("%Y/%m/%d")
+    tx_list['date'] = pd.to_datetime(tx_list['date']).dt.strftime('%Y/%m/%d')
 
     # Add source and reindex to desired tx format; category column is new and therefore empty
-    tx_list.loc[:, "source"] = os.path.basename(file_path)
-    tx_list = tx_list.reindex(columns=["date", "expense/income", "category", "name/description", "amount"])
+    tx_list.loc[:, 'source'] = os.path.basename(file_path)
+    tx_list = tx_list.reindex(columns=['date', 'expense/income', 'category', 'name/description', 'amount'])
 
     return tx_list
 
 
-async def save_results(db: AsyncSession, results: List) -> None:
+def save_results(results: List) -> None:
     """
     Merge all interim results in the input folder and write the merged results to the output file.
 
@@ -91,33 +87,29 @@ async def save_results(db: AsyncSession, results: List) -> None:
     ko_files = []
     error_messages = []
 
-    col_list = ["transaction_date", "type", "category", "name_description", "amount"]
+    col_list = ['date', 'expense/income', 'category', 'name/description', 'amount']
     tx_list = pd.DataFrame(columns=col_list)
     for result in results:
-        if not result["error"]:
-            ok_files.append(result["file_name"])
-            result_df = result["output"]
+        if not result['error']:
+            ok_files.append(result['file_name'])
+            result_df = result['output']
             result_df.columns = col_list
             tx_list = pd.concat([tx_list, result_df], ignore_index=True)
         else:
-            ko_files.append(result["file_name"])
-            error_messages.append(f"{result['file_name']}: {result['error']}")
+            ko_files.append(result['file_name'])
+            error_messages.append(f"{result['file_name']}: {result['error']}")  
 
-    # Save to database
-    # FIXME: get user_id from session
-    txn_list_to_save = [TransactionCreate(**row.to_dict(), user_id=1) for _, row in tx_list.iterrows()]
-    await Transaction.bulk_create(db, txn_list_to_save)
+    # Write contents to output file (based on file type)
+    tx_list.to_csv(RESULT_OUTPUT_FILE, mode="a", index=False, header=not os.path.exists(RESULT_OUTPUT_FILE))
 
-    new_ref_data = tx_list[["name/description", "category"]]
+    new_ref_data = tx_list[['name/description', 'category']]
     if os.path.exists(CATEGORY_REFERENCE_OUTPUT_FILE):
         # If it exists, add master file to interim results
-        old_ref_data = pd.read_csv(CATEGORY_REFERENCE_OUTPUT_FILE, names=["name/description", "category"], header=0)
+        old_ref_data = pd.read_csv(CATEGORY_REFERENCE_OUTPUT_FILE, names=['name/description', 'category'], header=0)
         new_ref_data = pd.concat([old_ref_data, new_ref_data], ignore_index=True)
-
+        
     # Drop duplicates, sort, and write to create new Master File
-    new_ref_data.drop_duplicates(subset=["name/description"]).sort_values(by=["name/description"]).to_csv(
-        CATEGORY_REFERENCE_OUTPUT_FILE, mode="w", index=False, header=True
-    )
+    new_ref_data.drop_duplicates(subset=['name/description']).sort_values(by=['name/description']).to_csv(CATEGORY_REFERENCE_OUTPUT_FILE, mode="w", index=False, header=True)
 
     # Summarize results
     print(f"\nProcessed {len(results)} files: {len(ok_files)} successful, {len(ko_files)} with errors\n")
@@ -125,4 +117,4 @@ async def save_results(db: AsyncSession, results: List) -> None:
         print(f"Errors in the following files:")
         for message in error_messages:
             print(f"  {message}")
-        print("\n")
+        print('\n')

app/engine/postgresdb.py

@@ -1,81 +0,0 @@
-import logging
-import contextlib
-from typing import Any, AsyncIterator
-
-from sqlalchemy.ext.asyncio import (
-    AsyncConnection,
-    AsyncSession,
-    AsyncEngine,
-    async_sessionmaker,
-    create_async_engine,
-)
-from sqlalchemy.orm import declarative_base
-
-from config.index import config as env
-
-logger = logging.getLogger(__name__)
-
-Base = declarative_base()
-
-
-class PostgresDatabase:
-
-    def __init__(self):
-        self._engine: AsyncEngine | None = None
-        self._sessionmaker: async_sessionmaker | None = None
-
-    def init(self, host: str, engine_kwargs: dict[str, Any] = {}):
-        self._engine = create_async_engine(host, **engine_kwargs)
-        self._sessionmaker = async_sessionmaker(autocommit=False, bind=self._engine)
-
-    async def close(self):
-        if self._engine is None:
-            raise Exception("DatabaseSessionManager is not initialized")
-        await self._engine.dispose()
-
-        self._engine = None
-        self._sessionmaker = None
-
-    @contextlib.asynccontextmanager
-    async def connect(self) -> AsyncIterator[AsyncConnection]:
-        if self._engine is None:
-            raise Exception("DatabaseSessionManager is not initialized")
-
-        async with self._engine.begin() as connection:
-            try:
-                yield connection
-            except Exception:
-                await connection.rollback()
-                raise
-
-    @contextlib.asynccontextmanager
-    async def session(self) -> AsyncIterator[AsyncSession]:
-        if self._sessionmaker is None:
-            raise Exception("DatabaseSessionManager is not initialized")
-
-        session = self._sessionmaker()
-        try:
-            yield session
-        except Exception:
-            await session.rollback()
-            raise
-        finally:
-            await session.close()
-
-    def get_engine(self):
-        return self._engine
-
-    # Used for testing
-    async def create_all(self, connection: AsyncConnection):
-        await connection.run_sync(Base.metadata.create_all)
-
-    async def drop_all(self, connection: AsyncConnection):
-        await connection.run_sync(Base.metadata.drop_all)
-
-
-postgresdb = PostgresDatabase()
-
-
-async def get_db_session():
-    async with postgresdb.session() as session:
-        yield session

app/model/base.py

@@ -1,15 +0,0 @@
-from datetime import datetime, timezone
-from sqlalchemy import DateTime
-from sqlalchemy.orm import Mapped, mapped_column
-
-from app.engine.postgresdb import Base
-
-
-class BaseModel:
-    id: Mapped[int] = mapped_column(primary_key=True, index=True, autoincrement=True)
-    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=datetime.now(timezone.utc))
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        default=datetime.now(timezone.utc),
-        onupdate=datetime.now(timezone.utc),
-    )

app/model/income_statement.py

@@ -1,46 +0,0 @@
-from datetime import datetime
-from typing import Any, Dict, List
-from sqlalchemy import ForeignKey
-from sqlalchemy.sql import expression as sql
-from sqlalchemy.orm import relationship, Mapped, mapped_column
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.dialects.postgresql import JSON
-
-from app.model.base import BaseModel
-from app.engine.postgresdb import Base
-from app.schema.index import IncomeStatement as IncomeStatementSchema
-
-
-class IncomeStatement(Base, BaseModel):
-    __tablename__ = "income_statement"
-
-    date_from: Mapped[datetime]
-    date_to: Mapped[datetime]
-    income: Mapped[Dict] = mapped_column(JSON, nullable=True)
-    expenses: Mapped[Dict] = mapped_column(JSON, nullable=True)
-
-    user_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
-    user = relationship("User", back_populates="income_statements")
-
-    def __str__(self) -> str:
-        return f"IncomeStatement(id={self.id}, user_id={self.user_id}, date_from={self.date_from}, date_to={self.date_to}, income={self.income}, expenses={self.expenses})"
-
-    @classmethod
-    async def create(cls: "type[IncomeStatement]", db: AsyncSession, **kwargs: IncomeStatementSchema) -> "IncomeStatement":
-        income_statement = cls(**kwargs)
-        db.add(income_statement)
-        await db.commit()
-        await db.refresh(income_statement)
-        return income_statement
-
-    @classmethod
-    async def get_by_user(cls: "type[IncomeStatement]", db: AsyncSession, user_id: int) -> "List[IncomeStatement]":
-        query = sql.select(cls).where(cls.user_id == user_id)
-        income_statements = await db.scalars(query)
-        return income_statements.all()
-
-    @classmethod
-    async def get(cls: "type[IncomeStatement]", db: AsyncSession, id: int) -> "IncomeStatement":
-        query = sql.select(cls).where(cls.id == id)
-        income_statement = await db.scalar(query)
-        return income_statement

app/model/transaction.py

@@ -1,62 +0,0 @@
-from datetime import datetime
-from typing import List
-from sqlalchemy import ForeignKey
-from sqlalchemy.orm import relationship, Mapped, mapped_column
-from sqlalchemy.sql import expression as sql
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.model.base import BaseModel
-from app.engine.postgresdb import Base
-from app.schema.index import TransactionCreate
-
-
-class Transaction(Base, BaseModel):
-    __tablename__ = "transactions"
-    transaction_date: Mapped[datetime]
-    category: Mapped[str]
-    name_description: Mapped[str]
-    amount: Mapped[float]
-    type: Mapped[str]
-
-    user_id = mapped_column(ForeignKey("users.id"))
-    user = relationship("User", back_populates="transactions")
-
-    def __str__(self) -> str:
-        return f"{self.transaction_date}, {self.category}, {self.name_description}, {self.amount}, {self.type}"
-
-    @classmethod
-    async def create(cls: "type[Transaction]", db: AsyncSession, **kwargs) -> "Transaction":
-        query = sql.insert(cls).values(**kwargs)
-        transactions = await db.execute(query)
-        transaction = transactions.first()
-        await db.commit()
-        return transaction
-
-    @classmethod
-    async def bulk_create(cls: "type[Transaction]", db: AsyncSession, transactions: List[TransactionCreate]) -> None:
-        values = [transaction.model_dump() for transaction in transactions]
-        query = sql.insert(cls).values(values)
-        await db.execute(query)
-        await db.commit()
-
-    @classmethod
-    async def update(cls: "type[Transaction]", db: AsyncSession, id: int, **kwargs) -> "Transaction":
-        query = sql.update(cls).where(cls.id == id).values(**kwargs).execution_options(synchronize_session="fetch")
-        transactions = await db.scalars(query)
-        transaction = transactions.first()
-        await db.commit()
-        return transaction
-
-    @classmethod
-    async def get_by_user(cls: "type[Transaction]", db: AsyncSession, user_id: int) -> "List[Transaction]":
-        query = sql.select(cls).where(cls.user_id == user_id)
-        transactions = await db.scalars(query)
-        return transactions
-
-    @classmethod
-    async def get_by_user_between_dates(
-        cls: "type[Transaction]", db: AsyncSession, user_id: int, start_date: datetime, end_date: datetime
-    ) -> "List[Transaction]":
-        query = sql.select(cls).where(cls.user_id == user_id).where(cls.transaction_date.between(start_date, end_date))
-        transactions = await db.scalars(query)
-        return transactions.all()

app/model/user.py

@@ -1,110 +0,0 @@
-import logging
-from sqlalchemy.orm import relationship, Mapped, mapped_column
-from sqlalchemy.sql import expression as sql
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.model.base import BaseModel
-from app.engine.postgresdb import Base
-from app.schema.index import UserCreate, UserUpdate
-
-logger = logging.getLogger(__name__)
-
-
-class User(Base, BaseModel):
-    __tablename__ = "users"
-
-    name: Mapped[str]
-    email: Mapped[str]
-    hashed_password: Mapped[str]
-    is_deleted: Mapped[bool] = mapped_column(default=False)
-
-    transactions = relationship("Transaction", back_populates="user")
-    income_statements = relationship("IncomeStatement", back_populates="user")
-
-    @classmethod
-    async def create(cls: "type[User]", db: AsyncSession, **kwargs: UserCreate) -> "User":
-        """
-        Creates a new user in the database.
-
-        Args:
-            cls (type[User]): The class object representing the User model.
-            db (AsyncSession): The asynchronous session object for interacting with the database.
-            **kwargs (UserCreate): The keyword arguments representing the user's attributes.
-
-        Returns:
-            User
-        """
-
-        print(f"Creating user: {kwargs}")
-        # query = sql.insert(cls).values(**kwargs)
-        user = cls(name=kwargs["name"], email=kwargs["email"], hashed_password=kwargs["hashed_password"])
-        db.add(user)
-        await db.commit()
-        await db.refresh(user)
-        return user
-
-    @classmethod
-    async def update(cls: "type[User]", db: AsyncSession, id: int, **kwargs: UserUpdate) -> "User":
-        """
-        Updates a user in the database with the given ID and keyword arguments.
-
-        Args:
-            cls (type[User]): The class object representing the User model.
-            db (AsyncSession): The asynchronous session object for interacting with the database.
-            id (int): The ID of the user to update.
-            **kwargs (UserUpdate): The keyword arguments representing the user's attributes to update.
-
-        Returns:
-            User
-        """
-
-        query = sql.update(cls).where(cls.id == id).values(**kwargs).execution_options(synchronize_session="fetch")
-        results = await db.execute(query)
-        user = results.fetchone()
-        await db.commit()
-        return user
-
-    @classmethod
-    async def get(cls: "type[User]", db: AsyncSession, email: str) -> "User":
-        """
-        Retrieves a user from the database based on their email.
-
-        Args:
-            cls (type[User]): The class object representing the User model.
-            db (AsyncSession): The asynchronous session object for interacting with the database.
-            email (str): The email of the user to retrieve.
-
-        Returns:
-            User
-        """
-
-        logging.info(f"Getting user: {email}")
-        query = sql.select(cls).where(cls.email == email)
-        logging.info(f"Query: {query}")
-        users = await db.scalars(query)
-        logging.info(f"Users: {users}")
-        return users.first()
-
-    @classmethod
-    async def delete(cls: "type[User]", db: AsyncSession, email: str) -> "User":
-        """
-        Deletes a user from the database based on their email.
-
-        Args:
-            cls (type[User]): The class object representing the User model.
-            db (AsyncSession): The asynchronous session object for interacting with the database.
-            email (str): The email of the user to delete.
-
-        Returns:
-            User
-        """
-        query = (
-            sql.update(cls)
-            .where(cls.email == email)
-            .values(is_deleted=True)
-            .execution_options(synchronize_session="fetch")
-        )
-        result = await db.execute(query)
-        user = result.fetchone()
-        await db.commit()
-        return user

app/schema/base.py

@@ -1,14 +0,0 @@
-from datetime import datetime
-from pydantic import BaseModel, ConfigDict
-
-
-class PydanticBaseModel(BaseModel):
-    pass
-
-
-class BaseModel(PydanticBaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    id: int
-    created_at: datetime
-    updated_at: datetime

app/schema/index.py

@@ -1,85 +0,0 @@
-from enum import Enum
-from datetime import datetime
-from typing import Dict, List
-from typing_extensions import TypedDict
-
-from app.schema.base import BaseModel, PydanticBaseModel
-
-
-class TransactionType(str, Enum):
-    INCOME = "income"
-    EXPENSE = "expense"
-
-
-class UserCreate(PydanticBaseModel):
-    name: str
-    email: str
-    hashed_password: str
-
-
-class UserUpdate(PydanticBaseModel):
-    name: str
-    email: str
-    hashed_password: str
-
-
-class UserResponse(PydanticBaseModel):
-    id: int
-    name: str
-    email: str
-    is_deleted: bool
-
-
-class User(BaseModel):
-    name: str
-    email: str
-    hashed_password: str
-    is_deleted: bool = False
-    transactions: "List[Transaction]" = []
-
-
-class TransactionResponse(PydanticBaseModel):
-    transaction_date: datetime
-    category: str
-    name_description: str
-    amount: float
-    type: TransactionType
-
-
-class TransactionCreate(TransactionResponse):
-    user_id: int
-
-
-class Transaction(TransactionResponse):
-    user: User
-
-
-class FileUploadCreate(PydanticBaseModel):
-    source: str
-    date: datetime
-    category: str
-    name_description: str
-    amount: float
-    type: str
-
-
-class IncomeStatementCreateRequest(PydanticBaseModel):
-    user_id: int
-    date_from: datetime
-    date_to: datetime
-
-
-class IncomeStatementDetail(TypedDict):
-    total: float
-    category_totals: List[Dict[str, str | float]]
-
-class IncomeStatementLLMResponse(PydanticBaseModel):
-    income: IncomeStatementDetail
-    expenses: IncomeStatementDetail
-
-
-class IncomeStatement(IncomeStatementCreateRequest, IncomeStatementLLMResponse):
-    pass
-
-class IncomeStatementResponse(IncomeStatement):
-    id: int

app/service/income_statement.py

@@ -1,37 +0,0 @@
-import logging
-from app.schema.index import IncomeStatement, IncomeStatementCreateRequest
-from app.model.transaction import Transaction as TransactionModel
-from app.model.income_statement import IncomeStatement as IncomeStatementModel
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.service.llm import call_llm
-
-
-async def call_llm_to_create_income_statement(payload: IncomeStatementCreateRequest, db: AsyncSession) -> None:
-    transactions = await TransactionModel.get_by_user_between_dates(
-        db, payload.user_id, payload.date_from, payload.date_to
-    )
-
-    if not transactions:
-        print("No transactions found")
-        return
-
-    response = await call_llm(transactions)
-
-    income = response.dict()['income']
-    expenses = response.dict()['expenses']
-
-    try:
-        income_statement_create_payload = IncomeStatement(
-            user_id=payload.user_id,
-            date_from=payload.date_from,
-            date_to=payload.date_to,
-            income=income,
-            expenses=expenses,
-        )
-
-        income_statement = await IncomeStatementModel.create(db, **income_statement_create_payload.model_dump())
-        print(f"Income statement created: {income_statement}")
-    except Exception as e:
-        print(e)
-        raise e

app/service/llm.py

@@ -1,55 +0,0 @@
-from typing import List
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables.base import RunnableSequence
-from langchain_openai import OpenAI
-from langchain.globals import set_llm_cache
-
-from app.model.transaction import Transaction
-from app.schema.index import IncomeStatementLLMResponse
-from config.index import config as env
-
-from langchain_core.output_parsers import PydanticOutputParser
-
-set_llm_cache(None)
-
-def income_statement_prompt () -> ChatPromptTemplate:
-    context_str = """
-        You are an accountant skilled at organizing transactions from multiple different bank
-        accounts and credit card statements to prepare an income statement.
-
-        Input data is in the below csv format:
-        transaction_date, category, name_description, amount, type\n
-        {input_data_csv}
-
-        Your task is to prepare an income statement. The output should be in the following format: {format_instructions}
-
-        """
-    prompt = ChatPromptTemplate.from_template(context_str)
-    return prompt
-
-async def call_llm(inputData: List[Transaction]) -> str:
-    input_data_csv = '\n'.join(str(x) for x in inputData)
-
-    output_parser = PydanticOutputParser(pydantic_object=IncomeStatementLLMResponse)
-
-    prompt = income_statement_prompt().partial(format_instructions=output_parser.get_format_instructions())
-
-    llm = OpenAI(name='Income Statement Generation Bot',
-                        api_key=env.OPENAI_API_KEY,
-                        # cache=True,
-                        temperature=0.7,
-                        verbose=True)
-
-    try:
-        runnable_chain = RunnableSequence(prompt, llm, output_parser)
-    except Exception as e:
-        print(f"runnable_chain error: {str(e)}")
-        raise e
-
-    try:
-        output_chunks = runnable_chain.invoke({"input_data_csv": input_data_csv})
-        return output_chunks
-
-    except Exception as e:
-        print(f"runnable_chain.invoke error: {str(e)}")
-        raise e

app/transactions_rag/categorize_transactions.ipynb

@@ -529,7 +529,7 @@
     "    print(\"\\nProcessing file\")\n",
     "    result = await asyncio.gather(processed_file)\n",
     "\n",
-    "    await save_results(result)\n",
+    "    save_results(result)\n",
     "    print(result)\n",
     "\n",
     "    output_file = open(CATEGORY_REFERENCE_OUTPUT_FILE, \"r+\")\n",
@@ -537,7 +537,8 @@
     "\n",
     "\n",
     "result = await apply_categorization()\n",
-    "print(result)\n"
+    "print(result)\n",
+    "\n"
    ]
   }
  ],

config/index.py

@@ -1,34 +0,0 @@
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-
-
-class Config:
-    DEBUG = os.getenv("DEBUG", False)
-    SQLALCHEMY_DATABASE_URI = os.getenv("SQLALCHEMY_DATABASE_URI")
-    SQLALCHEMY_TRACK_MODIFICATIONS = os.getenv("SQLALCHEMY_TRACK_MODIFICATIONS", False)
-    ENVIRONMENT = os.getenv("ENVIRONMENT", "dev")
-    APP_HOST = os.getenv("APP_HOST", "0.0.0.0")
-    APP_PORT = int(os.getenv("APP_PORT", "8000"))
-    PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
-    PINECONE_INDEX_NAME = os.getenv("PINECONE_INDEX_NAME")
-    PINECONE_ENVIRONMENT = os.getenv("PINECONE_ENVIRONMENT")
-    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-    OPENAI_ORGANIZATION = os.getenv("OPENAI_ORGANIZATION")
-    MODEL = os.getenv("MODEL", "gpt-3.5-turbo")
-    EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "text-embedding-ada-002")
-    EMBEDDING_DIM = os.getenv("EMBEDDING_DIM", "1536")
-    CHUNK_SIZE = int(os.getenv("CHUNK_SIZE", "1024"))
-    CHUNK_OVERLAP = int(os.getenv("CHUNK_OVERLAP", "20"))
-    MAX_TOKENS = int(os.getenv("MAX_TOKENS", "4000"))
-
-    POSTGRES_USER = os.getenv("POSTGRES_USER")
-    POSTGRES_PASSWORD = os.getenv("POSTGRES_PASSWORD")
-    POSTGRES_DB_NAME = os.getenv("POSTGRES_DB_NAME")
-    POSTGRES_DB_HOST = os.getenv("POSTGRES_DB_HOST")
-    POSTGRES_DB_PORT = int(os.getenv("POSTGRES_DB_PORT", 5432))
-    SQLALCHEMY_DATABASE_URL = f"postgresql+asyncpg://{POSTGRES_USER}:{POSTGRES_PASSWORD}@{POSTGRES_DB_HOST}:{POSTGRES_DB_PORT}/{POSTGRES_DB_NAME}"
-
-
-config = Config

data/tx_data/input/transactions_2024.csv

@@ -1,28 +0,0 @@
-2023-12-30,Comcast Internet,Expense,9.96
-2023-12-30,Lemonade Home Insurance,Expense,17.53
-2023-12-30,Monthly Appartment Rent,Expense,2000.0
-2023-12-30,Staples Office Supplies,Expense,12.46
-2023-12-29,Selling Paintings,Income,13.63
-2023-12-29,Spotify,Expense,12.19
-2023-12-23,Target,Expense,27.08
-2023-12-22,IT Consulting,Income,541.57
-2023-12-22,Phone,Expense,10.7
-2023-12-20,ML Consulting,Income,2641.93
-2023-12-19,Chipotle,Expense,18.9
-2023-12-18,Cold Brew Coffee,Expense,17.67
-2023-12-18,Gas,Expense,8.80
-2023-12-18,CA Property Tax,Expense,1670.34
-2022-11-26,Salary,Income,4000.36
-2022-11-26,Cellphone,Expense,19.27
-2022-11-26,Gym Membership,Expense,24.71
-2022-11-25,Wholefoods,Expense,17.35
-2022-11-24,Freelancing,Income,2409.55
-2022-11-19,Spotify,Expense,20.76
-2022-10-25,Blogging,Income,4044.27
-2022-10-24,Uber Taxi,Expense,18.9
-2022-10-23,Uber Taxi,Expense,27.54
-2022-10-22,Apple Services,Expense,41.25
-2022-10-21,Netflix,Expense,22.8
-2022-01-16,Amazon Lux,Expense,24.11
-2022-01-15,Burger King,Expense,30.08
-2022-01-14,Amazon,Expense,11.0

main.py

@@ -1,74 +1,51 @@
+from dotenv import load_dotenv
+
+load_dotenv()
+
 import logging
 import os
 import uvicorn
-from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import RedirectResponse
 from app.api.routers.chat import chat_router
-from app.api.routers.user import user_router
-from app.api.routers.transaction import transaction_router
-from app.api.routers.file_upload import file_upload_router
-from app.api.routers.income_statement import income_statement_router
 from app.settings import init_settings
+from app.observability import init_observability
 from fastapi.staticfiles import StaticFiles
-from alembic.config import Config
-from alembic import command
-
 
-from app.engine.postgresdb import postgresdb
-from config.index import config as env
-
-logger = logging.getLogger("uvicorn")
 
+app = FastAPI()
 
 init_settings()
-# init_observability()
-
-
-def init_app(init_db: bool = True) -> FastAPI:
-    lifespan = None
+init_observability()
 
-    if init_db:
-        postgresdb.init(env.SQLALCHEMY_DATABASE_URL, {"echo": True, "future": True})
+environment = os.getenv("ENVIRONMENT", "dev")  # Default to 'development' if not set
 
-        @asynccontextmanager
-        async def lifespan(app: FastAPI):
-            yield
-            if postgresdb.get_engine() is not None:
-                await postgresdb.close()
+if environment == "dev":
+    logger = logging.getLogger("uvicorn")
+    logger.warning("Running in development mode - allowing CORS for all origins")
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
 
-    app = FastAPI(lifespan=lifespan)
+    # Redirect to documentation page when accessing base URL
+    @app.get("/")
+    async def redirect_to_docs():
+        return RedirectResponse(url="/docs")
 
-    if env.ENVIRONMENT == "dev":
-        logger.warning("Running in development mode - allowing CORS for all origins")
-        app.add_middleware(
-            CORSMiddleware,
-            allow_origins=["*"],
-            allow_credentials=True,
-            allow_methods=["*"],
-            allow_headers=["*"],
-        )
 
-    if os.path.exists("data"):
-        app.mount("/api/data", StaticFiles(directory="data"), name="static")
-    app.include_router(chat_router, prefix="/api/chat")
-    app.include_router(user_router)
-    app.include_router(transaction_router)
-    app.include_router(file_upload_router)
-    app.include_router(income_statement_router)
-
-    return app
-
-
-app = init_app()
-
-
-# Redirect to documentation page when accessing base URL
-@app.get("/")
-async def redirect_to_docs():
-    return RedirectResponse(url="/docs")
+if os.path.exists("data"):
+    app.mount("/api/data", StaticFiles(directory="data"), name="static")
+app.include_router(chat_router, prefix="/api/chat")
 
 
 if __name__ == "__main__":
-    uvicorn.run(app="main:app", host=env.APP_HOST, port=env.APP_PORT, reload=(env.ENVIRONMENT == "dev"))
+    app_host = os.getenv("APP_HOST", "0.0.0.0")
+    app_port = int(os.getenv("APP_PORT", "8000"))
+    reload = True if environment == "dev" else False
+
+    uvicorn.run(app="main:app", host=app_host, port=app_port, reload=reload)

migration/README

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

migration/env.py

@@ -1,91 +0,0 @@
-import asyncio
-from logging.config import fileConfig
-
-from app.engine.postgresdb import Base
-from sqlalchemy import Connection
-from sqlalchemy import pool
-from sqlalchemy.ext.asyncio import async_engine_from_config
-
-from config.index import config as env
-
-from alembic import context
-
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
-config = context.config
-
-config.set_main_option("sqlalchemy.url", env.SQLALCHEMY_DATABASE_URL)
-
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name)
-
-# Import all models so they're registered with SQLAlchemy.
-import app.model.user
-import app.model.transaction
-import app.model.income_statement
-
-# 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.
-
-
-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 do_run_migrations(connection: Connection) -> None:
-    context.configure(connection=connection, target_metadata=target_metadata)
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-async 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.
-    """
-    configuration = config.get_section(config.config_ini_section)
-    configuration["sqlalchemy.url"] = env.SQLALCHEMY_DATABASE_URL
-    connectable = async_engine_from_config(
-        configuration,
-        prefix="sqlalchemy.",
-        poolclass=pool.NullPool,
-    )
-
-    async with connectable.connect() as connection:
-        await connection.run_sync(do_run_migrations)
-
-    await connectable.dispose()
-
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    asyncio.run(run_migrations_online())

migration/script.py.mako

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

migration/versions/4e76691ab103_add_income_statement_table.py

@@ -1,43 +0,0 @@
-"""add_income_statement_table
-
-Revision ID: 4e76691ab103
-Revises: 7ea44cbc5b1f
-Create Date: 2024-06-03 23:59:03.717778
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision: str = '4e76691ab103'
-down_revision: Union[str, None] = '7ea44cbc5b1f'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('income_statement',
-    sa.Column('income', postgresql.JSON(astext_type=sa.Text()), nullable=True),
-    sa.Column('expenses', postgresql.JSON(astext_type=sa.Text()), nullable=True),
-    sa.Column('date_from', sa.DateTime(), nullable=False),
-    sa.Column('date_to', sa.DateTime(), nullable=False),
-    sa.Column('user_id', sa.Integer(), nullable=False),
-    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
-    sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
-    sa.Column('updated_at', sa.DateTime(timezone=True), nullable=False),
-    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_index(op.f('ix_income_statement_id'), 'income_statement', ['id'], unique=False)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index(op.f('ix_income_statement_id'), table_name='income_statement')
-    op.drop_table('income_statement')
-    # ### end Alembic commands ###

migration/versions/7ea44cbc5b1f_default_timezone.py

@@ -1,69 +0,0 @@
-"""default_timezone
-
-Revision ID: 7ea44cbc5b1f
-Revises: 8feaedca36f9
-Create Date: 2024-06-02 14:36:01.552518
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision: str = "7ea44cbc5b1f"
-down_revision: Union[str, None] = "8feaedca36f9"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column(
-        "transactions",
-        "created_at",
-        existing_type=postgresql.TIMESTAMP(),
-        type_=sa.DateTime(timezone=True),
-        nullable=False,
-    )
-    op.alter_column(
-        "transactions",
-        "updated_at",
-        existing_type=postgresql.TIMESTAMP(),
-        type_=sa.DateTime(timezone=True),
-        nullable=False,
-    )
-    op.alter_column(
-        "users", "created_at", existing_type=postgresql.TIMESTAMP(), type_=sa.DateTime(timezone=True), nullable=False
-    )
-    op.alter_column(
-        "users", "updated_at", existing_type=postgresql.TIMESTAMP(), type_=sa.DateTime(timezone=True), nullable=False
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column(
-        "users", "updated_at", existing_type=sa.DateTime(timezone=True), type_=postgresql.TIMESTAMP(), nullable=True
-    )
-    op.alter_column(
-        "users", "created_at", existing_type=sa.DateTime(timezone=True), type_=postgresql.TIMESTAMP(), nullable=True
-    )
-    op.alter_column(
-        "transactions",
-        "updated_at",
-        existing_type=sa.DateTime(timezone=True),
-        type_=postgresql.TIMESTAMP(),
-        nullable=True,
-    )
-    op.alter_column(
-        "transactions",
-        "created_at",
-        existing_type=sa.DateTime(timezone=True),
-        type_=postgresql.TIMESTAMP(),
-        nullable=True,
-    )
-    # ### end Alembic commands ###

migration/versions/8feaedca36f9_users_datatype_updates.py

@@ -1,74 +0,0 @@
-"""Remove_Transactions_From_Users
-
-Revision ID: 8feaedca36f9
-Revises: cd515c44401d
-Create Date: 2024-06-02 01:26:54.731002
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision: str = '8feaedca36f9'
-down_revision: Union[str, None] = 'cd515c44401d'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column('transactions', 'transaction_date',
-               existing_type=postgresql.TIMESTAMP(),
-               nullable=False)
-    op.alter_column('transactions', 'category',
-               existing_type=sa.VARCHAR(),
-               nullable=False)
-    op.alter_column('transactions', 'name_description',
-               existing_type=sa.VARCHAR(),
-               nullable=False)
-    op.alter_column('transactions', 'amount',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=False)
-    op.alter_column('transactions', 'type',
-               existing_type=sa.VARCHAR(),
-               nullable=False)
-    op.add_column('users', sa.Column('hashed_password', sa.String(), nullable=False))
-    op.add_column('users', sa.Column('is_deleted', sa.Boolean(), nullable=False))
-    op.alter_column('users', 'name',
-               existing_type=sa.VARCHAR(),
-               nullable=False)
-    op.alter_column('users', 'email',
-               existing_type=sa.VARCHAR(),
-               nullable=False)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column('users', 'email',
-               existing_type=sa.VARCHAR(),
-               nullable=True)
-    op.alter_column('users', 'name',
-               existing_type=sa.VARCHAR(),
-               nullable=True)
-    op.drop_column('users', 'is_deleted')
-    op.drop_column('users', 'hashed_password')
-    op.alter_column('transactions', 'type',
-               existing_type=sa.VARCHAR(),
-               nullable=True)
-    op.alter_column('transactions', 'amount',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=True)
-    op.alter_column('transactions', 'name_description',
-               existing_type=sa.VARCHAR(),
-               nullable=True)
-    op.alter_column('transactions', 'category',
-               existing_type=sa.VARCHAR(),
-               nullable=True)
-    op.alter_column('transactions', 'transaction_date',
-               existing_type=postgresql.TIMESTAMP(),
-               nullable=True)
-    # ### end Alembic commands ###

migration/versions/cd515c44401d_add_users_transactions_tables.py

@@ -1,55 +0,0 @@
-"""Add users, transactions tables
-
-Revision ID: cd515c44401d
-Revises: 
-Create Date: 2024-06-01 01:32:42.500524
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = 'cd515c44401d'
-down_revision: Union[str, None] = None
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('users',
-    sa.Column('name', sa.String(), nullable=True),
-    sa.Column('email', sa.String(), nullable=True),
-    sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('created_at', sa.DateTime(), nullable=True),
-    sa.Column('updated_at', sa.DateTime(), nullable=True),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_index(op.f('ix_users_id'), 'users', ['id'], unique=False)
-    op.create_table('transactions',
-    sa.Column('transaction_date', sa.DateTime(), nullable=True),
-    sa.Column('category', sa.String(), nullable=True),
-    sa.Column('name_description', sa.String(), nullable=True),
-    sa.Column('amount', sa.Float(), nullable=True),
-    sa.Column('type', sa.String(), nullable=True),
-    sa.Column('user_id', sa.Integer(), nullable=True),
-    sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('created_at', sa.DateTime(), nullable=True),
-    sa.Column('updated_at', sa.DateTime(), nullable=True),
-    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_index(op.f('ix_transactions_id'), 'transactions', ['id'], unique=False)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index(op.f('ix_transactions_id'), table_name='transactions')
-    op.drop_table('transactions')
-    op.drop_index(op.f('ix_users_id'), table_name='users')
-    op.drop_table('users')
-    # ### end Alembic commands ###

poetry.lock

@@ -123,25 +123,6 @@ files = [
 [package.dependencies]
 typing-extensions = "*"
 
-[[package]]
-name = "alembic"
-version = "1.13.1"
-description = "A database migration tool for SQLAlchemy."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "alembic-1.13.1-py3-none-any.whl", hash = "sha256:2edcc97bed0bd3272611ce3a98d98279e9c209e7186e43e75bbb1b2bdfdbcc43"},
-    {file = "alembic-1.13.1.tar.gz", hash = "sha256:4932c8558bf68f2ee92b9bbcb8218671c627064d5b08939437af6d77dc05e595"},
-]
-
-[package.dependencies]
-Mako = "*"
-SQLAlchemy = ">=1.3.0"
-typing-extensions = ">=4"
-
-[package.extras]
-tz = ["backports.zoneinfo"]
-
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -198,87 +179,6 @@ doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphin
 test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"]
 trio = ["trio (>=0.23)"]
 
-[[package]]
-name = "async-timeout"
-version = "4.0.3"
-description = "Timeout context manager for asyncio programs"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"},
-    {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"},
-]
-
-[[package]]
-name = "asyncio"
-version = "3.4.3"
-description = "reference implementation of PEP 3156"
-optional = false
-python-versions = "*"
-files = [
-    {file = "asyncio-3.4.3-cp33-none-win32.whl", hash = "sha256:b62c9157d36187eca799c378e572c969f0da87cd5fc42ca372d92cdb06e7e1de"},
-    {file = "asyncio-3.4.3-cp33-none-win_amd64.whl", hash = "sha256:c46a87b48213d7464f22d9a497b9eef8c1928b68320a2fa94240f969f6fec08c"},
-    {file = "asyncio-3.4.3-py3-none-any.whl", hash = "sha256:c4d18b22701821de07bd6aea8b53d21449ec0ec5680645e5317062ea21817d2d"},
-    {file = "asyncio-3.4.3.tar.gz", hash = "sha256:83360ff8bc97980e4ff25c964c7bd3923d333d177aa4f7fb736b019f26c7cb41"},
-]
-
-[[package]]
-name = "asyncpg"
-version = "0.29.0"
-description = "An asyncio PostgreSQL driver"
-optional = false
-python-versions = ">=3.8.0"
-files = [
-    {file = "asyncpg-0.29.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72fd0ef9f00aeed37179c62282a3d14262dbbafb74ec0ba16e1b1864d8a12169"},
-    {file = "asyncpg-0.29.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:52e8f8f9ff6e21f9b39ca9f8e3e33a5fcdceaf5667a8c5c32bee158e313be385"},
-    {file = "asyncpg-0.29.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9e6823a7012be8b68301342ba33b4740e5a166f6bbda0aee32bc01638491a22"},
-    {file = "asyncpg-0.29.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:746e80d83ad5d5464cfbf94315eb6744222ab00aa4e522b704322fb182b83610"},
-    {file = "asyncpg-0.29.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:ff8e8109cd6a46ff852a5e6bab8b0a047d7ea42fcb7ca5ae6eaae97d8eacf397"},
-    {file = "asyncpg-0.29.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:97eb024685b1d7e72b1972863de527c11ff87960837919dac6e34754768098eb"},
-    {file = "asyncpg-0.29.0-cp310-cp310-win32.whl", hash = "sha256:5bbb7f2cafd8d1fa3e65431833de2642f4b2124be61a449fa064e1a08d27e449"},
-    {file = "asyncpg-0.29.0-cp310-cp310-win_amd64.whl", hash = "sha256:76c3ac6530904838a4b650b2880f8e7af938ee049e769ec2fba7cd66469d7772"},
-    {file = "asyncpg-0.29.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d4900ee08e85af01adb207519bb4e14b1cae8fd21e0ccf80fac6aa60b6da37b4"},
-    {file = "asyncpg-0.29.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a65c1dcd820d5aea7c7d82a3fdcb70e096f8f70d1a8bf93eb458e49bfad036ac"},
-    {file = "asyncpg-0.29.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b52e46f165585fd6af4863f268566668407c76b2c72d366bb8b522fa66f1870"},
-    {file = "asyncpg-0.29.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc600ee8ef3dd38b8d67421359779f8ccec30b463e7aec7ed481c8346decf99f"},
-    {file = "asyncpg-0.29.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:039a261af4f38f949095e1e780bae84a25ffe3e370175193174eb08d3cecab23"},
-    {file = "asyncpg-0.29.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:6feaf2d8f9138d190e5ec4390c1715c3e87b37715cd69b2c3dfca616134efd2b"},
-    {file = "asyncpg-0.29.0-cp311-cp311-win32.whl", hash = "sha256:1e186427c88225ef730555f5fdda6c1812daa884064bfe6bc462fd3a71c4b675"},
-    {file = "asyncpg-0.29.0-cp311-cp311-win_amd64.whl", hash = "sha256:cfe73ffae35f518cfd6e4e5f5abb2618ceb5ef02a2365ce64f132601000587d3"},
-    {file = "asyncpg-0.29.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6011b0dc29886ab424dc042bf9eeb507670a3b40aece3439944006aafe023178"},
-    {file = "asyncpg-0.29.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b544ffc66b039d5ec5a7454667f855f7fec08e0dfaf5a5490dfafbb7abbd2cfb"},
-    {file = "asyncpg-0.29.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d84156d5fb530b06c493f9e7635aa18f518fa1d1395ef240d211cb563c4e2364"},
-    {file = "asyncpg-0.29.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54858bc25b49d1114178d65a88e48ad50cb2b6f3e475caa0f0c092d5f527c106"},
-    {file = "asyncpg-0.29.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:bde17a1861cf10d5afce80a36fca736a86769ab3579532c03e45f83ba8a09c59"},
-    {file = "asyncpg-0.29.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:37a2ec1b9ff88d8773d3eb6d3784dc7e3fee7756a5317b67f923172a4748a175"},
-    {file = "asyncpg-0.29.0-cp312-cp312-win32.whl", hash = "sha256:bb1292d9fad43112a85e98ecdc2e051602bce97c199920586be83254d9dafc02"},
-    {file = "asyncpg-0.29.0-cp312-cp312-win_amd64.whl", hash = "sha256:2245be8ec5047a605e0b454c894e54bf2ec787ac04b1cb7e0d3c67aa1e32f0fe"},
-    {file = "asyncpg-0.29.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0009a300cae37b8c525e5b449233d59cd9868fd35431abc470a3e364d2b85cb9"},
-    {file = "asyncpg-0.29.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5cad1324dbb33f3ca0cd2074d5114354ed3be2b94d48ddfd88af75ebda7c43cc"},
-    {file = "asyncpg-0.29.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:012d01df61e009015944ac7543d6ee30c2dc1eb2f6b10b62a3f598beb6531548"},
-    {file = "asyncpg-0.29.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:000c996c53c04770798053e1730d34e30cb645ad95a63265aec82da9093d88e7"},
-    {file = "asyncpg-0.29.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:e0bfe9c4d3429706cf70d3249089de14d6a01192d617e9093a8e941fea8ee775"},
-    {file = "asyncpg-0.29.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:642a36eb41b6313ffa328e8a5c5c2b5bea6ee138546c9c3cf1bffaad8ee36dd9"},
-    {file = "asyncpg-0.29.0-cp38-cp38-win32.whl", hash = "sha256:a921372bbd0aa3a5822dd0409da61b4cd50df89ae85150149f8c119f23e8c408"},
-    {file = "asyncpg-0.29.0-cp38-cp38-win_amd64.whl", hash = "sha256:103aad2b92d1506700cbf51cd8bb5441e7e72e87a7b3a2ca4e32c840f051a6a3"},
-    {file = "asyncpg-0.29.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5340dd515d7e52f4c11ada32171d87c05570479dc01dc66d03ee3e150fb695da"},
-    {file = "asyncpg-0.29.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e17b52c6cf83e170d3d865571ba574577ab8e533e7361a2b8ce6157d02c665d3"},
-    {file = "asyncpg-0.29.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f100d23f273555f4b19b74a96840aa27b85e99ba4b1f18d4ebff0734e78dc090"},
-    {file = "asyncpg-0.29.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48e7c58b516057126b363cec8ca02b804644fd012ef8e6c7e23386b7d5e6ce83"},
-    {file = "asyncpg-0.29.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f9ea3f24eb4c49a615573724d88a48bd1b7821c890c2effe04f05382ed9e8810"},
-    {file = "asyncpg-0.29.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8d36c7f14a22ec9e928f15f92a48207546ffe68bc412f3be718eedccdf10dc5c"},
-    {file = "asyncpg-0.29.0-cp39-cp39-win32.whl", hash = "sha256:797ab8123ebaed304a1fad4d7576d5376c3a006a4100380fb9d517f0b59c1ab2"},
-    {file = "asyncpg-0.29.0-cp39-cp39-win_amd64.whl", hash = "sha256:cce08a178858b426ae1aa8409b5cc171def45d4293626e7aa6510696d46decd8"},
-    {file = "asyncpg-0.29.0.tar.gz", hash = "sha256:d1c49e1f44fffafd9a55e1a9b101590859d881d639ea2922516f5d9c512d354e"},
-]
-
-[package.dependencies]
-async-timeout = {version = ">=4.0.3", markers = "python_version < \"3.12.0\""}
-
-[package.extras]
-docs = ["Sphinx (>=5.3.0,<5.4.0)", "sphinx-rtd-theme (>=1.2.2)", "sphinxcontrib-asyncio (>=0.3.0,<0.4.0)"]
-test = ["flake8 (>=6.1,<7.0)", "uvloop (>=0.15.3)"]
-
 [[package]]
 name = "attrs"
 version = "23.2.0"
@@ -541,20 +441,6 @@ files = [
     {file = "distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed"},
 ]
 
-[[package]]
-name = "execnet"
-version = "2.1.1"
-description = "execnet: rapid multi-Python deployment"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "execnet-2.1.1-py3-none-any.whl", hash = "sha256:26dee51f1b80cebd6d0ca8e74dd8745419761d3bef34163928cbebbdc4749fdc"},
-    {file = "execnet-2.1.1.tar.gz", hash = "sha256:5189b52c6121c24feae288166ab41b32549c7e2348652736540b9e6e7d4e72e3"},
-]
-
-[package.extras]
-testing = ["hatch", "pre-commit", "pytest", "tox"]
-
 [[package]]
 name = "fastapi"
 version = "0.109.2"
@@ -1039,17 +925,6 @@ files = [
     {file = "inflection-0.5.1.tar.gz", hash = "sha256:1a29730d366e996aaacffb2f1f1cb9593dc38e2ddd30c91250c6dde09ea9b417"},
 ]
 
-[[package]]
-name = "iniconfig"
-version = "2.0.0"
-description = "brain-dead simple config-ini parsing"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},
-    {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
-]
-
 [[package]]
 name = "jinja2"
 version = "3.1.4"
@@ -1590,25 +1465,6 @@ files = [
 httpx = ">=0.20.0"
 pydantic = ">=1.10"
 
-[[package]]
-name = "mako"
-version = "1.3.5"
-description = "A super-fast templating language that borrows the best ideas from the existing templating languages."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "Mako-1.3.5-py3-none-any.whl", hash = "sha256:260f1dbc3a519453a9c856dedfe4beb4e50bd5a26d96386cb6c80856556bb91a"},
-    {file = "Mako-1.3.5.tar.gz", hash = "sha256:48dbc20568c1d276a2698b36d968fa76161bf127194907ea6fc594fa81f943bc"},
-]
-
-[package.dependencies]
-MarkupSafe = ">=0.9.2"
-
-[package.extras]
-babel = ["Babel"]
-lingua = ["lingua"]
-testing = ["pytest"]
-
 [[package]]
 name = "markupsafe"
 version = "2.1.5"
@@ -1697,20 +1553,6 @@ dev = ["marshmallow[tests]", "pre-commit (>=3.5,<4.0)", "tox"]
 docs = ["alabaster (==0.7.16)", "autodocsumm (==0.2.12)", "sphinx (==7.3.7)", "sphinx-issues (==4.1.0)", "sphinx-version-warning (==1.1.2)"]
 tests = ["pytest", "pytz", "simplejson"]
 
-[[package]]
-name = "mirakuru"
-version = "2.5.2"
-description = "Process executor (not only) for tests."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "mirakuru-2.5.2-py3-none-any.whl", hash = "sha256:90c2d90a8cf14349b2f33e6db30a16acd855499811e0312e56cf80ceacf2d3e5"},
-    {file = "mirakuru-2.5.2.tar.gz", hash = "sha256:41ca583d355eb7a6cfdc21c1aea549979d685c27b57239b88725434f115a7132"},
-]
-
-[package.dependencies]
-psutil = {version = ">=4.0.0", markers = "sys_platform != \"cygwin\""}
-
 [[package]]
 name = "monotonic"
 version = "1.6"
@@ -2698,32 +2540,6 @@ urllib3 = {version = ">=1.26.0", markers = "python_version >= \"3.8\" and python
 [package.extras]
 grpc = ["googleapis-common-protos (>=1.53.0)", "grpc-gateway-protoc-gen-openapiv2 (==0.1.0)", "grpcio (>=1.44.0)", "grpcio (>=1.59.0)", "lz4 (>=3.1.3)", "protobuf (>=3.20.0,<3.21.0)"]
 
-[[package]]
-name = "pluggy"
-version = "1.5.0"
-description = "plugin and hook calling mechanisms for python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
-    {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
-]
-
-[package.extras]
-dev = ["pre-commit", "tox"]
-testing = ["pytest", "pytest-benchmark"]
-
-[[package]]
-name = "port-for"
-version = "0.7.2"
-description = "Utility that helps with local TCP ports management. It can find an unused TCP localhost port and remember the association."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "port-for-0.7.2.tar.gz", hash = "sha256:074f29335130578aa42fef3726985e57d01c15189e509633a8a1b0b7f9226349"},
-    {file = "port_for-0.7.2-py3-none-any.whl", hash = "sha256:16b279ab4f210bad33515c45bd9af0c6e048ab24c3b6bbd9cfc7e451782617df"},
-]
-
 [[package]]
 name = "posthog"
 version = "3.5.0"
@@ -2767,129 +2583,6 @@ files = [
     {file = "protobuf-4.25.3.tar.gz", hash = "sha256:25b5d0b42fd000320bd7830b349e3b696435f3b329810427a6bcce6a5492cc5c"},
 ]
 
-[[package]]
-name = "psutil"
-version = "5.9.8"
-description = "Cross-platform lib for process and system monitoring in Python."
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*"
-files = [
-    {file = "psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8"},
-    {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73"},
-    {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7"},
-    {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36"},
-    {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d"},
-    {file = "psutil-5.9.8-cp27-none-win32.whl", hash = "sha256:36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e"},
-    {file = "psutil-5.9.8-cp27-none-win_amd64.whl", hash = "sha256:bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631"},
-    {file = "psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81"},
-    {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421"},
-    {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4"},
-    {file = "psutil-5.9.8-cp36-cp36m-win32.whl", hash = "sha256:7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee"},
-    {file = "psutil-5.9.8-cp36-cp36m-win_amd64.whl", hash = "sha256:27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2"},
-    {file = "psutil-5.9.8-cp37-abi3-win32.whl", hash = "sha256:bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0"},
-    {file = "psutil-5.9.8-cp37-abi3-win_amd64.whl", hash = "sha256:8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf"},
-    {file = "psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8"},
-    {file = "psutil-5.9.8.tar.gz", hash = "sha256:6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c"},
-]
-
-[package.extras]
-test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"]
-
-[[package]]
-name = "psycopg"
-version = "3.1.19"
-description = "PostgreSQL database adapter for Python"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "psycopg-3.1.19-py3-none-any.whl", hash = "sha256:dca5e5521c859f6606686432ae1c94e8766d29cc91f2ee595378c510cc5b0731"},
-    {file = "psycopg-3.1.19.tar.gz", hash = "sha256:92d7b78ad82426cdcf1a0440678209faa890c6e1721361c2f8901f0dccd62961"},
-]
-
-[package.dependencies]
-typing-extensions = ">=4.1"
-tzdata = {version = "*", markers = "sys_platform == \"win32\""}
-
-[package.extras]
-binary = ["psycopg-binary (==3.1.19)"]
-c = ["psycopg-c (==3.1.19)"]
-dev = ["black (>=24.1.0)", "codespell (>=2.2)", "dnspython (>=2.1)", "flake8 (>=4.0)", "mypy (>=1.4.1)", "types-setuptools (>=57.4)", "wheel (>=0.37)"]
-docs = ["Sphinx (>=5.0)", "furo (==2022.6.21)", "sphinx-autobuild (>=2021.3.14)", "sphinx-autodoc-typehints (>=1.12)"]
-pool = ["psycopg-pool"]
-test = ["anyio (>=3.6.2,<4.0)", "mypy (>=1.4.1)", "pproxy (>=2.7)", "pytest (>=6.2.5)", "pytest-cov (>=3.0)", "pytest-randomly (>=3.5)"]
-
-[[package]]
-name = "psycopg-binary"
-version = "3.1.19"
-description = "PostgreSQL database adapter for Python -- C optimisation distribution"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "psycopg_binary-3.1.19-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7204818f05151dd08f8f851defb01972ec9d2cc925608eb0de232563f203f354"},
-    {file = "psycopg_binary-3.1.19-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6d4e67fd86758dbeac85641419a54f84d74495a8683b58ad5dfad08b7fc37a8f"},
-    {file = "psycopg_binary-3.1.19-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e12173e34b176e93ad2da913de30f774d5119c2d4d4640c6858d2d77dfa6c9bf"},
-    {file = "psycopg_binary-3.1.19-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:052f5193304066318853b4b2e248f523c8f52b371fc4e95d4ef63baee3f30955"},
-    {file = "psycopg_binary-3.1.19-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:29008f3f8977f600b8a7fb07c2e041b01645b08121760609cc45e861a0364dc9"},
-    {file = "psycopg_binary-3.1.19-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7c6a9a651a08d876303ed059c9553df18b3c13c3406584a70a8f37f1a1fe2709"},
-    {file = "psycopg_binary-3.1.19-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:91a645e6468c4f064b7f4f3b81074bdd68fe5aa2b8c5107de15dcd85ba6141be"},
-    {file = "psycopg_binary-3.1.19-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:5c6956808fd5cf0576de5a602243af8e04594b25b9a28675feddc71c5526410a"},
-    {file = "psycopg_binary-3.1.19-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:1622ca27d5a7a98f7d8f35e8b146dc7efda4a4b6241d2edf7e076bd6bcecbeb4"},
-    {file = "psycopg_binary-3.1.19-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a100482950a55228f648bd382bb71bfaff520002f29845274fccbbf02e28bd52"},
-    {file = "psycopg_binary-3.1.19-cp310-cp310-win_amd64.whl", hash = "sha256:955ca8905c0251fc4af7ce0a20999e824a25652f53a558ab548b60969f1f368e"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cf49e91dcf699b8a449944ed898ef1466b39b92720613838791a551bc8f587a"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:964c307e400c5f33fa762ba1e19853e048814fcfbd9679cc923431adb7a2ead2"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3433924e1b14074798331dc2bfae2af452ed7888067f2fc145835704d8981b15"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:00879d4c6be4b3afc510073f48a5e960f797200e261ab3d9bd9b7746a08c669d"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:34a6997c80f86d3dd80a4f078bb3b200079c47eeda4fd409d8899b883c90d2ac"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0106e42b481677c41caa69474fe530f786dcef88b11b70000f0e45a03534bc8f"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:81efe09ba27533e35709905c3061db4dc9fb814f637360578d065e2061fbb116"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:d312d6dddc18d9c164e1893706269c293cba1923118349d375962b1188dafb01"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:bfd2c734da9950f7afaad5f132088e0e1478f32f042881fca6651bb0c8d14206"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8a732610a5a6b4f06dadcf9288688a8ff202fd556d971436a123b7adb85596e2"},
-    {file = "psycopg_binary-3.1.19-cp311-cp311-win_amd64.whl", hash = "sha256:321814a9a3ad785855a821b842aba08ca1b7de7dfb2979a2f0492dca9ec4ae70"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:4aa0ca13bb8a725bb6d12c13999217fd5bc8b86a12589f28a74b93e076fbb959"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:469424e354ebcec949aa6aa30e5a9edc352a899d9a68ad7a48f97df83cc914cf"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b04f5349313529ae1f1c42fe1aa0443faaf50fdf12d13866c2cc49683bfa53d0"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:959feabddc7fffac89b054d6f23f3b3c62d7d3c90cd414a02e3747495597f150"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e9da624a6ca4bc5f7fa1f03f8485446b5b81d5787b6beea2b4f8d9dbef878ad7"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1823221a6b96e38b15686170d4fc5b36073efcb87cce7d3da660440b50077f6"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:866db42f986298f0cf15d805225eb8df2228bf19f7997d7f1cb5f388cbfc6a0f"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:738c34657305b5973af6dbb6711b07b179dfdd21196d60039ca30a74bafe9648"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:fb9758473200384a04374d0e0cac6f451218ff6945a024f65a1526802c34e56e"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:0e991632777e217953ac960726158987da684086dd813ac85038c595e7382c91"},
-    {file = "psycopg_binary-3.1.19-cp312-cp312-win_amd64.whl", hash = "sha256:1d87484dd42c8783c44a30400949efb3d81ef2487eaa7d64d1c54df90cf8b97a"},
-    {file = "psycopg_binary-3.1.19-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:d1d1723d7449c12bb61aca7eb6e0c6ab2863cd8dc0019273cc4d4a1982f84bdb"},
-    {file = "psycopg_binary-3.1.19-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e538a8671005641fa195eab962f85cf0504defbd3b548c4c8fc27102a59f687b"},
-    {file = "psycopg_binary-3.1.19-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c50592bc8517092f40979e4a5d934f96a1737a77724bb1d121eb78b614b30fc8"},
-    {file = "psycopg_binary-3.1.19-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:95f16ae82bc242b76cd3c3e5156441e2bd85ff9ec3a9869d750aad443e46073c"},
-    {file = "psycopg_binary-3.1.19-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aebd1e98e865e9a28ce0cb2c25b7dfd752f0d1f0a423165b55cd32a431dcc0f4"},
-    {file = "psycopg_binary-3.1.19-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:49cd7af7d49e438a39593d1dd8cab106a1912536c2b78a4d814ebdff2786094e"},
-    {file = "psycopg_binary-3.1.19-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:affebd61aa3b7a8880fd4ac3ee94722940125ff83ff485e1a7c76be9adaabb38"},
-    {file = "psycopg_binary-3.1.19-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:d1bac282f140fa092f2bbb6c36ed82270b4a21a6fc55d4b16748ed9f55e50fdb"},
-    {file = "psycopg_binary-3.1.19-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:1285aa54449e362b1d30d92b2dc042ad3ee80f479cc4e323448d0a0a8a1641fa"},
-    {file = "psycopg_binary-3.1.19-cp37-cp37m-win_amd64.whl", hash = "sha256:6cff31af8155dc9ee364098a328bab688c887c732c66b8d027e5b03818ca0287"},
-    {file = "psycopg_binary-3.1.19-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d9b689c4a17dd3130791dcbb8c30dbf05602f7c2d56c792e193fb49adc7bf5f8"},
-    {file = "psycopg_binary-3.1.19-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:017518bd2de4851adc826a224fb105411e148ad845e11355edd6786ba3dfedf5"},
-    {file = "psycopg_binary-3.1.19-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c35fd811f339a3cbe7f9b54b2d9a5e592e57426c6cc1051632a62c59c4810208"},
-    {file = "psycopg_binary-3.1.19-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:38ed45ec9673709bfa5bc17f140e71dd4cca56d4e58ef7fd50d5a5043a4f55c6"},
-    {file = "psycopg_binary-3.1.19-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:433f1c256108f9e26f480a8cd6ddb0fb37dbc87d7f5a97e4540a9da9b881f23f"},
-    {file = "psycopg_binary-3.1.19-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:ed61e43bf5dc8d0936daf03a19fef3168d64191dbe66483f7ad08c4cea0bc36b"},
-    {file = "psycopg_binary-3.1.19-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:4ae8109ff9fdf1fa0cb87ab6645298693fdd2666a7f5f85660df88f6965e0bb7"},
-    {file = "psycopg_binary-3.1.19-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:a53809ee02e3952fae7977c19b30fd828bd117b8f5edf17a3a94212feb57faaf"},
-    {file = "psycopg_binary-3.1.19-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:9d39d5ffc151fb33bcd55b99b0e8957299c0b1b3e5a1a5f4399c1287ef0051a9"},
-    {file = "psycopg_binary-3.1.19-cp38-cp38-win_amd64.whl", hash = "sha256:e14bc8250000921fcccd53722f86b3b3d1b57db901e206e49e2ab2afc5919c2d"},
-    {file = "psycopg_binary-3.1.19-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:cd88c5cea4efe614d5004fb5f5dcdea3d7d59422be796689e779e03363102d24"},
-    {file = "psycopg_binary-3.1.19-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:621a814e60825162d38760c66351b4df679fd422c848b7c2f86ad399bff27145"},
-    {file = "psycopg_binary-3.1.19-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:46e50c05952b59a214e27d3606f6d510aaa429daed898e16b8a37bfbacc81acc"},
-    {file = "psycopg_binary-3.1.19-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:03354a9db667c27946e70162cb0042c3929154167f3678a30d23cebfe0ad55b5"},
-    {file = "psycopg_binary-3.1.19-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:703c2f3b79037581afec7baa2bdbcb0a1787f1758744a7662099b0eca2d721cb"},
-    {file = "psycopg_binary-3.1.19-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:6469ebd9e93327e9f5f36dcf8692fb1e7aeaf70087c1c15d4f2c020e0be3a891"},
-    {file = "psycopg_binary-3.1.19-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:85bca9765c04b6be90cb46e7566ffe0faa2d7480ff5c8d5e055ac427f039fd24"},
-    {file = "psycopg_binary-3.1.19-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:a836610d5c75e9cff98b9fdb3559c007c785c09eaa84a60d5d10ef6f85f671e8"},
-    {file = "psycopg_binary-3.1.19-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ef8de7a1d9fb3518cc6b58e3c80b75a824209ad52b90c542686c912db8553dad"},
-    {file = "psycopg_binary-3.1.19-cp39-cp39-win_amd64.whl", hash = "sha256:76fcd33342f38e35cd6b5408f1bc117d55ab8b16e5019d99b6d3ce0356c51717"},
-]
-
 [[package]]
 name = "pydantic"
 version = "2.7.2"
@@ -3018,82 +2711,6 @@ docs = ["myst_parser", "sphinx", "sphinx_rtd_theme"]
 full = ["Pillow (>=8.0.0)", "PyCryptodome", "cryptography"]
 image = ["Pillow (>=8.0.0)"]
 
-[[package]]
-name = "pytest"
-version = "8.2.1"
-description = "pytest: simple powerful testing with Python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pytest-8.2.1-py3-none-any.whl", hash = "sha256:faccc5d332b8c3719f40283d0d44aa5cf101cec36f88cde9ed8f2bc0538612b1"},
-    {file = "pytest-8.2.1.tar.gz", hash = "sha256:5046e5b46d8e4cac199c373041f26be56fdb81eb4e67dc11d4e10811fc3408fd"},
-]
-
-[package.dependencies]
-colorama = {version = "*", markers = "sys_platform == \"win32\""}
-iniconfig = "*"
-packaging = "*"
-pluggy = ">=1.5,<2.0"
-
-[package.extras]
-dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
-
-[[package]]
-name = "pytest-asyncio"
-version = "0.23.7"
-description = "Pytest support for asyncio"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pytest_asyncio-0.23.7-py3-none-any.whl", hash = "sha256:009b48127fbe44518a547bddd25611551b0e43ccdbf1e67d12479f569832c20b"},
-    {file = "pytest_asyncio-0.23.7.tar.gz", hash = "sha256:5f5c72948f4c49e7db4f29f2521d4031f1c27f86e57b046126654083d4770268"},
-]
-
-[package.dependencies]
-pytest = ">=7.0.0,<9"
-
-[package.extras]
-docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1.0)"]
-testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]
-
-[[package]]
-name = "pytest-postgresql"
-version = "6.0.0"
-description = "Postgresql fixtures and fixture factories for Pytest."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pytest-postgresql-6.0.0.tar.gz", hash = "sha256:6a4d8e600a2eef273f3c0e846cd0b2ea577282e252de29b4ca854bfb929bb682"},
-    {file = "pytest_postgresql-6.0.0-py3-none-any.whl", hash = "sha256:f14272bffad16a74d9a63f4cc828f243a12ae92995e236b68fd53154760e6a5a"},
-]
-
-[package.dependencies]
-mirakuru = "*"
-port-for = ">=0.6.0"
-psycopg = ">=3.0.0"
-pytest = ">=6.2"
-setuptools = "*"
-
-[[package]]
-name = "pytest-xdist"
-version = "3.6.1"
-description = "pytest xdist plugin for distributed testing, most importantly across multiple CPUs"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pytest_xdist-3.6.1-py3-none-any.whl", hash = "sha256:9ed4adfb68a016610848639bb7e02c9352d5d9f03d04809919e2dafc3be4cca7"},
-    {file = "pytest_xdist-3.6.1.tar.gz", hash = "sha256:ead156a4db231eec769737f57668ef58a2084a34b2e55c4a8fa20d861107300d"},
-]
-
-[package.dependencies]
-execnet = ">=2.1"
-pytest = ">=7.0.0"
-
-[package.extras]
-psutil = ["psutil (>=3.0)"]
-setproctitle = ["setproctitle"]
-testing = ["filelock"]
-
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
@@ -3122,20 +2739,6 @@ files = [
 [package.extras]
 cli = ["click (>=5.0)"]
 
-[[package]]
-name = "python-multipart"
-version = "0.0.9"
-description = "A streaming multipart parser for Python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "python_multipart-0.0.9-py3-none-any.whl", hash = "sha256:97ca7b8ea7b05f977dc3849c3ba99d51689822fab725c3703af7c866a0c2b215"},
-    {file = "python_multipart-0.0.9.tar.gz", hash = "sha256:03f54688c663f1b7977105f021043b0793151e4cb1c1a9d4a11fc13d622c4026"},
-]
-
-[package.extras]
-dev = ["atomicwrites (==1.4.1)", "attrs (==23.2.0)", "coverage (==7.4.1)", "hatch", "invoke (==2.2.0)", "more-itertools (==10.2.0)", "pbr (==6.0.0)", "pluggy (==1.4.0)", "py (==1.11.0)", "pytest (==8.0.0)", "pytest-cov (==4.1.0)", "pytest-timeout (==2.2.0)", "pyyaml (==6.0.1)", "ruff (==0.2.1)"]
-
 [[package]]
 name = "pytz"
 version = "2024.1"
@@ -4390,4 +3993,4 @@ testing = ["big-O", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.11,<3.12"
-content-hash = "99d9141afef8d1d15a2e26cd82d141146ba630edd99b3adc82803f50c2682091"
+content-hash = "764a6a2edfd938e4128d185bb383ddc23dadaa25b9f5cf7215998a90b3cc760e"

pyproject.toml

@@ -3,7 +3,7 @@
 name = "app"
 version = "0.1.0"
 description = ""
-authors = [ "Praneeth Yerrapragada, Patrick Alexis" ]
+authors = [ "Marcus Schiesser <mail@marcusschiesser.de>" ]
 readme = "README.md"
 package-mode = false
 
@@ -28,33 +28,14 @@ pydantic = "^2.7.2"
 dateparser = "^1.2.0"
 pandas = "^2.2.2"
 path = "^16.14.0"
-pytest-xdist = "^3.6.1"
-pytest-asyncio = "^0.23.7"
-httpx = "^0.27.0"
-alembic = "^1.13.1"
-asyncpg = "^0.29.0"
-asyncio = "^3.4.3"
-pytest-postgresql = "^6.0.0"
-psycopg-binary = "^3.1.19"
-python-multipart = "^0.0.9"
 
 [tool.poetry.dependencies.uvicorn]
 extras = [ "standard" ]
 version = "^0.23.2"
 
-[tool.poetry.dependencies.sqlalchemy]
-extras = [ "asyncio" ]
-version = "^2.0.30"
-
 [tool.poetry.dependencies.llama-index-agent-openai]
 version = "0.2.2"
 
-[tool.black]
-line-length = 119
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-
 [build-system]
 requires = [ "poetry-core" ]
 build-backend = "poetry.core.masonry.api"

tests/conftest.py

@@ -1,83 +0,0 @@
-# Credits: https://github.com/ThomasAitken/demo-fastapi-async-sqlalchemy/blob/main/backend/app/conftest.py
-
-import asyncio
-from contextlib import ExitStack
-
-import pytest
-from alembic.config import Config
-from alembic.migration import MigrationContext
-from alembic.operations import Operations
-from alembic.script import ScriptDirectory
-from config.index import config as settings
-from app.engine.postgresdb import Base, get_db_session, postgresdb as sessionmanager
-from main import init_app
-from asyncpg import Connection
-from fastapi.testclient import TestClient
-from pytest_postgresql import factories
-from pytest_postgresql.factories.noprocess import postgresql_noproc
-from pytest_postgresql.janitor import DatabaseJanitor
-from sqlalchemy.testing.entities import ComparableEntity
-
-from config.index import config as env
-
-test_db = factories.postgresql_proc(dbname="test_db", port=5433)
-
-
-@pytest.fixture(autouse=True)
-def app():
-    with ExitStack():
-        # Don't initialize database connection.
-        # This is because we want to initialize the database connection manually, so that we can create the test database.
-        yield init_app(init_db=False)
-
-
-@pytest.fixture
-def client(app):
-    with TestClient(app) as c:
-        yield c
-
-
-@pytest.fixture(scope="session")
-def event_loop(request):
-    loop = asyncio.get_event_loop_policy().new_event_loop()
-    yield loop
-    loop.close()
-
-
-@pytest.fixture(scope="function", autouse=True)
-async def connection_test(test_db, event_loop):
-    pg_host = test_db.host
-    pg_port = test_db.port
-    pg_user = test_db.user
-    pg_db = test_db.dbname
-    pg_password = test_db.password
-
-    with DatabaseJanitor(user=pg_user, host=pg_host, port=pg_port, dbname=pg_db, version=test_db.version, password=pg_password):
-        connection_str = f"postgresql+psycopg://{pg_user}:@{pg_host}:{pg_port}/{pg_db}"
-        sessionmanager.init(connection_str,
-                            # {"echo": True, "future": True}
-                            )
-        yield
-        await sessionmanager.close()
-
-
-@pytest.fixture(scope="function", autouse=True)
-async def create_tables(connection_test):
-    async with sessionmanager.connect() as connection:
-        await sessionmanager.drop_all(connection)
-        await sessionmanager.create_all(connection)
-
-
-@pytest.fixture(scope="function", autouse=True)
-async def session_override(app, connection_test):
-    async def get_db_session_override():
-        async with sessionmanager.session() as session:
-            yield session
-
-    app.dependency_overrides[get_db_session] = get_db_session_override
-
-
-@pytest.fixture(scope="function", autouse=True)
-async def get_db_session_fixture():
-    async with sessionmanager.session() as session:
-        yield session

tests/pytest.ini

@@ -1,4 +0,0 @@
-[pytest]
-asyncio_mode = auto
-timeout = 60
-addopts = -vv --disable-warnings --durations=10 --durations-min=1.0

tests/test_income_statement.py

@@ -1,51 +0,0 @@
-from fastapi.testclient import TestClient
-import pytest
-
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.model.transaction import Transaction
-from app.model.user import User
-from tests.utils import get_fake_transactions
-
-@pytest.mark.asyncio
-async def test_income_statement(client: TestClient, get_db_session_fixture: AsyncSession) -> None:
-    session_override = get_db_session_fixture
-
-    # 1. Create a user
-    user = await User.create(session_override, name="user", email="email", hashed_password="password")
-
-    # 2. Create a bunch of transactions
-    fake_transactions = get_fake_transactions(user.id)
-    await Transaction.bulk_create(session_override, fake_transactions)
-
-    # 3. Create an income statement
-    min_date = min(t.transaction_date for t in fake_transactions)
-    max_date = max(t.transaction_date for t in fake_transactions)
-
-    print(f"min_date: {min_date}, max_date: {max_date}")
-    response = client.post(
-        "/api/v1/income_statement",
-        json={
-            "user_id": 1,
-            "date_from": str(min_date),
-            "date_to": str(max_date),
-        },
-    )
-
-    assert response.status_code == 200
-
-    # 4. Verify that the income statement matches the transactions
-    response = client.get(f"/api/v1/income_statement/user/1")
-    print(response.json())
-    assert response.status_code == 200
-    assert response.json()[0].get("income")
-    assert response.json()[0].get("expenses")
-
-    report_id = response.json()[0].get("id")
-
-    # # 5. Verify that the income statement can be retrieved
-    if report_id is not None:
-        response = client.get(f"/api/v1/income_statement/report/{report_id}")
-        assert response.status_code == 200
-        assert response.json().get("income")
-        assert response.json().get("expenses")
-        assert response.json().get("id") == report_id

tests/test_transactions.py

@@ -1,25 +0,0 @@
-from fastapi.testclient import TestClient
-import pytest
-
-from app.model.transaction import Transaction
-from app.model.user import User
-from sqlalchemy.ext.asyncio import AsyncSession
-from tests.utils import get_fake_transactions
-
-
-@pytest.mark.asyncio
-async def test_transactions(client: TestClient, get_db_session_fixture: AsyncSession) -> None:
-
-    session_override = get_db_session_fixture
-
-    # 1. Create a user
-    user = await User.create(session_override, name="user", email="email", hashed_password="password")
-
-    # 2. Create a bunch of transactions
-    fake_transactions = get_fake_transactions(user.id)
-    await Transaction.bulk_create(session_override, fake_transactions)
-
-    # 3. Verify that the transactions are returned
-    response = client.get("/api/v1/transactions/1")
-    assert response.status_code == 200
-    assert len(response.json()) == 10

tests/test_users.py

@@ -1,40 +0,0 @@
-from random import randint
-
-from fastapi.testclient import TestClient
-
-
-def test_users(client: TestClient) -> None:
-    rand_int = randint(0, 1000)
-    email = f"test{rand_int}@example.com"
-    response = client.get(f"/api/v1/users/{email}")
-    assert response.status_code == 404
-
-    response = client.post(
-        "/api/v1/users",
-        json={"email": email, "name": "Full Name Test", "hashed_password": "test"},
-    )
-    assert response.status_code == 200
-    assert response.json().get("email") == email
-    assert response.json().get("name") == "Full Name Test"
-    assert response.json().get("is_deleted") == False
-
-    response = client.get(f"/api/v1/users/{email}")
-    assert response.status_code == 200
-    assert response.json().get("email") == email
-    assert response.json().get("name") == "Full Name Test"
-    assert response.json().get("is_deleted") == False
-
-    response = client.put(
-        f"/api/v1/users/{email}",
-        json={"email": email, "name": "Full Name Test 2", "hashed_password": "test"},
-    )
-    assert response.status_code == 200
-    assert response.json().get("email") == email
-    assert response.json().get("name") == "Full Name Test 2"
-    assert response.json().get("is_deleted") == False
-
-    response = client.delete(f"/api/v1/users/{email}")
-    assert response.status_code == 200
-    assert response.json().get("email") == email
-    assert response.json().get("name") == "Full Name Test 2"
-    assert response.json().get("is_deleted") == True

tests/utils.py

@@ -1,88 +0,0 @@
-from datetime import datetime
-from typing import List
-from app.schema.index import TransactionCreate, TransactionType
-
-
-def get_fake_transactions(user_id: int) -> List[TransactionCreate]:
-    return [
-        TransactionCreate(
-            user_id=user_id,
-            transaction_date=datetime(2022, 1, 1),
-            category="category1",
-            name_description="name_description",
-            amount=1.0,
-            type=TransactionType.EXPENSE,
-        ),
-        TransactionCreate(
-            user_id=user_id,
-            transaction_date=datetime(2022, 1, 2),
-            category="category2",
-            name_description="name_description",
-            amount=2.0,
-            type=TransactionType.EXPENSE,
-        ),
-        TransactionCreate(
-            user_id=user_id,
-            transaction_date=datetime(2022, 1, 3),
-            category="category3",
-            name_description="name_description",
-            amount=3.0,
-            type=TransactionType.INCOME,
-        ),
-        TransactionCreate(
-            user_id=user_id,
-            transaction_date=datetime(2022, 1, 4),
-            category="category1",
-            name_description="name_description",
-            amount=4.0,
-            type=TransactionType.INCOME,
-        ),
-        TransactionCreate(
-            user_id=user_id,
-            transaction_date=datetime(2022, 1, 5),
-            category="category2",
-            name_description="name_description",
-            amount=5.0,
-            type=TransactionType.EXPENSE,
-        ),
-        TransactionCreate(
-            user_id=user_id,
-            transaction_date=datetime(2022, 1, 6),
-            category="category3",
-            name_description="name_description",
-            amount=6.0,
-            type=TransactionType.EXPENSE,
-        ),
-        TransactionCreate(
-            user_id=user_id,
-            transaction_date=datetime(2022, 1, 7),
-            category="category1",
-            name_description="name_description",
-            amount=7.0,
-            type=TransactionType.INCOME,
-        ),
-        TransactionCreate(
-            user_id=user_id,
-            transaction_date=datetime(2022, 1, 8),
-            category="category2",
-            name_description="name_description",
-            amount=8.0,
-            type=TransactionType.INCOME,
-        ),
-        TransactionCreate(
-            user_id=user_id,
-            transaction_date=datetime(2022, 1, 9),
-            category="category3",
-            name_description="name_description",
-            amount=9.0,
-            type=TransactionType.EXPENSE,
-        ),
-        TransactionCreate(
-            user_id=user_id,
-            transaction_date=datetime(2022, 1, 10),
-            category="category1",
-            name_description="name_description",
-            amount=10.0,
-            type=TransactionType.EXPENSE,
-        ),
-    ]