Merge branch 'develop'

Author: tomy0000000

.pre-commit-config.yaml

@@ -13,7 +13,7 @@ repos:
       - id: mixed-line-ending
       - id: trailing-whitespace
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.9.6"
+    rev: "v0.11.9"
     hooks:
       - id: ruff
         args: [--fix]

README.md

@@ -2,6 +2,9 @@
 
 <p align="left">
     <img src="https://img.shields.io/badge/python-3.12-blue.svg?logo=python" alt="Python 3.12" />
+    <a href="https://codecov.io/gh/tomy0000000/k-backend">
+        <img src="https://codecov.io/gh/tomy0000000/k-backend/graph/badge.svg?token=ng4W7JDOn8"/>
+    </a>
     <a href="https://hub.docker.com/repository/docker/tomy0000000/k-backend">
         <img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/tomy0000000/k-backend">
     </a>

alembic.ini

@@ -59,12 +59,17 @@ sqlalchemy.url = driver://user:pass@localhost/dbname
 # post_write_hooks defines scripts or Python functions that are run
 # on newly generated revision scripts.  See the documentation for further
 # detail and examples
+hooks = ruff, ruff_format
 
-# 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"
+ruff.type = exec
+ruff.executable = ruff
+ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# format using "ruff" - use the exec runner, execute a binary
+ruff_format.type = exec
+ruff_format.executable = ruff
+ruff_format.options = format REVISION_SCRIPT_FILENAME --check
 
 # Logging configuration
 [loggers]

alembic/versions/c0db25a49f08_change_transaction_primary_key.py

@@ -0,0 +1,52 @@
+"""Change transaction primary key
+
+Revision ID: c0db25a49f08
+Revises: b591254840d9
+Create Date: 2025-03-24 06:46:54.994209
+
+"""
+import sqlalchemy as sa
+
+from alembic import op
+from sqlalchemy.sql import text
+
+# revision identifiers, used by Alembic.
+revision = 'c0db25a49f08'
+down_revision = 'b591254840d9'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Add the new column as nullable
+    op.add_column('transaction', sa.Column('id', sa.Integer(), nullable=True))
+
+    # Create the sequence
+    op.execute(sa.text("CREATE SEQUENCE transaction_id_seq"))
+
+    # Generate unique IDs for existing transactions
+    connection = op.get_bind()
+    connection.execute(text("UPDATE transaction SET id = nextval('transaction_id_seq')"))
+
+    # Make the new column non-nullable
+    op.alter_column('transaction', 'id', nullable=False)
+
+    # Drop the old primary key
+    op.drop_constraint('transaction_pkey', 'transaction')
+
+    # Make the new column the primary key
+    op.create_primary_key('transaction_pkey', 'transaction', ['id'])
+
+def downgrade():
+    # Drop the primary key created on the new "id" column
+    op.drop_constraint('transaction_pkey', 'transaction', type_='primary')
+
+    # Recreate the old primary key constraint.
+    # Replace 'old_primary_key_column' with the actual original primary key column name.
+    op.create_primary_key('transaction_pkey', 'transaction', ['account_id', 'payment_id'])
+
+    # Drop the sequence that was created for the new column
+    op.execute(sa.text("DROP SEQUENCE transaction_id_seq"))
+
+    # Remove the new "id" column from the table
+    op.drop_column('transaction', 'id')

docker-compose.override.yml

@@ -1,7 +1,7 @@
 services:
   api:
     build: .
-    command: "--reload"
+    command: "--reload  --log-level trace"
     ports:
       - "8000:8000"
     volumes:

k_backend/crud/account.py

@@ -0,0 +1,81 @@
+from collections.abc import Sequence
+from decimal import Decimal
+
+from sqlmodel import Integer, Session, cast, select
+
+from ..schemas.account import Account, AccountBase, AccountCreate, AccountUpdate
+
+
+def create_account(session: Session, account: AccountCreate) -> AccountBase:
+    session.add(account)
+    session.commit()
+    session.refresh(account)
+    return account
+
+
+def read_account(session: Session, account_id: int) -> Account | None:
+    return session.get(Account, account_id)
+
+
+def read_accounts(
+    session: Session, account_ids: list[int] | None = None, for_update: bool = False
+) -> Sequence[Account]:
+    statement = select(Account)
+    if account_ids:
+        statement = statement.where(cast(Account.id, Integer).in_(account_ids))
+    if for_update:
+        statement = statement.with_for_update()
+    return session.exec(statement).all()
+
+
+def update_accounts(
+    session: Session, account_ids: list[int], accounts: list[AccountUpdate]
+) -> Sequence[Account]:
+    # Verify account_ids and accounts have the same length
+    if len(account_ids) != len(accounts):
+        raise ValueError("account_ids and accounts must have the same length")
+
+    # Verify all accounts are valid
+    db_accounts = _verify_account_ids(session, account_ids)
+
+    # Update accounts
+    for db_account, account in zip(db_accounts, accounts, strict=True):
+        account_data = account.model_dump(exclude_unset=True)
+        db_account.sqlmodel_update(account_data)
+
+    session.add_all(db_accounts)
+    session.commit()
+
+    return read_accounts(session, account_ids)
+
+
+def update_account_balances(
+    session: Session,
+    account_amounts: dict[int, Decimal],
+    commit: bool = True,
+) -> Sequence[Account]:
+    account_ids = list(account_amounts.keys())
+    db_accounts = _verify_account_ids(session, account_ids)
+    id_to_index = {account.id: index for index, account in enumerate(db_accounts)}
+    for account_id, amount in account_amounts.items():
+        db_account = db_accounts[id_to_index[account_id]]
+        db_account.balance += amount
+
+    session.add_all(db_accounts)
+    if commit:
+        session.commit()
+        for account in db_accounts:
+            session.refresh(account)
+    else:
+        session.flush()
+
+    return read_accounts(session, account_ids)
+
+
+def _verify_account_ids(session: Session, account_ids: list[int]) -> Sequence[Account]:
+    db_accounts = read_accounts(session, account_ids, for_update=True)
+    missing_ids = set(account_ids) - {account.id for account in db_accounts}
+    if missing_ids:
+        raise ValueError(f"Account id(s) not found: {missing_ids}")
+
+    return db_accounts

k_backend/crud/currency.py

@@ -0,0 +1,17 @@
+from collections.abc import Sequence
+
+from sqlmodel import Session, select
+
+from ..schemas.currency import Currency
+
+
+def create_currency(session: Session, currency: Currency) -> Currency:
+    db_currency = Currency.model_validate(currency)
+    session.add(db_currency)
+    session.commit()
+    session.refresh(db_currency)
+    return db_currency
+
+
+def read_currencies(session: Session) -> Sequence[Currency]:
+    return session.exec(select(Currency)).all()

k_backend/crud/payment.py

@@ -1,13 +1,34 @@
 from collections.abc import Sequence
 from datetime import date
 
-from sqlalchemy import func
-from sqlmodel import Session, select
+from sqlmodel import Session, func, select
 
-from ..schemas.payment import Payment, PaymentEntry
+from ..schemas.payment import (
+    Payment,
+    PaymentBase,
+    PaymentCreate,
+    PaymentEntry,
+)
 
 
-def get_payments(
+def create_payment(
+    session: Session, payment: PaymentCreate, commit: bool = True
+) -> PaymentBase:
+    db_payment = Payment.model_validate(payment)
+    session.add(db_payment)
+    if commit:
+        session.commit()
+        session.refresh(db_payment)
+    else:
+        session.flush()
+    return db_payment
+
+
+def read_payment(session: Session, payment_id: int) -> Payment | None:
+    return session.get(Payment, payment_id)
+
+
+def read_payments(
     session: Session, payment_date: date | None = None, category_id: int | None = None
 ) -> Sequence[Payment]:
     scalar = select(Payment).distinct()

k_backend/crud/payment_entry.py

@@ -0,0 +1,21 @@
+from collections.abc import Sequence
+
+from sqlmodel import Session
+
+from ..schemas.payment import PaymentEntry, PaymentEntryBase, PaymentEntryCreate
+
+
+def create_payment_entries(
+    session: Session,
+    entries: list[PaymentEntryCreate],
+    commit: bool = True,
+) -> Sequence[PaymentEntryBase]:
+    db_entries = [PaymentEntry.model_validate(entry) for entry in entries]
+    session.add_all(db_entries)
+    if commit:
+        session.commit()
+        for db_entry in db_entries:
+            session.refresh(db_entry)
+    else:
+        session.flush()
+    return db_entries

k_backend/crud/transaction.py

@@ -2,7 +2,23 @@
 
 from sqlmodel import Session, select
 
-from ..schemas.payment import Transaction
+from ..schemas.transaction import Transaction, TransactionBase, TransactionCreate
+
+
+def create_transactions(
+    session: Session,
+    txns: Sequence[TransactionCreate],
+    commit: bool = True,
+) -> Sequence[TransactionBase]:
+    db_txns = [Transaction.model_validate(txn) for txn in txns]
+    session.add_all(db_txns)
+    if commit:
+        session.commit()
+        for db_txn in db_txns:
+            session.refresh(db_txn)
+    else:
+        session.flush()
+    return db_txns
 
 
 def get_transactions(