[release] Update project log for 37

PROJECT.org

@@ -92,7 +92,7 @@ fetching and simple saving.
 :LOGBOOK:
 CLOCK: [2025-07-09 Wed 09:55]--[2025-07-09 Wed 10:15] =>  0:20
 :END:
-* Backlog [2/26]
+* Backlog [0/19]
 ** TODO [#C] Create small utility to clean up tracks scrobbled with wonky playback times :vrobbler:personal:bug:music:scrobbles:
 ** TODO [#C] Move to using more robust mopidy-webhooks pacakge form pypi :utility:improvement:
 :PROPERTIES:
@@ -414,7 +414,6 @@ Could be as simple as a JSON form on the scrobble detail page (do I have have on
 ** TODO [#B] Add webdav syncing to retroarch imports :vrobbler:videogames:webdav:feature:project:personal:
 ** TODO [#B] Add CSV endpoint for book scrobbles that LibraryThing can ingest :personal:project:books:feature:export:
 https://app.todoist.com/app/task/add-a-csv-endpoint-for-users-book-reads-that-library-thing-can-ingest-6X7QPMRp265xMXqg#comment-6X7QrXq6gJjMP4hg
-** TODO [#B] Add youtube link in place of IMDB on video detail page :vrobbler:feature:videos:personal:project:
 ** TODO [#B] Fix PuzzleLogData has no attribute form :vrobbler:puzzles:personal:project:logdata:
 ** TODO [#B] Scrape ComicBookRoundUp ratings for comic book metadata :vrobbler:books:feature:comicbook:personal:project:
 
@@ -422,13 +421,82 @@ https://app.todoist.com/app/task/add-a-csv-endpoint-for-users-book-reads-that-li
 
   As an example https://comicbookroundup.com/comic-books/reviews/humanoids-publishing/the-history-of-science-fiction
 ** TODO [#B] Add PuzzleLogData class with with_people and completed :vrobbler:feature:puzzles:logdata:personal:project:
-** TODO [#A] Add classmethod for metadata fetching to tracks :vrobbler:feature:music:personal:project:
+** TODO [#A] Fix raw text webpage title not truncating to 254 chars :vrobbler:personal:bug:webpages:
+
+- Note taken on [2025-09-30 Tue 09:33]
+
+  This may have already been resolved ... need to just confirm it.
+** TODO [#A] Find page numbers for comic books from ComicVine :vrobbler:feature:books:personal:project:
+** TODO [#A] Fix koreader scrobble imports to use DST properly :vrobbler:personal:bug:books:imports:
+
+- Note taken on [2025-09-25 Thu 10:37] \\
+
+  This may already be fixed ... need to check.
+
+- Note taken on [2025-02-25 12:34] \\
+
+  The page data has the canonical date something was read in it, but it seems
+  to be an hour off. I traced this back to being off during DST, so we just need
+  the importer to be aware of whether a user is using DST or not and roll back
+  an hour for part of the year. Also, we'd need to adjust any old scrobbles that
+  took place with DST off to roll them back by an hour.
+
+* Version 37.0 [4/4]
+** DONE [#A] Tasks from org-mode should properly update notes and leave them out of the body :vrobbler:bug:tasks:
+:PROPERTIES:
+:ID:       c8410001-dbb7-1536-bd89-9784189e058f
+:END:
+** DONE [#A] Allow scrobbling from the Food list page's start links :vrobbler:bug:food:scrobbling:personal:project:
+:PROPERTIES:
+:ID:       00f99f60-ac00-6cde-311d-c31f41a01353
+:END:
+https://life.lab.unbl.ink/scrobble/e39779c8-62a5-46a6-bdef-fb7662810dc6/start/
+** DONE [#B] Food scrobbles should inherit calories from obj if missing :vrobbler:feature:food:personal:project:
+:PROPERTIES:
+:ID:       3322ff69-4252-db65-36b3-fae56c1b9327
+:END:
+** DONE [#A] Puzzles (and all longplays) should have a "Completed?" column on their detail page :vrobbler:bug:puzzles:personal:project:
+:PROPERTIES:
+:ID:       e3e49a9a-67d2-8ad8-1114-6f05effee9b7
+:END:
+* Version 36.0 [1/1]
+** DONE [#A] Refactor how videos are scrobbled :vrobbler:vidoes:feature:personal:project:
+:PROPERTIES:
+:ID:       6034a11d-5376-994d-9a4b-e1640e258cfa
+:END:
+* Version 35.0 [3/3]
+** DONE [#B] Add youtube link in place of IMDB on video detail page :vrobbler:feature:videos:personal:project:
+:PROPERTIES:
+:ID:       84064bd6-2258-a4de-f048-b131db9465c9
+:END:
+** DONE [#B] Add missing API lookups to resolve broken scrobbles endpoint :vrobbler:feature:api:scrobbles:personal:project:
+:PROPERTIES:
+:ID:       0f668a54-f587-3b17-353e-3a56969d3a82
+:END:
+** DONE [#A] IMDB lookups are not working :vrobbler:bug:videos:personal:project:
+:PROPERTIES:
+:ID:       d1ba1ca1-509b-13a9-1307-b2dc94a2eafe
+:END:
+* Version 34.0 [4/4]
+** DONE [#A] Use bgg-api for BoardGameGeek lookups :vrobbler:feature:boardgames:personal:project:
+:PROPERTIES:
+:ID:       738abb5a-c796-b16b-fe10-6e5639a0e10d
+:END:
+** DONE [#A] Add classmethod for metadata fetching to tracks :vrobbler:feature:music:personal:project:
 :PROPERTIES:
 :ID:       bc4b45e5-4c65-13c5-ab7b-1937d3fbf5c2
 :END:
 
-** TODO [#A] Tasks from org-mode should properly update notes and leave them out of the body :vrobbler:bug:tasks:
-** TODO [#A] Fix views for TV series where next episode is now None :vrobbler:bug:personal:videos:
+- Note taken on [2025-10-29 Wed 21:44]
+
+  Beyond a classmethod (which I think we have now), we need to update the flow of how we look up tracks.
+
+  It's a hot mess right now where Various Artists walks over the actual artist, and we often hit MB when we don't have to.
+
+** DONE [#A] Fix views for TV series where next episode is now None :vrobbler:bug:personal:videos:
+:PROPERTIES:
+:ID:       d7014ac4-cda6-0802-2cdf-8f66c6389fea
+:END:
 
 #+begin_src python
 ERROR    django.request:241 log_response Internal Server Error: /series/c24100d1-da45-4abe-86bf-27cfce9b1f89/
@@ -457,28 +525,32 @@ Traceback (most recent call last):
 TypeError: can only concatenate str (not "NoneType") to str
 #+end_src
 
-** TODO [#A] Fix koreader scrobble imports to use DST properly :vrobbler:personal:bug:books:imports:
+** DONE [#A] Emacs tasks are duplicating rather than updating :vrobbler:bug:tasks:emacs:personal:project:
+:PROPERTIES:
+:ID:       e93efc25-7ce9-8ef2-662e-0a19dd0b29c9
+:END:
 
-- Note taken on [2025-09-25 Thu 10:37] \\
+- Note taken on [2025-10-29 Wed 16:38]
 
-  This may already be fixed ... need to check.
+  Turns out I was misusing `orgmode` for the source of tasks when it shoulda been `Org-mode`
 
-- Note taken on [2025-02-25 12:34] \\
+  A good lesson in using constants for things.
 
-  The page data has the canonical date something was read in it, but it seems
-  to be an hour off. I traced this back to being off during DST, so we just need
-  the importer to be aware of whether a user is using DST or not and roll back
-  an hour for part of the year. Also, we'd need to adjust any old scrobbles that
-  took place with DST off to roll them back by an hour.
-
-** TODO [#A] Allow scrobbling from the Food list page's start links :vrobbler:bug:food:scrobbling:personal:project:
-https://life.lab.unbl.ink/scrobble/e39779c8-62a5-46a6-bdef-fb7662810dc6/start/
-** TODO [#A] Puzzles (and all longplays) should have a "Completed?" column on their detail page :vrobbler:bug:puzzles:personal:project:
-** TODO [#A] Fix raw text webpage title not truncating to 254 chars :vrobbler:personal:bug:webpages:
-
-- Note taken on [2025-09-30 Tue 09:33]
-
-  This may have already been resolved ... need to just confirm it.
+* Version 33.0 [3/3]
+** DONE [#A] Fix bug where scrobble is_stale only uses seconds not total_seconds :vrobbler:bug:scrobbles:personal:project:
+:PROPERTIES:
+:ID:       7f6070ac-4f67-011d-ebd5-f3dc47da46ed
+:END:
+** DONE [#B] Fix duplicatged Read next issue for Comic books :vrobbler:bug:books:personal:project:
+:PROPERTIES:
+:ID:       97943040-1f03-b0b7-b0aa-123a783e4f7b
+:END:
+** DONE [#A] Add API authentication to BGG calls :vrobbler:bug:boardgames:personal:project:
+:PROPERTIES:
+:ID:       4955cc34-0882-50db-92f7-f36a95bf57a4
+:END:
+<2025-10-28 Tue>
+* Version 32.0 [2/2]
 ** DONE [#B] Save path to reading source on book scrobbles and show it on the detail page :vrobbler:feature:books:personal:project:
 :PROPERTIES:
 :ID:       f1ef3945-e6e4-66c1-b72e-3cede7a0f84a

pyproject.toml

@@ -5,7 +5,7 @@ description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.12"
+python = ">=3.11,<3.14"
 Django = "^4.0.3"
 django-extensions = "^3.1.5"
 python-dateutil = "^2.8.2"
@@ -16,8 +16,8 @@ httpx = "<=0.27.2"
 djangorestframework = "^3.13.1"
 Markdown = "^3.3.6"
 django-filter = "^21.1"
-Pillow = "^9.0.1"
-psycopg2 = "^2.9.3"
+Pillow = "^10.0.0"
+psycopg2 = "2.9.10"
 dj-database-url = "^0.5.0"
 django-mathfilters = "^1.0.0"
 django-allauth = "^0.50.0"
@@ -28,7 +28,7 @@ django-markdownify = "^0.9.1"
 gunicorn = "^20.1.0"
 django-simple-history = "^3.1.1"
 musicbrainzngs = "^0.7.1"
-cinemagoer = "^2022.12.27"
+cinemagoerng = {git = "https://github.com/cinemagoer/cinemagoerng"}
 pysportsdb = "^0.1.0"
 pytz = "^2022.7.1"
 django-redis = "^5.2.0"
@@ -41,11 +41,11 @@ beautifulsoup4 = "^4.11.2"
 django-storages = "^1.13.2"
 stream-sqlite = "^0.0.41"
 ipython = "^8.14.0"
-pendulum = "^2.1.2"
+pendulum = "^3"
 trafilatura = "^1.6.3"
 django-imagekit = "^5.0.0"
 thefuzz = "^0.22.1"
-dataclass-wizard = "0.22.0"
+dataclass-wizard = "^0.35.0"
 webdavclient3 = "^3.14.6"
 boto3 = "^1.35.37"
 urllib3 = "<2"
@@ -58,6 +58,7 @@ tmdbv3api = "^1.9.0"
 themoviedb = "^1.0.2"
 feedparser = "^6.0.12"
 titlecase = "^2.4.1"
+bgg-api = "^1.1.13"
 
 [tool.poetry.group.test]
 optional = true

tests/boardgames_tests/test_bgg.py

@@ -1,3 +1,4 @@
+import pytest
 from boardgames.bgg import (
     take_first,
     lookup_boardgame_id_from_bgg,
@@ -5,12 +6,14 @@ from boardgames.bgg import (
 )
 
 
+@pytest.mark.skip(reason="Deprecated library")
 def test_take_first():
     assert take_first([]) == ""
 
     assert take_first(["a", "b"]) == "a"
 
 
+@pytest.mark.skip(reason="Deprecated library")
 def test_lookup_boardgame_id_from_bgg():
     bgg_id = lookup_boardgame_id_from_bgg("Cosmic Encounter")
     assert bgg_id == "15"
@@ -19,6 +22,7 @@ def test_lookup_boardgame_id_from_bgg():
     assert bgg_id == None
 
 
+@pytest.mark.skip(reason="Deprecated library")
 def test_lookup_boardgame_from_bgg():
     bgg_result = lookup_boardgame_from_bgg(15)
     assert bgg_result.get("bggeek_id") == 15

tests/scrobbles_tests/conftest.py

@@ -34,7 +34,7 @@ def test_track():
     Track.objects.create(
         title="Emotion",
         artist=Artist.objects.create(name="Carly Rae Jepsen"),
-        run_time_seconds=60,
+        base_run_time_seconds=60,
     )
 
 

tests/videos_tests/test_imdb.py

@@ -1,6 +1,10 @@
 from videos.sources.imdb import lookup_video_from_imdb
 
-
-def test_lookup_imdb():
+def test_lookup_imdb_without_tt():
     metadata = lookup_video_from_imdb("8946378")
+    print(metadata.__dict__)
+    assert not metadata.imdb_id
+
+def test_lookup_imdb_with_tt():
+    metadata = lookup_video_from_imdb("tt8946378")
     assert metadata.title == "Knives Out"

vrobbler/apps/beers/api/serializers.py

@@ -0,0 +1,18 @@
+from rest_framework import serializers
+from beers.models import Beer, BeerProducer, BeerStyle
+
+
+class BeerSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Beer
+        fields = "__all__"
+        
+class BeerProducerSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = BeerProducer
+        fields = "__all__"
+
+class BeerStyleSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = BeerStyle
+        fields = "__all__"

vrobbler/apps/beers/api/views.py

@@ -0,0 +1,19 @@
+from rest_framework import permissions, viewsets
+from beers.api import serializers
+from beers import models
+
+
+class BeerViewSet(viewsets.ModelViewSet):
+    queryset = models.Beer.objects.all().order_by("-created")
+    serializer_class = serializers.BeerSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+class BeerProducerViewSet(viewsets.ModelViewSet):
+    queryset = models.BeerProducer.objects.all().order_by("-created")
+    serializer_class = serializers.BeerProducerSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+class BeerStyleViewSet(viewsets.ModelViewSet):
+    queryset = models.BeerStyle.objects.all().order_by("-created")
+    serializer_class = serializers.BeerStyleSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/beers/migrations/0006_remove_beer_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('beers', '0005_alter_beer_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='beer',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='beer',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='beer',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/boardgames/api/serializers.py

@@ -0,0 +1,22 @@
+from boardgames import models
+from rest_framework import serializers
+
+class BoardGameDesignerSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.BoardGameDesigner
+        fields = "__all__"
+
+class BoardGamePublisherSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.BoardGamePublisher
+        fields = "__all__"
+
+class BoardGameLocationSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.BoardGameLocation
+        fields = "__all__"
+
+class BoardGameSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.BoardGame
+        fields = "__all__"

vrobbler/apps/boardgames/api/views.py

@@ -0,0 +1,28 @@
+from rest_framework import permissions, viewsets
+
+from boardgames.api import serializers
+from boardgames import models
+
+
+class BoardGameDesignerViewSet(viewsets.ModelViewSet):
+    queryset = models.BoardGameDesigner.objects.all().order_by("-created")
+    serializer_class = serializers.BoardGameDesignerSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class BoardGamePublisherViewSet(viewsets.ModelViewSet):
+    queryset = models.BoardGamePublisher.objects.all().order_by("-created")
+    serializer_class = serializers.BoardGamePublisherSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class BoardGameLocationViewSet(viewsets.ModelViewSet):
+    queryset = models.BoardGameLocation.objects.all().order_by("-created")
+    serializer_class = serializers.BoardGameLocationSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class BoardGameViewSet(viewsets.ModelViewSet):
+    queryset = models.BoardGame.objects.all().order_by("-created")
+    serializer_class = serializers.BoardGameSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/boardgames/bgg.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Optional
 import requests
 from bs4 import BeautifulSoup
 from django.contrib.auth import get_user_model
+from django.conf import settings
 
 User = get_user_model()
 if TYPE_CHECKING:
@@ -17,6 +18,8 @@ SEARCH_ID_URL = (
     "https://boardgamegeek.com/xmlapi/search?search={query}&exact=1"
 )
 GAME_ID_URL = "https://boardgamegeek.com/xmlapi/boardgame/{id}"
+BGG_ACCESS_TOKEN = getattr(settings, "BGG_ACCESS_TOKEN", "")
+BASE_HEADERS = {"User-Agent": "Vrobbler 31.0", "Authorization": f"Bearer {BGG_ACCESS_TOKEN}"}
 
 
 def take_first(thing: Optional[list]) -> str:
@@ -37,10 +40,9 @@ def take_first(thing: Optional[list]) -> str:
 
 def lookup_boardgame_id_from_bgg(title: str) -> Optional[int]:
     soup = None
-    headers = {"User-Agent": "Vrobbler 0.11.12"}
     game_id = None
     url = SEARCH_ID_URL.format(query=title)
-    r = requests.get(url, headers=headers)
+    r = requests.get(url, headers=BASE_HEADERS)
     if r.status_code == 200:
         soup = BeautifulSoup(r.text, "xml")
 
@@ -57,7 +59,6 @@ def lookup_boardgame_id_from_bgg(title: str) -> Optional[int]:
 def lookup_boardgame_from_bgg(lookup_id: str) -> dict:
     soup = None
     game_dict = {}
-    headers = {"User-Agent": "Vrobbler 0.11.12"}
 
     title = ""
     bgg_id = None
@@ -73,7 +74,7 @@ def lookup_boardgame_from_bgg(lookup_id: str) -> dict:
         bgg_id = lookup_boardgame_id_from_bgg(title)
 
     url = GAME_ID_URL.format(id=bgg_id)
-    r = requests.get(url, headers=headers)
+    r = requests.get(url, headers=BASE_HEADERS)
     if r.status_code == 200:
         soup = BeautifulSoup(r.text, "xml")
 
@@ -109,7 +110,8 @@ def push_scrobble_to_bgg(scrobble: "Scrobble", user: User) -> Optional[bool]:
     login_payload = {
         "credentials": {"username": bgg_username, "password": bgg_password}
     }
-    headers = {"content-type": "application/json"}
+    headers = BASE_HEADERS
+    headers["content-type"] = "application/json"
 
     # TODO Look up past plays for scrobble.media_obj.bggeek_id, and make sure we haven't scrobbled this before
 

vrobbler/apps/boardgames/migrations/0011_remove_boardgame_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boardgames', '0010_boardgame_published_year'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='boardgame',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='boardgame',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='boardgame',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/boardgames/migrations/0012_boardgame_bgg_rank.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.19 on 2025-11-03 04:34
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boardgames', '0011_remove_boardgame_run_time_seconds_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='boardgame',
+            name='bgg_rank',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/boardgames/migrations/0013_boardgame_publishers.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.19 on 2025-11-03 04:41
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boardgames', '0012_boardgame_bgg_rank'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='boardgame',
+            name='publishers',
+            field=models.ManyToManyField(related_name='board_games', to='boardgames.boardgamepublisher'),
+        ),
+    ]

vrobbler/apps/boardgames/models.py

@@ -2,12 +2,12 @@ from functools import cached_property
 import logging
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Optional
+from typing import Optional, Any
 from uuid import uuid4
 
 from django import forms
 import requests
-from boardgames.bgg import lookup_boardgame_from_bgg
+from boardgames.sources.bgg import lookup_boardgame_from_bgg
 from django.conf import settings
 from django.core.files.base import ContentFile
 from django.db import models
@@ -191,6 +191,10 @@ class BoardGame(ScrobblableMixin):
     publisher = models.ForeignKey(
         BoardGamePublisher, **BNULL, on_delete=models.DO_NOTHING
     )
+    publishers = models.ManyToManyField(
+        BoardGamePublisher,
+        related_name="board_games",
+    )
     designers = models.ManyToManyField(
         BoardGameDesigner,
         related_name="board_games",
@@ -224,6 +228,7 @@ class BoardGame(ScrobblableMixin):
         options={"quality": 75},
     )
     rating = models.FloatField(**BNULL)
+    bgg_rank = models.IntegerField(**BNULL)
     max_players = models.PositiveSmallIntegerField(**BNULL)
     min_players = models.PositiveSmallIntegerField(**BNULL)
     published_date = models.DateField(**BNULL)
@@ -301,29 +306,58 @@ class BoardGame(ScrobblableMixin):
 
             # Go get cover image if the URL is present
             if cover_url and not self.cover:
-                headers = {"User-Agent": "Vrobbler 0.11.12"}
-                r = requests.get(cover_url, headers=headers)
-                logger.debug(r.status_code)
-                if r.status_code == 200:
-                    fname = f"{self.title}_cover_{self.uuid}.jpg"
-                    self.cover.save(fname, ContentFile(r.content), save=True)
-                    logger.debug("Loaded cover image from BGGeek")
+                self.save_image_from_url(cover_url)
+
+    def save_image_from_url(self, url):
+        headers = {"User-Agent": "Vrobbler 0.11.12"}
+        r = requests.get(url, headers=headers)
+        if r.status_code == 200:
+            fname = f"{self.title}_cover_{self.uuid}.jpg"
+            self.cover.save(fname, ContentFile(r.content), save=True)
 
     @classmethod
     def find_or_create(
-        cls, lookup_id: str, data: Optional[dict] = {}
-    ) -> Optional["BoardGame"]:
+        cls, lookup_id: str, data: dict[str, Any] = {}
+    ) -> "BoardGame":
         """Given a Lookup ID (either BGG or BGA ID), return a board game object"""
-        boardgame = cls.objects.filter(bggeek_id=lookup_id).first()
+        game = cls.objects.filter(bggeek_id=lookup_id).first()
 
-        if not data or not boardgame:
-            data = lookup_boardgame_from_bgg(lookup_id)
+        if game:
+            logger.info("Board game exists in database.", extra={"lookup_id": lookup_id, "data": data})
+            return game
 
-        if data and not boardgame:
-            boardgame, created = cls.objects.get_or_create(
-                title=data["title"], bggeek_id=lookup_id
-            )
-            if created:
-                boardgame.fix_metadata(data=data)
+        bgg_data = lookup_boardgame_from_bgg(data.get("name"))
 
-        return boardgame
+        mechanics = bgg_data.pop("mechanics", [])
+        designers = bgg_data.pop("designers", [])
+        categories = bgg_data.pop("categories", [])
+        publishers = bgg_data.pop("publishers", [])
+        cover_url = bgg_data.pop("cover_url")
+
+        game = cls.objects.create(
+            **bgg_data
+        )
+
+        game.save_image_from_url(cover_url)
+        game.cooperative = data.get("cooperative", False)
+        game.highest_wins = data.get("highestWins", True)
+        game.no_points = data.get("noPoints", False)
+        game.uses_teams = data.get("useTeams", False)
+        game.bgstats_id = data.get("uuid", None)
+        game.save()
+
+        if designers:
+            for designer_name in designers:
+                designer, created = BoardGameDesigner.objects.get_or_create(
+                    name=designer_name
+                )
+                game.designers.add(designer.id)
+
+        if publishers:
+            for name in publishers:
+                publisher, _ = BoardGamePublisher.objects.get_or_create(
+                    name=name
+                )
+                game.publishers.add(publisher)
+
+        return game

vrobbler/apps/boardgames/sources/bgg.py

@@ -0,0 +1,29 @@
+from typing import Any
+from boardgamegeek import BGGClient
+
+from django.conf import settings
+
+def lookup_boardgame_from_bgg(title: str) -> dict[str, Any]:
+    game_dict = {"title": title}
+
+    bgg = BGGClient(access_token=settings.BGG_ACCESS_TOKEN)
+
+    game = bgg.game(title)
+
+    if game:
+        game_dict["description"] = game.description
+        game_dict["published_year"] = game.yearpublished
+        game_dict["cover_url"] = game.image
+        game_dict["min_players"] = game.minplayers
+        game_dict["max_players"] = game.maxplayers
+        game_dict["recommended_age"] = game.minage
+        game_dict["rating"] = game.rating_average
+        game_dict["bgg_rank"] = game.bgg_rank
+        game_dict["base_run_time_seconds"] = int(game.playingtime) * 60 if game.playingtime else None
+
+        game_dict["mechanics"] = game.mechanics
+        game_dict["categories"] = game.categories
+        game_dict["designers"] = game.designers
+        game_dict["publishers"] = game.publishers
+
+    return game_dict

vrobbler/apps/boardgames/sources/lichess.py

@@ -18,9 +18,9 @@ def import_chess_games_for_user_id(user_id: int, commit: bool = False) -> dict:
     for game_dict in games:
         chess, created = BoardGame.objects.get_or_create(title="Chess")
         if created:
-            chess.run_time_seconds = 1800
+            chess.base_run_time_seconds = 1800
             chess.bggeek_id = 171
-            chess.save(update_fields=["run_time_seconds", "bggeek_id"])
+            chess.save(update_fields=["base_run_time_seconds", "bggeek_id"])
         scrobble = Scrobble.objects.filter(
             user_id=user.id,
             timestamp=game_dict.get("createdAt"),

vrobbler/apps/books/api/views.py

@@ -1,19 +1,16 @@
 from rest_framework import permissions, viewsets
 
-from books.api.serializers import (
-    AuthorSerializer,
-    BookSerializer,
-)
-from books.models import Author, Book
+from books.api import serializers
+from books import models
 
 
 class AuthorViewSet(viewsets.ModelViewSet):
-    queryset = Author.objects.all().order_by("-created")
-    serializer_class = AuthorSerializer
+    queryset = models.Author.objects.all().order_by("-created")
+    serializer_class = serializers.AuthorSerializer
     permission_classes = [permissions.IsAuthenticated]
 
 
 class BookViewSet(viewsets.ModelViewSet):
-    queryset = Book.objects.all().order_by("-created")
-    serializer_class = BookSerializer
+    queryset = models.Book.objects.all().order_by("-created")
+    serializer_class = serializers.BookSerializer
     permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/books/koreader.py

@@ -114,7 +114,7 @@ def create_book_from_row(row: list):
                 "raw_row_data": clean_row,
             }
         },
-        run_time_seconds=run_time,
+        base_run_time_seconds=run_time,
     )
     # TODO Move these to async processes after importing
     # book.fix_metadata()
@@ -286,11 +286,11 @@ def build_scrobbles_from_book_map(
                 )
 
                 # Adjust for Daylight Saving Time
-                if timestamp.dst() == timedelta(
-                    0
-                ) or stop_timestamp.dst() == timedelta(0):
-                    timestamp = timestamp - timedelta(hours=1)
-                    stop_timestamp = stop_timestamp - timedelta(hours=1)
+                #if timestamp.dst() == timedelta(
+                #    0
+                #) or stop_timestamp.dst() == timedelta(0):
+                #    timestamp = timestamp - timedelta(hours=1)
+                #    stop_timestamp = stop_timestamp - timedelta(hours=1)
 
                 scrobble = Scrobble.objects.filter(
                     timestamp=timestamp,

vrobbler/apps/books/migrations/0032_remove_book_run_time_seconds_and_more.py

@@ -0,0 +1,39 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('books', '0031_book_next_readcomics_url'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='book',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='book',
+            name='run_time_ticks',
+        ),
+        migrations.RemoveField(
+            model_name='paper',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='paper',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='book',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='paper',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/books/models.py

@@ -153,8 +153,8 @@ class Book(LongPlayScrobblableMixin):
     comicvine_id = models.CharField(max_length=255, **BNULL)
     readcomics_url = models.CharField(max_length=255, **BNULL)
     next_readcomics_url = models.CharField(max_length=255, **BNULL)
-    issue_number = models.IntegerField(max_length=5, **BNULL)
-    volume_number = models.IntegerField(max_length=5, **BNULL)
+    issue_number = models.IntegerField(**BNULL)
+    volume_number = models.IntegerField(**BNULL)
     # OpenLibrary
     openlibrary_id = models.CharField(max_length=255, **BNULL)
     cover = models.ImageField(upload_to="books/covers/", **BNULL)
@@ -402,7 +402,7 @@ class Book(LongPlayScrobblableMixin):
                     self.cover.save(fname, ContentFile(r.content), save=True)
 
             if self.pages:
-                self.run_time_seconds = int(self.pages) * int(
+                self.base_run_time_seconds = int(self.pages) * int(
                     self.AVG_PAGE_READING_SECONDS
                 )
 

vrobbler/apps/books/sources/google.py

@@ -67,9 +67,9 @@ def lookup_book_from_google(title: str) -> dict:
         .replace("&edge=curl", "")
     )
 
-    book_dict["run_time_seconds"] = 3600
+    book_dict["base_run_time_seconds"] = 3600
     if book_dict.get("pages"):
-        book_dict["run_time_seconds"] = book_dict.get("pages", 10) * getattr(
+        book_dict["base_run_time_seconds"] = book_dict.get("pages", 10) * getattr(
             settings, "AVERAGE_PAGE_READING_SECONDS", 60
         )
 

vrobbler/apps/books/sources/semantic.py

@@ -67,7 +67,7 @@ def lookup_paper_from_semantic(title: str) -> dict:
     paper_dict["openaccess_pdf_url"] = result.get("openAccessPdf", {}).get(
         "url"
     )
-    paper_dict["run_time_seconds"] = paper_dict.get("pages", 10) * getattr(
+    paper_dict["base_run_time_seconds"] = paper_dict.get("pages", 10) * getattr(
         settings, "AVERAGE_PAGE_READING_SECONDS", 60
     )
     paper_dict["author_dicts"] = result.get("authors")

vrobbler/apps/bricksets/api/serializers.py

@@ -0,0 +1,8 @@
+from rest_framework import serializers
+from bricksets.models import BrickSet
+
+
+class BrickSetSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = BrickSet
+        fields = "__all__"

vrobbler/apps/bricksets/api/views.py

@@ -0,0 +1,9 @@
+from rest_framework import permissions, viewsets
+from bricksets.api.serializers import BrickSetSerializer
+from bricksets.models import BrickSet
+
+
+class BrickSetViewSet(viewsets.ModelViewSet):
+    queryset = BrickSet.objects.all().order_by("-created")
+    serializer_class = BrickSetSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/bricksets/migrations/0003_remove_brickset_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bricksets', '0002_alter_brickset_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='brickset',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='brickset',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='brickset',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/foods/api/serializers.py

@@ -0,0 +1,14 @@
+from rest_framework import serializers
+from foods import models
+
+
+class FoodCategorySerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.FoodCategory
+        fields = "__all__"
+
+
+class FoodSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.Food
+        fields = "__all__"

vrobbler/apps/foods/api/views.py

@@ -0,0 +1,21 @@
+from rest_framework import permissions, viewsets
+from foods.api.serializers import (
+    FoodSerializer,
+    FoodCategorySerializer,
+)
+from foods.models import (
+    FoodCategory,
+    Food,
+)
+
+
+class FoodCategoryViewSet(viewsets.ModelViewSet):
+    queryset = FoodCategory.objects.all().order_by("-created")
+    serializer_class = FoodCategorySerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class FoodViewSet(viewsets.ModelViewSet):
+    queryset = Food.objects.all().order_by("-created")
+    serializer_class = FoodSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/foods/migrations/0004_remove_food_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('foods', '0003_food_calories'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='food',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='food',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='food',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/foods/models.py

@@ -18,7 +18,6 @@ BNULL = {"blank": True, "null": True}
 class FoodLogData(BaseLogData, WithPeopleLogData):
     calories: Optional[int] = None
     meal: Optional[str] = None
-    rating: Optional[str] = None
 
 
 class FoodCategory(TimeStampedModel):

vrobbler/apps/lifeevents/api/serializers.py

@@ -0,0 +1,8 @@
+from lifeevents.models import LifeEvent
+from rest_framework import serializers
+
+
+class LifeEventSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = LifeEvent
+        fields = "__all__"

vrobbler/apps/lifeevents/api/views.py

@@ -0,0 +1,10 @@
+from rest_framework import permissions, viewsets
+
+from lifeevents.api import serializers
+from lifeevents import models
+
+
+class LifeEventViewSet(viewsets.ModelViewSet):
+    queryset = models.LifeEvent.objects.all().order_by("-created")
+    serializer_class = serializers.LifeEventSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/lifeevents/migrations/0003_remove_lifeevent_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('lifeevents', '0002_alter_lifeevent_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='lifeevent',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='lifeevent',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='lifeevent',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/locations/api/serializers.py

@@ -0,0 +1,8 @@
+from locations import models
+from rest_framework import serializers
+
+
+class GeoLocationSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.GeoLocation
+        fields = "__all__"

vrobbler/apps/locations/api/views.py

@@ -0,0 +1,9 @@
+from rest_framework import permissions, viewsets
+
+from locations.api import serializers
+from locations import models
+
+class GeoLocationViewSet(viewsets.ModelViewSet):
+    queryset = models.GeoLocation.objects.all().order_by("-created")
+    serializer_class = serializers.GeoLocationSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/locations/migrations/0008_remove_geolocation_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('locations', '0007_alter_geolocation_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='geolocation',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='geolocation',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='geolocation',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/moods/api/serializers.py

@@ -0,0 +1,8 @@
+from rest_framework import serializers
+from moods.models import Mood
+
+
+class MoodSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Mood
+        fields = "__all__"

vrobbler/apps/moods/api/views.py

@@ -0,0 +1,9 @@
+from rest_framework import permissions, viewsets
+from moods.api.serializers import MoodSerializer
+from moods.models import Mood
+
+
+class MoodViewSet(viewsets.ModelViewSet):
+    queryset = Mood.objects.all().order_by("-created")
+    serializer_class = MoodSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/moods/migrations/0004_remove_mood_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('moods', '0003_alter_mood_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='mood',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='mood',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='mood',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/music/migrations/0029_remove_track_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0028_alter_track_albums'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='track',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='track',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='track',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/music/models.py

@@ -677,7 +677,7 @@ class Track(ScrobblableMixin):
 
         lookup_keys = {"title": title, "artist": artist}
         if run_time_seconds:
-            lookup_keys["run_time_seconds"] = run_time_seconds
+            lookup_keys["base_run_time_seconds"] = run_time_seconds
         logger.info(f"Looking up track using: {lookup_keys}")
         track = cls.objects.filter(**lookup_keys).first()
         if track:
@@ -699,7 +699,7 @@ class Track(ScrobblableMixin):
         if album:
             track.albums.add(album)
 
-        if enrich or not track.run_time_seconds:
+        if enrich or not track.base_run_time_seconds:
             logger.info(
                 f"Enriching track {track}",
                 extra={
@@ -715,7 +715,7 @@ class Track(ScrobblableMixin):
             except Exception:
                 print("No musicbrainz result found, cannot enrich")
                 return track
-            track.run_time_seconds = run_time_seconds or int(length / 1000)
+            track.base_run_time_seconds = run_time_seconds or int(length / 1000)
             track.musicbrainz_id = mbid
             if commit:
                 track.save()

vrobbler/apps/podcasts/api/serializers.py

@@ -0,0 +1,17 @@
+from podcasts import models
+from rest_framework import serializers
+
+class ProducerSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.Producer
+        fields = "__all__"
+
+class PodcastEpisodeSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.PodcastEpisode
+        fields = "__all__"
+
+class PodcastSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.Podcast
+        fields = "__all__"

vrobbler/apps/podcasts/api/views.py

@@ -0,0 +1,20 @@
+from rest_framework import permissions, viewsets
+
+from podcasts.api import serializers
+from podcasts import models
+
+
+class ProducerViewSet(viewsets.ModelViewSet):
+    queryset = models.Producer.objects.all().order_by("-created")
+    serializer_class = serializers.ProducerSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+class PodcastViewSet(viewsets.ModelViewSet):
+    queryset = models.Podcast.objects.all().order_by("-created")
+    serializer_class = serializers.PodcastSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+class PodcastEpisodeViewSet(viewsets.ModelViewSet):
+    queryset = models.PodcastEpisode.objects.all().order_by("-created")
+    serializer_class = serializers.PodcastEpisodeSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/podcasts/migrations/0018_remove_podcastepisode_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0017_podcast_podcastindex_id'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='podcastepisode',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='podcastepisode',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='podcastepisode',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/podcasts/models.py

@@ -145,7 +145,7 @@ class PodcastEpisode(ScrobblableMixin):
         title: str,
         pub_date: str,
         episode_num: int = 0,
-        run_time_seconds: int = 1800,
+        base_run_time_seconds: int = 2400,
         mopidy_uri: str = "",
         podcast_name: str = "",
         podcast_producer: str = "",
@@ -174,7 +174,7 @@ class PodcastEpisode(ScrobblableMixin):
             title=title,
             podcast=podcast,
             defaults={
-                "run_time_seconds": run_time_seconds,
+                "base_run_time_seconds": base_run_time_seconds,
                 "number": episode_num,
                 "pub_date": pub_date,
                 "mopidy_uri": mopidy_uri,

vrobbler/apps/podcasts/utils.py

@@ -62,7 +62,7 @@ def fetch_metadata_from_rss(uri: str) -> dict[str, Any]:
             podcast_data["title"] = entry.title
             podcast_data["episode_num"] = int(entry.get("itunes_episode", 0))
             podcast_data["pub_date"] = parse(entry.get("published", None))
-            podcast_data["run_time_seconds"] = parse_duration(entry.get("itunes_duration", None))
+            podcast_data["base_run_time_seconds"] = parse_duration(entry.get("itunes_duration", None))
             # podcast_data["description"] = entry.get("description", None)
             # podcast_data["episode_url"] = entry.enclosures[0].href if entry.get("enclosures") else None
             return podcast_data

vrobbler/apps/puzzles/api/serializers.py

@@ -0,0 +1,12 @@
+from puzzles import models
+from rest_framework import serializers
+
+class PuzzleManufacturerSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.PuzzleManufacturer
+        fields = "__all__"
+
+class PuzzleSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.Puzzle
+        fields = "__all__"

vrobbler/apps/puzzles/api/views.py

@@ -0,0 +1,15 @@
+from rest_framework import permissions, viewsets
+
+from puzzles.api import serializers
+from puzzles import models
+
+class PuzzleManufacturerViewSet(viewsets.ModelViewSet):
+    queryset = models.PuzzleManufacturer.objects.all().order_by("-created")
+    serializer_class = serializers.PuzzleManufacturerSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class PuzzleViewSet(viewsets.ModelViewSet):
+    queryset = models.Puzzle.objects.all().order_by("-created")
+    serializer_class = serializers.PuzzleSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/puzzles/migrations/0004_remove_puzzle_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('puzzles', '0003_rename_igdb_id_puzzle_ipdb_id_and_more'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='puzzle',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='puzzle',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='puzzle',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/puzzles/models.py

@@ -11,17 +11,15 @@ from django_extensions.db.models import TimeStampedModel
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
 from puzzles.sources import ipdb
-from scrobbles.dataclasses import JSONDataclass
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData, LongPlayLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 
 BNULL = {"blank": True, "null": True}
 
 
 @dataclass
-class PuzzleLogData(JSONDataclass):
-    with_people: Optional[int] = None
+class PuzzleLogData(BaseLogData, WithPeopleLogData, LongPlayLogData):
     rating: Optional[str] = None
-    notes: Optional[str] = None
 
 
 class PuzzleManufacturer(TimeStampedModel):

vrobbler/apps/scrobbles/constants.py

@@ -20,6 +20,7 @@ PLAY_AGAIN_MEDIA = {
     "beers": "Beer",
     "foods": "Food",
     "locations": "GeoLocation",
+    "videos": "Video",
 }
 
 MEDIA_END_PADDING_SECONDS = {

vrobbler/apps/scrobbles/dataclasses.py

@@ -13,7 +13,10 @@ User = get_user_model()
 
 class ScrobbleLogDataEncoder(json.JSONEncoder):
     def default(self, o):
-        return o.__dict__
+        try:
+            return o.__dict__
+        except AttributeError:
+            return {}
 
 
 class ScrobbleLogDataDecoder(json.JSONDecoder):

vrobbler/apps/scrobbles/forms.py

@@ -77,11 +77,8 @@ def form_from_dataclass(dataclass):
     override_fields = {}
     for klass in dataclass.mro():
         if hasattr(klass, "override_fields"):
-            print(klass, ": ", klass.override_fields())
             override_fields.update(klass.override_fields())
-    print("overrides: ", override_fields)
     for f in fields(dataclass):
-        print(f)
         if f.name in override_fields:
             form_fields[f.name] = override_fields[f.name]
             continue

vrobbler/apps/scrobbles/mixins.py

@@ -57,14 +57,20 @@ class ScrobblableMixin(TimeStampedModel):
 
     uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
     title = models.CharField(max_length=255, **BNULL)
-    run_time_seconds = models.IntegerField(default=900)
-    run_time_ticks = models.PositiveBigIntegerField(**BNULL)
+    base_run_time_seconds = models.IntegerField(**BNULL)
 
     genre = TaggableManager(through=ObjectWithGenres, blank=True)
 
     class Meta:
         abstract = True
 
+    @property
+    def run_time_seconds(self) -> int:
+        run_time = 900
+        if self.base_run_time_seconds:
+            run_time = self.base_run_time_seconds
+        return run_time
+
     @classmethod
     def is_long_play_media(cls) -> bool:
         return False
@@ -93,7 +99,7 @@ class ScrobblableMixin(TimeStampedModel):
             "[scrobble_for_user] called",
             extra={
                 "id": self.id,
-                "media_type": self.__class__,
+                "media_type": self.__class__.__name__,
                 "user_id": user_id,
                 "scrobble_data": scrobble_data,
             },

vrobbler/apps/scrobbles/models.py

@@ -22,7 +22,7 @@ from django.db import models
 from django.urls import reverse
 from django.utils import timezone
 from django_extensions.db.models import TimeStampedModel
-from foods.models import Food
+from foods.models import Food, FoodLogData
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
 from lifeevents.models import LifeEvent
@@ -822,7 +822,7 @@ class Scrobble(TimeStampedModel):
         """
         is_stale = False
         now = timezone.now()
-        seconds_since_last_update = (now - self.modified).seconds
+        seconds_since_last_update = (now - self.modified).total_seconds()
         if seconds_since_last_update >= self.media_obj.SECONDS_TO_STALE:
             is_stale = True
         return is_stale
@@ -1210,6 +1210,9 @@ class Scrobble(TimeStampedModel):
                 "source": source,
             },
         )
+        if mtype == cls.MediaType.FOOD and not scrobble_data.get("log", {}).get("calories", None):
+            if media.calories:
+                scrobble_data["log"] = FoodLogData(calories=media.calories)
 
         scrobble = cls.create(scrobble_data)
         return scrobble

vrobbler/apps/scrobbles/scrobblers.py

@@ -123,9 +123,8 @@ def jellyfin_scrobble_media(
         / 10000000
     )
     if media_type == Scrobble.MediaType.VIDEO:
-        media_obj = Video.get_from_imdb_id(
-            post_data.get("Provider_imdb", "").replace("tt", "")
-        )
+        imdb_id = post_data.get("Provider_imdb", "")
+        media_obj = Video.find_or_create(imdb_id)
     else:
         media_obj = Track.find_or_create(
             title=post_data.get("Name", ""),
@@ -162,21 +161,16 @@ def jellyfin_scrobble_media(
 def web_scrobbler_scrobble_media(
     youtube_id: str, user_id: int, status: str = "started"
 ) -> Optional[Scrobble]:
-    video = Video.get_from_youtube_id(youtube_id)
+    video = Video.find_or_create(youtube_id)
     return video.scrobble_for_user(user_id, status, source="Web Scrobbler")
 
 
 def manual_scrobble_video(
-    video_id: str, user_id: int, action: Optional[str] = None
+        video_id: str, user_id: int, source: str = "IMDb", action: Optional[str] = None
 ):
-    if "tt" in video_id:
-        video = Video.get_from_imdb_id(video_id)
-
-    else:
-        video = Video.get_from_youtube_id(video_id)
+    video = Video.find_or_create(video_id)
 
     # When manually scrobbling, try finding a source from the series
-    source = "Vrobbler"
     if video.tv_series:
         source = video.tv_series.preferred_source
     scrobble_dict = {
@@ -205,7 +199,7 @@ def manual_scrobble_video(
 
 
 def manual_scrobble_event(
-    thesportsdb_id: str, user_id: int, action: Optional[str] = None
+    thesportsdb_id: str, user_id: int, source: str = "TheSportsDB", action: Optional[str] = None
 ):
     data_dict = lookup_event_from_thesportsdb(thesportsdb_id)
 
@@ -220,7 +214,7 @@ def manual_scrobble_event(
 
 
 def manual_scrobble_video_game(
-    hltb_id: str, user_id: int, action: Optional[str] = None
+    hltb_id: str, user_id: int, source: str = "HLTB", action: Optional[str] = None
 ):
     game = VideoGame.objects.filter(hltb_id=hltb_id).first()
     if not game:
@@ -242,7 +236,7 @@ def manual_scrobble_video_game(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
         "long_play_complete": False,
     }
 
@@ -260,10 +254,9 @@ def manual_scrobble_video_game(
 
 
 def manual_scrobble_book(
-    title: str, user_id: int, action: Optional[str] = None
+    title: str, user_id: int, source: str = "Google Books", action: Optional[str] = None
 ):
     log = {}
-    source = "Vrobbler"
     page = None
     url = ""
 
@@ -317,7 +310,10 @@ def manual_scrobble_book(
 
     if action == "stop":
         if url:
-            scrobble.log["resume_url"] = next_url_if_exists(url)
+            if isinstance(scrobble.log, "BookLogData"):
+                scrobble.log.resume_url = next_url_if_exists(url)
+            else:
+                scrobble.log["resume_url"] = next_url_if_exists(url)
             scrobble.save(update_fields=["log"])
         scrobble.stop(force_finish=True)
 
@@ -325,7 +321,7 @@ def manual_scrobble_book(
 
 
 def manual_scrobble_board_game(
-    bggeek_id: str, user_id: int, action: Optional[str] = None
+    bggeek_id: str, user_id: int, source: str = "BGG", action: Optional[str] = None
 ) -> Scrobble | None:
     boardgame = BoardGame.find_or_create(bggeek_id)
 
@@ -337,7 +333,7 @@ def manual_scrobble_board_game(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
     }
     logger.info(
         "[vrobbler-scrobble] board game scrobble request received",
@@ -352,29 +348,6 @@ def manual_scrobble_board_game(
     return Scrobble.create_or_update(boardgame, user_id, scrobble_dict)
 
 
-def find_and_enrich_board_game_data(game_dict: dict) -> BoardGame | None:
-    """TODO Move this to a utility somewhere"""
-    game = BoardGame.find_or_create(game_dict.get("bggId"))
-
-    if game:
-        game.cooperative = game_dict.get("cooperative", False)
-        game.highest_wins = game_dict.get("highestWins", True)
-        game.no_points = game_dict.get("noPoints", False)
-        game.uses_teams = game_dict.get("useTeams", False)
-        game.bgstats_id = game_dict.get("uuid", None)
-        if not game.rating:
-            game.rating = game_dict.get("rating") / 10
-        game.save()
-
-        if game_dict.get("designers"):
-            for designer_name in game_dict.get("designers", "").split(", "):
-                designer, created = BoardGameDesigner.objects.get_or_create(
-                    name=designer_name
-                )
-                game.designers.add(designer.id)
-    return game
-
-
 def email_scrobble_board_game(
     bgstat_data: dict[str, Any], user_id: int
 ) -> list[Scrobble]:
@@ -404,11 +377,11 @@ def email_scrobble_board_game(
     log_data = {}
     for game in game_list:
         logger.info(f"Finding and enriching {game.get('name')}")
-        enriched_game = find_and_enrich_board_game_data(game)
+        game_obj = BoardGame.find_or_create(game.get("bggId"), data=game)
         if game.get("isBaseGame"):
-            base_games[game.get("id")] = enriched_game
+            base_games[game.get("id")] = game_obj
         if game.get("isExpansion"):
-            expansions[game.get("id")] = enriched_game
+            expansions[game.get("id")] = game_obj
 
     locations = {}
     for location_dict in bgstat_data.get("locations", []):
@@ -550,7 +523,7 @@ def email_scrobble_board_game(
 
 
 def manual_scrobble_from_url(
-    url: str, user_id: int, action: Optional[str] = None
+        url: str, user_id: int, source: str = "Vrobbler", action: Optional[str] = None
 ) -> Scrobble:
     """We have scrobblable media URLs, and then any other webpages that
     we want to scrobble as a media type in and of itself. This checks whether
@@ -584,7 +557,7 @@ def manual_scrobble_from_url(
         item_id = "tt" + str(item_id)
 
     scrobble_fn = MANUAL_SCROBBLE_FNS[content_key]
-    return eval(scrobble_fn)(item_id, user_id, action=action)
+    return eval(scrobble_fn)(item_id, user_id, source=source, action=action)
 
 
 def todoist_scrobble_task_finish(
@@ -793,7 +766,6 @@ def emacs_scrobble_task(
         user_id=user_id,
         in_progress=True,
         log__orgmode_id=orgmode_id,
-        log__source="orgmode",
         task=task,
     ).last()
 
@@ -864,9 +836,10 @@ def emacs_scrobble_task(
     return scrobble
 
 
-def manual_scrobble_task(url: str, user_id: int, action: Optional[str] = None):
+def manual_scrobble_task(url: str, user_id: int, source: str = "Vrobbler", action: Optional[str] = None):
     source_id = re.findall(r"\d+", url)[0]
 
+    description = ""
     if "todoist" in url:
         source = "Todoist"
         title = "Generic Todoist task"
@@ -895,7 +868,7 @@ def manual_scrobble_task(url: str, user_id: int, action: Optional[str] = None):
 
 
 def manual_scrobble_webpage(
-    url: str, user_id: int, action: Optional[str] = None
+        url: str, user_id: int, source: str = "Bookmarklet", action: Optional[str] = None
 ):
     webpage = WebPage.find_or_create({"url": url})
 
@@ -903,7 +876,7 @@ def manual_scrobble_webpage(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
     }
     logger.info(
         "[vrobbler-scrobble] webpage scrobble request received",
@@ -1022,7 +995,7 @@ def web_scrobbler_scrobble_video_or_song(
 
 
 def manual_scrobble_beer(
-    untappd_id: str, user_id: int, action: Optional[str] = None
+        untappd_id: str, user_id: int, source: str = "Untappd", action: Optional[str] = None
 ):
     beer = Beer.find_or_create(untappd_id)
 
@@ -1034,7 +1007,7 @@ def manual_scrobble_beer(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
     }
     logger.info(
         "[vrobbler-scrobble] beer scrobble request received",
@@ -1051,7 +1024,7 @@ def manual_scrobble_beer(
 
 
 def manual_scrobble_puzzle(
-    ipdb_id: str, user_id: int, action: Optional[str] = None
+        ipdb_id: str, user_id: int, source: str = "IPDb", action: Optional[str] = None
 ):
     puzzle = Puzzle.find_or_create(ipdb_id)
 
@@ -1063,7 +1036,7 @@ def manual_scrobble_puzzle(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
     }
     logger.info(
         "[vrobbler-scrobble] puzzle scrobble request received",
@@ -1080,7 +1053,7 @@ def manual_scrobble_puzzle(
 
 
 def manual_scrobble_brickset(
-    brickset_id: str, user_id: int, action: Optional[str] = None
+        brickset_id: str, user_id: int, source: str = "BrickSet", action: Optional[str] = None
 ):
     brickset = BrickSet.find_or_create(brickset_id)
 
@@ -1092,7 +1065,7 @@ def manual_scrobble_brickset(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
         "log": {"serial_scrobble_id": ""},
     }
     logger.info(

vrobbler/apps/scrobbles/utils.py

@@ -394,10 +394,14 @@ def get_daily_calories_for_user_by_day(user_id: int, date: date| str) -> int:
     if isinstance(date, str):
         date = pendulum.parse(date)
 
-    qs = base_scrobble_qs(user_id).filter(day=date)
-    agg = qs.aggregate(total_calories=models.Sum("calories_int"))
+    try:
+        qs = base_scrobble_qs(user_id).filter(day=date)
+        agg = qs.aggregate(total_calories=models.Sum("calories_int"))
+    except AttributeError as e:
+        logger.warning(f"Can't generate calorie total: {e}")
+        agg = {}
 
-    return agg["total_calories"] or 0
+    return agg.get("total_calories") or 0
 
 def get_daily_calorie_dict_for_user(user_id: int) -> dict[date, int]:
     """Return {day: total_calories} for all days with scrobbles, in one query."""

vrobbler/apps/scrobbles/views.py

@@ -127,8 +127,9 @@ class RecentScrobbleList(ListView):
         if user.is_authenticated:
             if scrobble_url := self.request.GET.get("scrobble_url", ""):
                 action = self.request.GET.get("action", "")
+                source = self.request.GET.get("source", "Bookmarklet")
                 scrobble = manual_scrobble_from_url(
-                    scrobble_url, self.request.user.id, action
+                    scrobble_url, self.request.user.id, source, action
                 )
                 return HttpResponseRedirect(scrobble.redirect_url(user.id))
         return super().get(*args, **kwargs)
@@ -604,8 +605,7 @@ def scrobble_start(request, uuid):
             "[scrobble_start] media object not found",
             extra={"uuid": uuid, "user_id": user.id},
         )
-        # TODO Log that we couldn't find a media obj to scrobble
-        return
+        raise Exception("No media object provided to scrobble")
 
     scrobble = None
     user_id = request.user.id
@@ -949,12 +949,15 @@ class ScrobbleDetailView(DetailView):
 
         log = self.object.log or {}
         initial_notes = log.get("notes", [])
-        if isinstance(initial_notes, list):
-            notes_str = "\n".join(initial_notes)
-            notes_str_fixed = notes_str.encode("utf-8").decode(
-                "unicode_escape"
-            )
-            log["notes"] = notes_str_fixed
+        if isinstance(initial_notes, list) and len(initial_notes) > 0 and isinstance(initial_notes[0], dict):
+            notes_str = note_list_to_str(notes)
+        else:
+            notes_str = "\n".join(initial_notes) if initial_notes else ""
+
+        notes_str_fixed = notes_str.encode("utf-8").decode(
+            "unicode_escape"
+        )
+        log["notes"] = notes_str_fixed
 
         return FormClass(initial=log)
 

vrobbler/apps/sports/migrations/0016_remove_sportevent_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sports', '0015_alter_sportevent_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='sportevent',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='sportevent',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='sportevent',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/sports/models.py

@@ -244,7 +244,7 @@ class SportEvent(ScrobblableMixin):
             "player_two": player_two,
             "start": data_dict.get("Start"),
             "round": round,
-            "run_time_seconds": data_dict.get("RunTime"),
+            "base_run_time_seconds": data_dict.get("RunTime"),
         }
         event, _created = cls.objects.get_or_create(**event_dict)
 

vrobbler/apps/tasks/api/serializers.py

@@ -0,0 +1,8 @@
+from tasks import models
+from rest_framework import serializers
+
+
+class TaskSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.Task
+        fields = "__all__"

vrobbler/apps/tasks/api/views.py

@@ -0,0 +1,10 @@
+from rest_framework import permissions, viewsets
+
+from tasks.api import serializers
+from tasks import models
+
+
+class TaskViewSet(viewsets.ModelViewSet):
+    queryset = models.Task.objects.all().order_by("-created")
+    serializer_class = serializers.TaskSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/tasks/migrations/0005_remove_task_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tasks', '0004_alter_task_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='task',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='task',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='task',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/tasks/models.py

@@ -39,15 +39,22 @@ class TaskLogData(BaseLogData):
 
     def notes_as_str(self) -> str:
         """Return formatted notes with line breaks and no keys"""
-        note_block = ""
-        if isinstance(self.notes, list):
-            note_block = "</br>".join(self.notes)
+        labels_str = ""
+        if self.labels:
+            labels_str = ", ".join(self.labels)
 
-        # DEPRECATED ... we don't store notes in dicts anymore
-        if isinstance(self.notes, dict):
-            for id, content in self.notes.items():
-                note_block += content + "</br>"
-        return note_block
+        lines = []
+        if self.notes:
+            for note in self.notes:
+                if isinstance(note, dict):
+                    timestamp, note_text = next(iter(note.items()))
+                    # Flatten newlines and clean whitespace
+                    note_text = " ".join(note_text.strip().split())
+                    lines.append(f"{timestamp}: {note_text} [{labels_str}]")
+                if isinstance(note, str):
+                    lines.append(note)
+
+        return "\n".join(lines)
 
 
 class Task(LongPlayScrobblableMixin):
@@ -82,14 +89,14 @@ class Task(LongPlayScrobblableMixin):
 
     def subtitle_for_user(self, user_id):
         scrobble = self.scrobbles(user_id).first()
-        return scrobble.logdata.title or ""
+        return scrobble.logdata.title or scrobble.log.get("title")
 
     @classmethod
     def find_or_create(cls, title: str) -> "Task":
         task, created = cls.objects.get_or_create(title=title)
         if created:
-            task.run_time_seconds = 1800
-            task.save(update_fields=["run_time_seconds"])
+            task.base_run_time_seconds = 1800
+            task.save(update_fields=["base_run_time_seconds"])
 
         return task
 

vrobbler/apps/trails/api/serializers.py

@@ -0,0 +1,8 @@
+from trails import models
+from rest_framework import serializers
+
+
+class TrailSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.Trail
+        fields = "__all__"

vrobbler/apps/trails/api/views.py

@@ -0,0 +1,11 @@
+
+from rest_framework import permissions, viewsets
+
+from trails.api import serializers
+from trails import models
+
+
+class TrailViewSet(viewsets.ModelViewSet):
+    queryset = models.Trail.objects.all().order_by("-created")
+    serializer_class = serializers.TrailSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/trails/migrations/0006_remove_trail_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('trails', '0005_trail_alltrails_id_trail_gaiagps_id'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='trail',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='trail',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='trail',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/videogames/migrations/0013_remove_videogame_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('videogames', '0012_alter_videogame_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='videogame',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='videogame',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='videogame',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/videogames/models.py

@@ -205,7 +205,7 @@ class VideoGame(LongPlayScrobblableMixin):
 
     @property
     def seconds_for_completion(self) -> int:
-        completion_time = self.run_time_ticks
+        completion_time = self.run_time_seconds
         if not completion_time:
             # Default to 10 hours, why not
             completion_time = 10 * 60 * 60
@@ -237,9 +237,9 @@ class VideoGame(LongPlayScrobblableMixin):
         if self.igdb_id:
             load_game_data_from_igdb(self.id, self.igdb_id)
 
-        if (not self.run_time_ticks or force_update) and self.main_story_time:
-            self.run_time_seconds = self.main_story_time
-            self.save(update_fields=["run_time_seconds"])
+        if force_update and self.main_story_time:
+            self.base_run_time_seconds = self.main_story_time
+            self.save(update_fields=["base_run_time_seconds"])
 
     @classmethod
     def find_or_create(cls, data_dict: dict) -> "Game":

vrobbler/apps/videos/metadata.py

@@ -21,7 +21,7 @@ class VideoType(Enum):
 class VideoMetadata:
     title: str
     video_type: VideoType = VideoType.UNKNOWN
-    run_time_seconds: int = (
+    base_run_time_seconds: int = (
         60  # Silly default, but things break if this is 0 or null
     )
     imdb_id: Optional[str]
@@ -51,16 +51,19 @@ class VideoMetadata:
         self,
         imdb_id: Optional[str] = "",
         youtube_id: Optional[str] = "",
-        run_time_seconds: int = 900,
+        base_run_time_seconds: int = 900,
     ):
         self.imdb_id = imdb_id
         self.youtube_id = youtube_id
-        self.run_time_seconds = run_time_seconds
+        self.base_run_time_seconds = base_run_time_seconds
 
     def as_dict_with_cover_and_genres(self) -> tuple:
         video_dict = vars(self)
+        series_id = ""
         cover = None
         if "cover_url" in video_dict.keys():
             cover = video_dict.pop("cover_url", "")
         genres = video_dict.pop("genres", [])
-        return video_dict, cover, genres
+        if "tv_series_imdb_id" in video_dict.keys():
+            series_id = video_dict.pop("tv_series_imdb_id")
+        return video_dict, series_id, cover, genres

vrobbler/apps/videos/migrations/0024_remove_video_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('videos', '0023_video_tmdb_rating'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='video',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='video',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='video',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/videos/models.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+import re
 import logging
 from typing import Optional
 from uuid import uuid4
@@ -27,7 +28,9 @@ from vrobbler.apps.scrobbles.dataclasses import BaseLogData, WithPeopleLogData
 
 YOUTUBE_VIDEO_URL = "https://www.youtube.com/watch?v="
 YOUTUBE_CHANNEL_URL = "https://www.youtube.com/channel/"
-IMDB_VIDEO_URL = "https://www.imdb.com/title/tt"
+YOUTUBE_ID_PATTERN = re.compile(r'^[A-Za-z0-9_-]{11}$')
+
+IMDB_VIDEO_URL = "https://www.imdb.com/title/"
 
 logger = logging.getLogger(__name__)
 BNULL = {"blank": True, "null": True}
@@ -136,6 +139,13 @@ class Series(TimeStampedModel):
             url = self.cover_image_medium.url
         return url
 
+    def save_image_from_url(self, url: str, force_update: bool = False):
+        if not self.cover_image or (force_update and url):
+            r = requests.get(url)
+            if r.status_code == 200:
+                fname = f"{self.name}_{self.uuid}.jpg"
+                self.cover_image.save(fname, ContentFile(r.content), save=True)
+
     def scrobbles_for_user(self, user_id: int, include_playing=False):
         from scrobbles.models import Scrobble
 
@@ -184,6 +194,32 @@ class Series(TimeStampedModel):
         if genres := imdb_dict.get("genres"):
             self.genre.add(*genres)
 
+    @classmethod
+    def find_or_create(cls, imdb_id: str, overwrite: bool = True):
+        series, created = cls.objects.get_or_create(imdb_id=imdb_id)
+
+        if not created and not overwrite:
+            logger.info("Series not created and overwrite=False, returning")
+            return series
+
+        vdict, _, cover, genres = lookup_video_from_imdb(
+            imdb_id
+        ).as_dict_with_cover_and_genres()
+        vdict.pop("video_type")
+
+        vdict["name"] = vdict.pop("title")
+        for k, v in vdict.items():
+            setattr(series, k, v)
+        series.save()
+
+        if cover:
+            series.save_image_from_url(cover)
+        if genres:
+            series.genre.add(*genres)
+
+        return series
+
+
 
 class Video(ScrobblableMixin):
     COMPLETION_PERCENT = getattr(settings, "VIDEO_COMPLETION_PERCENT", 90)
@@ -304,7 +340,7 @@ class Video(ScrobblableMixin):
         if not created and not overwrite:
             return video
 
-        vdict, cover, genres = lookup_video_from_youtube(
+        vdict, _, cover, genres = lookup_video_from_youtube(
             youtube_id
         ).as_dict_with_cover_and_genres()
         if created or overwrite:
@@ -320,28 +356,38 @@ class Video(ScrobblableMixin):
     def get_from_imdb_id(
         cls, imdb_id: str, overwrite: bool = False
     ) -> "Video":
-        if "tt" in imdb_id:
-            imdb_id = imdb_id[2:]
         video, created = cls.objects.get_or_create(imdb_id=imdb_id)
         if not created and not overwrite:
             return video
 
-        vdict, cover, genres = lookup_video_from_tmdb(
+        vdict, series_id, cover, genres = lookup_video_from_imdb(
             imdb_id
         ).as_dict_with_cover_and_genres()
+
         if created or overwrite:
             for k, v in vdict.items():
                 setattr(video, k, v)
+
+            if series_id:
+                video.tv_series = Series.find_or_create(imdb_id=series_id)
+
             video.save()
 
-            video.save_image_from_url(cover)
-            video.genre.add(*genres)
+            if cover:
+                video.save_image_from_url(cover)
+            if genres:
+                video.genre.add(*genres)
+
         return video
 
     @classmethod
-    def find_or_create(
-        cls, data_dict: dict, post_keys: dict = JELLYFIN_POST_KEYS
-    ) -> Optional["Video"]:
-        """Thes smallest of wrappers around our actual get or create utility."""
-        imdb_key = post_keys.get("IMDB_ID", "").replace("tt", "")
-        return cls.get_from_imdb_id(data_dict.get(imdb_key))
+    def find_or_create(cls, source_id: str, overwrite: bool = True) -> "Video":
+        if "tt" in source_id:
+            return cls.get_from_imdb_id(source_id, overwrite)
+        if bool(YOUTUBE_ID_PATTERN.match(source_id)):
+            return cls.get_from_youtube_id(source_id, overwrite)
+
+        #TODO scrobble but without a video obj?
+        logger.warning("Video ID not recognized, not scrobbling")
+
+        return

vrobbler/apps/videos/sources/imdb.py

@@ -1,60 +1,21 @@
 import logging
 
-from imdb import Cinemagoer, helpers
+from cinemagoerng import web as imdb
 from videos.metadata import VideoMetadata, VideoType
 
-imdb_client = Cinemagoer()
-
 logger = logging.getLogger(__name__)
 
 
-def lookup_video_from_imdb(
-    name_or_id: str, kind: str = "movie"
-) -> VideoMetadata:
-    from videos.models import Series
-
-    # Very few video titles start with tt, but IMDB IDs often come in with it
-    if name_or_id.startswith("tt"):
-        name_or_id = name_or_id[2:]
-
-    imdb_id = None
-
-    try:
-        imdb_id = int(name_or_id)
-    except ValueError:
-        pass
+def lookup_video_from_imdb(imdb_id: str) -> VideoMetadata:
+    if not imdb_id.startswith("tt"):
+        logger.warning("This method requires an IMDB ID starting with 'tt'")
+        return VideoMetadata()
 
     video_metadata = VideoMetadata(imdb_id=imdb_id)
     imdb_result: dict = {}
 
-    imdb_result = imdb_client.get_movie(name_or_id)
-
-    if not imdb_result:
-        imdb_result = {}
-        imdb_results: list = imdb_client.search_movie(name_or_id)
-        if len(imdb_results) > 1:
-            for result in imdb_results:
-                if result["kind"] == kind:
-                    imdb_client.update(
-                        result,
-                        info=[
-                            "plot",
-                            "synopsis",
-                            "taglines",
-                            "next_episode",
-                            "genres",
-                        ],
-                    )
-                    imdb_result = result
-                    break
-
-        if len(imdb_results) == 1:
-            imdb_result = imdb_results[0]
-
-        imdb_client.update(
-            imdb_result,
-            info=["plot", "synopsis", "taglines", "next_episode", "genres"],
-        )
+    imdb_result = imdb.get_title(imdb_id)
+    logger.debug(f"Found result from IMDB: {imdb_result.title}")
 
     if not imdb_result:
         logger.info(
@@ -63,39 +24,27 @@ def lookup_video_from_imdb(
         )
         return None
 
-    video_metadata.cover_url = imdb_result.get("cover url")
-    if video_metadata.cover_url:
-        video_metadata.cover_url = helpers.resizeImage(
-            video_metadata.cover_url, width=800
-        )
+    video_metadata.imdb_id = imdb_id
+    video_metadata.title = imdb_result.title
+    video_metadata.base_run_time_seconds = (
+        imdb_result.runtime * 60
+    )
+    video_metadata.year = imdb_result.year
+    video_metadata.plot = imdb_result.plot.get("en-US", "")
+    video_metadata.imdb_rating = imdb_result.rating
+    video_metadata.genres = imdb_result.genres
+    video_metadata.cover_url = imdb_result.primary_image
 
     video_metadata.video_type = VideoType.MOVIE.value
-    series_name = None
-    if imdb_result.get("kind") == "episode":
-        try:
-            series_name = imdb_result.get("episode of", None).data.get(
-                "title", None
-            )
-        except IndexError:
-            series_name = None
-        if series_name:
-            series, _ = Series.objects.get_or_create(name=series_name)
-            video_metadata.video_type = VideoType.TV_EPISODE.value
-            video_metadata.tv_series_id = series.id
+    if imdb_result.type_id == "tvEpisode":
+        video_metadata.video_type = VideoType.TV_EPISODE.value
 
-    if imdb_result.get("runtimes"):
-        video_metadata.run_time_seconds = (
-            int(imdb_result.get("runtimes")[0]) * 60
-        )
+        series = imdb_result.series
+        video_metadata.tv_series_imdb_id = series.imdb_id
+        video_metadata.tv_series_title = series.title
+        video_metadata.episode_number = imdb_result.episode
+        video_metadata.season_number = imdb_result.season
+        video_metadata.next_imdb_id = imdb_result.next_episode_id
 
-    video_metadata.imdb_id = name_or_id
-    video_metadata.title = imdb_result.get("title", "")
-    video_metadata.episode_number = imdb_result.get("episode", None)
-    video_metadata.season_number = imdb_result.get("season", None)
-    video_metadata.next_imdb_id = imdb_result.get("next episode", None)
-    video_metadata.year = imdb_result.get("year", None)
-    video_metadata.plot = imdb_result.get("plot outline", "")
-    video_metadata.imdb_rating = imdb_result.get("rating", None)
-    video_metadata.genres = imdb_result.get("genres", [])
 
     return video_metadata

vrobbler/apps/videos/sources/skatevideosite.py

@@ -108,7 +108,7 @@ def lookup_video_from_skatevideosite(title: str) -> Optional[dict]:
         .replace("(", "")
         .replace(")", "")
     )
-    run_time_seconds = (
+    base_run_time_seconds = (
         int(
             detail_soup.find("div", class_="p-1")
             .contents[-1]
@@ -123,6 +123,6 @@ def lookup_video_from_skatevideosite(title: str) -> Optional[dict]:
         "title": str(result.find("img").get("alt").replace(" cover", "")),
         "video_type": "S",
         "year": year,
-        "run_time_seconds": run_time_seconds,
+        "base_run_time_seconds": run_time_seconds,
         "cover_url": str(result.find("img").get("src")),
     }

vrobbler/apps/videos/sources/tmdb.py

@@ -72,7 +72,7 @@ def lookup_video_from_tmdb(
         return video_metadata
 
     video_metadata.tmdb_id = media.id
-    video_metadata.run_time_seconds = media.runtime * 60
+    video_metadata.base_run_time_seconds = media.runtime * 60
     video_metadata.plot = media.overview
     video_metadata.overview = media.overview
     video_metadata.tmdb_rating = media.vote_average

vrobbler/apps/videos/sources/youtube.py

@@ -65,7 +65,7 @@ def lookup_video_from_youtube(youtube_id: str) -> VideoMetadata:
             video_metadata.channel_id = channel.id
 
         video_metadata.title = yt_metadata.get("title", "")
-        video_metadata.run_time_seconds = duration
+        video_metadata.base_run_time_seconds = duration
         video_metadata.video_type = VideoType.YOUTUBE.value
         video_metadata.youtube_id = youtube_id
         video_metadata.cover_url = (

vrobbler/apps/videos/utils.py

@@ -1,51 +1,24 @@
 import logging
 
-from scrobbles.utils import convert_to_seconds
-from videos.imdb import lookup_video_from_imdb
-from videos.models import Series, Video
-from videos.skatevideosite import lookup_video_from_skatevideosite
+from videos.models import Video
+from django.db import IntegrityError
+#from videos.skatevideosite import lookup_video_from_skatevideosite
 
 logger = logging.getLogger(__name__)
 
 
-def get_or_create_video(data_dict: dict, post_keys: dict, force_update=False):
-    name_or_id = data_dict.get(post_keys.get("IMDB_ID"), "") or data_dict.get(
-        post_keys.get("VIDEO_TITLE"), ""
-    )
+def clean_up_videos():
+    videos = Video.objects.filter(imdb_id__isnull=False).exclude(imdb_id__icontains="tt")
 
-    video = Video.objects.filter(imdb_id=name_or_id).first()
-    if video:
-        return video
+    for video in videos:
+        logger.info(f"Fixing imdb_id for {video}")
+        video.imdb_id = "tt" + video.imdb_id
+        try:
+            video.save(update_fields=["imdb_id"])
+        except IntegrityError:
+            new_video = Video.objects.filter(imdb_id="tt" + video.imdb_id).first()
+            video.scrobble_set.all().update(video=new_video)
+            video.delete()
 
-    imdb_metadata = lookup_video_from_imdb(name_or_id)
-    # skatevideosite_metadata = lookup_video_from_skatevideosite(name_or_id)
-    # youtube_metadata = {}  # TODO lookup_video_from_youtube(name_or_id)
-
-    video_dict = imdb_metadata
-    if not video_dict:
-        logger.info(
-            "No video found on imdb, skatevideosite or youtube, cannot scrobble",
-            extra={"name_or_id": name_or_id},
-        )
-        return
-
-    video = Video.get_from_imdb_id(video_dict.get("imdb_id")
-
-    if not "overview" in video_dict.keys():
-        video_dict["overview"] = data_dict.get(
-            post_keys.get("OVERVIEW"), None
-        )
-    if not "tagline" in video_dict.keys():
-        video_dict["tagline"] = data_dict.get(
-            post_keys.get("TAGLINE"), None
-        )
-    if not "tmdb_id" in video_dict.keys():
-        video_dict["tmdb_id"] = data_dict.get(
-            post_keys.get("TMDB_ID"), None
-        )
-
-    return video
-
-
-def get_or_create_video_from_skatevideosite(title: str, force_update: bool=True):
-    return
+    videos = Video.objects.filter(scrobble__isnull=True)
+    videos.delete()

vrobbler/apps/videos/views.py

@@ -27,10 +27,11 @@ class SeriesDetailView(LoginRequiredMixin, generic.DetailView):
         context_data["scrobbles"] = self.object.scrobbles_for_user(user_id)
         next_episode_id = self.object.last_scrobbled_episode(
             user_id
-        ).next_imdb_id
+        ).next_imdb_id or ""
         if self.object.is_episode_playing(user_id):
             next_episode_id = ""
-        context_data["next_episode_id"] = "tt" + next_episode_id
+        if next_episode_id:
+            context_data["next_episode_id"] = "tt" + next_episode_id
         return context_data
 
 

vrobbler/apps/webpages/api/serializers.py

@@ -0,0 +1,14 @@
+from webpages.models import Domain, WebPage
+from rest_framework import serializers
+
+
+class DomainSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Domain
+        fields = "__all__"
+
+
+class WebPageSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = WebPage
+        fields = "__all__"

vrobbler/apps/webpages/api/views.py

@@ -0,0 +1,19 @@
+from rest_framework import permissions, viewsets
+
+from webpages.api.serializers import (
+    DomainSerializer,
+    WebPageSerializer,
+)
+from webpages.models import Domain, WebPage
+
+
+class DomainViewSet(viewsets.ModelViewSet):
+    queryset = Domain.objects.all().order_by("-created")
+    serializer_class = DomainSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class WebPageViewSet(viewsets.ModelViewSet):
+    queryset = WebPage.objects.all().order_by("-created")
+    serializer_class = WebPageSerializer
+    permission_classes = [permissions.IsAuthenticated]

vrobbler/apps/webpages/migrations/0006_remove_webpage_run_time_seconds_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('webpages', '0005_alter_webpage_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='webpage',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='webpage',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='webpage',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/webpages/models.py

@@ -220,8 +220,8 @@ class WebPage(ScrobblableMixin):
         if not self.domain or force:
             self._update_domain_from_url()
 
-        if not self.run_time_seconds or force:
-            self.run_time_seconds = self.estimated_time_to_read_in_seconds
+        if not self.base_run_time_seconds or force:
+            self.base_run_time_seconds = self.estimated_time_to_read_in_seconds
 
         if save:
             self.save()

vrobbler/settings.py

@@ -68,6 +68,7 @@ LASTFM_SECRET_KEY = os.getenv("VROBBLER_LASTFM_SECRET_KEY")
 IGDB_CLIENT_ID = os.getenv("VROBBLER_IGDB_CLIENT_ID")
 IGDB_CLIENT_SECRET = os.getenv("VROBBLER_IGDB_CLIENT_SECRET")
 COMICVINE_API_KEY = os.getenv("VROBBLER_COMICVINE_API_KEY")
+BGG_ACCESS_TOKEN = os.getenv("VROBBLER_BGG_ACCESS_TOKEN", "")
 GEOLOC_ACCURACY = os.getenv("VROBBLER_GEOLOC_ACCURACY", 3)
 GEOLOC_PROXIMITY = os.getenv("VROBBLER_GEOLOC_PROXIMITY", "0.0001")
 POINTS_FOR_MOVEMENT_HISTORY = os.getenv(

vrobbler/templates/_longplay_scrobblable_list.html

@@ -0,0 +1,43 @@
+{% load urlreplace %}
+{% load naturalduration %}
+
+<table class="table table-striped table-sm">
+    <thead>
+        <tr>
+            <th scope="col">Latest</th>
+            <th scope="col">Title</th>
+            <th scope="col">Scrobbles</th>
+            <th scope="col">Complete</th>
+            <th scope="col">Start</th>
+        </tr>
+    </thead>
+    <tbody>
+        {% for obj in object_list %}
+        {% if obj.title %}
+        <tr>
+            <td><a href="{{obj.scrobble_set.last.get_absolute_url}}">{{obj.scrobble_set.last.local_timestamp}}
+            <td><a href="{{obj.get_absolute_url}}">{{obj}}</a></td>
+            {% if request.user.is_authenticated %}
+            <td>{{obj.scrobble_count}}</td>
+            <td>{% if obj.scrobble_set.last.logdata.long_play_complete == True %}Yes{% endif %}</td>
+            <td><a type="button" class="btn btn-sm btn-primary" href="{{obj.start_url}}">Scrobble</a></td>
+            {% endif %}
+        </tr>
+        {% endif %}
+        {% endfor %}
+    </tbody>
+</table>
+
+<p class="pagination">
+    <span class="page-links">
+        {% if page_obj.has_previous %}
+            <a href="?{% urlreplace page=page_obj.previous_page_number %}">prev</a>
+        {% endif %}
+            <span class="page-current">
+                Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}
+            </span>
+        {% if page_obj.has_next %}
+            <a href="?{% urlreplace page=page_obj.next_page_number %}">next</a>
+        {% endif %}
+    </span>
+</p>

vrobbler/templates/books/book_detail.html

@@ -26,9 +26,8 @@
     </div>
 </div>
 <div class="row">
-    <p><a href="{{s.logdata.restart_url}}">Read again</a></p>
     {% if object.readcomics_url %}
-    <p><a href="{{object.readcomics_url}}">Read next issue</a></p>
+    <p><a href="{{object.readcomics_url}}">Read again</a></p>
     {% endif %}
     {% if object.next_readcomics_url %}
     <p><a href="{{object.next_readcomics_url}}">Read next issue</a></p>

vrobbler/templates/books/book_list.html

@@ -16,7 +16,7 @@
 
     <div class="col-md">
         <div class="table-responsive">
-            {% include "_scrobblable_list.html" %}
+            {% include "_longplay_scrobblable_list.html" %}
         </div>
     </div>
 </div>

vrobbler/templates/bricksets/brickset_list.html

@@ -16,7 +16,7 @@
 
     <div class="col-md">
         <div class="table-responsive">
-            {% include "_scrobblable_list.html" %}
+            {% include "_longplay_scrobblable_list.html" %}
         </div>
     </div>
 </div>

vrobbler/templates/puzzles/puzzle_list.html

@@ -16,7 +16,7 @@
 
     <div class="col-md">
         <div class="table-responsive">
-            {% include "_scrobblable_list.html" %}
+            {% include "_longplay_scrobblable_list.html" %}
         </div>
     </div>
 </div>

vrobbler/templates/videos/video_detail.html

@@ -66,9 +66,16 @@ dd {
         {% if object.overview %}<p><em>{{object.overview}}</em></p>{% endif %}
         {% if object.plot%}<p>{{object.plot|safe|linebreaks|truncatewords:160}}</p>{% endif %}
         <hr />
+        {% if object.imdb_id %}
         <p style="float:right;">
             <a href="{{object.imdb_link}}"><img src="{% static "images/imdb_logo.png" %}" width=35></a>
         </p>
+        {% endif %}
+        {% if object.youtube_id %}
+        <p style="float:right;">
+            <a href="{{object.youtube_link}}"><img src="{% static "images/youtube_logo.png" %}" width=35></a>
+        </p>
+        {% endif %}
 
     </div>
     <div class="deets">

vrobbler/urls.py

@@ -4,21 +4,35 @@ from oauth2_provider import urls as oauth2_urls
 from rest_framework import routers
 
 import vrobbler.apps.scrobbles.views as scrobbles_views
+
 from vrobbler.apps.boardgames import urls as boardgame_urls
+from vrobbler.apps.boardgames.api.views import BoardGameViewSet, BoardGameDesignerViewSet, BoardGamePublisherViewSet, BoardGameLocationViewSet
+
 from vrobbler.apps.books import urls as book_urls
 from vrobbler.apps.books.api.views import AuthorViewSet, BookViewSet
-from vrobbler.apps.bricksets import urls as bricksets_urls
+
 from vrobbler.apps.lifeevents import urls as lifeevents_urls
+from vrobbler.apps.lifeevents.api.views import LifeEventViewSet
+
 from vrobbler.apps.locations import urls as locations_urls
+from vrobbler.apps.locations.api.views import GeoLocationViewSet
+
 from vrobbler.apps.moods import urls as moods_urls
+from vrobbler.apps.moods.api.views import MoodViewSet
+
+from vrobbler.apps.foods import urls as foods_urls
+from vrobbler.apps.foods.api.views import FoodViewSet, FoodCategoryViewSet
+
 from vrobbler.apps.music import urls as music_urls
 from vrobbler.apps.music.api.views import (
     AlbumViewSet,
     ArtistViewSet,
     TrackViewSet,
 )
+
 from vrobbler.apps.podcasts import urls as podcast_urls
-from vrobbler.apps.profiles.api.views import UserProfileViewSet, UserViewSet
+from vrobbler.apps.podcasts.api.views import ProducerViewSet, PodcastViewSet, PodcastEpisodeViewSet
+
 from vrobbler.apps.scrobbles import urls as scrobble_urls
 from vrobbler.apps.scrobbles.api.views import (
     AudioScrobblerTSVImportViewSet,
@@ -26,6 +40,7 @@ from vrobbler.apps.scrobbles.api.views import (
     LastFmImportViewSet,
     ScrobbleViewSet,
 )
+
 from vrobbler.apps.sports import urls as sports_urls
 from vrobbler.apps.sports.api.views import (
     LeagueViewSet,
@@ -36,15 +51,29 @@ from vrobbler.apps.sports.api.views import (
     TeamViewSet,
 )
 from vrobbler.apps.tasks import urls as tasks_urls
+from vrobbler.apps.tasks.api.views import TaskViewSet
+
 from vrobbler.apps.profiles import urls as profiles_urls
+from vrobbler.apps.profiles.api.views import UserProfileViewSet, UserViewSet
+
 from vrobbler.apps.trails import urls as trails_urls
+from vrobbler.apps.trails.api.views import TrailViewSet
+
 from vrobbler.apps.beers import urls as beers_urls
-from vrobbler.apps.foods import urls as foods_urls
+from vrobbler.apps.beers.api.views import BeerViewSet, BeerProducerViewSet, BeerStyleViewSet
+
 from vrobbler.apps.puzzles import urls as puzzles_urls
+from vrobbler.apps.puzzles.api.views import PuzzleViewSet, PuzzleManufacturerViewSet
 from vrobbler.apps.videogames import urls as videogame_urls
+
 from vrobbler.apps.videos import urls as video_urls
 from vrobbler.apps.videos.api.views import SeriesViewSet, VideoViewSet
+
+from vrobbler.apps.bricksets import urls as bricksets_urls
+from vrobbler.apps.bricksets.api.views import BrickSetViewSet
+
 from vrobbler.apps.webpages import urls as webpages_urls
+from vrobbler.apps.webpages.api.views import DomainViewSet, WebPageViewSet
 
 # from vrobbler.apps.modern_ui import urls as modern_ui_urls
 
@@ -68,6 +97,26 @@ router.register(r"sport-events", SportEventViewSet)
 router.register(r"teams", TeamViewSet)
 router.register(r"users", UserViewSet)
 router.register(r"profiles", UserProfileViewSet)
+router.register(r"domains", DomainViewSet)
+router.register(r"webpages", WebPageViewSet)
+router.register(r"foods", FoodViewSet)
+router.register(r"moods", MoodViewSet)
+router.register(r"tasks", TaskViewSet)
+router.register(r"locations", GeoLocationViewSet)
+router.register(r"beers", BeerViewSet)
+router.register(r"beer-producers", BeerProducerViewSet)
+router.register(r"beer-styles", BeerStyleViewSet)
+router.register(r"boardgames", BoardGameViewSet)
+router.register(r"boardgame-designers", BoardGameDesignerViewSet)
+router.register(r"boardgame-publishers", BoardGamePublisherViewSet)
+router.register(r"boardgame-locations", BoardGameLocationViewSet)
+router.register(r"podcast-producers", ProducerViewSet)
+router.register(r"podcast-episodes", PodcastEpisodeViewSet)
+router.register(r"podcasts", PodcastViewSet)
+router.register(r"puzzle-manufacturers", PuzzleManufacturerViewSet)
+router.register(r"puzzles", PuzzleViewSet)
+router.register(r"bricksets", BrickSetViewSet)
+router.register(r"lifeevents", LifeEventViewSet)
 
 urlpatterns = [
     path("api/v1/", include(router.urls)),