Fix currency API endpoint accepting only lowercase currency strings

Signed-off-by: Lukáš Kucharczyk <lukas@kucharczyk.xyz>

.vscode/launch.json

@@ -1,26 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "Python Debugger: Current File",
-            "type": "debugpy",
-            "request": "launch",
-            "program": "${file}",
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "Python Debugger: Django",
-            "type": "debugpy",
-            "request": "launch",
-            "args": [
-                "runserver"
-            ],
-            "django": true,
-            "autoStartBrowser": false,
-            "program": "${workspaceFolder}/manage.py"
-        }
-    ]
-}

CHANGELOG.md

@@ -9,7 +9,6 @@
 * Manage purchases
 * Automatically convert purchase prices
 * Add emulated property to sessions
-* Add today's and last 7 days playtime stats to navbar
 
 ## Improved
 * mark refunded purchases red on game overview

common/components.py

@@ -252,7 +252,7 @@ def NameWithIcon(
             game_id = purchase.games.first().pk
         if game_id:
             game = Game.objects.get(pk=game_id)
-        name = name or game.name
+        name = game.name
         platform = game.platform
         link = reverse("view_game", args=[int(game_id)])
     content = Div(

common/input.css

@@ -44,9 +44,9 @@
   transition: all 0.2s ease-out;
 } */
 
-/* form label {
+form label {
   @apply dark:text-slate-400;
-} */
+}
 
 .responsive-table {
   @apply dark:text-white mx-auto table-fixed;
@@ -90,37 +90,37 @@
   }
 }
 
-/* form input,
+form input,
 select,
 textarea {
   @apply dark:border dark:border-slate-900 dark:bg-slate-500 dark:text-slate-100;
-} */
+}
 
 form input:disabled,
 select:disabled,
 textarea:disabled {
-  @apply dark:bg-slate-800 dark:text-slate-500 cursor-not-allowed;
+  @apply dark:bg-slate-700 dark:text-slate-400;
 }
 
 .errorlist {
   @apply mt-4 mb-1 pl-3 py-2 bg-red-600 text-slate-200 w-[300px];
 }
 
-/* @media screen and (min-width: 768px) {
+@media screen and (min-width: 768px) {
   form input,
   select,
   textarea {
     width: 300px;
   }
-} */
+}
 
-/* @media screen and (max-width: 768px) {
+@media screen and (max-width: 768px) {
   form input,
   select,
   textarea {
     width: 150px;
   }
-} */
+}
 
 #button-container button {
   @apply mx-1;
@@ -169,27 +169,3 @@ textarea:disabled {
     
   }  
 } */
-
-label {
-  @apply dark:text-slate-500;
-}
-
-[type="text"], [type="password"], [type="datetime-local"], [type="datetime"], [type="date"], [type="number"], select, textarea {
-  @apply dark:bg-slate-600 dark:text-slate-300;
-}
-
-[type="submit"] {
-  @apply dark:text-white font-bold dark:bg-blue-600 px-4 py-2;
-}
-
-form div label {
-  @apply dark:text-white;
-}
-
-form div {
-  @apply flex flex-col;
-}
-
-div [type="submit"] {
-  @apply mt-3;
-}

common/time.py

@@ -13,7 +13,7 @@ durationformat_manual: str = "%H hours"
 
 
 def _safe_timedelta(duration: timedelta | int | None):
-    if duration is None:
+    if duration == None:
         return timedelta(0)
     elif isinstance(duration, int):
         return timedelta(seconds=duration)

common/utils.py

@@ -1,13 +1,5 @@
-import operator
-from dataclasses import dataclass
 from datetime import date
-from functools import reduce, wraps
+from typing import Any, Generator, TypeVar
-from typing import Any, Callable, Generator, Literal, TypeVar
-from urllib.parse import urlencode
-
-from django.db.models import Q
-from django.http import HttpRequest
-from django.shortcuts import redirect
 
 
 def safe_division(numerator: int | float, denominator: int | float) -> int | float:
@@ -44,7 +36,7 @@ def safe_getattr(obj: object, attr_chain: str, default: Any | None = None) -> ob
 
 def truncate_(input_string: str, length: int = 30, ellipsis: str = "…") -> str:
     return (
-        (f"{input_string[: length - len(ellipsis)].rstrip()}{ellipsis}")
+        (f"{input_string[:length-len(ellipsis)].rstrip()}{ellipsis}")
         if len(input_string) > length
         else input_string
     )
@@ -58,12 +50,12 @@ def truncate(
         raise ValueError("Length cannot be shorter than the length of endpart.")
 
     if len(input_string) > max_content_length:
-        return f"{input_string[: max_content_length - len(ellipsis)].rstrip()}{ellipsis}{endpart}"
+        return f"{input_string[:max_content_length - len(ellipsis)].rstrip()}{ellipsis}{endpart}"
 
     return (
         f"{input_string}{endpart}"
         if len(input_string) + len(endpart) <= length
-        else f"{input_string[: length - len(ellipsis) - len(endpart)].rstrip()}{ellipsis}{endpart}"
+        else f"{input_string[:length - len(ellipsis) - len(endpart)].rstrip()}{ellipsis}{endpart}"
     )
 
 
@@ -89,79 +81,3 @@ def generate_split_ranges(
 
 def format_float_or_int(number: int | float):
     return int(number) if float(number).is_integer() else f"{number:03.2f}"
-
-
-OperatorType = Literal["|", "&"]
-
-
-@dataclass
-class FilterEntry:
-    condition: Q
-    operator: OperatorType = "&"
-
-
-def build_dynamic_filter(
-    filters: list[FilterEntry | Q], default_operator: OperatorType = "&"
-):
-    """
-    Constructs a Django Q filter from a list of filter conditions.
-
-    Args:
-        filters (list): A list where each item is either:
-            - A Q object (default AND logic applied)
-            - A tuple of (Q object, operator) where operator is "|" (OR) or "&" (AND)
-
-    Returns:
-        Q: A combined Q object that can be passed to Django's filter().
-    """
-    op_map: dict[OperatorType, Callable[[Q, Q], Q]] = {
-        "|": operator.or_,
-        "&": operator.and_,
-    }
-
-    # Convert all plain Q objects into (Q, "&") for default AND behavior
-    processed_filters = [
-        FilterEntry(f, default_operator) if isinstance(f, Q) else f for f in filters
-    ]
-
-    # Reduce with dynamic operators
-    return reduce(
-        lambda combined_filters, filter: op_map[filter.operator](
-            combined_filters, filter.condition
-        ),
-        processed_filters,
-        Q(),
-    )
-
-
-def redirect_to(default_view: str, *default_args):
-    """
-    A decorator that redirects the user back to the referring page or a default view if no 'next' parameter is provided.
-
-    :param default_view: The name of the default view to redirect to if 'next' is missing.
-    :param default_args: Any arguments required for the default view.
-    """
-
-    def decorator(view_func):
-        @wraps(view_func)
-        def wrapped_view(request: HttpRequest, *args, **kwargs):
-            next_url = request.GET.get("next")
-            if not next_url:
-                from django.urls import (
-                    reverse,  # Import inside function to avoid circular imports
-                )
-
-                next_url = reverse(default_view, args=default_args)
-
-            response = view_func(
-                request, *args, **kwargs
-            )  # Execute the original view logic
-            return redirect(next_url)
-
-        return wrapped_view
-
-    return decorator
-
-
-def add_next_param_to_url(url: str, nexturl: str) -> str:
-    return f"{url}?{urlencode({'next': nexturl})}"

contrib/scripts/get_exchange_rates_since_1990.py

@@ -1,33 +0,0 @@
-from datetime import datetime
-
-import requests
-
-url = "https://data.kurzy.cz/json/meny/b[6]den[{0}].json"
-date_format = "%Y%m%d"
-years = range(2000, datetime.now().year + 1)
-dates = [
-    datetime.strftime(datetime(day=1, month=1, year=year), format=date_format)
-    for year in years
-]
-for date in dates:
-    final_url = url.format(date)
-    year = date[:4]
-    response = requests.get(final_url)
-    response.raise_for_status()
-    data = response.json()
-    if kurzy := data.get("kurzy"):
-        with open("output.yaml", mode="a") as o:
-            rates = [
-                f"""
-- model: games.exchangerate
-            fields:
-            currency_from: {currency_name}
-            currency_to: CZK
-            year: {year}
-            rate: {kurzy.get(currency_name, {}).get("dev_stred", 0)}
-                """
-                for currency_name in ["EUR", "USD", "CNY"]
-                if kurzy.get(currency_name)
-            ]
-            o.writelines(rates)
-    # time.sleep(0.5)

contrib/scripts/merge_exchange_records.py

@@ -1,65 +0,0 @@
-import sys
-
-import yaml
-
-
-def load_yaml(filename):
-    with open(filename, "r", encoding="utf-8") as file:
-        return yaml.safe_load(file) or []
-
-
-def save_yaml(filename, data):
-    with open(filename, "w", encoding="utf-8") as file:
-        yaml.safe_dump(data, file, allow_unicode=True, default_flow_style=False)
-
-
-def extract_existing_combinations(data):
-    return {
-        (
-            entry["fields"]["currency_from"],
-            entry["fields"]["currency_to"],
-            entry["fields"]["year"],
-        )
-        for entry in data
-        if entry["model"] == "games.exchangerate"
-    }
-
-
-def filter_new_entries(existing_combinations, additional_files):
-    new_entries = []
-
-    for filename in additional_files:
-        data = load_yaml(filename)
-        for entry in data:
-            if entry["model"] == "games.exchangerate":
-                key = (
-                    entry["fields"]["currency_from"],
-                    entry["fields"]["currency_to"],
-                    entry["fields"]["year"],
-                )
-                if key not in existing_combinations:
-                    new_entries.append(entry)
-
-    return new_entries
-
-
-def main():
-    if len(sys.argv) < 3:
-        print("Usage: script.py example.yaml additions1.yaml [additions2.yaml ...]")
-        sys.exit(1)
-
-    example_file = sys.argv[1]
-    additional_files = sys.argv[2:]
-    output_file = "filtered_output.yaml"
-
-    existing_data = load_yaml(example_file)
-    existing_combinations = extract_existing_combinations(existing_data)
-
-    new_entries = filter_new_entries(existing_combinations, additional_files)
-
-    save_yaml(output_file, new_entries)
-    print(f"Filtered data saved to {output_file}")
-
-
-if __name__ == "__main__":
-    main()

games/api.py

@@ -1,80 +0,0 @@
-from datetime import date, datetime
-from typing import List
-
-from django.shortcuts import get_object_or_404
-from django.utils.timezone import now as django_timezone_now
-from ninja import Field, ModelSchema, NinjaAPI, Router, Schema
-
-from games.models import PlayEvent
-
-api = NinjaAPI()
-playevent_router = Router()
-
-NOW_FACTORY = django_timezone_now
-
-
-class PlayEventIn(Schema):
-    game_id: int
-    started: date | None = None
-    ended: date | None = None
-    note: str = ""
-    days_to_finish: int | None = None
-
-
-class AutoPlayEventIn(ModelSchema):
-    class Meta:
-        model = PlayEvent
-        fields = ["game", "started", "ended", "note"]
-
-
-class UpdatePlayEventIn(Schema):
-    started: date | None = None
-    ended: date | None = None
-    note: str = ""
-
-
-class PlayEventOut(Schema):
-    id: int
-    game: str = Field(..., alias="game.name")
-    started: date | None = None
-    ended: date | None = None
-    days_to_finish: int | None = None
-    note: str = ""
-    updated_at: datetime
-    created_at: datetime
-
-
-@playevent_router.get("/", response=List[PlayEventOut])
-def list_playevents(request):
-    return PlayEvent.objects.all()
-
-
-@playevent_router.post("/", response={201: PlayEventOut})
-def create_playevent(request, payload: PlayEventIn):
-    playevent = PlayEvent.objects.create(**payload.dict())
-    return playevent
-
-
-@playevent_router.get("/{playevent_id}", response=PlayEventOut)
-def get_playevent(request, playevent_id: int):
-    playevent = get_object_or_404(PlayEvent, id=playevent_id)
-    return playevent
-
-
-@playevent_router.patch("/{playevent_id}", response=PlayEventOut)
-def partial_update_playevent(request, playevent_id: int, payload: UpdatePlayEventIn):
-    playevent = get_object_or_404(PlayEvent, id=playevent_id)
-    for attr, value in payload.dict(exclude_unset=True).items():
-        setattr(playevent, attr, value)
-    playevent.save()
-    return playevent
-
-
-@playevent_router.delete("/{playevent_id}", response={204: None})
-def delete_playevent(request, playevent_id: int):
-    playevent = get_object_or_404(PlayEvent, id=playevent_id)
-    playevent.delete()
-    return 204, None
-
-
-api.add_router("/playevent", playevent_router)

games/apps.py

@@ -1,10 +1,9 @@
-# from datetime import timedelta
+from datetime import timedelta
 
 from django.apps import AppConfig
 from django.core.management import call_command
 from django.db.models.signals import post_migrate
-
+from django.utils.timezone import now
-# from django.utils.timezone import now
 
 
 class GamesConfig(AppConfig):
@@ -12,32 +11,20 @@ class GamesConfig(AppConfig):
     name = "games"
 
     def ready(self):
-        import games.signals  # noqa: F401
-
         post_migrate.connect(schedule_tasks, sender=self)
 
 
 def schedule_tasks(sender, **kwargs):
-    # from django_q.models import Schedule
+    from django_q.models import Schedule
-    # from django_q.tasks import schedule
+    from django_q.tasks import schedule
 
-    # if not Schedule.objects.filter(name="Update converted prices").exists():
+    if not Schedule.objects.filter(name="Update converted prices").exists():
-    #     schedule(
+        schedule(
-    #         "games.tasks.convert_prices",
+            "games.tasks.convert_prices",
-    #         name="Update converted prices",
+            name="Update converted prices",
-    #         schedule_type=Schedule.MINUTES,
+            schedule_type=Schedule.MINUTES,
-    #         next_run=now() + timedelta(seconds=30),
+            next_run=now() + timedelta(seconds=30),
-    #         catchup=False,
+        )
-    #     )
-
-    # if not Schedule.objects.filter(name="Update price per game").exists():
-    #     schedule(
-    #         "games.tasks.calculate_price_per_game",
-    #         name="Update price per game",
-    #         schedule_type=Schedule.MINUTES,
-    #         next_run=now() + timedelta(seconds=30),
-    #         catchup=False,
-    #     )
 
     from games.models import ExchangeRate
 

games/fixtures/exchangerates.yaml

@@ -110,395 +110,3 @@
     currency_to: CZK
     year: 2018
     rate: 3.268
-- model: games.exchangerate
-  pk: 17
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2023
-    rate: 3.281
-- model: games.exchangerate
-  pk: 18
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2009
-    rate: 26.445
-- model: games.exchangerate
-  pk: 19
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2025
-    rate: 3.35
-- model: games.exchangerate
-  pk: 20
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2016
-    rate: 27.033
-- model: games.exchangerate
-  pk: 21
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2025
-    rate: 25.2021966
-- model: games.exchangerate
-  pk: 22
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2017
-    rate: 26.33
-- model: games.exchangerate
-  pk: 23
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2000
-    rate: 36.13
-- model: games.exchangerate
-  pk: 24
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2000
-    rate: 35.979
-- model: games.exchangerate
-  pk: 25
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2001
-    rate: 35.09
-- model: games.exchangerate
-  pk: 26
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2001
-    rate: 37.813
-- model: games.exchangerate
-  pk: 27
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2002
-    rate: 31.98
-- model: games.exchangerate
-  pk: 28
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2002
-    rate: 36.259
-- model: games.exchangerate
-  pk: 29
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2003
-    rate: 31.6
-- model: games.exchangerate
-  pk: 30
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2003
-    rate: 30.141
-- model: games.exchangerate
-  pk: 31
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2004
-    rate: 32.405
-- model: games.exchangerate
-  pk: 32
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2004
-    rate: 25.654
-- model: games.exchangerate
-  pk: 33
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2005
-    rate: 30.465
-- model: games.exchangerate
-  pk: 34
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2005
-    rate: 22.365
-- model: games.exchangerate
-  pk: 35
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2006
-    rate: 29.005
-- model: games.exchangerate
-  pk: 36
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2006
-    rate: 24.588
-- model: games.exchangerate
-  pk: 37
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2006
-    rate: 3.047
-- model: games.exchangerate
-  pk: 38
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2007
-    rate: 27.495
-- model: games.exchangerate
-  pk: 39
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2007
-    rate: 20.876
-- model: games.exchangerate
-  pk: 40
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2007
-    rate: 2.674
-- model: games.exchangerate
-  pk: 41
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2008
-    rate: 26.62
-- model: games.exchangerate
-  pk: 42
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2008
-    rate: 18.078
-- model: games.exchangerate
-  pk: 43
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2008
-    rate: 2.475
-- model: games.exchangerate
-  pk: 44
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2009
-    rate: 19.346
-- model: games.exchangerate
-  pk: 45
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2009
-    rate: 2.836
-- model: games.exchangerate
-  pk: 46
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2010
-    rate: 18.368
-- model: games.exchangerate
-  pk: 47
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2010
-    rate: 2.691
-- model: games.exchangerate
-  pk: 48
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2011
-    rate: 25.06
-- model: games.exchangerate
-  pk: 49
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2011
-    rate: 18.751
-- model: games.exchangerate
-  pk: 50
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2011
-    rate: 2.845
-- model: games.exchangerate
-  pk: 51
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2012
-    rate: 19.94
-- model: games.exchangerate
-  pk: 52
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2012
-    rate: 3.168
-- model: games.exchangerate
-  pk: 53
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2013
-    rate: 25.14
-- model: games.exchangerate
-  pk: 54
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2013
-    rate: 3.059
-- model: games.exchangerate
-  pk: 55
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2014
-    rate: 19.894
-- model: games.exchangerate
-  pk: 56
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2014
-    rate: 3.286
-- model: games.exchangerate
-  pk: 57
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2015
-    rate: 27.725
-- model: games.exchangerate
-  pk: 58
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2015
-    rate: 22.834
-- model: games.exchangerate
-  pk: 59
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2016
-    rate: 24.824
-- model: games.exchangerate
-  pk: 60
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2017
-    rate: 3.693
-- model: games.exchangerate
-  pk: 61
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2018
-    rate: 25.54
-- model: games.exchangerate
-  pk: 62
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2018
-    rate: 21.291
-- model: games.exchangerate
-  pk: 63
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2019
-    rate: 25.725
-- model: games.exchangerate
-  pk: 64
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2020
-    rate: 25.41
-- model: games.exchangerate
-  pk: 65
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2020
-    rate: 22.621
-- model: games.exchangerate
-  pk: 66
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2021
-    rate: 26.245
-- model: games.exchangerate
-  pk: 67
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2021
-    rate: 21.387
-- model: games.exchangerate
-  pk: 68
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2021
-    rate: 3.273
-- model: games.exchangerate
-  pk: 69
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2022
-    rate: 21.951
-- model: games.exchangerate
-  pk: 70
-  fields:
-    currency_from: CNY
-    currency_to: CZK
-    year: 2022
-    rate: 3.458
-- model: games.exchangerate
-  pk: 71
-  fields:
-    currency_from: EUR
-    currency_to: CZK
-    year: 2023
-    rate: 24.115
-- model: games.exchangerate
-  pk: 72
-  fields:
-    currency_from: USD
-    currency_to: CZK
-    year: 2025
-    rate: 24.237

games/forms.py

@@ -1,17 +1,8 @@
 from django import forms
-from django.db import transaction
 from django.urls import reverse
 
 from common.utils import safe_getattr
-from games.models import (
+from games.models import Device, Game, Platform, Purchase, Session
-    Device,
-    Game,
-    GameStatusChange,
-    Platform,
-    PlayEvent,
-    Purchase,
-    Session,
-)
 
 custom_date_widget = forms.DateInput(attrs={"type": "date"})
 custom_datetime_widget = forms.DateTimeInput(
@@ -20,37 +11,14 @@ custom_datetime_widget = forms.DateTimeInput(
 autofocus_input_widget = forms.TextInput(attrs={"autofocus": "autofocus"})
 
 
-class MultipleGameChoiceField(forms.ModelMultipleChoiceField):
-    def label_from_instance(self, obj) -> str:
-        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
-
-
-class SingleGameChoiceField(forms.ModelChoiceField):
-    def label_from_instance(self, obj) -> str:
-        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
-
-
 class SessionForm(forms.ModelForm):
-    game = SingleGameChoiceField(
+    game = forms.ModelChoiceField(
         queryset=Game.objects.order_by("sort_name"),
         widget=forms.Select(attrs={"autofocus": "autofocus"}),
     )
 
-    duration_manual = forms.DurationField(
-        required=False,
-        widget=forms.TextInput(
-            attrs={"x-mask": "99:99:99", "placeholder": "HH:MM:SS", "x-data": ""}
-        ),
-        label="Manual duration",
-    )
     device = forms.ModelChoiceField(queryset=Device.objects.order_by("name"))
 
-    mark_as_played = forms.BooleanField(
-        required=False,
-        initial={"mark_as_played": True},
-        label="Set game status to Played if Unplayed",
-    )
-
     class Meta:
         widgets = {
             "timestamp_start": custom_datetime_widget,
@@ -65,20 +33,12 @@ class SessionForm(forms.ModelForm):
             "emulated",
             "device",
             "note",
-            "mark_as_played",
         ]
 
-    def save(self, commit=True):
+
-        session = super().save(commit=False)
+class GameChoiceField(forms.ModelMultipleChoiceField):
-        if self.cleaned_data.get("mark_as_played"):
+    def label_from_instance(self, obj) -> str:
-            game_instance = session.game
+        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
-            if game_instance.status == "u":
-                game_instance.status = "p"
-            if commit:
-                game_instance.save()
-        if commit:
-            session.save()
-        return session
 
 
 class IncludePlatformSelect(forms.SelectMultiple):
@@ -105,7 +65,7 @@ class PurchaseForm(forms.ModelForm):
             }
         )
 
-    games = MultipleGameChoiceField(
+    games = GameChoiceField(
         queryset=Game.objects.order_by("sort_name"),
         widget=IncludePlatformSelect(attrs={"autoselect": "autoselect"}),
     )
@@ -115,22 +75,12 @@ class PurchaseForm(forms.ModelForm):
         required=False,
     )
 
-    price_currency = forms.CharField(
-        widget=forms.TextInput(
-            attrs={
-                "x-mask": "aaa",
-                "placeholder": "CZK",
-                "x-data": "",
-                "class": "uppercase",
-            }
-        ),
-        label="Currency",
-    )
-
     class Meta:
         widgets = {
             "date_purchased": custom_date_widget,
             "date_refunded": custom_date_widget,
+            "date_finished": custom_date_widget,
+            "date_dropped": custom_date_widget,
         }
         model = Purchase
         fields = [
@@ -138,6 +88,8 @@ class PurchaseForm(forms.ModelForm):
             "platform",
             "date_purchased",
             "date_refunded",
+            "date_finished",
+            "date_dropped",
             "infinite",
             "price",
             "price_currency",
@@ -191,16 +143,7 @@ class GameForm(forms.ModelForm):
 
     class Meta:
         model = Game
-        fields = [
+        fields = ["name", "sort_name", "platform", "year_released", "wikidata"]
-            "name",
-            "sort_name",
-            "platform",
-            "original_year_released",
-            "year_released",
-            "status",
-            "mastered",
-            "wikidata",
-        ]
         widgets = {"name": autofocus_input_widget}
 
 
@@ -220,48 +163,3 @@ class DeviceForm(forms.ModelForm):
         model = Device
         fields = ["name", "type"]
         widgets = {"name": autofocus_input_widget}
-
-
-class PlayEventForm(forms.ModelForm):
-    game = GameModelChoiceField(
-        queryset=Game.objects.order_by("sort_name"),
-        widget=forms.Select(attrs={"autofocus": "autofocus"}),
-    )
-
-    mark_as_finished = forms.BooleanField(
-        required=False,
-        initial={"mark_as_finished": True},
-        label="Set game status to Finished",
-    )
-
-    class Meta:
-        model = PlayEvent
-        fields = ["game", "started", "ended", "note", "mark_as_finished"]
-        widgets = {
-            "started": custom_date_widget,
-            "ended": custom_date_widget,
-        }
-
-    def save(self, commit=True):
-        with transaction.atomic():
-            session = super().save(commit=False)
-            if self.cleaned_data.get("mark_as_finished"):
-                game_instance = session.game
-                game_instance.status = "f"
-                game_instance.save()
-            session.save()
-        return session
-
-
-class GameStatusChangeForm(forms.ModelForm):
-    class Meta:
-        model = GameStatusChange
-        fields = [
-            "game",
-            "old_status",
-            "new_status",
-            "timestamp",
-        ]
-        widgets = {
-            "timestamp": custom_datetime_widget,
-        }

games/migrations/0002_purchase_price_per_game.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.1.5 on 2025-01-30 11:04
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('games', '0001_initial'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='purchase',
-            name='price_per_game',
-            field=models.FloatField(null=True),
-        ),
-    ]

games/migrations/0003_purchase_updated_at.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.1.5 on 2025-01-30 11:12
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('games', '0002_purchase_price_per_game'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='purchase',
-            name='updated_at',
-            field=models.DateTimeField(auto_now=True),
-        ),
-    ]

games/migrations/0004_purchase_num_purchases.py

@@ -1,28 +0,0 @@
-# Generated by Django 5.1.5 on 2025-01-30 11:57
-
-from django.db import migrations, models
-from django.db.models import Count
-
-
-def initialize_num_purchases(apps, schema_editor):
-    Purchase = apps.get_model("games", "Purchase")
-    purchases = Purchase.objects.annotate(num_games=Count("games"))
-
-    for purchase in purchases:
-        purchase.num_purchases = purchase.num_games
-        purchase.save(update_fields=["num_purchases"])
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0003_purchase_updated_at"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="purchase",
-            name="num_purchases",
-            field=models.IntegerField(default=0),
-        ),
-        migrations.RunPython(initialize_num_purchases),
-    ]

games/migrations/0005_game_mastered_game_status.py

@@ -1,38 +0,0 @@
-# Generated by Django 5.1.5 on 2025-02-01 19:18
-
-from django.db import migrations, models
-
-
-def set_finished_status(apps, schema_editor):
-    Game = apps.get_model("games", "Game")
-    Game.objects.filter(purchases__date_finished__isnull=False).update(status="f")
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0004_purchase_num_purchases"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="game",
-            name="mastered",
-            field=models.BooleanField(default=False),
-        ),
-        migrations.AddField(
-            model_name="game",
-            name="status",
-            field=models.CharField(
-                choices=[
-                    ("u", "Unplayed"),
-                    ("p", "Played"),
-                    ("f", "Finished"),
-                    ("r", "Retired"),
-                    ("a", "Abandoned"),
-                ],
-                default="u",
-                max_length=1,
-            ),
-        ),
-        migrations.RunPython(set_finished_status),
-    ]

games/migrations/0006_alter_game_sort_name_alter_game_wikidata_and_more.py

@@ -1,59 +0,0 @@
-# Generated by Django 5.1.5 on 2025-03-01 12:52
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('games', '0005_game_mastered_game_status'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='game',
-            name='sort_name',
-            field=models.CharField(blank=True, default='', max_length=255),
-        ),
-        migrations.AlterField(
-            model_name='game',
-            name='wikidata',
-            field=models.CharField(blank=True, default='', max_length=50),
-        ),
-        migrations.AlterField(
-            model_name='platform',
-            name='group',
-            field=models.CharField(blank=True, default='', max_length=255),
-        ),
-        migrations.AlterField(
-            model_name='purchase',
-            name='converted_currency',
-            field=models.CharField(blank=True, default='', max_length=3),
-        ),
-        migrations.AlterField(
-            model_name='purchase',
-            name='games',
-            field=models.ManyToManyField(related_name='purchases', to='games.game'),
-        ),
-        migrations.AlterField(
-            model_name='purchase',
-            name='name',
-            field=models.CharField(blank=True, default='', max_length=255),
-        ),
-        migrations.AlterField(
-            model_name='purchase',
-            name='related_purchase',
-            field=models.ForeignKey(default=None, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='related_purchases', to='games.purchase'),
-        ),
-        migrations.AlterField(
-            model_name='session',
-            name='game',
-            field=models.ForeignKey(default=None, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='sessions', to='games.game'),
-        ),
-        migrations.AlterField(
-            model_name='session',
-            name='note',
-            field=models.TextField(blank=True, default=''),
-        ),
-    ]

games/migrations/0007_game_updated_at.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.1.5 on 2025-03-17 07:36
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('games', '0006_alter_game_sort_name_alter_game_wikidata_and_more'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='game',
-            name='updated_at',
-            field=models.DateTimeField(auto_now=True),
-        ),
-    ]

games/migrations/0008_game_original_year_released_gamestatuschange_and_more.py

@@ -1,190 +0,0 @@
-# Generated by Django 5.1.7 on 2025-03-19 13:11
-
-import django.db.models.deletion
-import django.db.models.expressions
-from django.db import migrations, models
-from django.db.models import F, Min
-
-
-def copy_year_released(apps, schema_editor):
-    Game = apps.get_model("games", "Game")
-    Game.objects.update(original_year_released=F("year_released"))
-
-
-def set_abandoned_status(apps, schema_editor):
-    Game = apps.get_model("games", "Game")
-    Game = apps.get_model("games", "Game")
-    PlayEvent = apps.get_model("games", "PlayEvent")
-
-    Game.objects.filter(purchases__date_refunded__isnull=False).update(status="a")
-    Game.objects.filter(purchases__date_dropped__isnull=False).update(status="a")
-
-    finished = Game.objects.filter(purchases__date_finished__isnull=False)
-
-    for game in finished:
-        for purchase in game.purchases.all():
-            first_session = game.sessions.filter(
-                timestamp_start__gte=purchase.date_purchased
-            ).aggregate(Min("timestamp_start"))["timestamp_start__min"]
-            first_session_date = first_session.date() if first_session else None
-            if purchase.date_finished:
-                play_event = PlayEvent(
-                    game=game,
-                    started=first_session_date
-                    if first_session_date
-                    else purchase.date_purchased,
-                    ended=purchase.date_finished,
-                )
-                play_event.save()
-
-
-def create_game_status_changes(apps, schema_editor):
-    Game = apps.get_model("games", "Game")
-    GameStatusChange = apps.get_model("games", "GameStatusChange")
-
-    # if game has any sessions, find the earliest session and create a status change from unplayed to played with that sessions's timestamp_start
-    for game in Game.objects.filter(sessions__isnull=False).distinct():
-        if game.sessions.exists():
-            earliest_session = game.sessions.earliest()
-            GameStatusChange.objects.create(
-                game=game,
-                old_status="u",
-                new_status="p",
-                timestamp=earliest_session.timestamp_start,
-            )
-
-    for game in Game.objects.filter(purchases__date_dropped__isnull=False):
-        GameStatusChange.objects.create(
-            game=game,
-            old_status="p",
-            new_status="a",
-            timestamp=game.purchases.first().date_dropped,
-        )
-
-    for game in Game.objects.filter(purchases__date_refunded__isnull=False):
-        GameStatusChange.objects.create(
-            game=game,
-            old_status="p",
-            new_status="a",
-            timestamp=game.purchases.first().date_refunded,
-        )
-
-    # check if game has any playevents, if so create a status change from current status to finished based on playevent's ended date
-    # consider only the first playevent
-    for game in Game.objects.filter(playevents__isnull=False):
-        first_playevent = game.playevents.first()
-        GameStatusChange.objects.create(
-            game=game,
-            old_status="p",
-            new_status="f",
-            timestamp=first_playevent.ended,
-        )
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0007_game_updated_at"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="game",
-            name="original_year_released",
-            field=models.IntegerField(blank=True, default=None, null=True),
-        ),
-        migrations.RunPython(copy_year_released),
-        migrations.CreateModel(
-            name="GameStatusChange",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                (
-                    "old_status",
-                    models.CharField(
-                        blank=True,
-                        choices=[
-                            ("u", "Unplayed"),
-                            ("p", "Played"),
-                            ("f", "Finished"),
-                            ("r", "Retired"),
-                            ("a", "Abandoned"),
-                        ],
-                        max_length=1,
-                        null=True,
-                    ),
-                ),
-                (
-                    "new_status",
-                    models.CharField(
-                        choices=[
-                            ("u", "Unplayed"),
-                            ("p", "Played"),
-                            ("f", "Finished"),
-                            ("r", "Retired"),
-                            ("a", "Abandoned"),
-                        ],
-                        max_length=1,
-                    ),
-                ),
-                ("timestamp", models.DateTimeField(null=True)),
-                (
-                    "game",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="status_changes",
-                        to="games.game",
-                    ),
-                ),
-            ],
-            options={
-                "ordering": ["-timestamp"],
-            },
-        ),
-        migrations.CreateModel(
-            name="PlayEvent",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("started", models.DateField(blank=True, null=True)),
-                ("ended", models.DateField(blank=True, null=True)),
-                (
-                    "days_to_finish",
-                    models.GeneratedField(
-                        db_persist=True,
-                        expression=django.db.models.expressions.RawSQL(
-                            "\n            COALESCE(\n                CASE \n                    WHEN date(ended) = date(started) THEN 1\n                    ELSE julianday(ended) - julianday(started)\n                END, 0\n            )\n            ",
-                            [],
-                        ),
-                        output_field=models.IntegerField(),
-                    ),
-                ),
-                ("note", models.CharField(blank=True, default="", max_length=255)),
-                ("created_at", models.DateTimeField(auto_now_add=True)),
-                ("updated_at", models.DateTimeField(auto_now=True)),
-                (
-                    "game",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        related_name="playevents",
-                        to="games.game",
-                    ),
-                ),
-            ],
-        ),
-        migrations.RunPython(set_abandoned_status),
-        migrations.RunPython(create_game_status_changes),
-    ]

games/migrations/0009_remove_purchase_date_dropped_and_more.py

@@ -1,21 +0,0 @@
-# Generated by Django 5.1.7 on 2025-03-20 11:35
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('games', '0008_game_original_year_released_gamestatuschange_and_more'),
-    ]
-
-    operations = [
-        migrations.RemoveField(
-            model_name='purchase',
-            name='date_dropped',
-        ),
-        migrations.RemoveField(
-            model_name='purchase',
-            name='date_finished',
-        ),
-    ]

games/migrations/0010_remove_purchase_price_per_game.py

@@ -1,17 +0,0 @@
-# Generated by Django 5.1.7 on 2025-03-22 17:46
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('games', '0009_remove_purchase_date_dropped_and_more'),
-    ]
-
-    operations = [
-        migrations.RemoveField(
-            model_name='purchase',
-            name='price_per_game',
-        ),
-    ]

games/migrations/0011_purchase_price_per_game.py

@@ -1,20 +0,0 @@
-# Generated by Django 5.1.7 on 2025-03-22 17:46
-
-import django.db.models.expressions
-import django.db.models.functions.comparison
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('games', '0010_remove_purchase_price_per_game'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='purchase',
-            name='price_per_game',
-            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(django.db.models.functions.comparison.Coalesce(models.F('converted_price'), models.F('price'), 0), '/', models.F('num_purchases')), output_field=models.FloatField()),
-        ),
-    ]

games/migrations/0012_alter_session_duration_calculated.py

@@ -1,32 +0,0 @@
-# Generated by Django 5.1.7 on 2025-03-25 20:30
-
-import django.db.models.expressions
-import django.db.models.functions.comparison
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0011_purchase_price_per_game"),
-    ]
-
-    operations = [
-        migrations.RemoveField(
-            model_name="session",
-            name="duration_calculated",
-        ),
-        migrations.AddField(
-            model_name="session",
-            name="duration_calculated",
-            field=models.GeneratedField(
-                db_persist=True,
-                expression=django.db.models.functions.comparison.Coalesce(
-                    django.db.models.expressions.CombinedExpression(
-                        models.F("timestamp_end"), "-", models.F("timestamp_start")
-                    ),
-                    0,
-                ),
-                output_field=models.DurationField(),
-            ),
-        ),
-    ]

games/migrations/0013_game_playtime.py

@@ -1,35 +0,0 @@
-# Generated by Django 5.1.7 on 2025-03-25 20:33
-
-import datetime
-
-from django.db import migrations, models
-from django.db.models import F, Sum
-
-
-def calculate_game_playtime(apps, schema_editor):
-    Game = apps.get_model("games", "Game")
-    games = Game.objects.all()
-    for game in games:
-        total_playtime = game.sessions.aggregate(
-            total_playtime=Sum(F("duration_total"))
-        )["total_playtime"]
-        if total_playtime:
-            game.playtime = total_playtime
-            game.save(update_fields=["playtime"])
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0012_alter_session_duration_calculated"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="game",
-            name="playtime",
-            field=models.DurationField(
-                blank=True, default=datetime.timedelta(0), editable=False
-            ),
-        ),
-        migrations.RunPython(calculate_game_playtime),
-    ]

games/migrations/0014_session_duration_total.py

@@ -1,19 +0,0 @@
-# Generated by Django 5.1.7 on 2025-03-25 20:46
-
-import django.db.models.expressions
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('games', '0013_game_playtime'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='session',
-            name='duration_total',
-            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('duration_calculated'), '+', models.F('duration_manual')), output_field=models.DurationField()),
-        ),
-    ]

games/models.py

@@ -1,63 +1,27 @@
-import logging
 from datetime import timedelta
 
-import requests
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.db.models import F, Sum
-from django.db.models.expressions import RawSQL
+from django.template.defaultfilters import slugify
-from django.db.models.fields.generated import GeneratedField
-from django.db.models.functions import Coalesce
-from django.template.defaultfilters import floatformat, pluralize, slugify
 from django.utils import timezone
 
 from common.time import format_duration
 
-logger = logging.getLogger("games")
-
 
 class Game(models.Model):
     class Meta:
         unique_together = [["name", "platform", "year_released"]]
 
     name = models.CharField(max_length=255)
-    sort_name = models.CharField(max_length=255, blank=True, default="")
+    sort_name = models.CharField(max_length=255, null=True, blank=True, default=None)
     year_released = models.IntegerField(null=True, blank=True, default=None)
-    original_year_released = models.IntegerField(null=True, blank=True, default=None)
+    wikidata = models.CharField(max_length=50, null=True, blank=True, default=None)
-    wikidata = models.CharField(max_length=50, blank=True, default="")
     platform = models.ForeignKey(
         "Platform", on_delete=models.SET_DEFAULT, null=True, blank=True, default=None
     )
 
-    playtime = models.DurationField(blank=True, editable=False, default=timedelta(0))
-
     created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-    class Status(models.TextChoices):
-        UNPLAYED = (
-            "u",
-            "Unplayed",
-        )
-        PLAYED = (
-            "p",
-            "Played",
-        )
-        FINISHED = (
-            "f",
-            "Finished",
-        )
-        RETIRED = (
-            "r",
-            "Retired",
-        )
-        ABANDONED = (
-            "a",
-            "Abandoned",
-        )
-
-    status = models.CharField(max_length=1, choices=Status, default=Status.UNPLAYED)
-    mastered = models.BooleanField(default=False)
 
     session_average: float | int | timedelta | None
     session_count: int | None
@@ -65,24 +29,6 @@ class Game(models.Model):
     def __str__(self):
         return self.name
 
-    def finished(self):
-        return self.status == self.Status.FINISHED
-
-    def abandoned(self):
-        return self.status == self.Status.ABANDONED
-
-    def retired(self):
-        return self.status == self.Status.RETIRED
-
-    def played(self):
-        return self.status == self.Status.PLAYED
-
-    def unplayed(self):
-        return self.status == self.Status.UNPLAYED
-
-    def playtime_formatted(self):
-        return format_duration(self.playtime, "%2.1H")
-
     def save(self, *args, **kwargs):
         if self.platform is None:
             self.platform = get_sentinel_platform()
@@ -97,7 +43,7 @@ def get_sentinel_platform():
 
 class Platform(models.Model):
     name = models.CharField(max_length=255)
-    group = models.CharField(max_length=255, blank=True, default="")
+    group = models.CharField(max_length=255, null=True, blank=True, default=None)
     icon = models.SlugField(blank=True)
     created_at = models.DateTimeField(auto_now_add=True)
 
@@ -117,6 +63,9 @@ class PurchaseQueryset(models.QuerySet):
     def not_refunded(self):
         return self.filter(date_refunded__isnull=True)
 
+    def finished(self):
+        return self.filter(date_finished__isnull=False)
+
     def games_only(self):
         return self.filter(type=Purchase.GAME)
 
@@ -153,85 +102,61 @@ class Purchase(models.Model):
 
     objects = PurchaseQueryset().as_manager()
 
-    games = models.ManyToManyField(Game, related_name="purchases")
+    games = models.ManyToManyField(Game, related_name="purchases", blank=True)
 
     platform = models.ForeignKey(
         Platform, on_delete=models.CASCADE, default=None, null=True, blank=True
     )
-    date_purchased = models.DateField(verbose_name="Purchased")
+    date_purchased = models.DateField()
-    date_refunded = models.DateField(blank=True, null=True, verbose_name="Refunded")
+    date_refunded = models.DateField(blank=True, null=True)
+    date_finished = models.DateField(blank=True, null=True)
+    date_dropped = models.DateField(blank=True, null=True)
     infinite = models.BooleanField(default=False)
     price = models.FloatField(default=0)
     price_currency = models.CharField(max_length=3, default="USD")
     converted_price = models.FloatField(null=True)
-    converted_currency = models.CharField(max_length=3, blank=True, default="")
+    converted_currency = models.CharField(max_length=3, null=True)
-    price_per_game = GeneratedField(
-        expression=Coalesce(F("converted_price"), F("price"), 0) / F("num_purchases"),
-        output_field=models.FloatField(),
-        db_persist=True,
-        editable=False,
-    )
-    num_purchases = models.IntegerField(default=0)
     ownership_type = models.CharField(
         max_length=2, choices=OWNERSHIP_TYPES, default=DIGITAL
     )
     type = models.CharField(max_length=255, choices=TYPES, default=GAME)
-    name = models.CharField(max_length=255, blank=True, default="")
+    name = models.CharField(max_length=255, default="", null=True, blank=True)
     related_purchase = models.ForeignKey(
         "self",
         on_delete=models.SET_NULL,
         default=None,
         null=True,
+        blank=True,
         related_name="related_purchases",
     )
     created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-    @property
-    def standardized_price(self):
-        return (
-            f"{floatformat(self.converted_price, 0)} {self.converted_currency}"
-            if self.converted_price
-            else None
-        )
-
-    @property
-    def has_one_item(self):
-        return self.games.count() == 1
 
     @property
     def standardized_name(self):
-        return self.name or self.first_game.name
+        return self.name if self.name else self.first_game.name
 
     @property
     def first_game(self):
         return self.games.first()
 
     def __str__(self):
-        return self.standardized_name
-
-    @property
-    def full_name(self):
         additional_info = [
-            str(item)
+            self.get_type_display() if self.type != Purchase.GAME else "",
-            for item in [
+            (
-                f"{self.num_purchases} game{pluralize(self.num_purchases)}",
+                f"{self.first_game.platform} version on {self.platform}"
-                self.date_purchased,
+                if self.platform != self.first_game.platform
-                self.standardized_price,
+                else self.platform
-            ]
+            ),
-            if item
+            self.first_game.year_released,
+            self.get_ownership_type_display(),
         ]
-        return f"{self.standardized_name} ({', '.join(additional_info)})"
+        return (
+            f"{self.first_game} ({', '.join(filter(None, map(str, additional_info)))})"
+        )
 
     def is_game(self):
         return self.type == self.GAME
 
-    def price_or_currency_differ_from(self, purchase_to_compare):
-        return (
-            self.price != purchase_to_compare.price
-            or self.price_currency != purchase_to_compare.price_currency
-        )
-
     def save(self, *args, **kwargs):
         if self.type != Purchase.GAME and not self.related_purchase:
             raise ValidationError(
@@ -241,15 +166,12 @@ class Purchase(models.Model):
             # Retrieve the existing instance from the database
             existing_purchase = Purchase.objects.get(pk=self.pk)
             # If price has changed, reset converted fields
-            if existing_purchase.price_or_currency_differ_from(self):
+            if (
-                from games.tasks import currency_to
+                existing_purchase.price != self.price
-
+                or existing_purchase.price_currency != self.price_currency
-                exchange_rate = get_or_create_rate(
+            ):
-                    self.price_currency, currency_to, self.date_purchased.year
+                self.converted_price = None
-                )
+                self.converted_currency = None
-                if exchange_rate:
-                    self.converted_price = floatformat(self.price * exchange_rate, 0)
-                    self.converted_currency = currency_to
         super().save(*args, **kwargs)
 
 
@@ -284,27 +206,15 @@ class Session(models.Model):
     game = models.ForeignKey(
         Game,
         on_delete=models.CASCADE,
+        blank=True,
         null=True,
         default=None,
         related_name="sessions",
     )
-    timestamp_start = models.DateTimeField(verbose_name="Start")
+    timestamp_start = models.DateTimeField()
-    timestamp_end = models.DateTimeField(blank=True, null=True, verbose_name="End")
+    timestamp_end = models.DateTimeField(blank=True, null=True)
-    duration_manual = models.DurationField(
+    duration_manual = models.DurationField(blank=True, null=True, default=timedelta(0))
-        blank=True, null=True, default=timedelta(0), verbose_name="Manual duration"
+    duration_calculated = models.DurationField(blank=True, null=True)
-    )
-    duration_calculated = GeneratedField(
-        expression=Coalesce(F("timestamp_end") - F("timestamp_start"), 0),
-        output_field=models.DurationField(),
-        db_persist=True,
-        editable=False,
-    )
-    duration_total = GeneratedField(
-        expression=F("duration_calculated") + F("duration_manual"),
-        output_field=models.DurationField(),
-        db_persist=True,
-        editable=False,
-    )
     device = models.ForeignKey(
         "Device",
         on_delete=models.SET_DEFAULT,
@@ -312,7 +222,7 @@ class Session(models.Model):
         blank=True,
         default=None,
     )
-    note = models.TextField(blank=True, default="")
+    note = models.TextField(blank=True, null=True)
     emulated = models.BooleanField(default=False)
 
     created_at = models.DateTimeField(auto_now_add=True)
@@ -321,7 +231,7 @@ class Session(models.Model):
     objects = SessionQuerySet.as_manager()
 
     def __str__(self):
-        mark = "*" if self.is_manual() else ""
+        mark = ", manual" if self.is_manual() else ""
         return f"{str(self.game)} {str(self.timestamp_start.date())} ({self.duration_formatted()}{mark})"
 
     def finish_now(self):
@@ -330,18 +240,32 @@ class Session(models.Model):
     def start_now():
         self.timestamp_start = timezone.now()
 
-    def duration_formatted(self) -> str:
+    def duration_seconds(self) -> timedelta:
-        result = format_duration(self.duration_total, "%02.1H")
+        manual = timedelta(0)
-        return result
+        calculated = timedelta(0)
+        if self.is_manual() and isinstance(self.duration_manual, timedelta):
+            manual = self.duration_manual
+        if self.timestamp_end != None and self.timestamp_start != None:
+            calculated = self.timestamp_end - self.timestamp_start
+        return timedelta(seconds=(manual + calculated).total_seconds())
 
-    def duration_formatted_with_mark(self) -> str:
+    def duration_formatted(self) -> str:
-        mark = "*" if self.is_manual() else ""
+        result = format_duration(self.duration_seconds(), "%02.0H:%02.0m")
-        return f"{self.duration_formatted()}{mark}"
+        return result
 
     def is_manual(self) -> bool:
         return not self.duration_manual == timedelta(0)
 
+    @property
+    def duration_sum(self) -> str:
+        return Session.objects.all().total_duration_formatted()
+
     def save(self, *args, **kwargs) -> None:
+        if self.timestamp_start != None and self.timestamp_end != None:
+            self.duration_calculated = self.timestamp_end - self.timestamp_start
+        else:
+            self.duration_calculated = timedelta(0)
+
         if not isinstance(self.duration_manual, timedelta):
             self.duration_manual = timedelta(0)
 
@@ -387,97 +311,3 @@ class ExchangeRate(models.Model):
 
     def __str__(self):
         return f"{self.currency_from}/{self.currency_to} - {self.rate} ({self.year})"
-
-
-def get_or_create_rate(currency_from: str, currency_to: str, year: int) -> float | None:
-    exchange_rate = None
-    result = ExchangeRate.objects.filter(
-        currency_from=currency_from, currency_to=currency_to, year=year
-    )
-    if result:
-        exchange_rate = result[0].rate
-    else:
-        try:
-            # this API endpoint only accepts lowercase currency string
-            response = requests.get(
-                f"https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@{year}-01-01/v1/currencies/{currency_from.lower()}.json"
-            )
-            response.raise_for_status()
-            data = response.json()
-            currency_from_data = data.get(currency_from.lower())
-            rate = currency_from_data.get(currency_to.lower())
-
-            if rate:
-                logger.info(f"[convert_prices]: Got {rate}, saving...")
-                exchange_rate = ExchangeRate.objects.create(
-                    currency_from=currency_from,
-                    currency_to=currency_to,
-                    year=year,
-                    rate=floatformat(rate, 2),
-                )
-                exchange_rate = exchange_rate.rate
-            else:
-                logger.info("[convert_prices]: Could not get an exchange rate.")
-        except requests.RequestException as e:
-            logger.info(
-                f"[convert_prices]: Failed to fetch exchange rate for {currency_from}->{currency_to} in {year}: {e}"
-            )
-    return exchange_rate
-
-
-class PlayEvent(models.Model):
-    game = models.ForeignKey(Game, related_name="playevents", on_delete=models.CASCADE)
-    started = models.DateField(null=True, blank=True)
-    ended = models.DateField(null=True, blank=True)
-    days_to_finish = GeneratedField(
-        # special cases:
-        # missing ended, started, or both = 0
-        # same day = 1 day to finish
-        expression=RawSQL(
-            """
-            COALESCE(
-                CASE 
-                    WHEN date(ended) = date(started) THEN 1
-                    ELSE julianday(ended) - julianday(started)
-                END, 0
-            )
-            """,
-            [],
-        ),
-        output_field=models.IntegerField(),
-        db_persist=True,
-        editable=False,
-        blank=True,
-    )
-    note = models.CharField(max_length=255, blank=True, default="")
-
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-
-# class PlayMarker(models.Model):
-#     game = models.ForeignKey(Game, related_name="markers", on_delete=models.CASCADE)
-#     played_since = models.DurationField()
-#     played_total = models.DurationField()
-#     note = models.CharField(max_length=255)
-
-
-class GameStatusChange(models.Model):
-    """
-    Tracks changes to the status of a Game.
-    """
-
-    game = models.ForeignKey(
-        Game, on_delete=models.CASCADE, related_name="status_changes"
-    )
-    old_status = models.CharField(
-        max_length=1, choices=Game.Status.choices, blank=True, null=True
-    )
-    new_status = models.CharField(max_length=1, choices=Game.Status.choices)
-    timestamp = models.DateTimeField(null=True)
-
-    def __str__(self):
-        return f"{self.game.name}: {self.old_status or 'None'} -> {self.new_status} at {self.timestamp}"
-
-    class Meta:
-        ordering = ["-timestamp"]

games/signals.py

@@ -1,58 +0,0 @@
-import logging
-from datetime import timedelta
-
-from django.db.models import F, Sum
-from django.db.models.signals import m2m_changed, post_delete, post_save, pre_save
-from django.dispatch import receiver
-from django.utils.timezone import now
-
-from games.models import Game, GameStatusChange, Purchase, Session
-
-logger = logging.getLogger("games")
-
-
-@receiver(m2m_changed, sender=Purchase.games.through)
-def update_num_purchases(sender, instance, **kwargs):
-    instance.num_purchases = instance.games.count()
-    instance.updated_at = now()
-    instance.save(update_fields=["num_purchases"])
-
-
-@receiver([post_save, post_delete], sender=Session)
-def update_game_playtime(sender, instance, **kwargs):
-    game = instance.game
-    total_playtime = game.sessions.aggregate(
-        total_playtime=Sum(F("duration_calculated") + F("duration_manual"))
-    )["total_playtime"]
-    game.playtime = total_playtime if total_playtime else timedelta(0)
-    game.save(update_fields=["playtime"])
-
-
-@receiver(pre_save, sender=Game)
-def game_status_changed(sender, instance, **kwargs):
-    """
-    Signal handler to create a GameStatusChange record whenever a Game's status is updated.
-    """
-    try:
-        old_instance = sender.objects.get(pk=instance.pk)
-        old_status = old_instance.status
-        logger.info("[game_status_changed]: Previous status exists.")
-    except sender.DoesNotExist:
-        # Handle the case where the instance was deleted before the signal was sent
-        logger.info("[game_status_changed]: Previous status does not exist.")
-        return
-
-    if old_status != instance.status:
-        logger.info(
-            "[game_status_changed]: Status changed from {} to {}".format(
-                old_status, instance.status
-            )
-        )
-        GameStatusChange.objects.create(
-            game=instance,
-            old_status=old_status,
-            new_status=instance.status,
-            timestamp=now(),
-        )
-    else:
-        logger.info("[game_status_changed]: Status has not changed")

games/static/base.css

@@ -1299,14 +1299,6 @@ input:checked + .toggle-bg {
   bottom: 0px;
 }
 
-.-left-3 {
-  left: -0.75rem;
-}
-
-.-left-\[1px\] {
-  left: -1px;
-}
-
 .bottom-0 {
   bottom: 0px;
 }
@@ -1343,18 +1335,10 @@ input:checked + .toggle-bg {
   top: 0px;
 }
 
-.top-2 {
-  top: 0.5rem;
-}
-
 .top-3 {
   top: 0.75rem;
 }
 
-.top-\[100\%\] {
-  top: 100%;
-}
-
 .z-10 {
   z-index: 10;
 }
@@ -1431,10 +1415,6 @@ input:checked + .toggle-bg {
   margin-inline-end: 0.5rem;
 }
 
-.ml-3 {
-  margin-left: 0.75rem;
-}
-
 .mr-4 {
   margin-right: 1rem;
 }
@@ -1508,10 +1488,6 @@ input:checked + .toggle-bg {
   height: 3rem;
 }
 
-.h-2 {
-  height: 0.5rem;
-}
-
 .h-2\.5 {
   height: 0.625rem;
 }
@@ -1548,10 +1524,6 @@ input:checked + .toggle-bg {
   width: 2.5rem;
 }
 
-.w-2 {
-  width: 0.5rem;
-}
-
 .w-2\.5 {
   width: 0.625rem;
 }
@@ -1560,10 +1532,6 @@ input:checked + .toggle-bg {
   width: 6rem;
 }
 
-.w-3 {
-  width: 0.75rem;
-}
-
 .w-4 {
   width: 1rem;
 }
@@ -1588,10 +1556,6 @@ input:checked + .toggle-bg {
   width: 20rem;
 }
 
-.w-auto {
-  width: auto;
-}
-
 .w-full {
   width: 100%;
 }
@@ -1612,10 +1576,6 @@ input:checked + .toggle-bg {
   max-width: 24rem;
 }
 
-.max-w-xl {
-  max-width: 36rem;
-}
-
 .max-w-xs {
   max-width: 20rem;
 }
@@ -1744,10 +1704,6 @@ input:checked + .toggle-bg {
   justify-content: space-between;
 }
 
-.gap-1 {
-  gap: 0.25rem;
-}
-
 .gap-2 {
   gap: 0.5rem;
 }
@@ -1760,10 +1716,6 @@ input:checked + .toggle-bg {
   gap: 1.25rem;
 }
 
-.gap-y-4 {
-  row-gap: 1rem;
-}
-
 .-space-x-px > :not([hidden]) ~ :not([hidden]) {
   --tw-space-x-reverse: 0;
   margin-right: calc(-1px * var(--tw-space-x-reverse));
@@ -1835,15 +1787,6 @@ input:checked + .toggle-bg {
   border-radius: 0.125rem;
 }
 
-.rounded-xl {
-  border-radius: 0.75rem;
-}
-
-.rounded-b-md {
-  border-bottom-right-radius: 0.375rem;
-  border-bottom-left-radius: 0.375rem;
-}
-
 .rounded-e-lg {
   border-start-end-radius: 0.5rem;
   border-end-end-radius: 0.5rem;
@@ -1864,14 +1807,6 @@ input:checked + .toggle-bg {
   border-end-start-radius: 0.5rem;
 }
 
-.rounded-tl-none {
-  border-top-left-radius: 0px;
-}
-
-.rounded-tr-md {
-  border-top-right-radius: 0.375rem;
-}
-
 .border {
   border-width: 1px;
 }
@@ -1880,18 +1815,6 @@ input:checked + .toggle-bg {
   border-width: 0px;
 }
 
-.border-b {
-  border-bottom-width: 1px;
-}
-
-.border-e {
-  border-inline-end-width: 1px;
-}
-
-.border-t {
-  border-top-width: 1px;
-}
-
 .border-blue-600 {
   --tw-border-opacity: 1;
   border-color: rgb(28 100 242 / var(--tw-border-opacity));
@@ -1957,29 +1880,15 @@ input:checked + .toggle-bg {
   background-color: rgb(249 250 251 / var(--tw-bg-opacity));
 }
 
-.bg-gray-500 {
-  --tw-bg-opacity: 1;
-  background-color: rgb(107 114 128 / var(--tw-bg-opacity));
-}
-
 .bg-gray-800 {
   --tw-bg-opacity: 1;
   background-color: rgb(31 41 55 / var(--tw-bg-opacity));
 }
 
-.bg-gray-800\/20 {
-  background-color: rgb(31 41 55 / 0.2);
-}
-
 .bg-gray-900\/50 {
   background-color: rgb(17 24 39 / 0.5);
 }
 
-.bg-green-500 {
-  --tw-bg-opacity: 1;
-  background-color: rgb(14 159 110 / var(--tw-bg-opacity));
-}
-
 .bg-green-600 {
   --tw-bg-opacity: 1;
   background-color: rgb(5 122 85 / var(--tw-bg-opacity));
@@ -1990,21 +1899,6 @@ input:checked + .toggle-bg {
   background-color: rgb(4 108 78 / var(--tw-bg-opacity));
 }
 
-.bg-orange-400 {
-  --tw-bg-opacity: 1;
-  background-color: rgb(255 138 76 / var(--tw-bg-opacity));
-}
-
-.bg-purple-500 {
-  --tw-bg-opacity: 1;
-  background-color: rgb(144 97 249 / var(--tw-bg-opacity));
-}
-
-.bg-red-500 {
-  --tw-bg-opacity: 1;
-  background-color: rgb(240 82 82 / var(--tw-bg-opacity));
-}
-
 .bg-red-700 {
   --tw-bg-opacity: 1;
   background-color: rgb(200 30 30 / var(--tw-bg-opacity));
@@ -2136,10 +2030,6 @@ input:checked + .toggle-bg {
   vertical-align: top;
 }
 
-.align-middle {
-  vertical-align: middle;
-}
-
 .font-mono {
   font-family: IBM Plex Mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
 }
@@ -2287,11 +2177,6 @@ input:checked + .toggle-bg {
   color: rgb(203 213 225 / var(--tw-text-opacity));
 }
 
-.text-slate-400 {
-  --tw-text-opacity: 1;
-  color: rgb(148 163 184 / var(--tw-text-opacity));
-}
-
 .text-slate-500 {
   --tw-text-opacity: 1;
   color: rgb(100 116 139 / var(--tw-text-opacity));
@@ -2364,12 +2249,6 @@ input:checked + .toggle-bg {
   filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
 }
 
-.backdrop-blur-lg {
-  --tw-backdrop-blur: blur(16px);
-  -webkit-backdrop-filter: var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);
-  backdrop-filter: var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);
-}
-
 .transition {
   transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, -webkit-backdrop-filter;
   transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter;
@@ -2470,9 +2349,10 @@ input:checked + .toggle-bg {
   transition: all 0.2s ease-out;
 } */
 
-/* form label {
+form label:is(.dark *) {
-  @apply dark:text-slate-400;
+  --tw-text-opacity: 1;
-} */
+  color: rgb(148 163 184 / var(--tw-text-opacity));
+}
 
 .responsive-table {
   margin-left: auto;
@@ -2511,25 +2391,25 @@ input:checked + .toggle-bg {
   border-left-color: rgb(100 116 139 / var(--tw-border-opacity));
 }
 
-/* form input,
+form input:is(.dark *),
-select,
+select:is(.dark *),
-textarea {
+textarea:is(.dark *) {
-  @apply dark:border dark:border-slate-900 dark:bg-slate-500 dark:text-slate-100;
+  border-width: 1px;
-} */
+  --tw-border-opacity: 1;
-
+  border-color: rgb(15 23 42 / var(--tw-border-opacity));
-form input:disabled,
+  --tw-bg-opacity: 1;
-select:disabled,
+  background-color: rgb(100 116 139 / var(--tw-bg-opacity));
-textarea:disabled {
+  --tw-text-opacity: 1;
-  cursor: not-allowed;
+  color: rgb(241 245 249 / var(--tw-text-opacity));
 }
 
 form input:disabled:is(.dark *),
 select:disabled:is(.dark *),
 textarea:disabled:is(.dark *) {
   --tw-bg-opacity: 1;
-  background-color: rgb(30 41 59 / var(--tw-bg-opacity));
+  background-color: rgb(51 65 85 / var(--tw-bg-opacity));
   --tw-text-opacity: 1;
-  color: rgb(100 116 139 / var(--tw-text-opacity));
+  color: rgb(148 163 184 / var(--tw-text-opacity));
 }
 
 .errorlist {
@@ -2545,21 +2425,21 @@ textarea:disabled:is(.dark *) {
   color: rgb(226 232 240 / var(--tw-text-opacity));
 }
 
-/* @media screen and (min-width: 768px) {
+@media screen and (min-width: 768px) {
   form input,
   select,
   textarea {
     width: 300px;
   }
-} */
+}
 
-/* @media screen and (max-width: 768px) {
+@media screen and (max-width: 768px) {
   form input,
   select,
   textarea {
     width: 150px;
   }
-} */
+}
 
 #button-container button {
   margin-left: 0.25rem;
@@ -2668,47 +2548,6 @@ textarea:disabled:is(.dark *) {
   }  
 } */
 
-label:is(.dark *) {
-  --tw-text-opacity: 1;
-  color: rgb(100 116 139 / var(--tw-text-opacity));
-}
-
-[type="text"]:is(.dark *), [type="password"]:is(.dark *), [type="datetime-local"]:is(.dark *), [type="datetime"]:is(.dark *), [type="date"]:is(.dark *), [type="number"]:is(.dark *), select:is(.dark *), textarea:is(.dark *) {
-  --tw-bg-opacity: 1;
-  background-color: rgb(71 85 105 / var(--tw-bg-opacity));
-  --tw-text-opacity: 1;
-  color: rgb(203 213 225 / var(--tw-text-opacity));
-}
-
-[type="submit"] {
-  padding-left: 1rem;
-  padding-right: 1rem;
-  padding-top: 0.5rem;
-  padding-bottom: 0.5rem;
-  font-weight: 700;
-}
-
-[type="submit"]:is(.dark *) {
-  --tw-bg-opacity: 1;
-  background-color: rgb(28 100 242 / var(--tw-bg-opacity));
-  --tw-text-opacity: 1;
-  color: rgb(255 255 255 / var(--tw-text-opacity));
-}
-
-form div label:is(.dark *) {
-  --tw-text-opacity: 1;
-  color: rgb(255 255 255 / var(--tw-text-opacity));
-}
-
-form div {
-  display: flex;
-  flex-direction: column;
-}
-
-div [type="submit"] {
-  margin-top: 0.75rem;
-}
-
 .odd\:bg-white:nth-child(odd) {
   --tw-bg-opacity: 1;
   background-color: rgb(255 255 255 / var(--tw-bg-opacity));

games/static/js/add_purchase.js

@@ -21,6 +21,11 @@ function setupElementHandlers() {
     "#id_name",
     "#id_related_purchase",
   ]);
+  disableElementsWhenValueNotEqual(
+    "#id_type",
+    ["game", "dlc"],
+    ["#id_date_finished"]
+  );
 }
 
 document.addEventListener("DOMContentLoaded", setupElementHandlers);

games/tasks.py

@@ -1,11 +1,4 @@
 import requests
-from django.db.models import ExpressionWrapper, F, FloatField, Q
-from django.template.defaultfilters import floatformat
-from django.utils.timezone import now
-from django_q.models import Task
-import logging
-
-logger = logging.getLogger("games")
 
 from games.models import ExchangeRate, Purchase
 
@@ -15,8 +8,8 @@ currency_to = currency_to.upper()
 
 
 def save_converted_info(purchase, converted_price, converted_currency):
-    logger.info(
+    print(
-        f"Setting converted price of {purchase} to {converted_price} {converted_currency} (originally {purchase.price} {purchase.price_currency})"
+        f"Changing converted price of {purchase} to {converted_price} {converted_currency} "
     )
     purchase.converted_price = converted_price
     purchase.converted_currency = converted_currency
@@ -25,10 +18,8 @@ def save_converted_info(purchase, converted_price, converted_currency):
 
 def convert_prices():
     purchases = Purchase.objects.filter(
-        converted_price__isnull=True, converted_currency=""
+        converted_price__isnull=True, converted_currency__isnull=True
     )
-    if purchases.count() == 0:
-        logger.info("[convert_prices]: No prices to convert.")
 
     for purchase in purchases:
         if purchase.price_currency.upper() == currency_to or purchase.price == 0:
@@ -36,15 +27,11 @@ def convert_prices():
             continue
         year = purchase.date_purchased.year
         currency_from = purchase.price_currency.upper()
-
         exchange_rate = ExchangeRate.objects.filter(
             currency_from=currency_from, currency_to=currency_to, year=year
         ).first()
-        logger.info(f"[convert_prices]: Looking for exchange rate in database: {currency_from}->{currency_to}")
+
         if not exchange_rate:
-            logger.info(
-                f"[convert_prices]: Getting exchange rate from {currency_from} to {currency_to} for {year}..."
-            )
             try:
                 # this API endpoint only accepts lowercase currency string
                 response = requests.get(
@@ -52,43 +39,20 @@ def convert_prices():
                 )
                 response.raise_for_status()
                 data = response.json()
-                currency_from_data = data.get(currency_from.lower())
+                rate = data[currency_from].get(currency_to)
-                rate = currency_from_data.get(currency_to.lower())
 
                 if rate:
-                    logger.info(f"[convert_prices]: Got {rate}, saving...")
                     exchange_rate = ExchangeRate.objects.create(
                         currency_from=currency_from,
                         currency_to=currency_to,
                         year=year,
-                        rate=floatformat(rate, 2),
+                        rate=rate,
                     )
-                else:
-                    logger.info("[convert_prices]: Could not get an exchange rate.")
             except requests.RequestException as e:
-                logger.info(
+                print(
-                    f"[convert_prices]: Failed to fetch exchange rate for {currency_from}->{currency_to} in {year}: {e}"
+                    f"Failed to fetch exchange rate for {currency_from}->{currency_to} in {year}: {e}"
                 )
         if exchange_rate:
             save_converted_info(
-                purchase,
+                purchase, purchase.price * exchange_rate.rate, currency_to
-                floatformat(purchase.price * exchange_rate.rate, 0),
-                currency_to,
             )
-
-
-def calculate_price_per_game():
-    try:
-        last_task = Task.objects.filter(group="Update price per game").first()
-        last_run = last_task.started
-    except Task.DoesNotExist or AttributeError:
-        last_run = now()
-    purchases = Purchase.objects.filter(converted_price__isnull=False).filter(
-        Q(updated_at__gte=last_run) | Q(price_per_game__isnull=True)
-    )
-    logger.info(f"[calculate_price_per_game]: Updating {purchases.count()} purchases.")
-    purchases.update(
-        price_per_game=ExpressionWrapper(
-            F("converted_price") / F("num_purchases"), output_field=FloatField()
-        )
-    )

games/templates/add_game.html

@@ -1,7 +1,12 @@
 <c-layouts.add>
 <c-slot name="additional_row">
-    <input type="submit"
+<tr>
-                        name="submit_and_redirect"
+    <td></td>
-                        value="Submit & Create Purchase" />
+    <td>
+        <input type="submit"
+               name="submit_and_redirect"
+               value="Submit & Create Purchase" />
+    </td>
+</tr>
 </c-slot>
 </c-layouts.add>

games/templates/cotton/button.html

@@ -1,6 +1,6 @@
-<c-vars color="blue" size="base" type="button" />
+<c-vars color="blue" size="base" />
-<button type="{{ type }}" 
+<button type="button"
         title="{{ title }}"
-        class="{{ class }} {% if color == "blue" %} bg-blue-700 dark:bg-blue-600 dark:focus:ring-blue-800 dark:hover:bg-blue-700 focus:ring-blue-300 hover:bg-blue-800 text-white {% elif color == "red" %} bg-red-700 dark:bg-red-600 dark:focus:ring-red-900 dark:hover:bg-red-700 focus:ring-red-300 hover:bg-red-800 text-white {% elif color == "gray" %} bg-white border-gray-200 dark:bg-gray-800 dark:border-gray-600 dark:focus:ring-gray-700 dark:hover:bg-gray-700 dark:hover:text-white dark:text-gray-400 focus:ring-gray-100 hover:bg-gray-100 hover:text-blue-700 text-gray-900 border {% elif color == "green" %} bg-green-700 dark:bg-green-600 dark:focus:ring-green-800 dark:hover:bg-green-700 focus:ring-green-300 hover:bg-green-800 text-white {% endif %} focus:outline-none focus:ring-4 font-medium mb-2 me-2 rounded-lg {% if size == "xs" %} px-3 py-2 text-xs {% elif size == "sm" %} px-3 py-2 text-sm {% elif size == "base" %} px-5 py-2.5 text-sm {% elif size == "lg" %} px-5 py-3 text-base {% elif size == "xl" %} px-6 py-3.5 text-base {% endif %} {% if icon %} inline-flex text-center items-center gap-2 {% else %} {% endif %} ">
+        class=" {% if color == "blue" %} bg-blue-700 dark:bg-blue-600 dark:focus:ring-blue-800 dark:hover:bg-blue-700 focus:ring-blue-300 hover:bg-blue-800 text-white {% elif color == "red" %} bg-red-700 dark:bg-red-600 dark:focus:ring-red-900 dark:hover:bg-red-700 focus:ring-red-300 hover:bg-red-800 text-white {% elif color == "gray" %} bg-white border-gray-200 dark:bg-gray-800 dark:border-gray-600 dark:focus:ring-gray-700 dark:hover:bg-gray-700 dark:hover:text-white dark:text-gray-400 focus:ring-gray-100 hover:bg-gray-100 hover:text-blue-700 text-gray-900 border {% elif color == "green" %} bg-green-700 dark:bg-green-600 dark:focus:ring-green-800 dark:hover:bg-green-700 focus:ring-green-300 hover:bg-green-800 text-white {% endif %} focus:outline-none focus:ring-4 font-medium mb-2 me-2 rounded-lg {% if size == "xs" %} px-3 py-2 text-xs {% elif size == "sm" %} px-3 py-2 text-sm {% elif size == "base" %} px-5 py-2.5 text-sm {% elif size == "lg" %} px-5 py-3 text-base {% elif size == "xl" %} px-6 py-3.5 text-base {% endif %} {% if icon %} inline-flex text-center items-center gap-2 {% else %} {% endif %} ">
     {{ slot }}
 </button>

games/templates/cotton/gamestatus.html

@@ -1,16 +0,0 @@
-<span class="relative ml-3 {{class}}">
-    <span class="rounded-xl w-2 h-2 absolute -left-3 top-2
-    {% if status == "u" %}
-    bg-gray-500
-    {% elif status == "p" %}
-    bg-orange-400
-    {% elif status == "f" %}
-    bg-green-500
-    {% elif status == "a" %}
-    bg-red-500
-    {% elif status == "r" %}
-    bg-purple-500
-    {% endif %}
-    ">&nbsp;</span>
-    {{ slot }}
-</span>

games/templates/cotton/layouts/add.html

@@ -3,18 +3,19 @@
 {% if form_content %}
     {{ form_content }}
 {% else %}
-<div class="max-width-container">
+    <form method="post" enctype="multipart/form-data">
-    <div class="form-container max-w-xl mx-auto">
+        <table class="mx-auto">
-        <form method="post" enctype="multipart/form-data">
             {% csrf_token %}
-            {{ form.as_div }}
+            {{ form.as_table }}
-            <div><input type="submit" value="Submit" /></div>
+            <tr>
-            <div class="submit-button-container">
+                <td></td>
-                {{ additional_row }}
+                <td>
-            </div>
+                    <input type="submit" value="Submit" />
-        </form>
+                </td>
-    </div>
+            </tr>
-</div>
+            {{ additional_row }}
+        </table>
+    </form>
 {% endif %}
 <c-slot name="scripts">
 {% if script_name %}

games/templates/cotton/layouts/base.html

@@ -12,10 +12,6 @@
         {% django_htmx_script %}
         <link rel="stylesheet" href="{% static 'base.css' %}" />
         <script src="https://cdn.jsdelivr.net/npm/flowbite@2.4.1/dist/flowbite.min.js"></script>
-        {% comment %} <script src="//unpkg.com/alpinejs" defer></script>
-        <script src="//unpkg.com/@alpinejs/mask" defer></script> {% endcomment %}
-        <script defer src="https://cdn.jsdelivr.net/npm/@alpinejs/mask@3.x.x/dist/cdn.min.js"></script>
-        <script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3.x.x/dist/cdn.min.js"></script>
         <script>
         // On page load or when changing themes, best to add inline in `head` to avoid FOUC
             if (localStorage.getItem('color-theme') === 'dark' || (!('color-theme' in localStorage) && window.matchMedia('(prefers-color-scheme: dark)').matches)) {

games/templates/cotton/price_converted.html

@@ -1 +0,0 @@
-<span title="Price is a result of conversion and rounding." class="decoration-dotted underline">{{ slot }}</span>

games/templates/gamestatuschange_confirm_delete.html

@@ -1,16 +0,0 @@
-<c-layouts.base>
-    {% load static %}
-    <div class="2xl:max-w-screen-2xl xl:max-w-screen-xl md:max-w-screen-md sm:max-w-screen-sm self-center">
-        <form method="post" class="dark:text-white">
-            {% csrf_token %}
-            <div>
-                <p>Are you sure you want to delete this status change?</p>
-                <c-button color="red" type="submit" size="lg" class="w-full">Delete</c-button>
-                <a href="{% url 'view_game' object.game.id %}" class="">
-                    <c-button color="gray" class="w-full">Cancel</c-button>
-                </a>
-            </div>
-        </form>
-    </div>
-</c-layouts.base>
-

games/templates/gamestatuschange_list.html

@@ -1,7 +0,0 @@
-<c-layouts.base>
-    {% load static %}
-    <div class="2xl:max-w-screen-2xl xl:max-w-screen-xl md:max-w-screen-md sm:max-w-screen-sm self-center">
-        <c-simple-table :columns=["Test"] :rows=data.rows :page_obj=page_obj :elided_page_range=elided_page_range :header_action=data.header_action />
-    </div>
-    </c-layouts.base>
-    

games/templates/list_playevents.html

@@ -1,6 +0,0 @@
-<c-layouts.base>
-{% load static %}
-<div class="2xl:max-w-screen-2xl xl:max-w-screen-xl md:max-w-screen-md sm:max-w-screen-sm self-center">
-    <c-simple-table :columns=data.columns :rows=data.rows :page_obj=page_obj :elided_page_range=elided_page_range :header_action=data.header_action />
-</div>
-</c-layouts.base>

games/templates/navbar.html

@@ -25,11 +25,7 @@
             </svg>
         </button>
         <div class="hidden w-full md:block md:w-auto" id="navbar-dropdown">
-            <ul class="items-center flex flex-col font-medium p-4 md:p-0 mt-4 border border-gray-100 rounded-lg bg-gray-50 md:space-x-8 rtl:space-x-reverse md:flex-row md:mt-0 md:border-0 md:bg-white dark:bg-gray-800 md:dark:bg-gray-900 dark:border-gray-700">
+            <ul class="flex flex-col font-medium p-4 md:p-0 mt-4 border border-gray-100 rounded-lg bg-gray-50 md:space-x-8 rtl:space-x-reverse md:flex-row md:mt-0 md:border-0 md:bg-white dark:bg-gray-800 md:dark:bg-gray-900 dark:border-gray-700">
-                <li class="text-white flex flex-col items-center text-xs">
-                    <span class="flex uppercase gap-1">Today<span class="text-gray-400">·</span>Last 7 days</span>
-                    <span class="flex items-center gap-1">{{ today_played }}<span class="text-gray-400">·</span>{{ last_7_played }}</span>
-                </li>
                 <li>
                     <a href="#"
                        class="block py-2 px-3 text-white bg-blue-700 rounded md:bg-transparent md:text-blue-700 md:p-0 md:dark:text-blue-500 dark:bg-blue-600 md:dark:bg-transparent"
@@ -106,10 +102,6 @@
                                 <a href="{% url 'list_platforms' %}"
                                    class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Platforms</a>
                             </li>
-                            <li>
-                                <a href="{% url 'list_playevents' %}"
-                                   class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Play events</a>
-                            </li>
                             <li>
                                 <a href="{% url 'list_purchases' %}"
                                    class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Purchases</a>

games/templates/stats.html

@@ -1,17 +1,12 @@
 <c-layouts.base>
 {% load static %}
-{% load duration_formatter %}
 {% partialdef purchase-name %}
 {% if purchase.type != 'game' %}
     <c-gamelink :game_id=purchase.first_game.id>
-    {% if purchase.game_name %}{{ purchase.game_name }}{% else %}{{ purchase.name }}{% endif %} ({{ purchase.first_game.name }} {{ purchase.get_type_display }})
+    {{ purchase.name }} ({{ purchase.first_game.name }} {{ purchase.get_type_display }})
     </c-gamelink>
 {% else %}
-    {% if purchase.game_name %}
+    <c-gamelink :game_id=purchase.first_game.id :name=purchase.first_game.name />
-        <c-gamelink :game_id=purchase.first_game.id :name=purchase.game_name />
-    {% else %}
-        <c-gamelink :game_id=purchase.first_game.id :name=purchase.first_game.name />
-    {% endif %}
 {% endif %}
 {% endpartialdef %}
 <div class="dark:text-white max-w-sm sm:max-w-xl lg:max-w-3xl mx-auto">
@@ -51,7 +46,7 @@
             {% endif %}
             <tr>
                 <td class="px-2 sm:px-4 md:px-6 md:py-2">Games ({{ year }})</td>
-                <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ total_year_games }}</td>
+                <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ total_2023_games }}</td>
             </tr>
             {% if all_finished_this_year_count %}
                 <tr>
@@ -112,7 +107,7 @@
                 {% for month in month_playtimes %}
                     <tr>
                         <td class="px-2 sm:px-4 md:px-6 md:py-2">{{ month.month | date:"F" }}</td>
-                        <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ month.playtime | format_duration }}</td>
+                        <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ month.playtime }}</td>
                     </tr>
                 {% endfor %}
             </tbody>
@@ -153,12 +148,12 @@
             </tr>
         </tbody>
     </table>
-    <h1 class="text-5xl text-center my-6">Games by playtime</h1>
+    <h1 class="text-5xl text-center my-6">Top games by playtime</h1>
     <table class="responsive-table">
         <thead>
             <tr>
                 <th class="px-2 sm:px-4 md:px-6 md:py-2">Name</th>
-                <th class="px-2 sm:px-4 md:px-6 md:py-2">Playtime</th>
+                <th class="px-2 sm:px-4 md:px-6 md:py-2">Playtime (hours)</th>
             </tr>
         </thead>
         <tbody>
@@ -167,7 +162,7 @@
                     <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">
                         <c-gamelink :game_id=game.id :name=game.name />
                     </td>
-                    <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ game.total_playtime | format_duration }}</td>
+                    <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ game.formatted_playtime }}</td>
                 </tr>
             {% endfor %}
         </tbody>
@@ -177,14 +172,14 @@
         <thead>
             <tr>
                 <th class="px-2 sm:px-4 md:px-6 md:py-2">Platform</th>
-                <th class="px-2 sm:px-4 md:px-6 md:py-2">Playtime</th>
+                <th class="px-2 sm:px-4 md:px-6 md:py-2">Playtime (hours)</th>
             </tr>
         </thead>
         <tbody>
             {% for item in total_playtime_per_platform %}
                 <tr>
                     <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ item.platform_name }}</td>
-                    <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ item.playtime | format_duration }}</td>
+                    <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ item.formatted_playtime }}</td>
                 </tr>
             {% endfor %}
         </tbody>

games/templates/view_game.html

@@ -16,7 +16,7 @@
                      class="size-6">
                     <path stroke-linecap="round" stroke-linejoin="round" d="M12 6v6h4.5m4.5 0a9 9 0 1 1-18 0 9 9 0 0 1 18 0Z" />
                 </svg>
-                {{ game.playtime_formatted }}
+                {{ hours_sum }}
                 </c-popover>
                 <c-popover id="popover-sessions" popover_content="Number of sessions" class="flex gap-2 items-center">
                 <svg xmlns="http://www.w3.org/2000/svg"
@@ -52,68 +52,6 @@
                 {{ playrange }}
                 </c-popover>
             </div>
-            <div class="flex flex-col mb-6 text-slate-400 gap-y-4">
-                <div class="flex gap-2 items-center">
-                    <span class="uppercase">Original year</span>
-                    <span class="text-slate-300">{{ game.original_year_released }}</span>
-                </div>
-                <div class="flex gap-2 items-center">
-                    <span class="uppercase">Status</span>
-                    <c-gamestatus :status="game.status" class="text-slate-300">
-                        {{ game.get_status_display }}
-                    </c-gamestatus>
-                    {% if game.mastered %}👑{% endif %} 
-                </div>
-                <div class="flex gap-2 items-center"
-                     x-data="{ open: false }"
-                >
-                    <span class="uppercase">Played</span>
-                    <div class="inline-flex rounded-md shadow-xs" role="group" x-data="{ played: {{ game.playevents.count }} }">
-                        <a href="{% url 'add_playevent' %}">
-                        <button type="button" class="px-4 py-2 text-sm font-medium text-gray-900 bg-white border border-gray-200 rounded-s-lg hover:bg-gray-100 hover:text-blue-700 focus:z-10 focus:ring-2 focus:ring-blue-700 focus:text-blue-700 dark:bg-gray-800 dark:border-gray-700 dark:text-white dark:hover:text-white dark:hover:bg-gray-700 dark:focus:ring-blue-500 dark:focus:text-white">
-                            <span x-text="played"></span> times
-                        </button>
-                        </a>
-                        <button type="button" x-on:click="open = !open" @click.outside="open = false" class="relative px-4 py-2 text-sm font-medium text-gray-900 bg-white border-e border-b border-t border-gray-200 rounded-e-lg hover:bg-gray-100 hover:text-blue-700 focus:z-10 focus:ring-2 focus:ring-blue-700 focus:text-blue-700 dark:bg-gray-800 dark:border-gray-700 dark:text-white dark:hover:text-white dark:hover:bg-gray-700 dark:focus:ring-blue-500 dark:focus:text-white align-middle">
-                            <svg class="text-white w-3" viewBox="5 8 14 8" fill="none" xmlns="http://www.w3.org/2000/svg">
-                                <path d="M6 9L12 15L18 9" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-                                </svg>
-                            <div
-                                class="absolute top-[100%] -left-[1px] w-auto whitespace-nowrap z-10 text-sm font-medium bg-gray-800/20 backdrop-blur-lg rounded-md rounded-tl-none border border-gray-200 dark:border-gray-700"
-                                x-show="open"
-                            >
-                                <ul
-                                    class=""
-                                >
-                                    <li class="px-4 py-2 dark:hover:text-white dark:hover:bg-gray-700 dark:focus:ring-blue-500 dark:focus:text-white rounded-tr-md">
-                                        <a href="{% url 'add_playevent_for_game' game.id %}">Add playthrough...</a>
-                                    </li>
-                                    <li
-                                        x-on:click="createPlayEvent"
-                                        class="relative px-4 py-2 dark:hover:text-white dark:hover:bg-gray-700 dark:focus:ring-blue-500 dark:focus:text-white rounded-b-md"
-                                    >
-                                        Played times +1
-                                    </li>
-                                    <script>
-                                       function createPlayEvent() {
-                                        this.played++;
-                                        fetch('{% url 'api-1.0.0:create_playevent' %}', { method: 'POST', headers: { 'X-CSRFToken': '{{ csrf_token }}' }, body: '{"game_id": {{ game.id }}}'})
-                                       }
-                                    </script>
-                                </ul>
-                            </div>
-                        </button>
-                      </div>
-                </div>
-
-
-  
-  
-                <div class="flex gap-2 items-center">
-                    <span class="uppercase">Platform</span>
-                    <span class="text-slate-300">{{ game.platform }}</span>
-                </div>
-            </div>
             <div class="inline-flex rounded-md shadow-sm mb-3" role="group">
                 <a href="{% url 'edit_game' game.id %}">
                     <button type="button"
@@ -131,37 +69,11 @@
         </div>
         <div class="mb-6">
             <c-h1 :badge="purchase_count">Purchases</c-h1>
-            {% if purchase_count %}
             <c-simple-table :rows=purchase_data.rows :columns=purchase_data.columns />
-            {% else %}
-            No purchases yet.
-            {% endif %}
         </div>
         <div class="mb-6">
             <c-h1 :badge="session_count">Sessions</c-h1>
-            {% if session_count %}
             <c-simple-table :rows=session_data.rows :columns=session_data.columns :header_action=session_data.header_action :page_obj=session_page_obj :elided_page_range=session_elided_page_range />
-            {% else %}
-            No sessions yet.
-            {% endif %}
-        </div>
-        <!-- list all playevents -->
-        <div class="mb-6">
-            <c-h1 :badge="playevent_count">Play Events</c-h1>
-            {% if playevent_count %}
-                <c-simple-table :rows=playevent_data.rows :columns=playevent_data.columns />
-            {% else %}
-                No play events yet.
-            {% endif %}
-        </div>
-        <div class="mb-6">
-            <c-h1 :badge="statuschange_count">History</c-h1>
-            <ul class="list-disc list-inside">
-                {% for change in statuschanges %}
-                <li class="text-slate-500">
-                    {% if change.timestamp %}{{ change.timestamp | date:"d/m/Y H:i" }}: Changed{% else %}At some point changed{% endif %} status from <c-gamestatus :status="change.old_status" class="text-white">{{ change.get_old_status_display }}</c-gamestatus> to <c-gamestatus :status="change.new_status" class="text-white">{{ change.get_new_status_display }}</c-gamestatus> (<a href="{% url 'edit_statuschange' change.id %}">Edit</a>, <a href="{% url 'delete_statuschange' change.id %}">Delete</a>)</li>
-                {% endfor %}
-            </ul>
         </div>
     </div>
     <script>

games/templates/view_purchase.html

@@ -2,17 +2,8 @@
     <div class="dark:text-white max-w-sm sm:max-w-xl lg:max-w-3xl mx-auto">
     
     <div class="flex flex-col gap-5 mb-3">
-        <div class="font-bold font-serif text-slate-500 text-2xl">
-        {% if not purchase.name %}
-            Unnamed purchase
-        {% else %}
-            {{ purchase.name }}
-        {% endif %}
-        </div>
     <span class="text-balance max-w-[30rem] text-4xl">
-        <span class="font-bold font-serif">
+        <span class="font-bold font-serif">{% if purchase.name %}{{ purchase.name }}{% else %}Unnamed purchase{% endif %}</span> <span class="text-slate-500 text-2xl">({{ purchase.games.count }} games)</span>
-            {{ purchase.date_purchased }} ({{ purchase.num_purchases }} game{{ purchase.num_purchases|pluralize}})
-        </span>
     </span>
     <div class="inline-flex rounded-md shadow-sm mb-3" role="group">
         <a href="{% url 'edit_purchase' purchase.id %}">
@@ -29,12 +20,13 @@
         </a>
     </div>
     <div>
-        <p>
+        Price:
-            Price:
+        {% if purchase.converted_price %}
-            <c-price-converted>{{ purchase.standardized_price }}</c-price-converted>
+            {{ purchase.converted_price | floatformat }} {{ purchase.converted_currency }}
-             ({{ purchase.price | floatformat:2 }} {{ purchase.price_currency }})
+        {% else %}
-        </p>
+        None
-        <p>Price per game: <c-price-converted>{{ purchase.price_per_game | floatformat:0 }} {{ purchase.converted_currency }}</c-price-converted> </p>
+        {% endif %}
+         ({{ purchase.price | floatformat }} {{ purchase.price_currency }})
     </div>
     <div>
         <h2 class="text-base">Items:</h2>

games/templatetags/duration_formatter.py

@@ -1,12 +0,0 @@
-from datetime import timedelta
-
-from django import template
-
-from common.time import durationformat, format_duration
-
-register = template.Library()
-
-
-@register.filter(name="format_duration")
-def filter_format_duration(duration: timedelta, argument: str = durationformat):
-    return format_duration(duration, format_string=argument)

games/urls.py

@@ -1,16 +1,6 @@
 from django.urls import path
 
-from games.api import api
+from games.views import device, game, general, platform, purchase, session
-from games.views import (
-    device,
-    game,
-    general,
-    platform,
-    playevent,
-    purchase,
-    session,
-    statuschange,
-)
 
 urlpatterns = [
     path("", general.index, name="index"),
@@ -35,23 +25,6 @@ urlpatterns = [
         name="delete_platform",
     ),
     path("platform/list", platform.list_platforms, name="list_platforms"),
-    path("playevent/list", playevent.list_playevents, name="list_playevents"),
-    path("playevent/add", playevent.add_playevent, name="add_playevent"),
-    path(
-        "playevent/add/for-game/<int:game_id>",
-        playevent.add_playevent,
-        name="add_playevent_for_game",
-    ),
-    path(
-        "playevent/edit/<int:playevent_id>",
-        playevent.edit_playevent,
-        name="edit_playevent",
-    ),
-    path(
-        "playevent/delete/<int:playevent_id>",
-        playevent.delete_playevent,
-        name="delete_playevent",
-    ),
     path("purchase/add", purchase.add_purchase, name="add_purchase"),
     path(
         "purchase/add/for-game/<int:game_id>",
@@ -136,31 +109,10 @@ urlpatterns = [
     ),
     path("session/list", session.list_sessions, name="list_sessions"),
     path("session/search", session.search_sessions, name="search_sessions"),
-    path(
-        "statuschange/add",
-        statuschange.AddStatusChangeView.as_view(),
-        name="add_statuschange",
-    ),
-    path(
-        "statuschange/edit/<int:statuschange_id>",
-        statuschange.EditStatusChangeView.as_view(),
-        name="edit_statuschange",
-    ),
-    path(
-        "statuschange/delete/<int:pk>",
-        statuschange.GameStatusChangeDeleteView.as_view(),
-        name="delete_statuschange",
-    ),
-    path(
-        "statuschange/list",
-        statuschange.GameStatusChangeListView.as_view(),
-        name="list_statuschanges",
-    ),
     path("stats/", general.stats_alltime, name="stats_alltime"),
     path(
         "stats/<int:year>",
         general.stats,
         name="stats_by_year",
     ),
-    path("api/", api.urls),
 ]

games/views/game.py

@@ -2,7 +2,7 @@ from typing import Any
 
 from django.contrib.auth.decorators import login_required
 from django.core.paginator import Paginator
-from django.db.models import Prefetch, Q
+from django.db.models import Prefetch
 from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
 from django.shortcuts import get_object_or_404, redirect, render
 from django.template.loader import render_to_string
@@ -12,7 +12,6 @@ from common.components import (
     A,
     Button,
     Div,
-    Form,
     Icon,
     LinkedPurchase,
     NameWithIcon,
@@ -22,44 +21,25 @@ from common.components import (
 )
 from common.time import (
     dateformat,
+    durationformat,
+    durationformat_manual,
     format_duration,
     local_strftime,
     timeformat,
 )
-from common.utils import build_dynamic_filter, safe_division, truncate
+from common.utils import safe_division, truncate
 from games.forms import GameForm
 from games.models import Game, Purchase
 from games.views.general import use_custom_redirect
-from games.views.playevent import create_playevent_tabledata
 
 
 @login_required
-def list_games(request: HttpRequest, search_string: str = "") -> HttpResponse:
+def list_games(request: HttpRequest) -> HttpResponse:
     context: dict[Any, Any] = {}
     page_number = request.GET.get("page", 1)
     limit = request.GET.get("limit", 10)
     games = Game.objects.order_by("-created_at")
     page_obj = None
-    search_string = request.GET.get("search_string", search_string)
-    if search_string != "":
-        filters = [
-            Q(name__icontains=search_string),
-            Q(sort_name__icontains=search_string),
-            Q(platform__name__icontains=search_string),
-        ]
-        try:
-            year_value = int(search_string)
-        except ValueError:
-            year_value = None
-        if year_value:
-            filters.append(Q(year_released=year_value))
-        search_string_parts = search_string.split()
-        # only search for status if it exactly matches and is the only word
-        if len(search_string_parts) == 1:
-            if search_string.title() in Game.Status.labels:
-                search_status = Game.Status[search_string.upper()]
-                filters.append(Q(status=search_status))
-        games = games.filter(build_dynamic_filter(filters, "|"))
     if int(limit) != 0:
         paginator = Paginator(games, limit)
         page_obj = paginator.get_page(page_number)
@@ -76,28 +56,11 @@ def list_games(request: HttpRequest, search_string: str = "") -> HttpResponse:
             else None
         ),
         "data": {
-            "header_action": Div(
+            "header_action": A([], Button([], "Add game"), url="add_game"),
-                children=[
-                    Form(
-                        children=[
-                            render_to_string(
-                                "cotton/search_field.html",
-                                {
-                                    "id": "search_string",
-                                    "search_string": search_string,
-                                },
-                            )
-                        ]
-                    ),
-                    A([], Button([], "Add game"), url="add_game"),
-                ],
-                attributes=[("class", "flex justify-between")],
-            ),
             "columns": [
                 "Name",
                 "Sort Name",
                 "Year",
-                "Status",
                 "Wikidata",
                 "Created",
                 "Actions",
@@ -111,10 +74,6 @@ def list_games(request: HttpRequest, search_string: str = "") -> HttpResponse:
                         else "(identical)"
                     ),
                     game.year_released,
-                    render_to_string(
-                        "cotton/gamestatus.html",
-                        {"status": game.status, "slot": game.get_status_display()},
-                    ),
                     game.wikidata,
                     local_strftime(game.created_at, dateformat),
                     render_to_string(
@@ -206,7 +165,7 @@ def view_game(request: HttpRequest, game_id: int) -> HttpResponse:
     session_count = sessions.count()
     session_count_without_manual = game.sessions.without_manual().count()
 
-    if sessions.exists():
+    if sessions:
         playrange_start = local_strftime(sessions.earliest().timestamp_start, "%b %Y")
         latest_session = sessions.latest()
         playrange_end = local_strftime(latest_session.timestamp_start, "%b %Y")
@@ -308,7 +267,11 @@ def view_game(request: HttpRequest, game_id: int) -> HttpResponse:
                     session_id=session.pk,
                 ),
                 f"{local_strftime(session.timestamp_start)}{f' — {local_strftime(session.timestamp_end, timeformat)}' if session.timestamp_end else ''}",
-                session.duration_formatted_with_mark,
+                (
+                    format_duration(session.duration_calculated, durationformat)
+                    if session.duration_calculated
+                    else f"{format_duration(session.duration_manual, durationformat_manual)}*"
+                ),
                 render_to_string(
                     "cotton/button_group.html",
                     {
@@ -346,34 +309,7 @@ def view_game(request: HttpRequest, game_id: int) -> HttpResponse:
         ],
     }
 
-    playevents = game.playevents.all()
-    playevent_count = playevents.count()
-    playevent_data = create_playevent_tabledata(playevents, exclude_columns=["Game"])
-
-    statuschanges = game.status_changes.all()
-    statuschange_count = statuschanges.count()
-    statuschange_data = {
-        "columns": [
-            "Old Status",
-            "New Status",
-            "Timestamp",
-        ],
-        "rows": [
-            [
-                statuschange.get_old_status_display()
-                if statuschange.old_status
-                else "-",
-                statuschange.get_new_status_display(),
-                local_strftime(statuschange.timestamp, dateformat),
-            ]
-            for statuschange in statuschanges
-        ],
-    }
-
     context: dict[str, Any] = {
-        "statuschange_data": statuschange_data,
-        "statuschange_count": statuschange_count,
-        "statuschanges": statuschanges,
         "game": game,
         "playrange": playrange,
         "purchase_count": game.purchases.count(),
@@ -388,8 +324,6 @@ def view_game(request: HttpRequest, game_id: int) -> HttpResponse:
         "title": f"Game Overview - {game.name}",
         "hours_sum": total_hours,
         "purchase_data": purchase_data,
-        "playevent_data": playevent_data,
-        "playevent_count": playevent_count,
         "session_data": session_data,
         "session_page_obj": session_page_obj,
         "session_elided_page_range": (

games/views/general.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import Any, Callable
 
 from django.contrib.auth.decorators import login_required
@@ -8,7 +8,6 @@ from django.db.models.manager import BaseManager
 from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
 from django.shortcuts import redirect, render
 from django.urls import reverse
-from django.utils.timezone import now as timezone_now
 
 from common.time import available_stats_year_range, dateformat, format_duration
 from common.utils import safe_division
@@ -16,24 +15,11 @@ from games.models import Game, Platform, Purchase, Session
 
 
 def model_counts(request: HttpRequest) -> dict[str, bool]:
-    now = timezone_now()
-    this_day, this_month, this_year = now.day, now.month, now.year
-    today_played = Session.objects.filter(
-        timestamp_start__day=this_day,
-        timestamp_start__month=this_month,
-        timestamp_start__year=this_year,
-    ).aggregate(time=Sum(F("duration_total")))["time"]
-    last_7_played = Session.objects.filter(
-        timestamp_start__gte=(now - timedelta(days=7))
-    ).aggregate(time=Sum(F("duration_total")))["time"]
-
     return {
         "game_available": Game.objects.exists(),
         "platform_available": Platform.objects.exists(),
         "purchase_available": Purchase.objects.exists(),
         "session_count": Session.objects.exists(),
-        "today_played": format_duration(today_played, "%H h %m m"),
-        "last_7_played": format_duration(last_7_played, "%H h %m m"),
     }
 
 
@@ -137,13 +123,19 @@ def stats_alltime(request: HttpRequest) -> HttpResponse:
     )
     total_spent = this_year_spendings["total_spent"] or 0
 
-    games_with_playtime = Game.objects.filter(
+    games_with_playtime = (
-        sessions__in=this_year_sessions
+        Game.objects.filter(sessions__in=this_year_sessions)
-    ).distinct()
+        .annotate(
+            total_playtime=Sum(
+                F("sessions__duration_calculated") + F("sessions__duration_manual")
+            )
+        )
+        .values("id", "name", "total_playtime")
+    )
     month_playtimes = (
         this_year_sessions.annotate(month=TruncMonth("timestamp_start"))
         .values("month")
-        .annotate(playtime=Sum("duration_total"))
+        .annotate(playtime=Sum("duration_calculated"))
         .order_by("month")
     )
     for month in month_playtimes:
@@ -156,14 +148,18 @@ def stats_alltime(request: HttpRequest) -> HttpResponse:
         .first()
     )
     top_10_games_by_playtime = games_with_playtime.order_by("-total_playtime")[:10]
+    for game in top_10_games_by_playtime:
+        game["formatted_playtime"] = format_duration(game["total_playtime"], "%2.0H")
 
     total_playtime_per_platform = (
         this_year_sessions.values("game__platform__name")
-        .annotate(playtime=Sum(F("duration_total")))
+        .annotate(total_playtime=Sum(F("duration_calculated") + F("duration_manual")))
         .annotate(platform_name=F("game__platform__name"))
-        .values("platform_name", "playtime")
+        .values("platform_name", "total_playtime")
-        .order_by("-playtime")
+        .order_by("-total_playtime")
     )
+    for item in total_playtime_per_platform:
+        item["formatted_playtime"] = format_duration(item["total_playtime"], "%2.0H")
 
     backlog_decrease_count = (
         Purchase.objects.all().intersection(purchases_finished_this_year).count()
@@ -191,7 +187,7 @@ def stats_alltime(request: HttpRequest) -> HttpResponse:
         "total_hours": format_duration(
             this_year_sessions.total_duration_unformatted(), "%2.0H"
         ),
-        "total_year_games": this_year_played_purchases.all().count(),
+        "total_2023_games": this_year_played_purchases.all().count(),
         "top_10_games_by_playtime": top_10_games_by_playtime,
         "year": year,
         "total_playtime_per_platform": total_playtime_per_platform,
@@ -291,43 +287,27 @@ def stats(request: HttpRequest, year: int = 0) -> HttpResponse:
         games__sessions__in=this_year_sessions
     ).distinct()
 
-    this_year_played_games = Game.objects.filter(
+    this_year_purchases = Purchase.objects.filter(date_purchased__year=year)
-        sessions__in=this_year_sessions
+    this_year_purchases_with_currency = this_year_purchases.prefetch_related("games")
-    ).distinct()
+    this_year_purchases_without_refunded = this_year_purchases_with_currency.filter(
+        date_refunded=None
+    ).exclude(ownership_type=Purchase.DEMO)
+    this_year_purchases_refunded = this_year_purchases_with_currency.refunded()
 
-    this_year_purchases = Purchase.objects.filter(
-        date_purchased__year=year
-    ).prefetch_related("games")
-    # purchased this year
-    # not refunded
-    this_year_purchases_without_refunded = Purchase.objects.filter(
-        date_refunded=None, date_purchased__year=year
-    )
-
-    # purchased this year
-    # not refunded
-    # not finished
-    # not infinite
-    # only Game and DLC
     this_year_purchases_unfinished_dropped_nondropped = (
-        this_year_purchases_without_refunded.exclude(
+        this_year_purchases_without_refunded.filter(date_finished__isnull=True)
-            games__in=Game.objects.filter(status="f")
-        )
         .filter(infinite=False)
         .filter(Q(type=Purchase.GAME) | Q(type=Purchase.DLC))
-    )
+    )  # do not count battle passes etc.
 
-    # not finished
     this_year_purchases_unfinished = (
-        this_year_purchases_unfinished_dropped_nondropped.exclude(
+        this_year_purchases_unfinished_dropped_nondropped.filter(
-            games__status__in="ura"
+            date_dropped__isnull=True
         )
     )
-    # abandoned
-    # retired
     this_year_purchases_dropped = (
-        this_year_purchases_unfinished_dropped_nondropped.exclude(
+        this_year_purchases_unfinished_dropped_nondropped.filter(
-            games__in=Game.objects.filter(status="ar")
+            date_dropped__isnull=False
         )
     )
 
@@ -343,21 +323,15 @@ def stats(request: HttpRequest, year: int = 0) -> HttpResponse:
         * 100
     )
 
-    purchases_finished_this_year = Purchase.objects.filter(
+    purchases_finished_this_year = Purchase.objects.filter(date_finished__year=year)
-        games__playevents__ended__year=year
-    ).annotate(game_name=F("games__name"), date_finished=F("games__playevents__ended"))
     purchases_finished_this_year_released_this_year = (
         purchases_finished_this_year.filter(games__year_released=year).order_by(
-            "games__playevents__ended"
+            "date_finished"
         )
     )
     purchased_this_year_finished_this_year = (
-        this_year_purchases_without_refunded.filter(
+        this_year_purchases_without_refunded.filter(date_finished__year=year)
-            games__playevents__ended__year=year
+    ).order_by("date_finished")
-        ).annotate(
-            game_name=F("games__name"), date_finished=F("games__playevents__ended")
-        )
-    ).order_by("games__playevents__ended")
 
     this_year_spendings = this_year_purchases_without_refunded.aggregate(
         total_spent=Sum(F("converted_price"))
@@ -365,21 +339,22 @@ def stats(request: HttpRequest, year: int = 0) -> HttpResponse:
     total_spent = this_year_spendings["total_spent"] or 0
 
     games_with_playtime = (
-        Game.objects.filter(sessions__timestamp_start__year=year)
+        Game.objects.filter(sessions__in=this_year_sessions)
         .annotate(
             total_playtime=Sum(
-                F("sessions__duration_calculated"),
+                F("sessions__duration_calculated") + F("sessions__duration_manual")
             )
         )
-        .filter(total_playtime__gt=timedelta(0))
+        .values("id", "name", "total_playtime")
     )
-
     month_playtimes = (
         this_year_sessions.annotate(month=TruncMonth("timestamp_start"))
         .values("month")
-        .annotate(playtime=Sum("duration_total"))
+        .annotate(playtime=Sum("duration_calculated"))
         .order_by("month")
     )
+    for month in month_playtimes:
+        month["playtime"] = format_duration(month["playtime"], "%2.0H")
 
     highest_session_average_game = (
         Game.objects.filter(sessions__in=this_year_sessions)
@@ -387,20 +362,23 @@ def stats(request: HttpRequest, year: int = 0) -> HttpResponse:
         .order_by("-session_average")
         .first()
     )
-    top_10_games_by_playtime = games_with_playtime.order_by("-total_playtime")
+    top_10_games_by_playtime = games_with_playtime.order_by("-total_playtime")[:10]
+    for game in top_10_games_by_playtime:
+        game["formatted_playtime"] = format_duration(game["total_playtime"], "%2.0H")
 
     total_playtime_per_platform = (
         this_year_sessions.values("game__platform__name")
-        .annotate(playtime=Sum(F("duration_total")))
+        .annotate(total_playtime=Sum(F("duration_calculated") + F("duration_manual")))
         .annotate(platform_name=F("game__platform__name"))
-        .values("platform_name", "playtime")
+        .values("platform_name", "total_playtime")
-        .order_by("-playtime")
+        .order_by("-total_playtime")
     )
+    for item in total_playtime_per_platform:
+        item["formatted_playtime"] = format_duration(item["total_playtime"], "%2.0H")
 
     backlog_decrease_count = (
         Purchase.objects.filter(date_purchased__year__lt=year)
-        .filter(games__status="f")
+        .intersection(purchases_finished_this_year)
-        .filter(games__playevents__ended__year=year)
         .count()
     )
 
@@ -416,10 +394,7 @@ def stats(request: HttpRequest, year: int = 0) -> HttpResponse:
         last_play_game = last_session.game
         last_play_date = last_session.timestamp_start.strftime(dateformat)
 
-    all_purchased_this_year_count = this_year_purchases.count()
+    all_purchased_this_year_count = this_year_purchases_with_currency.count()
-    this_year_purchases_refunded = Purchase.objects.exclude(date_refunded=None).filter(
-        date_purchased__year=year
-    )
     all_purchased_refunded_this_year_count = this_year_purchases_refunded.count()
 
     this_year_purchases_dropped_count = this_year_purchases_dropped.count()
@@ -431,8 +406,8 @@ def stats(request: HttpRequest, year: int = 0) -> HttpResponse:
         "total_hours": format_duration(
             this_year_sessions.total_duration_unformatted(), "%2.0H"
         ),
-        "total_games": this_year_played_games.count(),
+        "total_games": this_year_played_purchases.count(),
-        "total_year_games": this_year_played_purchases.filter(
+        "total_2023_games": this_year_played_purchases.filter(
             games__year_released=year
         ).count(),
         "top_10_games_by_playtime": top_10_games_by_playtime,
@@ -446,15 +421,15 @@ def stats(request: HttpRequest, year: int = 0) -> HttpResponse:
         ),
         "all_finished_this_year": purchases_finished_this_year.prefetch_related(
             "games"
-        ).order_by("games__playevents__ended"),
+        ).order_by("date_finished"),
         "all_finished_this_year_count": purchases_finished_this_year.count(),
         "this_year_finished_this_year": purchases_finished_this_year_released_this_year.prefetch_related(
             "games"
-        ).order_by("games__playevents__ended"),
+        ).order_by("date_finished"),
         "this_year_finished_this_year_count": purchases_finished_this_year_released_this_year.count(),
         "purchased_this_year_finished_this_year": purchased_this_year_finished_this_year.prefetch_related(
             "games"
-        ).order_by("games__playevents__ended"),
+        ).order_by("date_finished"),
         "total_sessions": this_year_sessions.count(),
         "unique_days": unique_days["dates"],
         "unique_days_percent": int(unique_days["dates"] / 365 * 100),
@@ -472,7 +447,9 @@ def stats(request: HttpRequest, year: int = 0) -> HttpResponse:
         ),
         "all_purchased_refunded_this_year": this_year_purchases_refunded,
         "all_purchased_refunded_this_year_count": all_purchased_refunded_this_year_count,
-        "all_purchased_this_year": this_year_purchases.order_by("date_purchased"),
+        "all_purchased_this_year": this_year_purchases_with_currency.order_by(
+            "date_purchased"
+        ),
         "all_purchased_this_year_count": all_purchased_this_year_count,
         "backlog_decrease_count": backlog_decrease_count,
         "longest_session_time": (

games/views/playevent.py

@@ -1,149 +0,0 @@
-import logging
-from typing import Any, Callable, TypedDict
-
-from django.contrib.auth.decorators import login_required
-from django.core.paginator import Paginator
-from django.db.models import QuerySet
-from django.db.models.manager import BaseManager
-from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
-from django.shortcuts import get_object_or_404, render
-from django.template.loader import render_to_string
-from django.urls import reverse
-
-from common.components import A, Button, Icon
-from common.time import dateformat, local_strftime
-from games.forms import PlayEventForm
-from games.models import Game, PlayEvent
-
-logger = logging.getLogger("games")
-
-
-class TableData(TypedDict):
-    header_action: Callable[..., Any]
-    columns: list[str]
-    rows: list[list[Any]]
-
-
-def create_playevent_tabledata(
-    playevents: list[PlayEvent] | BaseManager[PlayEvent] | QuerySet[PlayEvent],
-    exclude_columns: list[str] = [],
-    request: HttpRequest | None = None,
-) -> TableData:
-    column_list = [
-        "Game",
-        "Started",
-        "Ended",
-        "Days to finish",
-        "Note",
-        "Created",
-        "Actions",
-    ]
-    filtered_column_list = filter(
-        lambda x: x not in exclude_columns,
-        column_list,
-    )
-    excluded_column_indexes = [column_list.index(column) for column in exclude_columns]
-
-    row_list = [
-        [
-            playevent.game,
-            playevent.started.strftime(dateformat) if playevent.started else "-",
-            playevent.ended.strftime(dateformat) if playevent.ended else "-",
-            playevent.days_to_finish if playevent.days_to_finish else "-",
-            playevent.note,
-            local_strftime(playevent.created_at, dateformat),
-            render_to_string(
-                "cotton/button_group.html",
-                {
-                    "buttons": [
-                        {
-                            "href": reverse("edit_playevent", args=[playevent.pk]),
-                            "slot": Icon("edit"),
-                            "color": "gray",
-                        },
-                        {
-                            "href": reverse("delete_playevent", args=[playevent.pk]),
-                            "slot": Icon("delete"),
-                            "color": "red",
-                        },
-                    ]
-                },
-            ),
-        ]
-        for playevent in playevents
-    ]
-    filtered_row_list = [
-        [column for idx, column in enumerate(row) if idx not in excluded_column_indexes]
-        for row in row_list
-    ]
-    return {
-        "header_action": A([], Button([], "Add play event"), url="add_playevent"),
-        "columns": list(filtered_column_list),
-        "rows": filtered_row_list,
-    }
-
-
-@login_required
-def list_playevents(request: HttpRequest) -> HttpResponse:
-    page_number = request.GET.get("page", 1)
-    limit = request.GET.get("limit", 10)
-    playevents = PlayEvent.objects.order_by("-created_at")
-    page_obj = None
-    if int(limit) != 0:
-        paginator = Paginator(playevents, limit)
-        page_obj = paginator.get_page(page_number)
-        playevents = page_obj.object_list
-    context: dict[str, Any] = {
-        "title": "Manage play events",
-        "page_obj": page_obj or None,
-        "elided_page_range": (
-            page_obj.paginator.get_elided_page_range(
-                page_number, on_each_side=1, on_ends=1
-            )
-            if page_obj
-            else None
-        ),
-        "data": create_playevent_tabledata(playevents, request=request),
-    }
-    return render(request, "list_playevents.html", context)
-
-
-@login_required
-def add_playevent(request: HttpRequest, game_id: int = 0) -> HttpResponse:
-    initial: dict[str, Any] = {}
-    if game_id:
-        # coming from add_playevent_for_game url path
-        game = get_object_or_404(Game, id=game_id)
-        initial["game"] = game
-        initial["started"] = game.sessions.earliest().timestamp_start
-        initial["ended"] = game.sessions.latest().timestamp_start
-    form = PlayEventForm(request.POST or None, initial=initial)
-    if form.is_valid():
-        form.save()
-        if not game_id:
-            # coming from add_playevent url path
-            game_id = form.instance.game.id
-        return HttpResponseRedirect(reverse("view_game", args=[game_id]))
-
-    return render(request, "add.html", {"form": form, "title": "Add new playthrough"})
-
-
-def edit_playevent(request: HttpRequest, playevent_id: int) -> HttpResponse:
-    context: dict[str, Any] = {}
-    playevent = get_object_or_404(PlayEvent, id=playevent_id)
-    form = PlayEventForm(request.POST or None, instance=playevent)
-    if form.is_valid():
-        form.save()
-        return HttpResponseRedirect(reverse("view_game", args=[playevent.game.id]))
-
-    context = {
-        "form": form,
-        "title": "Edit Play Event",
-    }
-    return render(request, "add.html", context)
-
-
-def delete_playevent(request: HttpRequest, playevent_id: int) -> HttpResponse:
-    playevent = get_object_or_404(PlayEvent, id=playevent_id)
-    playevent.delete()
-    return HttpResponseRedirect(request.META.get("HTTP_REFERER", "/"))

games/views/purchase.py

@@ -51,6 +51,8 @@ def list_purchases(request: HttpRequest) -> HttpResponse:
                 "Infinite",
                 "Purchased",
                 "Refunded",
+                "Finished",
+                "Dropped",
                 "Created",
                 "Actions",
             ],
@@ -66,11 +68,39 @@ def list_purchases(request: HttpRequest) -> HttpResponse:
                         if purchase.date_refunded
                         else "-"
                     ),
+                    (
+                        purchase.date_finished.strftime(dateformat)
+                        if purchase.date_finished
+                        else "-"
+                    ),
+                    (
+                        purchase.date_dropped.strftime(dateformat)
+                        if purchase.date_dropped
+                        else "-"
+                    ),
                     purchase.created_at.strftime(dateformat),
                     render_to_string(
                         "cotton/button_group.html",
                         {
                             "buttons": [
+                                {
+                                    "href": reverse(
+                                        "finish_purchase", args=[purchase.pk]
+                                    ),
+                                    "slot": Icon("checkmark"),
+                                    "title": "Mark as finished",
+                                }
+                                if not purchase.date_finished
+                                else {},
+                                {
+                                    "href": reverse(
+                                        "drop_purchase", args=[purchase.pk]
+                                    ),
+                                    "slot": Icon("eject"),
+                                    "title": "Mark as dropped",
+                                }
+                                if not purchase.date_dropped
+                                else {},
                                 {
                                     "href": reverse(
                                         "refund_purchase", args=[purchase.pk]
@@ -170,11 +200,7 @@ def delete_purchase(request: HttpRequest, purchase_id: int) -> HttpResponse:
 @login_required
 def view_purchase(request: HttpRequest, purchase_id: int) -> HttpResponse:
     purchase = get_object_or_404(Purchase, id=purchase_id)
-    return render(
+    return render(request, "view_purchase.html", {"purchase": purchase})
-        request,
-        "view_purchase.html",
-        {"purchase": purchase, "title": f"Purchase: {purchase.full_name}"},
-    )
 
 
 @login_required

games/views/session.py

@@ -20,12 +20,16 @@ from common.components import (
 )
 from common.time import (
     dateformat,
+    durationformat,
+    durationformat_manual,
+    format_duration,
     local_strftime,
     timeformat,
 )
 from common.utils import truncate
 from games.forms import SessionForm
 from games.models import Game, Session
+from games.views.general import use_custom_redirect
 
 
 @login_required
@@ -126,7 +130,11 @@ def list_sessions(request: HttpRequest, search_string: str = "") -> HttpResponse
                 [
                     NameWithIcon(session_id=session.pk),
                     f"{local_strftime(session.timestamp_start)}{f' — {local_strftime(session.timestamp_end, timeformat)}' if session.timestamp_end else ''}",
-                    session.duration_formatted_with_mark,
+                    (
+                        format_duration(session.duration_calculated, durationformat)
+                        if session.duration_calculated
+                        else f"{format_duration(session.duration_manual, durationformat_manual)}*"
+                    ),
                     session.device,
                     session.created_at.strftime(dateformat),
                     render_to_string(
@@ -207,13 +215,13 @@ def add_session(request: HttpRequest, game_id: int = 0) -> HttpResponse:
             form = SessionForm(initial=initial)
 
     context["title"] = "Add New Session"
-    # TODO: re-add custom buttons #91
+    context["script_name"] = "add_session.js"
-    # context["script_name"] = "add_session.js"
     context["form"] = form
-    return render(request, "add.html", context)
+    return render(request, "add_session.html", context)
 
 
 @login_required
+@use_custom_redirect
 def edit_session(request: HttpRequest, session_id: int) -> HttpResponse:
     context = {}
     session = get_object_or_404(Session, id=session_id)
@@ -223,7 +231,7 @@ def edit_session(request: HttpRequest, session_id: int) -> HttpResponse:
         return redirect("list_sessions")
     context["title"] = "Edit Session"
     context["form"] = form
-    return render(request, "add.html", context)
+    return render(request, "add_session.html", context)
 
 
 def clone_session_by_id(session_id: int) -> Session:

games/views/statuschange.py

@@ -1,57 +0,0 @@
-from django.contrib.auth.mixins import LoginRequiredMixin
-from django.shortcuts import get_object_or_404
-from django.urls import reverse_lazy
-from django.views.generic import CreateView, DeleteView, ListView, UpdateView
-
-from games.forms import GameStatusChangeForm
-from games.models import GameStatusChange
-
-
-class EditStatusChangeView(LoginRequiredMixin, UpdateView):
-    model = GameStatusChange
-    form_class = GameStatusChangeForm
-    template_name = "add.html"
-    context_object_name = "form"
-
-    def get_object(self, queryset=None):
-        return get_object_or_404(GameStatusChange, id=self.kwargs["statuschange_id"])
-
-    def get_success_url(self):
-        return reverse_lazy("list_platforms")
-
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        context["title"] = "Edit Platform"
-        return context
-
-
-class AddStatusChangeView(LoginRequiredMixin, CreateView):
-    model = GameStatusChange
-    form_class = GameStatusChangeForm
-    template_name = "add.html"
-
-    def get_success_url(self):
-        return reverse_lazy("view_game", kwargs={"pk": self.object.game.id})
-
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        context["title"] = "Add status change"
-        return context
-
-
-class GameStatusChangeListView(LoginRequiredMixin, ListView):
-    model = GameStatusChange
-    template_name = "list_purchases.html"
-    context_object_name = "status_changes"
-    paginate_by = 10
-
-    def get_queryset(self):
-        return GameStatusChange.objects.select_related("game").all()
-
-
-class GameStatusChangeDeleteView(LoginRequiredMixin, DeleteView):
-    model = GameStatusChange
-    template_name = "gamestatuschange_confirm_delete.html"
-
-    def get_success_url(self):
-        return reverse_lazy("view_game", kwargs={"game_id": self.object.game.id})

poetry.lock

@@ -1,16 +1,4 @@
-# This file is automatically @generated by Poetry 2.1.1 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.0.0 and should not be changed by hand.
-
-[[package]]
-name = "annotated-types"
-version = "0.7.0"
-description = "Reusable constraint types to use with typing.Annotated"
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-files = [
-    {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"},
-    {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"},
-]
 
 [[package]]
 name = "asgiref"
@@ -240,14 +228,14 @@ files = [
 
 [[package]]
 name = "django"
-version = "5.1.7"
+version = "5.1.5"
 description = "A high-level Python web framework that encourages rapid development and clean, pragmatic design."
 optional = false
 python-versions = ">=3.10"
 groups = ["main", "dev"]
 files = [
-    {file = "Django-5.1.7-py3-none-any.whl", hash = "sha256:1323617cb624add820cb9611cdcc788312d250824f92ca6048fda8625514af2b"},
+    {file = "Django-5.1.5-py3-none-any.whl", hash = "sha256:c46eb936111fffe6ec4bc9930035524a8be98ec2f74d8a0ff351226a3e52f459"},
-    {file = "Django-5.1.7.tar.gz", hash = "sha256:30de4ee43a98e5d3da36a9002f287ff400b43ca51791920bfb35f6917bfe041c"},
+    {file = "Django-5.1.5.tar.gz", hash = "sha256:19bbca786df50b9eca23cee79d495facf55c8f5c54c529d9bf1fe7b5ea086af3"},
 ]
 
 [package.dependencies]
@@ -261,14 +249,14 @@ bcrypt = ["bcrypt"]
 
 [[package]]
 name = "django-cotton"
-version = "1.6.0"
+version = "1.3.0"
 description = "Bringing component based design to Django templates."
 optional = false
 python-versions = "<4,>=3.8"
 groups = ["main"]
 files = [
-    {file = "django_cotton-1.6.0-py3-none-any.whl", hash = "sha256:46452e5fc9ddfff43ac3b10925ba63151e2e9143ffa665a9519178122204b456"},
+    {file = "django_cotton-1.3.0-py3-none-any.whl", hash = "sha256:a23f29b759c43423e2f901352c0810388839cc412f6985614153c6ccfcfc2595"},
-    {file = "django_cotton-1.6.0.tar.gz", hash = "sha256:1feb2ab486491f304e701fda82f37e608f0b9874473b3ec92922f3891d1a6cd7"},
+    {file = "django_cotton-1.3.0.tar.gz", hash = "sha256:8f4a15dd55c8ee9182cf7234c228ea45d9fcdec1de125221bce8d05af035730a"},
 ]
 
 [package.dependencies]
@@ -321,27 +309,6 @@ files = [
 asgiref = ">=3.6"
 django = ">=4.2"
 
-[[package]]
-name = "django-ninja"
-version = "1.3.0"
-description = "Django Ninja - Fast Django REST framework"
-optional = false
-python-versions = ">=3.7"
-groups = ["main"]
-files = [
-    {file = "django_ninja-1.3.0-py3-none-any.whl", hash = "sha256:f58096b6c767d1403dfd6c49743f82d780d7b9688d9302ecab316ac1fa6131bb"},
-    {file = "django_ninja-1.3.0.tar.gz", hash = "sha256:5b320e2dc0f41a6032bfa7e1ebc33559ae1e911a426f0c6be6674a50b20819be"},
-]
-
-[package.dependencies]
-Django = ">=3.1"
-pydantic = ">=2.0,<3.0.0"
-
-[package.extras]
-dev = ["pre-commit"]
-doc = ["markdown-include", "mkdocs", "mkdocs-material", "mkdocstrings"]
-test = ["django-stubs", "mypy (==1.7.1)", "psycopg2-binary", "pytest", "pytest-asyncio", "pytest-cov", "pytest-django", "ruff (==0.5.7)"]
-
 [[package]]
 name = "django-picklefield"
 version = "3.2"
@@ -483,7 +450,7 @@ files = [
 [package.extras]
 docs = ["furo (>=2024.8.6)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4.1)"]
 testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "diff-cover (>=9.2)", "pytest (>=8.3.3)", "pytest-asyncio (>=0.24)", "pytest-cov (>=5)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.26.4)"]
-typing = ["typing-extensions (>=4.12.2) ; python_version < \"3.11\""]
+typing = ["typing-extensions (>=4.12.2)"]
 
 [[package]]
 name = "graphene"
@@ -561,14 +528,14 @@ graphql-core = ">=3.2,<3.3"
 
 [[package]]
 name = "gunicorn"
-version = "23.0.0"
+version = "22.0.0"
 description = "WSGI HTTP Server for UNIX"
 optional = false
 python-versions = ">=3.7"
 groups = ["main"]
 files = [
-    {file = "gunicorn-23.0.0-py3-none-any.whl", hash = "sha256:ec400d38950de4dfd418cff8328b2c8faed0edb0d517d3394e457c317908ca4d"},
+    {file = "gunicorn-22.0.0-py3-none-any.whl", hash = "sha256:350679f91b24062c86e386e198a15438d53a7a8207235a78ba1b53df4c4378d9"},
-    {file = "gunicorn-23.0.0.tar.gz", hash = "sha256:f014447a0101dc57e294f6c18ca6b40227a4c90e9bdb586042628030cba004ec"},
+    {file = "gunicorn-22.0.0.tar.gz", hash = "sha256:4a0b436239ff76fb33f11c07a16482c521a7e09c1ce3cc293c2330afe01bec63"},
 ]
 
 [package.dependencies]
@@ -695,49 +662,49 @@ testing = ["coverage", "pyyaml"]
 
 [[package]]
 name = "mypy"
-version = "1.15.0"
+version = "1.13.0"
 description = "Optional static typing for Python"
 optional = false
-python-versions = ">=3.9"
+python-versions = ">=3.8"
 groups = ["dev"]
 files = [
-    {file = "mypy-1.15.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:979e4e1a006511dacf628e36fadfecbcc0160a8af6ca7dad2f5025529e082c13"},
+    {file = "mypy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6607e0f1dd1fb7f0aca14d936d13fd19eba5e17e1cd2a14f808fa5f8f6d8f60a"},
-    {file = "mypy-1.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c4bb0e1bd29f7d34efcccd71cf733580191e9a264a2202b0239da95984c5b559"},
+    {file = "mypy-1.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8a21be69bd26fa81b1f80a61ee7ab05b076c674d9b18fb56239d72e21d9f4c80"},
-    {file = "mypy-1.15.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be68172e9fd9ad8fb876c6389f16d1c1b5f100ffa779f77b1fb2176fcc9ab95b"},
+    {file = "mypy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b2353a44d2179846a096e25691d54d59904559f4232519d420d64da6828a3a7"},
-    {file = "mypy-1.15.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7be1e46525adfa0d97681432ee9fcd61a3964c2446795714699a998d193f1a3"},
+    {file = "mypy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0730d1c6a2739d4511dc4253f8274cdd140c55c32dfb0a4cf8b7a43f40abfa6f"},
-    {file = "mypy-1.15.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2e2c2e6d3593f6451b18588848e66260ff62ccca522dd231cd4dd59b0160668b"},
+    {file = "mypy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:c5fc54dbb712ff5e5a0fca797e6e0aa25726c7e72c6a5850cfd2adbc1eb0a372"},
-    {file = "mypy-1.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:6983aae8b2f653e098edb77f893f7b6aca69f6cffb19b2cc7443f23cce5f4828"},
+    {file = "mypy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:581665e6f3a8a9078f28d5502f4c334c0c8d802ef55ea0e7276a6e409bc0d82d"},
-    {file = "mypy-1.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2922d42e16d6de288022e5ca321cd0618b238cfc5570e0263e5ba0a77dbef56f"},
+    {file = "mypy-1.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3ddb5b9bf82e05cc9a627e84707b528e5c7caaa1c55c69e175abb15a761cec2d"},
-    {file = "mypy-1.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2ee2d57e01a7c35de00f4634ba1bbf015185b219e4dc5909e281016df43f5ee5"},
+    {file = "mypy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20c7ee0bc0d5a9595c46f38beb04201f2620065a93755704e141fcac9f59db2b"},
-    {file = "mypy-1.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:973500e0774b85d9689715feeffcc980193086551110fd678ebe1f4342fb7c5e"},
+    {file = "mypy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3790ded76f0b34bc9c8ba4def8f919dd6a46db0f5a6610fb994fe8efdd447f73"},
-    {file = "mypy-1.15.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a95fb17c13e29d2d5195869262f8125dfdb5c134dc8d9a9d0aecf7525b10c2c"},
+    {file = "mypy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:51f869f4b6b538229c1d1bcc1dd7d119817206e2bc54e8e374b3dfa202defcca"},
-    {file = "mypy-1.15.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1905f494bfd7d85a23a88c5d97840888a7bd516545fc5aaedff0267e0bb54e2f"},
+    {file = "mypy-1.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5c7051a3461ae84dfb5dd15eff5094640c61c5f22257c8b766794e6dd85e72d5"},
-    {file = "mypy-1.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:c9817fa23833ff189db061e6d2eff49b2f3b6ed9856b4a0a73046e41932d744f"},
+    {file = "mypy-1.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:39bb21c69a5d6342f4ce526e4584bc5c197fd20a60d14a8624d8743fffb9472e"},
-    {file = "mypy-1.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:aea39e0583d05124836ea645f412e88a5c7d0fd77a6d694b60d9b6b2d9f184fd"},
+    {file = "mypy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:164f28cb9d6367439031f4c81e84d3ccaa1e19232d9d05d37cb0bd880d3f93c2"},
-    {file = "mypy-1.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f2147ab812b75e5b5499b01ade1f4a81489a147c01585cda36019102538615f"},
+    {file = "mypy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a4c1bfcdbce96ff5d96fc9b08e3831acb30dc44ab02671eca5953eadad07d6d0"},
-    {file = "mypy-1.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce436f4c6d218a070048ed6a44c0bbb10cd2cc5e272b29e7845f6a2f57ee4464"},
+    {file = "mypy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:a0affb3a79a256b4183ba09811e3577c5163ed06685e4d4b46429a271ba174d2"},
-    {file = "mypy-1.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8023ff13985661b50a5928fc7a5ca15f3d1affb41e5f0a9952cb68ef090b31ee"},
+    {file = "mypy-1.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a7b44178c9760ce1a43f544e595d35ed61ac2c3de306599fa59b38a6048e1aa7"},
-    {file = "mypy-1.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1124a18bc11a6a62887e3e137f37f53fbae476dc36c185d549d4f837a2a6a14e"},
+    {file = "mypy-1.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5d5092efb8516d08440e36626f0153b5006d4088c1d663d88bf79625af3d1d62"},
-    {file = "mypy-1.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:171a9ca9a40cd1843abeca0e405bc1940cd9b305eaeea2dda769ba096932bb22"},
+    {file = "mypy-1.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2904956dac40ced10931ac967ae63c5089bd498542194b436eb097a9f77bc8"},
-    {file = "mypy-1.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93faf3fdb04768d44bf28693293f3904bbb555d076b781ad2530214ee53e3445"},
+    {file = "mypy-1.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7bfd8836970d33c2105562650656b6846149374dc8ed77d98424b40b09340ba7"},
-    {file = "mypy-1.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:811aeccadfb730024c5d3e326b2fbe9249bb7413553f15499a4050f7c30e801d"},
+    {file = "mypy-1.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:9f73dba9ec77acb86457a8fc04b5239822df0c14a082564737833d2963677dbc"},
-    {file = "mypy-1.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98b7b9b9aedb65fe628c62a6dc57f6d5088ef2dfca37903a7d9ee374d03acca5"},
+    {file = "mypy-1.13.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:100fac22ce82925f676a734af0db922ecfea991e1d7ec0ceb1e115ebe501301a"},
-    {file = "mypy-1.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43a7682e24b4f576d93072216bf56eeff70d9140241f9edec0c104d0c515036"},
+    {file = "mypy-1.13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7bcb0bb7f42a978bb323a7c88f1081d1b5dee77ca86f4100735a6f541299d8fb"},
-    {file = "mypy-1.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:baefc32840a9f00babd83251560e0ae1573e2f9d1b067719479bfb0e987c6357"},
+    {file = "mypy-1.13.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bde31fc887c213e223bbfc34328070996061b0833b0a4cfec53745ed61f3519b"},
-    {file = "mypy-1.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b9378e2c00146c44793c98b8d5a61039a048e31f429fb0eb546d93f4b000bedf"},
+    {file = "mypy-1.13.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:07de989f89786f62b937851295ed62e51774722e5444a27cecca993fc3f9cd74"},
-    {file = "mypy-1.15.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e601a7fa172c2131bff456bb3ee08a88360760d0d2f8cbd7a75a65497e2df078"},
+    {file = "mypy-1.13.0-cp38-cp38-win_amd64.whl", hash = "sha256:4bde84334fbe19bad704b3f5b78c4abd35ff1026f8ba72b29de70dda0916beb6"},
-    {file = "mypy-1.15.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:712e962a6357634fef20412699a3655c610110e01cdaa6180acec7fc9f8513ba"},
+    {file = "mypy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0246bcb1b5de7f08f2826451abd947bf656945209b140d16ed317f65a17dc7dc"},
-    {file = "mypy-1.15.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95579473af29ab73a10bada2f9722856792a36ec5af5399b653aa28360290a5"},
+    {file = "mypy-1.13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7f5b7deae912cf8b77e990b9280f170381fdfbddf61b4ef80927edd813163732"},
-    {file = "mypy-1.15.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f8722560a14cde92fdb1e31597760dc35f9f5524cce17836c0d22841830fd5b"},
+    {file = "mypy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7029881ec6ffb8bc233a4fa364736789582c738217b133f1b55967115288a2bc"},
-    {file = "mypy-1.15.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:1fbb8da62dc352133d7d7ca90ed2fb0e9d42bb1a32724c287d3c76c58cbaa9c2"},
+    {file = "mypy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3e38b980e5681f28f033f3be86b099a247b13c491f14bb8b1e1e134d23bb599d"},
-    {file = "mypy-1.15.0-cp39-cp39-win_amd64.whl", hash = "sha256:d10d994b41fb3497719bbf866f227b3489048ea4bbbb5015357db306249f7980"},
+    {file = "mypy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:a6789be98a2017c912ae6ccb77ea553bbaf13d27605d2ca20a76dfbced631b24"},
-    {file = "mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e"},
+    {file = "mypy-1.13.0-py3-none-any.whl", hash = "sha256:9c250883f9fd81d212e0952c92dbfcc96fc237f4b7c92f56ac81fd48460b3e5a"},
-    {file = "mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43"},
+    {file = "mypy-1.13.0.tar.gz", hash = "sha256:0291a61b6fbf3e6673e3405cfcc0e7650bebc7939659fdca2702958038bd835e"},
 ]
 
 [package.dependencies]
-mypy_extensions = ">=1.0.0"
+mypy-extensions = ">=1.0.0"
-typing_extensions = ">=4.6.0"
+typing-extensions = ">=4.6.0"
 
 [package.extras]
 dmypy = ["psutil (>=4.0)"]
@@ -863,140 +830,6 @@ six = "*"
 [package.extras]
 test = ["coveralls", "futures", "mock", "pytest (>=2.7.3)", "pytest-benchmark", "pytest-cov"]
 
-[[package]]
-name = "pydantic"
-version = "2.10.6"
-description = "Data validation using Python type hints"
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-files = [
-    {file = "pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584"},
-    {file = "pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236"},
-]
-
-[package.dependencies]
-annotated-types = ">=0.6.0"
-pydantic-core = "2.27.2"
-typing-extensions = ">=4.12.2"
-
-[package.extras]
-email = ["email-validator (>=2.0.0)"]
-timezone = ["tzdata ; python_version >= \"3.9\" and platform_system == \"Windows\""]
-
-[[package]]
-name = "pydantic-core"
-version = "2.27.2"
-description = "Core functionality for Pydantic validation and serialization"
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-files = [
-    {file = "pydantic_core-2.27.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2d367ca20b2f14095a8f4fa1210f5a7b78b8a20009ecced6b12818f455b1e9fa"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:491a2b73db93fab69731eaee494f320faa4e093dbed776be1a829c2eb222c34c"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7969e133a6f183be60e9f6f56bfae753585680f3b7307a8e555a948d443cc05a"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3de9961f2a346257caf0aa508a4da705467f53778e9ef6fe744c038119737ef5"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e2bb4d3e5873c37bb3dd58714d4cd0b0e6238cebc4177ac8fe878f8b3aa8e74c"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:280d219beebb0752699480fe8f1dc61ab6615c2046d76b7ab7ee38858de0a4e7"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47956ae78b6422cbd46f772f1746799cbb862de838fd8d1fbd34a82e05b0983a"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:14d4a5c49d2f009d62a2a7140d3064f686d17a5d1a268bc641954ba181880236"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:337b443af21d488716f8d0b6164de833e788aa6bd7e3a39c005febc1284f4962"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:03d0f86ea3184a12f41a2d23f7ccb79cdb5a18e06993f8a45baa8dfec746f0e9"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7041c36f5680c6e0f08d922aed302e98b3745d97fe1589db0a3eebf6624523af"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-win32.whl", hash = "sha256:50a68f3e3819077be2c98110c1f9dcb3817e93f267ba80a2c05bb4f8799e2ff4"},
-    {file = "pydantic_core-2.27.2-cp310-cp310-win_amd64.whl", hash = "sha256:e0fd26b16394ead34a424eecf8a31a1f5137094cabe84a1bcb10fa6ba39d3d31"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:8e10c99ef58cfdf2a66fc15d66b16c4a04f62bca39db589ae8cba08bc55331bc"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:26f32e0adf166a84d0cb63be85c562ca8a6fa8de28e5f0d92250c6b7e9e2aff7"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c19d1ea0673cd13cc2f872f6c9ab42acc4e4f492a7ca9d3795ce2b112dd7e15"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e68c4446fe0810e959cdff46ab0a41ce2f2c86d227d96dc3847af0ba7def306"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d9640b0059ff4f14d1f37321b94061c6db164fbe49b334b31643e0528d100d99"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40d02e7d45c9f8af700f3452f329ead92da4c5f4317ca9b896de7ce7199ea459"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c1fd185014191700554795c99b347d64f2bb637966c4cfc16998a0ca700d048"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d81d2068e1c1228a565af076598f9e7451712700b673de8f502f0334f281387d"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1a4207639fb02ec2dbb76227d7c751a20b1a6b4bc52850568e52260cae64ca3b"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:3de3ce3c9ddc8bbd88f6e0e304dea0e66d843ec9de1b0042b0911c1663ffd474"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:30c5f68ded0c36466acede341551106821043e9afaad516adfb6e8fa80a4e6a6"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-win32.whl", hash = "sha256:c70c26d2c99f78b125a3459f8afe1aed4d9687c24fd677c6a4436bc042e50d6c"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-win_amd64.whl", hash = "sha256:08e125dbdc505fa69ca7d9c499639ab6407cfa909214d500897d02afb816e7cc"},
-    {file = "pydantic_core-2.27.2-cp311-cp311-win_arm64.whl", hash = "sha256:26f0d68d4b235a2bae0c3fc585c585b4ecc51382db0e3ba402a22cbc440915e4"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-win32.whl", hash = "sha256:1e2cb691ed9834cd6a8be61228471d0a503731abfb42f82458ff27be7b2186fc"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9"},
-    {file = "pydantic_core-2.27.2-cp312-cp312-win_arm64.whl", hash = "sha256:3911ac9284cd8a1792d3cb26a2da18f3ca26c6908cc434a18f730dc0db7bfa3b"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7d14bd329640e63852364c306f4d23eb744e0f8193148d4044dd3dacdaacbd8b"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82f91663004eb8ed30ff478d77c4d1179b3563df6cdb15c0817cd1cdaf34d154"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71b24c7d61131bb83df10cc7e687433609963a944ccf45190cfc21e0887b08c9"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa8e459d4954f608fa26116118bb67f56b93b209c39b008277ace29937453dc9"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8918cbebc8da707ba805b7fd0b382816858728ae7fe19a942080c24e5b7cd1"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eda3f5c2a021bbc5d976107bb302e0131351c2ba54343f8a496dc8783d3d3a6a"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8086fa684c4775c27f03f062cbb9eaa6e17f064307e86b21b9e0abc9c0f02e"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8d9b3388db186ba0c099a6d20f0604a44eabdeef1777ddd94786cdae158729e4"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7a66efda2387de898c8f38c0cf7f14fca0b51a8ef0b24bfea5849f1b3c95af27"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:18a101c168e4e092ab40dbc2503bdc0f62010e95d292b27827871dc85450d7ee"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ba5dd002f88b78a4215ed2f8ddbdf85e8513382820ba15ad5ad8955ce0ca19a1"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-win32.whl", hash = "sha256:1ebaf1d0481914d004a573394f4be3a7616334be70261007e47c2a6fe7e50130"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-win_amd64.whl", hash = "sha256:953101387ecf2f5652883208769a79e48db18c6df442568a0b5ccd8c2723abee"},
-    {file = "pydantic_core-2.27.2-cp313-cp313-win_arm64.whl", hash = "sha256:ac4dbfd1691affb8f48c2c13241a2e3b60ff23247cbcf981759c768b6633cf8b"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:d3e8d504bdd3f10835468f29008d72fc8359d95c9c415ce6e767203db6127506"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:521eb9b7f036c9b6187f0b47318ab0d7ca14bd87f776240b90b21c1f4f149320"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85210c4d99a0114f5a9481b44560d7d1e35e32cc5634c656bc48e590b669b145"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d716e2e30c6f140d7560ef1538953a5cd1a87264c737643d481f2779fc247fe1"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f66d89ba397d92f840f8654756196d93804278457b5fbede59598a1f9f90b228"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:669e193c1c576a58f132e3158f9dfa9662969edb1a250c54d8fa52590045f046"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdbe7629b996647b99c01b37f11170a57ae675375b14b8c13b8518b8320ced5"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d262606bf386a5ba0b0af3b97f37c83d7011439e3dc1a9298f21efb292e42f1a"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:cabb9bcb7e0d97f74df8646f34fc76fbf793b7f6dc2438517d7a9e50eee4f14d"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-musllinux_1_1_armv7l.whl", hash = "sha256:d2d63f1215638d28221f664596b1ccb3944f6e25dd18cd3b86b0a4c408d5ebb9"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bca101c00bff0adb45a833f8451b9105d9df18accb8743b08107d7ada14bd7da"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-win32.whl", hash = "sha256:f6f8e111843bbb0dee4cb6594cdc73e79b3329b526037ec242a3e49012495b3b"},
-    {file = "pydantic_core-2.27.2-cp38-cp38-win_amd64.whl", hash = "sha256:fd1aea04935a508f62e0d0ef1f5ae968774a32afc306fb8545e06f5ff5cdf3ad"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:c10eb4f1659290b523af58fa7cffb452a61ad6ae5613404519aee4bfbf1df993"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ef592d4bad47296fb11f96cd7dc898b92e795032b4894dfb4076cfccd43a9308"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c61709a844acc6bf0b7dce7daae75195a10aac96a596ea1b776996414791ede4"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:42c5f762659e47fdb7b16956c71598292f60a03aa92f8b6351504359dbdba6cf"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c9775e339e42e79ec99c441d9730fccf07414af63eac2f0e48e08fd38a64d76"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:57762139821c31847cfb2df63c12f725788bd9f04bc2fb392790959b8f70f118"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d1e85068e818c73e048fe28cfc769040bb1f475524f4745a5dc621f75ac7630"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:097830ed52fd9e427942ff3b9bc17fab52913b2f50f2880dc4a5611446606a54"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:044a50963a614ecfae59bb1eaf7ea7efc4bc62f49ed594e18fa1e5d953c40e9f"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:4e0b4220ba5b40d727c7f879eac379b822eee5d8fff418e9d3381ee45b3b0362"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5e4f4bb20d75e9325cc9696c6802657b58bc1dbbe3022f32cc2b2b632c3fbb96"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-win32.whl", hash = "sha256:cca63613e90d001b9f2f9a9ceb276c308bfa2a43fafb75c8031c4f66039e8c6e"},
-    {file = "pydantic_core-2.27.2-cp39-cp39-win_amd64.whl", hash = "sha256:77d1bca19b0f7021b3a982e6f903dcd5b2b06076def36a652e3907f596e29f67"},
-    {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2bf14caea37e91198329b828eae1618c068dfb8ef17bb33287a7ad4b61ac314e"},
-    {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0cb791f5b45307caae8810c2023a184c74605ec3bcbb67d13846c28ff731ff8"},
-    {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:688d3fd9fcb71f41c4c015c023d12a79d1c4c0732ec9eb35d96e3388a120dcf3"},
-    {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d591580c34f4d731592f0e9fe40f9cc1b430d297eecc70b962e93c5c668f15f"},
-    {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:82f986faf4e644ffc189a7f1aafc86e46ef70372bb153e7001e8afccc6e54133"},
-    {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:bec317a27290e2537f922639cafd54990551725fc844249e64c523301d0822fc"},
-    {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:0296abcb83a797db256b773f45773da397da75a08f5fcaef41f2044adec05f50"},
-    {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:0d75070718e369e452075a6017fbf187f788e17ed67a3abd47fa934d001863d9"},
-    {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7e17b560be3c98a8e3aa66ce828bdebb9e9ac6ad5466fba92eb74c4c95cb1151"},
-    {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c33939a82924da9ed65dab5a65d427205a73181d8098e79b6b426bdf8ad4e656"},
-    {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:00bad2484fa6bda1e216e7345a798bd37c68fb2d97558edd584942aa41b7d278"},
-    {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c817e2b40aba42bac6f457498dacabc568c3b7a986fc9ba7c8d9d260b71485fb"},
-    {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:251136cdad0cb722e93732cb45ca5299fb56e1344a833640bf93b2803f8d1bfd"},
-    {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d2088237af596f0a524d3afc39ab3b036e8adb054ee57cbb1dcf8e09da5b29cc"},
-    {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:d4041c0b966a84b4ae7a09832eb691a35aec90910cd2dbe7a208de59be77965b"},
-    {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:8083d4e875ebe0b864ffef72a4304827015cff328a1be6e22cc850753bfb122b"},
-    {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f141ee28a0ad2123b6611b6ceff018039df17f32ada8b534e6aa039545a3efb2"},
-    {file = "pydantic_core-2.27.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7d0c8399fcc1848491f00e0314bd59fb34a9c008761bcb422a057670c3f65e35"},
-    {file = "pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39"},
-]
-
-[package.dependencies]
-typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0"
-
 [[package]]
 name = "pytest"
 version = "8.3.3"
@@ -1334,7 +1167,7 @@ files = [
 ]
 
 [package.extras]
-brotli = ["brotli (>=1.0.9) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\""]
+brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"]
 h2 = ["h2 (>=4,<5)"]
 socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
 zstd = ["zstandard (>=0.18.0)"]
@@ -1356,7 +1189,7 @@ click = ">=7.0"
 h11 = ">=0.8"
 
 [package.extras]
-standard = ["colorama (>=0.4) ; sys_platform == \"win32\"", "httptools (>=0.5.0)", "python-dotenv (>=0.13)", "pyyaml (>=5.1)", "uvloop (>=0.14.0,!=0.15.0,!=0.15.1) ; sys_platform != \"win32\" and sys_platform != \"cygwin\" and platform_python_implementation != \"PyPy\"", "watchfiles (>=0.13)", "websockets (>=10.4)"]
+standard = ["colorama (>=0.4)", "httptools (>=0.5.0)", "python-dotenv (>=0.13)", "pyyaml (>=5.1)", "uvloop (>=0.14.0,!=0.15.0,!=0.15.1)", "watchfiles (>=0.13)", "websockets (>=10.4)"]
 
 [[package]]
 name = "virtualenv"
@@ -1377,9 +1210,9 @@ platformdirs = ">=3.9.1,<5"
 
 [package.extras]
 docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
-test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8) ; platform_python_implementation == \"PyPy\" or platform_python_implementation == \"CPython\" and sys_platform == \"win32\" and python_version >= \"3.13\"", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10) ; platform_python_implementation == \"CPython\""]
+test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"]
 
 [metadata]
 lock-version = "2.1"
 python-versions = "^3.11"
-content-hash = "6538de3a90b0a21de23da3768e8eeb6f520b09a61eb33454bb8a2b50444c14f5"
+content-hash = "b5bb46a6591964aec145637cd9a412a681f2cc5e7e4fdd6fd9ecb0fe8724b8e3"

pyproject.toml

@@ -22,7 +22,7 @@ django-debug-toolbar = "^4.4.2"
 [tool.poetry.dependencies]
 python = "^3.11"
 django = "^5.0.6"
-gunicorn = "^23.0.0"
+gunicorn = "^22.0.0"
 uvicorn = "^0.30.1"
 graphene-django = "^3.2.0"
 django-htmx = "^1.18.0"
@@ -34,7 +34,6 @@ django-q2 = "^1.7.4"
 croniter = "^5.0.1"
 requests = "^2.32.3"
 pyyaml = "^6.0.2"
-django-ninja = "^1.3.0"
 [tool.isort]
 profile = "black"
 

timetracker/settings.py

@@ -47,7 +47,7 @@ INSTALLED_APPS = [
 
 Q_CLUSTER = {
     "name": "DjangoQ",
-    "workers": 1,
+    "workers": 4,
     "recycle": 500,
     "timeout": 60,
     "retry": 120,
@@ -113,10 +113,6 @@ DATABASES = {
     "default": {
         "ENGINE": "django.db.backends.sqlite3",
         "NAME": BASE_DIR / "db.sqlite3",
-        "OPTIONS": {
-            "timeout": 20,
-            "init_command": "PRAGMA synchronous=FULL; PRAGMA journal_mode=WAL;",
-        },
     }
 }
 
@@ -173,9 +169,8 @@ LOGGING = {
     "loggers": {
         "django": {
             "handlers": ["console"],
-            "level": "WARNING",
+            "level": "INFO",
         },
-        "games": {"handlers": ["console"], "level": "INFO", "propagate": False},
     },
 }