fixup! Add benchmarks

.gitea/workflows/benchmark.yaml

@@ -0,0 +1,58 @@
+name: Run benchmarks
+on:
+  workflow_dispatch:
+  # TODO: make this only workflow_dispatch when merged into main
+  push:
+
+jobs:
+  run-tests:
+    runs-on: debian-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Install dependencies
+        run: uv sync --locked --group test
+
+      - name: Run benchmarks
+        continue-on-error: true
+        run: |
+          set -euo pipefail
+          set -x
+
+          PYTEST_ARGS=(
+            -vv
+
+            --benchmark-only
+            -k test_benchmark
+          )
+
+          uv run -- pytest "${PYTEST_ARGS[@]}"
+
+      - name: Upload benchmark JSON report
+        uses: https://git.pvv.ntnu.no/Projects/rsync-action@v1
+        with:
+          source: ./benchmark/**/*.json
+          target: ${{ gitea.ref_name }}/benchmark/${{ github.run_id }}/benchmark.json
+          username: gitea-web
+          ssh-key: ${{ secrets.WEB_SYNC_SSH_KEY }}
+          host: pages.pvv.ntnu.no
+          known-hosts: "pages.pvv.ntnu.no ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH2QjfFB+city1SYqltkVqWACfo1j37k+oQQfj13mtgg"
+
+      - name: Upload histograms
+        uses: https://git.pvv.ntnu.no/Projects/rsync-action@v1
+        with:
+          source: ./benchmark/*.svg
+          target: ${{ gitea.ref_name }}/benchmark/${{ github.run_id }}/
+          username: gitea-web
+          ssh-key: ${{ secrets.WEB_SYNC_SSH_KEY }}
+          host: pages.pvv.ntnu.no
+          known-hosts: "pages.pvv.ntnu.no ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH2QjfFB+city1SYqltkVqWACfo1j37k+oQQfj13mtgg"
+
+      - name: Check failure
+        if: failure()
+        run: |
+          echo "Tests failed"
+          exit 1

.gitea/workflows/test.yaml

@@ -0,0 +1,72 @@
+name: Run tests
+on:
+  pull_request:
+  push:
+  workflow_dispatch:
+    inputs:
+      debug_sql:
+        description: "Print SQL statements executed by SQLAlchemy during tests"
+        type: boolean
+        default: True
+
+env:
+  DEBUG_SQL: ${{ inputs.debug_sql || true }}
+
+jobs:
+  run-tests:
+    runs-on: debian-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Install dependencies
+        run: uv sync --locked --group test
+
+      - name: Run tests
+        continue-on-error: true
+        run: |
+          set -euo pipefail
+          set -x
+
+          PYTEST_ARGS=(
+            -vv
+          )
+
+          if [ "$DEBUG_SQL" == "true" ]; then
+            PYTEST_ARGS+=(
+              --debug-sql
+            )
+          fi
+
+          uv run -- pytest "${PYTEST_ARGS[@]}"
+
+      - name: Generate badge
+        run: uv run -- coverage-badge -o htmlcov/badge.svg
+
+      - name: Upload test report
+        uses: https://git.pvv.ntnu.no/Projects/rsync-action@v1
+        with:
+          source: ./test-report/
+          target: ${{ gitea.ref_name }}/test-report/
+          username: gitea-web
+          ssh-key: ${{ secrets.WEB_SYNC_SSH_KEY }}
+          host: pages.pvv.ntnu.no
+          known-hosts: "pages.pvv.ntnu.no ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH2QjfFB+city1SYqltkVqWACfo1j37k+oQQfj13mtgg"
+
+      - name: Upload coverage report
+        uses: https://git.pvv.ntnu.no/Projects/rsync-action@v1
+        with:
+          source: ./htmlcov/
+          target: ${{ gitea.ref_name }}/coverage/
+          username: gitea-web
+          ssh-key: ${{ secrets.WEB_SYNC_SSH_KEY }}
+          host: pages.pvv.ntnu.no
+          known-hosts: "pages.pvv.ntnu.no ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH2QjfFB+city1SYqltkVqWACfo1j37k+oQQfj13mtgg"
+
+      - name: Check failure
+        if: failure()
+        run: |
+          echo "Tests failed"
+          exit 1

.gitignore

@@ -7,3 +7,9 @@ dist
 test.db
 
 .ruff_cache
+
+.coverage
+.coverage.*
+htmlcov
+test-report
+/benchmark

README.md

@@ -1,3 +1,6 @@
+[![Coverage](https://pages.pvv.ntnu.no/Projects/dibbler/event-sourcing/coverage/badge.svg)](https://pages.pvv.ntnu.no/Projects/dibbler/event-sourcing/coverage)
+[![Test report](https://img.shields.io/badge/status-grab_the_latest_test_report-blue)](https://pages.pvv.ntnu.no/Projects/dibbler/event-sourcing/test-report)
+
 # Dibbler
 
 EDB-system for PVVVV
@@ -24,6 +27,38 @@ python -m dibbler -c example-config.ini create-db
 python -m dibbler -c example-config.ini loop
 ```
 
+## Prosjektstruktur
+
+Her er en oversikt over prosjektstrukturen og hva de forskjellige mappene og filene gjør.
+
+### `dibbler/models`
+
+I denne mappen ligger databasemodellene. Med få unntak så er hver fil i denne mappen en modell.
+
+Vi bruker for tiden moderne deklarativ SQLAlchemy syntaks for å definere modellene (see [SQLAlchemy - Declarative Mapping Styles](https://docs.sqlalchemy.org/en/20/orm/declarative_styles.html)).
+
+Pass på å ikke putte for mye logikk i modellene, de skal helst bare definere dataene. Konstruktører, hjelpefunksjoner og statisk validering er anbefalt, men unngå dynamisk validering mot databasen - det hører hjemme i `dibbler/queries`.
+
+### `dibbler/queries`
+
+I denne mappen ligger databasespørringer. Disse databasespørringene har etter hvert blitt ganske komplekse da vi ikke lagrer tilstand, men heller deriverer den ut ifra en gående logg av transaksjoner. Her gjøres det også en del validering, både statisk validering av argumenter, men også dynamisk validering mot databasen.
+
+### `dibbler/menus`
+
+Her ligger menydefinisjonene for terminalgrensesnittet. Menyene håndterer brukerinteraksjon og navigasjon.
+
+### `dibbler/lib`
+
+Her finner du hjelpefunksjoner og verktøy som brukes på tvers av prosjektet. Ting som ikke passet inn andre steder.
+
+### `dibbler/subcommands`
+
+Her ligger inngangspunktet for kommandolinjegrensesnittet. Dette er ikke noe vanlige brukere vanligvis vil se da vi har låst dibbler-terminalen til å kjøre terminalgrensesnittet i en evig loop. Det er nyttig for å legge ved ekstra konfigurasjon eller å legge ved vedlikeholdsoppgaver og testverktøy.
+
+### `tests`
+
+Her ligger enhetstester for prosjektet. Testene bruker `pytest` som testløper. Vi tester i all hovedsak databasespørringer og modelllogikk her, da "korrekthet" av terminalgrensesnittet er vanskelig å definere og teste automatisk.
+
 ## Nix
 
 ### Bygge nytt image
@@ -41,6 +76,7 @@ Du kan også endre hvilken config-fil som blir brukt direkte i pakken eller i mo
 Se eksempelet for hvordan skrot er satt opp i `flake.nix` og `nix/skrott.nix`
 
 ### Bygge image for skrot
+
 Skrot har et image definert i flake.nix:
 
 1. endre `example-config.ini`

dibbler/db.py

@@ -5,12 +5,15 @@ from sqlalchemy.orm import sessionmaker
 
 from dibbler.conf import config
 
-if (url := config.get("database", "url")) is not None:
-  database_url = url
+database_url: str | None = None
 
+if (url := config.get("database", "url")) is not None:
+    database_url = url
 elif (url_file := config.get("database", "url_file")) is not None:
-  with Path(url_file).open() as file:
-    database_url = file.read().strip()
+    with Path(url_file).open() as file:
+        database_url = file.read().strip()
+
+assert database_url is not None, "Database URL must be specified in config"
 
 engine = create_engine(database_url)
 Session = sessionmaker(bind=engine)

dibbler/lib/helpers.py

@@ -1,79 +1,7 @@
-import pwd
-import subprocess
 import os
+import pwd
 import signal
-
-from sqlalchemy import or_, and_
-
-from ..models import User, Product
-
-
-def search_user(string, session, ignorethisflag=None):
-    string = string.lower()
-    exact_match = (
-        session.query(User)
-        .filter(or_(User.name == string, User.card == string, User.rfid == string))
-        .first()
-    )
-    if exact_match:
-        return exact_match
-    user_list = (
-        session.query(User)
-        .filter(
-            or_(
-                User.name.ilike(f"%{string}%"),
-                User.card.ilike(f"%{string}%"),
-                User.rfid.ilike(f"%{string}%"),
-            )
-        )
-        .all()
-    )
-    return user_list
-
-
-def search_product(string, session, find_hidden_products=True):
-    if find_hidden_products:
-        exact_match = (
-            session.query(Product)
-            .filter(or_(Product.bar_code == string, Product.name == string))
-            .first()
-        )
-    else:
-        exact_match = (
-            session.query(Product)
-            .filter(
-                or_(
-                    Product.bar_code == string,
-                    and_(Product.name == string, Product.hidden is False),
-                )
-            )
-            .first()
-        )
-    if exact_match:
-        return exact_match
-    if find_hidden_products:
-        product_list = (
-            session.query(Product)
-            .filter(
-                or_(
-                    Product.bar_code.ilike(f"%{string}%"),
-                    Product.name.ilike(f"%{string}%"),
-                )
-            )
-            .all()
-        )
-    else:
-        product_list = (
-            session.query(Product)
-            .filter(
-                or_(
-                    Product.bar_code.ilike(f"%{string}%"),
-                    and_(Product.name.ilike(f"%{string}%"), Product.hidden is False),
-                )
-            )
-            .all()
-        )
-    return product_list
+import subprocess
 
 
 def system_user_exists(username):

dibbler/lib/render_transaction_log.py

@@ -0,0 +1,115 @@
+from dibbler.lib.render_tree import render_tree
+from dibbler.models import Transaction, TransactionType
+from dibbler.models.Transaction import EXPECTED_FIELDS
+
+
+def render_transaction_log(transaction_log: list[Transaction]) -> str:
+    """
+    Renders a transaction log as a pretty, human-readable string.
+    """
+
+    aggregated_log = _aggregate_joint_transactions(transaction_log)
+
+    lines = []
+    for transaction in aggregated_log:
+        if isinstance(transaction, list):
+            inner_lines = []
+            lines.append(_render_transaction(transaction[0]))
+            for sub_transaction in transaction[1:]:
+                line = _render_transaction(sub_transaction)
+                inner_lines.append(line)
+            lines.append(inner_lines)
+        else:
+            line = _render_transaction(transaction)
+            lines.append(line)
+
+    return render_tree(lines)
+
+
+def _aggregate_joint_transactions(
+    transactions: list[Transaction],
+) -> list[Transaction | list[Transaction]]:
+    aggregated: list[Transaction | list[Transaction]] = []
+
+    i = 0
+    while i < len(transactions):
+        current = transactions[i]
+
+        # The aggregation is running backwards, so it will hit JOINT transactions first
+        if current.type_ == TransactionType.JOINT:
+            joint_transactions = [current]
+            j = i
+            while j < len(transactions):
+                j += 1
+                next_transaction = transactions[j]
+                if next_transaction.type_ == TransactionType.JOINT_BUY_PRODUCT:
+                    joint_transactions.append(next_transaction)
+                else:
+                    break
+            aggregated.append(joint_transactions)
+            i = j  # Skip processed transactions
+        elif current.type_ == TransactionType.JOINT:
+            # Empty joint transaction?
+            i += 1
+            continue
+        else:
+            aggregated.append(current)
+            i += 1
+    return aggregated
+
+
+def _render_transaction(transaction: Transaction) -> str:
+    match transaction.type_:
+        case TransactionType.ADD_PRODUCT:
+            line = f"ADD_PRODUCT({transaction.id}, {transaction.user.name}"
+            for field in EXPECTED_FIELDS[TransactionType.ADD_PRODUCT]:
+                value = getattr(transaction, field)
+                line += f", {field}={value}"
+            line += ")"
+        case TransactionType.BUY_PRODUCT:
+            line = f"BUY_PRODUCT({transaction.id}, {transaction.user.name}"
+            for field in EXPECTED_FIELDS[TransactionType.BUY_PRODUCT]:
+                value = getattr(transaction, field)
+                line += f", {field}={value}"
+            line += ")"
+        case TransactionType.ADJUST_STOCK:
+            line = f"ADJUST_STOCK({transaction.id}, {transaction.user.name}"
+            for field in EXPECTED_FIELDS[TransactionType.ADJUST_STOCK]:
+                value = getattr(transaction, field)
+                line += f", {field}={value}"
+            line += ")"
+        case TransactionType.ADJUST_PENALTY:
+            line = f"ADJUST_PENALTY({transaction.id}, {transaction.user.name}"
+            for field in EXPECTED_FIELDS[TransactionType.ADJUST_PENALTY]:
+                value = getattr(transaction, field)
+                line += f", {field}={value}"
+            line += ")"
+        case TransactionType.ADJUST_INTEREST:
+            line = f"ADJUST_INTEREST({transaction.id}, {transaction.user.name}"
+            for field in EXPECTED_FIELDS[TransactionType.ADJUST_INTEREST]:
+                value = getattr(transaction, field)
+                line += f", {field}={value}"
+            line += ")"
+        case TransactionType.ADJUST_BALANCE:
+            line = f"ADJUST_BALANCE({transaction.id}, {transaction.user.name}"
+            for field in EXPECTED_FIELDS[TransactionType.ADJUST_BALANCE]:
+                value = getattr(transaction, field)
+                line += f", {field}={value}"
+            line += ")"
+        case TransactionType.JOINT:
+            line = f"JOINT({transaction.id}, {transaction.user.name}"
+            for field in EXPECTED_FIELDS[TransactionType.JOINT]:
+                value = getattr(transaction, field)
+                line += f", {field}={value}"
+            line += ")"
+        case TransactionType.JOINT_BUY_PRODUCT:
+            line = f"JOINT_BUY_PRODUCT({transaction.id}, {transaction.user.name}"
+            for field in EXPECTED_FIELDS[TransactionType.JOINT_BUY_PRODUCT]:
+                value = getattr(transaction, field)
+                line += f", {field}={value}"
+            line += ")"
+        case _:
+            line = (
+                f"UNKNOWN[{transaction.type_}](id={transaction.id}, user_id={transaction.user_id})"
+            )
+    return line

dibbler/lib/render_tree.py

@@ -0,0 +1,115 @@
+_TREE_CHARS = {
+    "normal": {
+        "vertical": "│  ",
+        "branch": "├─ ",
+        "last": "└─ ",
+        "empty": "   ",
+    },
+    "ascii": {
+        "vertical": "|   ",
+        "branch": "|-- ",
+        "last": "`-- ",
+        "empty": "    ",
+    },
+}
+
+assert set(_TREE_CHARS["normal"].keys()) == set(_TREE_CHARS["ascii"].keys())
+assert all(len(v) == 3 for v in _TREE_CHARS["normal"].values())
+assert all(len(v) == 4 for v in _TREE_CHARS["ascii"].values())
+
+
+def render_tree(
+    tree: list[str | list],
+    ascii_only: bool = False,
+) -> str:
+    """
+    Render a tree structure as a string.
+
+    Each item in the `tree` list can be either a string (a leaf node)
+    or another list (a subtree).
+
+    When `ascii_only` is `True`, only ASCII characters are used for drawing the tree.
+
+    Example:
+
+    ```python
+        tree = [
+            "root",
+            [
+                "child1",
+                [
+                    "grandchild1",
+                    "grandchild2",
+                ],
+                "child2",
+            ],
+            "root2",
+        ]
+        print(render_tree(tree, ascii_only=False))
+    ```
+
+    Output:
+
+    ```
+    ├─ root
+    │  ├─ child1
+    │  │  ├─ grandchild1
+    │  │  └─ grandchild2
+    │  └─ child2
+    └─ root2
+    ```
+
+    Example with ASCII only:
+
+    ```python
+        print(render_tree(tree, ascii_only=True))
+    ```
+
+    Output:
+
+    ```
+    |-- root
+    |   |-- child1
+    |   |   |-- grandchild1
+    |   |   `-- grandchild2
+    |   `-- child2
+    `-- root2
+    ```
+    """
+
+    result: list[str] = []
+    for index, item in enumerate(tree):
+        is_last = index == len(tree) - 1
+        item_lines = _render_tree_line(item, is_last, ascii_only)
+        result.extend(item_lines)
+    return "\n".join(result)
+
+
+def _render_tree_line(
+    item: str | list,
+    is_last: bool,
+    ascii_only: bool,
+    prefix: str = "",
+) -> list[str]:
+    chars = _TREE_CHARS["ascii"] if ascii_only else _TREE_CHARS["normal"]
+    lines: list[str] = []
+
+    if isinstance(item, str):
+        line_prefix = chars["last"] if is_last else chars["branch"]
+        item_lines = item.splitlines()
+        for line_index, line in enumerate(item_lines):
+            if line_index == 0:
+                lines.append(f"{prefix}{line_prefix}{line}")
+            else:
+                lines.append(f"{prefix}{chars['vertical']}{line}")
+
+    elif isinstance(item, list):
+        new_prefix = prefix + (chars["empty"] if is_last else chars["vertical"])
+        for sub_index, sub_item in enumerate(item):
+            sub_is_last = sub_index == len(item) - 1
+            sub_lines = _render_tree_line(sub_item, sub_is_last, ascii_only, new_prefix)
+            lines.extend(sub_lines)
+    else:
+        raise ValueError("Item must be either a string or a list.")
+
+    return lines

dibbler/main.py

@@ -1,4 +1,5 @@
 import argparse
+from pathlib import Path
 
 from dibbler.conf import config
 
@@ -8,8 +9,9 @@ parser.add_argument(
     "-c",
     "--config",
     help="Path to the config file",
-    type=str,
-    required=False,
+    type=Path,
+    metavar="FILE",
+    default="config.ini",
 )
 
 subparsers = parser.add_subparsers(
@@ -21,6 +23,7 @@ subparsers.add_parser("loop", help="Run the dibbler loop")
 subparsers.add_parser("create-db", help="Create the database")
 subparsers.add_parser("slabbedasker", help="Find out who is slabbedasker")
 subparsers.add_parser("seed-data", help="Fill with mock data")
+subparsers.add_parser("transaction-log", help="Print transaction log")
 
 
 def main():
@@ -47,6 +50,11 @@ def main():
 
         seed_test_data.main()
 
+    elif args.subcommand == "transaction-log":
+        import dibbler.subcommands.transaction_log as transaction_log
+
+        transaction_log.main()
+
 
 if __name__ == "__main__":
     main()

dibbler/models/Base.py

@@ -10,21 +10,29 @@ from sqlalchemy.orm.collections import (
 )
 
 
+def _pascal_case_to_snake_case(name: str) -> str:
+    return "".join(["_" + i.lower() if i.isupper() else i for i in name]).lstrip("_")
+
+
 class Base(DeclarativeBase):
     metadata = MetaData(
         naming_convention={
-            "ix": "ix_%(column_0_label)s",
-            "uq": "uq_%(table_name)s_%(column_0_name)s",
-            "ck": "ck_%(table_name)s_`%(constraint_name)s`",
-            "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
-            "pk": "pk_%(table_name)s",
+            "ix": "ix__%(table_name)s__%(column_0_label)s",
+            "uq": "uq__%(table_name)s__%(column_0_name)s",
+            "ck": "ck__%(table_name)s__%(constraint_name)s",
+            "fk": "fk__%(table_name)s__%(column_0_name)s_%(referred_table_name)s",
+            "pk": "pk__%(table_name)s",
         }
     )
 
     @declared_attr.directive
     def __tablename__(cls) -> str:
-        return cls.__name__
+        return _pascal_case_to_snake_case(cls.__name__)
 
+    # NOTE: This is the default implementation of __repr__ for all tables,
+    #       but it is preferable to override it for each table to get a nicer
+    #       looking representation. This trades a bit of messiness for a complete
+    #       output of all relevant fields.
     def __repr__(self) -> str:
         columns = ", ".join(
             f"{k}={repr(v)}"

dibbler/models/Product.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
+
+from typing import Self
 
 from sqlalchemy import (
     Boolean,
@@ -9,39 +10,45 @@ from sqlalchemy import (
 from sqlalchemy.orm import (
     Mapped,
     mapped_column,
-    relationship,
 )
 
 from .Base import Base
 
-if TYPE_CHECKING:
-    from .PurchaseEntry import PurchaseEntry
-    from .UserProducts import UserProducts
-
 
 class Product(Base):
-    __tablename__ = "products"
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    """Internal database ID"""
 
-    product_id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    bar_code: Mapped[str] = mapped_column(String(13))
-    name: Mapped[str] = mapped_column(String(45))
-    price: Mapped[int] = mapped_column(Integer)
-    stock: Mapped[int] = mapped_column(Integer)
-    hidden: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
+    # TODO: add more validation for barcode
+    bar_code: Mapped[str] = mapped_column(String(13), unique=True)
+    """
+        The bar code of the product.
 
-    purchases: Mapped[set[PurchaseEntry]] = relationship(back_populates="product")
-    users: Mapped[set[UserProducts]] = relationship(back_populates="product")
+        This is a unique identifier for the product, typically a 13-digit
+        EAN-13 code.
+    """
 
-    bar_code_re = r"[0-9]+"
-    name_re = r".+"
-    name_length = 45
+    name: Mapped[str] = mapped_column(String(45), unique=True)
+    """
+        The name of the product.
 
-    def __init__(self, bar_code, name, price, stock=0, hidden=False):
-        self.name = name
+        Please don't write fanfics here, this is not a place for that.
+    """
+
+    hidden: Mapped[bool] = mapped_column(Boolean, default=False)
+    """
+        Whether the product is hidden from the user interface.
+
+        Hidden products are not shown in the product list, but can still be
+        used in transactions.
+    """
+
+    def __init__(
+        self: Self,
+        bar_code: str,
+        name: str,
+        hidden: bool = False,
+    ) -> None:
         self.bar_code = bar_code
-        self.price = price
-        self.stock = stock
+        self.name = name
         self.hidden = hidden
-
-    def __str__(self):
-        return self.name

dibbler/models/ProductCache.py

@@ -0,0 +1,16 @@
+from datetime import datetime
+
+from sqlalchemy import Integer, DateTime
+from sqlalchemy.orm import Mapped, mapped_column
+
+from dibbler.models import Base
+
+
+class ProductCache(Base):
+    product_id: Mapped[int] = mapped_column(Integer, primary_key=True)
+
+    price: Mapped[int] = mapped_column(Integer)
+    price_timestamp: Mapped[datetime] = mapped_column(DateTime)
+
+    stock: Mapped[int] = mapped_column(Integer)
+    stock_timestamp: Mapped[datetime] = mapped_column(DateTime)

dibbler/models/Purchase.py

@@ -1,70 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-from datetime import datetime
-import math
-
-from sqlalchemy import (
-    DateTime,
-    Integer,
-)
-from sqlalchemy.orm import (
-    Mapped,
-    mapped_column,
-    relationship,
-)
-
-from .Base import Base
-from .Transaction import Transaction
-
-if TYPE_CHECKING:
-    from .PurchaseEntry import PurchaseEntry
-
-
-class Purchase(Base):
-    __tablename__ = "purchases"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    time: Mapped[datetime] = mapped_column(DateTime)
-    price: Mapped[int] = mapped_column(Integer)
-
-    transactions: Mapped[set[Transaction]] = relationship(
-        back_populates="purchase", order_by="Transaction.user_name"
-    )
-    entries: Mapped[set[PurchaseEntry]] = relationship(back_populates="purchase")
-
-    def __init__(self):
-        pass
-
-    def is_complete(self):
-        return len(self.transactions) > 0 and len(self.entries) > 0
-
-    def price_per_transaction(self, round_up=True):
-        if round_up:
-            return int(math.ceil(float(self.price) / len(self.transactions)))
-        else:
-            return int(math.floor(float(self.price) / len(self.transactions)))
-
-    def set_price(self, round_up=True):
-        self.price = 0
-        for entry in self.entries:
-            self.price += entry.amount * entry.product.price
-        if len(self.transactions) > 0:
-            for t in self.transactions:
-                t.amount = self.price_per_transaction(round_up=round_up)
-
-    def perform_purchase(self, ignore_penalty=False, round_up=True):
-        self.time = datetime.datetime.now()
-        self.set_price(round_up=round_up)
-        for t in self.transactions:
-            t.perform_transaction(ignore_penalty=ignore_penalty)
-        for entry in self.entries:
-            entry.product.stock -= entry.amount
-
-    def perform_soft_purchase(self, price, round_up=True):
-        self.time = datetime.datetime.now()
-        self.price = price
-        for t in self.transactions:
-            t.amount = self.price_per_transaction(round_up=round_up)
-        for t in self.transactions:
-            t.perform_transaction()

dibbler/models/PurchaseEntry.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-from sqlalchemy import (
-    Integer,
-    ForeignKey,
-)
-from sqlalchemy.orm import (
-    Mapped,
-    mapped_column,
-    relationship,
-)
-
-from .Base import Base
-
-if TYPE_CHECKING:
-    from .Product import Product
-    from .Purchase import Purchase
-
-
-class PurchaseEntry(Base):
-    __tablename__ = "purchase_entries"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    amount: Mapped[int] = mapped_column(Integer)
-
-    product_id: Mapped[int] = mapped_column(ForeignKey("products.product_id"))
-    purchase_id: Mapped[int] = mapped_column(ForeignKey("purchases.id"))
-
-    product: Mapped[Product] = relationship(lazy="joined")
-    purchase: Mapped[Purchase] = relationship(lazy="joined")
-
-    def __init__(self, purchase, product, amount):
-        self.product = product
-        self.product_bar_code = product.bar_code
-        self.purchase = purchase
-        self.amount = amount

dibbler/models/Transaction.py

@@ -1,52 +1,632 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
 
 from datetime import datetime
+from typing import TYPE_CHECKING, Self
 
 from sqlalchemy import (
+    CheckConstraint,
     DateTime,
     ForeignKey,
     Integer,
-    String,
+    Text,
+    and_,
+    column,
+    func,
+    or_,
 )
 from sqlalchemy.orm import (
     Mapped,
     mapped_column,
     relationship,
 )
+from sqlalchemy.orm.collections import (
+    InstrumentedDict,
+    InstrumentedList,
+    InstrumentedSet,
+)
+from sqlalchemy.sql.schema import Index
 
 from .Base import Base
+from .TransactionType import TransactionType, TransactionTypeSQL
 
 if TYPE_CHECKING:
+    from .Product import Product
     from .User import User
-    from .Purchase import Purchase
+
+# NOTE: these only matter when there are no adjustments made in the database.
+DEFAULT_INTEREST_RATE_PERCENT = 100
+DEFAULT_PENALTY_THRESHOLD = -100
+DEFAULT_PENALTY_MULTIPLIER_PERCENT = 200
+
+_DYNAMIC_FIELDS: set[str] = {
+    "amount",
+    "interest_rate_percent",
+    "joint_transaction_id",
+    "penalty_multiplier_percent",
+    "penalty_threshold",
+    "per_product",
+    "product_count",
+    "product_id",
+    "transfer_user_id",
+}
+
+EXPECTED_FIELDS: dict[TransactionType, set[str]] = {
+    TransactionType.ADD_PRODUCT: {"amount", "per_product", "product_count", "product_id"},
+    TransactionType.ADJUST_BALANCE: {"amount"},
+    TransactionType.ADJUST_INTEREST: {"interest_rate_percent"},
+    TransactionType.ADJUST_PENALTY: {"penalty_multiplier_percent", "penalty_threshold"},
+    TransactionType.ADJUST_STOCK: {"product_count", "product_id"},
+    TransactionType.BUY_PRODUCT: {"product_count", "product_id"},
+    TransactionType.JOINT: {"product_count", "product_id"},
+    TransactionType.JOINT_BUY_PRODUCT: {"joint_transaction_id"},
+    TransactionType.THROW_PRODUCT: {"product_count", "product_id"},
+    TransactionType.TRANSFER: {"amount", "transfer_user_id"},
+}
+
+assert all(x <= _DYNAMIC_FIELDS for x in EXPECTED_FIELDS.values()), (
+    "All expected fields must be part of _DYNAMIC_FIELDS."
+)
+
+
+def _transaction_type_field_constraints(
+    transaction_type: TransactionType,
+    expected_fields: set[str],
+) -> CheckConstraint:
+    unexpected_fields = _DYNAMIC_FIELDS - expected_fields
+
+    return CheckConstraint(
+        or_(
+            column("type") != transaction_type.value,
+            and_(
+                *[column(field).is_not(None) for field in expected_fields],
+                *[column(field).is_(None) for field in unexpected_fields],
+            ),
+        ),
+        name=f"trx_type_{transaction_type.value}_expected_fields",
+    )
 
 
 class Transaction(Base):
-    __tablename__ = "transactions"
+    __table_args__ = (
+        *[
+            _transaction_type_field_constraints(transaction_type, expected_fields)
+            for transaction_type, expected_fields in EXPECTED_FIELDS.items()
+        ],
+        CheckConstraint(
+            or_(
+                column("type") != TransactionType.TRANSFER.value,
+                column("user_id") != column("transfer_user_id"),
+            ),
+            name="trx_type_transfer_no_self_transfers",
+        ),
+        CheckConstraint(
+            func.coalesce(column("product_count"), 1) != 0,
+            name="trx_product_count_non_zero",
+        ),
+        CheckConstraint(
+            func.coalesce(column("penalty_multiplier_percent"), 100) >= 100,
+            name="trx_penalty_multiplier_percent_min_100",
+        ),
+        CheckConstraint(
+            func.coalesce(column("interest_rate_percent"), 0) >= 0,
+            name="trx_interest_rate_percent_non_negative",
+        ),
+        CheckConstraint(
+            func.coalesce(column("amount"), 1) != 0,
+            name="trx_amount_non_zero",
+        ),
+        CheckConstraint(
+            func.coalesce(column("per_product"), 1) > 0,
+            name="trx_per_product_positive",
+        ),
+        CheckConstraint(
+            func.coalesce(column("penalty_threshold"), 0) <= 0,
+            name="trx_penalty_threshold_max_0",
+        ),
+        CheckConstraint(
+            or_(
+                column("joint_transaction_id").is_(None),
+                column("joint_transaction_id") != column("id"),
+            ),
+            name="trx_joint_transaction_id_not_self",
+        ),
+
+        # Speed up product stock calculation
+        Index("ix__transaction__product_id_type_time", "product_id", "type", "time"),
+
+        # Speed up product owner calculation
+        Index("ix__transaction__user_id_product_time", "user_id", "product_id", "time"),
+
+        # Speed up user transaction list / credit calculation
+        Index("ix__transaction__user_id_time", "user_id", "time"),
+
+        # Speed up product price calculation
+        Index("ix__transaction__product_id_time_type", "product_id", "time", "type"),
+
+        # Speed up transaction logs
+        Index("ix__transaction__time_id", "time", "id"),
+    )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    """
+        A unique identifier for the transaction.
 
-    time: Mapped[datetime] = mapped_column(DateTime)
-    amount: Mapped[int] = mapped_column(Integer)
-    penalty: Mapped[int] = mapped_column(Integer)
-    description: Mapped[str | None] = mapped_column(String(50))
+        Not used for anything else than identifying the transaction in the database.
+    """
 
-    user_name: Mapped[str] = mapped_column(ForeignKey("users.name"))
-    purchase_id: Mapped[int | None] = mapped_column(ForeignKey("purchases.id"))
+    time: Mapped[datetime] = mapped_column(DateTime, index=True)
+    """
+        The time when the transaction took place.
 
-    user: Mapped[User] = relationship(lazy="joined")
-    purchase: Mapped[Purchase] = relationship(lazy="joined")
+        This is used to order transactions chronologically, and to calculate
+        all kinds of state.
+    """
+
+    message: Mapped[str | None] = mapped_column(Text, nullable=True)
+    """
+        A message that can be set by the user to describe the reason
+        behind the transaction (or potentially a place to write som fan fiction).
+
+        This is not used for any calculations, but can be useful for debugging.
+    """
+
+    type_: Mapped[TransactionType] = mapped_column(TransactionTypeSQL, name="type", index=True)
+    """
+        Which type of transaction this is.
+
+        The type determines which fields are expected to be set.
+    """
+
+    amount: Mapped[int | None] = mapped_column(Integer)
+    """
+        This field means different things depending on the transaction type:
+
+         - `ADD_PRODUCT`: The real amount spent on the products.
+
+         - `ADJUST_BALANCE`: The amount of credit to add or subtract from the user's balance.
+
+         - `TRANSFER`: The amount of balance to transfer to another user.
+    """
+
+    per_product: Mapped[int | None] = mapped_column(Integer)
+    """
+        If adding products, how much is each product worth
+
+        Note that this is distinct from the total amount of the transaction,
+        because this gets rounded up to the nearest integer, while the total amount
+        that the user paid in the store would be stored in the `amount` field.
+    """
+
+    user_id: Mapped[int] = mapped_column(ForeignKey("user.id"), index=True)
+    """The user who performs the transaction. See `user` for more details."""
+    user: Mapped[User] = relationship(
+        lazy="joined",
+        foreign_keys=[user_id],
+    )
+    """
+        The user who performs the transaction.
+
+        For some transaction types, like `TRANSFER` and `ADD_PRODUCT`, this is a
+        functional field with "real world consequences" for price calculations.
+
+        For others, like `ADJUST_PENALTY` and `ADJUST_STOCK`, this is just a record of who
+        performed the transaction, and does not affect any state calculations.
+
+        In the case of `JOINT` transactions, this is the user who initiated the joint transaction.
+    """
+
+    joint_transaction_id: Mapped[int | None] = mapped_column(
+        ForeignKey("transaction.id"),
+        index=True,
+    )
+    """
+    An optional ID to group multiple transactions together as part of a joint transaction.
+
+    This is used for `JOINT` and `JOINT_BUY_PRODUCT` transactions, where multiple users
+    are involved in a single transaction.
+    """
+    joint_transaction: Mapped[Transaction | None] = relationship(
+        lazy="joined",
+        foreign_keys=[joint_transaction_id],
+    )
+    """
+    The joint transaction that this transaction is part of, if any.
+    """
+
+    # Receiving user when moving credit from one user to another
+    transfer_user_id: Mapped[int | None] = mapped_column(ForeignKey("user.id"), index=True)
+    """The user who receives money in a `TRANSFER` transaction."""
+    transfer_user: Mapped[User | None] = relationship(
+        lazy="joined",
+        foreign_keys=[transfer_user_id],
+    )
+    """The user who receives money in a `TRANSFER` transaction."""
+
+    # The product that is either being added or bought
+    product_id: Mapped[int | None] = mapped_column(ForeignKey("product.id"), index=True)
+    """The product being added or bought."""
+    product: Mapped[Product | None] = relationship(lazy="joined")
+    """The product being added or bought."""
+
+    # The amount of products being added or bought
+    product_count: Mapped[int | None] = mapped_column(Integer)
+    """
+        The amount of products being added or bought.
+
+        This is always relative to the existing stock.
+
+        - `ADD_PRODUCT` increases the stock by this amount.
+
+        - `BUY_PRODUCT` decreases the stock by this amount.
+
+        - `ADJUST_STOCK` increases or decreases the stock by this amount,
+          depending on whether the amount is positive or negative.
+    """
+
+    penalty_threshold: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    """
+        On `ADJUST_PENALTY` transactions, this is the threshold in krs for when the user
+        should start getting penalized for low credit.
+
+        See also `penalty_multiplier`.
+    """
+
+    penalty_multiplier_percent: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    """
+        On `ADJUST_PENALTY` transactions, this is the multiplier for the amount of
+        money the user has to pay when they have too low credit.
+
+        The multiplier is a percentage, so `100` means the user has to pay the full
+        price of the product, `200` means they have to pay double, etc.
+
+        See also `penalty_threshold`.
+    """
+
+    interest_rate_percent: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    """
+        On `ADJUST_INTEREST` transactions, this is the interest rate in percent
+        that the user has to pay on their balance.
+
+        The interest rate is a percentage, so `100` means the user has to pay the full
+        price of the product, `200` means they have to pay double, etc.
+    """
+
+    economy_spec_version: Mapped[int] = mapped_column(Integer, default=1)
+    """
+        The version of the economy specification that this transaction adheres to.
+
+        This is used to handle changes in the economy rules over time.
+    """
+
+    def __init__(
+        self: Self,
+        type_: TransactionType,
+        user_id: int,
+        amount: int | None = None,
+        interest_rate_percent: int | None = None,
+        joint_transaction_id: int | None = None,
+        message: str | None = None,
+        penalty_multiplier_percent: int | None = None,
+        penalty_threshold: int | None = None,
+        per_product: int | None = None,
+        product_count: int | None = None,
+        product_id: int | None = None,
+        time: datetime | None = None,
+        transfer_user_id: int | None = None,
+    ) -> None:
+        """
+        Please do not call this constructor directly, use the factory methods instead.
+        """
+        if time is None:
+            time = datetime.now()
 
-    def __init__(self, user, amount=0, description=None, purchase=None, penalty=1):
-        self.user = user
         self.amount = amount
-        self.description = description
-        self.purchase = purchase
-        self.penalty = penalty
+        self.interest_rate_percent = interest_rate_percent
+        self.joint_transaction_id = joint_transaction_id
+        self.message = message
+        self.penalty_multiplier_percent = penalty_multiplier_percent
+        self.penalty_threshold = penalty_threshold
+        self.per_product = per_product
+        self.product_count = product_count
+        self.product_id = product_id
+        self.time = time
+        self.transfer_user_id = transfer_user_id
+        self.type_ = type_
+        self.user_id = user_id
 
-    def perform_transaction(self, ignore_penalty=False):
-        self.time = datetime.datetime.now()
-        if not ignore_penalty:
-            self.amount *= self.penalty
-        self.user.credit -= self.amount
+        self._validate_by_transaction_type()
+
+    def _validate_by_transaction_type(self: Self) -> None:
+        """
+        Validates the transaction's fields based on its type.
+        Raises `ValueError` if the transaction is invalid.
+        """
+        if self.amount == 0:
+            raise ValueError("Amount must not be zero.")
+
+        for field in EXPECTED_FIELDS[self.type_]:
+            if getattr(self, field) is None:
+                raise ValueError(f"{field} must not be None for {self.type_.value} transactions.")
+
+        for field in _DYNAMIC_FIELDS - EXPECTED_FIELDS[self.type_]:
+            if getattr(self, field) is not None:
+                raise ValueError(f"{field} must be None for {self.type_.value} transactions.")
+
+        if self.per_product is not None and self.per_product <= 0:
+            raise ValueError("per_product must be greater than zero.")
+
+        if (
+            self.per_product is not None
+            and self.product_count is not None
+            and self.amount is not None
+            and self.amount > self.per_product * self.product_count
+        ):
+            raise ValueError(
+                "The real amount of the transaction must be less than the total value of the products."
+            )
+
+    # TODO: improve printing further
+
+    def __repr__(self) -> str:
+        sort_order = [
+            "id",
+            "time",
+        ]
+
+        columns = ", ".join(
+            f"{k}={repr(v)}"
+            for k, v in sorted(
+                self.__dict__.items(),
+                key=lambda item: chr(sort_order.index(item[0]))
+                if item[0] in sort_order
+                else item[0],
+            )
+            if not any(
+                [
+                    k == "type_",
+                    (k == "message" and v is None),
+                    k.startswith("_"),
+                    # Ensure that we don't try to print out the entire list of
+                    # relationships, which could create an infinite loop
+                    isinstance(v, Base),
+                    isinstance(v, InstrumentedList),
+                    isinstance(v, InstrumentedSet),
+                    isinstance(v, InstrumentedDict),
+                    *[k in (_DYNAMIC_FIELDS - EXPECTED_FIELDS[self.type_])],
+                ]
+            )
+        )
+        return f"{self.type_.upper()}({columns})"
+
+    ###################
+    # FACTORY METHODS #
+    ###################
+
+    @classmethod
+    def adjust_balance(
+        cls: type[Self],
+        amount: int,
+        user_id: int,
+        time: datetime | None = None,
+        message: str | None = None,
+    ) -> Self:
+        """
+        Convenience constructor for creating an `ADJUST_BALANCE` transaction.
+
+        Should NOT be used directly in the application code; use the various queries instead.
+        """
+        return cls(
+            time=time,
+            type_=TransactionType.ADJUST_BALANCE,
+            amount=amount,
+            user_id=user_id,
+            message=message,
+        )
+
+    @classmethod
+    def adjust_interest(
+        cls: type[Self],
+        interest_rate_percent: int,
+        user_id: int,
+        time: datetime | None = None,
+        message: str | None = None,
+    ) -> Self:
+        """
+        Convenience constructor for creating an `ADJUST_INTEREST` transaction.
+
+        Should NOT be used directly in the application code; use the various queries instead.
+        """
+
+        return cls(
+            time=time,
+            type_=TransactionType.ADJUST_INTEREST,
+            interest_rate_percent=interest_rate_percent,
+            user_id=user_id,
+            message=message,
+        )
+
+    @classmethod
+    def adjust_penalty(
+        cls: type[Self],
+        penalty_multiplier_percent: int,
+        penalty_threshold: int,
+        user_id: int,
+        time: datetime | None = None,
+        message: str | None = None,
+    ) -> Self:
+        """
+        Convenience constructor for creating an `ADJUST_PENALTY` transaction.
+
+        Should NOT be used directly in the application code; use the various queries instead.
+        """
+        return cls(
+            time=time,
+            type_=TransactionType.ADJUST_PENALTY,
+            penalty_multiplier_percent=penalty_multiplier_percent,
+            penalty_threshold=penalty_threshold,
+            user_id=user_id,
+            message=message,
+        )
+
+    @classmethod
+    def adjust_stock(
+        cls: type[Self],
+        user_id: int,
+        product_id: int,
+        product_count: int,
+        time: datetime | None = None,
+        message: str | None = None,
+    ) -> Self:
+        """
+        Convenience constructor for creating an `ADJUST_STOCK` transaction.
+
+        Should NOT be used directly in the application code; use the various queries instead.
+        """
+        return cls(
+            time=time,
+            type_=TransactionType.ADJUST_STOCK,
+            user_id=user_id,
+            product_id=product_id,
+            product_count=product_count,
+            message=message,
+        )
+
+    @classmethod
+    def add_product(
+        cls: type[Self],
+        amount: int,
+        user_id: int,
+        product_id: int,
+        per_product: int,
+        product_count: int,
+        time: datetime | None = None,
+        message: str | None = None,
+    ) -> Self:
+        """
+        Convenience constructor for creating an `ADD_PRODUCT` transaction.
+
+        Should NOT be used directly in the application code; use the various queries instead.
+        """
+        return cls(
+            time=time,
+            type_=TransactionType.ADD_PRODUCT,
+            amount=amount,
+            user_id=user_id,
+            product_id=product_id,
+            per_product=per_product,
+            product_count=product_count,
+            message=message,
+        )
+
+    @classmethod
+    def buy_product(
+        cls: type[Self],
+        user_id: int,
+        product_id: int,
+        product_count: int,
+        time: datetime | None = None,
+        message: str | None = None,
+    ) -> Self:
+        """
+        Convenience constructor for creating a `BUY_PRODUCT` transaction.
+
+        Should NOT be used directly in the application code; use the various queries instead.
+        """
+        return cls(
+            time=time,
+            type_=TransactionType.BUY_PRODUCT,
+            user_id=user_id,
+            product_id=product_id,
+            product_count=product_count,
+            message=message,
+        )
+
+    @classmethod
+    def joint(
+        cls: type[Self],
+        user_id: int,
+        product_id: int,
+        product_count: int,
+        time: datetime | None = None,
+        message: str | None = None,
+    ) -> Self:
+        """
+        Convenience constructor for creating a `JOINT` transaction.
+
+        Should NOT be used directly in the application code; use the various queries instead.
+        """
+        return cls(
+            time=time,
+            type_=TransactionType.JOINT,
+            user_id=user_id,
+            product_id=product_id,
+            product_count=product_count,
+            message=message,
+        )
+
+    @classmethod
+    def joint_buy_product(
+        cls: type[Self],
+        joint_transaction_id: int,
+        user_id: int,
+        time: datetime | None = None,
+        message: str | None = None,
+    ) -> Self:
+        """
+        Convenience constructor for creating a `JOINT_BUY_PRODUCT` transaction.
+
+        Should NOT be used directly in the application code; use the various queries instead.
+        """
+        return cls(
+            time=time,
+            type_=TransactionType.JOINT_BUY_PRODUCT,
+            joint_transaction_id=joint_transaction_id,
+            user_id=user_id,
+            message=message,
+        )
+
+    @classmethod
+    def transfer(
+        cls: type[Self],
+        amount: int,
+        user_id: int,
+        transfer_user_id: int,
+        time: datetime | None = None,
+        message: str | None = None,
+    ) -> Self:
+        """
+        Convenience constructor for creating a `TRANSFER` transaction.
+
+        Should NOT be used directly in the application code; use the various queries instead.
+        """
+        return cls(
+            time=time,
+            type_=TransactionType.TRANSFER,
+            amount=amount,
+            user_id=user_id,
+            transfer_user_id=transfer_user_id,
+            message=message,
+        )
+
+    @classmethod
+    def throw_product(
+        cls: type[Self],
+        user_id: int,
+        product_id: int,
+        product_count: int,
+        time: datetime | None = None,
+        message: str | None = None,
+    ) -> Self:
+        """
+        Convenience constructor for creating a `THROW_PRODUCT` transaction.
+
+        Should NOT be used directly in the application code; use the various queries instead.
+        """
+        return cls(
+            time=time,
+            type_=TransactionType.THROW_PRODUCT,
+            user_id=user_id,
+            product_id=product_id,
+            product_count=product_count,
+            message=message,
+        )

dibbler/models/TransactionType.py

@@ -0,0 +1,40 @@
+from enum import StrEnum, auto
+
+from sqlalchemy import Enum as SQLEnum
+
+
+class TransactionType(StrEnum):
+    """
+    Enum for transaction types.
+    """
+
+    ADD_PRODUCT = auto()
+    ADJUST_BALANCE = auto()
+    ADJUST_INTEREST = auto()
+    ADJUST_PENALTY = auto()
+    ADJUST_STOCK = auto()
+    BUY_PRODUCT = auto()
+    JOINT = auto()
+    JOINT_BUY_PRODUCT = auto()
+    THROW_PRODUCT = auto()
+    TRANSFER = auto()
+
+    def as_literal_column(self):
+        """
+        Return the transaction type as a SQL literal column.
+
+        This is useful to avoid too many `?` bind parameters in SQL queries,
+        when the input value is known to be safe.
+        """
+        from sqlalchemy import literal_column
+
+        return literal_column(f"'{self.value}'")
+
+
+TransactionTypeSQL = SQLEnum(
+    TransactionType,
+    native_enum=True,
+    create_constraint=True,
+    validate_strings=True,
+    values_callable=lambda x: [i.value for i in x],
+)

dibbler/models/User.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
+
+from typing import Self
 
 from sqlalchemy import (
     Integer,
@@ -8,42 +9,35 @@ from sqlalchemy import (
 from sqlalchemy.orm import (
     Mapped,
     mapped_column,
-    relationship,
 )
 
 from .Base import Base
 
-if TYPE_CHECKING:
-    from .UserProducts import UserProducts
-    from .Transaction import Transaction
-
 
 class User(Base):
-    __tablename__ = "users"
-    name: Mapped[str] = mapped_column(String(10), primary_key=True)
-    credit: Mapped[str] = mapped_column(Integer)
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    """Internal database ID"""
+
+    name: Mapped[str] = mapped_column(String(20), unique=True)
+    """The PVV username of the user."""
+
     card: Mapped[str | None] = mapped_column(String(20))
+    """The NTNU card number of the user."""
+
     rfid: Mapped[str | None] = mapped_column(String(20))
+    """The RFID tag of the user (if they have any, rare these days)."""
 
-    products: Mapped[set[UserProducts]] = relationship(back_populates="user")
-    transactions: Mapped[set[Transaction]] = relationship(back_populates="user")
+    # name_re = r"[a-z]+"
+    # card_re = r"(([Nn][Tt][Nn][Uu])?[0-9]+)?"
+    # rfid_re = r"[0-9a-fA-F]*"
 
-    name_re = r"[a-z]+"
-    card_re = r"(([Nn][Tt][Nn][Uu])?[0-9]+)?"
-    rfid_re = r"[0-9a-fA-F]*"
-
-    def __init__(self, name, card, rfid=None, credit=0):
+    def __init__(self: Self, name: str, card: str | None = None, rfid: str | None = None) -> None:
         self.name = name
-        if card == "":
-            card = None
         self.card = card
-        if rfid == "":
-            rfid = None
         self.rfid = rfid
-        self.credit = credit
 
-    def __str__(self):
-        return self.name
+    # def __str__(self):
+    #     return self.name
 
-    def is_anonymous(self):
-        return self.card == "11122233"
+    # def is_anonymous(self):
+    #     return self.card == "11122233"

dibbler/models/UserCache.py

@@ -0,0 +1,14 @@
+from datetime import datetime
+
+from sqlalchemy import Integer, DateTime
+from sqlalchemy.orm import Mapped, mapped_column
+
+from dibbler.models import Base
+
+
+# More like user balance cash money flow, amirite?
+class UserBalanceCache(Base):
+    user_id: Mapped[int] = mapped_column(Integer, primary_key=True)
+
+    balance: Mapped[int] = mapped_column(Integer)
+    timestamp: Mapped[datetime] = mapped_column(DateTime)

dibbler/models/UserProducts.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-from sqlalchemy import (
-    Integer,
-    ForeignKey,
-)
-from sqlalchemy.orm import (
-    Mapped,
-    mapped_column,
-    relationship,
-)
-
-from .Base import Base
-
-if TYPE_CHECKING:
-    from .User import User
-    from .Product import Product
-
-
-class UserProducts(Base):
-    __tablename__ = "user_products"
-
-    user_name: Mapped[str] = mapped_column(ForeignKey("users.name"), primary_key=True)
-    product_id: Mapped[int] = mapped_column(ForeignKey("products.product_id"), primary_key=True)
-
-    count: Mapped[int] = mapped_column(Integer)
-    sign: Mapped[int] = mapped_column(Integer)
-
-    user: Mapped[User] = relationship()
-    product: Mapped[Product] = relationship()

dibbler/models/__init__.py

@@ -1,17 +1,13 @@
 __all__ = [
     "Base",
     "Product",
-    "Purchase",
-    "PurchaseEntry",
     "Transaction",
+    "TransactionType",
     "User",
-    "UserProducts",
 ]
 
 from .Base import Base
 from .Product import Product
-from .Purchase import Purchase
-from .PurchaseEntry import PurchaseEntry
 from .Transaction import Transaction
+from .TransactionType import TransactionType
 from .User import User
-from .UserProducts import UserProducts

dibbler/queries/__init__.py

@@ -0,0 +1,46 @@
+__all__ = [
+    "add_product",
+    "adjust_balance",
+    "adjust_interest",
+    "adjust_penalty",
+    "adjust_stock",
+    "create_product",
+    "create_user",
+    "current_interest",
+    "current_penalty",
+    "joint_buy_product",
+    "product_owners",
+    "product_owners_log",
+    "product_price",
+    "product_price_log",
+    "product_stock",
+    "search_product",
+    "search_user",
+    "throw_product",
+    "transaction_log",
+    "transfer",
+    "user_balance",
+    "user_balance_log",
+    "user_products",
+]
+
+from .add_product import add_product
+from .adjust_balance import adjust_balance
+from .adjust_interest import adjust_interest
+from .adjust_penalty import adjust_penalty
+from .adjust_stock import adjust_stock
+from .create_product import create_product
+from .create_user import create_user
+from .current_interest import current_interest
+from .current_penalty import current_penalty
+from .joint_buy_product import joint_buy_product
+from .product_owners import product_owners, product_owners_log
+from .product_price import product_price, product_price_log
+from .product_stock import product_stock
+from .search_product import search_product
+from .search_user import search_user
+from .throw_product import throw_product
+from .transaction_log import transaction_log
+from .transfer import transfer
+from .user_balance import user_balance, user_balance_log
+from .user_products import user_products

dibbler/queries/add_product.py

@@ -0,0 +1,51 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, Transaction, User
+
+
+def add_product(
+    sql_session: Session,
+    user: User,
+    product: Product,
+    amount: int,
+    per_product: int,
+    product_count: int,
+    time: datetime | None = None,
+    message: str | None = None,
+) -> Transaction:
+    if user.id is None:
+        raise ValueError("User must be persisted in the database.")
+
+    if product.id is None:
+        raise ValueError("Product must be persisted in the database.")
+
+    if amount <= 0:
+        raise ValueError("Amount must be positive.")
+
+    if per_product <= 0:
+        raise ValueError("Per product price must be positive.")
+
+    if product_count <= 0:
+        raise ValueError("Product count must be positive.")
+
+    if per_product * product_count < amount:
+        raise ValueError("Total per product price must be at least equal to amount.")
+
+    # TODO: verify time is not behind last transaction's time
+
+    transaction = Transaction.add_product(
+        user_id=user.id,
+        product_id=product.id,
+        amount=amount,
+        per_product=per_product,
+        product_count=product_count,
+        time=time,
+        message=message,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()
+
+    return transaction

dibbler/queries/adjust_balance.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import Transaction, User
+
+
+def adjust_balance(
+    sql_session: Session,
+    user: User,
+    amount: int,
+    time: datetime | None = None,
+    message: str | None = None,
+) -> Transaction:
+    if user.id is None:
+        raise ValueError("User must be persisted in the database.")
+
+    if amount == 0:
+        raise ValueError("Amount must be non-zero.")
+
+    # TODO: verify time is not behind last transaction's time
+
+    transaction = Transaction.adjust_balance(
+        user_id=user.id,
+        amount=amount,
+        time=time,
+        message=message,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()
+
+    return transaction

dibbler/queries/adjust_interest.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import Transaction, User
+
+# TODO: this type of transaction should be password protected.
+#       the password can be set as a string literal in the config file.
+
+
+def adjust_interest(
+    sql_session: Session,
+    user: User,
+    new_interest: int,
+    time: datetime | None = None,
+    message: str | None = None,
+) -> Transaction:
+    if new_interest < 0:
+        raise ValueError("Interest rate cannot be negative")
+
+    if user.id is None:
+        raise ValueError("User must be persisted in the database.")
+
+    # TODO: verify time is not behind last transaction's time
+
+    transaction = Transaction.adjust_interest(
+        user_id=user.id,
+        interest_rate_percent=new_interest,
+        time=time,
+        message=message,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()
+
+    return transaction

dibbler/queries/adjust_penalty.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import Transaction, User
+from dibbler.queries.current_penalty import current_penalty
+
+# TODO: this type of transaction should be password protected.
+#       the password can be set as a string literal in the config file.
+
+
+def adjust_penalty(
+    sql_session: Session,
+    user: User,
+    new_penalty: int | None = None,
+    new_penalty_multiplier: int | None = None,
+    time: datetime | None = None,
+    message: str | None = None,
+) -> Transaction:
+    if new_penalty is None and new_penalty_multiplier is None:
+        raise ValueError("At least one of new_penalty or new_penalty_multiplier must be provided")
+
+    if new_penalty_multiplier is not None and new_penalty_multiplier < 100:
+        raise ValueError("Penalty multiplier cannot be less than 100%")
+
+    if user.id is None:
+        raise ValueError("User must be persisted in the database.")
+
+    if new_penalty is None or new_penalty_multiplier is None:
+        existing_penalty, existing_penalty_multiplier = current_penalty(sql_session)
+        if new_penalty is None:
+            new_penalty = existing_penalty
+        if new_penalty_multiplier is None:
+            new_penalty_multiplier = existing_penalty_multiplier
+
+    # TODO: verify time is not behind last transaction's time
+
+    transaction = Transaction.adjust_penalty(
+        user_id=user.id,
+        penalty_threshold=new_penalty,
+        penalty_multiplier_percent=new_penalty_multiplier,
+        time=time,
+        message=message,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()
+
+    return transaction

dibbler/queries/adjust_stock.py

@@ -0,0 +1,40 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, Transaction, User
+
+
+def adjust_stock(
+    sql_session: Session,
+    user: User,
+    product: Product,
+    product_count: int,
+    time: datetime | None = None,
+    message: str | None = None,
+) -> Transaction:
+    if user.id is None:
+        raise ValueError("User must be persisted in the database.")
+
+    if product.id is None:
+        raise ValueError("Product must be persisted in the database.")
+
+    if product_count == 0:
+        raise ValueError("Product count must be non-zero.")
+
+    # TODO: it should not be possible to reduce stock below zero.
+    #
+    # TODO: verify time is not behind last transaction's time
+
+    transaction = Transaction.adjust_stock(
+        user_id=user.id,
+        product_id=product.id,
+        product_count=product_count,
+        time=time,
+        message=message,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()
+
+    return transaction

dibbler/queries/buy_product.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, Transaction, User
+
+
+def buy_product(
+    sql_session: Session,
+    user: User,
+    product: Product,
+    product_count: int,
+    time: datetime | None = None,
+    message: str | None = None,
+) -> Transaction:
+    if user.id is None:
+        raise ValueError("User must be persisted in the database.")
+
+    if product.id is None:
+        raise ValueError("Product must be persisted in the database.")
+
+    if product_count <= 0:
+        raise ValueError("Product count must be positive.")
+
+    # TODO: verify time is not behind last transaction's time
+
+    transaction = Transaction.buy_product(
+        user_id=user.id,
+        product_id=product.id,
+        product_count=product_count,
+        time=time,
+        message=message,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()
+
+    return transaction

dibbler/queries/create_product.py

@@ -0,0 +1,25 @@
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product
+
+
+def create_product(
+    sql_session: Session,
+    name: str,
+    barcode: str,
+) -> Product:
+    if not name:
+        raise ValueError("Name cannot be empty.")
+
+    if not barcode:
+        raise ValueError("Barcode cannot be empty.")
+
+    # TODO: check for duplicate names, barcodes
+
+    # TODO: add more validation for barcode
+
+    product = Product(barcode, name)
+    sql_session.add(product)
+    sql_session.commit()
+
+    return product

dibbler/queries/create_user.py

@@ -0,0 +1,21 @@
+from sqlalchemy.orm import Session
+
+from dibbler.models import User
+
+
+def create_user(
+    sql_session: Session,
+    name: str,
+    card: str | None,
+    rfid: str | None,
+) -> User:
+    if not name:
+        raise ValueError("Name cannot be empty.")
+
+    # TODO: check for duplicate names, cards, rfids
+
+    user = User(name=name, card=card, rfid=rfid)
+    sql_session.add(user)
+    sql_session.commit()
+
+    return user

dibbler/queries/current_interest.py

@@ -0,0 +1,55 @@
+from datetime import datetime
+
+from sqlalchemy import BindParameter, bindparam, select
+from sqlalchemy.orm import Session
+
+from dibbler.models import Transaction, TransactionType
+from dibbler.models.Transaction import DEFAULT_INTEREST_RATE_PERCENT
+from dibbler.queries.query_helpers import until_filter
+
+
+def current_interest(
+    sql_session: Session,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: BindParameter[Transaction] | Transaction | None = None,
+    until_inclusive: bool = True,
+) -> int:
+    """
+    Get the current interest rate percentage as of a given time or transaction.
+
+    Returns the interest rate percentage as an integer.
+    """
+
+    if not (until_time is None or until_transaction is None):
+        raise ValueError("Cannot filter by both until_time and until_transaction.")
+
+    if isinstance(until_time, datetime):
+        until_time = BindParameter("until_time", value=until_time)
+
+    if isinstance(until_transaction, Transaction):
+        if until_transaction.id is None:
+            raise ValueError("until_transaction must be persisted in the database.")
+        until_transaction_id = bindparam("until_transaction_id", value=until_transaction.id)
+    else:
+        until_transaction_id = None
+
+    result = sql_session.scalars(
+        select(Transaction)
+        .where(
+            Transaction.type_ == TransactionType.ADJUST_INTEREST,
+            until_filter(
+                until_time=until_time,
+                until_transaction_id=until_transaction_id,
+                until_inclusive=until_inclusive,
+            ),
+        )
+        .order_by(Transaction.time.desc())
+        .limit(1)
+    ).one_or_none()
+
+    if result is None:
+        return DEFAULT_INTEREST_RATE_PERCENT
+    elif result.interest_rate_percent is None:
+        return DEFAULT_INTEREST_RATE_PERCENT
+    else:
+        return result.interest_rate_percent

dibbler/queries/current_penalty.py

@@ -0,0 +1,59 @@
+from datetime import datetime
+
+from sqlalchemy import BindParameter, bindparam, select
+from sqlalchemy.orm import Session
+
+from dibbler.models import Transaction, TransactionType
+from dibbler.models.Transaction import (
+    DEFAULT_PENALTY_MULTIPLIER_PERCENT,
+    DEFAULT_PENALTY_THRESHOLD,
+)
+from dibbler.queries.query_helpers import until_filter
+
+
+def current_penalty(
+    sql_session: Session,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: BindParameter[Transaction] | Transaction | None = None,
+    until_inclusive: bool = True,
+) -> tuple[int, int]:
+    """
+    Get the current penalty settings (threshold and multiplier percentage) as of a given time or transaction.
+
+    Returns a tuple of `(penalty_threshold, penalty_multiplier_percentage)`.
+    """
+
+    if not (until_time is None or until_transaction is None):
+        raise ValueError("Cannot filter by both until_time and until_transaction.")
+
+    if isinstance(until_time, datetime):
+        until_time = BindParameter("until_time", value=until_time)
+
+    if isinstance(until_transaction, Transaction):
+        if until_transaction.id is None:
+            raise ValueError("until_transaction must be persisted in the database.")
+        until_transaction_id = bindparam("until_transaction_id", value=until_transaction.id)
+    else:
+        until_transaction_id = None
+
+    result = sql_session.scalars(
+        select(Transaction)
+        .where(
+            Transaction.type_ == TransactionType.ADJUST_PENALTY,
+            until_filter(
+                until_time=until_time,
+                until_transaction_id=until_transaction_id,
+                until_inclusive=until_inclusive,
+            ),
+        )
+        .order_by(Transaction.time.desc())
+        .limit(1)
+    ).one_or_none()
+
+    if result is None:
+        return DEFAULT_PENALTY_THRESHOLD, DEFAULT_PENALTY_MULTIPLIER_PERCENT
+
+    assert result.penalty_threshold is not None, "Penalty threshold must be set"
+    assert result.penalty_multiplier_percent is not None, "Penalty multiplier percent must be set"
+
+    return result.penalty_threshold, result.penalty_multiplier_percent

dibbler/queries/joint_buy_product.py

@@ -0,0 +1,69 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import (
+    Product,
+    Transaction,
+    User,
+)
+
+
+def joint_buy_product(
+    sql_session: Session,
+    product: Product,
+    product_count: int,
+    instigator: User,
+    users: list[User],
+    time: datetime | None = None,
+    message: str | None = None,
+) -> list[Transaction]:
+    """
+    Create buy product transactions for multiple users at once.
+    """
+
+    if product.id is None:
+        raise ValueError("Product must be persisted in the database.")
+
+    if instigator.id is None:
+        raise ValueError("Instigator must be persisted in the database.")
+
+    if len(users) == 0:
+        raise ValueError("At least bying one user must be specified.")
+
+    if any(user.id is None for user in users):
+        raise ValueError("All users must be persisted in the database.")
+
+    if instigator not in users:
+        raise ValueError("Instigator must be in the list of users buying the product.")
+
+    if product_count <= 0:
+        raise ValueError("Product count must be positive.")
+
+    # TODO: verify time is not behind last transaction's time
+
+    with sql_session.begin(nested=True):
+        joint_transaction = Transaction.joint(
+            user_id=instigator.id,
+            product_id=product.id,
+            product_count=product_count,
+            time=time,
+            message=message,
+        )
+        sql_session.add(joint_transaction)
+        sql_session.flush()  # Ensure joint_transaction gets an ID
+
+        transactions = [joint_transaction]
+
+        for user in users:
+            buy_transaction = Transaction.joint_buy_product(
+                user_id=user.id,
+                joint_transaction_id=joint_transaction.id,
+                time=time,
+                message=message,
+            )
+            sql_session.add(buy_transaction)
+            transactions.append(buy_transaction)
+
+        sql_session.commit()
+    return transactions

dibbler/queries/product_owners.py

@@ -0,0 +1,306 @@
+from dataclasses import dataclass
+from datetime import datetime
+
+from sqlalchemy import (
+    CTE,
+    BindParameter,
+    and_,
+    bindparam,
+    case,
+    func,
+    or_,
+    select,
+)
+from sqlalchemy.orm import Session
+
+from dibbler.models import (
+    Product,
+    Transaction,
+    TransactionType,
+    User,
+)
+from dibbler.queries.product_stock import _product_stock_query
+from dibbler.queries.query_helpers import (
+    CONST_NONE,
+    CONST_ONE,
+    CONST_ZERO,
+    until_filter,
+)
+
+
+def _product_owners_query(
+    product_id: BindParameter[int] | int,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+    cte_name: str = "rec_cte",
+    trx_subset_name: str = "trx_subset",
+) -> CTE:
+    """
+    The inner query for inferring the owners of a given product.
+    """
+
+    if use_cache:
+        print("WARNING: Using cache for users owning product query is not implemented yet.")
+
+    if isinstance(product_id, int):
+        product_id = bindparam("product_id", value=product_id)
+
+    if until_time is not None and until_transaction is not None:
+        raise ValueError("Cannot filter by both until_time and until_transaction.")
+
+    if isinstance(until_time, datetime):
+        until_time = bindparam("until_time", value=until_time)
+
+    if isinstance(until_transaction, Transaction):
+        if until_transaction.id is None:
+            raise ValueError("until_transaction must be persisted in the database.")
+        until_transaction_id = bindparam("until_transaction_id", value=until_transaction.id)
+    else:
+        until_transaction_id = None
+
+    product_stock = _product_stock_query(
+        product_id=product_id,
+        use_cache=use_cache,
+        until_time=until_time,
+        until_transaction=until_transaction,
+        until_inclusive=until_inclusive,
+    )
+
+    # Subset of transactions that we'll want to iterate over.
+    trx_subset = (
+        select(
+            func.row_number().over(order_by=Transaction.time.desc()).label("i"),
+            Transaction.time,
+            Transaction.id,
+            Transaction.type_,
+            Transaction.user_id,
+            Transaction.product_count,
+        )
+        .where(
+            or_(
+                Transaction.type_ == TransactionType.ADD_PRODUCT.as_literal_column(),
+                and_(
+                    Transaction.type_ == TransactionType.ADJUST_STOCK.as_literal_column(),
+                    Transaction.product_count > CONST_ZERO,
+                ),
+            ),
+            Transaction.product_id == product_id,
+            until_filter(
+                until_time=until_time,
+                until_transaction_id=until_transaction_id,
+                until_inclusive=until_inclusive,
+            ),
+        )
+        .subquery(trx_subset_name)
+    )
+
+    initial_element = select(
+        CONST_ZERO.label("i"),
+        CONST_ZERO.label("time"),
+        CONST_NONE.label("transaction_id"),
+        CONST_NONE.label("user_id"),
+        CONST_ZERO.label("product_count"),
+        product_stock.scalar_subquery().label("products_left_to_account_for"),
+    )
+
+    recursive_cte = initial_element.cte(name=cte_name, recursive=True)
+
+    recursive_elements = (
+        select(
+            trx_subset.c.i,
+            trx_subset.c.time,
+            trx_subset.c.id.label("transaction_id"),
+            # Who added the product (if any)
+            case(
+                # Someone adds the product -> they own it
+                (
+                    trx_subset.c.type_ == TransactionType.ADD_PRODUCT.as_literal_column(),
+                    trx_subset.c.user_id,
+                ),
+                else_=CONST_NONE,
+            ).label("user_id"),
+            # How many products did they add (if any)
+            case(
+                # Someone adds the product -> they added a certain amount of products
+                (
+                    trx_subset.c.type_ == TransactionType.ADD_PRODUCT.as_literal_column(),
+                    trx_subset.c.product_count,
+                ),
+                # Stock got adjusted upwards -> consider those products as added by nobody
+                (
+                    (trx_subset.c.type_ == TransactionType.ADJUST_STOCK.as_literal_column())
+                    and (trx_subset.c.product_count > CONST_ZERO),
+                    trx_subset.c.product_count,
+                ),
+                else_=CONST_ZERO,
+            ).label("product_count"),
+            # How many products left to account for
+            case(
+                # Someone adds the product -> known owner, decrease the number of products left to account for
+                (
+                    trx_subset.c.type_ == TransactionType.ADD_PRODUCT.as_literal_column(),
+                    recursive_cte.c.products_left_to_account_for - trx_subset.c.product_count,
+                ),
+                # Stock got adjusted upwards -> none owner, decrease the number of products left to account for
+                (
+                    and_(
+                        trx_subset.c.type_ == TransactionType.ADJUST_STOCK.as_literal_column(),
+                        trx_subset.c.product_count > CONST_ZERO,
+                    ),
+                    recursive_cte.c.products_left_to_account_for - trx_subset.c.product_count,
+                ),
+                else_=recursive_cte.c.products_left_to_account_for,
+            ).label("products_left_to_account_for"),
+        )
+        .select_from(trx_subset)
+        .where(
+            and_(
+                trx_subset.c.i == recursive_cte.c.i + CONST_ONE,
+                # Base case: stop if we've accounted for all products
+                recursive_cte.c.products_left_to_account_for > CONST_ZERO,
+            )
+        )
+    )
+
+    return recursive_cte.union_all(recursive_elements)
+
+
+@dataclass
+class ProductOwnersLogEntry:
+    transaction: Transaction
+    user: User | None
+    products_left_to_account_for: int
+
+
+def product_owners_log(
+    sql_session: Session,
+    product: Product,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+) -> list[ProductOwnersLogEntry]:
+    """
+    Returns a log of the product ownership calculation for the given product.
+
+    If 'until' is given, only transactions up to that time are considered.
+    """
+
+    if product.id is None:
+        raise ValueError("Product must be persisted in the database.")
+
+    recursive_cte = _product_owners_query(
+        product_id=product.id,
+        use_cache=use_cache,
+        until_time=until_time,
+        until_transaction=until_transaction,
+        until_inclusive=until_inclusive,
+    )
+
+    result = sql_session.execute(
+        select(
+            Transaction,
+            User,
+            recursive_cte.c.products_left_to_account_for,
+        )
+        .select_from(recursive_cte)
+        .join(
+            Transaction,
+            onclause=Transaction.id == recursive_cte.c.transaction_id,
+        )
+        .join(
+            User,
+            onclause=User.id == recursive_cte.c.user_id,
+            isouter=True,
+        )
+        .order_by(recursive_cte.c.time.desc())
+    ).all()
+
+    if result is None:
+        # If there are no transactions for this product, the query should return an empty list, not None.
+        raise RuntimeError(
+            f"Something went wrong while calculating the owner log for product {product.name} (ID: {product.id})."
+        )
+
+    return [
+        ProductOwnersLogEntry(
+            transaction=row[0],
+            user=row[1],
+            products_left_to_account_for=row[2],
+        )
+        for row in result
+    ]
+
+
+def product_owners(
+    sql_session: Session,
+    product: Product,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+) -> list[User | None]:
+    """
+    Returns an ordered list of users owning the given product.
+
+    If 'until' is given, only transactions up to that time are considered.
+    """
+
+    if product.id is None:
+        raise ValueError("Product must be persisted in the database.")
+
+    recursive_cte = _product_owners_query(
+        product_id=product.id,
+        use_cache=use_cache,
+        until_time=until_time,
+        until_transaction=until_transaction,
+        until_inclusive=until_inclusive,
+    )
+
+    db_result = sql_session.execute(
+        select(
+            recursive_cte.c.products_left_to_account_for,
+            recursive_cte.c.product_count,
+            User,
+        )
+        .join(User, User.id == recursive_cte.c.user_id, isouter=True)
+        .order_by(recursive_cte.c.time.desc())
+    ).all()
+
+    result: list[User | None] = []
+    none_count = 0
+
+    # We are moving backwards through history, but this is the order we want to return the list
+    # There are 3 cases:
+    # User is not none -> add user product_count times
+    # User is none, and product_count is not 0 -> add None product_count times
+    # User is none, and product_count is 0 -> check how much products are left to account for,
+
+    # TODO: embed this into the query itself?
+    for products_left_to_account_for, product_count, user in db_result:
+        if user is not None:
+            if products_left_to_account_for < 0:
+                result.extend([user] * (product_count + products_left_to_account_for))
+            else:
+                result.extend([user] * product_count)
+        elif product_count != 0:
+            if products_left_to_account_for < 0:
+                none_count += product_count + products_left_to_account_for
+            else:
+                none_count += product_count
+        else:
+            pass
+
+        #     none_count += user_count
+        # else:
+
+    result.extend([None] * none_count)
+
+    # # NOTE: if the last line exeeds the product count, we need to truncate it
+    # result.extend([user] * min(user_count, products_left_to_account_for))
+
+    # redistribute the user counts to a list of users
+
+    return list(result)

dibbler/queries/product_price.py

@@ -0,0 +1,351 @@
+import math
+from dataclasses import dataclass
+from datetime import datetime
+
+from sqlalchemy import (
+    CTE,
+    BindParameter,
+    ColumnElement,
+    Integer,
+    and_,
+    bindparam,
+    case,
+    cast,
+    func,
+    select,
+    tuple_,
+)
+from sqlalchemy.orm import Session, aliased
+
+from dibbler.models import (
+    Product,
+    Transaction,
+    TransactionType,
+)
+from dibbler.models.Transaction import DEFAULT_INTEREST_RATE_PERCENT
+from dibbler.queries.query_helpers import (
+    CONST_NONE,
+    CONST_ONE,
+    CONST_ZERO,
+    until_filter,
+)
+
+
+def cte_union(self, other, inner_fn=lambda x: x):
+    inner = self.element.union_all(other)
+    inner = inner_fn(inner)
+    return CTE._construct(
+        inner,
+        name=self.name,
+        recursive=self.recursive,
+        nesting=self.nesting,
+        _restates=self,
+        _prefixes=self._prefixes,
+        _suffixes=self._suffixes,
+    )
+
+
+def _product_price_query(
+    product_id: int | ColumnElement[int],
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+    cte_name: str = "rec_cte",
+    trx_subset_name: str = "trx_subset",
+):
+    """
+    The inner query for calculating the product price.
+    """
+
+    if use_cache:
+        print("WARNING: Using cache for product price query is not implemented yet.")
+
+    if isinstance(product_id, int):
+        product_id = BindParameter("product_id", value=product_id)
+
+    if not (until_time is None or until_transaction is None):
+        raise ValueError("Cannot filter by both until_time and until_transaction.")
+
+    if isinstance(until_time, datetime):
+        until_time = BindParameter("until_time", value=until_time)
+
+    if isinstance(until_transaction, Transaction):
+        if until_transaction.id is None:
+            raise ValueError("until_transaction must be persisted in the database.")
+        until_transaction_id = bindparam("until_transaction_id", value=until_transaction.id)
+    else:
+        until_transaction_id = None
+
+    initial_element = select(
+        CONST_ZERO.label("i"),
+        CONST_NONE.label("transaction_id"),
+        CONST_ZERO.label("time"),
+        CONST_ZERO.label("price"),
+        CONST_ZERO.label("product_count"),
+    )
+
+    recursive_cte = initial_element.cte(name=cte_name, recursive=True)
+
+    t1 = aliased(Transaction)
+
+    next_time = (
+        select(func.min(t1.time))
+        .where(
+            t1.product_id == product_id,
+            t1.type_.in_(
+                [
+                    TransactionType.BUY_PRODUCT.as_literal_column(),
+                    TransactionType.ADD_PRODUCT.as_literal_column(),
+                    TransactionType.ADJUST_STOCK.as_literal_column(),
+                    TransactionType.JOINT.as_literal_column(),
+                ]
+            ),
+            tuple_(t1.time, t1.id) > tuple_(recursive_cte.c.time, recursive_cte.c.transaction_id),
+            until_filter(
+                until_time=until_time,
+                until_transaction_id=until_transaction_id,
+                until_inclusive=until_inclusive,
+                transaction_time=t1.time,
+            ),
+        )
+        .correlate(recursive_cte)
+        .scalar_subquery()
+    )
+
+    next_id = (
+        select(func.min(t1.id))
+        .where(
+            t1.product_id == product_id,
+            t1.type_.in_(
+                [
+                    TransactionType.BUY_PRODUCT.as_literal_column(),
+                    TransactionType.ADD_PRODUCT.as_literal_column(),
+                    TransactionType.ADJUST_STOCK.as_literal_column(),
+                    TransactionType.JOINT.as_literal_column(),
+                ]
+            ),
+            tuple_(t1.time, t1.id) > tuple_(recursive_cte.c.time, recursive_cte.c.transaction_id),
+            until_filter(
+                until_time=until_time,
+                until_transaction_id=until_transaction_id,
+                until_inclusive=until_inclusive,
+                transaction_time=t1.time,
+            ),
+            t1.time == next_time,
+        )
+        .correlate(recursive_cte)
+        .scalar_subquery()
+    )
+
+    t_next = aliased(Transaction)
+
+    recursive_elements = (
+        select(
+            (recursive_cte.c.i + CONST_ONE).label("i"),
+            t_next.id.label("transaction_id"),
+            t_next.time,
+            case(
+                # Someone adds the product -> price is recalculated based on
+                #  product count, previous price, and new price.
+                (
+                    t_next.type_ == TransactionType.ADD_PRODUCT.as_literal_column(),
+                    cast(
+                        func.ceil(
+                            (
+                                recursive_cte.c.price
+                                * cast(recursive_cte.c.product_count > CONST_ZERO, Integer)
+                                * recursive_cte.c.product_count
+                                + t_next.per_product * t_next.product_count
+                            )
+                            / (
+                                # The running product count can be negative if the accounting is bad.
+                                # This ensures that we never end up with negative prices or zero divisions
+                                # and other disastrous phenomena.
+                                cast(recursive_cte.c.product_count > CONST_ZERO, Integer)
+                                * recursive_cte.c.product_count
+                                + t_next.product_count
+                            )
+                        ),
+                        Integer,
+                    ),
+                ),
+                # BUY_PRODUCT
+                # JOINT
+                # ADJUST_STOCK
+                else_=recursive_cte.c.price,
+            ).label("price"),
+            (
+                recursive_cte.c.product_count
+                - (
+                    # Someone buys the product -> product count is reduced.
+                    cast(t_next.type_ == TransactionType.BUY_PRODUCT.as_literal_column(), Integer)
+                    * t_next.product_count
+                )
+                - (
+                    cast(t_next.type_ == TransactionType.JOINT.as_literal_column(), Integer)
+                    * t_next.product_count
+                )
+                + (
+                    # Someone adds the product -> product count is increased.
+                    cast(t_next.type_ == TransactionType.ADD_PRODUCT.as_literal_column(), Integer)
+                    * t_next.product_count
+                )
+                + (
+                    # Someone adjusts the stock -> product count is adjusted.
+                    cast(t_next.type_ == TransactionType.ADJUST_STOCK.as_literal_column(), Integer)
+                    * t_next.product_count
+                )
+            ).label("product_count"),
+        )
+        .select_from(recursive_cte)
+        .join(
+            t_next,
+            onclause=and_(t_next.time == next_time, t_next.id == next_id),
+        )
+    )
+
+    return recursive_cte.union_all(recursive_elements)
+
+
+# TODO: create a function for the log that pretty prints the log entries
+#       for debugging purposes
+
+
+@dataclass
+class ProductPriceLogEntry:
+    transaction: Transaction
+    price: int
+    product_count: int
+
+
+def product_price_log(
+    sql_session: Session,
+    product: Product,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+) -> list[ProductPriceLogEntry]:
+    """
+    Calculates the price of a product and returns a log of the price changes.
+    """
+
+    if product.id is None:
+        raise ValueError("Product must be persisted in the database.")
+
+    recursive_cte = _product_price_query(
+        product.id,
+        use_cache=use_cache,
+        until_time=until_time,
+        until_transaction=until_transaction,
+        until_inclusive=until_inclusive,
+    )
+
+    result = sql_session.execute(
+        select(
+            Transaction,
+            recursive_cte.c.price,
+            recursive_cte.c.product_count,
+        )
+        .select_from(recursive_cte)
+        .join(
+            Transaction,
+            onclause=Transaction.id == recursive_cte.c.transaction_id,
+        )
+        .order_by(recursive_cte.c.time.asc())
+    ).all()
+
+    if result is None:
+        # If there are no transactions for this product, the query should return an empty list, not None.
+        raise RuntimeError(
+            f"Something went wrong while calculating the price log for product {product.name} (ID: {product.id})."
+        )
+
+    return [
+        ProductPriceLogEntry(
+            transaction=row[0],
+            price=row.price,
+            product_count=row.product_count,
+        )
+        for row in result
+    ]
+
+
+def product_price(
+    sql_session: Session,
+    product: Product,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+    include_interest: bool = False,
+) -> int:
+    """
+    Calculates the price of a product.
+    """
+
+    if product.id is None:
+        raise ValueError("Product must be persisted in the database.")
+
+    if isinstance(until_time, datetime):
+        until_time = BindParameter("until_time", value=until_time)
+
+    if isinstance(until_transaction, Transaction):
+        if until_transaction.id is None:
+            raise ValueError("until_transaction must be persisted in the database.")
+        until_transaction_id = bindparam("until_transaction_id", value=until_transaction.id)
+    else:
+        until_transaction_id = None
+
+    recursive_cte = _product_price_query(
+        product.id,
+        use_cache=use_cache,
+        until_time=until_time,
+        until_transaction=until_transaction,
+        until_inclusive=until_inclusive,
+    )
+
+    # TODO: optionally verify subresults:
+    #   - product_count should never be negative (but this happens sometimes, so just a warning)
+    #   - price should never be negative
+
+    # TODO: remove the order_by
+    #       the order_by causes sqlite to build a temp b-tree, even though we
+    #       already have calculated the rows in the correct order, and only need
+    #       to take the last one. I think it *should* be possible to do this, but
+    #       I couldn't figure out a good way to do it.
+    result = sql_session.scalars(
+        select(recursive_cte.c.price)
+        .select_from(recursive_cte)
+        .order_by(recursive_cte.c.time.desc())
+        .limit(CONST_ONE)
+        .offset(CONST_ZERO)
+    ).one_or_none()
+
+    if result is None:
+        # If there are no transactions for this product, the query should return 0, not None.
+        raise RuntimeError(
+            f"Something went wrong while calculating the price for product {product.name} (ID: {product.id})."
+        )
+
+    if include_interest:
+        interest_rate = (
+            sql_session.scalar(
+                select(Transaction.interest_rate_percent)
+                .where(
+                    Transaction.type_ == TransactionType.ADJUST_INTEREST,
+                    until_filter(
+                        until_time=until_time,
+                        until_transaction_id=until_transaction_id,
+                        until_inclusive=until_inclusive,
+                    ),
+                )
+                .order_by(Transaction.time.desc())
+                .limit(CONST_ONE)
+            )
+            or DEFAULT_INTEREST_RATE_PERCENT
+        )
+        result = math.ceil(result * interest_rate / 100)
+
+    return result

dibbler/queries/product_stock.py

@@ -0,0 +1,126 @@
+from datetime import datetime
+from typing import Tuple
+
+from sqlalchemy import (
+    BindParameter,
+    Select,
+    bindparam,
+    case,
+    func,
+    select,
+)
+from sqlalchemy.orm import Session
+
+from dibbler.models import (
+    Product,
+    Transaction,
+    TransactionType,
+)
+from dibbler.queries.query_helpers import until_filter
+
+
+def _product_stock_query(
+    product_id: BindParameter[int] | int,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+) -> Select[Tuple[int]]:
+    """
+    The inner query for calculating the product stock.
+    """
+
+    if use_cache:
+        print("WARNING: Using cache for product stock query is not implemented yet.")
+
+    if isinstance(product_id, int):
+        product_id = BindParameter("product_id", value=product_id)
+
+    if not (until_time is None or until_transaction is None):
+        raise ValueError("Cannot filter by both until_time and until_transaction.")
+
+    if isinstance(until_time, datetime):
+        until_time = BindParameter("until_time", value=until_time)
+
+    if isinstance(until_transaction, Transaction):
+        if until_transaction.id is None:
+            raise ValueError("until_transaction must be persisted in the database.")
+        until_transaction_id = bindparam("until_transaction_id", value=until_transaction.id)
+    else:
+        until_transaction_id = None
+
+    query = select(
+        func.sum(
+            case(
+                (
+                    Transaction.type_ == TransactionType.ADD_PRODUCT.as_literal_column(),
+                    Transaction.product_count,
+                ),
+                (
+                    Transaction.type_ == TransactionType.ADJUST_STOCK.as_literal_column(),
+                    Transaction.product_count,
+                ),
+                (
+                    Transaction.type_ == TransactionType.BUY_PRODUCT.as_literal_column(),
+                    -Transaction.product_count,
+                ),
+                (
+                    Transaction.type_ == TransactionType.JOINT.as_literal_column(),
+                    -Transaction.product_count,
+                ),
+                (
+                    Transaction.type_ == TransactionType.THROW_PRODUCT.as_literal_column(),
+                    -Transaction.product_count,
+                ),
+                else_=0,
+            )
+        ).label("stock")
+    ).where(
+        Transaction.type_.in_(
+            [
+                TransactionType.ADD_PRODUCT.as_literal_column(),
+                TransactionType.ADJUST_STOCK.as_literal_column(),
+                TransactionType.BUY_PRODUCT.as_literal_column(),
+                TransactionType.JOINT.as_literal_column(),
+                TransactionType.THROW_PRODUCT.as_literal_column(),
+            ]
+        ),
+        Transaction.product_id == product_id,
+        until_filter(
+            until_time=until_time,
+            until_transaction_id=until_transaction_id,
+            until_inclusive=until_inclusive,
+        ),
+    )
+
+    return query
+
+
+def product_stock(
+    sql_session: Session,
+    product: Product,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+) -> int:
+    """
+    Returns the number of products in stock.
+
+    If 'until' is given, only transactions up to that time are considered.
+    """
+
+    if product.id is None:
+        raise ValueError("Product must be persisted in the database.")
+
+    query = _product_stock_query(
+        product_id=product.id,
+        use_cache=use_cache,
+        until_time=until_time,
+        until_transaction=until_transaction,
+        until_inclusive=until_inclusive,
+    )
+
+    result = sql_session.scalars(query).one_or_none()
+
+    return result or 0

dibbler/queries/query_helpers.py

@@ -0,0 +1,80 @@
+from datetime import datetime
+from typing import TypeVar
+
+from sqlalchemy import (
+    BindParameter,
+    ColumnExpressionArgument,
+    literal,
+    select,
+)
+from sqlalchemy.orm import QueryableAttribute
+
+from dibbler.models import Transaction
+
+T = TypeVar("T")
+
+
+def const(value: T) -> BindParameter[T]:
+    """
+    Create a constant SQL literal bind parameter.
+
+    This is useful to avoid too many `?` bind parameters in SQL queries,
+    when the input value is known to be safe.
+    """
+
+    return literal(value, literal_execute=True)
+
+
+CONST_ZERO: BindParameter[int] = const(0)
+"""A constant SQL expression `0`. This will render as a literal `0` in SQL queries."""
+
+CONST_ONE: BindParameter[int] = const(1)
+"""A constant SQL expression `1`. This will render as a literal `1` in SQL queries."""
+
+CONST_TRUE: BindParameter[bool] = const(True)
+"""A constant SQL expression `TRUE`. This will render as a literal `TRUE` in SQL queries."""
+
+CONST_FALSE: BindParameter[bool] = const(False)
+"""A constant SQL expression `FALSE`. This will render as a literal `FALSE` in SQL queries."""
+
+CONST_NONE: BindParameter[None] = const(None)
+"""A constant SQL expression `NULL`. This will render as a literal `NULL` in SQL queries."""
+
+
+def until_filter(
+    until_time: BindParameter[datetime] | None = None,
+    until_transaction_id: BindParameter[int] | None = None,
+    until_inclusive: bool = True,
+    transaction_time: QueryableAttribute = Transaction.time,
+) -> ColumnExpressionArgument[bool]:
+    """
+    Create a filter condition for transactions up to a given time or transaction.
+
+    Only one of `until_time` or `until_transaction_id` may be specified.
+    """
+
+    assert not (until_time is not None and until_transaction_id is not None), (
+        "Cannot filter by both until_time and until_transaction_id."
+    )
+
+    match (until_time, until_transaction_id, until_inclusive):
+        case (BindParameter(), None, True):
+            return transaction_time <= until_time
+        case (BindParameter(), None, False):
+            return transaction_time < until_time
+        case (None, BindParameter(), True):
+            return (
+                transaction_time
+                <= select(Transaction.time)
+                .where(Transaction.id == until_transaction_id)
+                .scalar_subquery()
+            )
+        case (None, BindParameter(), False):
+            return (
+                transaction_time
+                < select(Transaction.time)
+                .where(Transaction.id == until_transaction_id)
+                .scalar_subquery()
+            )
+
+    return CONST_TRUE

dibbler/queries/search_product.py

@@ -0,0 +1,42 @@
+from sqlalchemy import and_, literal, not_, or_, select
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product
+
+
+def search_product(
+    string: str,
+    sql_session: Session,
+    find_hidden_products=False,
+) -> Product | list[Product]:
+    if not string:
+        raise ValueError("Search string cannot be empty.")
+
+    exact_match = sql_session.scalars(
+        select(Product).where(
+            or_(
+                Product.bar_code == string,
+                and_(
+                    Product.name == string,
+                    literal(True) if find_hidden_products else not_(Product.hidden),
+                ),
+            )
+        )
+    ).first()
+
+    if exact_match:
+        return exact_match
+
+    product_list = sql_session.scalars(
+        select(Product).where(
+            or_(
+                Product.bar_code.ilike(f"%{string}%"),
+                and_(
+                    Product.name.ilike(f"%{string}%"),
+                    literal(True) if find_hidden_products else not_(Product.hidden),
+                ),
+            )
+        )
+    ).all()
+
+    return list(product_list)

dibbler/queries/search_user.py

@@ -0,0 +1,39 @@
+from sqlalchemy import or_, select
+from sqlalchemy.orm import Session
+
+from dibbler.models import User
+
+
+def search_user(
+    string: str,
+    sql_session: Session,
+) -> User | list[User]:
+    if not string:
+        raise ValueError("Search string cannot be empty.")
+
+    string = string.lower()
+
+    exact_match = sql_session.scalars(
+        select(User).where(
+            or_(
+                User.name == string,
+                User.card == string,
+                User.rfid == string,
+            )
+        )
+    ).first()
+
+    if exact_match:
+        return exact_match
+
+    user_list = sql_session.scalars(
+        select(User).where(
+            or_(
+                User.name.ilike(f"%{string}%"),
+                User.card.ilike(f"%{string}%"),
+                User.rfid.ilike(f"%{string}%"),
+            )
+        )
+    ).all()
+
+    return list(user_list)

dibbler/queries/throw_product.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, Transaction, User
+
+
+def throw_product(
+    sql_session: Session,
+    user: User,
+    product: Product,
+    product_count: int,
+    time: datetime | None = None,
+    message: str | None = None,
+) -> Transaction:
+    if user.id is None:
+        raise ValueError("User must be persisted in the database.")
+
+    if product.id is None:
+        raise ValueError("Product must be persisted in the database.")
+
+    if product_count <= 0:
+        raise ValueError("Product count must be positive.")
+
+    # TODO: verify time is not behind last transaction's time
+
+    raise NotImplementedError(
+        "Please don't use this function until relevant calculations have been added to user_balance."
+    )
+
+    transaction = Transaction.throw_product(
+        user_id=user.id,
+        product_id=product.id,
+        product_count=product_count,
+        time=time,
+        message=message,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()
+
+    return transaction

dibbler/queries/transaction_log.py

@@ -0,0 +1,142 @@
+from datetime import datetime
+
+from sqlalchemy import BindParameter, select
+from sqlalchemy.orm import Session
+
+from dibbler.models import (
+    Product,
+    Transaction,
+    TransactionType,
+    User,
+)
+
+
+# TODO: should this include full joint transactions that involve a user?
+# TODO: should this involve throw-away transactions that affects a user?
+def transaction_log(
+    sql_session: Session,
+    user: User | None = None,
+    product: Product | None = None,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+    after_time: BindParameter[datetime] | datetime | None = None,
+    after_transaction: Transaction | None = None,
+    after_inlcusive: bool = True,
+    transaction_type: list[TransactionType] | None = None,
+    negate_transaction_type_filter: bool = False,
+    limit: int | None = None,
+) -> list[Transaction]:
+    """
+    Retrieve the transaction log, optionally filtered.
+
+    Only one of `user` or `product` may be specified.
+    Only one of `until_time` or `until_transaction_id` may be specified.
+    Only one of `after_time` or `after_transaction_id` may be specified.
+
+    The after and after filters are inclusive by default.
+    """
+
+    if not (user is None or product is None):
+        raise ValueError("Cannot filter by both user and product.")
+
+    if isinstance(user, User):
+        if user.id is None:
+            raise ValueError("User must be persisted in the database.")
+        user_id = BindParameter("user_id", value=user.id)
+    else:
+        user_id = None
+
+    if isinstance(product, Product):
+        if product.id is None:
+            raise ValueError("Product must be persisted in the database.")
+        product_id = BindParameter("product_id", value=product.id)
+    else:
+        product_id = None
+
+    if not (until_time is None or until_transaction is None):
+        raise ValueError("Cannot filter by both after_time and after_transaction_id.")
+
+    if isinstance(until_time, datetime):
+        until_time = BindParameter("until_time", value=until_time)
+
+    if isinstance(until_transaction, Transaction):
+        if until_transaction.id is None:
+            raise ValueError("until_transaction must be persisted in the database.")
+        until_transaction_id = BindParameter("until_transaction_id", value=until_transaction.id)
+    else:
+        until_transaction_id = None
+
+    if not (after_time is None or after_transaction is None):
+        raise ValueError("Cannot filter by both after_time and after_transaction_id.")
+
+    if isinstance(after_time, datetime):
+        after_time = BindParameter("after_time", value=after_time)
+
+    if isinstance(after_transaction, Transaction):
+        if after_transaction.id is None:
+            raise ValueError("after_transaction must be persisted in the database.")
+        after_transaction_id = BindParameter("after_transaction_id", value=after_transaction.id)
+    else:
+        after_transaction_id = None
+
+    if after_time is not None and until_time is not None:
+        assert isinstance(after_time.value, datetime)
+        assert isinstance(until_time.value, datetime)
+
+        if after_time.value > until_time.value:
+            raise ValueError("after_time cannot be after until_time.")
+
+    if after_transaction is not None and until_transaction is not None:
+        assert after_transaction.time is not None
+        assert until_transaction.time is not None
+
+        if after_transaction.time > until_transaction.time:
+            raise ValueError("after_transaction cannot be after until_transaction.")
+
+    if limit is not None and limit <= 0:
+        raise ValueError("Limit must be positive.")
+
+    query = select(Transaction)
+    if user is not None:
+        query = query.where(Transaction.user_id == user_id)
+    if product is not None:
+        query = query.where(Transaction.product_id == product_id)
+
+    match (until_time, until_transaction_id, until_inclusive):
+        case (BindParameter(), None, True):
+            query = query.where(Transaction.time <= until_time)
+        case (BindParameter(), None, False):
+            query = query.where(Transaction.time < until_time)
+        case (None, BindParameter(), True):
+            query = query.where(Transaction.id <= until_transaction_id)
+        case (None, BindParameter(), False):
+            query = query.where(Transaction.id < until_transaction_id)
+        case _:
+            pass
+
+    match (after_time, after_transaction_id, after_inlcusive):
+        case (BindParameter(), None, True):
+            query = query.where(Transaction.time >= after_time)
+        case (BindParameter(), None, False):
+            query = query.where(Transaction.time > after_time)
+        case (None, BindParameter(), True):
+            query = query.where(Transaction.id >= after_transaction_id)
+        case (None, BindParameter(), False):
+            query = query.where(Transaction.id > after_transaction_id)
+        case _:
+            pass
+
+    if transaction_type is not None:
+        if negate_transaction_type_filter:
+            query = query.where(~Transaction.type_.in_(transaction_type))
+        else:
+            query = query.where(Transaction.type_.in_(transaction_type))
+
+    if limit is not None:
+        query = query.limit(limit)
+
+    query = query.order_by(Transaction.time.asc(), Transaction.id.asc())
+    result = sql_session.scalars(query).all()
+
+    return list(result)

dibbler/queries/transfer.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import Transaction, User
+
+
+def transfer(
+    sql_session: Session,
+    from_user: User,
+    to_user: User,
+    amount: int,
+    time: datetime | None = None,
+    message: str | None = None,
+) -> Transaction:
+    if from_user.id is None:
+        raise ValueError("From user must be persisted in the database.")
+
+    if to_user.id is None:
+        raise ValueError("To user must be persisted in the database.")
+
+    if amount <= 0:
+        raise ValueError("Amount must be positive.")
+
+    # TODO: verify time is not behind last transaction's time
+
+    transaction = Transaction.transfer(
+        user_id=from_user.id,
+        transfer_user_id=to_user.id,
+        amount=amount,
+        time=time,
+        message=message,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()
+
+    return transaction

dibbler/queries/user_balance.py

@@ -0,0 +1,566 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Tuple
+
+from sqlalchemy import (
+    CTE,
+    BindParameter,
+    Float,
+    Integer,
+    Select,
+    and_,
+    bindparam,
+    case,
+    cast,
+    column,
+    func,
+    or_,
+    select,
+)
+from sqlalchemy.orm import Session, aliased
+from sqlalchemy.sql.elements import KeyedColumnElement
+
+from dibbler.models import (
+    Transaction,
+    TransactionType,
+    User,
+)
+from dibbler.models.Transaction import (
+    DEFAULT_INTEREST_RATE_PERCENT,
+    DEFAULT_PENALTY_MULTIPLIER_PERCENT,
+    DEFAULT_PENALTY_THRESHOLD,
+)
+from dibbler.queries.product_price import _product_price_query
+from dibbler.queries.query_helpers import (
+    CONST_NONE,
+    CONST_ONE,
+    CONST_ZERO,
+    const,
+    until_filter,
+)
+
+
+def _joint_transaction_query(
+    user_id: BindParameter[int] | int,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+) -> Select[Tuple[int, int, int]]:
+    """
+    The inner query for getting joint transactions relevant to a user.
+
+    This scans for JOINT_BUY_PRODUCT transactions made by the user,
+    then finds the corresponding JOINT transactions, and counts how many "shares"
+    of the joint transaction the user has, as well as the total number of shares.
+    """
+
+    if isinstance(until_transaction, Transaction):
+        if until_transaction.id is None:
+            raise ValueError("until_transaction must be persisted in the database.")
+        until_transaction_id = bindparam("until_transaction_id", value=until_transaction.id)
+    else:
+        until_transaction_id = None
+
+    # First, select all joint buy product transactions for the given user
+    # sub_joint_transaction = aliased(Transaction, name="right_trx")
+    sub_joint_transaction = (
+        select(Transaction.joint_transaction_id.distinct().label("joint_transaction_id"))
+        .where(
+            Transaction.type_ == TransactionType.JOINT_BUY_PRODUCT.as_literal_column(),
+            Transaction.user_id == user_id,
+            until_filter(
+                until_time=until_time,
+                until_transaction_id=until_transaction_id,
+                until_inclusive=until_inclusive,
+                transaction_time=Transaction.time,
+            ),
+        )
+        .subquery("sub_joint_transaction")
+    )
+
+    # Join those with their main joint transaction
+    # (just use Transaction)
+
+    # Then, count how many users are involved in each joint transaction
+    joint_transaction_count = aliased(Transaction, name="count_trx")
+
+    joint_transaction = (
+        select(
+            Transaction.id,
+            # Shares the user has in the transaction,
+            func.sum(
+                case(
+                    (joint_transaction_count.user_id == user_id, CONST_ONE),
+                    else_=CONST_ZERO,
+                )
+            ).label("user_shares"),
+            # The total number of shares in the transaction,
+            func.count(joint_transaction_count.id).label("user_count"),
+        )
+        .select_from(sub_joint_transaction)
+        .join(
+            Transaction,
+            onclause=Transaction.id == sub_joint_transaction.c.joint_transaction_id,
+        )
+        .join(
+            joint_transaction_count,
+            onclause=joint_transaction_count.joint_transaction_id == Transaction.id,
+        )
+        .group_by(joint_transaction_count.joint_transaction_id)
+    )
+
+    return joint_transaction
+
+
+def _non_joint_transaction_query(
+    user_id: BindParameter[int] | int,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+) -> Select[Tuple[int, None, None]]:
+    """
+    The inner query for getting non-joint transactions relevant to a user.
+    """
+
+    if isinstance(until_transaction, Transaction):
+        if until_transaction.id is None:
+            raise ValueError("until_transaction must be persisted in the database.")
+        until_transaction_id = bindparam("until_transaction_id", value=until_transaction.id)
+    else:
+        until_transaction_id = None
+
+    query = select(
+        Transaction.id,
+        CONST_NONE.label("user_shares"),
+        CONST_NONE.label("user_count"),
+    ).where(
+        or_(
+            and_(
+                Transaction.user_id == user_id,
+                Transaction.type_.in_(
+                    [
+                        TransactionType.ADD_PRODUCT.as_literal_column(),
+                        TransactionType.ADJUST_BALANCE.as_literal_column(),
+                        TransactionType.BUY_PRODUCT.as_literal_column(),
+                        TransactionType.TRANSFER.as_literal_column(),
+                    ]
+                ),
+            ),
+            and_(
+                Transaction.type_ == TransactionType.TRANSFER.as_literal_column(),
+                Transaction.transfer_user_id == user_id,
+            ),
+            Transaction.type_.in_(
+                [
+                    TransactionType.THROW_PRODUCT.as_literal_column(),
+                    TransactionType.ADJUST_INTEREST.as_literal_column(),
+                    TransactionType.ADJUST_PENALTY.as_literal_column(),
+                ]
+            ),
+        ),
+        until_filter(
+            until_time=until_time,
+            until_transaction_id=until_transaction_id,
+            until_inclusive=until_inclusive,
+        ),
+    )
+
+    return query
+
+
+def _product_cost_expression(
+    product_count_column: KeyedColumnElement[int],
+    product_id_column: KeyedColumnElement[int],
+    interest_rate_percent_column: KeyedColumnElement[int],
+    user_balance_column: KeyedColumnElement[int],
+    penalty_threshold_column: KeyedColumnElement[int],
+    penalty_multiplier_percent_column: KeyedColumnElement[int],
+    joint_user_shares_column: KeyedColumnElement[int],
+    joint_user_count_column: KeyedColumnElement[int],
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+    cte_name: str = "product_price_cte",
+    trx_subset_name: str = "product_price_trx_subset",
+):
+    # TODO: This can get quite expensive real quick, so we should do some caching of the
+    #       product prices somehow.
+    expression = (
+        select(
+            cast(
+                func.ceil(
+                    # Base price
+                    (
+                        cast(
+                            column("price") * product_count_column * joint_user_shares_column,
+                            Float,
+                        )
+                        / joint_user_count_column
+                    )
+                    # Interest
+                    + (
+                        cast(
+                            column("price") * product_count_column * joint_user_shares_column,
+                            Float,
+                        )
+                        / joint_user_count_column
+                        * cast(interest_rate_percent_column - const(100), Float)
+                        / const(100.0)
+                    )
+                    # Penalty
+                    + (
+                        (
+                            cast(
+                                column("price") * product_count_column * joint_user_shares_column,
+                                Float,
+                            )
+                            / joint_user_count_column
+                        )
+                        * cast(penalty_multiplier_percent_column - const(100), Float)
+                        / const(100.0)
+                        * cast(user_balance_column < penalty_threshold_column, Integer)
+                    )
+                ),
+                Integer,
+            )
+        )
+        .select_from(
+            _product_price_query(
+                product_id_column,
+                use_cache=use_cache,
+                until_time=until_time,
+                until_transaction=until_transaction,
+                until_inclusive=until_inclusive,
+                cte_name=cte_name,
+                trx_subset_name=trx_subset_name,
+            )
+        )
+        .order_by(column("time").desc())
+        .limit(CONST_ONE)
+        .scalar_subquery()
+    )
+
+    return expression
+
+
+def _user_balance_query(
+    user_id: BindParameter[int] | int,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+    cte_name: str = "rec_cte",
+    trx_subset_name: str = "trx_subset",
+) -> CTE:
+    """
+    The inner query for calculating the user's balance.
+    """
+
+    if use_cache:
+        print("WARNING: Using cache for user balance query is not implemented yet.")
+
+    if isinstance(user_id, int):
+        user_id = BindParameter("user_id", value=user_id)
+
+    initial_element = select(
+        CONST_ZERO.label("i"),
+        CONST_ZERO.label("time"),
+        CONST_NONE.label("transaction_id"),
+        CONST_ZERO.label("balance"),
+        const(DEFAULT_INTEREST_RATE_PERCENT).label("interest_rate_percent"),
+        const(DEFAULT_PENALTY_THRESHOLD).label("penalty_threshold"),
+        const(DEFAULT_PENALTY_MULTIPLIER_PERCENT).label("penalty_multiplier_percent"),
+    )
+
+    recursive_cte = initial_element.cte(name=cte_name, recursive=True)
+
+    trx_subset_subset = (
+        _non_joint_transaction_query(
+            user_id=user_id,
+            use_cache=use_cache,
+            until_time=until_time,
+            until_transaction=until_transaction,
+            until_inclusive=until_inclusive,
+        )
+        .union_all(
+            _joint_transaction_query(
+                user_id=user_id,
+                use_cache=use_cache,
+                until_time=until_time,
+                until_transaction=until_transaction,
+                until_inclusive=until_inclusive,
+            )
+        )
+        .subquery(f"{trx_subset_name}_subset")
+    )
+
+    # Subset of transactions that we'll want to iterate over.
+    trx_subset = (
+        select(
+            func.row_number().over(order_by=Transaction.time.asc()).label("i"),
+            Transaction.id,
+            Transaction.amount,
+            Transaction.interest_rate_percent,
+            Transaction.penalty_multiplier_percent,
+            Transaction.penalty_threshold,
+            Transaction.product_count,
+            Transaction.product_id,
+            Transaction.time,
+            Transaction.transfer_user_id,
+            Transaction.type_,
+            trx_subset_subset.c.user_shares,
+            trx_subset_subset.c.user_count,
+        )
+        .select_from(trx_subset_subset)
+        .join(
+            Transaction,
+            onclause=Transaction.id == trx_subset_subset.c.id,
+        )
+        .subquery(trx_subset_name)
+    )
+
+    recursive_elements = (
+        select(
+            trx_subset.c.i,
+            trx_subset.c.time,
+            trx_subset.c.id.label("transaction_id"),
+            case(
+                # Adjusts balance -> balance gets adjusted
+                (
+                    trx_subset.c.type_ == TransactionType.ADJUST_BALANCE.as_literal_column(),
+                    recursive_cte.c.balance + trx_subset.c.amount,
+                ),
+                # Adds a product -> balance increases
+                (
+                    trx_subset.c.type_ == TransactionType.ADD_PRODUCT.as_literal_column(),
+                    recursive_cte.c.balance + trx_subset.c.amount,
+                ),
+                # Buys a product -> balance decreases
+                (
+                    trx_subset.c.type_ == TransactionType.BUY_PRODUCT.as_literal_column(),
+                    recursive_cte.c.balance
+                    - _product_cost_expression(
+                        product_count_column=trx_subset.c.product_count,
+                        product_id_column=trx_subset.c.product_id,
+                        interest_rate_percent_column=recursive_cte.c.interest_rate_percent,
+                        user_balance_column=recursive_cte.c.balance,
+                        penalty_threshold_column=recursive_cte.c.penalty_threshold,
+                        penalty_multiplier_percent_column=recursive_cte.c.penalty_multiplier_percent,
+                        joint_user_shares_column=CONST_ONE,
+                        joint_user_count_column=CONST_ONE,
+                        use_cache=use_cache,
+                        until_time=until_time,
+                        until_transaction=until_transaction,
+                        until_inclusive=until_inclusive,
+                        cte_name=f"{cte_name}_price",
+                        trx_subset_name=f"{trx_subset_name}_price",
+                    ).label("product_cost"),
+                ),
+                # Joint transaction -> balance decreases proportionally
+                (
+                    trx_subset.c.type_ == TransactionType.JOINT.as_literal_column(),
+                    recursive_cte.c.balance
+                    - _product_cost_expression(
+                        product_count_column=trx_subset.c.product_count,
+                        product_id_column=trx_subset.c.product_id,
+                        interest_rate_percent_column=recursive_cte.c.interest_rate_percent,
+                        user_balance_column=recursive_cte.c.balance,
+                        penalty_threshold_column=recursive_cte.c.penalty_threshold,
+                        penalty_multiplier_percent_column=recursive_cte.c.penalty_multiplier_percent,
+                        joint_user_shares_column=trx_subset.c.user_shares,
+                        joint_user_count_column=trx_subset.c.user_count,
+                        use_cache=use_cache,
+                        until_time=until_time,
+                        until_transaction=until_transaction,
+                        until_inclusive=until_inclusive,
+                        cte_name=f"{cte_name}_joint_price",
+                        trx_subset_name=f"{trx_subset_name}_joint_price",
+                    ).label("joint_product_cost"),
+                ),
+                # Transfers money to self ->  balance increases
+                (
+                    and_(
+                        trx_subset.c.type_ == TransactionType.TRANSFER.as_literal_column(),
+                        trx_subset.c.transfer_user_id == user_id,
+                    ),
+                    recursive_cte.c.balance + trx_subset.c.amount,
+                ),
+                # Transfers money from self ->  balance decreases
+                (
+                    and_(
+                        trx_subset.c.type_ == TransactionType.TRANSFER.as_literal_column(),
+                        trx_subset.c.transfer_user_id != user_id,
+                    ),
+                    recursive_cte.c.balance - trx_subset.c.amount,
+                ),
+                # Throws a product -> if the user is considered to have bought it, balance increases
+                # TODO: # (
+                #     trx_subset.c.type_ == TransactionType.THROW_PRODUCT,
+                #     recursive_cte.c.balance + trx_subset.c.amount,
+                # ),
+                # Interest adjustment -> balance stays the same
+                # Penalty adjustment -> balance stays the same
+                else_=recursive_cte.c.balance,
+            ).label("balance"),
+            case(
+                (
+                    trx_subset.c.type_ == TransactionType.ADJUST_INTEREST.as_literal_column(),
+                    trx_subset.c.interest_rate_percent,
+                ),
+                else_=recursive_cte.c.interest_rate_percent,
+            ).label("interest_rate_percent"),
+            case(
+                (
+                    trx_subset.c.type_ == TransactionType.ADJUST_PENALTY.as_literal_column(),
+                    trx_subset.c.penalty_threshold,
+                ),
+                else_=recursive_cte.c.penalty_threshold,
+            ).label("penalty_threshold"),
+            case(
+                (
+                    trx_subset.c.type_ == TransactionType.ADJUST_PENALTY.as_literal_column(),
+                    trx_subset.c.penalty_multiplier_percent,
+                ),
+                else_=recursive_cte.c.penalty_multiplier_percent,
+            ).label("penalty_multiplier_percent"),
+        )
+        .select_from(trx_subset)
+        .where(trx_subset.c.i == recursive_cte.c.i + CONST_ONE)
+    )
+
+    return recursive_cte.union_all(recursive_elements)
+
+
+# TODO: create a function for the log that pretty prints the log entries
+#       for debugging purposes
+
+
+@dataclass
+class UserBalanceLogEntry:
+    transaction: Transaction
+    balance: int
+    interest_rate_percent: int
+    penalty_threshold: int
+    penalty_multiplier_percent: int
+
+    def is_penalized(self) -> bool:
+        """
+        Returns whether this exact transaction is penalized.
+        """
+
+        raise NotImplementedError("is_penalized is not implemented yet.")
+
+
+def user_balance_log(
+    sql_session: Session,
+    user: User,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+) -> list[UserBalanceLogEntry]:
+    """
+    Returns a log of the user's balance over time, including interest and penalty adjustments.
+
+    If 'until' is given, only transactions up to that time are considered.
+    """
+
+    if user.id is None:
+        raise ValueError("User must be persisted in the database.")
+
+    if not (until_time is None or until_transaction is None):
+        raise ValueError("Cannot filter by both until_time and until_transaction.")
+
+    if isinstance(until_time, datetime):
+        until_time = BindParameter("until_time", value=until_time)
+
+    recursive_cte = _user_balance_query(
+        user.id,
+        use_cache=use_cache,
+        until_time=until_time,
+        until_transaction=until_transaction,
+        until_inclusive=until_inclusive,
+    )
+
+    result = sql_session.execute(
+        select(
+            Transaction,
+            recursive_cte.c.balance,
+            recursive_cte.c.interest_rate_percent,
+            recursive_cte.c.penalty_threshold,
+            recursive_cte.c.penalty_multiplier_percent,
+        )
+        .select_from(recursive_cte)
+        .join(
+            Transaction,
+            onclause=Transaction.id == recursive_cte.c.transaction_id,
+        )
+        .order_by(recursive_cte.c.i.asc())
+    ).all()
+
+    if result is None:
+        # If there are no transactions for this user, the query should return 0, not None.
+        raise RuntimeError(
+            f"Something went wrong while calculating the balance for user {user.name} (ID: {user.id})."
+        )
+
+    return [
+        UserBalanceLogEntry(
+            transaction=row[0],
+            balance=row.balance,
+            interest_rate_percent=row.interest_rate_percent,
+            penalty_threshold=row.penalty_threshold,
+            penalty_multiplier_percent=row.penalty_multiplier_percent,
+        )
+        for row in result
+    ]
+
+
+def user_balance(
+    sql_session: Session,
+    user: User,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+) -> int:
+    """
+    Calculates the balance of a user.
+
+    If 'until' is given, only transactions up to that time are considered.
+    """
+
+    if user.id is None:
+        raise ValueError("User must be persisted in the database.")
+
+    if not (until_time is None or until_transaction is None):
+        raise ValueError("Cannot filter by both until_time and until_transaction.")
+
+    if isinstance(until_time, datetime):
+        until_time = BindParameter("until_time", value=until_time)
+
+    recursive_cte = _user_balance_query(
+        user.id,
+        use_cache=use_cache,
+        until_time=until_time,
+        until_transaction=until_transaction,
+        until_inclusive=until_inclusive,
+    )
+
+    result = sql_session.scalar(
+        select(recursive_cte.c.balance)
+        .order_by(recursive_cte.c.i.desc())
+        .limit(CONST_ONE)
+        .offset(CONST_ZERO)
+    )
+
+    if result is None:
+        # If there are no transactions for this user, the query should return 0, not None.
+        raise RuntimeError(
+            f"Something went wrong while calculating the balance for user {user.name} (ID: {user.id})."
+        )
+
+    return result

dibbler/queries/user_products.py

@@ -0,0 +1,48 @@
+from datetime import datetime
+
+from sqlalchemy import BindParameter, bindparam
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, Transaction, User
+
+# NOTE: This absoulutely needs a cache, else we can't stop recursing until we know all owners for all products...
+#
+# Since we know that the non-owned products will not get renowned by the user by other means,
+# we can just check for ownership on the products that have an ADD_PRODUCT transaction for the user.
+# between now and the cached time.
+#
+# However, the opposite way is more difficult. The cache will store which products are owned by which users,
+# but we still need to check if the user passes out of ownership for the item, without needing to check past
+# the cache time. Maybe we also need to store the queue number(s) per user/product combo in the cache? What if
+# a user has products multiple places in the queue, interleaved with other users?
+
+
+def user_products(
+    sql_session: Session,
+    user: User,
+    use_cache: bool = True,
+    until_time: BindParameter[datetime] | datetime | None = None,
+    until_transaction: Transaction | None = None,
+    until_inclusive: bool = True,
+) -> list[tuple[Product, int]]:
+    """
+    Returns the list of products owned by the user, along with how many of each product they own.
+    """
+
+    if user.id is None:
+        raise ValueError("User must be persisted in the database.")
+
+    if not (until_time is None or until_transaction is None):
+        raise ValueError("Cannot filter by both until_time and until_transaction.")
+
+    if isinstance(until_time, datetime):
+        until_time = BindParameter("until_time", value=until_time)
+
+    if isinstance(until_transaction, Transaction):
+        if until_transaction.id is None:
+            raise ValueError("until_transaction must be persisted in the database.")
+        until_transaction_id = bindparam("until_transaction_id", value=until_transaction.id)
+    else:
+        until_transaction_id = None
+
+    raise NotImplementedError("Not implemented yet, needs caching system first.")

dibbler/subcommands/seed_test_data.py

@@ -1,48 +1,116 @@
-import json
-from dibbler.db import Session
-
+from datetime import datetime
 from pathlib import Path
 
-from dibbler.models.Product import Product
-
-from dibbler.models.User import User
+from dibbler.db import Session
+from dibbler.models import Product, Transaction, User
+from dibbler.queries import joint_buy_product
 
 JSON_FILE = Path(__file__).parent.parent.parent / "mock_data.json"
 
 
-def clear_db(session):
-    session.query(Product).delete()
-    session.query(User).delete()
-    session.commit()
+# TODO: integrate this as a part of create-db, either asking interactively
+#       whether to seed test data, or by using command line arguments for
+#       automatating the answer.
+
+
+def clear_db(sql_session):
+    sql_session.query(Product).delete()
+    sql_session.query(User).delete()
+    sql_session.commit()
 
 
 def main():
-    session = Session()
-    clear_db(session)
-    product_items = []
-    user_items = []
+    # TODO: There is some leftover json data in the mock_data.json file.
+    #       It should be dealt with before merging this PR, either by removing
+    #       it or using it here.
+    sql_session = Session()
+    clear_db(sql_session)
 
-    with open(JSON_FILE) as f:
-        json_obj = json.load(f)
+    # Add users
+    user1 = User("Test User 1")
+    user2 = User("Test User 2")
+    user3 = User("Test User 3")
 
-        for product in json_obj["products"]:
-            product_item = Product(
-                bar_code=product["bar_code"],
-                name=product["name"],
-                price=product["price"],
-                stock=product["stock"],
-            )
-            product_items.append(product_item)
+    sql_session.add(user1)
+    sql_session.add(user2)
+    sql_session.add(user3)
+    sql_session.commit()
 
-        for user in json_obj["users"]:
-            user_item = User(
-                name=user["name"],
-                card=user["card"],
-                rfid=user["rfid"],
-                credit=user["credit"],
-            )
-            user_items.append(user_item)
+    # Add products
+    product1 = Product("1234567890123", "Test Product 1")
+    product2 = Product("9876543210987", "Test Product 2")
+    sql_session.add(product1)
+    sql_session.add(product2)
+    sql_session.commit()
 
-        session.add_all(product_items)
-        session.add_all(user_items)
-        session.commit()
+    # Add transactions
+    transactions = [
+        Transaction.adjust_balance(
+            time=datetime(2023, 10, 1, 10, 0, 0),
+            amount=100,
+            user_id=user1.id,
+        ),
+        Transaction.adjust_balance(
+            time=datetime(2023, 10, 1, 10, 0, 1),
+            amount=50,
+            user_id=user2.id,
+        ),
+        Transaction.adjust_balance(
+            time=datetime(2023, 10, 1, 10, 0, 2),
+            amount=-50,
+            user_id=user1.id,
+        ),
+        Transaction.add_product(
+            time=datetime(2023, 10, 1, 12, 0, 0),
+            amount=27 * 2,
+            per_product=27,
+            product_count=2,
+            user_id=user1.id,
+            product_id=product1.id,
+        ),
+        Transaction.buy_product(
+            time=datetime(2023, 10, 1, 12, 0, 1),
+            product_count=1,
+            user_id=user2.id,
+            product_id=product1.id,
+        ),
+    ]
+
+    sql_session.add_all(transactions)
+    sql_session.flush()
+
+    joint_buy_product(
+        sql_session,
+        time=datetime(2023, 10, 1, 12, 0, 2),
+        instigator=user1,
+        product_count=1,
+        users=[user1, user2, user3],
+        product=product2,
+    )
+
+    joint_buy_product(
+        sql_session,
+        time=datetime(2023, 10, 1, 13, 0, 2),
+        instigator=user3,
+        product_count=2,
+        users=[user2, user3],
+        product=product2,
+    )
+
+    transactions = [
+        Transaction.buy_product(
+            time=datetime(2023, 10, 2, 14, 0, 0),
+            product_count=1,
+            user_id=user1.id,
+            product_id=product1.id,
+        ),
+        Transaction.buy_product(
+            time=datetime(2023, 10, 2, 14, 0, 1),
+            product_count=1,
+            user_id=user2.id,
+            product_id=product2.id,
+        ),
+    ]
+
+    sql_session.add_all(transactions)
+    sql_session.commit()

dibbler/subcommands/transaction_log.py

@@ -0,0 +1,16 @@
+from dibbler.db import Session
+from dibbler.queries import transaction_log
+from dibbler.lib.render_transaction_log import render_transaction_log
+
+
+def main() -> None:
+    sql_session = Session()
+
+    result = transaction_log(sql_session)
+    rendered = render_transaction_log(result)
+
+    print(rendered)
+
+
+if __name__ == "__main__":
+    main()

docs/economics.md

@@ -0,0 +1,263 @@
+# Dibbler economy spec v1
+
+This document provides an overview of how dibbler counts and calculates its running event log.
+
+It is a sort of semi-formal specification for how dibbler's economy is intended to work, and is useful for both users and developers to understand the underlying mechanics.
+
+## Some general notes
+
+- All calculations involving money are done in whole numbers (integers). There are no fractional krs.
+- All rounding is done by rounding up to the nearest integer, in favor of the system economy - not the users.
+- All rounding is done as late as possible in calculations, to avoid rounding errors accumulating.
+- The system allows negative stock counts, but acts a bit weirdly and potentially unfairly when that happens.
+  The system should generally warn you about this, and recommend recounting the stock whenever it happens.
+- Throughout the document, the penalty multiplier and interest rate are expressed as percentages in int (e.g. `penalty_multiplier = 150` means the prices should be multiplied by `1.5`, and `interest_rate = 120` means the prices should be multiplied by `1.2`).
+
+## Adding products - product stock and product price
+
+This section covers what happens to the stock count and price of a product when a user adds more of that product to the system.
+
+### Calculating the total value of products added
+
+When a user adds a product, the resulting product price is averaged over the new products and the existing products. However, the new product price will become an integer. To avoid the economy going downwards, we round up the price after doing the averaging - i.e. in favor of the system, not the users.
+
+### When the product count is `0` before adding.
+
+When the product count is `0`, adding more of that product sets the product count to the amount added, and the product price will be set to the price of all products added divided by the number of products added, rounded up to the nearest integer.
+
+```python
+new_product_count: int = products_added
+new_product_price: int = math.ceil(total_value_of_products_added / products_added)
+```
+
+### When the product count is greater than `0` before adding.
+
+When the product count is greater than `0`, adding more of that product increases the product count by the amount added, and the product price will be recalculated as the total value of all existing products plus the total value of all newly added products, divided by the new total product count, rounded up to the nearest integer.
+
+```python
+new_product_count: int = product_count + products_added
+new_product_price: int = math.ceil((product_price * product_count + total_value_of_new_products_added) / new_product_count)
+```
+
+### When the product count is less than `0` before adding.
+
+> [!NOTE]
+> This situation can happen when the product count in the system does not accurately reflect the real-world stock of that product.
+> This sometimes happens when people throw away product that have gone bad, or if someone buys something and forgets to actually take it from the shelf.
+
+When the product count is less than `0`, adding more of that product increases the product count by the amount added. The product price will be recalculated with an assumption that the existing negative stock has a total value of `0`, plus the total value of all newly added products.
+
+> [!WARN]
+> Note that this means that if you add products to a negative stock and the stock is still negative,
+> the product price will be completely recalculated the next time someone adds the same product.
+> There will also be a noticable effect if the stock goes from negative to positive.
+
+```python
+new_product_count: int = product_count + products_added
+new_product_price: int = math.ceil(((product_price * max(product_count, 0)) + (total_value_of_new_products_added)) / new_product_count)
+```
+
+### A note about adding `0` items
+
+If a user attempts to add `0` items of a product, the system will not change the product count or price, and no transaction will be recorded.
+
+
+## Buying products - product stock
+
+### When the product count is positive and you buy less than or equal to the stock count
+
+When the product count is positive and a user buys an amount less than or equal to the current stock count, the product stock count will be decreased by the amount bought.
+
+```python
+new_product_count: int = product_count - products_bought
+```
+
+### When the product count is positive or `0` and you buy more than there are in stock
+
+When the product count is positive and a user buys an amount greater than the current stock count, the product stock count will be decreased by the amount bought, resulting in a negative stock count.
+
+```python
+new_product_count: int = product_count - products_bought
+```
+
+> [!NOTE]
+> This should also yield a warning, recommending the user to adjust the stock count for the product in question.
+
+### Buying from negative stock
+
+When the product count is negative, buying more of that product will further decrease the product stock count.
+
+```python
+new_product_count: int = product_count - products_bought
+```
+
+> [!NOTE]
+> This should also yield a warning, recommending the user to adjust the stock count for the product in question.
+
+### Buying items with joint transactions.
+
+The same rules as above apply for all 3 cases.
+
+### Note about buying `0` items
+
+If a user attempts to buy `0` items of a product, the system will not change the product count or price, and no transaction will be recorded.
+
+
+## Interest and penalty
+
+### What is interest, and why do we need it
+
+We have had some issues with the economy going in the negative, most likely due to users throwing away products gone bad. When the economy goes negative, we end up in a situation where users have money but there aren't really any products to buy, because the users don't have the incentive to add products back into the system to gain more balance.
+
+To readjust the economy over time, there is an interest rate that will increase the amount you pay for each product by a certain percentage (the interest rate). This percentage can be adjusted by administrators when they see that the economy needs fixing. By default, the interest rate is set to `100%` (i.e., you don't pay anything extra).
+
+> [!NOTE]
+> You can not go below `100%` interest rate.
+
+### What is penalty, and why do we need it
+
+We currently allow users to go into negative balance when buying products. This is useful when you're having a great time at hacking night or similar, and don't want to be stopped by a low balance. However, to avoid users going too deep into negative balance, we make the cost of the product multiply by a penalty multiplier once the user's balance goes below a certain threshold. This penalty multiplier and threshold can be adjusted by administrators. By default, the threshold is set to `-100` krs, and the penalty multiplier is set to `200%` (i.e. you pay double the amount of money for products once your balance goes below `-100` krs).
+
+The penalty starts counting as soon as your balance goes below the threshold, not when it is equal to the threshold.
+
+> [!NOTE]
+> You can not set the penalty multiplier to below `100%` (that would be a rebate, not a penalty),
+> and you can not set the penalty threshold to above `0` krs (we do not punish people for having money).
+
+## Adding products - user balance
+
+### When your existing balance is above the penalty threshold
+
+You gain balance equal to the total value of the products you add.
+
+Note that this might be separate from the per-product cost of the products after you add them, due to rounding and price recalculation.
+
+```python
+new_user_balance: int = user_balance + total_value_of_products_added
+
+assert total_value_of_new_products_added >= product_price * products_added
+```
+
+### When your existing balance is below the penalty threshold
+
+This case is the same as above.
+
+
+## Buying products - user balance
+
+### When your existing balance is above the penalty threshold, and the purchase does not push you below the threshold
+
+You pay the normal product price for the products you buy, plus any interest.
+
+```python
+new_user_balance: int = user_balance - math.ceil(products_bought * product_price * (interest_rate / 100))
+```
+
+Note that the system performs a transaction for every product kind, so if you buy multiple different products in one go, the rounding is done per product kind.
+
+### When your balance is below the penalty threshold before buying
+
+You pay the penalized product price for the products you buy, plus any interest.
+
+The interest and penalty are calculated separately before they are added together, *not* multiplied together.
+
+```python
+base_cost: float = product_price * products_bought
+penalty: float = (base_cost * (penalty_multiplier / 100)) - base_cost
+interest: float = (base_cost * (interest_rate / 100)) - base_cost
+new_user_balance: int = user_balance - math.ceil(base_cost + penalty + interest)
+```
+
+### When your balance is above the penalty threshold before buying, but the purchase pushes you below the threshold
+
+When your balance is above the penalty threshold before buying, but the purchase pushes you below the threshold, the system not apply any penalty for the purchase. The entire purchase is done at the normal product price plus any interest.
+
+```python
+new_user_balance: int = user_balance - math.ceil(products_bought * product_price * (interest_rate / 100))
+```
+
+> [!NOTE]
+> In the case where you are performing multiple transactions at once, the system should try its best to order the purchases in a way that minimizes the amount of penalties you need to pay.
+
+### Joint purchases, when all users are above the penalty threshold and stays above the threshold
+
+When making joint purchases (multiple users buying products together), and all users are above the penalty threshold before and after the purchase, the total cost (including interest) will be split equally between all users. The price will be rounded up for each user after splitting the bill.
+
+```python
+total_cost: float = product_price * products_bought * (interest_rate / 100)
+cost_per_user: float = total_cost / number_of_users
+new_user_balance = user_balance - math.ceil(cost_per_user)
+```
+
+### Joint purchases where a user appears more than one time
+
+When a user appears more than once in a joint purchase (e.g. two people buying together, but one of them is buying twice as much as the other), the system will the amount of times a user appears in the purchase as a multiplier for the base price. You can think of it as if the user is having shares in the joint purchase.
+
+```python
+base_cost_for_user: float = product_price * products_bought * user_shares / total_user_shares
+added_interest: float = base_cost_for_user * ((interest_rate - 100) / 100)
+new_user_balance: int = user_balance - math.ceil(base_cost_for_user + added_interest)
+```
+
+### Joint purchases when one or more users are below the penalty threshold
+
+The cost for each user will be calculated as usual, but for the users who are below the penalty threshold, the penalty will also be calculated and added to this user's cost. The penalty is calculated based on the share of the total purchase that this user is responsible for.
+
+
+```python
+base_cost_for_user: float = product_price * products_bought * user_shares / total_user_shares
+added_interest: float = base_cost_for_user * ((interest_rate - 100) / 100)
+penalty: float = base_cost_for_user * ((penalty_multiplier - 100) / 100)
+new_user_balance: int = user_balance - math.ceil(base_cost_for_user + added_interest + penalty)
+```
+
+### Joint purchases when one or more users will end up below the penalty threshold after the purchase
+
+Just as the single-user case, if a user who is part of a joint purchase is above the penalty threshold before the purchase, but will end up below the threshold after the purchase, no penalty will be applied to that user for this purchase. The entire cost (including interest) will be split equally between all users.
+
+```python
+base_cost_for_user: float = product_price * products_bought * user_shares / total_user_shares
+added_interest: float = base_cost_for_user * ((interest_rate - 100) / 100)
+new_user_balance: int = user_balance - math.ceil(base_cost_for_user + added_interest)
+```
+
+> [!NOTE]
+> In the case where you (and others) are performing multiple transactions at once, the system should try its best to order the purchases in a way that minimizes the amount of penalties you need to pay.
+
+## Who owns a product
+
+When throwing away products, it can be useful to know who added the products in the first place. Dibbler will look back at its event log to determine who added the products that are being thrown away, and pull the money from their balance in order for the economy to stay sane.
+
+The algorithm is based on FIFO (first in, first out), meaning that the products that were added first are the ones that will be considered thrown away first. This might not always be accurate in real life (someone could buy a newer product and add it to the shelf before an older product is added and then considered newer by the system), but it is an overall reasonable approximation.
+
+When adjusting the product count upwards manually, the system will consider the new products to not be owned by anyone. When adjusting the product count downwards manually, the system will let go of ownership of the products being removed according to the FIFO queue, without adjusting their balance.
+
+If the stock count of a product goes negative, the system will consider that the products being bought are owned by no one, and will not adjust any balances. The system should warn about the negative stock count, and recommend recounting the stock. As mentioned above, the manual adjustment made when recounting the stock will not assign ownership to anyone.
+
+Upon throwing away products (not manual adjustment), the system will pull money from the balances of the users who added the products being thrown away, according to the FIFO queue. In the case where the systemd decides that no one own the products due to manual adjustments, the system will not pull any money from anyone's balance and let the economy absorb the loss.
+
+## Other actions
+
+### Transfers
+
+You can transfer money from one user to another. The amount transferred will be deducted from the sender's balance and added to the receiver's balance without any interest or penalty applied.
+
+```python
+new_sender_balance: int = sender_balance - amount_transferred
+new_receiver_balance: int = receiver_balance + amount_transferred
+```
+
+> [!NOTE]
+> Transfers from one user to itself are not allowed.
+
+### Balance adjustments
+
+You can manually adjust a user's balance. This action will not have any multipliers of any kind applied, and will simply add or subtract the specified amount from the user's balance.
+
+```python
+new_user_balance: int = user_balance + adjustment_amount
+```
+
+## Updating the economy specification
+
+All transactions in the database are tagged with the economy specification version they were created under. If you are to update this document with changes to how the economy works, and change the software accordingly, you will want to keep the old logic around and bump the version number. This way, the old event log is still valid, and will be aggregated using the old logic, while new transactions will user the logic applicable to the version they were created under.

example-config.ini

@@ -6,7 +6,7 @@ input_encoding = 'utf8'
 
 [database]
 # url = "postgresql://robertem@127.0.0.1/pvvvv"
-url = "sqlite:///test.db"
+url = sqlite:///test.db
 
 [limits]
 low_credit_warning_limit = -100

flake.nix

@@ -42,7 +42,7 @@
       devShells = forAllSystems (system: pkgs: {
         default = self.devShells.${system}.dibbler;
         dibbler = pkgs.callPackage ./nix/shell.nix {
-          python = pkgs.python312;
+          python3 = pkgs.python312;
         };
       });
 

nix/dibbler.nix

@@ -13,11 +13,19 @@ python3Packages.buildPythonApplication {
   # https://github.com/NixOS/nixpkgs/issues/285234
   dontCheckRuntimeDeps = true;
 
+  pythonImportsCheck = [];
+
+  doCheck = true;
+  nativeCheckInputs = with python3Packages; [
+    pytest
+    pytestCheckHook
+  ];
+
   nativeBuildInputs = with python3Packages; [ setuptools ];
   propagatedBuildInputs = with python3Packages; [
     brother-ql
     matplotlib
-    psycopg2
+    psycopg2-binary
     python-barcode
     sqlalchemy
   ];

nix/shell.nix

@@ -1,6 +1,6 @@
 {
   mkShell,
-  python,
+  python3,
   ruff,
   uv,
 }:
@@ -9,12 +9,19 @@ mkShell {
   packages = [
     ruff
     uv
-    (python.withPackages (ps: with ps; [
+    (python3.withPackages (ps: with ps; [
       brother-ql
       matplotlib
       psycopg2
       python-barcode
       sqlalchemy
+      sqlparse
+
+      pytest
+      pytest-cov
+      pytest-html
+      pytest-benchmark
+      pygal
     ]))
   ];
 }

pyproject.toml

@@ -15,11 +15,21 @@ dependencies = [
     "SQLAlchemy >= 2.0, <2.1",
     "brother-ql",
     "matplotlib",
-    "psycopg2 >= 2.8, <2.10",
+    "psycopg2-binary >= 2.8, <2.10",
     "python-barcode",
 ]
 dynamic = ["version"]
 
+[dependency-groups]
+test = [
+    "pytest",
+    "pytest-cov",
+    "coverage-badge>=1.1.2",
+    "pytest-html>=4.1.1",
+    "sqlparse>=0.5.4",
+    "pytest-benchmark[histogram]>=5.2.3",
+]
+
 [tool.setuptools.packages.find]
 include = ["dibbler*"]
 
@@ -31,3 +41,22 @@ line-length = 100
 
 [tool.ruff]
 line-length = 100
+
+[tool.pytest.ini_options]
+addopts = [
+    "--cov=dibbler.lib",
+    "--cov=dibbler.models",
+    "--cov=dibbler.queries",
+    "--cov-report=html",
+    "--cov-branch",
+
+    "--self-contained-html",
+    "--html=./test-report/index.html",
+
+    "--benchmark-skip",
+    "--benchmark-autosave",
+    "--benchmark-save=default",
+    "--benchmark-verbose",
+    "--benchmark-storage=benchmark",
+    "--benchmark-histogram=benchmark/histogram",
+]

tests/benchmark/helpers.py

@@ -0,0 +1,301 @@
+import random
+from datetime import datetime, timedelta
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, Transaction, TransactionType, User
+from dibbler.queries import joint_buy_product
+
+
+def insert_users_and_products(
+    sql_session: Session, user_count: int = 10, product_count: int = 10
+) -> tuple[list[User], list[Product]]:
+    users = []
+    for i in range(user_count):
+        user = User(f"User{i + 1}")
+        sql_session.add(user)
+        users.append(user)
+    sql_session.commit()
+
+    products = []
+    for i in range(product_count):
+        barcode = str(1000000000000 + i)
+        product = Product(barcode, f"Product{i + 1}")
+        sql_session.add(product)
+        products.append(product)
+    sql_session.commit()
+
+    return users, products
+
+
+def generate_random_transactions(
+    sql_session: Session,
+    n: int,
+    seed: int = 42,
+    transaction_type_filter: list[TransactionType] | None = None,
+    distribution: dict[TransactionType, float] | None = None,
+) -> list[Transaction]:
+    random.seed(seed)
+
+    if transaction_type_filter is None:
+        transaction_type_filter = list(TransactionType)
+
+    if TransactionType.JOINT_BUY_PRODUCT in transaction_type_filter:
+        transaction_type_filter.remove(TransactionType.JOINT_BUY_PRODUCT)
+
+    # TODO: implement me
+    if TransactionType.THROW_PRODUCT in transaction_type_filter:
+        transaction_type_filter.remove(TransactionType.THROW_PRODUCT)
+
+    if distribution is None:
+        distribution = {t: 1 / len(transaction_type_filter) for t in transaction_type_filter}
+    transaction_types = list(distribution.keys())
+    weights = list(distribution.values())
+    transactions: list[Transaction] = []
+    last_time = datetime(2023, 1, 1, 0, 0, 0)
+    for _ in range(n):
+        transaction_type = random.choices(transaction_types, weights=weights, k=1)[0]
+        generator = RANDOM_GENERATORS[transaction_type]
+        transaction_or_transactions = generator(sql_session, last_time)
+        if isinstance(transaction_or_transactions, list):
+            transactions.extend(transaction_or_transactions)
+            last_time = max(t.time for t in transaction_or_transactions)
+        else:
+            transactions.append(transaction_or_transactions)
+            last_time = transaction_or_transactions.time
+    return transactions
+
+
+EXCEPTION_LIMIT = 15
+
+
+def random_add_product_transaction(sql_session: Session, last_time: datetime) -> Transaction:
+    i = 0
+    while True:
+        i += 1
+        user = random.choice(sql_session.query(User).all())
+        product = random.choice(sql_session.query(Product).all())
+        product_count = random.randint(1, 10)
+        product_price = random.randint(15, 45)
+        amount = product_count * product_price + random.randint(-7, 0)
+        new_datetime = last_time + timedelta(minutes=random.randint(1, 60))
+        try:
+            transaction = Transaction.add_product(
+                amount,
+                user.id,
+                product.id,
+                product_price,
+                product_count,
+                time=new_datetime,
+            )
+        except Exception:
+            if i > EXCEPTION_LIMIT:
+                raise RuntimeError(
+                    "Too many failed attempts to create a valid transaction, consider changing the seed"
+                )
+            continue
+        return transaction
+
+
+def random_adjust_balance_transaction(sql_session: Session, last_time: datetime) -> Transaction:
+    i = 0
+    while True:
+        i += 1
+        user = random.choice(sql_session.query(User).all())
+        amount = random.randint(-50, 100)
+        new_datetime = last_time + timedelta(minutes=random.randint(1, 60))
+        try:
+            transaction = Transaction.adjust_balance(
+                amount,
+                user.id,
+                time=new_datetime,
+            )
+        except Exception:
+            if i > EXCEPTION_LIMIT:
+                raise RuntimeError(
+                    "Too many failed attempts to create a valid transaction, consider changing the seed"
+                )
+            continue
+        return transaction
+
+
+def random_adjust_interest_transaction(sql_session: Session, last_time: datetime) -> Transaction:
+    i = 0
+    while True:
+        i += 1
+        user = random.choice(sql_session.query(User).all())
+        amount = random.randint(-5, 5)
+        new_datetime = last_time + timedelta(minutes=random.randint(1, 60))
+        try:
+            transaction = Transaction.adjust_interest(
+                amount,
+                user.id,
+                time=new_datetime,
+            )
+        except Exception:
+            if i > EXCEPTION_LIMIT:
+                raise RuntimeError(
+                    "Too many failed attempts to create a valid transaction, consider changing the seed"
+                )
+            continue
+        return transaction
+
+
+def random_adjust_penalty_transaction(sql_session: Session, last_time: datetime) -> Transaction:
+    i = 0
+    while True:
+        i += 1
+        user = random.choice(sql_session.query(User).all())
+        penalty_multiplier_percent = random.randint(100, 200)
+        penalty_threshold = random.randint( -150, -50)
+        new_datetime = last_time + timedelta(minutes=random.randint(1, 60))
+        try:
+            transaction = Transaction.adjust_penalty(
+                penalty_multiplier_percent,
+                penalty_threshold,
+                user.id,
+                time=new_datetime,
+            )
+        except Exception:
+            if i > EXCEPTION_LIMIT:
+                raise RuntimeError(
+                    "Too many failed attempts to create a valid transaction, consider changing the seed"
+                )
+            continue
+        return transaction
+
+
+def random_adjust_stock_transaction(sql_session: Session, last_time: datetime) -> Transaction:
+    i = 0
+    while True:
+        i += 1
+        user = random.choice(sql_session.query(User).all())
+        product = random.choice(sql_session.query(Product).all())
+        stock_change = random.randint(-5, 6)
+        new_datetime = last_time + timedelta(minutes=random.randint(1, 60))
+        try:
+            transaction = Transaction.adjust_stock(
+                user_id=user.id,
+                product_id=product.id,
+                product_count=stock_change,
+                time=new_datetime,
+            )
+        except Exception:
+            if i > EXCEPTION_LIMIT:
+                raise RuntimeError(
+                    "Too many failed attempts to create a valid transaction, consider changing the seed"
+                )
+            continue
+        return transaction
+
+
+def random_buy_product_transaction(sql_session: Session, last_time: datetime) -> Transaction:
+    i = 0
+    while True:
+        i += 1
+        user = random.choice(sql_session.query(User).all())
+        product = random.choice(sql_session.query(Product).all())
+        product_count = random.randint(1, 5)
+        new_datetime = last_time + timedelta(minutes=random.randint(1, 60))
+        try:
+            transaction = Transaction.buy_product(
+                user_id=user.id,
+                product_id=product.id,
+                product_count=product_count,
+                time=new_datetime,
+            )
+        except Exception:
+            if i > EXCEPTION_LIMIT:
+                raise RuntimeError(
+                    "Too many failed attempts to create a valid transaction, consider changing the seed"
+                )
+            continue
+        return transaction
+
+
+def random_joint_transaction(sql_session: Session, last_time: datetime) -> list[Transaction]:
+    i = 0
+    while True:
+        i += 1
+        user_count = random.randint(2, 4)
+        users = random.sample(sql_session.query(User).all(), k=user_count)
+        product = random.choice(sql_session.query(Product).all())
+        product_count = random.randint(1, 5)
+        new_datetime = last_time + timedelta(minutes=random.randint(1, 60))
+
+        try:
+            transactions = joint_buy_product(
+                sql_session,
+                product=product,
+                product_count=product_count,
+                instigator=users[0],
+                users=users,
+                time=new_datetime,
+            )
+        except Exception:
+            if i > EXCEPTION_LIMIT:
+                raise RuntimeError(
+                    "Too many failed attempts to create a valid transaction, consider changing the seed"
+                )
+            continue
+        return transactions
+
+
+def random_transfer_transaction(sql_session: Session, last_time: datetime) -> Transaction:
+    i = 0
+    while True:
+        i += 1
+        sender, receiver = random.sample(sql_session.query(User).all(), k=2)
+        amount = random.randint(1, 50)
+        new_datetime = last_time + timedelta(minutes=random.randint(1, 60))
+        try:
+            transaction = Transaction.transfer(
+                amount,
+                sender.id,
+                receiver.id,
+                time=new_datetime,
+            )
+        except Exception:
+            if i > EXCEPTION_LIMIT:
+                raise RuntimeError(
+                    "Too many failed attempts to create a valid transaction, consider changing the seed"
+                )
+            continue
+        return transaction
+
+
+def random_throw_product_transaction(sql_session: Session, last_time: datetime) -> Transaction:
+    i = 0
+    while True:
+        i += 1
+        user = random.choice(sql_session.query(User).all())
+        product = random.choice(sql_session.query(Product).all())
+        product_count = random.randint(1, 5)
+        new_datetime = last_time + timedelta(minutes=random.randint(1, 60))
+        try:
+            transaction = Transaction.throw_product(
+                user_id=user.id,
+                product_id=product.id,
+                product_count=product_count,
+                time=new_datetime,
+            )
+        except Exception:
+            if i > EXCEPTION_LIMIT:
+                raise RuntimeError(
+                    "Too many failed attempts to create a valid transaction, consider changing the seed"
+                )
+            continue
+        return transaction
+
+
+RANDOM_GENERATORS = {
+    TransactionType.ADD_PRODUCT: random_add_product_transaction,
+    TransactionType.ADJUST_BALANCE: random_adjust_balance_transaction,
+    TransactionType.ADJUST_INTEREST: random_adjust_interest_transaction,
+    TransactionType.ADJUST_PENALTY: random_adjust_penalty_transaction,
+    TransactionType.ADJUST_STOCK: random_adjust_stock_transaction,
+    TransactionType.BUY_PRODUCT: random_buy_product_transaction,
+    TransactionType.JOINT: random_joint_transaction,
+    TransactionType.TRANSFER: random_transfer_transaction,
+    TransactionType.THROW_PRODUCT: random_throw_product_transaction,
+}

tests/benchmark/test_benchmark_product_owners.py

@@ -0,0 +1,46 @@
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, TransactionType
+from dibbler.queries import product_owners
+from tests.benchmark.helpers import generate_random_transactions, insert_users_and_products
+
+
+@pytest.mark.benchmark(group='product_owners')
+@pytest.mark.parametrize(
+    "transaction_count",
+    [
+        100,
+        500,
+        1000,
+        2000,
+        5000,
+        10000,
+    ],
+)
+def test_benchmark_product_owners(benchmark, sql_session: Session, transaction_count: int):
+    _users, products = insert_users_and_products(sql_session)
+
+    generate_random_transactions(
+        sql_session,
+        transaction_count,
+        transaction_type_filter=[
+            TransactionType.ADD_PRODUCT,
+            TransactionType.ADJUST_STOCK,
+            TransactionType.BUY_PRODUCT,
+            TransactionType.JOINT,
+            TransactionType.THROW_PRODUCT,
+        ],
+    )
+
+    benchmark.pedantic(
+        query_all_product_owners,
+        args=(sql_session, products),
+        iterations=10,
+        rounds=5,
+    )
+
+
+def query_all_product_owners(sql_session: Session, products: list[Product]) -> None:
+    for product in products:
+        product_owners(sql_session, product)

tests/benchmark/test_benchmark_product_price.py

@@ -0,0 +1,43 @@
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, TransactionType
+from dibbler.queries import product_price
+from tests.benchmark.helpers import generate_random_transactions, insert_users_and_products
+
+
+@pytest.mark.benchmark(group='product_price')
+@pytest.mark.parametrize("transaction_count", [
+    100,
+    500,
+    1000,
+    2000,
+    5000,
+    10000,
+])
+def test_benchmark_product_price(benchmark, sql_session: Session, transaction_count):
+    _users, products = insert_users_and_products(sql_session)
+
+    generate_random_transactions(
+        sql_session,
+        transaction_count,
+        transaction_type_filter=[
+            TransactionType.ADD_PRODUCT,
+            TransactionType.ADJUST_STOCK,
+            TransactionType.BUY_PRODUCT,
+            TransactionType.JOINT,
+            TransactionType.THROW_PRODUCT,
+        ],
+    )
+
+    benchmark.pedantic(
+        query_all_products_price,
+        args=(sql_session, products),
+        iterations=10,
+        rounds=5,
+    )
+
+
+def query_all_products_price(sql_session: Session, products: list[Product]) -> None:
+    for product in products:
+        product_price(sql_session, product)

tests/benchmark/test_benchmark_product_stock.py

@@ -0,0 +1,46 @@
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, TransactionType
+from dibbler.queries import product_stock
+from tests.benchmark.helpers import generate_random_transactions, insert_users_and_products
+
+
+@pytest.mark.benchmark(group='product_stock')
+@pytest.mark.parametrize(
+    "transaction_count",
+    [
+        100,
+        500,
+        1000,
+        2000,
+        5000,
+        10000,
+    ],
+)
+def test_benchmark_product_stock(benchmark, sql_session: Session, transaction_count: int):
+    _users, products = insert_users_and_products(sql_session)
+
+    generate_random_transactions(
+        sql_session,
+        transaction_count,
+        transaction_type_filter=[
+            TransactionType.ADD_PRODUCT,
+            TransactionType.ADJUST_STOCK,
+            TransactionType.BUY_PRODUCT,
+            TransactionType.JOINT,
+            TransactionType.THROW_PRODUCT,
+        ],
+    )
+
+    benchmark.pedantic(
+        query_all_products_stock,
+        args=(sql_session, products),
+        iterations=10,
+        rounds=5,
+    )
+
+
+def query_all_products_stock(sql_session: Session, products: list[Product]) -> None:
+    for product in products:
+        product_stock(sql_session, product)

tests/benchmark/test_benchmark_transaction_log.py

@@ -0,0 +1,46 @@
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, User
+from dibbler.queries import transaction_log
+from tests.benchmark.helpers import generate_random_transactions, insert_users_and_products
+
+
+@pytest.mark.benchmark(group='transaction_log')
+@pytest.mark.parametrize(
+    "transaction_count",
+    [
+        100,
+        500,
+        1000,
+        2000,
+        5000,
+        10000,
+    ],
+)
+def test_benchmark_transaction_log(benchmark, sql_session: Session, transaction_count: int):
+    users, products = insert_users_and_products(sql_session)
+
+    generate_random_transactions(
+        sql_session,
+        transaction_count,
+    )
+
+    benchmark.pedantic(
+        query_transaction_log,
+        args=(
+            sql_session,
+            products,
+            users,
+        ),
+        iterations=10,
+        rounds=5,
+    )
+
+
+def query_transaction_log(sql_session: Session, products: list[Product], users: list[User]) -> None:
+    for user in users:
+        transaction_log(sql_session, user=user)
+
+    for product in products:
+        transaction_log(sql_session, product=product)

tests/benchmark/test_benchmark_user_balance.py

@@ -0,0 +1,38 @@
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import User
+from dibbler.queries import user_balance
+from tests.benchmark.helpers import generate_random_transactions, insert_users_and_products
+
+
+@pytest.mark.benchmark(group='user_balance')
+@pytest.mark.parametrize(
+    "transaction_count",
+    [
+        100,
+        500,
+        1000,
+        1500,
+        2000,
+    ],
+)
+def test_benchmark_user_balance(benchmark, sql_session: Session, transaction_count: int):
+    users, _products = insert_users_and_products(sql_session)
+
+    generate_random_transactions(
+        sql_session,
+        transaction_count,
+    )
+
+    benchmark.pedantic(
+        query_all_users_balance,
+        args=(sql_session, users),
+        iterations=10,
+        rounds=5,
+    )
+
+
+def query_all_users_balance(sql_session: Session, users: list[User]) -> None:
+    for user in users:
+        user_balance(sql_session, user)

tests/conftest.py

@@ -0,0 +1,83 @@
+import logging
+
+import pytest
+import sqlparse
+from sqlalchemy import create_engine, event
+from sqlalchemy.exc import OperationalError
+from sqlalchemy.orm import Session
+
+from dibbler.models import Base
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--debug-sql",
+        action="store_true",
+        help="Enable SQLAlchemy 'echo' mode for debugging",
+    )
+
+
+class SqlParseFormatter(logging.Formatter):
+    def format(self, record):
+        recordMessage = record.getMessage()
+        if not recordMessage.startswith("[") and any(
+            recordMessage.startswith(keyword)
+            for keyword in [
+                "SELECT",
+                "INSERT",
+                "UPDATE",
+                "DELETE",
+                "WITH",
+            ]
+        ):
+            formatted_sql = sqlparse.format(recordMessage, reindent=True, keyword_case="upper")
+            record.msg = "\n" + formatted_sql
+
+        return super().format(record)
+
+
+def pytest_configure(config):
+    """Setup pretty SQL logging if --debug-sql is enabled."""
+
+    logger = logging.getLogger("sqlalchemy.engine")
+
+    # TODO: it would be nice not to duplicate these logs.
+    #       logging.NullHandler() does not seem to work here
+    handler = logging.StreamHandler()
+    handler.setFormatter(SqlParseFormatter())
+    logger.addHandler(handler)
+
+    if config.getoption("--debug-sql"):
+        logger.setLevel(logging.INFO)
+
+
+@pytest.fixture(scope="function")
+def sql_session(request):
+    """Create a new SQLAlchemy session for testing."""
+
+    engine = create_engine("sqlite:///:memory:")
+
+    @event.listens_for(engine, "connect")
+    def set_sqlite_pragma(dbapi_connection, _connection_record):
+        cursor = dbapi_connection.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.close()
+
+    Base.metadata.create_all(engine)
+    with Session(engine) as sql_session:
+        yield sql_session
+    sql_session.close()
+
+
+# FIXME: Declaring this hook seems to have a side effect where the database does not
+#        get reset between tests.
+# @pytest.hookimpl(trylast=True)
+# def pytest_runtest_call(item: pytest.Item):
+#     """Hook to format SQL statements in OperationalError exceptions."""
+#     try:
+#         item.runtest()
+#     except OperationalError as e:
+#         if e.statement is not None:
+#             formatted_sql = sqlparse.format(e.statement, reindent=True, keyword_case="upper")
+#             e.statement = "\n" + formatted_sql + "\n"
+#         raise e

tests/helpers.py

@@ -0,0 +1,28 @@
+from datetime import datetime, timedelta
+
+from dibbler.models import Transaction
+
+
+def assign_times(
+    transactions: list[Transaction],
+    start_time: datetime = datetime(2024, 1, 1, 0, 0, 0),
+    delta: timedelta = timedelta(minutes=1),
+) -> None:
+    """Assigns datetimes to a list of transactions starting from start_time and incrementing by delta."""
+    current_time = start_time
+    for transaction in transactions:
+        transaction.time = current_time
+        current_time += delta
+
+
+def assert_id_order_similar_to_time_order(transactions: list[Transaction]) -> None:
+    """Asserts that the order of transaction IDs is similar to the order of their timestamps."""
+    sorted_by_time = sorted(transactions, key=lambda t: t.time)
+    sorted_by_id = sorted(transactions, key=lambda t: t.id)
+
+    for t1, t2 in zip(sorted_by_time, sorted_by_id):
+        assert t1.id == t2.id or t1.time == t2.time, (
+            f"Transaction ID order does not match time order:\n"
+            f"ID {t1.id} at time {t1.time}\n"
+            f"ID {t2.id} at time {t2.time}"
+        )

tests/models/test_product.py

@@ -0,0 +1,32 @@
+import pytest
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product
+
+
+def insert_test_data(sql_session: Session) -> Product:
+    product = Product("1234567890123", "Test Product")
+    sql_session.add(product)
+    sql_session.commit()
+    return product
+
+
+def test_product_no_duplicate_barcodes(sql_session: Session):
+    product = insert_test_data(sql_session)
+
+    duplicate_product = Product(product.bar_code, "Hehe >:)")
+    sql_session.add(duplicate_product)
+
+    with pytest.raises(IntegrityError):
+        sql_session.commit()
+
+
+def test_product_no_duplicate_names(sql_session: Session):
+    product = insert_test_data(sql_session)
+
+    duplicate_product = Product("1918238911928", product.name)
+    sql_session.add(duplicate_product)
+
+    with pytest.raises(IntegrityError):
+        sql_session.commit()

tests/models/test_transaction.py

@@ -0,0 +1,157 @@
+from datetime import datetime
+
+import pytest
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, Transaction, User
+from dibbler.queries import product_stock
+
+
+def insert_test_data(sql_session: Session) -> tuple[User, Product]:
+    user = User("Test User")
+    product = Product("1234567890123", "Test Product")
+
+    sql_session.add(user)
+    sql_session.add(product)
+    sql_session.commit()
+
+    return user, product
+
+
+def test_user_not_allowed_to_transfer_to_self(sql_session: Session) -> None:
+    user, _ = insert_test_data(sql_session)
+
+    transaction = Transaction.transfer(
+        time=datetime(2023, 10, 1, 12, 0, 0),
+        user_id=user.id,
+        transfer_user_id=user.id,
+        amount=50,
+    )
+
+    sql_session.add(transaction)
+
+    with pytest.raises(IntegrityError):
+        sql_session.commit()
+
+
+def test_product_foreign_key_constraint(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transaction = Transaction.add_product(
+        time=datetime(2023, 10, 1, 12, 0, 0),
+        user_id=user.id,
+        product_id=product.id,
+        amount=27,
+        per_product=27,
+        product_count=1,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()
+
+    # Attempt to add a transaction with a non-existent product
+    invalid_transaction = Transaction.add_product(
+        time=datetime(2023, 10, 1, 12, 0, 1),
+        user_id=user.id,
+        product_id=9999,  # Non-existent product ID
+        amount=27,
+        per_product=27,
+        product_count=1,
+    )
+
+    sql_session.add(invalid_transaction)
+
+    with pytest.raises(IntegrityError):
+        sql_session.commit()
+
+
+def test_user_foreign_key_constraint(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transaction = Transaction.add_product(
+        time=datetime(2023, 10, 1, 12, 0, 0),
+        user_id=user.id,
+        product_id=product.id,
+        amount=27,
+        per_product=27,
+        product_count=1,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()
+
+    # Attempt to add a transaction with a non-existent user
+    invalid_transaction = Transaction.add_product(
+        time=datetime(2023, 10, 1, 12, 0, 1),
+        user_id=9999,  # Non-existent user ID
+        product_id=product.id,
+        amount=27,
+        per_product=27,
+        product_count=1,
+    )
+
+    sql_session.add(invalid_transaction)
+
+    with pytest.raises(IntegrityError):
+        sql_session.commit()
+
+
+def test_transaction_buy_product_more_than_stock(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            time=datetime(2023, 10, 1, 12, 0, 0),
+            user_id=user.id,
+            product_id=product.id,
+            amount=27,
+            per_product=27,
+            product_count=1,
+        ),
+        Transaction.buy_product(
+            time=datetime(2023, 10, 1, 13, 0, 0),
+            product_count=10,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+    ]
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert product_stock(sql_session, product) == 1 - 10
+
+
+def test_transaction_add_product_deny_amount_over_per_product_times_product_count(
+    sql_session: Session,
+) -> None:
+    user, product = insert_test_data(sql_session)
+
+    with pytest.raises(ValueError):
+        _transaction = Transaction.add_product(
+            time=datetime(2023, 10, 1, 12, 0, 0),
+            user_id=user.id,
+            product_id=product.id,
+            amount=27 * 2 + 1,  # Invalid amount
+            per_product=27,
+            product_count=2,
+        )
+
+
+def test_transaction_add_product_allow_amount_under_per_product_times_product_count(
+    sql_session: Session,
+) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transaction = Transaction.add_product(
+        time=datetime(2023, 10, 1, 12, 0, 0),
+        user_id=user.id,
+        product_id=product.id,
+        amount=27 * 2 - 1,  # Valid amount
+        per_product=27,
+        product_count=2,
+    )
+
+    sql_session.add(transaction)
+    sql_session.commit()

tests/models/test_user.py

@@ -0,0 +1,23 @@
+import pytest
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+
+from dibbler.models import User
+
+
+def insert_test_data(sql_session: Session) -> User:
+    user = User("Test User")
+    sql_session.add(user)
+    sql_session.commit()
+
+    return user
+
+
+def test_ensure_no_duplicate_user_names(sql_session: Session):
+    user = insert_test_data(sql_session)
+
+    user2 = User(user.name)
+    sql_session.add(user2)
+
+    with pytest.raises(IntegrityError):
+        sql_session.commit()

tests/queries/test_adjust_interest.py

@@ -0,0 +1,85 @@
+from datetime import datetime, timedelta
+
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Transaction, User
+from dibbler.queries import adjust_interest, current_interest
+
+
+def insert_test_data(sql_session: Session) -> User:
+    user = User("Test User")
+    sql_session.add(user)
+    sql_session.commit()
+
+    return user
+
+
+def test_adjust_interest_unitialized_user(sql_session: Session) -> None:
+    user = User("Uninitialized User")
+
+    with pytest.raises(ValueError, match="User must be persisted in the database."):
+        adjust_interest(
+            sql_session,
+            user=user,
+            new_interest=4,
+            message="Attempting to adjust interest for uninitialized user",
+        )
+
+
+def test_adjust_interest_no_history(sql_session: Session) -> None:
+    user = insert_test_data(sql_session)
+
+    adjust_interest(
+        sql_session,
+        user=user,
+        new_interest=3,
+        message="Setting initial interest rate",
+    )
+    sql_session.commit()
+
+    current_interest_rate = current_interest(sql_session)
+
+    assert current_interest_rate == 3
+
+
+def test_adjust_interest_existing_history(sql_session: Session) -> None:
+    user = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.adjust_interest(
+            time=datetime(2023, 10, 1, 9, 0, 0),
+            user_id=user.id,
+            interest_rate_percent=5,
+            message="Initial interest rate",
+        ),
+    ]
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    current_interest_rate = current_interest(sql_session)
+    assert current_interest_rate == 5
+
+    adjust_interest(
+        sql_session,
+        user=user,
+        new_interest=2,
+        message="Adjusting interest rate",
+        time=transactions[-1].time + timedelta(days=1),
+    )
+    sql_session.commit()
+
+    current_interest_rate = current_interest(sql_session)
+    assert current_interest_rate == 2
+
+
+def test_adjust_interest_negative_failure(sql_session: Session) -> None:
+    user = insert_test_data(sql_session)
+
+    with pytest.raises(ValueError, match="Interest rate cannot be negative"):
+        adjust_interest(
+            sql_session,
+            user=user,
+            new_interest=-1,
+            message="Attempting to set negative interest rate",
+        )

tests/queries/test_adjust_penalty.py

@@ -0,0 +1,179 @@
+from datetime import datetime, timedelta
+
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Transaction, User
+from dibbler.models.Transaction import (
+    DEFAULT_PENALTY_MULTIPLIER_PERCENT,
+    DEFAULT_PENALTY_THRESHOLD,
+)
+from dibbler.queries import adjust_penalty, current_penalty
+
+
+def insert_test_data(sql_session: Session) -> User:
+    user = User("Test User")
+    sql_session.add(user)
+    sql_session.commit()
+
+    return user
+
+
+def test_adjust_penalty_empty_not_allowed(sql_session: Session) -> None:
+    user = insert_test_data(sql_session)
+
+    with pytest.raises(ValueError):
+        adjust_penalty(
+            sql_session,
+            user=user,
+            message="No penalty or multiplier provided",
+        )
+
+
+def test_adjust_penalty_unitialized_user(sql_session: Session) -> None:
+    user = User("Uninitialized User")
+
+    with pytest.raises(ValueError):
+        adjust_penalty(
+            sql_session,
+            user=user,
+            new_penalty=-100,
+            new_penalty_multiplier=110,
+            message="Attempting to adjust penalty for uninitialized user",
+        )
+
+
+def test_adjust_penalty_no_history(sql_session: Session) -> None:
+    user = insert_test_data(sql_session)
+
+    adjust_penalty(
+        sql_session,
+        user=user,
+        new_penalty=-200,
+        message="Setting initial interest rate",
+    )
+    sql_session.commit()
+
+    (penalty, multiplier) = current_penalty(sql_session)
+
+    assert penalty == -200
+    assert multiplier == DEFAULT_PENALTY_MULTIPLIER_PERCENT
+
+
+def test_adjust_penalty_multiplier_no_history(sql_session: Session) -> None:
+    user = insert_test_data(sql_session)
+
+    adjust_penalty(
+        sql_session,
+        user=user,
+        new_penalty_multiplier=125,
+        message="Setting initial interest rate",
+    )
+    sql_session.commit()
+
+    (penalty, multiplier) = current_penalty(sql_session)
+
+    assert penalty == DEFAULT_PENALTY_THRESHOLD
+    assert multiplier == 125
+
+
+def test_adjust_penalty_multiplier_less_than_100_fail(sql_session: Session) -> None:
+    user = insert_test_data(sql_session)
+
+    adjust_penalty(
+        sql_session,
+        user=user,
+        new_penalty_multiplier=100,
+        message="Setting initial interest rate",
+    )
+    sql_session.commit()
+
+    (_, multiplier) = current_penalty(sql_session)
+
+    assert multiplier == 100
+
+    with pytest.raises(ValueError, match="Penalty multiplier cannot be less than 100%"):
+        adjust_penalty(
+            sql_session,
+            user=user,
+            new_penalty_multiplier=99,
+            message="Setting initial interest rate",
+        )
+
+
+def test_adjust_penalty_existing_history(sql_session: Session) -> None:
+    user = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.adjust_penalty(
+            time=datetime(2024, 1, 1, 10, 0, 0),
+            user_id=user.id,
+            penalty_threshold=-150,
+            penalty_multiplier_percent=110,
+            message="Initial penalty settings",
+        ),
+    ]
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    (penalty, _) = current_penalty(sql_session)
+    assert penalty == -150
+
+    adjust_penalty(
+        sql_session,
+        user=user,
+        new_penalty=-250,
+        message="Adjusting penalty threshold",
+        time=transactions[-1].time + timedelta(days=1),
+    )
+    sql_session.commit()
+
+    (penalty, _) = current_penalty(sql_session)
+    assert penalty == -250
+
+
+def test_adjust_penalty_multiplier_existing_history(sql_session: Session) -> None:
+    user = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.adjust_penalty(
+            time=datetime(2024, 1, 1, 10, 0, 0),
+            user_id=user.id,
+            penalty_threshold=-150,
+            penalty_multiplier_percent=110,
+            message="Initial penalty settings",
+        ),
+    ]
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    (_, multiplier) = current_penalty(sql_session)
+    assert multiplier == 110
+
+    adjust_penalty(
+        sql_session,
+        user=user,
+        new_penalty_multiplier=130,
+        message="Adjusting penalty multiplier",
+        time=transactions[-1].time + timedelta(days=1),
+    )
+    sql_session.commit()
+    (_, multiplier) = current_penalty(sql_session)
+    assert multiplier == 130
+
+
+def test_adjust_penalty_and_multiplier(sql_session: Session) -> None:
+    user = insert_test_data(sql_session)
+
+    adjust_penalty(
+        sql_session,
+        user=user,
+        new_penalty=-300,
+        new_penalty_multiplier=150,
+        message="Setting both penalty and multiplier",
+    )
+    sql_session.commit()
+
+    (penalty, multiplier) = current_penalty(sql_session)
+    assert penalty == -300
+    assert multiplier == 150

tests/queries/test_current_interest.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models.Transaction import DEFAULT_INTEREST_RATE_PERCENT
+from dibbler.models import Transaction, User
+from dibbler.queries import current_interest
+from tests.helpers import assert_id_order_similar_to_time_order, assign_times
+
+
+def test_current_interest_no_history(sql_session: Session) -> None:
+    assert current_interest(sql_session) == DEFAULT_INTEREST_RATE_PERCENT
+
+
+def test_current_interest_with_history(sql_session: Session) -> None:
+    user = User("Admin User")
+    sql_session.add(user)
+    sql_session.commit()
+
+    transactions = [
+        Transaction.adjust_interest(
+            interest_rate_percent=5,
+            user_id=user.id,
+        ),
+        Transaction.adjust_interest(
+            interest_rate_percent=7,
+            user_id=user.id,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    assert current_interest(sql_session) == 7

tests/queries/test_current_penalty.py

@@ -0,0 +1,46 @@
+from datetime import datetime
+
+from sqlalchemy.orm import Session
+
+from dibbler.models import Transaction, User
+from dibbler.models.Transaction import (
+    DEFAULT_PENALTY_MULTIPLIER_PERCENT,
+    DEFAULT_PENALTY_THRESHOLD,
+)
+from dibbler.queries import current_penalty
+from tests.helpers import assign_times, assert_id_order_similar_to_time_order
+
+
+def test_current_penalty_no_history(sql_session: Session) -> None:
+    assert current_penalty(sql_session) == (
+        DEFAULT_PENALTY_THRESHOLD,
+        DEFAULT_PENALTY_MULTIPLIER_PERCENT,
+    )
+
+
+def test_current_penalty_with_history(sql_session: Session) -> None:
+    user = User("Admin User")
+    sql_session.add(user)
+    sql_session.commit()
+
+    transactions = [
+        Transaction.adjust_penalty(
+            penalty_threshold=-200,
+            penalty_multiplier_percent=150,
+            user_id=user.id,
+        ),
+        Transaction.adjust_penalty(
+            penalty_threshold=-300,
+            penalty_multiplier_percent=200,
+            user_id=user.id,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    assert current_penalty(sql_session) == (-300, 200)

tests/queries/test_joint_buy_product.py

@@ -0,0 +1,199 @@
+from datetime import datetime, timedelta
+
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, Transaction, User
+from dibbler.queries import joint_buy_product
+
+
+def insert_test_data(sql_session: Session) -> tuple[User, User, User, Product]:
+    user1 = User("Test User 1")
+    user2 = User("Test User 2")
+    user3 = User("Test User 3")
+    product = Product("1234567890123", "Test Product")
+
+    sql_session.add_all([user1, user2, user3, product])
+    sql_session.commit()
+
+    transactions = [
+        Transaction.add_product(
+            user_id=user1.id,
+            product_id=product.id,
+            amount=30,
+            per_product=10,
+            product_count=3,
+            time=datetime(2024, 1, 1, 10, 0, 0),
+        )
+    ]
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    return user1, user2, user3, product
+
+
+def test_joint_buy_product_uninitialized_product(sql_session: Session) -> None:
+    user = User("Test User 1")
+    sql_session.add(user)
+    sql_session.commit()
+
+    product = Product("1234567890123", "Uninitialized Product")
+
+    with pytest.raises(ValueError):
+        joint_buy_product(
+            sql_session,
+            instigator=user,
+            users=[user],
+            product=product,
+            product_count=1,
+        )
+
+
+def test_joint_buy_product_no_users(sql_session: Session) -> None:
+    user, _, _, product = insert_test_data(sql_session)
+
+    with pytest.raises(ValueError):
+        joint_buy_product(
+            sql_session,
+            instigator=user,
+            users=[],
+            product=product,
+            product_count=1,
+        )
+
+
+def test_joint_buy_product_uninitialized_instigator(sql_session: Session) -> None:
+    user, user2, _, product = insert_test_data(sql_session)
+
+    uninitialized_user = User("Uninitialized User")
+    with pytest.raises(ValueError):
+        joint_buy_product(
+            sql_session,
+            instigator=uninitialized_user,
+            users=[user, user2],
+            product=product,
+            product_count=1,
+        )
+
+
+def test_joint_buy_product_uninitialized_user_in_list(sql_session: Session) -> None:
+    user, _, _, product = insert_test_data(sql_session)
+
+    uninitialized_user = User("Uninitialized User")
+    with pytest.raises(ValueError):
+        joint_buy_product(
+            sql_session,
+            instigator=user,
+            users=[user, uninitialized_user],
+            product=product,
+            product_count=1,
+        )
+
+
+def test_joint_buy_product_invalid_product_count(sql_session: Session) -> None:
+    user, _, _, product = insert_test_data(sql_session)
+
+    with pytest.raises(ValueError):
+        joint_buy_product(
+            sql_session,
+            instigator=user,
+            users=[user],
+            product=product,
+            product_count=0,
+        )
+
+    with pytest.raises(ValueError):
+        joint_buy_product(
+            sql_session,
+            instigator=user,
+            users=[user],
+            product=product,
+            product_count=-1,
+        )
+
+
+def test_joint_single_user(sql_session: Session) -> None:
+    user, _, _, product = insert_test_data(sql_session)
+
+    joint_buy_product(
+        sql_session,
+        instigator=user,
+        users=[user],
+        product=product,
+        product_count=1,
+    )
+
+
+def test_joint_buy_product(sql_session: Session) -> None:
+    user, user2, user3, product = insert_test_data(sql_session)
+
+    joint_buy_product(
+        sql_session,
+        instigator=user,
+        users=[user, user2, user3],
+        product=product,
+        product_count=1,
+    )
+
+
+def test_joint_buy_product_more_than_in_stock(sql_session: Session) -> None:
+    user, user2, user3, product = insert_test_data(sql_session)
+
+    joint_buy_product(
+        sql_session,
+        instigator=user,
+        users=[user, user2, user3],
+        product=product,
+        product_count=5,
+    )
+
+
+def test_joint_buy_product_out_of_stock(sql_session: Session) -> None:
+    user, user2, user3, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.buy_product(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=3,
+            time=datetime(2024, 1, 2, 10, 0, 0),
+        )
+    ]
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    joint_buy_product(
+        sql_session,
+        instigator=user,
+        users=[user, user2, user3],
+        product=product,
+        product_count=10,
+        time=transactions[-1].time + timedelta(days=1),
+    )
+
+
+def test_joint_buy_product_duplicate_user(sql_session: Session) -> None:
+    user, user2, _, product = insert_test_data(sql_session)
+
+    joint_buy_product(
+        sql_session,
+        instigator=user,
+        users=[user, user, user2],
+        product=product,
+        product_count=1,
+    )
+
+
+def test_joint_buy_product_non_involved_instigator(sql_session: Session) -> None:
+    user, user2, user3, product = insert_test_data(sql_session)
+
+    with pytest.raises(ValueError):
+        joint_buy_product(
+            sql_session,
+            instigator=user,
+            users=[user2, user3],
+            product=product,
+            product_count=1,
+        )

tests/queries/test_product_owners.py

@@ -0,0 +1,335 @@
+from datetime import datetime
+from pprint import pprint
+
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, User
+from dibbler.models.Transaction import Transaction
+from dibbler.queries import product_owners, product_owners_log, product_stock
+from tests.helpers import assign_times, assert_id_order_similar_to_time_order
+
+
+def insert_test_data(sql_session: Session) -> tuple[Product, User]:
+    user = User("testuser")
+    product = Product("1234567890123", "Test Product")
+
+    sql_session.add(user)
+    sql_session.add(product)
+
+    sql_session.commit()
+
+    return product, user
+
+
+def test_product_owners_unitilialized_product(sql_session: Session) -> None:
+    user = User("testuser")
+    sql_session.add(user)
+    sql_session.commit()
+
+    product = Product("1234567890123", "Uninitialized Product")
+
+    with pytest.raises(ValueError):
+        product_owners(sql_session, product)
+
+
+def test_product_owners_no_transactions(sql_session: Session) -> None:
+    product, _ = insert_test_data(sql_session)
+
+    pprint(product_owners_log(sql_session, product))
+
+    owners = product_owners(sql_session, product)
+    assert owners == []
+
+
+def test_product_owners_add_products(sql_session: Session) -> None:
+    product, user = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            user_id=user.id,
+            product_id=product.id,
+            amount=30,
+            per_product=10,
+            product_count=3,
+        )
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_owners_log(sql_session, product))
+
+    owners = product_owners(sql_session, product)
+    assert owners == [user, user, user]
+
+
+def test_product_owners_add_and_buy_products(sql_session: Session) -> None:
+    product, user = insert_test_data(sql_session)
+    transactions = [
+        Transaction.add_product(
+            user_id=user.id,
+            product_id=product.id,
+            amount=30,
+            per_product=10,
+            product_count=3,
+        ),
+        Transaction.buy_product(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=1,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_owners_log(sql_session, product))
+
+    owners = product_owners(sql_session, product)
+    assert owners == [user, user]
+
+
+def test_product_owners_add_and_throw_products(sql_session: Session) -> None:
+    product, user = insert_test_data(sql_session)
+    transactions = [
+        Transaction.add_product(
+            user_id=user.id,
+            product_id=product.id,
+            amount=40,
+            per_product=10,
+            product_count=4,
+        ),
+        Transaction.throw_product(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=2,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_owners_log(sql_session, product))
+
+    owners = product_owners(sql_session, product)
+    assert owners == [user, user]
+
+
+def test_product_owners_multiple_users(sql_session: Session) -> None:
+    product, user1 = insert_test_data(sql_session)
+    user2 = User("testuser2")
+    sql_session.add(user2)
+    sql_session.commit()
+    transactions = [
+        Transaction.add_product(
+            user_id=user1.id,
+            product_id=product.id,
+            amount=20,
+            per_product=10,
+            product_count=2,
+        ),
+        Transaction.add_product(
+            user_id=user2.id,
+            product_id=product.id,
+            amount=30,
+            per_product=10,
+            product_count=3,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_owners_log(sql_session, product))
+
+    owners = product_owners(sql_session, product)
+    assert owners == [user2, user2, user2, user1, user1]
+
+
+def test_product_owners_adjust_stock_down(sql_session: Session) -> None:
+    product, user = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            user_id=user.id,
+            product_id=product.id,
+            amount=50,
+            per_product=10,
+            product_count=5,
+        ),
+        Transaction.adjust_stock(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=-2,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_owners_log(sql_session, product))
+
+    assert product_stock(sql_session, product) == 3
+
+    owners = product_owners(sql_session, product)
+    assert owners == [user, user, user]
+
+
+def test_product_owners_adjust_stock_up(sql_session: Session) -> None:
+    product, user = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            user_id=user.id,
+            product_id=product.id,
+            amount=20,
+            per_product=10,
+            product_count=2,
+        ),
+        Transaction.adjust_stock(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=3,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_owners_log(sql_session, product))
+
+    owners = product_owners(sql_session, product)
+    assert owners == [user, user, None, None, None]
+
+
+def test_product_owners_negative_stock(sql_session: Session) -> None:
+    product, user = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            user_id=user.id,
+            product_id=product.id,
+            amount=10,
+            per_product=10,
+            product_count=1,
+        ),
+        Transaction.buy_product(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=2,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    owners = product_owners(sql_session, product)
+    assert owners == []
+
+
+def test_product_owners_add_products_from_negative_stock(sql_session: Session) -> None:
+    product, user = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.buy_product(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=2,
+        ),
+        Transaction.add_product(
+            user_id=user.id,
+            product_id=product.id,
+            amount=30,
+            per_product=10,
+            product_count=3,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_owners_log(sql_session, product))
+
+    owners = product_owners(sql_session, product)
+    assert owners == [user]
+
+
+def test_product_owners_interleaved_users(sql_session: Session) -> None:
+    product, user1 = insert_test_data(sql_session)
+    user2 = User("testuser2")
+    sql_session.add(user2)
+    sql_session.commit()
+
+    transactions = [
+        Transaction.add_product(
+            user_id=user1.id,
+            product_id=product.id,
+            amount=20,
+            per_product=10,
+            product_count=2,
+        ),
+        Transaction.add_product(
+            user_id=user2.id,
+            product_id=product.id,
+            amount=30,
+            per_product=10,
+            product_count=3,
+        ),
+        Transaction.buy_product(
+            user_id=user1.id,
+            product_id=product.id,
+            product_count=1,
+        ),
+        Transaction.add_product(
+            user_id=user1.id,
+            product_id=product.id,
+            amount=10,
+            per_product=10,
+            product_count=1,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_owners_log(sql_session, product))
+
+    owners = product_owners(sql_session, product)
+    assert owners == [user1, user2, user2, user2, user1]

tests/queries/test_product_price.py

@@ -0,0 +1,447 @@
+import math
+from datetime import datetime, timedelta
+from pprint import pprint
+
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, Transaction, User
+from dibbler.queries import product_price, product_price_log, joint_buy_product
+from tests.helpers import assert_id_order_similar_to_time_order, assign_times
+
+# TODO: see if we can use pytest_runtest_makereport to print the "product_price_log"s
+#       only on failures instead of inlining it in every test function
+
+
+def insert_test_data(sql_session: Session) -> tuple[User, Product]:
+    user = User("Test User")
+    product = Product("1234567890123", "Test Product")
+
+    sql_session.add(user)
+    sql_session.add(product)
+    sql_session.commit()
+
+    return user, product
+
+
+def test_product_price_uninitialized_product(sql_session: Session) -> None:
+    user = User("Test User")
+    sql_session.add(user)
+    sql_session.commit()
+
+    product = Product("1234567890123", "Uninitialized Product")
+
+    with pytest.raises(ValueError, match="Product must be persisted in the database."):
+        product_price(sql_session, product)
+
+
+def test_product_price_no_transactions(sql_session: Session) -> None:
+    _, product = insert_test_data(sql_session)
+
+    pprint(product_price_log(sql_session, product))
+
+    assert product_price(sql_session, product) == 0
+
+
+def test_product_price_basic_history(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            time=datetime(2023, 10, 1, 12, 0, 0),
+            amount=27 * 2 - 1,
+            per_product=27,
+            product_count=2,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+    ]
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    pprint(product_price_log(sql_session, product))
+
+    assert product_price(sql_session, product) == 27
+
+
+def test_product_price_sold_out(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            amount=27 * 2 - 1,
+            per_product=27,
+            product_count=2,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        Transaction.buy_product(
+            product_count=2,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_price_log(sql_session, product))
+
+    assert product_price(sql_session, product) == 27
+
+
+def test_product_price_interest(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.adjust_interest(
+            interest_rate_percent=110,
+            user_id=user.id,
+        ),
+        Transaction.add_product(
+            amount=27 * 2 - 1,
+            per_product=27,
+            product_count=2,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_price_log(sql_session, product))
+
+    product_price_ = product_price(sql_session, product)
+    product_price_interest = product_price(sql_session, product, include_interest=True)
+
+    assert product_price_ == 27
+    assert product_price_interest == math.ceil(27 * 1.1)
+
+
+def test_product_price_changing_interest(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.adjust_interest(
+            interest_rate_percent=110,
+            user_id=user.id,
+        ),
+        Transaction.add_product(
+            amount=27 * 2 - 1,
+            per_product=27,
+            product_count=2,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        Transaction.adjust_interest(
+            interest_rate_percent=120,
+            user_id=user.id,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_price_log(sql_session, product))
+
+    product_price_interest = product_price(sql_session, product, include_interest=True)
+    assert product_price_interest == math.ceil(27 * 1.2)
+
+
+def test_product_price_old_transaction(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            amount=27 * 2,
+            per_product=27,
+            product_count=2,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        # Price should be 27
+        Transaction.add_product(
+            amount=38 * 3,
+            per_product=38,
+            product_count=3,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        # price should be averaged upwards
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    until_transaction = transactions[0]
+
+    pprint(
+        product_price_log(
+            sql_session,
+            product,
+            until_transaction=until_transaction,
+        )
+    )
+
+    product_price_ = product_price(
+        sql_session,
+        product,
+        until_transaction=until_transaction,
+    )
+    assert product_price_ == 27
+
+
+# Price goes up and gets rounded up to the next integer
+def test_product_price_round_up_from_below(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            amount=27 * 2,
+            per_product=27,
+            product_count=2,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        # Price should be 27
+        Transaction.add_product(
+            amount=38 * 3,
+            per_product=38,
+            product_count=3,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        # price should be averaged upwards
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_price_log(sql_session, product))
+
+    product_price_ = product_price(sql_session, product)
+    assert product_price_ == math.ceil((27 * 2 + 38 * 3) / (2 + 3))
+
+
+# Price goes down and gets rounded up to the next integer
+def test_product_price_round_up_from_above(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            amount=27 * 2,
+            per_product=27,
+            product_count=2,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        # Price should be 27
+        Transaction.add_product(
+            amount=20 * 3,
+            per_product=20,
+            product_count=3,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        # price should be averaged downwards
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_price_log(sql_session, product))
+
+    product_price_ = product_price(sql_session, product)
+    assert product_price_ == math.ceil((27 * 2 + 20 * 3) / (2 + 3))
+
+
+def test_product_price_with_negative_stock_single_addition(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            amount=1,
+            per_product=10,
+            product_count=1,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        Transaction.buy_product(
+            product_count=10,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        Transaction.add_product(
+            amount=22,
+            per_product=22,
+            product_count=1,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_price_log(sql_session, product))
+
+    # Stock went subzero, price should be the last added product price
+    product1_price = product_price(sql_session, product)
+    assert product1_price == 22
+
+
+def test_product_price_with_negative_stock_multiple_additions(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            amount=1,
+            per_product=10,
+            product_count=1,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        Transaction.buy_product(
+            product_count=10,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        Transaction.add_product(
+            amount=22,
+            per_product=22,
+            product_count=1,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+        Transaction.add_product(
+            amount=29,
+            per_product=29,
+            product_count=2,
+            user_id=user.id,
+            product_id=product.id,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    pprint(product_price_log(sql_session, product))
+
+    # Stock went subzero, price should be the last added product price
+    product1_price = product_price(sql_session, product)
+    assert product1_price == math.ceil(29)
+
+
+def test_product_price_joint_transactions(sql_session: Session) -> None:
+    user1, product = insert_test_data(sql_session)
+    user2 = User("Test User 2")
+    sql_session.add(user2)
+    sql_session.commit()
+
+    transactions = [
+        Transaction.add_product(
+            amount=30 * 3,
+            per_product=30,
+            product_count=3,
+            user_id=user1.id,
+            product_id=product.id,
+        ),
+        Transaction.add_product(
+            amount=20 * 2,
+            per_product=20,
+            product_count=2,
+            user_id=user2.id,
+            product_id=product.id,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    product_price_ = product_price(sql_session, product)
+    assert product_price_ == math.ceil((30 * 3 + 20 * 2) / (3 + 2))
+
+    transactions += joint_buy_product(
+        sql_session,
+        instigator=user1,
+        users=[user1, user2],
+        product=product,
+        product_count=2,
+        time=transactions[-1].time + timedelta(seconds=1),
+    )
+
+    pprint(product_price_log(sql_session, product))
+
+    old_product_price = product_price_
+    product_price_ = product_price(sql_session, product)
+    assert product_price_ == old_product_price, (
+        "Joint buy transactions should not affect product price"
+    )
+
+    transactions = [
+        Transaction.add_product(
+            amount=25 * 4,
+            per_product=25,
+            product_count=4,
+            user_id=user1.id,
+            product_id=product.id,
+            time=transactions[-1].time + timedelta(seconds=1),
+        ),
+    ]
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    pprint(product_price_log(sql_session, product))
+    product_price_ = product_price(sql_session, product)
+
+    # Expected state:
+    # Added products:
+    #   Count: 3 + 2 = 5, Price: (30 * 3 + 20 * 2) / 5 = 26
+    # Joint bought products:
+    #   Count: 5 - 2 = 3, Price: n/a (should not affect price)
+    # Added products:
+    #   Count: 3 + 4 = 7, Price: (26 * 3 + 25 * 4) / (3 + 4) = 25.57 -> 26
+
+    assert product_price_ == math.ceil((26 * 3 + 25 * 4) / (3 + 4))
+
+
+def test_product_price_until(sql_session: Session) -> None: ...

tests/queries/test_product_stock.py

@@ -0,0 +1,285 @@
+from datetime import datetime, timedelta
+
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product, Transaction, User
+from dibbler.queries import joint_buy_product, product_stock
+from tests.helpers import assert_id_order_similar_to_time_order, assign_times
+
+
+def insert_test_data(sql_session: Session) -> tuple[User, Product]:
+    user = User("Test User 1")
+    product = Product("1234567890123", "Test Product")
+    sql_session.add(user)
+    sql_session.add(product)
+    sql_session.commit()
+    return user, product
+
+
+def test_product_stock_uninitialized_product(sql_session: Session) -> None:
+    user = User("Test User 1")
+    sql_session.add(user)
+    sql_session.commit()
+
+    product = Product("1234567890123", "Uninitialized Product")
+
+    with pytest.raises(ValueError):
+        product_stock(sql_session, product)
+
+
+def test_product_stock_until_datetime_and_transaction_id_not_allowed(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transaction = Transaction.add_product(
+        amount=10,
+        per_product=10,
+        user_id=user.id,
+        product_id=product.id,
+        product_count=1,
+    )
+
+    with pytest.raises(ValueError):
+        product_stock(
+            sql_session,
+            product,
+            until_time=datetime.now(),
+            until_transaction=transaction,
+        )
+
+
+def test_product_stock_basic_history(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    sql_session.commit()
+
+    transactions = [
+        Transaction.add_product(
+            amount=10,
+            per_product=10,
+            user_id=user.id,
+            product_id=product.id,
+            product_count=1,
+        ),
+    ]
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert product_stock(sql_session, product) == 1
+
+
+def test_product_stock_adjust_stock_up(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            user_id=user.id,
+            product_id=product.id,
+            amount=50,
+            per_product=10,
+            product_count=5,
+        ),
+        Transaction.adjust_stock(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=2,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    assert product_stock(sql_session, product) == 5 + 2
+
+
+def test_product_stock_adjust_stock_down(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            user_id=user.id,
+            product_id=product.id,
+            amount=50,
+            per_product=10,
+            product_count=5,
+        ),
+        Transaction.adjust_stock(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=-2,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    assert product_stock(sql_session, product) == 5 - 2
+
+
+def test_product_stock_complex_history(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            amount=27 * 2,
+            per_product=27,
+            user_id=user.id,
+            product_id=product.id,
+            product_count=2,
+        ),
+        Transaction.buy_product(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=3,
+        ),
+        Transaction.add_product(
+            amount=50 * 4,
+            per_product=50,
+            user_id=user.id,
+            product_id=product.id,
+            product_count=4,
+        ),
+        Transaction.adjust_stock(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=3,
+        ),
+        Transaction.adjust_stock(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=-2,
+        ),
+        Transaction.throw_product(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=1,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    assert product_stock(sql_session, product) == 2 - 3 + 4 + 3 - 2 - 1
+
+
+def test_product_stock_no_transactions(sql_session: Session) -> None:
+    _, product = insert_test_data(sql_session)
+
+    assert product_stock(sql_session, product) == 0
+
+
+def test_negative_product_stock(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            amount=50,
+            per_product=50,
+            user_id=user.id,
+            product_id=product.id,
+            product_count=1,
+        ),
+        Transaction.buy_product(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=2,
+        ),
+        Transaction.adjust_stock(
+            user_id=user.id,
+            product_id=product.id,
+            product_count=-1,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    # The stock should be negative because we added and bought the product
+    assert product_stock(sql_session, product) == 1 - 2 - 1
+
+
+def test_product_stock_joint_transaction(sql_session: Session) -> None:
+    user1, product = insert_test_data(sql_session)
+
+    user2 = User("Test User 2")
+    sql_session.add(user2)
+    sql_session.commit()
+
+    transactions = [
+        Transaction.add_product(
+            time=datetime(2023, 10, 1, 17, 0, 0),
+            amount=100,
+            per_product=100,
+            user_id=user1.id,
+            product_id=product.id,
+            product_count=5,
+        ),
+    ]
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    joint_buy_product(
+        sql_session,
+        time=transactions[0].time + timedelta(seconds=1),
+        instigator=user1,
+        users=[user1, user2],
+        product=product,
+        product_count=3,
+    )
+
+    assert product_stock(sql_session, product) == 5 - 3
+
+
+def test_product_stock_until_time(sql_session: Session) -> None:
+    user, product = insert_test_data(sql_session)
+
+    transactions = [
+        Transaction.add_product(
+            amount=10,
+            per_product=10,
+            user_id=user.id,
+            product_id=product.id,
+            product_count=1,
+        ),
+        Transaction.add_product(
+            amount=20,
+            per_product=10,
+            user_id=user.id,
+            product_id=product.id,
+            product_count=2,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    assert (
+        product_stock(
+            sql_session,
+            product,
+            until_time=transactions[-1].time - timedelta(seconds=1),
+        )
+        == 1
+    )

tests/queries/test_search_product.py

@@ -0,0 +1,96 @@
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import Product
+from dibbler.queries import search_product
+
+
+def insert_test_data(sql_session: Session) -> list[Product]:
+    products = [
+        Product("1234567890123", "Test Product A"),
+        Product("2345678901234", "Test Product B"),
+        Product("3456789012345", "Another Product"),
+        Product("4567890123456", "Hidden Product", hidden=True),
+    ]
+
+    sql_session.add_all(products)
+    sql_session.commit()
+
+    return products
+
+
+def test_search_product_empty_not_allowed(sql_session: Session) -> None:
+    insert_test_data(sql_session)
+
+    with pytest.raises(ValueError):
+        search_product("", sql_session)
+
+
+def test_search_product_no_products(sql_session: Session) -> None:
+    result = search_product("Nonexistent Product", sql_session)
+
+    assert isinstance(result, list)
+
+    assert len(result) == 0
+
+
+def test_search_product_name_exact_match(sql_session: Session) -> None:
+    insert_test_data(sql_session)
+
+    result = search_product("Test Product A", sql_session)
+    assert isinstance(result, Product)
+    assert result.bar_code == "1234567890123"
+
+
+def test_search_product_name_partial_match(sql_session: Session) -> None:
+    insert_test_data(sql_session)
+
+    result = search_product("Test Product", sql_session)
+    assert isinstance(result, list)
+    assert len(result) == 2
+    names = {product.name for product in result}
+    assert names == {"Test Product A", "Test Product B"}
+
+
+def test_search_product_name_no_match(sql_session: Session) -> None:
+    insert_test_data(sql_session)
+
+    result = search_product("Nonexistent", sql_session)
+    assert isinstance(result, list)
+    assert len(result) == 0
+
+
+def test_search_product_barcode_exact_match(sql_session: Session) -> None:
+    products = insert_test_data(sql_session)
+
+    product = products[1]  # Test Product B
+
+    result = search_product(product.bar_code, sql_session)
+    assert isinstance(result, Product)
+    assert result.name == product.name
+
+
+# Should not be able to find hidden products
+def test_search_product_hidden_products(sql_session: Session) -> None:
+    insert_test_data(sql_session)
+    result = search_product("Hidden Product", sql_session)
+    assert isinstance(result, list)
+    assert len(result) == 0
+
+
+# Should be able to find hidden products if specified
+def test_search_product_find_hidden_products(sql_session: Session) -> None:
+    insert_test_data(sql_session)
+    result = search_product("Hidden Product", sql_session, find_hidden_products=True)
+    assert isinstance(result, Product)
+    assert result.name == "Hidden Product"
+
+
+# Should be able to find hidden products by barcode despite not specified
+def test_search_product_hidden_products_by_barcode(sql_session: Session) -> None:
+    products = insert_test_data(sql_session)
+    hidden_product = products[3]  # Hidden Product
+
+    result = search_product(hidden_product.bar_code, sql_session)
+    assert isinstance(result, Product)
+    assert result.name == "Hidden Product"

tests/queries/test_search_user.py

@@ -0,0 +1,86 @@
+from sqlalchemy.orm import Session
+import pytest
+
+from dibbler.models import User
+from dibbler.queries import search_user
+
+USER = [
+    ("alice", 123),
+    ("bob", 125),
+    ("charlie", 126),
+    ("david", 127),
+    ("eve", 128),
+    ("evey", 129),
+    ("evy", 130),
+    ("-symbol-man", 131),
+    ("user_123", 132),
+]
+
+
+def setup_users(sql_session: Session) -> None:
+    for username, rfid in USER:
+        user = User(name=username, rfid=str(rfid))
+        sql_session.add(user)
+    sql_session.commit()
+
+
+def test_search_user_empty_not_allowed(sql_session: Session) -> None:
+    setup_users(sql_session)
+
+    with pytest.raises(ValueError):
+        search_user("", sql_session)
+
+
+def test_search_user_exact_match(sql_session: Session) -> None:
+    setup_users(sql_session)
+
+    user = search_user("alice", sql_session)
+    assert user is not None
+    assert isinstance(user, User)
+    assert user.name == "alice"
+
+    user = search_user("125", sql_session)
+    assert user is not None
+    assert isinstance(user, User)
+    assert user.name == "bob"
+
+
+def test_search_user_partial_match(sql_session: Session) -> None:
+    setup_users(sql_session)
+
+    users = search_user("ev", sql_session)
+    assert isinstance(users, list)
+    assert len(users) == 3
+    names = {user.name for user in users}
+    assert names == {"eve", "evey", "evy"}
+
+    users = search_user("user", sql_session)
+    assert isinstance(users, list)
+    assert len(users) == 1
+    assert users[0].name == "user_123"
+
+
+def test_search_user_no_match(sql_session: Session) -> None:
+    setup_users(sql_session)
+
+    result = search_user("nonexistent", sql_session)
+    assert isinstance(result, list)
+    assert len(result) == 0
+
+
+def test_search_user_special_characters(sql_session: Session) -> None:
+    setup_users(sql_session)
+
+    user = search_user("-symbol-man", sql_session)
+    assert user is not None
+    assert isinstance(user, User)
+    assert user.name == "-symbol-man"
+
+
+def test_search_by_rfid(sql_session: Session) -> None:
+    setup_users(sql_session)
+
+    user = search_user("130", sql_session)
+    assert user is not None
+    assert isinstance(user, User)
+    assert user.name == "evy"

tests/queries/test_transaction_log.py

@@ -0,0 +1,687 @@
+from datetime import datetime, timedelta
+
+import pytest
+from sqlalchemy.orm import Session
+
+from dibbler.models import (
+    Product,
+    Transaction,
+    TransactionType,
+    User,
+)
+from dibbler.queries import transaction_log
+from tests.helpers import assert_id_order_similar_to_time_order, assign_times
+
+
+def insert_test_data(sql_session: Session) -> tuple[User, User, Product, Product]:
+    user1 = User("Test User 1")
+    user2 = User("Test User 2")
+
+    product1 = Product("1234567890123", "Test Product 1")
+    product2 = Product("9876543210987", "Test Product 2")
+    sql_session.add_all([user1, user2, product1, product2])
+    sql_session.commit()
+
+    return user1, user2, product1, product2
+
+
+def insert_default_test_transactions(
+    sql_session: Session,
+    user1: User,
+    user2: User,
+    product1: Product,
+    product2: Product,
+) -> list[Transaction]:
+    transactions = [
+        Transaction.adjust_balance(
+            amount=100,
+            user_id=user1.id,
+        ),
+        Transaction.adjust_balance(
+            amount=50,
+            user_id=user2.id,
+        ),
+        Transaction.adjust_balance(
+            amount=-50,
+            user_id=user1.id,
+        ),
+        Transaction.add_product(
+            amount=27 * 2,
+            per_product=27,
+            product_count=2,
+            user_id=user1.id,
+            product_id=product1.id,
+        ),
+        Transaction.buy_product(
+            product_count=1,
+            user_id=user2.id,
+            product_id=product2.id,
+        ),
+        Transaction.add_product(
+            amount=15 * 1,
+            per_product=15,
+            product_count=1,
+            user_id=user2.id,
+            product_id=product2.id,
+        ),
+        Transaction.transfer(
+            amount=30,
+            user_id=user1.id,
+            transfer_user_id=user2.id,
+        ),
+    ]
+
+    assign_times(transactions)
+
+    sql_session.add_all(transactions)
+    sql_session.commit()
+
+    assert_id_order_similar_to_time_order(transactions)
+
+    return transactions
+
+
+def test_transaction_log_invalid_limit(sql_session: Session) -> None:
+    with pytest.raises(ValueError):
+        transaction_log(sql_session, limit=0)
+
+    with pytest.raises(ValueError):
+        transaction_log(sql_session, limit=-1)
+
+
+def test_transaction_log_uninitialized_user(sql_session: Session) -> None:
+    user = User("Uninitialized User")
+
+    with pytest.raises(ValueError):
+        transaction_log(sql_session, user=user)
+
+
+def test_transaction_log_uninitialized_product(sql_session: Session) -> None:
+    product = Product("1234567890123", "Uninitialized Product")
+
+    with pytest.raises(ValueError):
+        transaction_log(sql_session, product=product)
+
+
+def test_transaction_log_uninitialized_after_until_transaction(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    uninitialized_transaction = Transaction.adjust_balance(
+        time=datetime(2023, 10, 1, 10, 0, 0),
+        amount=100,
+        user_id=user.id,
+    )
+
+    with pytest.raises(ValueError):
+        transaction_log(
+            sql_session,
+            user=user,
+            after_transaction=uninitialized_transaction,
+        )
+
+    with pytest.raises(ValueError):
+        transaction_log(
+            sql_session,
+            user=user,
+            until_transaction=uninitialized_transaction,
+        )
+
+
+def test_transaction_log_product_and_user_not_allowed(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    with pytest.raises(ValueError):
+        transaction_log(
+            sql_session,
+            user=user,
+            product=product,
+        )
+
+
+def test_transaction_log_until_datetime_and_transaction_id_not_allowed(
+    sql_session: Session,
+) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    trx = Transaction.adjust_balance(
+        time=datetime(2023, 10, 1, 10, 0, 0),
+        amount=100,
+        user_id=user.id,
+    )
+    sql_session.add(trx)
+    sql_session.commit()
+
+    with pytest.raises(ValueError):
+        transaction_log(
+            sql_session,
+            user=user,
+            until_time=datetime(2023, 10, 1, 11, 0, 0),
+            until_transaction=trx,
+        )
+
+
+def test_transaction_log_after_datetime_and_transaction_id_not_allowed(
+    sql_session: Session,
+) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    trx = Transaction.adjust_balance(
+        time=datetime(2023, 10, 1, 10, 0, 0),
+        amount=100,
+        user_id=user.id,
+    )
+    sql_session.add(trx)
+    sql_session.commit()
+
+    with pytest.raises(ValueError):
+        transaction_log(
+            sql_session,
+            user=user,
+            after_time=datetime(2023, 10, 1, 15, 0, 0),
+            after_transaction=trx,
+        )
+
+
+def test_user_transactions_no_transactions(sql_session: Session) -> None:
+    insert_test_data(sql_session)
+
+    transactions = transaction_log(sql_session)
+
+    assert len(transactions) == 0
+
+
+def test_transaction_log_basic(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert len(transaction_log(sql_session)) == 7
+
+
+def test_transaction_log_filtered_by_user(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert len(transaction_log(sql_session, user=user)) == 4
+    assert len(transaction_log(sql_session, user=user2)) == 3
+
+
+def test_transaction_log_filtered_by_product(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert len(transaction_log(sql_session, product=product)) == 1
+    assert len(transaction_log(sql_session, product=product2)) == 2
+
+
+def test_transaction_log_after_datetime(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                after_time=transactions[2].time,
+            )
+        )
+        == len(transactions) - 2
+    )
+
+
+def test_transaction_log_after_datetime_no_transactions(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                after_time=transactions[-1].time + timedelta(seconds=1),
+            )
+        )
+        == 0
+    )
+
+
+def test_transaction_log_after_datetime_exclusive(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                after_time=transactions[2].time,
+                after_inlcusive=False,
+            )
+        )
+        == len(transactions) - 3
+    )
+
+
+def test_transaction_log_after_transaction_id(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    first_transaction = transactions[0]
+
+    assert len(
+        transaction_log(
+            sql_session,
+            after_transaction=first_transaction,
+        )
+    ) == len(transactions)
+
+
+def test_transaction_log_after_transaction_id_one_transaction(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    last_transaction = transactions[-1]
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                after_transaction=last_transaction,
+            )
+        )
+        == 1
+    )
+
+
+def test_transaction_log_after_transaction_id_exclusive(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    third_transaction = transactions[2]
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                after_transaction=third_transaction,
+                after_inlcusive=False,
+            )
+        )
+        == len(transactions) - 3
+    )
+
+
+def test_transaction_log_until_datetime(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                until_time=transactions[-3].time,
+            )
+        )
+        == len(transactions) - 2
+    )
+
+
+def test_transaction_log_until_datetime_no_transactions(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                until_time=transactions[0].time - timedelta(seconds=1),
+            )
+        )
+        == 0
+    )
+
+
+def test_transaction_log_until_datetime_exclusive(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                until_time=transactions[-3].time,
+                until_inclusive=False,
+            )
+        )
+        == len(transactions) - 3
+    )
+
+
+def test_transaction_log_until_transaction(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    last_transaction = transactions[-3]
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                until_transaction=last_transaction,
+            )
+        )
+        == len(transactions) - 2
+    )
+
+
+def test_transaction_log_until_transaction_one_transaction(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    first_transaction = transactions[0]
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                until_transaction=first_transaction,
+            )
+        )
+        == 1
+    )
+
+
+def test_transaction_log_until_transaction_exclusive(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    last_transaction = transactions[-3]
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                until_transaction=last_transaction,
+                until_inclusive=False,
+            )
+        )
+        == len(transactions) - 3
+    )
+
+
+def test_transaction_log_after_until_datetime_illegal_order(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    second_transaction = transactions[1]
+    fifth_transaction = transactions[4]
+
+    with pytest.raises(ValueError):
+        transaction_log(
+            sql_session,
+            after_time=fifth_transaction.time,
+            until_time=second_transaction.time,
+        )
+
+
+def test_transaction_log_after_until_datetime_combined(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    second_transaction = transactions[1]
+    fifth_transaction = transactions[4]
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                after_time=second_transaction.time,
+                until_time=fifth_transaction.time,
+            )
+        )
+        == 4
+    )
+
+
+def test_transaction_log_after_until_transaction_illegal_order(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    second_transaction = transactions[1]
+    fifth_transaction = transactions[4]
+
+    with pytest.raises(ValueError):
+        transaction_log(
+            sql_session,
+            after_transaction=fifth_transaction,
+            until_transaction=second_transaction,
+        )
+
+
+def test_transaction_log_after_until_transaction_combined(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    second_transaction = transactions[1]
+    fifth_transaction = transactions[4]
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                after_transaction=second_transaction,
+                until_transaction=fifth_transaction,
+            )
+        )
+        == 4
+    )
+
+
+def test_transaction_log_after_date_until_transaction(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    second_transaction = transactions[1]
+    fifth_transaction = transactions[4]
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                after_time=second_transaction.time,
+                until_transaction=fifth_transaction,
+            )
+        )
+        == 4
+    )
+
+
+def test_transaction_log_after_transaction_until_date(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    second_transaction = transactions[1]
+    fifth_transaction = transactions[4]
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                after_transaction=second_transaction,
+                until_time=fifth_transaction.time,
+            )
+        )
+        == 4
+    )
+
+
+def test_transaction_log_limit(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert len(transaction_log(sql_session, limit=3)) == 3
+    assert len(transaction_log(sql_session, limit=len(transactions) + 3)) == len(transactions)
+
+
+def test_transaction_log_filtered_by_transaction_type(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                transaction_type=[TransactionType.ADJUST_BALANCE],
+            )
+        )
+        == 3
+    )
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                transaction_type=[TransactionType.ADD_PRODUCT],
+            )
+        )
+        == 2
+    )
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                transaction_type=[TransactionType.BUY_PRODUCT, TransactionType.ADD_PRODUCT],
+            )
+        )
+        == 3
+    )
+
+
+def test_transaction_log_filtered_by_transaction_type_negated(sql_session: Session) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                transaction_type=[TransactionType.ADJUST_BALANCE],
+                negate_transaction_type_filter=True,
+            )
+        )
+        == len(transactions) - 3
+    )
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                transaction_type=[TransactionType.ADD_PRODUCT],
+                negate_transaction_type_filter=True,
+            )
+        )
+        == len(transactions) - 2
+    )
+    assert (
+        len(
+            transaction_log(
+                sql_session,
+                transaction_type=[TransactionType.BUY_PRODUCT, TransactionType.ADD_PRODUCT],
+                negate_transaction_type_filter=True,
+            )
+        )
+        == len(transactions) - 3
+    )
+
+
+def test_transaction_log_combined_filter_user_datetime_transaction_type_limit(
+    sql_session: Session,
+) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    second_transaction = transactions[1]
+    sixth_transaction = transactions[5]
+
+    result = transaction_log(
+        sql_session,
+        user=user,
+        after_time=second_transaction.time,
+        until_time=sixth_transaction.time,
+        transaction_type=[TransactionType.ADJUST_BALANCE, TransactionType.ADD_PRODUCT],
+        limit=2,
+    )
+
+    assert len(result) == 2
+
+
+def test_transaction_log_combined_filter_user_transaction_transaction_type_limit(
+    sql_session: Session,
+) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    second_transaction = transactions[1]
+    sixth_transaction = transactions[5]
+
+    result = transaction_log(
+        sql_session,
+        user=user,
+        after_transaction=second_transaction,
+        until_transaction=sixth_transaction,
+        transaction_type=[TransactionType.ADJUST_BALANCE, TransactionType.ADD_PRODUCT],
+        limit=2,
+    )
+
+    assert len(result) == 2
+
+
+def test_transaction_log_combined_filter_product_datetime_transaction_type_limit(
+    sql_session: Session,
+) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    second_transaction = transactions[1]
+    sixth_transaction = transactions[5]
+
+    result = transaction_log(
+        sql_session,
+        product=product2,
+        after_time=second_transaction.time,
+        until_time=sixth_transaction.time,
+        transaction_type=[TransactionType.BUY_PRODUCT, TransactionType.ADD_PRODUCT],
+        limit=2,
+    )
+
+    assert len(result) == 2
+
+
+def test_transaction_log_combined_filter_product_transaction_transaction_type_limit(
+    sql_session: Session,
+) -> None:
+    user, user2, product, product2 = insert_test_data(sql_session)
+    transactions = insert_default_test_transactions(sql_session, user, user2, product, product2)
+
+    second_transaction = transactions[1]
+    sixth_transaction = transactions[5]
+
+    result = transaction_log(
+        sql_session,
+        product=product2,
+        after_transaction=second_transaction,
+        until_transaction=sixth_transaction,
+        transaction_type=[TransactionType.BUY_PRODUCT, TransactionType.ADD_PRODUCT],
+        limit=2,
+    )
+
+    assert len(result) == 2
+
+
+# NOTE: see the corresponding TODO's above the function definition
+
+
+@pytest.mark.skip(reason="Not yet implemented")
+def test_transaction_log_filtered_by_user_joint_transactions(sql_session: Session) -> None: ...
+
+
+@pytest.mark.skip(reason="Not yet implemented")
+def test_transaction_log_filtered_by_user_throw_away_transactions(sql_session: Session) -> None: ...

uv.lock

@@ -131,6 +131,111 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" },
 ]
 
+[[package]]
+name = "coverage"
+version = "7.13.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b6/45/2c665ca77ec32ad67e25c77daf1cee28ee4558f3bc571cdbaf88a00b9f23/coverage-7.13.0.tar.gz", hash = "sha256:a394aa27f2d7ff9bc04cf703817773a59ad6dfbd577032e690f961d2460ee936", size = 820905, upload-time = "2025-12-08T13:14:38.055Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/dc/888bf90d8b1c3d0b4020a40e52b9f80957d75785931ec66c7dfaccc11c7d/coverage-7.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0dfa3855031070058add1a59fdfda0192fd3e8f97e7c81de0596c145dea51820", size = 218104, upload-time = "2025-12-08T13:12:33.333Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/ea/069d51372ad9c380214e86717e40d1a743713a2af191cfba30a0911b0a4a/coverage-7.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4fdb6f54f38e334db97f72fa0c701e66d8479af0bc3f9bfb5b90f1c30f54500f", size = 218606, upload-time = "2025-12-08T13:12:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/68/09/77b1c3a66c2aa91141b6c4471af98e5b1ed9b9e6d17255da5eb7992299e3/coverage-7.13.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7e442c013447d1d8d195be62852270b78b6e255b79b8675bad8479641e21fd96", size = 248999, upload-time = "2025-12-08T13:12:36.02Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/32/2e2f96e9d5691eaf1181d9040f850b8b7ce165ea10810fd8e2afa534cef7/coverage-7.13.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1ed5630d946859de835a85e9a43b721123a8a44ec26e2830b296d478c7fd4259", size = 250925, upload-time = "2025-12-08T13:12:37.221Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/45/b88ddac1d7978859b9a39a8a50ab323186148f1d64bc068f86fc77706321/coverage-7.13.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f15a931a668e58087bc39d05d2b4bf4b14ff2875b49c994bbdb1c2217a8daeb", size = 253032, upload-time = "2025-12-08T13:12:38.763Z" },
+    { url = "https://files.pythonhosted.org/packages/71/cb/e15513f94c69d4820a34b6bf3d2b1f9f8755fa6021be97c7065442d7d653/coverage-7.13.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:30a3a201a127ea57f7e14ba43c93c9c4be8b7d17a26e03bb49e6966d019eede9", size = 249134, upload-time = "2025-12-08T13:12:40.382Z" },
+    { url = "https://files.pythonhosted.org/packages/09/61/d960ff7dc9e902af3310ce632a875aaa7860f36d2bc8fc8b37ee7c1b82a5/coverage-7.13.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7a485ff48fbd231efa32d58f479befce52dcb6bfb2a88bb7bf9a0b89b1bc8030", size = 250731, upload-time = "2025-12-08T13:12:41.992Z" },
+    { url = "https://files.pythonhosted.org/packages/98/34/c7c72821794afc7c7c2da1db8f00c2c98353078aa7fb6b5ff36aac834b52/coverage-7.13.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:22486cdafba4f9e471c816a2a5745337742a617fef68e890d8baf9f3036d7833", size = 248795, upload-time = "2025-12-08T13:12:43.331Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5b/e0f07107987a43b2def9aa041c614ddb38064cbf294a71ef8c67d43a0cdd/coverage-7.13.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:263c3dbccc78e2e331e59e90115941b5f53e85cfcc6b3b2fbff1fd4e3d2c6ea8", size = 248514, upload-time = "2025-12-08T13:12:44.546Z" },
+    { url = "https://files.pythonhosted.org/packages/71/c2/c949c5d3b5e9fc6dd79e1b73cdb86a59ef14f3709b1d72bf7668ae12e000/coverage-7.13.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e5330fa0cc1f5c3c4c3bb8e101b742025933e7848989370a1d4c8c5e401ea753", size = 249424, upload-time = "2025-12-08T13:12:45.759Z" },
+    { url = "https://files.pythonhosted.org/packages/11/f1/bbc009abd6537cec0dffb2cc08c17a7f03de74c970e6302db4342a6e05af/coverage-7.13.0-cp311-cp311-win32.whl", hash = "sha256:0f4872f5d6c54419c94c25dd6ae1d015deeb337d06e448cd890a1e89a8ee7f3b", size = 220597, upload-time = "2025-12-08T13:12:47.378Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f6/d9977f2fb51c10fbaed0718ce3d0a8541185290b981f73b1d27276c12d91/coverage-7.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:51a202e0f80f241ccb68e3e26e19ab5b3bf0f813314f2c967642f13ebcf1ddfe", size = 221536, upload-time = "2025-12-08T13:12:48.7Z" },
+    { url = "https://files.pythonhosted.org/packages/be/ad/3fcf43fd96fb43e337a3073dea63ff148dcc5c41ba7a14d4c7d34efb2216/coverage-7.13.0-cp311-cp311-win_arm64.whl", hash = "sha256:d2a9d7f1c11487b1c69367ab3ac2d81b9b3721f097aa409a3191c3e90f8f3dd7", size = 220206, upload-time = "2025-12-08T13:12:50.365Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/f1/2619559f17f31ba00fc40908efd1fbf1d0a5536eb75dc8341e7d660a08de/coverage-7.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0b3d67d31383c4c68e19a88e28fc4c2e29517580f1b0ebec4a069d502ce1e0bf", size = 218274, upload-time = "2025-12-08T13:12:52.095Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/11/30d71ae5d6e949ff93b2a79a2c1b4822e00423116c5c6edfaeef37301396/coverage-7.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:581f086833d24a22c89ae0fe2142cfaa1c92c930adf637ddf122d55083fb5a0f", size = 218638, upload-time = "2025-12-08T13:12:53.418Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c2/fce80fc6ded8d77e53207489d6065d0fed75db8951457f9213776615e0f5/coverage-7.13.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0a3a30f0e257df382f5f9534d4ce3d4cf06eafaf5192beb1a7bd066cb10e78fb", size = 250129, upload-time = "2025-12-08T13:12:54.744Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/b6/51b5d1eb6fcbb9a1d5d6984e26cbe09018475c2922d554fd724dd0f056ee/coverage-7.13.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:583221913fbc8f53b88c42e8dbb8fca1d0f2e597cb190ce45916662b8b9d9621", size = 252885, upload-time = "2025-12-08T13:12:56.401Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/972a5affea41de798691ab15d023d3530f9f56a72e12e243f35031846ff7/coverage-7.13.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f5d9bd30756fff3e7216491a0d6d520c448d5124d3d8e8f56446d6412499e74", size = 253974, upload-time = "2025-12-08T13:12:57.718Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/56/116513aee860b2c7968aa3506b0f59b22a959261d1dbf3aea7b4450a7520/coverage-7.13.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a23e5a1f8b982d56fa64f8e442e037f6ce29322f1f9e6c2344cd9e9f4407ee57", size = 250538, upload-time = "2025-12-08T13:12:59.254Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/75/074476d64248fbadf16dfafbf93fdcede389ec821f74ca858d7c87d2a98c/coverage-7.13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9b01c22bc74a7fb44066aaf765224c0d933ddf1f5047d6cdfe4795504a4493f8", size = 251912, upload-time = "2025-12-08T13:13:00.604Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/d2/aa4f8acd1f7c06024705c12609d8698c51b27e4d635d717cd1934c9668e2/coverage-7.13.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:898cce66d0836973f48dda4e3514d863d70142bdf6dfab932b9b6a90ea5b222d", size = 250054, upload-time = "2025-12-08T13:13:01.892Z" },
+    { url = "https://files.pythonhosted.org/packages/19/98/8df9e1af6a493b03694a1e8070e024e7d2cdc77adedc225a35e616d505de/coverage-7.13.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:3ab483ea0e251b5790c2aac03acde31bff0c736bf8a86829b89382b407cd1c3b", size = 249619, upload-time = "2025-12-08T13:13:03.236Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/71/f8679231f3353018ca66ef647fa6fe7b77e6bff7845be54ab84f86233363/coverage-7.13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d84e91521c5e4cb6602fe11ece3e1de03b2760e14ae4fcf1a4b56fa3c801fcd", size = 251496, upload-time = "2025-12-08T13:13:04.511Z" },
+    { url = "https://files.pythonhosted.org/packages/04/86/9cb406388034eaf3c606c22094edbbb82eea1fa9d20c0e9efadff20d0733/coverage-7.13.0-cp312-cp312-win32.whl", hash = "sha256:193c3887285eec1dbdb3f2bd7fbc351d570ca9c02ca756c3afbc71b3c98af6ef", size = 220808, upload-time = "2025-12-08T13:13:06.422Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/59/af483673df6455795daf5f447c2f81a3d2fcfc893a22b8ace983791f6f34/coverage-7.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:4f3e223b2b2db5e0db0c2b97286aba0036ca000f06aca9b12112eaa9af3d92ae", size = 221616, upload-time = "2025-12-08T13:13:07.95Z" },
+    { url = "https://files.pythonhosted.org/packages/64/b0/959d582572b30a6830398c60dd419c1965ca4b5fb38ac6b7093a0d50ca8d/coverage-7.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:086cede306d96202e15a4b77ace8472e39d9f4e5f9fd92dd4fecdfb2313b2080", size = 220261, upload-time = "2025-12-08T13:13:09.581Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/cc/bce226595eb3bf7d13ccffe154c3c487a22222d87ff018525ab4dd2e9542/coverage-7.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:28ee1c96109974af104028a8ef57cec21447d42d0e937c0275329272e370ebcf", size = 218297, upload-time = "2025-12-08T13:13:10.977Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/9f/73c4d34600aae03447dff3d7ad1d0ac649856bfb87d1ca7d681cfc913f9e/coverage-7.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d1e97353dcc5587b85986cda4ff3ec98081d7e84dd95e8b2a6d59820f0545f8a", size = 218673, upload-time = "2025-12-08T13:13:12.562Z" },
+    { url = "https://files.pythonhosted.org/packages/63/ab/8fa097db361a1e8586535ae5073559e6229596b3489ec3ef2f5b38df8cb2/coverage-7.13.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:99acd4dfdfeb58e1937629eb1ab6ab0899b131f183ee5f23e0b5da5cba2fec74", size = 249652, upload-time = "2025-12-08T13:13:13.909Z" },
+    { url = "https://files.pythonhosted.org/packages/90/3a/9bfd4de2ff191feb37ef9465855ca56a6f2f30a3bca172e474130731ac3d/coverage-7.13.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ff45e0cd8451e293b63ced93161e189780baf444119391b3e7d25315060368a6", size = 252251, upload-time = "2025-12-08T13:13:15.553Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/b5d8105f016e1b5874af0d7c67542da780ccd4a5f2244a433d3e20ceb1ad/coverage-7.13.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f4f72a85316d8e13234cafe0a9f81b40418ad7a082792fa4165bd7d45d96066b", size = 253492, upload-time = "2025-12-08T13:13:16.849Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/b8/0fad449981803cc47a4694768b99823fb23632150743f9c83af329bb6090/coverage-7.13.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:11c21557d0e0a5a38632cbbaca5f008723b26a89d70db6315523df6df77d6232", size = 249850, upload-time = "2025-12-08T13:13:18.142Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e9/8d68337c3125014d918cf4327d5257553a710a2995a6a6de2ac77e5aa429/coverage-7.13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76541dc8d53715fb4f7a3a06b34b0dc6846e3c69bc6204c55653a85dd6220971", size = 251633, upload-time = "2025-12-08T13:13:19.56Z" },
+    { url = "https://files.pythonhosted.org/packages/55/14/d4112ab26b3a1bc4b3c1295d8452dcf399ed25be4cf649002fb3e64b2d93/coverage-7.13.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:6e9e451dee940a86789134b6b0ffbe31c454ade3b849bb8a9d2cca2541a8e91d", size = 249586, upload-time = "2025-12-08T13:13:20.883Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/a9/22b0000186db663b0d82f86c2f1028099ae9ac202491685051e2a11a5218/coverage-7.13.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:5c67dace46f361125e6b9cace8fe0b729ed8479f47e70c89b838d319375c8137", size = 249412, upload-time = "2025-12-08T13:13:22.22Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/2e/42d8e0d9e7527fba439acdc6ed24a2b97613b1dc85849b1dd935c2cffef0/coverage-7.13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f59883c643cb19630500f57016f76cfdcd6845ca8c5b5ea1f6e17f74c8e5f511", size = 251191, upload-time = "2025-12-08T13:13:23.899Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/af/8c7af92b1377fd8860536aadd58745119252aaaa71a5213e5a8e8007a9f5/coverage-7.13.0-cp313-cp313-win32.whl", hash = "sha256:58632b187be6f0be500f553be41e277712baa278147ecb7559983c6d9faf7ae1", size = 220829, upload-time = "2025-12-08T13:13:25.182Z" },
+    { url = "https://files.pythonhosted.org/packages/58/f9/725e8bf16f343d33cbe076c75dc8370262e194ff10072c0608b8e5cf33a3/coverage-7.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:73419b89f812f498aca53f757dd834919b48ce4799f9d5cad33ca0ae442bdb1a", size = 221640, upload-time = "2025-12-08T13:13:26.836Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/ff/e98311000aa6933cc79274e2b6b94a2fe0fe3434fca778eba82003675496/coverage-7.13.0-cp313-cp313-win_arm64.whl", hash = "sha256:eb76670874fdd6091eedcc856128ee48c41a9bbbb9c3f1c7c3cf169290e3ffd6", size = 220269, upload-time = "2025-12-08T13:13:28.116Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/cf/bbaa2e1275b300343ea865f7d424cc0a2e2a1df6925a070b2b2d5d765330/coverage-7.13.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6e63ccc6e0ad8986386461c3c4b737540f20426e7ec932f42e030320896c311a", size = 218990, upload-time = "2025-12-08T13:13:29.463Z" },
+    { url = "https://files.pythonhosted.org/packages/21/1d/82f0b3323b3d149d7672e7744c116e9c170f4957e0c42572f0366dbb4477/coverage-7.13.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:494f5459ffa1bd45e18558cd98710c36c0b8fbfa82a5eabcbe671d80ecffbfe8", size = 219340, upload-time = "2025-12-08T13:13:31.524Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e3/fe3fd4702a3832a255f4d43013eacb0ef5fc155a5960ea9269d8696db28b/coverage-7.13.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:06cac81bf10f74034e055e903f5f946e3e26fc51c09fc9f584e4a1605d977053", size = 260638, upload-time = "2025-12-08T13:13:32.965Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/01/63186cb000307f2b4da463f72af9b85d380236965574c78e7e27680a2593/coverage-7.13.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f2ffc92b46ed6e6760f1d47a71e56b5664781bc68986dbd1836b2b70c0ce2071", size = 262705, upload-time = "2025-12-08T13:13:34.378Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/a1/c0dacef0cc865f2455d59eed3548573ce47ed603205ffd0735d1d78b5906/coverage-7.13.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0602f701057c6823e5db1b74530ce85f17c3c5be5c85fc042ac939cbd909426e", size = 265125, upload-time = "2025-12-08T13:13:35.73Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/92/82b99223628b61300bd382c205795533bed021505eab6dd86e11fb5d7925/coverage-7.13.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:25dc33618d45456ccb1d37bce44bc78cf269909aa14c4db2e03d63146a8a1493", size = 259844, upload-time = "2025-12-08T13:13:37.69Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/2c/89b0291ae4e6cd59ef042708e1c438e2290f8c31959a20055d8768349ee2/coverage-7.13.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:71936a8b3b977ddd0b694c28c6a34f4fff2e9dd201969a4ff5d5fc7742d614b0", size = 262700, upload-time = "2025-12-08T13:13:39.525Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/f9/a5f992efae1996245e796bae34ceb942b05db275e4b34222a9a40b9fbd3b/coverage-7.13.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:936bc20503ce24770c71938d1369461f0c5320830800933bc3956e2a4ded930e", size = 260321, upload-time = "2025-12-08T13:13:41.172Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/89/a29f5d98c64fedbe32e2ac3c227fbf78edc01cc7572eee17d61024d89889/coverage-7.13.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:af0a583efaacc52ae2521f8d7910aff65cdb093091d76291ac5820d5e947fc1c", size = 259222, upload-time = "2025-12-08T13:13:43.282Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/c3/940fe447aae302a6701ee51e53af7e08b86ff6eed7631e5740c157ee22b9/coverage-7.13.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f1c23e24a7000da892a312fb17e33c5f94f8b001de44b7cf8ba2e36fbd15859e", size = 261411, upload-time = "2025-12-08T13:13:44.72Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/31/12a4aec689cb942a89129587860ed4d0fd522d5fda81237147fde554b8ae/coverage-7.13.0-cp313-cp313t-win32.whl", hash = "sha256:5f8a0297355e652001015e93be345ee54393e45dc3050af4a0475c5a2b767d46", size = 221505, upload-time = "2025-12-08T13:13:46.332Z" },
+    { url = "https://files.pythonhosted.org/packages/65/8c/3b5fe3259d863572d2b0827642c50c3855d26b3aefe80bdc9eba1f0af3b0/coverage-7.13.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6abb3a4c52f05e08460bd9acf04fec027f8718ecaa0d09c40ffbc3fbd70ecc39", size = 222569, upload-time = "2025-12-08T13:13:47.79Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/39/f71fa8316a96ac72fc3908839df651e8eccee650001a17f2c78cdb355624/coverage-7.13.0-cp313-cp313t-win_arm64.whl", hash = "sha256:3ad968d1e3aa6ce5be295ab5fe3ae1bf5bb4769d0f98a80a0252d543a2ef2e9e", size = 220841, upload-time = "2025-12-08T13:13:49.243Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/4b/9b54bedda55421449811dcd5263a2798a63f48896c24dfb92b0f1b0845bd/coverage-7.13.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:453b7ec753cf5e4356e14fe858064e5520c460d3bbbcb9c35e55c0d21155c256", size = 218343, upload-time = "2025-12-08T13:13:50.811Z" },
+    { url = "https://files.pythonhosted.org/packages/59/df/c3a1f34d4bba2e592c8979f924da4d3d4598b0df2392fbddb7761258e3dc/coverage-7.13.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:af827b7cbb303e1befa6c4f94fd2bf72f108089cfa0f8abab8f4ca553cf5ca5a", size = 218672, upload-time = "2025-12-08T13:13:52.284Z" },
+    { url = "https://files.pythonhosted.org/packages/07/62/eec0659e47857698645ff4e6ad02e30186eb8afd65214fd43f02a76537cb/coverage-7.13.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9987a9e4f8197a1000280f7cc089e3ea2c8b3c0a64d750537809879a7b4ceaf9", size = 249715, upload-time = "2025-12-08T13:13:53.791Z" },
+    { url = "https://files.pythonhosted.org/packages/23/2d/3c7ff8b2e0e634c1f58d095f071f52ed3c23ff25be524b0ccae8b71f99f8/coverage-7.13.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3188936845cd0cb114fa6a51842a304cdbac2958145d03be2377ec41eb285d19", size = 252225, upload-time = "2025-12-08T13:13:55.274Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ac/fb03b469d20e9c9a81093575003f959cf91a4a517b783aab090e4538764b/coverage-7.13.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2bdb3babb74079f021696cb46b8bb5f5661165c385d3a238712b031a12355be", size = 253559, upload-time = "2025-12-08T13:13:57.161Z" },
+    { url = "https://files.pythonhosted.org/packages/29/62/14afa9e792383c66cc0a3b872a06ded6e4ed1079c7d35de274f11d27064e/coverage-7.13.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7464663eaca6adba4175f6c19354feea61ebbdd735563a03d1e472c7072d27bb", size = 249724, upload-time = "2025-12-08T13:13:58.692Z" },
+    { url = "https://files.pythonhosted.org/packages/31/b7/333f3dab2939070613696ab3ee91738950f0467778c6e5a5052e840646b7/coverage-7.13.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8069e831f205d2ff1f3d355e82f511eb7c5522d7d413f5db5756b772ec8697f8", size = 251582, upload-time = "2025-12-08T13:14:00.642Z" },
+    { url = "https://files.pythonhosted.org/packages/81/cb/69162bda9381f39b2287265d7e29ee770f7c27c19f470164350a38318764/coverage-7.13.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:6fb2d5d272341565f08e962cce14cdf843a08ac43bd621783527adb06b089c4b", size = 249538, upload-time = "2025-12-08T13:14:02.556Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/76/350387b56a30f4970abe32b90b2a434f87d29f8b7d4ae40d2e8a85aacfb3/coverage-7.13.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:5e70f92ef89bac1ac8a99b3324923b4749f008fdbd7aa9cb35e01d7a284a04f9", size = 249349, upload-time = "2025-12-08T13:14:04.015Z" },
+    { url = "https://files.pythonhosted.org/packages/86/0d/7f6c42b8d59f4c7e43ea3059f573c0dcfed98ba46eb43c68c69e52ae095c/coverage-7.13.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4b5de7d4583e60d5fd246dd57fcd3a8aa23c6e118a8c72b38adf666ba8e7e927", size = 251011, upload-time = "2025-12-08T13:14:05.505Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/f1/4bb2dff379721bb0b5c649d5c5eaf438462cad824acf32eb1b7ca0c7078e/coverage-7.13.0-cp314-cp314-win32.whl", hash = "sha256:a6c6e16b663be828a8f0b6c5027d36471d4a9f90d28444aa4ced4d48d7d6ae8f", size = 221091, upload-time = "2025-12-08T13:14:07.127Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/44/c239da52f373ce379c194b0ee3bcc121020e397242b85f99e0afc8615066/coverage-7.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:0900872f2fdb3ee5646b557918d02279dc3af3dfb39029ac4e945458b13f73bc", size = 221904, upload-time = "2025-12-08T13:14:08.542Z" },
+    { url = "https://files.pythonhosted.org/packages/89/1f/b9f04016d2a29c2e4a0307baefefad1a4ec5724946a2b3e482690486cade/coverage-7.13.0-cp314-cp314-win_arm64.whl", hash = "sha256:3a10260e6a152e5f03f26db4a407c4c62d3830b9af9b7c0450b183615f05d43b", size = 220480, upload-time = "2025-12-08T13:14:10.958Z" },
+    { url = "https://files.pythonhosted.org/packages/16/d4/364a1439766c8e8647860584171c36010ca3226e6e45b1753b1b249c5161/coverage-7.13.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9097818b6cc1cfb5f174e3263eba4a62a17683bcfe5c4b5d07f4c97fa51fbf28", size = 219074, upload-time = "2025-12-08T13:14:13.345Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/f4/71ba8be63351e099911051b2089662c03d5671437a0ec2171823c8e03bec/coverage-7.13.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0018f73dfb4301a89292c73be6ba5f58722ff79f51593352759c1790ded1cabe", size = 219342, upload-time = "2025-12-08T13:14:15.02Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/25/127d8ed03d7711a387d96f132589057213e3aef7475afdaa303412463f22/coverage-7.13.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:166ad2a22ee770f5656e1257703139d3533b4a0b6909af67c6b4a3adc1c98657", size = 260713, upload-time = "2025-12-08T13:14:16.907Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/db/559fbb6def07d25b2243663b46ba9eb5a3c6586c0c6f4e62980a68f0ee1c/coverage-7.13.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f6aaef16d65d1787280943f1c8718dc32e9cf141014e4634d64446702d26e0ff", size = 262825, upload-time = "2025-12-08T13:14:18.68Z" },
+    { url = "https://files.pythonhosted.org/packages/37/99/6ee5bf7eff884766edb43bd8736b5e1c5144d0fe47498c3779326fe75a35/coverage-7.13.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e999e2dcc094002d6e2c7bbc1fb85b58ba4f465a760a8014d97619330cdbbbf3", size = 265233, upload-time = "2025-12-08T13:14:20.55Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/90/92f18fe0356ea69e1f98f688ed80cec39f44e9f09a1f26a1bbf017cc67f2/coverage-7.13.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:00c3d22cf6fb1cf3bf662aaaa4e563be8243a5ed2630339069799835a9cc7f9b", size = 259779, upload-time = "2025-12-08T13:14:22.367Z" },
+    { url = "https://files.pythonhosted.org/packages/90/5d/b312a8b45b37a42ea7d27d7d3ff98ade3a6c892dd48d1d503e773503373f/coverage-7.13.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22ccfe8d9bb0d6134892cbe1262493a8c70d736b9df930f3f3afae0fe3ac924d", size = 262700, upload-time = "2025-12-08T13:14:24.309Z" },
+    { url = "https://files.pythonhosted.org/packages/63/f8/b1d0de5c39351eb71c366f872376d09386640840a2e09b0d03973d791e20/coverage-7.13.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:9372dff5ea15930fea0445eaf37bbbafbc771a49e70c0aeed8b4e2c2614cc00e", size = 260302, upload-time = "2025-12-08T13:14:26.068Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/7c/d42f4435bc40c55558b3109a39e2d456cddcec37434f62a1f1230991667a/coverage-7.13.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:69ac2c492918c2461bc6ace42d0479638e60719f2a4ef3f0815fa2df88e9f940", size = 259136, upload-time = "2025-12-08T13:14:27.604Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/d3/23413241dc04d47cfe19b9a65b32a2edd67ecd0b817400c2843ebc58c847/coverage-7.13.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:739c6c051a7540608d097b8e13c76cfa85263ced467168dc6b477bae3df7d0e2", size = 261467, upload-time = "2025-12-08T13:14:29.09Z" },
+    { url = "https://files.pythonhosted.org/packages/13/e6/6e063174500eee216b96272c0d1847bf215926786f85c2bd024cf4d02d2f/coverage-7.13.0-cp314-cp314t-win32.whl", hash = "sha256:fe81055d8c6c9de76d60c94ddea73c290b416e061d40d542b24a5871bad498b7", size = 221875, upload-time = "2025-12-08T13:14:31.106Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/46/f4fb293e4cbe3620e3ac2a3e8fd566ed33affb5861a9b20e3dd6c1896cbc/coverage-7.13.0-cp314-cp314t-win_amd64.whl", hash = "sha256:445badb539005283825959ac9fa4a28f712c214b65af3a2c464f1adc90f5fcbc", size = 222982, upload-time = "2025-12-08T13:14:33.1Z" },
+    { url = "https://files.pythonhosted.org/packages/68/62/5b3b9018215ed9733fbd1ae3b2ed75c5de62c3b55377a52cae732e1b7805/coverage-7.13.0-cp314-cp314t-win_arm64.whl", hash = "sha256:de7f6748b890708578fc4b7bb967d810aeb6fcc9bff4bb77dbca77dab2f9df6a", size = 221016, upload-time = "2025-12-08T13:14:34.601Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/4c/1968f32fb9a2604645827e11ff84a31e59d532e01995f904723b4f5328b3/coverage-7.13.0-py3-none-any.whl", hash = "sha256:850d2998f380b1e266459ca5b47bc9e7daf9af1d070f66317972f382d46f1904", size = 210068, upload-time = "2025-12-08T13:14:36.236Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
+[[package]]
+name = "coverage-badge"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage" },
+    { name = "setuptools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/be/8f/e92b0a010c76b0da82709838b3f3ae9aec638d0c44dbfb1186a5751f5d2e/coverage_badge-1.1.2.tar.gz", hash = "sha256:fe7ed58a3b72dad85a553b64a99e963dea3847dcd0b8ddd2b38a00333618642c", size = 6335, upload-time = "2024-08-02T23:34:08.58Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/3d/5642a1a06191b2e1e0f87a2e824e6d3eb7c32c589a68ed4d1dcbd3324d63/coverage_badge-1.1.2-py2.py3-none-any.whl", hash = "sha256:d8413ce51c91043a1692b943616b450868cbeeb0ea6a0c54a32f8318c9c96ff7", size = 6493, upload-time = "2024-08-02T23:34:07.063Z" },
+]
+
 [[package]]
 name = "cycler"
 version = "0.12.1"
@@ -146,20 +251,40 @@ source = { editable = "." }
 dependencies = [
     { name = "brother-ql" },
     { name = "matplotlib" },
-    { name = "psycopg2" },
+    { name = "psycopg2-binary" },
     { name = "python-barcode" },
     { name = "sqlalchemy" },
 ]
 
+[package.dev-dependencies]
+test = [
+    { name = "coverage-badge" },
+    { name = "pytest" },
+    { name = "pytest-benchmark", extra = ["histogram"] },
+    { name = "pytest-cov" },
+    { name = "pytest-html" },
+    { name = "sqlparse" },
+]
+
 [package.metadata]
 requires-dist = [
     { name = "brother-ql" },
     { name = "matplotlib" },
-    { name = "psycopg2", specifier = ">=2.8,<2.10" },
+    { name = "psycopg2-binary", specifier = ">=2.8,<2.10" },
     { name = "python-barcode" },
     { name = "sqlalchemy", specifier = ">=2.0,<2.1" },
 ]
 
+[package.metadata.requires-dev]
+test = [
+    { name = "coverage-badge", specifier = ">=1.1.2" },
+    { name = "pytest" },
+    { name = "pytest-benchmark", extras = ["histogram"], specifier = ">=5.2.3" },
+    { name = "pytest-cov" },
+    { name = "pytest-html", specifier = ">=4.1.1" },
+    { name = "sqlparse", specifier = ">=0.5.4" },
+]
+
 [[package]]
 name = "fonttools"
 version = "4.61.0"
@@ -265,6 +390,39 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4f/dc/041be1dff9f23dac5f48a43323cd0789cb798342011c19a248d9c9335536/greenlet-3.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c10513330af5b8ae16f023e8ddbfb486ab355d04467c4679c5cfe4659975dd9", size = 1676034, upload-time = "2025-12-04T14:27:33.531Z" },
 ]
 
+[[package]]
+name = "importlib-metadata"
+version = "8.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
 [[package]]
 name = "kiwisolver"
 version = "1.4.9"
@@ -355,6 +513,80 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/da/e9/0d4add7873a73e462aeb45c036a2dead2562b825aa46ba326727b3f31016/kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1", size = 73929, upload-time = "2025-08-10T21:27:48.236Z" },
 ]
 
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
+    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
+    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
+    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
+    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
+    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
+]
+
 [[package]]
 name = "matplotlib"
 version = "3.10.7"
@@ -603,15 +835,103 @@ wheels = [
 ]
 
 [[package]]
-name = "psycopg2"
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "psycopg2-binary"
 version = "2.9.11"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/89/8d/9d12bc8677c24dad342ec777529bce705b3e785fa05d85122b5502b9ab55/psycopg2-2.9.11.tar.gz", hash = "sha256:964d31caf728e217c697ff77ea69c2ba0865fa41ec20bb00f0977e62fdcc52e3", size = 379598, upload-time = "2025-10-10T11:14:46.075Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/6c/8767aaa597ba424643dc87348c6f1754dd9f48e80fdc1b9f7ca5c3a7c213/psycopg2-binary-2.9.11.tar.gz", hash = "sha256:b6aed9e096bf63f9e75edf2581aa9a7e7186d97ab5c177aa6c87797cd591236c", size = 379620, upload-time = "2025-10-10T11:14:48.041Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/86/fe/d6dce306fd7b61e312757ba4d068617f562824b9c6d3e4a39fc578ea2814/psycopg2-2.9.11-cp311-cp311-win_amd64.whl", hash = "sha256:210daed32e18f35e3140a1ebe059ac29209dd96468f2f7559aa59f75ee82a5cb", size = 2713723, upload-time = "2025-10-10T11:10:12.957Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/bf/635fbe5dd10ed200afbbfbe98f8602829252ca1cce81cc48fb25ed8dadc0/psycopg2-2.9.11-cp312-cp312-win_amd64.whl", hash = "sha256:e03e4a6dbe87ff81540b434f2e5dc2bddad10296db5eea7bdc995bf5f4162938", size = 2713969, upload-time = "2025-10-10T11:10:15.946Z" },
-    { url = "https://files.pythonhosted.org/packages/88/5a/18c8cb13fc6908dc41a483d2c14d927a7a3f29883748747e8cb625da6587/psycopg2-2.9.11-cp313-cp313-win_amd64.whl", hash = "sha256:8dc379166b5b7d5ea66dcebf433011dfc51a7bb8a5fc12367fa05668e5fc53c8", size = 2714048, upload-time = "2025-10-10T11:10:19.816Z" },
-    { url = "https://files.pythonhosted.org/packages/47/08/737aa39c78d705a7ce58248d00eeba0e9fc36be488f9b672b88736fbb1f7/psycopg2-2.9.11-cp314-cp314-win_amd64.whl", hash = "sha256:f10a48acba5fe6e312b891f290b4d2ca595fc9a06850fe53320beac353575578", size = 2803738, upload-time = "2025-10-10T11:10:23.196Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/ae/8d8266f6dd183ab4d48b95b9674034e1b482a3f8619b33a0d86438694577/psycopg2_binary-2.9.11-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0e8480afd62362d0a6a27dd09e4ca2def6fa50ed3a4e7c09165266106b2ffa10", size = 3756452, upload-time = "2025-10-10T11:11:11.583Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/34/aa03d327739c1be70e09d01182619aca8ebab5970cd0cfa50dd8b9cec2ac/psycopg2_binary-2.9.11-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:763c93ef1df3da6d1a90f86ea7f3f806dc06b21c198fa87c3c25504abec9404a", size = 3863957, upload-time = "2025-10-10T11:11:16.932Z" },
+    { url = "https://files.pythonhosted.org/packages/48/89/3fdb5902bdab8868bbedc1c6e6023a4e08112ceac5db97fc2012060e0c9a/psycopg2_binary-2.9.11-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e164359396576a3cc701ba8af4751ae68a07235d7a380c631184a611220d9a4", size = 4410955, upload-time = "2025-10-10T11:11:21.21Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/24/e18339c407a13c72b336e0d9013fbbbde77b6fd13e853979019a1269519c/psycopg2_binary-2.9.11-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:d57c9c387660b8893093459738b6abddbb30a7eab058b77b0d0d1c7d521ddfd7", size = 4468007, upload-time = "2025-10-10T11:11:24.831Z" },
+    { url = "https://files.pythonhosted.org/packages/91/7e/b8441e831a0f16c159b5381698f9f7f7ed54b77d57bc9c5f99144cc78232/psycopg2_binary-2.9.11-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2c226ef95eb2250974bf6fa7a842082b31f68385c4f3268370e3f3870e7859ee", size = 4165012, upload-time = "2025-10-10T11:11:29.51Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/61/4aa89eeb6d751f05178a13da95516c036e27468c5d4d2509bb1e15341c81/psycopg2_binary-2.9.11-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a311f1edc9967723d3511ea7d2708e2c3592e3405677bf53d5c7246753591fbb", size = 3981881, upload-time = "2025-10-30T02:55:07.332Z" },
+    { url = "https://files.pythonhosted.org/packages/76/a1/2f5841cae4c635a9459fe7aca8ed771336e9383b6429e05c01267b0774cf/psycopg2_binary-2.9.11-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ebb415404821b6d1c47353ebe9c8645967a5235e6d88f914147e7fd411419e6f", size = 3650985, upload-time = "2025-10-10T11:11:34.975Z" },
+    { url = "https://files.pythonhosted.org/packages/84/74/4defcac9d002bca5709951b975173c8c2fa968e1a95dc713f61b3a8d3b6a/psycopg2_binary-2.9.11-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f07c9c4a5093258a03b28fab9b4f151aa376989e7f35f855088234e656ee6a94", size = 3296039, upload-time = "2025-10-10T11:11:40.432Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/c2/782a3c64403d8ce35b5c50e1b684412cf94f171dc18111be8c976abd2de1/psycopg2_binary-2.9.11-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:00ce1830d971f43b667abe4a56e42c1e2d594b32da4802e44a73bacacb25535f", size = 3043477, upload-time = "2025-10-30T02:55:11.182Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/31/36a1d8e702aa35c38fc117c2b8be3f182613faa25d794b8aeaab948d4c03/psycopg2_binary-2.9.11-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:cffe9d7697ae7456649617e8bb8d7a45afb71cd13f7ab22af3e5c61f04840908", size = 3345842, upload-time = "2025-10-10T11:11:45.366Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/b4/a5375cda5b54cb95ee9b836930fea30ae5a8f14aa97da7821722323d979b/psycopg2_binary-2.9.11-cp311-cp311-win_amd64.whl", hash = "sha256:304fd7b7f97eef30e91b8f7e720b3db75fee010b520e434ea35ed1ff22501d03", size = 2713894, upload-time = "2025-10-10T11:11:48.775Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/91/f870a02f51be4a65987b45a7de4c2e1897dd0d01051e2b559a38fa634e3e/psycopg2_binary-2.9.11-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:be9b840ac0525a283a96b556616f5b4820e0526addb8dcf6525a0fa162730be4", size = 3756603, upload-time = "2025-10-10T11:11:52.213Z" },
+    { url = "https://files.pythonhosted.org/packages/27/fa/cae40e06849b6c9a95eb5c04d419942f00d9eaac8d81626107461e268821/psycopg2_binary-2.9.11-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f090b7ddd13ca842ebfe301cd587a76a4cf0913b1e429eb92c1be5dbeb1a19bc", size = 3864509, upload-time = "2025-10-10T11:11:56.452Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/75/364847b879eb630b3ac8293798e380e441a957c53657995053c5ec39a316/psycopg2_binary-2.9.11-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ab8905b5dcb05bf3fb22e0cf90e10f469563486ffb6a96569e51f897c750a76a", size = 4411159, upload-time = "2025-10-10T11:12:00.49Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/a0/567f7ea38b6e1c62aafd58375665a547c00c608a471620c0edc364733e13/psycopg2_binary-2.9.11-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:bf940cd7e7fec19181fdbc29d76911741153d51cab52e5c21165f3262125685e", size = 4468234, upload-time = "2025-10-10T11:12:04.892Z" },
+    { url = "https://files.pythonhosted.org/packages/30/da/4e42788fb811bbbfd7b7f045570c062f49e350e1d1f3df056c3fb5763353/psycopg2_binary-2.9.11-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fa0f693d3c68ae925966f0b14b8edda71696608039f4ed61b1fe9ffa468d16db", size = 4166236, upload-time = "2025-10-10T11:12:11.674Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/94/c1777c355bc560992af848d98216148be5f1be001af06e06fc49cbded578/psycopg2_binary-2.9.11-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a1cf393f1cdaf6a9b57c0a719a1068ba1069f022a59b8b1fe44b006745b59757", size = 3983083, upload-time = "2025-10-30T02:55:15.73Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/42/c9a21edf0e3daa7825ed04a4a8588686c6c14904344344a039556d78aa58/psycopg2_binary-2.9.11-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ef7a6beb4beaa62f88592ccc65df20328029d721db309cb3250b0aae0fa146c3", size = 3652281, upload-time = "2025-10-10T11:12:17.713Z" },
+    { url = "https://files.pythonhosted.org/packages/12/22/dedfbcfa97917982301496b6b5e5e6c5531d1f35dd2b488b08d1ebc52482/psycopg2_binary-2.9.11-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:31b32c457a6025e74d233957cc9736742ac5a6cb196c6b68499f6bb51390bd6a", size = 3298010, upload-time = "2025-10-10T11:12:22.671Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ea/d3390e6696276078bd01b2ece417deac954dfdd552d2edc3d03204416c0c/psycopg2_binary-2.9.11-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:edcb3aeb11cb4bf13a2af3c53a15b3d612edeb6409047ea0b5d6a21a9d744b34", size = 3044641, upload-time = "2025-10-30T02:55:19.929Z" },
+    { url = "https://files.pythonhosted.org/packages/12/9a/0402ded6cbd321da0c0ba7d34dc12b29b14f5764c2fc10750daa38e825fc/psycopg2_binary-2.9.11-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:62b6d93d7c0b61a1dd6197d208ab613eb7dcfdcca0a49c42ceb082257991de9d", size = 3347940, upload-time = "2025-10-10T11:12:26.529Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/d2/99b55e85832ccde77b211738ff3925a5d73ad183c0b37bcbbe5a8ff04978/psycopg2_binary-2.9.11-cp312-cp312-win_amd64.whl", hash = "sha256:b33fabeb1fde21180479b2d4667e994de7bbf0eec22832ba5d9b5e4cf65b6c6d", size = 2714147, upload-time = "2025-10-10T11:12:29.535Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/a8/a2709681b3ac11b0b1786def10006b8995125ba268c9a54bea6f5ae8bd3e/psycopg2_binary-2.9.11-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b8fb3db325435d34235b044b199e56cdf9ff41223a4b9752e8576465170bb38c", size = 3756572, upload-time = "2025-10-10T11:12:32.873Z" },
+    { url = "https://files.pythonhosted.org/packages/62/e1/c2b38d256d0dafd32713e9f31982a5b028f4a3651f446be70785f484f472/psycopg2_binary-2.9.11-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:366df99e710a2acd90efed3764bb1e28df6c675d33a7fb40df9b7281694432ee", size = 3864529, upload-time = "2025-10-10T11:12:36.791Z" },
+    { url = "https://files.pythonhosted.org/packages/11/32/b2ffe8f3853c181e88f0a157c5fb4e383102238d73c52ac6d93a5c8bffe6/psycopg2_binary-2.9.11-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8c55b385daa2f92cb64b12ec4536c66954ac53654c7f15a203578da4e78105c0", size = 4411242, upload-time = "2025-10-10T11:12:42.388Z" },
+    { url = "https://files.pythonhosted.org/packages/10/04/6ca7477e6160ae258dc96f67c371157776564679aefd247b66f4661501a2/psycopg2_binary-2.9.11-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:c0377174bf1dd416993d16edc15357f6eb17ac998244cca19bc67cdc0e2e5766", size = 4468258, upload-time = "2025-10-10T11:12:48.654Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/7e/6a1a38f86412df101435809f225d57c1a021307dd0689f7a5e7fe83588b1/psycopg2_binary-2.9.11-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5c6ff3335ce08c75afaed19e08699e8aacf95d4a260b495a4a8545244fe2ceb3", size = 4166295, upload-time = "2025-10-10T11:12:52.525Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7d/c07374c501b45f3579a9eb761cbf2604ddef3d96ad48679112c2c5aa9c25/psycopg2_binary-2.9.11-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:84011ba3109e06ac412f95399b704d3d6950e386b7994475b231cf61eec2fc1f", size = 3983133, upload-time = "2025-10-30T02:55:24.329Z" },
+    { url = "https://files.pythonhosted.org/packages/82/56/993b7104cb8345ad7d4516538ccf8f0d0ac640b1ebd8c754a7b024e76878/psycopg2_binary-2.9.11-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ba34475ceb08cccbdd98f6b46916917ae6eeb92b5ae111df10b544c3a4621dc4", size = 3652383, upload-time = "2025-10-10T11:12:56.387Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/ac/eaeb6029362fd8d454a27374d84c6866c82c33bfc24587b4face5a8e43ef/psycopg2_binary-2.9.11-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b31e90fdd0f968c2de3b26ab014314fe814225b6c324f770952f7d38abf17e3c", size = 3298168, upload-time = "2025-10-10T11:13:00.403Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/39/50c3facc66bded9ada5cbc0de867499a703dc6bca6be03070b4e3b65da6c/psycopg2_binary-2.9.11-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:d526864e0f67f74937a8fce859bd56c979f5e2ec57ca7c627f5f1071ef7fee60", size = 3044712, upload-time = "2025-10-30T02:55:27.975Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/8e/b7de019a1f562f72ada81081a12823d3c1590bedc48d7d2559410a2763fe/psycopg2_binary-2.9.11-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04195548662fa544626c8ea0f06561eb6203f1984ba5b4562764fbeb4c3d14b1", size = 3347549, upload-time = "2025-10-10T11:13:03.971Z" },
+    { url = "https://files.pythonhosted.org/packages/80/2d/1bb683f64737bbb1f86c82b7359db1eb2be4e2c0c13b947f80efefa7d3e5/psycopg2_binary-2.9.11-cp313-cp313-win_amd64.whl", hash = "sha256:efff12b432179443f54e230fdf60de1f6cc726b6c832db8701227d089310e8aa", size = 2714215, upload-time = "2025-10-10T11:13:07.14Z" },
+    { url = "https://files.pythonhosted.org/packages/64/12/93ef0098590cf51d9732b4f139533732565704f45bdc1ffa741b7c95fb54/psycopg2_binary-2.9.11-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:92e3b669236327083a2e33ccfa0d320dd01b9803b3e14dd986a4fc54aa00f4e1", size = 3756567, upload-time = "2025-10-10T11:13:11.885Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/a9/9d55c614a891288f15ca4b5209b09f0f01e3124056924e17b81b9fa054cc/psycopg2_binary-2.9.11-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e0deeb03da539fa3577fcb0b3f2554a97f7e5477c246098dbb18091a4a01c16f", size = 3864755, upload-time = "2025-10-10T11:13:17.727Z" },
+    { url = "https://files.pythonhosted.org/packages/13/1e/98874ce72fd29cbde93209977b196a2edae03f8490d1bd8158e7f1daf3a0/psycopg2_binary-2.9.11-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9b52a3f9bb540a3e4ec0f6ba6d31339727b2950c9772850d6545b7eae0b9d7c5", size = 4411646, upload-time = "2025-10-10T11:13:24.432Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/bd/a335ce6645334fb8d758cc358810defca14a1d19ffbc8a10bd38a2328565/psycopg2_binary-2.9.11-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:db4fd476874ccfdbb630a54426964959e58da4c61c9feba73e6094d51303d7d8", size = 4468701, upload-time = "2025-10-10T11:13:29.266Z" },
+    { url = "https://files.pythonhosted.org/packages/44/d6/c8b4f53f34e295e45709b7568bf9b9407a612ea30387d35eb9fa84f269b4/psycopg2_binary-2.9.11-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:47f212c1d3be608a12937cc131bd85502954398aaa1320cb4c14421a0ffccf4c", size = 4166293, upload-time = "2025-10-10T11:13:33.336Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/e0/f8cc36eadd1b716ab36bb290618a3292e009867e5c97ce4aba908cb99644/psycopg2_binary-2.9.11-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e35b7abae2b0adab776add56111df1735ccc71406e56203515e228a8dc07089f", size = 3983184, upload-time = "2025-10-30T02:55:32.483Z" },
+    { url = "https://files.pythonhosted.org/packages/53/3e/2a8fe18a4e61cfb3417da67b6318e12691772c0696d79434184a511906dc/psycopg2_binary-2.9.11-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fcf21be3ce5f5659daefd2b3b3b6e4727b028221ddc94e6c1523425579664747", size = 3652650, upload-time = "2025-10-10T11:13:38.181Z" },
+    { url = "https://files.pythonhosted.org/packages/76/36/03801461b31b29fe58d228c24388f999fe814dfc302856e0d17f97d7c54d/psycopg2_binary-2.9.11-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:9bd81e64e8de111237737b29d68039b9c813bdf520156af36d26819c9a979e5f", size = 3298663, upload-time = "2025-10-10T11:13:44.878Z" },
+    { url = "https://files.pythonhosted.org/packages/97/77/21b0ea2e1a73aa5fa9222b2a6b8ba325c43c3a8d54272839c991f2345656/psycopg2_binary-2.9.11-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:32770a4d666fbdafab017086655bcddab791d7cb260a16679cc5a7338b64343b", size = 3044737, upload-time = "2025-10-30T02:55:35.69Z" },
+    { url = "https://files.pythonhosted.org/packages/67/69/f36abe5f118c1dca6d3726ceae164b9356985805480731ac6712a63f24f0/psycopg2_binary-2.9.11-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c3cb3a676873d7506825221045bd70e0427c905b9c8ee8d6acd70cfcbd6e576d", size = 3347643, upload-time = "2025-10-10T11:13:53.499Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/36/9c0c326fe3a4227953dfb29f5d0c8ae3b8eb8c1cd2967aa569f50cb3c61f/psycopg2_binary-2.9.11-cp314-cp314-win_amd64.whl", hash = "sha256:4012c9c954dfaccd28f94e84ab9f94e12df76b4afb22331b1f0d3154893a6316", size = 2803913, upload-time = "2025-10-10T11:13:57.058Z" },
+]
+
+[[package]]
+name = "py-cpuinfo"
+version = "9.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/a8/d832f7293ebb21690860d2e01d8115e5ff6f2ae8bbdc953f0eb0fa4bd2c7/py-cpuinfo-9.0.0.tar.gz", hash = "sha256:3cdbbf3fac90dc6f118bfd64384f309edeadd902d7c8fb17f02ffa1fc3f49690", size = 104716, upload-time = "2022-10-25T20:38:06.303Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/a9/023730ba63db1e494a271cb018dcd361bd2c917ba7004c3e49d5daf795a2/py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5", size = 22335, upload-time = "2022-10-25T20:38:27.636Z" },
+]
+
+[[package]]
+name = "pygal"
+version = "3.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b0/b6/04176faeb312c84d7f9bc1a810f96ee38d15597e226bb9bda59f3a5cb122/pygal-3.1.0.tar.gz", hash = "sha256:fbdee7351a7423e7907fb8a9c3b77305f6b5678cb2e6fd0db36a8825e42955ec", size = 81006, upload-time = "2025-12-09T10:29:19.587Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/4c/2862dd25352fe4b22ec7760d4fa12cb692587cd7ec3e378cbf644fc0d2a8/pygal-3.1.0-py3-none-any.whl", hash = "sha256:4e923490f3490c90c481f4535fa3adcda20ff374257ab9d8ae897f91b632c0bb", size = 130171, upload-time = "2025-12-09T10:29:16.721Z" },
+]
+
+[[package]]
+name = "pygaljs"
+version = "1.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/75/19/3a53f34232a9e6ddad665e71c83693c5db9a31f71785105905c5bc9fbbba/pygaljs-1.0.2.tar.gz", hash = "sha256:0b71ee32495dcba5fbb4a0476ddbba07658ad65f5675e4ad409baf154dec5111", size = 89711, upload-time = "2020-04-03T07:51:44.082Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/6f/07dab31ca496feda35cf3455b9e9380c43b5c685bb54ad890831c790da38/pygaljs-1.0.2-py2.py3-none-any.whl", hash = "sha256:d75e18cb21cc2cda40c45c3ee690771e5e3d4652bf57206f20137cf475c0dbe8", size = 91111, upload-time = "2020-04-03T07:51:42.658Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
 ]
 
 [[package]]
@@ -623,6 +943,82 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/10/5e/1aa9a93198c6b64513c9d7752de7422c06402de6600a8767da1524f9570b/pyparsing-3.2.5-py3-none-any.whl", hash = "sha256:e38a4f02064cf41fe6593d328d0512495ad1f3d8a91c4f73fc401b3079a59a5e", size = 113890, upload-time = "2025-09-21T04:11:04.117Z" },
 ]
 
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pytest-benchmark"
+version = "5.2.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "py-cpuinfo" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/24/34/9f732b76456d64faffbef6232f1f9dbec7a7c4999ff46282fa418bd1af66/pytest_benchmark-5.2.3.tar.gz", hash = "sha256:deb7317998a23c650fd4ff76e1230066a76cb45dcece0aca5607143c619e7779", size = 341340, upload-time = "2025-11-09T18:48:43.215Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/29/e756e715a48959f1c0045342088d7ca9762a2f509b945f362a316e9412b7/pytest_benchmark-5.2.3-py3-none-any.whl", hash = "sha256:bc839726ad20e99aaa0d11a127445457b4219bdb9e80a1afc4b51da7f96b0803", size = 45255, upload-time = "2025-11-09T18:48:39.765Z" },
+]
+
+[package.optional-dependencies]
+histogram = [
+    { name = "pygal" },
+    { name = "pygaljs" },
+    { name = "setuptools" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "7.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
+]
+
+[[package]]
+name = "pytest-html"
+version = "4.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jinja2" },
+    { name = "pytest" },
+    { name = "pytest-metadata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/ab/4862dcb5a8a514bd87747e06b8d55483c0c9e987e1b66972336946e49b49/pytest_html-4.1.1.tar.gz", hash = "sha256:70a01e8ae5800f4a074b56a4cb1025c8f4f9b038bba5fe31e3c98eb996686f07", size = 150773, upload-time = "2023-11-07T15:44:28.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/c7/c160021cbecd956cc1a6f79e5fe155f7868b2e5b848f1320dad0b3e3122f/pytest_html-4.1.1-py3-none-any.whl", hash = "sha256:c8152cea03bd4e9bee6d525573b67bbc6622967b72b9628dda0ea3e2a0b5dd71", size = 23491, upload-time = "2023-11-07T15:44:27.149Z" },
+]
+
+[[package]]
+name = "pytest-metadata"
+version = "3.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a6/85/8c969f8bec4e559f8f2b958a15229a35495f5b4ce499f6b865eac54b878d/pytest_metadata-3.1.1.tar.gz", hash = "sha256:d2a29b0355fbc03f168aa96d41ff88b1a3b44a3b02acbe491801c98a048017c8", size = 9952, upload-time = "2024-02-12T19:38:44.887Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3e/43/7e7b2ec865caa92f67b8f0e9231a798d102724ca4c0e1f414316be1c1ef2/pytest_metadata-3.1.1-py3-none-any.whl", hash = "sha256:c8e0844db684ee1c798cfa38908d20d67d0463ecb6137c72e91f418558dd5f4b", size = 11428, upload-time = "2024-02-12T19:38:42.531Z" },
+]
+
 [[package]]
 name = "python-barcode"
 version = "0.16.1"
@@ -653,6 +1049,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/28/b8/27e6312e86408a44fe16bd28ee12dd98608b39f7e7e57884a24e8f29b573/pyusb-1.3.1-py3-none-any.whl", hash = "sha256:bf9b754557af4717fe80c2b07cc2b923a9151f5c08d17bdb5345dac09d6a0430", size = 58465, upload-time = "2025-01-08T23:45:00.029Z" },
 ]
 
+[[package]]
+name = "setuptools"
+version = "80.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" },
+]
+
 [[package]]
 name = "six"
 version = "1.17.0"
@@ -664,39 +1069,102 @@ wheels = [
 
 [[package]]
 name = "sqlalchemy"
-version = "2.0.44"
+version = "2.0.45"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f0/f2/840d7b9496825333f532d2e3976b8eadbf52034178aac53630d09fe6e1ef/sqlalchemy-2.0.44.tar.gz", hash = "sha256:0ae7454e1ab1d780aee69fd2aae7d6b8670a581d8847f2d1e0f7ddfbf47e5a22", size = 9819830, upload-time = "2025-10-10T14:39:12.935Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/be/f9/5e4491e5ccf42f5d9cfc663741d261b3e6e1683ae7812114e7636409fcc6/sqlalchemy-2.0.45.tar.gz", hash = "sha256:1632a4bda8d2d25703fdad6363058d882541bdaaee0e5e3ddfa0cd3229efce88", size = 9869912, upload-time = "2025-12-09T21:05:16.737Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e3/81/15d7c161c9ddf0900b076b55345872ed04ff1ed6a0666e5e94ab44b0163c/sqlalchemy-2.0.44-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fe3917059c7ab2ee3f35e77757062b1bea10a0b6ca633c58391e3f3c6c488dd", size = 2140517, upload-time = "2025-10-10T15:36:15.64Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/d5/4abd13b245c7d91bdf131d4916fd9e96a584dac74215f8b5bc945206a974/sqlalchemy-2.0.44-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:de4387a354ff230bc979b46b2207af841dc8bf29847b6c7dbe60af186d97aefa", size = 2130738, upload-time = "2025-10-10T15:36:16.91Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/3c/8418969879c26522019c1025171cefbb2a8586b6789ea13254ac602986c0/sqlalchemy-2.0.44-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3678a0fb72c8a6a29422b2732fe423db3ce119c34421b5f9955873eb9b62c1e", size = 3304145, upload-time = "2025-10-10T15:34:19.569Z" },
-    { url = "https://files.pythonhosted.org/packages/94/2d/fdb9246d9d32518bda5d90f4b65030b9bf403a935cfe4c36a474846517cb/sqlalchemy-2.0.44-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3cf6872a23601672d61a68f390e44703442639a12ee9dd5a88bbce52a695e46e", size = 3304511, upload-time = "2025-10-10T15:47:05.088Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/fb/40f2ad1da97d5c83f6c1269664678293d3fe28e90ad17a1093b735420549/sqlalchemy-2.0.44-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:329aa42d1be9929603f406186630135be1e7a42569540577ba2c69952b7cf399", size = 3235161, upload-time = "2025-10-10T15:34:21.193Z" },
-    { url = "https://files.pythonhosted.org/packages/95/cb/7cf4078b46752dca917d18cf31910d4eff6076e5b513c2d66100c4293d83/sqlalchemy-2.0.44-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:70e03833faca7166e6a9927fbee7c27e6ecde436774cd0b24bbcc96353bce06b", size = 3261426, upload-time = "2025-10-10T15:47:07.196Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/3b/55c09b285cb2d55bdfa711e778bdffdd0dc3ffa052b0af41f1c5d6e582fa/sqlalchemy-2.0.44-cp311-cp311-win32.whl", hash = "sha256:253e2f29843fb303eca6b2fc645aca91fa7aa0aa70b38b6950da92d44ff267f3", size = 2105392, upload-time = "2025-10-10T15:38:20.051Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/23/907193c2f4d680aedbfbdf7bf24c13925e3c7c292e813326c1b84a0b878e/sqlalchemy-2.0.44-cp311-cp311-win_amd64.whl", hash = "sha256:7a8694107eb4308a13b425ca8c0e67112f8134c846b6e1f722698708741215d5", size = 2130293, upload-time = "2025-10-10T15:38:21.601Z" },
-    { url = "https://files.pythonhosted.org/packages/62/c4/59c7c9b068e6813c898b771204aad36683c96318ed12d4233e1b18762164/sqlalchemy-2.0.44-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72fea91746b5890f9e5e0997f16cbf3d53550580d76355ba2d998311b17b2250", size = 2139675, upload-time = "2025-10-10T16:03:31.064Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/ae/eeb0920537a6f9c5a3708e4a5fc55af25900216bdb4847ec29cfddf3bf3a/sqlalchemy-2.0.44-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:585c0c852a891450edbb1eaca8648408a3cc125f18cf433941fa6babcc359e29", size = 2127726, upload-time = "2025-10-10T16:03:35.934Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/d5/2ebbabe0379418eda8041c06b0b551f213576bfe4c2f09d77c06c07c8cc5/sqlalchemy-2.0.44-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b94843a102efa9ac68a7a30cd46df3ff1ed9c658100d30a725d10d9c60a2f44", size = 3327603, upload-time = "2025-10-10T15:35:28.322Z" },
-    { url = "https://files.pythonhosted.org/packages/45/e5/5aa65852dadc24b7d8ae75b7efb8d19303ed6ac93482e60c44a585930ea5/sqlalchemy-2.0.44-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:119dc41e7a7defcefc57189cfa0e61b1bf9c228211aba432b53fb71ef367fda1", size = 3337842, upload-time = "2025-10-10T15:43:45.431Z" },
-    { url = "https://files.pythonhosted.org/packages/41/92/648f1afd3f20b71e880ca797a960f638d39d243e233a7082c93093c22378/sqlalchemy-2.0.44-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0765e318ee9179b3718c4fd7ba35c434f4dd20332fbc6857a5e8df17719c24d7", size = 3264558, upload-time = "2025-10-10T15:35:29.93Z" },
-    { url = "https://files.pythonhosted.org/packages/40/cf/e27d7ee61a10f74b17740918e23cbc5bc62011b48282170dc4c66da8ec0f/sqlalchemy-2.0.44-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2e7b5b079055e02d06a4308d0481658e4f06bc7ef211567edc8f7d5dce52018d", size = 3301570, upload-time = "2025-10-10T15:43:48.407Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/3d/3116a9a7b63e780fb402799b6da227435be878b6846b192f076d2f838654/sqlalchemy-2.0.44-cp312-cp312-win32.whl", hash = "sha256:846541e58b9a81cce7dee8329f352c318de25aa2f2bbe1e31587eb1f057448b4", size = 2103447, upload-time = "2025-10-10T15:03:21.678Z" },
-    { url = "https://files.pythonhosted.org/packages/25/83/24690e9dfc241e6ab062df82cc0df7f4231c79ba98b273fa496fb3dd78ed/sqlalchemy-2.0.44-cp312-cp312-win_amd64.whl", hash = "sha256:7cbcb47fd66ab294703e1644f78971f6f2f1126424d2b300678f419aa73c7b6e", size = 2130912, upload-time = "2025-10-10T15:03:24.656Z" },
-    { url = "https://files.pythonhosted.org/packages/45/d3/c67077a2249fdb455246e6853166360054c331db4613cda3e31ab1cadbef/sqlalchemy-2.0.44-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ff486e183d151e51b1d694c7aa1695747599bb00b9f5f604092b54b74c64a8e1", size = 2135479, upload-time = "2025-10-10T16:03:37.671Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/91/eabd0688330d6fd114f5f12c4f89b0d02929f525e6bf7ff80aa17ca802af/sqlalchemy-2.0.44-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0b1af8392eb27b372ddb783b317dea0f650241cea5bd29199b22235299ca2e45", size = 2123212, upload-time = "2025-10-10T16:03:41.755Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/bb/43e246cfe0e81c018076a16036d9b548c4cc649de241fa27d8d9ca6f85ab/sqlalchemy-2.0.44-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2b61188657e3a2b9ac4e8f04d6cf8e51046e28175f79464c67f2fd35bceb0976", size = 3255353, upload-time = "2025-10-10T15:35:31.221Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/96/c6105ed9a880abe346b64d3b6ddef269ddfcab04f7f3d90a0bf3c5a88e82/sqlalchemy-2.0.44-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b87e7b91a5d5973dda5f00cd61ef72ad75a1db73a386b62877d4875a8840959c", size = 3260222, upload-time = "2025-10-10T15:43:50.124Z" },
-    { url = "https://files.pythonhosted.org/packages/44/16/1857e35a47155b5ad927272fee81ae49d398959cb749edca6eaa399b582f/sqlalchemy-2.0.44-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:15f3326f7f0b2bfe406ee562e17f43f36e16167af99c4c0df61db668de20002d", size = 3189614, upload-time = "2025-10-10T15:35:32.578Z" },
-    { url = "https://files.pythonhosted.org/packages/88/ee/4afb39a8ee4fc786e2d716c20ab87b5b1fb33d4ac4129a1aaa574ae8a585/sqlalchemy-2.0.44-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e77faf6ff919aa8cd63f1c4e561cac1d9a454a191bb864d5dd5e545935e5a40", size = 3226248, upload-time = "2025-10-10T15:43:51.862Z" },
-    { url = "https://files.pythonhosted.org/packages/32/d5/0e66097fc64fa266f29a7963296b40a80d6a997b7ac13806183700676f86/sqlalchemy-2.0.44-cp313-cp313-win32.whl", hash = "sha256:ee51625c2d51f8baadf2829fae817ad0b66b140573939dd69284d2ba3553ae73", size = 2101275, upload-time = "2025-10-10T15:03:26.096Z" },
-    { url = "https://files.pythonhosted.org/packages/03/51/665617fe4f8c6450f42a6d8d69243f9420f5677395572c2fe9d21b493b7b/sqlalchemy-2.0.44-cp313-cp313-win_amd64.whl", hash = "sha256:c1c80faaee1a6c3428cecf40d16a2365bcf56c424c92c2b6f0f9ad204b899e9e", size = 2127901, upload-time = "2025-10-10T15:03:27.548Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/5e/6a29fa884d9fb7ddadf6b69490a9d45fded3b38541713010dad16b77d015/sqlalchemy-2.0.44-py3-none-any.whl", hash = "sha256:19de7ca1246fbef9f9d1bff8f1ab25641569df226364a0e40457dc5457c54b05", size = 1928718, upload-time = "2025-10-10T15:29:45.32Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/1c/769552a9d840065137272ebe86ffbb0bc92b0f1e0a68ee5266a225f8cd7b/sqlalchemy-2.0.45-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2e90a344c644a4fa871eb01809c32096487928bd2038bf10f3e4515cb688cc56", size = 2153860, upload-time = "2025-12-10T20:03:23.843Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f8/9be54ff620e5b796ca7b44670ef58bc678095d51b0e89d6e3102ea468216/sqlalchemy-2.0.45-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8c8b41b97fba5f62349aa285654230296829672fc9939cd7f35aab246d1c08b", size = 3309379, upload-time = "2025-12-09T22:06:07.461Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/2b/60ce3ee7a5ae172bfcd419ce23259bb874d2cddd44f67c5df3760a1e22f9/sqlalchemy-2.0.45-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:12c694ed6468333a090d2f60950e4250b928f457e4962389553d6ba5fe9951ac", size = 3309948, upload-time = "2025-12-09T22:09:57.643Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/42/bac8d393f5db550e4e466d03d16daaafd2bad1f74e48c12673fb499a7fc1/sqlalchemy-2.0.45-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7d27a1d977a1cfef38a0e2e1ca86f09c4212666ce34e6ae542f3ed0a33bc606", size = 3261239, upload-time = "2025-12-09T22:06:08.879Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/12/43dc70a0528c59842b04ea1c1ed176f072a9b383190eb015384dd102fb19/sqlalchemy-2.0.45-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d62e47f5d8a50099b17e2bfc1b0c7d7ecd8ba6b46b1507b58cc4f05eefc3bb1c", size = 3284065, upload-time = "2025-12-09T22:09:59.454Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/9c/563049cf761d9a2ec7bc489f7879e9d94e7b590496bea5bbee9ed7b4cc32/sqlalchemy-2.0.45-cp311-cp311-win32.whl", hash = "sha256:3c5f76216e7b85770d5bb5130ddd11ee89f4d52b11783674a662c7dd57018177", size = 2113480, upload-time = "2025-12-09T21:29:57.03Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/fa/09d0a11fe9f15c7fa5c7f0dd26be3d235b0c0cbf2f9544f43bc42efc8a24/sqlalchemy-2.0.45-cp311-cp311-win_amd64.whl", hash = "sha256:a15b98adb7f277316f2c276c090259129ee4afca783495e212048daf846654b2", size = 2138407, upload-time = "2025-12-09T21:29:58.556Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c7/1900b56ce19bff1c26f39a4ce427faec7716c81ac792bfac8b6a9f3dca93/sqlalchemy-2.0.45-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3ee2aac15169fb0d45822983631466d60b762085bc4535cd39e66bea362df5f", size = 3333760, upload-time = "2025-12-09T22:11:02.66Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/93/3be94d96bb442d0d9a60e55a6bb6e0958dd3457751c6f8502e56ef95fed0/sqlalchemy-2.0.45-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba547ac0b361ab4f1608afbc8432db669bd0819b3e12e29fb5fa9529a8bba81d", size = 3348268, upload-time = "2025-12-09T22:13:49.054Z" },
+    { url = "https://files.pythonhosted.org/packages/48/4b/f88ded696e61513595e4a9778f9d3f2bf7332cce4eb0c7cedaabddd6687b/sqlalchemy-2.0.45-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:215f0528b914e5c75ef2559f69dca86878a3beeb0c1be7279d77f18e8d180ed4", size = 3278144, upload-time = "2025-12-09T22:11:04.14Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/6a/310ecb5657221f3e1bd5288ed83aa554923fb5da48d760a9f7622afeb065/sqlalchemy-2.0.45-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:107029bf4f43d076d4011f1afb74f7c3e2ea029ec82eb23d8527d5e909e97aa6", size = 3313907, upload-time = "2025-12-09T22:13:50.598Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/39/69c0b4051079addd57c84a5bfb34920d87456dd4c90cf7ee0df6efafc8ff/sqlalchemy-2.0.45-cp312-cp312-win32.whl", hash = "sha256:0c9f6ada57b58420a2c0277ff853abe40b9e9449f8d7d231763c6bc30f5c4953", size = 2112182, upload-time = "2025-12-09T21:39:30.824Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/4e/510db49dd89fc3a6e994bee51848c94c48c4a00dc905e8d0133c251f41a7/sqlalchemy-2.0.45-cp312-cp312-win_amd64.whl", hash = "sha256:8defe5737c6d2179c7997242d6473587c3beb52e557f5ef0187277009f73e5e1", size = 2139200, upload-time = "2025-12-09T21:39:32.321Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/c8/7cc5221b47a54edc72a0140a1efa56e0a2730eefa4058d7ed0b4c4357ff8/sqlalchemy-2.0.45-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe187fc31a54d7fd90352f34e8c008cf3ad5d064d08fedd3de2e8df83eb4a1cf", size = 3277082, upload-time = "2025-12-09T22:11:06.167Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/50/80a8d080ac7d3d321e5e5d420c9a522b0aa770ec7013ea91f9a8b7d36e4a/sqlalchemy-2.0.45-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:672c45cae53ba88e0dad74b9027dddd09ef6f441e927786b05bec75d949fbb2e", size = 3293131, upload-time = "2025-12-09T22:13:52.626Z" },
+    { url = "https://files.pythonhosted.org/packages/da/4c/13dab31266fc9904f7609a5dc308a2432a066141d65b857760c3bef97e69/sqlalchemy-2.0.45-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:470daea2c1ce73910f08caf10575676a37159a6d16c4da33d0033546bddebc9b", size = 3225389, upload-time = "2025-12-09T22:11:08.093Z" },
+    { url = "https://files.pythonhosted.org/packages/74/04/891b5c2e9f83589de202e7abaf24cd4e4fa59e1837d64d528829ad6cc107/sqlalchemy-2.0.45-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9c6378449e0940476577047150fd09e242529b761dc887c9808a9a937fe990c8", size = 3266054, upload-time = "2025-12-09T22:13:54.262Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/24/fc59e7f71b0948cdd4cff7a286210e86b0443ef1d18a23b0d83b87e4b1f7/sqlalchemy-2.0.45-cp313-cp313-win32.whl", hash = "sha256:4b6bec67ca45bc166c8729910bd2a87f1c0407ee955df110d78948f5b5827e8a", size = 2110299, upload-time = "2025-12-09T21:39:33.486Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/c5/d17113020b2d43073412aeca09b60d2009442420372123b8d49cc253f8b8/sqlalchemy-2.0.45-cp313-cp313-win_amd64.whl", hash = "sha256:afbf47dc4de31fa38fd491f3705cac5307d21d4bb828a4f020ee59af412744ee", size = 2136264, upload-time = "2025-12-09T21:39:36.801Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8d/bb40a5d10e7a5f2195f235c0b2f2c79b0bf6e8f00c0c223130a4fbd2db09/sqlalchemy-2.0.45-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:83d7009f40ce619d483d26ac1b757dfe3167b39921379a8bd1b596cf02dab4a6", size = 3521998, upload-time = "2025-12-09T22:13:28.622Z" },
+    { url = "https://files.pythonhosted.org/packages/75/a5/346128b0464886f036c039ea287b7332a410aa2d3fb0bb5d404cb8861635/sqlalchemy-2.0.45-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d8a2ca754e5415cde2b656c27900b19d50ba076aa05ce66e2207623d3fe41f5a", size = 3473434, upload-time = "2025-12-09T22:13:30.188Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/64/4e1913772646b060b025d3fc52ce91a58967fe58957df32b455de5a12b4f/sqlalchemy-2.0.45-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f46ec744e7f51275582e6a24326e10c49fbdd3fc99103e01376841213028774", size = 3272404, upload-time = "2025-12-09T22:11:09.662Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/27/caf606ee924282fe4747ee4fd454b335a72a6e018f97eab5ff7f28199e16/sqlalchemy-2.0.45-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:883c600c345123c033c2f6caca18def08f1f7f4c3ebeb591a63b6fceffc95cce", size = 3277057, upload-time = "2025-12-09T22:13:56.213Z" },
+    { url = "https://files.pythonhosted.org/packages/85/d0/3d64218c9724e91f3d1574d12eb7ff8f19f937643815d8daf792046d88ab/sqlalchemy-2.0.45-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2c0b74aa79e2deade948fe8593654c8ef4228c44ba862bb7c9585c8e0db90f33", size = 3222279, upload-time = "2025-12-09T22:11:11.1Z" },
+    { url = "https://files.pythonhosted.org/packages/24/10/dd7688a81c5bc7690c2a3764d55a238c524cd1a5a19487928844cb247695/sqlalchemy-2.0.45-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8a420169cef179d4c9064365f42d779f1e5895ad26ca0c8b4c0233920973db74", size = 3244508, upload-time = "2025-12-09T22:13:57.932Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/41/db75756ca49f777e029968d9c9fee338c7907c563267740c6d310a8e3f60/sqlalchemy-2.0.45-cp314-cp314-win32.whl", hash = "sha256:e50dcb81a5dfe4b7b4a4aa8f338116d127cb209559124f3694c70d6cd072b68f", size = 2113204, upload-time = "2025-12-09T21:39:38.365Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a2/0e1590e9adb292b1d576dbcf67ff7df8cf55e56e78d2c927686d01080f4b/sqlalchemy-2.0.45-cp314-cp314-win_amd64.whl", hash = "sha256:4748601c8ea959e37e03d13dcda4a44837afcd1b21338e637f7c935b8da06177", size = 2138785, upload-time = "2025-12-09T21:39:39.503Z" },
+    { url = "https://files.pythonhosted.org/packages/42/39/f05f0ed54d451156bbed0e23eb0516bcad7cbb9f18b3bf219c786371b3f0/sqlalchemy-2.0.45-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cd337d3526ec5298f67d6a30bbbe4ed7e5e68862f0bf6dd21d289f8d37b7d60b", size = 3522029, upload-time = "2025-12-09T22:13:32.09Z" },
+    { url = "https://files.pythonhosted.org/packages/54/0f/d15398b98b65c2bce288d5ee3f7d0a81f77ab89d9456994d5c7cc8b2a9db/sqlalchemy-2.0.45-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9a62b446b7d86a3909abbcd1cd3cc550a832f99c2bc37c5b22e1925438b9367b", size = 3475142, upload-time = "2025-12-09T22:13:33.739Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e1/3ccb13c643399d22289c6a9786c1a91e3dcbb68bce4beb44926ac2c557bf/sqlalchemy-2.0.45-py3-none-any.whl", hash = "sha256:5225a288e4c8cc2308dbdd874edad6e7d0fd38eac1e9e5f23503425c8eee20d0", size = 1936672, upload-time = "2025-12-09T21:54:52.608Z" },
+]
+
+[[package]]
+name = "sqlparse"
+version = "0.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/67/701f86b28d63b2086de47c942eccf8ca2208b3be69715a1119a4e384415a/sqlparse-0.5.4.tar.gz", hash = "sha256:4396a7d3cf1cd679c1be976cf3dc6e0a51d0111e87787e7a8d780e7d5a998f9e", size = 120112, upload-time = "2025-11-28T07:10:18.377Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/70/001ee337f7aa888fb2e3f5fd7592a6afc5283adb1ed44ce8df5764070f22/sqlparse-0.5.4-py3-none-any.whl", hash = "sha256:99a9f0314977b76d776a0fcb8554de91b9bb8a18560631d6bc48721d07023dcb", size = 45933, upload-time = "2025-11-28T07:10:19.73Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/52/ed/3f73f72945444548f33eba9a87fc7a6e969915e7b1acc8260b30e1f76a2f/tomli-2.3.0.tar.gz", hash = "sha256:64be704a875d2a59753d80ee8a533c3fe183e3f06807ff7dc2232938ccb01549", size = 17392, upload-time = "2025-10-08T22:01:47.119Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/2e/299f62b401438d5fe1624119c723f5d877acc86a4c2492da405626665f12/tomli-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:88bd15eb972f3664f5ed4b57c1634a97153b4bac4479dcb6a495f41921eb7f45", size = 153236, upload-time = "2025-10-08T22:01:00.137Z" },
+    { url = "https://files.pythonhosted.org/packages/86/7f/d8fffe6a7aefdb61bced88fcb5e280cfd71e08939da5894161bd71bea022/tomli-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:883b1c0d6398a6a9d29b508c331fa56adbcdff647f6ace4dfca0f50e90dfd0ba", size = 148084, upload-time = "2025-10-08T22:01:01.63Z" },
+    { url = "https://files.pythonhosted.org/packages/47/5c/24935fb6a2ee63e86d80e4d3b58b222dafaf438c416752c8b58537c8b89a/tomli-2.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d1381caf13ab9f300e30dd8feadb3de072aeb86f1d34a8569453ff32a7dea4bf", size = 234832, upload-time = "2025-10-08T22:01:02.543Z" },
+    { url = "https://files.pythonhosted.org/packages/89/da/75dfd804fc11e6612846758a23f13271b76d577e299592b4371a4ca4cd09/tomli-2.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0e285d2649b78c0d9027570d4da3425bdb49830a6156121360b3f8511ea3441", size = 242052, upload-time = "2025-10-08T22:01:03.836Z" },
+    { url = "https://files.pythonhosted.org/packages/70/8c/f48ac899f7b3ca7eb13af73bacbc93aec37f9c954df3c08ad96991c8c373/tomli-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a154a9ae14bfcf5d8917a59b51ffd5a3ac1fd149b71b47a3a104ca4edcfa845", size = 239555, upload-time = "2025-10-08T22:01:04.834Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/28/72f8afd73f1d0e7829bfc093f4cb98ce0a40ffc0cc997009ee1ed94ba705/tomli-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:74bf8464ff93e413514fefd2be591c3b0b23231a77f901db1eb30d6f712fc42c", size = 245128, upload-time = "2025-10-08T22:01:05.84Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/eb/a7679c8ac85208706d27436e8d421dfa39d4c914dcf5fa8083a9305f58d9/tomli-2.3.0-cp311-cp311-win32.whl", hash = "sha256:00b5f5d95bbfc7d12f91ad8c593a1659b6387b43f054104cda404be6bda62456", size = 96445, upload-time = "2025-10-08T22:01:06.896Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/fe/3d3420c4cb1ad9cb462fb52967080575f15898da97e21cb6f1361d505383/tomli-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:4dc4ce8483a5d429ab602f111a93a6ab1ed425eae3122032db7e9acf449451be", size = 107165, upload-time = "2025-10-08T22:01:08.107Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b7/40f36368fcabc518bb11c8f06379a0fd631985046c038aca08c6d6a43c6e/tomli-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d7d86942e56ded512a594786a5ba0a5e521d02529b3826e7761a05138341a2ac", size = 154891, upload-time = "2025-10-08T22:01:09.082Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/3f/d9dd692199e3b3aab2e4e4dd948abd0f790d9ded8cd10cbaae276a898434/tomli-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:73ee0b47d4dad1c5e996e3cd33b8a76a50167ae5f96a2607cbe8cc773506ab22", size = 148796, upload-time = "2025-10-08T22:01:10.266Z" },
+    { url = "https://files.pythonhosted.org/packages/60/83/59bff4996c2cf9f9387a0f5a3394629c7efa5ef16142076a23a90f1955fa/tomli-2.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:792262b94d5d0a466afb5bc63c7daa9d75520110971ee269152083270998316f", size = 242121, upload-time = "2025-10-08T22:01:11.332Z" },
+    { url = "https://files.pythonhosted.org/packages/45/e5/7c5119ff39de8693d6baab6c0b6dcb556d192c165596e9fc231ea1052041/tomli-2.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4f195fe57ecceac95a66a75ac24d9d5fbc98ef0962e09b2eddec5d39375aae52", size = 250070, upload-time = "2025-10-08T22:01:12.498Z" },
+    { url = "https://files.pythonhosted.org/packages/45/12/ad5126d3a278f27e6701abde51d342aa78d06e27ce2bb596a01f7709a5a2/tomli-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e31d432427dcbf4d86958c184b9bfd1e96b5b71f8eb17e6d02531f434fd335b8", size = 245859, upload-time = "2025-10-08T22:01:13.551Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/a1/4d6865da6a71c603cfe6ad0e6556c73c76548557a8d658f9e3b142df245f/tomli-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b0882799624980785240ab732537fcfc372601015c00f7fc367c55308c186f6", size = 250296, upload-time = "2025-10-08T22:01:14.614Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/b7/a7a7042715d55c9ba6e8b196d65d2cb662578b4d8cd17d882d45322b0d78/tomli-2.3.0-cp312-cp312-win32.whl", hash = "sha256:ff72b71b5d10d22ecb084d345fc26f42b5143c5533db5e2eaba7d2d335358876", size = 97124, upload-time = "2025-10-08T22:01:15.629Z" },
+    { url = "https://files.pythonhosted.org/packages/06/1e/f22f100db15a68b520664eb3328fb0ae4e90530887928558112c8d1f4515/tomli-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:1cb4ed918939151a03f33d4242ccd0aa5f11b3547d0cf30f7c74a408a5b99878", size = 107698, upload-time = "2025-10-08T22:01:16.51Z" },
+    { url = "https://files.pythonhosted.org/packages/89/48/06ee6eabe4fdd9ecd48bf488f4ac783844fd777f547b8d1b61c11939974e/tomli-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5192f562738228945d7b13d4930baffda67b69425a7f0da96d360b0a3888136b", size = 154819, upload-time = "2025-10-08T22:01:17.964Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/01/88793757d54d8937015c75dcdfb673c65471945f6be98e6a0410fba167ed/tomli-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:be71c93a63d738597996be9528f4abe628d1adf5e6eb11607bc8fe1a510b5dae", size = 148766, upload-time = "2025-10-08T22:01:18.959Z" },
+    { url = "https://files.pythonhosted.org/packages/42/17/5e2c956f0144b812e7e107f94f1cc54af734eb17b5191c0bbfb72de5e93e/tomli-2.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4665508bcbac83a31ff8ab08f424b665200c0e1e645d2bd9ab3d3e557b6185b", size = 240771, upload-time = "2025-10-08T22:01:20.106Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f4/0fbd014909748706c01d16824eadb0307115f9562a15cbb012cd9b3512c5/tomli-2.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4021923f97266babc6ccab9f5068642a0095faa0a51a246a6a02fccbb3514eaf", size = 248586, upload-time = "2025-10-08T22:01:21.164Z" },
+    { url = "https://files.pythonhosted.org/packages/30/77/fed85e114bde5e81ecf9bc5da0cc69f2914b38f4708c80ae67d0c10180c5/tomli-2.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4ea38c40145a357d513bffad0ed869f13c1773716cf71ccaa83b0fa0cc4e42f", size = 244792, upload-time = "2025-10-08T22:01:22.417Z" },
+    { url = "https://files.pythonhosted.org/packages/55/92/afed3d497f7c186dc71e6ee6d4fcb0acfa5f7d0a1a2878f8beae379ae0cc/tomli-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ad805ea85eda330dbad64c7ea7a4556259665bdf9d2672f5dccc740eb9d3ca05", size = 248909, upload-time = "2025-10-08T22:01:23.859Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/84/ef50c51b5a9472e7265ce1ffc7f24cd4023d289e109f669bdb1553f6a7c2/tomli-2.3.0-cp313-cp313-win32.whl", hash = "sha256:97d5eec30149fd3294270e889b4234023f2c69747e555a27bd708828353ab606", size = 96946, upload-time = "2025-10-08T22:01:24.893Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/b7/718cd1da0884f281f95ccfa3a6cc572d30053cba64603f79d431d3c9b61b/tomli-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0c95ca56fbe89e065c6ead5b593ee64b84a26fca063b5d71a1122bf26e533999", size = 107705, upload-time = "2025-10-08T22:01:26.153Z" },
+    { url = "https://files.pythonhosted.org/packages/19/94/aeafa14a52e16163008060506fcb6aa1949d13548d13752171a755c65611/tomli-2.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:cebc6fe843e0733ee827a282aca4999b596241195f43b4cc371d64fc6639da9e", size = 154244, upload-time = "2025-10-08T22:01:27.06Z" },
+    { url = "https://files.pythonhosted.org/packages/db/e4/1e58409aa78eefa47ccd19779fc6f36787edbe7d4cd330eeeedb33a4515b/tomli-2.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4c2ef0244c75aba9355561272009d934953817c49f47d768070c3c94355c2aa3", size = 148637, upload-time = "2025-10-08T22:01:28.059Z" },
+    { url = "https://files.pythonhosted.org/packages/26/b6/d1eccb62f665e44359226811064596dd6a366ea1f985839c566cd61525ae/tomli-2.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c22a8bf253bacc0cf11f35ad9808b6cb75ada2631c2d97c971122583b129afbc", size = 241925, upload-time = "2025-10-08T22:01:29.066Z" },
+    { url = "https://files.pythonhosted.org/packages/70/91/7cdab9a03e6d3d2bb11beae108da5bdc1c34bdeb06e21163482544ddcc90/tomli-2.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0eea8cc5c5e9f89c9b90c4896a8deefc74f518db5927d0e0e8d4a80953d774d0", size = 249045, upload-time = "2025-10-08T22:01:31.98Z" },
+    { url = "https://files.pythonhosted.org/packages/15/1b/8c26874ed1f6e4f1fcfeb868db8a794cbe9f227299402db58cfcc858766c/tomli-2.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b74a0e59ec5d15127acdabd75ea17726ac4c5178ae51b85bfe39c4f8a278e879", size = 245835, upload-time = "2025-10-08T22:01:32.989Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/42/8e3c6a9a4b1a1360c1a2a39f0b972cef2cc9ebd56025168c4137192a9321/tomli-2.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b5870b50c9db823c595983571d1296a6ff3e1b88f734a4c8f6fc6188397de005", size = 253109, upload-time = "2025-10-08T22:01:34.052Z" },
+    { url = "https://files.pythonhosted.org/packages/22/0c/b4da635000a71b5f80130937eeac12e686eefb376b8dee113b4a582bba42/tomli-2.3.0-cp314-cp314-win32.whl", hash = "sha256:feb0dacc61170ed7ab602d3d972a58f14ee3ee60494292d384649a3dc38ef463", size = 97930, upload-time = "2025-10-08T22:01:35.082Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/74/cb1abc870a418ae99cd5c9547d6bce30701a954e0e721821df483ef7223c/tomli-2.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:b273fcbd7fc64dc3600c098e39136522650c49bca95df2d11cf3b626422392c8", size = 107964, upload-time = "2025-10-08T22:01:36.057Z" },
+    { url = "https://files.pythonhosted.org/packages/54/78/5c46fff6432a712af9f792944f4fcd7067d8823157949f4e40c56b8b3c83/tomli-2.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:940d56ee0410fa17ee1f12b817b37a4d4e4dc4d27340863cc67236c74f582e77", size = 163065, upload-time = "2025-10-08T22:01:37.27Z" },
+    { url = "https://files.pythonhosted.org/packages/39/67/f85d9bd23182f45eca8939cd2bc7050e1f90c41f4a2ecbbd5963a1d1c486/tomli-2.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f85209946d1fe94416debbb88d00eb92ce9cd5266775424ff81bc959e001acaf", size = 159088, upload-time = "2025-10-08T22:01:38.235Z" },
+    { url = "https://files.pythonhosted.org/packages/26/5a/4b546a0405b9cc0659b399f12b6adb750757baf04250b148d3c5059fc4eb/tomli-2.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a56212bdcce682e56b0aaf79e869ba5d15a6163f88d5451cbde388d48b13f530", size = 268193, upload-time = "2025-10-08T22:01:39.712Z" },
+    { url = "https://files.pythonhosted.org/packages/42/4f/2c12a72ae22cf7b59a7fe75b3465b7aba40ea9145d026ba41cb382075b0e/tomli-2.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5f3ffd1e098dfc032d4d3af5c0ac64f6d286d98bc148698356847b80fa4de1b", size = 275488, upload-time = "2025-10-08T22:01:40.773Z" },
+    { url = "https://files.pythonhosted.org/packages/92/04/a038d65dbe160c3aa5a624e93ad98111090f6804027d474ba9c37c8ae186/tomli-2.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e01decd096b1530d97d5d85cb4dff4af2d8347bd35686654a004f8dea20fc67", size = 272669, upload-time = "2025-10-08T22:01:41.824Z" },
+    { url = "https://files.pythonhosted.org/packages/be/2f/8b7c60a9d1612a7cbc39ffcca4f21a73bf368a80fc25bccf8253e2563267/tomli-2.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8a35dd0e643bb2610f156cca8db95d213a90015c11fee76c946aa62b7ae7e02f", size = 279709, upload-time = "2025-10-08T22:01:43.177Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/46/cc36c679f09f27ded940281c38607716c86cf8ba4a518d524e349c8b4874/tomli-2.3.0-cp314-cp314t-win32.whl", hash = "sha256:a1f7f282fe248311650081faafa5f4732bdbfef5d45fe3f2e702fbc6f2d496e0", size = 107563, upload-time = "2025-10-08T22:01:44.233Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ff/426ca8683cf7b753614480484f6437f568fd2fda2edbdf57a2d3d8b27a0b/tomli-2.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:70a251f8d4ba2d9ac2542eecf008b3c8a9fc5c3f9f02c56a9d7952612be2fdba", size = 119756, upload-time = "2025-10-08T22:01:45.234Z" },
+    { url = "https://files.pythonhosted.org/packages/77/b8/0135fadc89e73be292b473cb820b4f5a08197779206b33191e801feeae40/tomli-2.3.0-py3-none-any.whl", hash = "sha256:e95b1af3c5b07d9e643909b5abbec77cd9f1217e6d0bca72b0234736b9fb1f1b", size = 14408, upload-time = "2025-10-08T22:01:46.04Z" },
 ]
 
 [[package]]
@@ -707,3 +1175,12 @@ sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac8
 wheels = [
     { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
 ]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]