[widgets] Fix import of live_charts

Ultimately these should probably be templated

.drone.yml

@@ -34,7 +34,7 @@ steps:
       command_timeout: 2m
       script:
         - pip uninstall -y vrobbler
-        - pip install git+https://code.unbl.ink/secstate/vrobbler.git@main
+        - pip install git+https://code.lab.unbl.ink/secstate/vrobbler.git@main
         - vrobbler migrate
         - vrobbler collectstatic --noinput
         - immortalctl restart celery && immortalctl restart vrobbler
@@ -50,8 +50,15 @@ steps:
       topic: drone
       priority: low
       tags:
-        - failure
+        - success
         - vrobbler
+      actions:
+        - action: view
+          label: Changes
+          url: "{{ .Commit.Link }}"
+        - action: view
+          label: Build
+          url: "{{ .Build.Link }}"
   - name: build failure notification
     image: parrazam/drone-ntfy:0.3-linux-amd64
     when:
@@ -61,8 +68,15 @@ steps:
       topic: drone
       priority: high
       tags:
-        - success
+        - failure
         - vrobbler
+      actions:
+        - action: view
+          label: Changes
+          url: "{{ .Commit.Link }}"
+        - action: view
+          label: Build
+          url: "{{ .Build.Link }}"
 volumes:
   - name: docker
     host:

.gitea/workflows/build-deploy.yml

@@ -0,0 +1,114 @@
+name: build & deploy
+
+on:
+  push:
+    branches: ["**"]
+    tags: ["*"]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    env:
+      VROBBLER_DATABASE_URL: sqlite:///test.db
+      VROBBLER_USDA_API_KEY: ${{ vars.VROBBLER_USDA_API_KEY }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      # Cache pip + Poetry caches (rough equivalent to your mounted pip_cache)
+      - name: Cache pip/poetry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/pip
+            ~/.cache/pypoetry
+          key: ${{ runner.os }}-py311-${{ hashFiles('**/poetry.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-py311-
+
+      - name: Install Poetry
+        run: |
+          python -m pip install --upgrade pip
+          pip install poetry
+
+      - name: Install deps
+        run: |
+          cp vrobbler.conf.test vrobbler.conf
+          poetry install --with test
+
+      - name: Pytest with coverage
+        run: |
+          poetry run pytest -n 5 --cov-report term:skip-covered --cov=vrobbler tests
+
+      # Notifications (success/failure) for the test job
+      - name: Notify success (ntfy)
+        if: success()
+        run: |
+          curl -fsS \
+            -H "Title: vrobbler CI success" \
+            -H "Priority: low" \
+            -H "Tags: success,vrobbler" \
+            -H "Actions: view, Changes, ${{ gitea.server_url }}/${{ gitea.repository }}/commit/${{ gitea.sha }}; view, Build, ${{ gitea.server_url }}/${{ gitea.repository }}/actions/runs/${{ gitea.run_id }}" \
+            -d "✅ Build succeeded: ${{ gitea.repository }} @ ${{ gitea.sha }}" \
+            https://ntfy.unbl.ink/drone
+
+      - name: Notify failure (ntfy)
+        if: failure()
+        run: |
+          curl -fsS \
+            -H "Title: vrobbler CI failure" \
+            -H "Priority: high" \
+            -H "Tags: failure,vrobbler" \
+            -H "Actions: view, Changes, ${{ gitea.server_url }}/${{ gitea.repository }}/commit/${{ gitea.sha }}; view, Build, ${{ gitea.server_url }}/${{ gitea.repository }}/actions/runs/${{ gitea.run_id }}" \
+            -d "❌ Build failed: ${{ gitea.repository }} @ ${{ gitea.sha }}" \
+            https://ntfy.unbl.ink/drone
+
+  deploy:
+    # Only deploy on tags (equivalent to Drone when: ref: refs/tags/*)
+    # if: startsWith(gitea.ref, 'refs/tags/')
+    needs: [test]
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Deploy via SSH
+        uses: appleboy/ssh-action@v1.0.3
+        with:
+          host: vrobbler.service
+          username: root
+          key: ${{ secrets.JAIL_KEY }}
+          command_timeout: 2m
+          script: |
+            pip uninstall -y vrobbler
+            pip install git+https://code.lab.unbl.ink/secstate/vrobbler.git@main
+            vrobbler migrate
+            vrobbler collectstatic --noinput
+            immortalctl restart celery && immortalctl restart vrobbler
+
+      - name: Notify deploy success (ntfy)
+        if: success()
+        run: |
+          curl -fsS \
+            -H "Title: vrobbler deploy success" \
+            -H "Priority: low" \
+            -H "Tags: success,vrobbler,deploy" \
+            -H "Actions: view, View changes, ${{ gitea.server_url }}/${{ gitea.repository }}/commit/${{ gitea.sha }}; view, View build, ${{ gitea.server_url }}/${{ gitea.repository }}/actions/runs/${{ gitea.run_id }}" \
+            -d "🚀 Deploy succeeded: ${{ gitea.ref_name }} (${{ gitea.sha }})" \
+            https://ntfy.unbl.ink/drone
+
+      - name: Notify deploy failure (ntfy)
+        if: failure()
+        run: |
+          curl -fsS \
+            -H "Title: vrobbler deploy failure" \
+            -H "Priority: high" \
+            -H "Tags: failure,vrobbler,deploy" \
+            -H "Actions: view, View changes, ${{ gitea.server_url }}/${{ gitea.repository }}/commit/${{ gitea.sha }}; view, View build, ${{ gitea.server_url }}/${{ gitea.repository }}/actions/runs/${{ gitea.run_id }}" \
+            -d "💥 Deploy failed: ${{ gitea.ref_name }} (${{ gitea.sha }})" \
+            https://ntfy.unbl.ink/drone

.gitignore

@@ -3,3 +3,5 @@ vrobbler.conf
 media/
 dist/
 .coverage
+tmp/*
+vrobbler/static/*

Makefile

@@ -1,5 +1,5 @@
 deploy:
-	ssh vrobbler.service "rm -rf /usr/local/lib/python3.11/site-packages/vrobbler-0.15.4.dist-info/ && pip install git+https://code.unbl.ink/secstate/vrobbler.git@develop && immortalctl restart vrobbler && immortalctl restart vrobbler-celery && vrobbler migrate"
+	ssh vrobbler.service "pip uninstall vrobbler && pip install git+https://code.lab.unbl.ink/secstate/vrobbler.git && immortalctl restart vrobbler && immortalctl restart vrobbler-celery && vrobbler migrate"
 logs:
 	ssh life.unbl.ink tail -n 100 -f /var/log/vrobbler.json
 test:

PROJECT.org

@@ -1,6 +1,20 @@
 #+title: Vrobbler Project
 
 * Overview
+Vrobbler began humbly enough as a way to use Jellyfin's webhook to keep track of
+the shows and movies I was watching. More specifically, I broke my ankle a few
+days after Christmas in 2022 and spent the next four months very slowly
+recovering after surgical repair. So once I had the webhook working, and
+scrobbling videos, it was only a matter of time till I expaned it to mopidy to
+replicate LastFM. Then I added board games, books via KoReader, sports events,
+podcasts ... it just keeps going. Vrobbler is now a sort of Frankenstein's
+monster of scrobbling an entire life.
+
+I am still unconvinced I can keep this going, but being able to scrobble org
+tasks, Todoist tasks, web pages I've read and trails I've hiked has turned out
+to be sometimes cathartic and sometimes functional as I try to remember when I
+did a thing.
+
 * Features
 ** Beer
 *** Triggers
@@ -70,7 +84,6 @@ fetching and simple saving.
 **** Bookmarklet
 *** Metadata sources
 **** Scraper
-* Release history
 * Chores
 ** DONE Document various vrobbler features :chore:personal:project:vrobbler:documentation:
 :PROPERTIES:
@@ -79,72 +92,8 @@ fetching and simple saving.
 :LOGBOOK:
 CLOCK: [2025-07-09 Wed 09:55]--[2025-07-09 Wed 10:15] =>  0:20
 :END:
-* Backlog [1/22]
+* Backlog [14/33]
-** TODO [#A] Add classmethod for metadata fetching to tracks :vrobbler:feature:music:personal:project:
+** TODO [#C] Create small utility to clean up tracks scrobbled with wonky playback times :vrobbler:personal:bug:music:scrobbles:
-:PROPERTIES:
-:ID:       bc4b45e5-4c65-13c5-ab7b-1937d3fbf5c2
-:END:
-:LOGBOOK:
-CLOCK: [2025-07-09 Wed 10:15]
-:END:
-
-** TODO Look in comments for a timestamp for start from BG stats if the time is missing :vrobbler:feature:boardgames:project:personal:
-** TODO Add importer class for IMAP imports :vrobbler:feature:imap:importers:project:personal:
-** TODO Add youtube link in place of IMDB on video detail page :vrobbler:feature:videos:personal:project:
-** TODO [#A] Tasks from org-mode should properly update notes and leave them out of the body :vrobbler:bug:tasks:
-** TODO [#A] Fix small bug in views for TV series where next episode is now None :vrobbler:bug:personal:videos:
-
-#+begin_src python
-ERROR    django.request:241 log_response Internal Server Error: /series/c24100d1-da45-4abe-86bf-27cfce9b1f89/
-Traceback (most recent call last):
-  File "/usr/local/lib/python3.11/site-packages/django/core/handlers/exception.py", line 55, in inner
-    response = get_response(request)
-               ^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/django/core/handlers/base.py", line 197, in _get_response
-    response = wrapped_callback(request, *callback_args, **callback_kwargs)
-               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/django/views/generic/base.py", line 104, in view
-    return self.dispatch(request, *args, **kwargs)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/django/contrib/auth/mixins.py", line 73, in dispatch
-    return super().dispatch(request, *args, **kwargs)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/django/views/generic/base.py", line 143, in dispatch
-    return handler(request, *args, **kwargs)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/django/views/generic/detail.py", line 109, in get
-    context = self.get_context_data(object=self.object)
-              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/videos/views.py", line 33, in get_context_data
-    context_data["next_episode_id"] = "tt" + next_episode_id
-                                      ~~~~~^~~~~~~~~~~~~~~~~
-TypeError: can only concatenate str (not "NoneType") to str
-#+end_src
-
-** TODO [#A] Send periodic check notifications for board games and beer that ask if you're still scrobbling :vrobbler:personal:project:beers:boardgames:notifications:feature:
-** TODO [#A] Fix raw text webpage title not truncating to 254 chars :vrobbler:personal:bug:webpages:
-** TODO [#A] Fix koreader scrobble imports to use DST properly :vrobbler:personal:bug:books:imports:
-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] Create small utility to clean up tracks scrobbled with wonky playback times :vrobbler:personal:bug:music:scrobbles:
-** TODO [#B] Add AllTrails as a source for Trail data :vrobbler:trails:feature:personal:project:
-Pretty clear, I would love to make trails more useful. Historically I wasn't
-hiking a lot, which made the source for this a bit silly. But it's clear that
-AllTrails is the best source, though having TrailForks is nice to.
-** TODO [#B] Add `garmin_activity_id` to the TrailMetadataLog class :vrobbler:trails:feature:personal:project:
-Would be nice to have some loose connection to the actual event in my Garmin profile.
-** TODO [#B] Explore a way to add metadata editing to scrobbles after saving :vrobbler:spike:scrobbling:personal:project:
-Could be as simple as a JSON form on the scrobble detail page (do I have have one of those yet?).
-** TODO [#B] Explore a good way to show notes and descriptions from scrobbles to users :personal:project:scrobbling:vrobbler:spike:
-** 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 [#C] Fix bug where podcast scrobbling creates duplicate Podcast :project:vrobbler:scrobbling:podcasts:bug:personal:
-Rather than pick up an existing Podcast using the podcast title in the mopidy
-file name, Vrobbler creates a new podcast with no enriched data. Not a big deal
-for my use as the volume of podcasts I listen to makes manual fixes easy. But
-it's annoying.
 ** TODO [#C] Move to using more robust mopidy-webhooks pacakge form pypi :utility:improvement:
 :PROPERTIES:
 :ID:       ab31fdc3-359c-1b1d-6b9d-546b476021ba
@@ -443,17 +392,465 @@ it's annoying.
 ** TODO [#C] Allow users to see tasks on calendar view :vrobbler:personal:project:templates:feature:
 https://codepen.io/oliviale/pen/QYqybo
 ** TODO [#C] Come up with a possible flow using WebDAV and super-productivity for tasks :personal:feature:project:vrobbler:tasks:
-* Version 19.0
+** TODO [#B] Add importer class for IMAP imports :vrobbler:feature:imap:importers:project:personal:
+** TODO [#B] Add AllTrails as a source for Trail data :vrobbler:trails:feature:personal:project:
+Pretty clear, I would love to make trails more useful. Historically I wasn't
+hiking a lot, which made the source for this a bit silly. But it's clear that
+AllTrails is the best source, though having TrailForks is nice to.
+** TODO [#B] Add `garmin_activity_id` to the TrailMetadataLog class :vrobbler:trails:feature:personal:project:
+Would be nice to have some loose connection to the actual event in my Garmin profile.
+** TODO [#B] Explore a way to add metadata editing to scrobbles after saving :vrobbler:spike:scrobbling:personal:project:
+
+Could be as simple as a JSON form on the scrobble detail page (do I have have
+one of those yet?).
+** TODO [#B] Explore a good way to show notes and descriptions from scrobbles to users :personal:project:scrobbling:vrobbler:spike:
+** 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] 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:
+
+- Note taken on [2025-09-25 Thu 10:51]
+
+  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] 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.
+      
+** TODO [#A] When creating org-mode tasks, don't copy comments :vrobbler:bug:scrobbles:tasks:
+** TODO Add sentiment parsing for Scrobbles with notes :vrobbler:project:scrobbles:sentiment:
+** DONE [#A] Save raw scrobble request data to every scrobble log :vrobbler:personal:feature:scrobbles:
+:PROPERTIES:
+:ID:       b4686db4-1319-399c-9b84-f0b1036c6815
+:END:
+
+The idea here is that no matter where the data comes from, we should just save
+it in the scrobble for posterity, so we can always in some form recover the
+original intent of the scrobble.
+
+It may also allow us to clean up junk scrobbles if the data was just horribly
+wrong.
+
+** DONE [#B] Clean up follow up notifications for if you're still scrobbling :vrobbler:personal:project:beers:boardgames:notifications:feature:
+:PROPERTIES:
+:ID:       7937545f-2a62-4188-ad49-34f85fad0c25
+:END:
+
+- Note taken on [2025-09-30 Tue 09:32]
+
+  I added this feature in a very rough way, but now we should add "Action"
+  headers so that we can either Finish or Cancel the associated scrobble:
+
+  https://docs.ntfy.sh/publish/#send-http-request
+
+** DONE [#A] Fix lookup of music tracks from Musicbrainz :vrobbler:bug:tracks:music:
+:PROPERTIES:
+:ID:       2bc1cc0b-6c4e-bc3d-e7c3-47df364df206
+:END:
+
+Turns out we're not looking up music tracks properly, again.
+
+** DONE Check opencode about a way to present stats like movies per month :vrobbler:scrobbles:stats:personal:project:
+:PROPERTIES:
+:ID:       eed39a0b-3aa7-dc65-9e03-a58fa401c8c6
+:END:
+** DONE Fix bug in Jellyfin audio track playback :vrobbler:personal:project:bug:music:jellyfin:
+:PROPERTIES:
+:ID:       002bd234-4507-5313-fb59-2d3baa49b847
+:END:
+
+#+begin_src shell
+ERROR    django.request:241 log_response Internal Server Error: /webhook/jellyfin/
+Traceback (most recent call last):
+  File "/usr/local/lib/python3.11/site-packages/django/core/handlers/exception.py", line 55, in inner
+    response = get_response(request)
+               ^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/core/handlers/base.py", line 197, in _get_response
+    response = wrapped_callback(request, *callback_args, **callback_kwargs)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/views/decorators/csrf.py", line 56, in wrapper_view
+    return view_func(*args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/views/decorators/csrf.py", line 56, in wrapper_view
+    return view_func(*args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/views/generic/base.py", line 104, in view
+    return self.dispatch(request, *args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/rest_framework/views.py", line 509, in dispatch
+    response = self.handle_exception(exc)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/rest_framework/views.py", line 469, in handle_exception
+    self.raise_uncaught_exception(exc)
+  File "/usr/local/lib/python3.11/site-packages/rest_framework/views.py", line 480, in raise_uncaught_exception
+    raise exc
+  File "/usr/local/lib/python3.11/site-packages/rest_framework/views.py", line 506, in dispatch
+    response = handler(request, *args, **kwargs)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/rest_framework/decorators.py", line 50, in handler
+    return func(*args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/scrobbles/views.py", line 494, in jellyfin_webhook
+    scrobble = jellyfin_scrobble_media(post_data, request.user.id)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/scrobbles/scrobblers.py", line 177, in jellyfin_scrobble_media
+    log["album_id"] = media_obj.album_id
+    ~~~^^^^^^^^^^^^
+TypeError: 'tuple' object does not support item assignment
+#+end_src
+** DONE [#B] Auto calc duration if no playback time seconds present :vrobbler:bug:scrobbles:personal:project:
+:PROPERTIES:
+:ID:       e16228b2-b062-bd00-32e6-b2353e6406e9
+:END:
+** DONE Fix bug in video find_or_create :vrobbler:personal:project:bug:videos:
+:PROPERTIES:
+:ID:       10e611a5-fbcf-7473-25f0-c9bad7b79ffd
+:END:
+The error:
+#+begin_src shell
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/scrobbles/views.py", line 493, in jellyfin_webhook
+    scrobble = jellyfin_scrobble_media(post_data, request.user.id)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/scrobbles/scrobblers.py", line 149, in jellyfin_scrobble_media
+    media_obj = Video.find_or_create(imdb_id)
+                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/videos/models.py", line 390, in find_or_create
+    return cls.get_from_imdb_id(source_id, overwrite)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/videos/models.py", line 374, in get_from_imdb_id
+    video.tv_series = Series.find_or_create(
+                      ^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/videos/models.py", line 203, in find_or_create
+    vdict, _, cover, genres = lookup_video_from_imdb(
+                              ^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/videos/sources/imdb.py", line 17, in lookup_video_from_imdb
+    imdb_result = imdb.get_title(imdb_id)
+                  ^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/cinemagoerng/web.py", line 127, in get_title
+    data = _scrape(spec=spec, context=context, headers=headers)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/cinemagoerng/web.py", line 120, in _scrape
+    document = fetch(url, headers=request_headers)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/cinemagoerng/web.py", line 44, in fetch
+    with urlopen(request) as response:
+         ^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/urllib/request.py", line 216, in urlopen
+    return opener.open(url, data, timeout)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/urllib/request.py", line 525, in open
+    response = meth(req, response)
+               ^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/urllib/request.py", line 634, in http_response
+    response = self.parent.error(
+               ^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/urllib/request.py", line 563, in error
+    return self._call_chain(*args)
+           ^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/urllib/request.py", line 496, in _call_chain
+    result = func(*args)
+             ^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/urllib/request.py", line 643, in http_error_default
+    raise HTTPError(req.full_url, code, msg, hdrs, fp)
+urllib.error.HTTPError: HTTP Error 500: Internal Server Error
+#+end_src
+
+- Note taken on [2026-03-11 Wed 20:53]
+
+  It turns out that every time a TV show was scrobbled were were hitting IMDB.
+  Woof.
+
+** DONE Update admin page to be easier to use :vrobbler:djadmin:project:personal:
+:PROPERTIES:
+:ID:       0779be1f-1ad7-ddc7-8861-d3c7c833cbe9
+:END:
+** DONE Fix migrations and update repo :vrobbler:scrobbles:admin:personal:project:
+:PROPERTIES:
+:ID:       ccbc2ef0-68bf-9ef7-dcaf-febab5ebefe2
+:END:
+** DONE Add recipe parsing for food lookups :vrobbler:foods:project:feature:personal:
+:PROPERTIES:
+:ID:       86456c78-247b-fb63-7ae8-d6d17e7666b1
+:END:
+** DONE [#A] Videos are scrobbling duplicates again :vrobbler:bug:videos:scrobbles:
+:PROPERTIES:
+:ID:       a46884fe-7ef1-410a-316b-7ac6d7599331
+:END:
+<2026-03-06 Fri>
+** DONE Fix board games not saving BGG id on lookup :vrobbler:bug:boardgames:
+:PROPERTIES:
+:ID:       506c2965-51d6-6cb9-fc4f-4f0468d2d62f
+:END:
+** DONE Fix board game lookup with name like Unmatched Game System :vrobbler:bug:boardgames:
+:PROPERTIES:
+:ID:       57956723-b34a-37ad-fde9-44947cc9bb65
+:END:
+** DONE [#A] Fix raw text webpage title not truncating to 254 chars :vrobbler:personal:bug:webpages:
+:PROPERTIES:
+:ID:       13fa0efd-2c3f-dd07-deb2-62882096feff
+:END:
+
+- Note taken on [2025-09-30 Tue 09:33]
+
+  This may have already been resolved ... need to just confirm it.
+* 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:
+
+- 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/
+Traceback (most recent call last):
+  File "/usr/local/lib/python3.11/site-packages/django/core/handlers/exception.py", line 55, in inner
+    response = get_response(request)
+               ^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/core/handlers/base.py", line 197, in _get_response
+    response = wrapped_callback(request, *callback_args, **callback_kwargs)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/views/generic/base.py", line 104, in view
+    return self.dispatch(request, *args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/contrib/auth/mixins.py", line 73, in dispatch
+    return super().dispatch(request, *args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/views/generic/base.py", line 143, in dispatch
+    return handler(request, *args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/views/generic/detail.py", line 109, in get
+    context = self.get_context_data(object=self.object)
+              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/videos/views.py", line 33, in get_context_data
+    context_data["next_episode_id"] = "tt" + next_episode_id
+                                      ~~~~~^~~~~~~~~~~~~~~~~
+TypeError: can only concatenate str (not "NoneType") to str
+#+end_src
+
+** 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-10-29 Wed 16:38]
+
+  Turns out I was misusing `orgmode` for the source of tasks when it shoulda been `Org-mode`
+
+  A good lesson in using constants for things.
+
+* 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
+:END:
+** DONE [#B] Move comic resume URL to next page and check if it exists :vrobbler:feature:books:personal:project:
+:PROPERTIES:
+:ID:       9fe09567-11a3-7083-53c7-07458a9591d0
+:END:
+* Version 31.0 [3/3]
+** DONE [#A] Stop comic book webpage scrobbles from overwriting old scrobbles :vrobbler:personal:bug:books:scrobbling:
+:PROPERTIES:
+:ID:       4b2ec068-a281-a88b-c31d-6248d6eb0aa0
+:END:
+** DONE [#A] Add page calculation to manually scrobbled books :vrobbler:personal:feature:books:scrobbling:
+:PROPERTIES:
+:ID:       b2e313b3-5c35-57e7-8933-627535baf34b
+:END:
+** DONE [#A] Fix bug in scrobbling comics where google fails :vrobbler:personal:bug:books:scrobbling:
+:PROPERTIES:
+:ID:       9a870c05-6d20-0803-d35d-c03fbe1d0ee1
+:END:
+* Version 30.0 [3/3]
+** DONE [#A] Fix readcomicsonline browsing to update pages :vrobbler:books:feature:comicbook:personal:project:scrobbling:
+:PROPERTIES:
+:ID:       981b215a-6473-5fc7-d4cc-51b3eddec4c3
+:END:
+** DONE [#B] Redirect webpages back to the original page when starting or stopping :vrobbler:project:webpages:bug:
+:PROPERTIES:
+:ID:       6183d03a-452b-51d5-cceb-5bfeada947aa
+:END:
+
+** DONE [#B] Fix ComicVine as source for comic book metadata :vrobbler:books:feature:comicbook:personal:project:scrobbling:
+:PROPERTIES:
+:ID:       d22cec3f-117f-f203-33a5-efbefa8a5cee
+:END:
+* Version 29.0 [1/1]
+** DONE HOTFIX podcast lookups, final
+* Version 28.0 [1/1]
+** DONE HOTFIX podcast lookups
+* Version 27.0 [3/3]
+** DONE [#A] Fix bug where podcast scrobbling creates duplicate Podcast :project:vrobbler:scrobbling:podcasts:bug:personal:
+:PROPERTIES:
+:ID:       7377ef6c-5fa7-9e4e-9080-f9810a76118c
+:END:
+
+Rather than pick up an existing Podcast using the podcast title in the mopidy
+file name, Vrobbler creates a new podcast with no enriched data. Not a big deal
+for my use as the volume of podcasts I listen to makes manual fixes easy. But
+it's annoying.
+
+** DONE [#A] Allow reading comic books from readcomicsoline.ru :vrobbler:books:feature:comicbook:personal:project:scrobbling:
+:PROPERTIES:
+:ID:       7c7e9ecc-b675-68c3-764f-ef771ce5d88f
+:END:
+
+- Note taken on [2025-09-25 Thu 10:52]
+
+  Things to consider are whether we scrobble the issue on one page, send it to
+  archivebox? (yes), and how best to enrich the data
+
+** DONE [#A] Add RSS feed lookups to podcasts :vrobbler:personal:feature:podcasts:
+:PROPERTIES:
+:ID:       d60645b0-7578-97c1-0278-05bd9de4269c
+:END:
+
+- Note taken on [2025-10-14 Tue 10:08]
+
+  Turns out the Podcast plugin for mopidy does a pretty good job of showing the
+  latest file without having to scroll the bottom using only Muse to not parse
+  the podcast title name. BUT, now we're getting urls like this:
+
+  https://nsf.libsyn.com/rss#77e01251-cb20-4609-b577-d48e985d2e7b
+
+  This is great, because there's more context there, but it has to read out of
+  the RSS feed. We should add a check in the podcast util to sniff out the file
+  referenced in the # in that url and populate the info from there. This should
+  actually be much more reliable than the current state of the podcast lookup
+  which depends on the file to be name properly.
+
+* Version 26.0 [3/3]
+** DONE Clean up templates for scrobble details :vrobbler:personal:bug:templates:
+:PROPERTIES:
+:ID:       43dc1e02-c110-5b49-0ac7-4c4f7656d1aa
+:END:
+** DONE Add named locations visited to dashboard :vrobbler:personal:feature:locations:templates:
+:PROPERTIES:
+:ID:       ebc365a1-cef4-f75d-569f-c24b072ef5a4
+:END:
+** DONE Add moods to dashboard :vrobbler:moods:feature:templates:personal:
+:PROPERTIES:
+:ID:       c03a38ce-b337-f4fa-adba-aee08d4329f5
+:END:
+* Version 25.0 [3/3]
+** DONE Add basic food templates and fix urls :food:vrobbler:personal:project:bug:urls:
+:PROPERTIES:
+:ID:       3de3459e-8e7e-abba-e068-b919a819d3e3
+:END:
+** DONE [#C] Fix how elapsed time is calculated :vrobbler:personal:project:scrobbles:bug:
+:PROPERTIES:
+:ID:       cff58fc4-06ac-8016-4eae-130b51e3c9b7
+:END:
+** DONE Fix templates for videos and dashboard links :personal:feature:project:vrobbler:templates:
+:PROPERTIES:
+:ID:       7debfbaf-cdd8-f49b-57ff-804bfe7c9236
+:END:
+* Version 24.0 [2/2]
+** DONE Clean up logdata for various media :personal:feature:project:vrobbler:logdata:
+:PROPERTIES:
+:ID:       d5cce807-1f45-ef19-45a4-9f7069fa2a93
+:END:
+** DONE Removed sidebar and add links to headers :personal:feature:templates:scrobbles:
+:PROPERTIES:
+:ID:       1a1c0aa6-0313-c8be-1676-5d6adddef0a4
+:END:
+
+* Version 23.0 [3/3]
+** DONE Add dynamic forms for LogData classes :personal:feature:vrobbler:project:forms:logdata:
+:PROPERTIES:
+:ID:       0db889a1-f262-fba2-7fed-ed99eded1c88
+:END:
+** DONE Look in comments for a timestamp for start from BG stats if the time is missing :vrobbler:feature:boardgames:project:personal:
+** DONE Fix long play scrobbles to provide better data :vrobbler:feature:scrobbles:longplay:personal:project:
+:PROPERTIES:
+:ID:       99f6bd77-dc8f-6ed1-0321-32a52c944264
+:END:
+* Version 19.0 [1/1]
 ** DONE Add periodic check for mood :vrobbler:feature:moods:personal:project:
 :PROPERTIES:
 :ID:       55404488-c69f-0dd5-838e-1d1e15c873eb
 :END:
-* Version 18.7
+* Version 18.7 [1/1]
 ** DONE Use the timezone history log to fix old Scrobbles that fall into those timezone blocks :vrobbler:chore:scrobbles:project:personal:
 :PROPERTIES:
 :ID:       9d055ac1-584b-20c8-7ad9-9ce36b329dc7
 :END:
-* Version 18.4
+* Version 18.4 [2/2]
 ** DONE Track timezone changes for profiles :vrobbler:feature:profiles:personal:project:
 :PROPERTIES:
 :ID:       89ec867f-29fd-82f1-be17-b49dddc30c78
@@ -466,12 +863,12 @@ https://codepen.io/oliviale/pen/QYqybo
 - Note taken on [2025-07-20 Sun 16:21]
 
   This thing is kicking my butt. As it stands it works, but the scrobbles are not assigned to the tracks properly.
-* Version 18.3
+* Version 18.3 [1/1]
 ** DONE Add timezone awarness to IMAP importer :personal:project:vrobbler:feature:importer:imap:timezones:
 :PROPERTIES:
 :ID:       05837b7c-96aa-6190-3678-e2ae7c7cac75
 :END:
-* Version 18
+* Version 18 [4/4]
 ** DONE Condense tracks of the same title by the same artist with multiple albums :vrobbler:feature:music:project:personal:
 :PROPERTIES:
 :ID:       b39fcec8-59fd-eab0-5809-b8144c7d2708
@@ -592,7 +989,7 @@ https://codepen.io/oliviale/pen/QYqybo
 :PROPERTIES:
 :ID:       23f485e3-988c-6198-c79d-91fdf92f001c
 :END:
-* Version 17.0
+* Version 17.0 [6/6]
 ** DONE [#A] Fix bug in new task label lookup for Emacs/Org-mode :vrobbler:bug:tasks:
 :PROPERTIES:
 :ID:       683fb109-dfc4-85e4-80f0-ea618434f61e
@@ -655,7 +1052,7 @@ Not sure if the problem is in my Emacs hook sending or Vrobbler itself.
 :PROPERTIES:
 :ID:       df58f8d0-fa4a-2037-c7d7-e5388c239042
 :END:
-* Version 0.16.0
+* Version 0.16.0 [19/19]
 ** DONE [#A] Jellyfin, bandcamp tracks from Mopidy create duplicate music tracks :bug:scrobbling:music:
 :PROPERTIES:
 :ID:       670e8634-49b5-dce9-1684-14f2ffb797f1
@@ -760,7 +1157,7 @@ out using that.
 ** DONE Fix bug in Jellyfin scrobbles that spam more scrobbles after completion :scrobbling:videos:bug:
 This was fixed a while ago, but there's a new manifested bug. Going to create a
 separate bug tracking ticket for that.
-* Version 0.11.4
+* Version 0.11.4 [9/9]
 ** DONE Add rudimentary video game scrobbling :improvement:content:videogames:
 CLOSED: [2023-03-07 Tue 11:11]
 ** DONE Add ability to scrobble from KOReader statistics files :improvement:books:content:

justfile

@@ -0,0 +1,10 @@
+dj-port := "0.0.0.0:" + env_var_or_default("DJANGO_PORT", "8000")
+
+default:
+    @just --list
+
+django:
+    poetry run python manage.py runserver {{dj-port}}
+
+shell:
+    poetry run python manage.py shell

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"
+Pillow = "^10.0.0"
-psycopg2 = "^2.9.3"
+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"
@@ -56,6 +56,10 @@ poetry-bumpversion = "^0.3.3"
 orgparse = "^0.4.20250520"
 tmdbv3api = "^1.9.0"
 themoviedb = "^1.0.2"
+feedparser = "^6.0.12"
+titlecase = "^2.4.1"
+bgg-api = "^1.1.13"
+recipe-scrapers = "^15.11.0"
 
 [tool.poetry.group.test]
 optional = true
@@ -79,8 +83,7 @@ types-requests = "^2.27"
 bandit = "^1.7.4"
 
 [tool.pytest.ini_options]
-minversion = "6.0"
+addopts = "-ra -q --reuse-db --no-migrations"
-addopts = "-ra -q --reuse-db"
 testpaths = ["tests"]
 DJANGO_SETTINGS_MODULE='vrobbler.settings-testing'
 

scripts/README.org

@@ -0,0 +1,27 @@
+#+title: Readme
+
+Scripts are a collection of helpful utility scripts, or simple gut-check tests for various functional pieces.
+
+* test_recipe_scraper.py
+Asserts various urls by making actual calls out to the internet, while our test suite mocks return values.
+
+#+begin_src shell
+python ../manage.py shell < ../scripts/test_recipe_scraper.py
+#+end_src
+
+#+RESULTS:
+| Eagerly   | running                                                                     | all               | tasks |
+| Connected | to                                                                          | sqlite@db.sqlite3 |       |
+| Checking: | https://cookingwithmike.com/quinoa-meatloaf/                                |                   |       |
+| Checking: | https://www.kingarthurbaking.com/recipes/overnight-sourdough-waffles-recipe |                   |       |
+| Checking: | https://dirt.fyi/article/2026/02/25-years-of-ipod-brain?src=longreads       |                   |       |
+
+* test_koreader_import.py
+Run through an actual koreader sqlite file and make sure imports work as expected
+
+#+begin_src shell
+rm db.sqlite3
+cp ../db.sqlite3 .
+python ../manage.py shell < ../scripts/test_koreader_import.py
+#+end_src
+

scripts/test_koreader_import.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+
+from books.koreader import process_koreader_sqlite_file
+
+
+process_koreader_sqlite_file("./koreader-test.sqlite3", 1)

scripts/test_recipe_scraper.py

@@ -0,0 +1,21 @@
+import requests
+from foods.sources.rscraper import (
+    RecipeScraperService,
+)
+
+
+test_urls = {
+    "https://cookingwithmike.com/quinoa-meatloaf/": True,
+    "https://www.kingarthurbaking.com/recipes/overnight-sourdough-waffles-recipe": True,
+    "https://dirt.fyi/article/2026/02/25-years-of-ipod-brain?src=longreads": False,
+    "https://tastesbetterfromscratch.com/belgian-waffles/": True,
+}
+
+for k, v in test_urls.items():
+
+    html = requests.get(k).text
+    print("Checking: ", k)
+    if v:
+        assert RecipeScraperService().is_recipe(html, k)
+    else:
+        assert not RecipeScraperService().is_recipe(html, k)

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/foods_tests/test_recipe_scraper.py

@@ -0,0 +1,198 @@
+import pytest
+from foods.sources.rscraper import (
+    RecipeScraperService,
+)
+
+
+RECIPE_HTML_WITH_SCHEMA = """
+<!DOCTYPE html>
+<html>
+<head>
+    <script type="application/ld+json">
+    {
+        "@context": "https://schema.org/",
+        "@type": "Recipe",
+        "name": "Test Recipe",
+        "author": {
+            "@type": "Person",
+            "name": "Test Author"
+        },
+        "recipeIngredient": ["1 cup flour", "2 eggs", "1/2 cup sugar"],
+        "recipeInstructions": [
+            {
+                "@type": "HowToStep",
+                "text": "Mix ingredients together"
+            }
+        ],
+        "totalTime": "PT30M",
+        "recipeYield": "4 servings"
+    }
+    </script>
+</head>
+<body>
+    <h1>Test Recipe</h1>
+</body>
+</html>
+"""
+
+RECIPE_HTML_WITHOUT_SCHEMA = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Not a Recipe Page</title>
+</head>
+<body>
+    <h1>Welcome to My Blog</h1>
+    <p>This is just a regular blog post about cooking.</p>
+</body>
+</html>
+"""
+
+RECIPE_HTML_WITH_MICRODATA = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Test Recipe</title>
+</head>
+<body itemscope itemtype="http://schema.org/Recipe">
+    <h1 itemprop="name">Microdata Recipe</h1>
+    <div itemprop="author" itemscope itemtype="http://schema.org/Person">
+        <span itemprop="name">Test Author</span>
+    </div>
+    <div itemprop="recipeIngredient">1 cup flour</div>
+    <div itemprop="recipeIngredient">2 eggs</div>
+    <div itemprop="recipeInstructions">
+        <div itemprop="text">Mix all ingredients</div>
+    </div>
+</body>
+</html>
+"""
+
+
+class TestRecipeScraperService:
+    @pytest.fixture
+    def scraper(self):
+        return RecipeScraperService()
+
+    def test_is_recipe_with_valid_schema(self, scraper):
+        result = scraper.is_recipe(
+            RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe"
+        )
+        assert result is True
+
+    def test_is_recipe_without_schema(self, scraper):
+        result = scraper.is_recipe(
+            RECIPE_HTML_WITHOUT_SCHEMA, "https://example.com/blog"
+        )
+        assert result is False
+
+    def test_is_recipe_with_microdata(self, scraper):
+        result = scraper.is_recipe(
+            RECIPE_HTML_WITH_MICRODATA, "https://example.com/recipe"
+        )
+        assert result is True
+
+    def test_scrape_returns_title(self, scraper):
+        result = scraper.scrape(
+            RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe"
+        )
+        assert result["title"] == "Test Recipe"
+
+    def test_scrape_returns_ingredients(self, scraper):
+        result = scraper.scrape(
+            RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe"
+        )
+        assert len(result["ingredients"]) == 3
+        assert "1 cup flour" in result["ingredients"]
+
+    def test_scrape_returns_instructions(self, scraper):
+        result = scraper.scrape(
+            RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe"
+        )
+        assert len(result["instructions"]) > 0
+        assert "Mix ingredients together" in result["instructions"]
+
+    def test_scrape_returns_yields(self, scraper):
+        result = scraper.scrape(
+            RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe"
+        )
+        assert result["yields"] == "4 servings"
+
+    def test_scrape_returns_total_time(self, scraper):
+        result = scraper.scrape(
+            RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe"
+        )
+        assert result["total_time"] == 30
+
+    def test_scrape_returns_url(self, scraper):
+        result = scraper.scrape(
+            RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe"
+        )
+        assert result["url"] == "https://example.com/recipe"
+
+    def test_scrape_raises_on_invalid_html(self, scraper):
+        with pytest.raises(ValueError):
+            scraper.scrape("", "https://example.com/recipe")
+
+    def test_scrape_handles_missing_optional_fields(self, scraper):
+        minimal_html = """
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <script type="application/ld+json">
+            {
+                "@context": "https://schema.org/",
+                "@type": "Recipe",
+                "name": "Minimal Recipe"
+            }
+            </script>
+        </head>
+        <body></body>
+        </html>
+        """
+        result = scraper.scrape(minimal_html, "https://example.com/minimal")
+        assert result["title"] == "Minimal Recipe"
+        assert result["ingredients"] == []
+        assert result["instructions"] == []
+
+    def test_parse_servings(self, scraper):
+        assert scraper.parse_servings("4 servings") == 4
+        assert scraper.parse_servings("6 people") == 6
+        assert scraper.parse_servings("2") == 2
+        assert scraper.parse_servings("serves 8") == 8
+        assert scraper.parse_servings(None) is None
+        assert scraper.parse_servings("") is None
+
+    def test_extract_tags_from_cuisine(self, scraper):
+        recipe_data = {"cuisine": "Italian"}
+        tags = scraper.extract_tags(recipe_data)
+        assert "Italian" in tags
+
+    def test_extract_tags_from_cuisine_list(self, scraper):
+        recipe_data = {"cuisine": ["Italian", "Mexican"]}
+        tags = scraper.extract_tags(recipe_data)
+        assert "Italian" in tags
+        assert "Mexican" in tags
+
+    def test_extract_tags_from_dietary(self, scraper):
+        recipe_data = {"dietary": "Gluten-Free"}
+        tags = scraper.extract_tags(recipe_data)
+        assert "Gluten-Free" in tags
+
+    def test_extract_tags_from_course(self, scraper):
+        recipe_data = {"course": "Dessert"}
+        tags = scraper.extract_tags(recipe_data)
+        assert "Dessert" in tags
+
+    def test_extract_tags_from_keywords(self, scraper):
+        recipe_data = {"keywords": "easy, quick, healthy"}
+        tags = scraper.extract_tags(recipe_data)
+        assert "easy" in tags
+        assert "quick" in tags
+        assert "healthy" in tags
+
+    def test_extract_tags_from_keywords_list(self, scraper):
+        recipe_data = {"keywords": ["comfort food", "winter"]}
+        tags = scraper.extract_tags(recipe_data)
+        assert "comfort food" in tags
+        assert "winter" in tags

tests/foods_tests/test_usda.py

@@ -0,0 +1,135 @@
+import pytest
+from unittest.mock import patch
+from foods.sources.usda import (
+    USDAFoodAPI,
+    NutritionCalculator,
+)
+
+
+class TestUSDAFoodAPI:
+    @pytest.fixture
+    def usda_api(self):
+        with patch(
+            "vrobbler.apps.foods.sources.usda.settings"
+        ) as mock_settings:
+            mock_settings.USDA_API_KEY = "test_api_key"
+            return USDAFoodAPI(api_key="test_api_key")
+
+    def test_extract_nutrients_with_nutrient_number(self, usda_api):
+        food_data = {
+            "description": "Test Food",
+            "foodNutrients": [
+                {
+                    "nutrientNumber": "203",
+                    "nutrientName": "Protein",
+                    "value": 10.0,
+                },
+                {
+                    "nutrientNumber": "204",
+                    "nutrientName": "Total lipid (fat)",
+                    "value": 5.0,
+                },
+                {
+                    "nutrientNumber": "205",
+                    "nutrientName": "Carbohydrate, by difference",
+                    "value": 20.0,
+                },
+                {
+                    "nutrientNumber": "208",
+                    "nutrientName": "Energy",
+                    "value": 150.0,
+                },
+                {
+                    "nutrientNumber": "269",
+                    "nutrientName": "Sugars, total",
+                    "value": 5.0,
+                },
+            ],
+        }
+        result = usda_api.extract_nutrients(food_data)
+        assert result["protein"] == 10.0
+        assert result["fat"] == 5.0
+        assert result["carbohydrates"] == 20.0
+        assert result["calories"] == 150.0
+        assert result["sugar"] == 5.0
+
+    def test_extract_nutrients_with_nested_nutrient(self, usda_api):
+        food_data = {
+            "description": "Test Food",
+            "foodNutrients": [
+                {
+                    "nutrient": {"id": 203, "name": "Protein"},
+                    "value": 10.0,
+                },
+            ],
+        }
+        result = usda_api.extract_nutrients(food_data)
+        assert result["protein"] == 10.0
+
+    def test_extract_nutrients_with_empty_nutrients(self, usda_api):
+        food_data = {"description": "Test Food", "foodNutrients": []}
+        result = usda_api.extract_nutrients(food_data)
+        assert result["protein"] == 0
+        assert result["calories"] == 0
+
+    def test_extract_nutrients_with_no_nutrients_key(self, usda_api):
+        food_data = {"description": "Test Food"}
+        result = usda_api.extract_nutrients(food_data)
+        assert result["protein"] == 0
+
+
+class TestNutritionCalculator:
+    @pytest.fixture
+    def calculator(self):
+        with patch("vrobbler.apps.foods.sources.usda.USDAFoodAPI"):
+            return NutritionCalculator()
+
+    def test_parse_ingredient_with_fraction(self, calculator):
+        result = calculator.parse_ingredient("1/2 cup flour")
+        assert result["quantity"] == 0.5
+        assert result["unit"] == "cup"
+        assert result["ingredient"] == "flour"
+
+    def test_parse_ingredient_with_mixed_number(self, calculator):
+        result = calculator.parse_ingredient("1 1/2 cups sugar")
+        assert result["quantity"] == 1.5
+        assert result["unit"] == "cups"
+        assert result["ingredient"] == "sugar"
+
+    def test_parse_ingredient_with_decimal(self, calculator):
+        result = calculator.parse_ingredient("0.5 tsp salt")
+        assert result["quantity"] == 0.5
+        assert result["unit"] == "tsp"
+        assert result["ingredient"] == "salt"
+
+    def test_parse_ingredient_with_whole_number(self, calculator):
+        result = calculator.parse_ingredient("3 eggs")
+        assert result["quantity"] == 3
+        assert result["unit"] is None
+        assert result["ingredient"] == "eggs"
+
+    def test_parse_ingredient_with_no_quantity(self, calculator):
+        result = calculator.parse_ingredient("salt to taste")
+        assert result["quantity"] == 1
+
+    def test_clean_ingredient_name_removes_modifiers(self, calculator):
+        result = calculator._clean_ingredient_name("fresh chopped onions")
+        assert "fresh" not in result.lower()
+        assert "chopped" not in result.lower()
+
+    def test_clean_ingredient_name_removes_parentheses(self, calculator):
+        result = calculator._clean_ingredient_name("flour (sifted)")
+        assert "(" not in result
+        assert ")" not in result
+
+    def test_convert_to_grams_cup(self, calculator):
+        result = calculator._convert_to_grams(2, "cups", "flour")
+        assert result == 480
+
+    def test_convert_to_grams_tablespoon(self, calculator):
+        result = calculator._convert_to_grams(3, "tbsp", "olive oil")
+        assert result == 45
+
+    def test_convert_to_grams_unknown_unit(self, calculator):
+        result = calculator._convert_to_grams(1, "unknown", "something")
+        assert result == 100

tests/scrobbles_tests/conftest.py

@@ -22,8 +22,18 @@ def boardgame_scrobble():
         played_to_completion=True,
         log={
             "players": [
-                {"person_id": first.id, "win": True, "score": 30, "color": "Blue"},
+                {
-                {"person_id": second.id, "win": False, "score": 28, "color": "Red"}
+                    "person_id": first.id,
+                    "win": True,
+                    "score": 30,
+                    "color": "Blue",
+                },
+                {
+                    "person_id": second.id,
+                    "win": False,
+                    "score": 28,
+                    "color": "Red",
+                },
             ],
         },
     )
@@ -34,7 +44,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,
     )
 
 
@@ -116,6 +126,14 @@ def mopidy_podcast_request_data():
     ).request_json
 
 
+@pytest.fixture
+def mopidy_podcast_https_request_data():
+    mopidy_uri = "podcast+https://feeds.npr.org/510318/podcast.xml#85b9c4c4-ae09-43d9-8853-31ccf43f68e6"
+    return MopidyRequest(
+        mopidy_uri=mopidy_uri, artist="NPR", album="Up First"
+    ).request_json
+
+
 class JellyfinTrackRequest:
     name = "Emotion"
     artist = "Carly Rae Jepsen"
@@ -130,6 +148,7 @@ class JellyfinTrackRequest:
     musicbrainz_album_id = "03b864cd-7761-314c-a892-05a89ddff00d"
     musicbrainz_artist_id = "95f5b748-d370-47fe-85bd-0af2dc450bc0"
     status = "resumed"
+    client_name = "Jellyfin"
 
     def __init__(self, **kwargs):
         self.request_data = {
@@ -153,6 +172,7 @@ class JellyfinTrackRequest:
                 "musicbrainz_artist_id", self.musicbrainz_artist_id
             ),
             "Status": kwargs.get("status", self.status),
+            "ClientName": kwargs.get("client_name", self.client_name),
         }
 
     def __eq__(self, other):

tests/scrobbles_tests/test_aggregators.py

@@ -1,4 +1,5 @@
 from datetime import datetime, timedelta
+from unittest.mock import patch
 
 import pytest
 import time_machine
@@ -26,8 +27,21 @@ def build_scrobbles(client, request_json, num=7, spacing=2):
 
 
 @pytest.mark.django_db
+@patch("music.models.get_album_metadata_with_artist", return_value={})
+@patch("music.models.get_track_metadata_with_artist", return_value={})
+@patch("music.models.get_recording_mbid_exact", return_value=(None, None))
+@patch("music.models.lookup_artist_from_tadb", return_value={})
+@patch("music.models.lookup_album_from_tadb", return_value={})
 @time_machine.travel(datetime(2022, 3, 4, 1, 24))
-def test_scrobble_counts_data(client, mopidy_track):
+def test_scrobble_counts_data(
+    mock_lookup_album_tadb,
+    mock_lookup_artist_tadb,
+    mock_get_recording,
+    mock_get_track,
+    mock_get_album,
+    client,
+    mopidy_track,
+):
     build_scrobbles(client, mopidy_track.request_json)
     user = get_user_model().objects.first()
     count_dict = scrobble_counts(user)
@@ -41,8 +55,21 @@ def test_scrobble_counts_data(client, mopidy_track):
 
 
 @pytest.mark.django_db
+@patch("music.models.get_album_metadata_with_artist", return_value={})
+@patch("music.models.get_track_metadata_with_artist", return_value={})
+@patch("music.models.get_recording_mbid_exact", return_value=(None, None))
+@patch("music.models.lookup_artist_from_tadb", return_value={})
+@patch("music.models.lookup_album_from_tadb", return_value={})
 @time_machine.travel(datetime(2022, 3, 4, 1, 24))
-def test_live_charts(client, mopidy_track):
+def test_live_charts(
+    mock_lookup_album_tadb,
+    mock_lookup_artist_tadb,
+    mock_get_recording,
+    mock_get_track,
+    mock_get_album,
+    client,
+    mopidy_track,
+):
     build_scrobbles(client, mopidy_track.request_json, 7, 1)
     user = get_user_model().objects.first()
 

tests/scrobbles_tests/test_metadata.py

@@ -1,6 +1,6 @@
 import pytest
 
-from scrobbles.dataclasses import BoardGameLogData, BoardGameScoreLogData
+# from scrobbles.dataclasses import BoardGameLogData, BoardGameScoreLogData
 
 
 @pytest.mark.skip("Need to get local tests running working again")
@@ -19,7 +19,7 @@ def test_boardgame_log_data(boardgame_scrobble):
                 new=None,
                 rank=None,
                 seat_order=None,
-                role=None
+                role=None,
             ),
             BoardGameScoreLogData(
                 person_id=2,
@@ -32,7 +32,7 @@ def test_boardgame_log_data(boardgame_scrobble):
                 new=None,
                 rank=None,
                 seat_order=None,
-                role=None
+                role=None,
             ),
         ],
         difficulty=None,

tests/scrobbles_tests/test_scrobblers.py

@@ -0,0 +1,41 @@
+from unittest.mock import MagicMock, patch
+
+from scrobbles.scrobblers import jellyfin_scrobble_media, mopidy_scrobble_media
+
+
+def test_jellyfin_scrobble_media_ignores_progress_with_zero_position():
+
+    post_data = {
+        "ItemType": "Audio",
+        "PlaybackPosition": "00:00:00",
+        "NotificationType": "PlaybackProgress",
+    }
+
+    result = jellyfin_scrobble_media(post_data, 1)
+
+    assert result is None
+
+
+def test_mopidy_scrobble_handles_missing_mopidy_uri():
+
+    with patch("scrobbles.scrobblers.Track") as mock_track_class:
+        with patch("scrobbles.scrobblers.parse_mopidy_uri", return_value=None):
+            mock_track = MagicMock()
+            mock_track.scrobble_for_user = MagicMock(return_value=MagicMock())
+            mock_track_class.find_or_create.return_value = mock_track
+
+            post_data = {
+                "name": "Test Song",
+                "artist": "Test Artist",
+                "album": "Test Album",
+                "run_time": 180000,
+            }
+
+            result = mopidy_scrobble_media(post_data, 1)
+
+            mock_track_class.find_or_create.assert_called_once_with(
+                title="Test Song",
+                artist_name="Test Artist",
+                album_name="Test Album",
+                run_time_seconds=180000,
+            )

tests/scrobbles_tests/test_views.py

@@ -1,13 +1,15 @@
 from datetime import datetime, timedelta
-from unittest.mock import patch
+from unittest.mock import patch, MagicMock
 from django.utils import timezone
+from django.contrib.auth import get_user_model
 
 import pytest
 import time_machine
 from django.urls import reverse
-from music.models import Track
+from music.models import Track, Artist, Album
 from podcasts.models import PodcastEpisode
 from scrobbles.models import Scrobble
+from tasks.models import Task
 
 
 @pytest.mark.django_db
@@ -18,6 +20,14 @@ def test_get_not_allowed_from_mopidy(client, valid_auth_token):
     assert response.status_code == 405
 
 
+@pytest.mark.django_db
+def test_get_not_allowed_from_jellyfin(client, valid_auth_token):
+    url = reverse("scrobbles:jellyfin-webhook")
+    headers = {"Authorization": f"Token {valid_auth_token}"}
+    response = client.get(url, headers=headers)
+    assert response.status_code == 405
+
+
 @pytest.mark.django_db
 def test_bad_mopidy_request_data(client, valid_auth_token):
     url = reverse("scrobbles:mopidy-webhook")
@@ -30,6 +40,338 @@ def test_bad_mopidy_request_data(client, valid_auth_token):
     )
 
 
+@pytest.mark.django_db
+def test_bad_jellyfin_request_data(client, valid_auth_token):
+    url = reverse("scrobbles:jellyfin-webhook")
+    headers = {"Authorization": f"Token {valid_auth_token}"}
+    response = client.post(url, headers)
+    assert response.status_code == 400
+    assert (
+        response.data["detail"]
+        == "JSON parse error - Expecting value: line 1 column 1 (char 0)"
+    )
+
+
+@pytest.mark.django_db
+@patch("music.models.Artist.find_or_create")
+@patch("music.models.Track.find_or_create")
+def test_create_scrobble_from_mopidy_track_webhook(
+    mock_track_fc,
+    mock_artist_fc,
+    client,
+    valid_auth_token,
+    mopidy_track,
+):
+    mock_artist = MagicMock(spec=Artist)
+    mock_artist.id = 1
+    mock_artist_fc.return_value = mock_artist
+
+    mock_track = MagicMock(spec=Track)
+    mock_track.id = 1
+    mock_track.scrobble_for_user.return_value = Scrobble(
+        id=1, track_id=1, user_id=1, in_progress=True
+    )
+    mock_track_fc.return_value = mock_track
+
+    url = reverse("scrobbles:mopidy-webhook")
+    headers = {"Authorization": f"Token {valid_auth_token}"}
+    response = client.post(
+        url,
+        mopidy_track.request_data,
+        content_type="application/json",
+        headers=headers,
+    )
+    assert response.status_code == 200
+    assert response.data == {"scrobble_id": 1}
+    mock_track.scrobble_for_user.assert_called_once()
+
+
+@pytest.mark.django_db
+@patch("music.models.Artist.find_or_create")
+@patch("music.models.Track.find_or_create")
+def test_create_scrobble_from_jellyfin_track_webhook(
+    mock_track_fc,
+    mock_artist_fc,
+    client,
+    valid_auth_token,
+    jellyfin_track,
+):
+    mock_artist = MagicMock(spec=Artist)
+    mock_artist.id = 1
+    mock_artist_fc.return_value = mock_artist
+
+    mock_track = MagicMock(spec=Track)
+    mock_track.id = 1
+    mock_track.scrobble_for_user.return_value = Scrobble(
+        id=1, track_id=1, user_id=1, in_progress=True
+    )
+    mock_track_fc.return_value = mock_track
+
+    url = reverse("scrobbles:jellyfin-webhook")
+    headers = {"Authorization": f"Token {valid_auth_token}"}
+
+    with time_machine.travel(datetime(2024, 1, 14, 12, 00, 1)):
+        jellyfin_track.request_data["UtcTimestamp"] = timezone.now().strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        response = client.post(
+            url,
+            jellyfin_track.request_json,
+            content_type="application/json",
+            headers=headers,
+        )
+        assert response.status_code == 200
+        assert response.data == {"scrobble_id": 1}
+        mock_track.scrobble_for_user.assert_called_once()
+
+
+@pytest.mark.django_db
+@patch("music.models.Artist.find_or_create")
+@patch("music.models.Track.find_or_create")
+def test_mopidy_track_webhook_creates_track_and_scrobble(
+    mock_track_fc,
+    mock_artist_fc,
+    client,
+    valid_auth_token,
+    mopidy_track,
+):
+    artist = Artist.objects.create(name="Sublime")
+    album = Album.objects.create(name="Sublime", album_artist=artist)
+    track = Track.objects.create(
+        title="Same in the End",
+        artist=artist,
+        base_run_time_seconds=60,
+    )
+    track.albums.add(album)
+
+    mock_artist_fc.return_value = artist
+    mock_track_fc.return_value = track
+
+    url = reverse("scrobbles:mopidy-webhook")
+    headers = {"Authorization": f"Token {valid_auth_token}"}
+    response = client.post(
+        url,
+        mopidy_track.request_data,
+        content_type="application/json",
+        headers=headers,
+    )
+    assert response.status_code == 200
+    assert response.data == {"scrobble_id": 1}
+
+    scrobble = Scrobble.objects.get(id=1)
+    assert scrobble.track == track
+    assert scrobble.source == "Mopidy"
+
+
+@pytest.mark.django_db
+@patch("music.models.Artist.find_or_create")
+@patch("music.models.Track.find_or_create")
+def test_jellyfin_track_webhook_creates_track_and_scrobble(
+    mock_track_fc,
+    mock_artist_fc,
+    client,
+    valid_auth_token,
+    jellyfin_track,
+):
+    artist = Artist.objects.create(name="Carly Rae Jepsen")
+    album = Album.objects.create(name="Emotion", album_artist=artist)
+    track = Track.objects.create(
+        title="Emotion",
+        artist=artist,
+        base_run_time_seconds=60,
+    )
+    track.albums.add(album)
+
+    mock_artist_fc.return_value = artist
+    mock_track_fc.return_value = track
+
+    url = reverse("scrobbles:jellyfin-webhook")
+    headers = {"Authorization": f"Token {valid_auth_token}"}
+
+    with time_machine.travel(datetime(2024, 1, 14, 12, 00, 1)):
+        jellyfin_track.request_data["UtcTimestamp"] = timezone.now().strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        response = client.post(
+            url,
+            jellyfin_track.request_json,
+            content_type="application/json",
+            headers=headers,
+        )
+        assert response.status_code == 200
+        assert response.data == {"scrobble_id": 1}
+
+        scrobble = Scrobble.objects.get(id=1)
+        assert scrobble.track == track
+        assert scrobble.source == "Jellyfin"
+        assert "raw_data" in scrobble.log
+
+
+@pytest.mark.django_db
+@patch("music.models.Artist.find_or_create")
+@patch("music.models.Track.find_or_create")
+def test_mopidy_track_webhook_stores_raw_data(
+    mock_track_fc,
+    mock_artist_fc,
+    client,
+    valid_auth_token,
+    mopidy_track,
+):
+    artist = Artist.objects.create(name="Sublime")
+    album = Album.objects.create(name="Sublime", album_artist=artist)
+    track = Track.objects.create(
+        title="Same in the End",
+        artist=artist,
+        base_run_time_seconds=60,
+    )
+    track.albums.add(album)
+
+    mock_artist_fc.return_value = artist
+    mock_track_fc.return_value = track
+
+    url = reverse("scrobbles:mopidy-webhook")
+    headers = {"Authorization": f"Token {valid_auth_token}"}
+    response = client.post(
+        url,
+        mopidy_track.request_data,
+        content_type="application/json",
+        headers=headers,
+    )
+    assert response.status_code == 200
+    assert response.data == {"scrobble_id": 1}
+
+    scrobble = Scrobble.objects.get(id=1)
+    assert scrobble.track == track
+    assert scrobble.source == "Mopidy"
+    assert "raw_data" in scrobble.log
+    assert scrobble.log["raw_data"]["name"] == "Same in the End"
+
+
+@pytest.mark.django_db
+@patch("music.models.Artist.find_or_create")
+@patch("music.models.Track.find_or_create")
+def test_mopidy_track_webhook_stores_album_id(
+    mock_track_fc,
+    mock_artist_fc,
+    client,
+    valid_auth_token,
+    mopidy_track,
+):
+    artist = Artist.objects.create(name="Sublime")
+    album = Album.objects.create(name="Sublime", album_artist=artist)
+    track = Track.objects.create(
+        title="Same in the End",
+        artist=artist,
+        album=album,
+        base_run_time_seconds=60,
+    )
+
+    mock_artist_fc.return_value = artist
+    mock_track_fc.return_value = track
+
+    url = reverse("scrobbles:mopidy-webhook")
+    headers = {"Authorization": f"Token {valid_auth_token}"}
+    response = client.post(
+        url,
+        mopidy_track.request_data,
+        content_type="application/json",
+        headers=headers,
+    )
+    assert response.status_code == 200
+
+    scrobble = Scrobble.objects.get(id=1)
+    assert "album_id" in scrobble.log
+    assert scrobble.log["album_id"] == album.id
+    assert "album" not in scrobble.log
+
+
+@pytest.mark.django_db
+@patch("music.models.Artist.find_or_create")
+@patch("music.models.Track.find_or_create")
+def test_jellyfin_track_webhook_stores_raw_data(
+    mock_track_fc,
+    mock_artist_fc,
+    client,
+    valid_auth_token,
+    jellyfin_track,
+):
+    artist = Artist.objects.create(name="Carly Rae Jepsen")
+    album = Album.objects.create(name="Emotion", album_artist=artist)
+    track = Track.objects.create(
+        title="Emotion",
+        artist=artist,
+        base_run_time_seconds=60,
+    )
+    track.albums.add(album)
+
+    mock_artist_fc.return_value = artist
+    mock_track_fc.return_value = track
+
+    url = reverse("scrobbles:jellyfin-webhook")
+    headers = {"Authorization": f"Token {valid_auth_token}"}
+
+    with time_machine.travel(datetime(2024, 1, 14, 12, 00, 1)):
+        jellyfin_track.request_data["UtcTimestamp"] = timezone.now().strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        response = client.post(
+            url,
+            jellyfin_track.request_json,
+            content_type="application/json",
+            headers=headers,
+        )
+        assert response.status_code == 200
+
+        scrobble = Scrobble.objects.get(id=1)
+        assert scrobble.track == track
+        assert scrobble.source == "Jellyfin"
+        assert "raw_data" in scrobble.log
+        assert scrobble.log["raw_data"]["Name"] == "Emotion"
+
+
+@pytest.mark.django_db
+@patch("music.models.Artist.find_or_create")
+@patch("music.models.Track.find_or_create")
+def test_jellyfin_track_webhook_stores_album_id(
+    mock_track_fc,
+    mock_artist_fc,
+    client,
+    valid_auth_token,
+    jellyfin_track,
+):
+    artist = Artist.objects.create(name="Carly Rae Jepsen")
+    album = Album.objects.create(name="Emotion", album_artist=artist)
+    track = Track.objects.create(
+        title="Emotion",
+        artist=artist,
+        album=album,
+        base_run_time_seconds=60,
+    )
+    track.albums.add(album)
+
+    mock_artist_fc.return_value = artist
+    mock_track_fc.return_value = track
+
+    url = reverse("scrobbles:jellyfin-webhook")
+    headers = {"Authorization": f"Token {valid_auth_token}"}
+
+    with time_machine.travel(datetime(2024, 1, 14, 12, 00, 1)):
+        jellyfin_track.request_data["UtcTimestamp"] = timezone.now().strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        response = client.post(
+            url,
+            jellyfin_track.request_json,
+            content_type="application/json",
+            headers=headers,
+        )
+        assert response.status_code == 200
+
+        scrobble = Scrobble.objects.get(id=1)
+        assert "album_id" in scrobble.log
+        assert scrobble.log["album_id"] == album.id
+
+
 @pytest.mark.skip("Need to refactor")
 @pytest.mark.django_db
 @patch("music.utils.lookup_artist_from_mb", return_value={})
@@ -146,9 +488,125 @@ def test_scrobble_jellyfin_track(
         assert response.status_code == 200
         assert response.data == {"scrobble_id": 1}
 
-        scrobble = Scrobble.objects.get(id=1)
+    scrobble = Scrobble.objects.get(id=1)
-        assert scrobble.media_obj.__class__ == Track
+    assert scrobble.media_obj.__class__ == Track
-        assert scrobble.media_obj.title == "Emotion"
+    assert scrobble.media_obj.title == "Emotion"
+
+
+@pytest.mark.django_db
+def test_scrobble_detail_view_with_notes_as_flat_list(client):
+    user = get_user_model().objects.create_user(
+        username="testuser", email="test@example.com", password="testpass"
+    )
+    task = Task.objects.create(
+        title="Test Task", description="Test description"
+    )
+    scrobble = Scrobble.objects.create(
+        task=task,
+        media_type="Task",
+        user=user,
+        log={
+            "notes": ["First note", "Second note"],
+            "description": "Test description",
+        },
+    )
+    url = reverse("scrobbles:detail", kwargs={"uuid": scrobble.uuid})
+    response = client.get(url)
+    assert response.status_code == 200
+    assert "First note" in response.content.decode()
+    assert "Second note" in response.content.decode()
+
+
+@pytest.mark.django_db
+def test_scrobble_detail_view_with_notes_as_dict_timestamps(client):
+    user = get_user_model().objects.create_user(
+        username="testuser", email="test@example.com", password="testpass"
+    )
+    task = Task.objects.create(
+        title="Test Task", description="Test description"
+    )
+    scrobble = Scrobble.objects.create(
+        task=task,
+        media_type="Task",
+        user=user,
+        log={
+            "notes": [
+                {"2024-01-01 10:00:00": "Note at first timestamp"},
+                {"2024-01-02 11:30:00": "Note at second timestamp"},
+            ],
+            "description": "Test description",
+        },
+    )
+    url = reverse("scrobbles:detail", kwargs={"uuid": scrobble.uuid})
+    response = client.get(url)
+    assert response.status_code == 200
+    content = response.content.decode()
+    assert "2024-01-01 10:00:00" in content
+    assert "Note at first timestamp" in content
+    assert "2024-01-02 11:30:00" in content
+    assert "Note at second timestamp" in content
+
+
+@pytest.mark.django_db
+def test_scrobble_detail_view_with_notes_and_labels(client):
+    user = get_user_model().objects.create_user(
+        username="testuser", email="test@example.com", password="testpass"
+    )
+    task = Task.objects.create(
+        title="Test Task", description="Test description"
+    )
+    scrobble = Scrobble.objects.create(
+        task=task,
+        media_type="Task",
+        user=user,
+        log={
+            "notes": [
+                {"2024-01-01 10:00:00": "Note with label"},
+            ],
+            "labels": ["work", "urgent"],
+            "description": "Test description",
+        },
+    )
+    url = reverse("scrobbles:detail", kwargs={"uuid": scrobble.uuid})
+    response = client.get(url)
+    assert response.status_code == 200
+    content = response.content.decode()
+    assert "work" in content
+    assert "urgent" in content
+
+
+@pytest.mark.django_db
+def test_scrobble_detail_view_post_updates_log(client):
+    user = get_user_model().objects.create_user(
+        username="testuser", email="test@example.com", password="testpass"
+    )
+    task = Task.objects.create(
+        title="Test Task", description="Test description"
+    )
+    scrobble = Scrobble.objects.create(
+        task=task,
+        media_type="Task",
+        user=user,
+        log={
+            "notes": ["Original note"],
+            "description": "Original description",
+        },
+    )
+    url = reverse("scrobbles:detail", kwargs={"uuid": scrobble.uuid})
+
+    client.force_login(user)
+    response = client.post(
+        url,
+        {
+            "description": "Updated description",
+            "notes": "Updated note",
+        },
+    )
+    assert response.status_code == 302
+
+    scrobble.refresh_from_db()
+    assert scrobble.log["description"] == "Updated description"
+    assert scrobble.log["notes"] == ["Updated note"]
 
 
 @pytest.mark.skip("Need to refactor")

tests/test_context_processors.py

@@ -0,0 +1,95 @@
+import os
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+
+import pytest
+from vrobbler.context_processors import version_info
+
+
+@pytest.fixture
+def mock_request():
+    return MagicMock()
+
+
+class TestVersionInfo:
+    def test_returns_version_and_commit(self, mock_request):
+        with (
+            patch(
+                "vrobbler.context_processors.get_version"
+            ) as mock_get_version,
+            patch(
+                "vrobbler.context_processors.subprocess.check_output"
+            ) as mock_check_output,
+        ):
+            mock_get_version.return_value = "1.0.0"
+            mock_check_output.return_value = b"abc1234"
+
+            result = version_info(mock_request)
+
+            assert result["app_version"] == "1.0.0"
+            assert result["git_commit"] == "abc1234"
+
+    def test_uses_env_commit_if_set(self, mock_request):
+        with (
+            patch.dict(os.environ, {"VROBBLER_COMMIT": "env_commit_hash"}),
+            patch(
+                "vrobbler.context_processors.get_version"
+            ) as mock_get_version,
+        ):
+            mock_get_version.return_value = "1.0.0"
+
+            result = version_info(mock_request)
+
+            assert result["git_commit"] == "env_commit_hash"
+
+    def test_returns_unknown_when_version_fails(self, mock_request):
+        with (
+            patch(
+                "vrobbler.context_processors.get_version"
+            ) as mock_get_version,
+            patch(
+                "vrobbler.context_processors.subprocess.check_output"
+            ) as mock_check_output,
+        ):
+            mock_get_version.side_effect = Exception("not found")
+            mock_check_output.return_value = b"abc1234"
+
+            result = version_info(mock_request)
+
+            assert result["app_version"] == "unknown"
+
+    def test_returns_unknown_when_git_fails(self, mock_request):
+        import subprocess
+
+        with (
+            patch(
+                "vrobbler.context_processors.get_version"
+            ) as mock_get_version,
+            patch(
+                "vrobbler.context_processors.subprocess.check_output"
+            ) as mock_check_output,
+        ):
+            mock_get_version.return_value = "1.0.0"
+            mock_check_output.side_effect = subprocess.SubprocessError()
+
+            result = version_info(mock_request)
+
+            assert result["git_commit"] == "unknown"
+
+    def test_returns_unknown_when_git_not_found(self, mock_request):
+        import subprocess
+
+        with (
+            patch(
+                "vrobbler.context_processors.get_version"
+            ) as mock_get_version,
+            patch(
+                "vrobbler.context_processors.subprocess.check_output"
+            ) as mock_check_output,
+        ):
+            mock_get_version.return_value = "1.0.0"
+            mock_check_output.side_effect = FileNotFoundError()
+
+            result = version_info(mock_request)
+
+            assert result["git_commit"] == "unknown"

tests/videos_tests/test_api.py

@@ -0,0 +1,104 @@
+import pytest
+from django.contrib.auth import get_user_model
+from rest_framework.authtoken.models import Token
+
+from videos.models import Channel, Series, Video
+
+User = get_user_model()
+
+
+@pytest.fixture
+def auth_headers():
+    user = User.objects.create(email="api@test.com")
+    token = Token.objects.create(user=user)
+    return {"HTTP_AUTHORIZATION": f"Token {token.key}"}
+
+
+@pytest.fixture
+def channel():
+    return Channel.objects.create(name="Test Channel")
+
+
+@pytest.fixture
+def series():
+    return Series.objects.create(
+        name="Test Series",
+    )
+
+
+@pytest.fixture
+def video(channel):
+    return Video.objects.create(
+        title="Test Video",
+        imdb_id="tt1234567",
+        channel=channel,
+    )
+
+
+@pytest.mark.django_db
+class TestVideoAPI:
+    def test_list_videos(self, client, auth_headers, video):
+        response = client.get("/api/v1/videos/", **auth_headers)
+        assert response.status_code == 200
+        assert len(response.data["results"]) == 1
+        assert response.data["results"][0]["title"] == "Test Video"
+
+    def test_get_video(self, client, auth_headers, video):
+        response = client.get(f"/api/v1/videos/{video.id}/", **auth_headers)
+        assert response.status_code == 200
+        assert response.data["title"] == "Test Video"
+
+    def test_filter_videos_by_channel(
+        self, client, auth_headers, channel, video
+    ):
+        response = client.get(
+            f"/api/v1/videos/?channel={channel.id}", **auth_headers
+        )
+        assert response.status_code == 200
+        assert len(response.data["results"]) == 1
+        assert response.data["results"][0]["channel"] == channel.id
+
+
+@pytest.mark.django_db
+class TestChannelAPI:
+    def test_list_channels(self, client, auth_headers, channel):
+        response = client.get("/api/v1/channels/", **auth_headers)
+        assert response.status_code == 200
+        assert len(response.data["results"]) == 1
+        assert response.data["results"][0]["name"] == "Test Channel"
+
+    def test_get_channel(self, client, auth_headers, channel):
+        response = client.get(
+            f"/api/v1/channels/{channel.id}/", **auth_headers
+        )
+        assert response.status_code == 200
+        assert response.data["name"] == "Test Channel"
+
+
+@pytest.mark.django_db
+class TestSeriesAPI:
+    def test_list_series(self, client, auth_headers, series):
+        response = client.get("/api/v1/series/", **auth_headers)
+        assert response.status_code == 200
+        assert len(response.data["results"]) == 1
+        assert response.data["results"][0]["name"] == "Test Series"
+
+    def test_get_series(self, client, auth_headers, series):
+        response = client.get(f"/api/v1/series/{series.id}/", **auth_headers)
+        assert response.status_code == 200
+        assert response.data["name"] == "Test Series"
+
+
+@pytest.mark.django_db
+class TestVideoAPIUnauthorized:
+    def test_list_videos_unauthenticated(self, client, video):
+        response = client.get("/api/v1/videos/")
+        assert response.status_code == 401
+
+    def test_list_channels_unauthenticated(self, client, channel):
+        response = client.get("/api/v1/channels/")
+        assert response.status_code == 401
+
+    def test_list_series_unauthenticated(self, client, series):
+        response = client.get("/api/v1/series/")
+        assert response.status_code == 401

tests/videos_tests/test_imdb.py

@@ -1,6 +1,14 @@
+import pytest
 from videos.sources.imdb import lookup_video_from_imdb
 
 
-def test_lookup_imdb():
+@pytest.mark.skip(reason="Should not hit IMDB api in CI")
+def test_lookup_imdb_without_tt():
     metadata = lookup_video_from_imdb("8946378")
+    assert not metadata.imdb_id
+
+
+@pytest.mark.skip(reason="Should not hit IMDB api in CI")
+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,20 @@
+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,21 @@
+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,26 @@
+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,11 @@ 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 +43,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 +62,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 +77,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 +113,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
 
@@ -119,8 +124,6 @@ def push_scrobble_to_bgg(scrobble: "Scrobble", user: User) -> Optional[bool]:
             data=json.dumps(login_payload),
             headers=headers,
         )
-        print(p)
-
         players = []
         if scrobble.log:
             for player in scrobble.log.get("players"):
@@ -153,4 +156,3 @@ def push_scrobble_to_bgg(scrobble: "Scrobble", user: User) -> Optional[bool]:
             data=json.dumps(play_payload),
             headers=headers,
         )
-        print(r)

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

@@ -1,12 +1,13 @@
-from functools import cached_property
 import logging
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Optional
+from functools import cached_property
+from typing import Any, Optional
 from uuid import uuid4
 
 import requests
-from boardgames.bgg import lookup_boardgame_from_bgg
+from boardgames.sources.bgg import lookup_boardgame_from_bgg
+from django import forms
 from django.conf import settings
 from django.core.files.base import ContentFile
 from django.db import models
@@ -79,9 +80,20 @@ class BoardGameLogData(BaseLogData, LongPlayLogData):
     board: Optional[str] = None
     rounds: Optional[int] = None
     details: Optional[str] = None
-    # Legacy
+
-    learning: Optional[bool] = None
+    _excluded_fields = {
-    scenario: Optional[str] = None
+        "lichess_id",
+        "speed",
+        "rated",
+        "moves",
+        "variant",
+    }
+
+    @cached_property
+    def location(self):
+        if not self.location_id:
+            return
+        return BoardGameLocation.objects.filter(id=self.location_id).first()
 
     @cached_property
     def player_log(self) -> str:
@@ -94,6 +106,23 @@ class BoardGameLogData(BaseLogData, LongPlayLogData):
             )
         return ""
 
+    @classmethod
+    def override_fields(cls) -> dict:
+        fields = {}
+        for base in cls.mro()[1:]:
+            if hasattr(base, "override_fields"):
+                base_fields = base.override_fields()
+                fields.update(base_fields)
+        custom_fields = {
+            "location_id": forms.ModelChoiceField(
+                queryset=BoardGameLocation.objects.all(),
+                required=False,
+                widget=forms.Select(),
+            )
+        }
+        fields.update(custom_fields)
+        return fields
+
 
 class BoardGamePublisher(TimeStampedModel):
     name = models.CharField(max_length=255)
@@ -162,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",
@@ -195,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)
@@ -272,29 +306,72 @@ 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"}
+                self.save_image_from_url(cover_url)
-                r = requests.get(cover_url, headers=headers)
+
-                logger.debug(r.status_code)
+    def save_image_from_url(self, url):
-                if r.status_code == 200:
+        headers = {"User-Agent": "Vrobbler 0.11.12"}
-                    fname = f"{self.title}_cover_{self.uuid}.jpg"
+        r = requests.get(url, headers=headers)
-                    self.cover.save(fname, ContentFile(r.content), save=True)
+        if r.status_code == 200:
-                    logger.debug("Loaded cover image from BGGeek")
+            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] = {}
+        cls, lookup_id: str, data: dict[str, Any] = {}
-    ) -> Optional["BoardGame"]:
+    ) -> "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 game:
+            game = cls.objects.filter(title=lookup_id).first()
 
-        if not data or not boardgame:
+        if game:
-            data = lookup_boardgame_from_bgg(lookup_id)
+            logger.info(
-
+                "Board game exists in database.",
-        if data and not boardgame:
+                extra={"lookup_id": lookup_id, "data": data},
-            boardgame, created = cls.objects.get_or_create(
-                title=data["title"], bggeek_id=lookup_id
             )
-            if created:
+            return game
-                boardgame.fix_metadata(data=data)
 
-        return boardgame
+        if data.get("bggId"):
+            bgg_data = lookup_boardgame_from_bgg(lookup_id=data.get("bggId"))
+        elif data.get("name"):
+            bgg_data = lookup_boardgame_from_bgg(title=data.get("name"))
+        else:
+            bgg_data = lookup_boardgame_from_bgg(title=lookup_id)
+
+        mechanics = bgg_data.pop("mechanics", [])
+        designers = bgg_data.pop("designers", [])
+        categories = bgg_data.pop("categories", [])
+        publishers = bgg_data.pop("publishers", [])
+        publisher = bgg_data.pop("publisher", [])
+        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)
+        if publisher:
+            publisher, _ = BoardGamePublisher.objects.get_or_create(
+                name=publisher
+            )
+            game.publisher = publisher
+        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,40 @@
+from typing import Any, Union
+from boardgamegeek import BGGClient
+
+from django.conf import settings
+
+
+def lookup_boardgame_from_bgg(
+    lookup_id: str | None = None, title: str | None = None
+) -> dict[str, Any]:
+    game_dict: dict[str, Any] = {}
+
+    bgg = BGGClient(access_token=settings.BGG_ACCESS_TOKEN)
+
+    if lookup_id:
+        game = bgg.game(game_id=lookup_id)
+    else:
+        game = bgg.game(title)
+
+    if game:
+        game_dict["title"] = game.name
+        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["bggeek_id"] = game.id
+        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
+        if game.publishers:
+            game_dict["publisher"] = game.publishers[0]
+
+    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/boardgames/views.py

@@ -1,11 +1,68 @@
+import datetime
+from django.utils import timezone
 from django.views import generic
-from boardgames.models import BoardGame, BoardGamePublisher
+from boardgames.models import BoardGame, BoardGameDesigner, BoardGamePublisher
+from scrobbles.models import Scrobble
 from scrobbles.views import ScrobbleableListView, ScrobbleableDetailView
 
 
 class BoardGameListView(ScrobbleableListView):
     model = BoardGame
 
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        user = self.request.user
+        now = timezone.now()
+        start_day_of_week = now - datetime.timedelta(days=now.weekday())
+        start_day_of_month = now.replace(day=1)
+
+        scrobbles_this_week = Scrobble.objects.filter(
+            user=user,
+            board_game__isnull=False,
+            timestamp__gte=start_day_of_week,
+        ).select_related("board_game")
+
+        scrobbles_this_month = Scrobble.objects.filter(
+            user=user,
+            board_game__isnull=False,
+            timestamp__gte=start_day_of_month,
+        ).select_related("board_game")
+
+        designers_this_week = {}
+        for scrobble in scrobbles_this_week:
+            for designer in scrobble.board_game.designers.all():
+                designers_this_week[designer.id] = {
+                    "designer": designer,
+                    "count": designers_this_week.get(designer.id, {}).get(
+                        "count", 0
+                    )
+                    + 1,
+                }
+
+        designers_this_month = {}
+        for scrobble in scrobbles_this_month:
+            for designer in scrobble.board_game.designers.all():
+                designers_this_month[designer.id] = {
+                    "designer": designer,
+                    "count": designers_this_month.get(designer.id, {}).get(
+                        "count", 0
+                    )
+                    + 1,
+                }
+
+        context_data["designers_this_week"] = sorted(
+            designers_this_week.values(),
+            key=lambda x: x["count"],
+            reverse=True,
+        )
+        context_data["designers_this_month"] = sorted(
+            designers_this_month.values(),
+            key=lambda x: x["count"],
+            reverse=True,
+        )
+
+        return context_data
+
 
 class BoardGameDetailView(ScrobbleableDetailView):
     model = BoardGame

vrobbler/apps/books/admin.py

@@ -21,7 +21,8 @@ class BookAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
     list_display = (
         "title",
-        "subtitle",
+        "author",
+        "issue_or_volume",
         "isbn_13",
         "first_publish_year",
         "pages",
@@ -32,6 +33,9 @@ class BookAdmin(admin.ModelAdmin):
         ScrobbleInline,
     ]
 
+    def issue_or_volume(self, obj):
+        return obj.issue_number or obj.volume_number
+
 
 @admin.register(Paper)
 class BookAdmin(admin.ModelAdmin):

vrobbler/apps/books/api/views.py

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

vrobbler/apps/books/constants.py

@@ -5,3 +5,5 @@ BOOKS_TITLES_TO_IGNORE = [
     "zb2rhkSwygt9vjkAEBj7tP5KVgFqejJqsJ2W3bYsrgiiKK8XL",
     "zb2rhchGpo7P27mofV9hYjT63d9ZaQnbQ6LSfzmkvsYzvARif",
 ]
+
+READCOMICSONLINE_URL = "https://readcomicsonline.ru"

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()
@@ -139,7 +139,6 @@ def build_book_map(rows) -> dict:
     book_id_map = {}
 
     for book_row in rows:
-
         if book_row[KoReaderBookColumn.TITLE.value] in BOOKS_TITLES_TO_IGNORE:
             logger.info(
                 "[build_book_map] Ignoring book title that is likely garbage",
@@ -286,13 +285,11 @@ def build_scrobbles_from_book_map(
                 )
 
                 # Adjust for Daylight Saving Time
-                if timestamp.dst() == timedelta(
+                # if timestamp.dst() == timedelta(
-                    0
+                #    0
-                ) or stop_timestamp.dst() == timedelta(0):
+                # ) or stop_timestamp.dst() == timedelta(0):
-                    timestamp = timestamp - timedelta(hours=1)
+                #    timestamp = timestamp - timedelta(hours=1)
-                    stop_timestamp = stop_timestamp - timedelta(hours=1)
+                #    stop_timestamp = stop_timestamp - timedelta(hours=1)
-                else:
-                    print("In DST! ", timestamp)
 
                 scrobble = Scrobble.objects.filter(
                     timestamp=timestamp,
@@ -309,6 +306,10 @@ def build_scrobbles_from_book_map(
                         "page_data": scrobble_page_data,
                         "pages_read": len(scrobble_page_data.keys()),
                     }
+                    if hasattr(timestamp.tzinfo, "tzname"):
+                        tz = timestamp.tzinfo.tzname
+                    if hasattr(timestamp.tzinfo, "name"):
+                        tz = timestamp.tzinfo.name
                     scrobbles_to_create.append(
                         Scrobble(
                             book_id=book_id,
@@ -322,7 +323,7 @@ def build_scrobbles_from_book_map(
                             in_progress=False,
                             played_to_completion=True,
                             long_play_complete=False,
-                            timezone=timestamp.tzinfo.name,
+                            timezone=tz,
                         )
                     )
                 # Then start over

vrobbler/apps/books/management/commands/cleanup_book_scrobble_times.py

@@ -14,14 +14,13 @@ logger = logging.getLogger(__name__)
 # Grace period between page reads for it to be a new scrobble
 SESSION_GAP_SECONDS = 1800  #  a half hour
 
+
 def update_scrobble_from_page_data(scrobble, commit=True):
     page_list = list(scrobble.book_page_data.items())
     first_page_start_ts = datetime.fromtimestamp(page_list[0][1]["start_ts"])
     last_page_end_ts = datetime.fromtimestamp(page_list[-1][1]["end_ts"])
 
-    if (
+    if datetime(2023, 10, 15) <= first_page_start_ts <= datetime(2023, 12, 15):
-        datetime(2023, 10, 15) <= first_page_start_ts <= datetime(2023, 12, 15)
-    ):
         first_page_start_ts.replace(tzinfo=pytz.timezone("Europe/Paris"))
         last_page_end_ts.replace(tzinfo=pytz.timezone("Europe/Paris"))
     else:
@@ -38,5 +37,7 @@ class Command(BaseCommand):
     def handle(self, *args, **options):
         scrobbles_to_create = []
 
-        for scrobble in Scrobble.objects.filter(media_type="Book", source="KOReader"):
+        for scrobble in Scrobble.objects.filter(
+            media_type="Book", source="KOReader"
+        ):
             update_scrobble_from_page_data(scrobble)

vrobbler/apps/books/metadata.py

@@ -1,10 +1,8 @@
-from enum import Enum
 from typing import Optional
 
-import pendulum
 
 YOUTUBE_VIDEO_URL = "https://www.youtube.com/watch?v="
-IMDB_VIDEO_URL = "https://www.imdb.com/title/tt"
+IMDB_VIDEO_URL = "https://www.imdb.com/title/"
 
 
 class BookType:

vrobbler/apps/books/migrations/0029_book_comicvine_id_book_issue_number_and_more.py

@@ -0,0 +1,33 @@
+# Generated by Django 4.2.19 on 2025-10-20 18:35
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('books', '0028_delete_page'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='book',
+            name='comicvine_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='book',
+            name='issue_number',
+            field=models.IntegerField(blank=True, max_length=5, null=True),
+        ),
+        migrations.AddField(
+            model_name='book',
+            name='original_title',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='book',
+            name='volume_number',
+            field=models.IntegerField(blank=True, max_length=5, null=True),
+        ),
+    ]

vrobbler/apps/books/migrations/0030_book_readcomics_url.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.19 on 2025-10-22 16:29
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('books', '0029_book_comicvine_id_book_issue_number_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='book',
+            name='readcomics_url',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]

vrobbler/apps/books/migrations/0031_book_next_readcomics_url.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.19 on 2025-10-22 17:42
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('books', '0030_book_readcomics_url'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='book',
+            name='next_readcomics_url',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]

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/migrations/0033_alter_book_issue_number_alter_book_volume_number.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.29 on 2026-03-08 05:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("books", "0032_remove_book_run_time_seconds_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="book",
+            name="issue_number",
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AlterField(
+            model_name="book",
+            name="volume_number",
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/books/models.py

@@ -1,15 +1,19 @@
+import logging
 from collections import OrderedDict
 from dataclasses import dataclass
-import logging
+from datetime import datetime
-from datetime import timedelta, datetime
 from typing import Optional
 from uuid import uuid4
 
 import requests
+from books.constants import READCOMICSONLINE_URL
 from books.openlibrary import (
     lookup_author_from_openlibrary,
     lookup_book_from_openlibrary,
 )
+from books.sources.google import lookup_book_from_google
+from books.sources.semantic import lookup_paper_from_semantic
+from books.utils import get_comic_issue_url
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.files.base import ContentFile
@@ -18,28 +22,25 @@ from django.urls import reverse
 from django_extensions.db.models import TimeStampedModel
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
+from scrobbles.dataclasses import BaseLogData, LongPlayLogData
 from scrobbles.mixins import (
     LongPlayScrobblableMixin,
     ObjectWithGenres,
     ScrobblableConstants,
-    ScrobblableMixin,
 )
-from scrobbles.utils import get_scrobbles_for_media
+from scrobbles.utils import get_scrobbles_for_media, next_url_if_exists
 from taggit.managers import TaggableManager
 from thefuzz import fuzz
-from vrobbler.apps.books.comicvine import (
-    ComicVineClient,
-    lookup_comic_from_comicvine,
-)
 
 from vrobbler.apps.books.locg import (
     lookup_comic_by_locg_slug,
     lookup_comic_from_locg,
     lookup_comic_writer_by_locg_slug,
 )
-from books.sources.google import lookup_book_from_google
+from vrobbler.apps.books.sources.comicvine import (
-from books.sources.semantic import lookup_paper_from_semantic
+    ComicVineClient,
-from scrobbles.dataclasses import BaseLogData, LongPlayLogData
+    lookup_comic_from_comicvine,
+)
 
 COMICVINE_API_KEY = getattr(settings, "COMICVINE_API_KEY", "")
 
@@ -63,6 +64,17 @@ class BookLogData(BaseLogData, LongPlayLogData):
     pages_read: Optional[int] = None
     page_start: Optional[int] = None
     page_end: Optional[int] = None
+    resume_url: Optional[str] = None
+
+    _excluded_fields = {"koreader_hash", "page_data"}
+
+    def avg_seconds_per_page(self):
+        if self.page_data:
+            total_duration = 0
+            for page_num, stats in self.page_data.items():
+                total_duration += stats.get("duration", 0)
+            if total_duration:
+                return int(total_duration / len(self.page_data))
 
 
 class Author(TimeStampedModel):
@@ -126,6 +138,7 @@ class Book(LongPlayScrobblableMixin):
     )
 
     title = models.CharField(max_length=255)
+    original_title = models.CharField(max_length=255, **BNULL)
     authors = models.ManyToManyField(Author, blank=True)
     koreader_data_by_hash = models.JSONField(**BNULL)
     isbn_13 = models.CharField(max_length=255, **BNULL)
@@ -136,6 +149,13 @@ class Book(LongPlayScrobblableMixin):
     publish_date = models.DateField(**BNULL)
     publisher = models.CharField(max_length=255, **BNULL)
     first_sentence = models.TextField(**BNULL)
+    # ComicVine
+    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(**BNULL)
+    volume_number = models.IntegerField(**BNULL)
+    # OpenLibrary
     openlibrary_id = models.CharField(max_length=255, **BNULL)
     cover = models.ImageField(upload_to="books/covers/", **BNULL)
     cover_small = ImageSpecField(
@@ -154,7 +174,11 @@ class Book(LongPlayScrobblableMixin):
 
     genre = TaggableManager(through=ObjectWithGenres)
 
-    def __str__(self):
+    def __str__(self) -> str:
+        if self.issue_number and "Issue" not in str(self.title):
+            return f"{self.title} - Issue {self.issue_number}"
+        if self.volume_number and "Volume" not in str(self.title):
+            return f"{self.title} - Volume {self.volume_number}"
         return f"{self.title}"
 
     @property
@@ -179,9 +203,51 @@ class Book(LongPlayScrobblableMixin):
     def get_absolute_url(self):
         return reverse("books:book_detail", kwargs={"slug": self.uuid})
 
+    @classmethod
+    def get_from_comicvine(
+        cls, title: str, overwrite: bool = False, force_new: bool = False
+    ) -> "Book":
+        book, created = cls.objects.get_or_create(title=title)
+
+        if not created:
+            return book
+
+        book_dict = lookup_comic_from_comicvine(title)
+
+        if created or overwrite:
+            author_list = []
+            author_dicts = book_dict.pop("author_dicts")
+            if author_dicts:
+                for author_dict in author_dicts:
+                    if author_dict.get("authorId"):
+                        author, a_created = Author.objects.get_or_create(
+                            semantic_id=author_dict.get("authorId")
+                        )
+                        author_list.append(author)
+                        if a_created:
+                            author.name = author_dict.get("name")
+                            author.save()
+                            # TODO enrich author?
+                            ...
+
+            for k, v in book_dict.items():
+                setattr(book, k, v)
+            book.save()
+
+            if author_list:
+                book.authors.add(*author_list)
+            genres = book_dict.pop("genres", [])
+            if genres:
+                book.genre.add(*genres)
+        return book
+
     @classmethod
     def find_or_create(
-        cls, title: str, enrich: bool = False, commit: bool = True
+        cls,
+        title: str,
+        url: str = "",
+        enrich: bool = False,
+        commit: bool = True,
     ):
         """Given a title, get a Book instance.
 
@@ -192,7 +258,7 @@ class Book(LongPlayScrobblableMixin):
         like to batch create, use commit=False and you'll get an unsaved but enriched
         instance back which you can then save at your convenience."""
         # TODO use either a Google Books id identifier or author name like for tracks
-        book, created = cls.objects.get_or_create(title=title)
+        book, created = cls.objects.get_or_create(original_title=title)
         if not created:
             logger.info(
                 "Found exact match for book by title", extra={"title": title}
@@ -205,15 +271,27 @@ class Book(LongPlayScrobblableMixin):
             )
             return book
 
-        book_dict = lookup_book_from_google(title)
+        book_dict = None
+        if READCOMICSONLINE_URL in url:
+            book_dict = lookup_comic_from_comicvine(title)
+            book_dict["readcomics_url"] = get_comic_issue_url(url)
+            book_dict["next_readcomics_url"] = next_url_if_exists(
+                book_dict["readcomics_url"]
+            )
+
+        if not book_dict:
+            book_dict = lookup_book_from_google(title)
+
+        if not book_dict:
+            logger.warning(
+                "No book found in any source, using data as is",
+                extra={"title": title},
+            )
 
         author_list = []
-        authors = book_dict.pop("authors")
+        authors = book_dict.pop("authors", [])
-        cover_url = book_dict.pop("cover_url")
+        cover_url = book_dict.pop("cover_url", "")
-        try:
+        genres = book_dict.pop("generes", [])
-            genres = book_dict.pop("generes")
-        except:
-            genres = []
 
         if authors:
             for author_str in authors:
@@ -239,7 +317,7 @@ class Book(LongPlayScrobblableMixin):
         return book
 
     def save_image_from_url(self, url: str, force_update: bool = False):
-        if not self.cover or (force_update and url):
+        if url and (not self.cover or force_update):
             r = requests.get(url)
             if r.status_code == 200:
                 fname = f"{self.title}_{self.uuid}.jpg"
@@ -335,7 +413,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/comicvine.py

@@ -3,7 +3,6 @@ ComicVine API Information & Documentation:
 https://comicvine.gamespot.com/api/
 https://comicvine.gamespot.com/api/documentation
 """
-import json
 import logging
 from django.conf import settings
 
@@ -200,34 +199,72 @@ class ComicVineClient(object):
 
 
 def lookup_comic_from_comicvine(title: str) -> dict:
+    original_title = title
+
+    issue_number = None
+    volume_nubmer = None
+    resource_type = "issue"
+    if "Issue " in title:
+        resource_type = "issue"
+        issue_number = title.split("Issue ")[1]
+    volume_number = None
+    if "Volume " in title:
+        resource_type = "volume"
+        volume_number = title.split("Volume ")[1]
+
     api_key = getattr(settings, "COMICVINE_API_KEY", "")
     if not api_key:
-        logger.warn("No ComicVine API key configured, not looking anything up")
+        logger.warning(
+            "No ComicVine API key configured, not looking anything up"
+        )
         return {}
 
     client = ComicVineClient(
         api_key=getattr(settings, "COMICVINE_API_KEY", None)
     )
-    result = [
-        r
-        for r in client.search(title).get("results")
-        if r.get("resource_type") == "volume"
-    ][0]
 
-    if "volume" not in result.keys():
+    raw_results = client.search(title).get("results")
-        logger.warn("No result found on ComicVine", extra={"title": title})
+    results = [
+        r for r in raw_results if r.get("resource_type") == resource_type
+    ]
+    if not results:
+        logger.warning("No comic found on ComicVine")
         return {}
 
-    title = " ".join([result.get("volume").get("name"), result.get("name)")])
+    found_result = None
+    for result in results:
+        if result.get("issue_number") == str(issue_number):
+            found_result = result
+            break
+        if result.get("volume_number") == str(volume_number):
+            found_result = result
+            break
+
+    if not found_result:
+        found_result = results[0]
+
+    logger.info("ComicVine results", extra={"results": results})
+
+    if not found_result:
+        logger.warning("No matches found on ComicVine")
+        return {}
+
+    title = found_result.get("name")
+
+    if found_result.get("volume"):
+        title = found_result.get("volume").get("name")
+
     data_dict = {
         "title": title,
-        "cover_url": result.get("image").get("original_url"),
+        "original_title": original_title,
-        "comicvine_data": {
+        "issue_number": found_result.get("issue_number"),
-            "id": result.get("id"),
+        "volume_number": found_result.get("volume_number"),
-            "site_detail_url": result.get("site_detail_url"),
+        "cover_url": found_result.get("image").get("original_url"),
-            "description": result.get("description"),
+        "comicvine_id": found_result.get("id"),
-            "image": result.get("image").get("original_url"),
+        "comicvine_data": found_result,
-        },
+        "summary": found_result.get("description"),
+        "publish_date": found_result.get("cover_date"),
+        "first_publish_year": found_result.get("cover_date", "")[:4],
     }
 
     return data_dict

vrobbler/apps/books/sources/google.py

@@ -7,7 +7,7 @@ from django.conf import settings
 
 API_KEY = settings.GOOGLE_API_KEY
 GOOGLE_BOOKS_URL = (
-    "https://www.googleapis.com/books/v1/volumes?q=\"{title}\"&key={key}"
+    'https://www.googleapis.com/books/v1/volumes?q="{title}"&key={key}'
 )
 
 logger = logging.getLogger(__name__)
@@ -29,6 +29,9 @@ def lookup_book_from_google(title: str) -> dict:
     google_result = (
         json.loads(response.content).get("items", [{}])[0].get("volumeInfo")
     )
+    if not google_result:
+        return {}
+
     publish_date = pendulum.parse(google_result.get("publishedDate"))
 
     isbn_13 = ""
@@ -59,13 +62,15 @@ def lookup_book_from_google(title: str) -> dict:
     book_dict["genres"] = google_result.get("categories")
     book_dict["cover_url"] = (
         google_result.get("imageLinks", {})
-        .get("thumbnail")
+        .get("thumbnail", "")
         .replace("zoom=1", "zoom=15")
         .replace("&edge=curl", "")
     )
 
-    book_dict["run_time_seconds"] = book_dict.get("pages", 10) * getattr(
+    book_dict["base_run_time_seconds"] = 3600
-        settings, "AVERAGE_PAGE_READING_SECONDS", 60
+    if book_dict.get("pages"):
-    )
+        book_dict["base_run_time_seconds"] = book_dict.get(
+            "pages", 10
+        ) * getattr(settings, "AVERAGE_PAGE_READING_SECONDS", 60)
 
     return book_dict

vrobbler/apps/books/sources/semantic.py

@@ -67,9 +67,9 @@ 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(
-        settings, "AVERAGE_PAGE_READING_SECONDS", 60
+        "pages", 10
-    )
+    ) * getattr(settings, "AVERAGE_PAGE_READING_SECONDS", 60)
     paper_dict["author_dicts"] = result.get("authors")
     paper_dict["genres"] = result.get("fieldsOfStudy")
 

vrobbler/apps/books/tests/test_koreader.py

@@ -1,11 +1,16 @@
 import pytest
 from unittest import mock
+from datetime import datetime
 
 from books.koreader import (
     KoReaderBookColumn,
     build_book_map,
     build_page_data,
     build_scrobbles_from_book_map,
+    get_author_str_from_row,
+    lookup_or_create_authors_from_author_str,
+    create_book_from_row,
+    process_koreader_sqlite_file,
 )
 
 
@@ -52,3 +57,157 @@ def test_build_scrobbles_from_pages(
     assert len(scrobbles[3].logdata.page_data.keys()) == 20
     assert len(scrobbles[4].logdata.page_data.keys()) == 20
     assert len(scrobbles[5].logdata.page_data.keys()) == 18
+
+
+def test_get_author_str_from_row():
+    row = [
+        1,
+        "Test Book",
+        "John Smith\nJane Doe",
+        0,
+        0,
+        0,
+        300,
+        "",
+        "",
+        "abc123",
+        0,
+        120,
+    ]
+    result = get_author_str_from_row(row)
+    assert result == "John Smith, Jane Doe"
+
+
+def test_get_author_str_from_row_strips_middle_initials():
+    row = [
+        1,
+        "Test Book",
+        "John A. Smith",
+        0,
+        0,
+        0,
+        300,
+        "",
+        "",
+        "abc123",
+        0,
+        120,
+    ]
+    result = get_author_str_from_row(row)
+    assert result == "John Smith"
+
+
+@pytest.mark.django_db
+def test_lookup_or_create_authors_from_author_str_creates_new_author():
+    author = lookup_or_create_authors_from_author_str("New Author")
+    assert len(author) == 1
+    assert author[0].name == "New Author"
+
+
+@pytest.mark.django_db
+def test_lookup_or_create_authors_from_author_str_finds_existing():
+    from books.models import Author
+
+    Author.objects.create(name="Existing Author")
+    author = lookup_or_create_authors_from_author_str("Existing Author")
+    assert len(author) == 1
+    assert author[0].name == "Existing Author"
+
+
+@pytest.mark.django_db
+def test_lookup_or_create_authors_from_author_str_ignores_na():
+    author = lookup_or_create_authors_from_author_str("N/A")
+    assert len(author) == 0
+
+
+@pytest.mark.django_db
+def test_lookup_or_create_authors_from_author_str_handles_multiple():
+    author = lookup_or_create_authors_from_author_str("Author One, Author Two")
+    assert len(author) == 2
+
+
+@pytest.mark.django_db
+def test_create_book_from_row():
+    row = [
+        1,
+        "Test Book - Author Name",
+        "Test Author",
+        0,
+        0,
+        0,
+        300,
+        "",
+        "",
+        "abc123def456",
+        3600,
+        120,
+    ]
+    book = create_book_from_row(row)
+    assert book.title == "Test Book"
+    assert book.pages == 300
+    assert "abc123def456" in book.koreader_data_by_hash
+    assert book.authors.count() == 1
+
+
+@pytest.mark.django_db
+def test_create_book_from_row_handles_title_with_author_suffix():
+    row = [
+        1,
+        "Test Book - Author_Name",
+        "N/A",
+        0,
+        0,
+        0,
+        300,
+        "",
+        "",
+        "abc123def456",
+        3600,
+        120,
+    ]
+    book = create_book_from_row(row)
+    assert book.title == "Test Book"
+    assert book.authors.count() == 1
+    assert book.authors.first().name == "Author"
+
+
+@pytest.mark.django_db
+def test_create_book_from_row_handles_null_bytes():
+    row = [
+        1,
+        "Test\x00Book",
+        "Test\x00Author",
+        0,
+        0,
+        0,
+        300,
+        "",
+        "",
+        "abc123def456",
+        3600,
+        120,
+    ]
+    book = create_book_from_row(row)
+    assert "TestBook" in book.title
+    assert "TestAuthor" in book.authors.first().name
+
+
+@pytest.mark.django_db
+def test_build_book_map_ignores_garbage_titles(koreader_rows):
+    garbage_row = [
+        999,
+        "KOReader Quickstart Guide",
+        "N/A",
+        0,
+        0,
+        0,
+        0,
+        "",
+        "",
+        "garbage123",
+        0,
+        0,
+    ]
+    book_map = build_book_map(koreader_rows.BOOK_ROWS + [garbage_row])
+    assert len(book_map) == 1
+    assert 999 not in book_map

vrobbler/apps/books/utils.py

@@ -0,0 +1,61 @@
+import re
+from urllib.parse import urlparse, urlunparse
+
+from titlecase import titlecase
+
+
+def parse_readcomicsonline_uri(uri: str) -> tuple:
+    try:
+        path = uri.split("comic/")[1]
+    except IndexError:
+        return "", "", ""
+
+    parts = path.split("/")
+    title = ""
+    volume = 1
+    page = 1
+    if len(parts) == 2:
+        title = titlecase(parts[0].replace("-", " "))
+        volume = parts[1]
+    if len(parts) == 3:
+        title = titlecase(parts[0].replace("-", " "))
+        volume = parts[1]
+        page = parts[2]
+
+    return title, volume, page
+
+
+def get_comic_issue_url(url: str) -> str:
+    parsed = urlparse(url)
+    parts = [p for p in parsed.path.strip("/").split("/") if p]
+
+    # Find the index of "comic"
+    try:
+        comic_index = parts.index("comic")
+    except ValueError:
+        raise ValueError("URL does not contain '/comic/' segment")
+
+    # Extract title (next part after 'comic')
+    if len(parts) <= comic_index + 1:
+        raise ValueError("No comic title found after '/comic/'")
+    title = parts[comic_index + 1]
+
+    # Look for the first numeric segment after the title
+    number = None
+    for segment in parts[comic_index + 2 :]:
+        if segment.isdigit():
+            number = segment
+            break
+
+    # Build normalized path
+    new_parts = ["comic", title]
+    if number:
+        new_parts.append(number)
+
+    normalized_path = "/" + "/".join(new_parts)
+
+    # Rebuild full URL (same scheme and host)
+    simplified_url = urlunparse(
+        parsed._replace(path=normalized_path, query="", fragment="")
+    )
+    return simplified_url

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/bricksets/models.py

@@ -1,9 +1,11 @@
 from dataclasses import dataclass
+
 from django.db import models
 from django.urls import reverse
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
 from scrobbles.mixins import LongPlayScrobblableMixin
+
 from vrobbler.apps.scrobbles.dataclasses import (
     BaseLogData,
     LongPlayLogData,

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/constants.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python3
+
+EXCLUDED_FOOD_DOMAINS = ["bbc.co.uk", "bbc.com", "www.bbc.com"]

vrobbler/apps/foods/migrations/0003_food_calories.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.19 on 2025-09-11 13:35
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('foods', '0002_alter_food_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='food',
+            name='calories',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

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/migrations/0005_food_nutrition_and_sources.py

@@ -0,0 +1,131 @@
+# Generated by Django 4.2.29 on 2026-03-05 17:01
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("foods", "0004_remove_food_run_time_seconds_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="food",
+            name="carbohydrates",
+            field=models.DecimalField(
+                blank=True, decimal_places=2, max_digits=10, null=True
+            ),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="cook_time_minutes",
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="fat",
+            field=models.DecimalField(
+                blank=True, decimal_places=2, max_digits=10, null=True
+            ),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="fiber",
+            field=models.DecimalField(
+                blank=True, decimal_places=2, max_digits=10, null=True
+            ),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="ingredients",
+            field=models.TextField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="instructions",
+            field=models.TextField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="prep_time_minutes",
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="protein",
+            field=models.DecimalField(
+                blank=True, decimal_places=2, max_digits=10, null=True
+            ),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="servings",
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="sodium",
+            field=models.DecimalField(
+                blank=True, decimal_places=2, max_digits=10, null=True
+            ),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="source_site",
+            field=models.CharField(blank=True, max_length=100, null=True),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="source_url",
+            field=models.URLField(blank=True, null=True, unique=True),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="sugar",
+            field=models.DecimalField(
+                blank=True, decimal_places=2, max_digits=10, null=True
+            ),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="total_time_minutes",
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="food",
+            name="yield_text",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddIndex(
+            model_name="food",
+            index=models.Index(
+                fields=["source_url"], name="foods_food_source__f42f6f_idx"
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="food",
+            index=models.Index(
+                fields=["allrecipe_id"], name="foods_food_allreci_3e7a6c_idx"
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="food",
+            index=models.Index(
+                fields=["description"], name="foods_food_descrip_fccd4d_idx"
+            ),
+        ),
+        migrations.RenameField(
+            model_name="food",
+            old_name="allrecipe_image",
+            new_name="recipe_image",
+        ),
+        migrations.RemoveField(
+            model_name="foodcategory",
+            name="allrecipe_image",
+        ),
+        migrations.AddField(
+            model_name="foodcategory",
+            name="category_image",
+            field=models.ImageField(blank=True, null=True, upload_to="food/category/"),
+        ),
+    ]

vrobbler/apps/foods/models.py

@@ -1,5 +1,6 @@
+import json
 from dataclasses import dataclass
-from typing import Optional
+from typing import Optional, Tuple
 from uuid import uuid4
 
 from django.apps import apps
@@ -8,30 +9,32 @@ from django.urls import reverse
 from django_extensions.db.models import TimeStampedModel
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
-from scrobbles.dataclasses import BaseLogData
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
+from foods.sources.rscraper import RecipeScraperService
+from foods.sources.usda import NutritionCalculator
 
 BNULL = {"blank": True, "null": True}
 
 
 @dataclass
-class FoodLogData(BaseLogData):
+class FoodLogData(BaseLogData, WithPeopleLogData):
+    calories: Optional[int] = None
     meal: Optional[str] = None
-    rating: Optional[str] = None
 
 
 class FoodCategory(TimeStampedModel):
     uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
     name = models.CharField(max_length=255)
-    allrecipe_image = models.ImageField(upload_to="food/recipe/", **BNULL)
+    category_image = models.ImageField(upload_to="food/category/", **BNULL)
-    allrecipe_image_small = ImageSpecField(
+    category_image_small = ImageSpecField(
-        source="recipe_image",
+        source="category_image",
         processors=[ResizeToFit(100, 100)],
         format="JPEG",
         options={"quality": 60},
     )
-    allrecipe_image_medium = ImageSpecField(
+    category_image_medium = ImageSpecField(
-        source="recipe_image",
+        source="category_image",
         processors=[ResizeToFit(300, 300)],
         format="JPEG",
         options={"quality": 75},
@@ -39,6 +42,7 @@ class FoodCategory(TimeStampedModel):
     allrecipe_id = models.CharField(max_length=255, **BNULL)
     description = models.TextField(**BNULL)
 
+    @classmethod
     def find_or_create(cls, title: str) -> "FoodCategory":
         return cls.objects.filter(title=title).first()
 
@@ -47,16 +51,42 @@ class FoodCategory(TimeStampedModel):
 
 
 class Food(ScrobblableMixin):
-    description = models.TextField(**BNULL)
+    # Recipe source tracking
-    allrecipe_image = models.ImageField(upload_to="food/recipe/", **BNULL)
+    source_url = models.URLField(null=True, blank=True, unique=True)
-    allrecipe_image_small = ImageSpecField(
+    source_site = models.CharField(max_length=100, null=True, blank=True)
-        source="allrecipe_image",
+
+    # Recipe data
+    description = models.TextField(**BNULL)  # Recipe title
+    ingredients = models.TextField(**BNULL)  # JSON or newline-separated
+    instructions = models.TextField(**BNULL)  # JSON or newline-separated
+    prep_time_minutes = models.IntegerField(**BNULL)
+    cook_time_minutes = models.IntegerField(**BNULL)
+    total_time_minutes = models.IntegerField(**BNULL)
+    servings = models.IntegerField(**BNULL)
+    yield_text = models.CharField(
+        max_length=255, **BNULL
+    )  # e.g., "8 calzones"
+
+    # Nutrition (per serving)
+    calories = models.IntegerField(**BNULL)
+    protein = models.DecimalField(max_digits=10, decimal_places=2, **BNULL)
+    fat = models.DecimalField(max_digits=10, decimal_places=2, **BNULL)
+    carbohydrates = models.DecimalField(
+        max_digits=10, decimal_places=2, **BNULL
+    )
+    fiber = models.DecimalField(max_digits=10, decimal_places=2, **BNULL)
+    sugar = models.DecimalField(max_digits=10, decimal_places=2, **BNULL)
+    sodium = models.DecimalField(max_digits=10, decimal_places=2, **BNULL)
+
+    recipe_image = models.ImageField(upload_to="food/recipe/", **BNULL)
+    recipe_image_small = ImageSpecField(
+        source="recipe_image",
         processors=[ResizeToFit(100, 100)],
         format="JPEG",
         options={"quality": 60},
     )
-    allrecipe_image_medium = ImageSpecField(
+    recipe_image_medium = ImageSpecField(
-        source="allrecipe_image",
+        source="recipe_image",
         processors=[ResizeToFit(300, 300)],
         format="JPEG",
         options={"quality": 75},
@@ -67,12 +97,20 @@ class Food(ScrobblableMixin):
         FoodCategory, on_delete=models.DO_NOTHING, **BNULL
     )
 
+    class Meta:
+        indexes = [
+            models.Index(fields=["source_url"]),
+            models.Index(fields=["allrecipe_id"]),
+            models.Index(fields=["description"]),
+        ]
+
     def get_absolute_url(self) -> str:
         return reverse("foods:food_detail", kwargs={"slug": self.uuid})
 
     @property
     def subtitle(self):
-        return self.category.name
+        if self.category:
+            return self.category.name
 
     @property
     def strings(self) -> ScrobblableConstants:
@@ -89,8 +127,8 @@ class Food(ScrobblableMixin):
     @property
     def primary_image_url(self) -> str:
         url = ""
-        if self.allrecipe_image:
+        if self.recipe_image:
-            url = self.allrecipe_image.url
+            url = self.recipe_image.url
         return url
 
     @property
@@ -98,21 +136,155 @@ class Food(ScrobblableMixin):
         return FoodLogData
 
     @classmethod
-    def find_or_create(cls, allrecipe_id: str) -> "Food":
+    def find_or_create_from_recipe(
-        food = cls.objects.filter(allrecipe_id=allrecipe_id).first()
+        cls, url: str, category=None
+    ) -> Tuple["Food", bool]:
+        """
+        Scrape a recipe URL and create/update Food instance.
+        Uses django-taggit for tags and existing FoodCategory for category.
+        """
+        # Check if URL already exists
+        existing = cls.objects.filter(source_url=url).first()
+        if existing:
+            return existing, False
 
-        if not food:
+        # Scrape the recipe
-            food_dict = get_food_from_allrecipe_id(allrecipe_id)
+        scraper = RecipeScraperService()
-            # category_dict = {}
+        recipe_data = scraper.scrape_url(url)
 
-            # category, _created = FoodCategory.objects.get_or_create(
+        # Download image
-            #    **category_dict
+        recipe_image = None
-            # )
+        if recipe_data.get("image"):
-            food = Food.objects.create(**food_dict)
+            recipe_image = scraper.download_image(recipe_data["image"])
-            # for category_id in category_ids:
-            #    food.category.add(category_id)
 
-        return food
+        # Extract tags
+        tags = scraper.extract_tags(recipe_data)
+
+        # Calculate nutrition
+        nutrition = recipe_data.get("nutrition")
+        if not nutrition:
+            calculator = NutritionCalculator()
+            servings = (
+                scraper.parse_servings(recipe_data.get("yields", "1")) or 1
+            )
+            nutrition = calculator.calculate_nutrition(
+                recipe_data.get("ingredients", []), servings
+            )
+        else:
+            servings = (
+                scraper.parse_servings(recipe_data.get("yields", "1")) or 1
+            )
+
+        # Get or create category (if not provided)
+        if not category and recipe_data.get("category"):
+            category, _ = FoodCategory.objects.get_or_create(
+                name=recipe_data["category"]
+            )
+
+        # Create Food instance
+        food = cls.objects.create(
+            title=recipe_data.get("title"),
+            source_url=url,
+            source_site=recipe_data.get("site"),
+            ingredients=json.dumps(recipe_data.get("ingredients", [])),
+            instructions=json.dumps(recipe_data.get("instructions", [])),
+            prep_time_minutes=recipe_data.get("prep_time"),
+            cook_time_minutes=recipe_data.get("cook_time"),
+            total_time_minutes=recipe_data.get("total_time"),
+            servings=servings,
+            yield_text=recipe_data.get("yields"),
+            # cuisine=recipe_data.get("cuisine"),
+            # course=recipe_data.get("course"),
+            calories=int(nutrition.get("calories", 0)) if nutrition else None,
+            protein=nutrition.get("protein") if nutrition else None,
+            fat=nutrition.get("fat") if nutrition else None,
+            carbohydrates=(
+                nutrition.get("carbohydrates") if nutrition else None
+            ),
+            fiber=nutrition.get("fiber") if nutrition else None,
+            category=category,
+        )
+
+        # Add tags via django-taggit
+        if tags:
+            food.genre.add(*tags)
+
+        # Save image if downloaded
+        if recipe_image:
+            food.recipe_image.save(recipe_image.name, recipe_image, save=True)
+
+        if "allrecipes.com" in url:
+            food.allrecipe_id = url.split("/recipe/")[-1].split("/")[0]
+            food.save()
+
+        return food, True
+
+    @classmethod
+    def find_or_create_from_ingredients(
+        cls,
+        ingredients: list[str],
+        title: str,
+        servings: int = 1,
+        category=None,
+    ) -> Tuple["Food", bool]:
+        """
+        Create Food from ingredient list (no URL).
+        Calculates nutrition using USDA API.
+        """
+        # Check if similar recipe exists
+        existing = cls.objects.filter(description__icontains=title).first()
+        if existing:
+            return existing, False
+
+        calculator = NutritionCalculator()
+        nutrition = calculator.calculate_nutrition(ingredients, servings)
+
+        food = cls.objects.create(
+            description=title,
+            ingredients=json.dumps(ingredients),
+            servings=servings,
+            calories=int(nutrition.get("calories", 0)) if nutrition else None,
+            protein=nutrition.get("protein") if nutrition else None,
+            fat=nutrition.get("fat") if nutrition else None,
+            carbohydrates=(
+                nutrition.get("carbohydrates") if nutrition else None
+            ),
+            fiber=nutrition.get("fiber") if nutrition else None,
+            category=category,
+        )
+
+        return food, True
+
+    def refresh_nutrition(self) -> bool:
+        """Recalculate nutrition from ingredients (useful if USDA data updated)."""
+        if not self.ingredients:
+            return False
+
+        try:
+            ingredients = json.loads(self.ingredients)
+            calculator = NutritionCalculator()
+            nutrition = calculator.calculate_nutrition(
+                ingredients, self.servings or 1
+            )
+
+            self.calories = int(nutrition.get("calories", 0))
+            self.protein = nutrition.get("protein")
+            self.fat = nutrition.get("fat")
+            self.carbohydrates = nutrition.get("carbohydrates")
+            self.fiber = nutrition.get("fiber")
+            self.save(
+                update_fields=[
+                    "calories",
+                    "protein",
+                    "fat",
+                    "carbohydrates",
+                    "fiber",
+                ]
+            )
+
+            return True
+        except Exception:
+            return False
 
     def scrobbles(self, user_id):
         Scrobble = apps.get_model("scrobbles", "Scrobble")

vrobbler/apps/foods/sources/rscraper.py

@@ -0,0 +1,190 @@
+import logging
+from typing import Dict, List, Optional
+from urllib.parse import urlparse
+
+import requests
+from django.core.files.base import ContentFile
+from foods.constants import EXCLUDED_FOOD_DOMAINS
+from recipe_scrapers import scrape_html
+from recipe_scrapers._exceptions import (
+    NoSchemaFoundInWildMode,
+    SchemaOrgException,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class RecipeScraperService:
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"User-Agent": "Mozilla/5.0 (compatible; Vrobbler/0.3)"}
+        )
+
+    def scrape(self, html: str, org_url: str) -> Dict:
+        """Scrape recipe data from HTML.
+
+        Args:
+            html: The HTML content of the page
+            org_url: The original URL the HTML was fetched from
+        """
+        try:
+            scraper = scrape_html(html, org_url=org_url, supported_only=False)
+        except Exception as e:
+            raise ValueError(f"Failed to scrape {org_url}: {str(e)}")
+
+        data_dict = {
+            "title": scraper.title(),
+            "ingredients": self._safe_call(scraper, "ingredients", []),
+            "instructions": self._safe_call(scraper, "instructions_list", []),
+            "yields": self._safe_call(scraper, "yields"),
+            "nutrition": self._safe_call(scraper, "nutrition"),
+            "course": self._safe_call(scraper, "course"),
+            "dietary": self._safe_call(scraper, "dietary", []),
+            "prep_time": self._safe_call(scraper, "prep_time"),
+            "total_time": self._safe_call(scraper, "total_time"),
+            "image": self._safe_call(scraper, "image"),
+            "cook_time": self._safe_call(scraper, "cook_time"),
+            "cuisine": self._safe_call(scraper, "cuisine"),
+            "site": self._safe_call(scraper, "host"),
+            "url": org_url,
+            "category": self._safe_call(scraper, "category"),
+            "keywords": self._safe_call(scraper, "keywords"),
+        }
+
+        return data_dict
+
+    def scrape_url(self, url: str):
+        response = self.session.get(url)
+        if response.status_code != 200:
+            raise Exception("Recipe website returned non 200 response")
+        return self.scrape(response.text, org_url=url)
+
+    @classmethod
+    def is_recipe(self, html: str, org_url: str) -> bool:
+        """Check if HTML contains a recipe.
+
+        Args:
+            html: The HTML content to check
+            org_url: The original URL the HTML was fetched from
+        """
+        try:
+            scraper = scrape_html(html, org_url=org_url, supported_only=False)
+            return scraper.schema is not None
+        except NoSchemaFoundInWildMode:
+            return False
+        except Exception:
+            return False
+
+    @classmethod
+    def is_recipe_url(cls, url: str) -> bool:
+        """Check if a URL points to a recipe by fetching and checking the HTML."""
+        domain = urlparse(url).netloc
+        if domain in EXCLUDED_FOOD_DOMAINS and "food" not in url:
+            logger.info("[food] domain found in EXCLUDED_FOOD_DOMAINS")
+            return False
+        try:
+            response = requests.get(
+                url,
+                timeout=10,
+                headers={
+                    "User-Agent": "Mozilla/5.0 (compatible; Vrobbler/0.3)"
+                },
+            )
+            if response.status_code != 200:
+                logger.debug("Recipe website returned non 200 response")
+                return False
+            return cls.is_recipe(response.text, url)
+        except Exception as e:
+            return False
+
+    def _safe_call(self, scraper, method, default=None):
+        """
+        Safely call a scraper method, returning default on error.
+        Handles both missing methods (AttributeError) and methods that return None.
+        """
+        try:
+            # Check if method exists before calling
+            if not hasattr(scraper, method):
+                return default
+
+            result = getattr(scraper, method)()
+            return result if result else default
+        except (
+            AttributeError,
+            TypeError,
+            KeyError,
+            ValueError,
+            SchemaOrgException,
+        ):
+            # AttributeError: method doesn't exist on this scraper class
+            # TypeError: method exists but can't be called
+            # KeyError: method exists but data structure is unexpected
+            return default
+
+    def download_image(self, image_url: str) -> Optional[ContentFile]:
+        """Download recipe image and return as Django ContentFile."""
+        if not image_url:
+            return None
+
+        try:
+            response = self.session.get(image_url, timeout=10)
+            response.raise_for_status()
+
+            filename = image_url.split("/")[-1].split("?")[0]
+            if not filename.endswith((".jpg", ".jpeg", ".png", ".webp")):
+                filename = "recipe_image.jpg"
+
+            return ContentFile(response.content, name=filename)
+        except Exception:
+            return None
+
+    def parse_servings(self, yield_text: str) -> Optional[int]:
+        """Extract number of servings from yield text."""
+        import re
+
+        if not yield_text:
+            return None
+
+        match = re.search(r"(\d+)", yield_text)
+        return int(match.group(1)) if match else None
+
+    def extract_tags(self, recipe_data: Dict) -> List[str]:
+        """Extract all tags from recipe metadata."""
+        tags = set()
+
+        # Add cuisine
+        if recipe_data.get("cuisine"):
+            cuisine = recipe_data["cuisine"]
+            if isinstance(cuisine, str):
+                tags.add(cuisine.strip())
+            elif isinstance(cuisine, list):
+                tags.update([c.strip() for c in cuisine if c])
+
+        # Add dietary
+        if recipe_data.get("dietary"):
+            dietary = recipe_data["dietary"]
+            if isinstance(dietary, str):
+                tags.add(dietary.strip())
+            elif isinstance(dietary, list):
+                tags.update([d.strip() for d in dietary if d])
+
+        # Add course
+        if recipe_data.get("course"):
+            course = recipe_data["course"]
+            if isinstance(course, str):
+                tags.add(course.strip())
+            elif isinstance(course, list):
+                tags.update([c.strip() for c in course if c])
+
+        # Add keywords
+        keywords = recipe_data.get("keywords")
+        if keywords:
+            if isinstance(keywords, str):
+                tags.update(
+                    [k.strip() for k in keywords.split(",") if k.strip()]
+                )
+            elif isinstance(keywords, list):
+                tags.update([k.strip() for k in keywords if k.strip()])
+
+        return list(tags)

vrobbler/apps/foods/sources/usda.py

@@ -0,0 +1,577 @@
+from django.conf import settings
+import requests
+from typing import Dict, List, Optional
+from functools import lru_cache
+from typing import List, Dict
+import re
+from fractions import Fraction
+
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class USDAFoodAPI:
+    BASE_URL = "https://api.nal.usda.gov/fdc/v1"
+
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key or getattr(settings, "USDA_API_KEY", None)
+        if not self.api_key:
+            raise ValueError(
+                "USDA API key not found. Set USDA_API_KEY in your Django settings."
+            )
+        self.session = requests.Session()
+
+    def _get_base_params(self) -> Dict:
+        """Return base parameters including the API key."""
+        return {"api_key": self.api_key}
+
+    @lru_cache(maxsize=100)
+    def search_foods(
+        self, query: str, page_size: int = 50, page_number: int = 1
+    ) -> List[Dict]:
+        """Search for food items by keyword."""
+        url = f"{self.BASE_URL}/foods/search"
+        params = {
+            **self._get_base_params(),
+            "query": query,
+            "pageSize": page_size,
+            "pageNumber": page_number,
+            "includeNutrientCodes": "203,204,205,208,269",
+        }
+        response = self.session.get(url, params=params)
+        response.raise_for_status()
+        data = response.json()
+        return data.get("foods", [])
+
+    def get_food_details(self, fdc_id: int) -> Dict:
+        """Retrieve detailed nutrient data for a specific food item."""
+        url = f"{self.BASE_URL}/food/{fdc_id}"
+        params = {
+            **self._get_base_params(),
+            "nutrients": [
+                203,
+                204,
+                205,
+                208,
+                269,
+            ],  # Protein, Fat, Carbs, Calories, Fiber
+        }
+        response = self.session.get(url, params=params)
+        response.raise_for_status()
+        return response.json()
+
+    def get_multiple_foods(self, fdc_ids: List[int]) -> List[Dict]:
+        """Retrieve details for multiple food items."""
+        url = f"{self.BASE_URL}/foods"
+        params = {
+            **self._get_base_params(),
+            "fdcIds": fdc_ids,
+            "nutrients": ["203", "204", "205", "208", "269"],
+        }
+        response = self.session.get(url, params=params)
+        response.raise_for_status()
+        return response.json().get("foods", [])
+
+    def extract_nutrients(self, food_data: Dict) -> Dict:
+        """Extract key nutrients into a clean dictionary."""
+        nutrients = {
+            "protein": 0,
+            "fat": 0,
+            "carbohydrates": 0,
+            "calories": 0,
+            "fiber": 0,
+            "sugar": 0,
+            "sodium": 0,
+        }
+        nutrient_map = {
+            "203": "protein",
+            "204": "fat",
+            "205": "carbohydrates",
+            "208": "calories",
+            "269": "fiber",
+            "2000": "sodium",
+            "269": "sugar",
+        }
+        food_nutrients = food_data.get("foodNutrients", [])
+
+        if not food_nutrients:
+            logger.warning(
+                f"No nutrients found for food: {food_data.get('description', 'unknown')}"
+            )
+            return nutrients
+
+        for nutrient in food_nutrients:
+            nutrient_id = None
+            value = None
+
+            if isinstance(nutrient, dict):
+                if "nutrientNumber" in nutrient:
+                    nutrient_id = str(nutrient.get("nutrientNumber", ""))
+                    value = nutrient.get("value")
+                elif "nutrient" in nutrient and isinstance(
+                    nutrient["nutrient"], dict
+                ):
+                    nutrient_id = str(
+                        nutrient.get("nutrient", {}).get("id", "")
+                    )
+                    value = nutrient.get("value")
+                elif "number" in nutrient:
+                    nutrient_id = str(nutrient.get("number", ""))
+                    value = nutrient.get("value")
+
+            if (
+                nutrient_id
+                and nutrient_id in nutrient_map
+                and value is not None
+            ):
+                key = nutrient_map[nutrient_id]
+                try:
+                    nutrients[key] = float(value)
+                except (TypeError, ValueError):
+                    pass
+
+        return nutrients
+
+    def get_food_summary(self, fdc_id: int) -> Dict:
+        """Return a simplified summary of a food item."""
+        details = self.get_food_details(fdc_id)
+        return {
+            "fdcId": details.get("fdcId"),
+            "description": details.get("description"),
+            "dataType": details.get("dataType"),
+            "brandOwner": details.get("brandOwner"),
+            "servingSize": details.get("servingSize"),
+            "servingSizeUnit": details.get("servingSizeUnit"),
+            "nutrients": self.extract_nutrients(details),
+        }
+
+
+class NutritionCalculator:
+    """Calculate recipe nutrition from ingredients using USDA API."""
+
+    # Common units to strip from ingredient names
+    UNITS = [
+        "cup",
+        "cups",
+        "c",
+        "tablespoon",
+        "tablespoons",
+        "tbsp",
+        "tb",
+        "t",
+        "teaspoon",
+        "teaspoons",
+        "tsp",
+        "ts",
+        "ounce",
+        "ounces",
+        "oz",
+        "fluid ounce",
+        "fluid ounces",
+        "fl oz",
+        "pound",
+        "pounds",
+        "lb",
+        "lbs",
+        "gram",
+        "grams",
+        "g",
+        "kilogram",
+        "kilograms",
+        "kg",
+        "milliliter",
+        "milliliters",
+        "ml",
+        "liter",
+        "liters",
+        "l",
+        "piece",
+        "pieces",
+        "whole",
+        "large",
+        "medium",
+        "small",
+        "can",
+        "cans",
+        "bottle",
+        "bottles",
+        "jar",
+        "jars",
+        "package",
+        "packages",
+        "pkg",
+        "box",
+        "boxes",
+        "slice",
+        "slices",
+        "clove",
+        "cloves",
+        "stick",
+        "sticks",
+        "pinch",
+        "dash",
+        "handful",
+        "bunch",
+        "sprig",
+        "sprigs",
+    ]
+
+    # Common modifiers to strip (don't affect nutrition much)
+    MODIFIERS = [
+        "all-purpose",
+        "all purpose",
+        "ap",
+        "bread",
+        "cake",
+        "self-rising",
+        "self rising",
+        "granulated",
+        "powdered",
+        "confectioners",
+        "brown",
+        "white",
+        "raw",
+        "extra virgin",
+        "virgin",
+        "light",
+        "dark",
+        "heavy",
+        "whipping",
+        "fresh",
+        "dried",
+        "frozen",
+        "canned",
+        "jarred",
+        "bottled",
+        "chopped",
+        "diced",
+        "minced",
+        "sliced",
+        "grated",
+        "shredded",
+        "crushed",
+        "melted",
+        "softened",
+        "room temperature",
+        "cold",
+        "warm",
+        "hot",
+        "packed",
+        "sifted",
+        "sieved",
+        "ground",
+        "whole",
+        "halved",
+        "quartered",
+        "peeled",
+        "unpeeled",
+        "seeded",
+        "pitted",
+        "cored",
+        "trimmed",
+        "optional",
+        "to taste",
+        "as needed",
+        "for garnish",
+        "for serving",
+    ]
+
+    def __init__(self):
+        self.usda = USDAFoodAPI()
+        self._unit_pattern = self._build_unit_pattern()
+
+    def _build_unit_pattern(self) -> re.Pattern:
+        """Build regex pattern for matching units."""
+        # Sort by length (longest first) to match "tablespoon" before "tbsp"
+        sorted_units = sorted(self.UNITS, key=len, reverse=True)
+        unit_str = "|".join(re.escape(u) for u in sorted_units)
+        return re.compile(rf"\b({unit_str})\b", re.IGNORECASE)
+
+    def parse_ingredient(self, ingredient_text: str) -> Dict:
+        """
+        Parse ingredient string into quantity, unit, and clean ingredient name.
+
+        Examples:
+            "2 cups all-purpose flour" → {qty: 2, unit: 'cups', name: 'flour'}
+            "1 1/2 tsp salt" → {qty: 1.5, unit: 'tsp', name: 'salt'}
+            "1/4 cup olive oil" → {qty: 0.25, unit: 'cup', name: 'olive oil'}
+            "3 large eggs" → {qty: 3, unit: 'large', name: 'eggs'}
+        """
+        text = ingredient_text.strip()
+
+        # Parse quantity (handles whole numbers, fractions, and mixed numbers)
+        quantity, remaining = self._parse_quantity(text)
+
+        # Parse unit from remaining text
+        unit, remaining = self._parse_unit(remaining)
+
+        # Clean the ingredient name
+        ingredient_name = self._clean_ingredient_name(remaining)
+
+        return {
+            "quantity": quantity,
+            "unit": unit,
+            "ingredient": ingredient_name,
+            "original": text,
+        }
+
+    def _parse_quantity(self, text: str) -> tuple:
+        """
+        Extract quantity from start of ingredient text.
+        Handles: "2", "1/2", "1 1/2", "0.5", etc.
+        """
+        text = text.strip()
+
+        # Pattern for mixed numbers: "1 1/2", "2 3/4"
+        mixed_pattern = r"^(\d+)\s+(\d+)/(\d+)"
+        mixed_match = re.match(mixed_pattern, text)
+        if mixed_match:
+            whole = int(mixed_match.group(1))
+            numerator = int(mixed_match.group(2))
+            denominator = int(mixed_match.group(3))
+            quantity = whole + (numerator / denominator)
+            remaining = text[mixed_match.end() :].strip()
+            return quantity, remaining
+
+        # Pattern for simple fractions: "1/2", "3/4"
+        fraction_pattern = r"^(\d+)/(\d+)"
+        fraction_match = re.match(fraction_pattern, text)
+        if fraction_match:
+            numerator = int(fraction_match.group(1))
+            denominator = int(fraction_match.group(2))
+            quantity = numerator / denominator
+            remaining = text[fraction_match.end() :].strip()
+            return quantity, remaining
+
+        # Pattern for decimals: "0.5", "1.5"
+        decimal_pattern = r"^(\d+\.?\d*)"
+        decimal_match = re.match(decimal_pattern, text)
+        if decimal_match:
+            quantity = float(decimal_match.group(1))
+            remaining = text[decimal_match.end() :].strip()
+            return quantity, remaining
+
+        # No quantity found
+        return 1, text
+
+    def _parse_unit(self, text: str) -> tuple:
+        """Extract unit from text."""
+        text = text.strip()
+
+        match = self._unit_pattern.match(text)
+        if match:
+            unit = match.group(1).lower()
+            remaining = text[match.end() :].strip()
+            return unit, remaining
+
+        return None, text
+
+    def _clean_ingredient_name(self, text: str) -> str:
+        """
+        Clean ingredient name for better USDA matching.
+        Removes modifiers, extra whitespace, and normalizes text.
+        """
+        text = text.strip()
+
+        # Remove parenthetical notes: "flour (sifted)" → "flour"
+        text = re.sub(r"\s*\([^)]*\)", "", text)
+
+        # Remove common modifiers
+        for modifier in sorted(self.MODIFIERS, key=len, reverse=True):
+            # Use word boundaries to avoid partial matches
+            pattern = rf"\b{re.escape(modifier)}\b"
+            text = re.sub(pattern, "", text, flags=re.IGNORECASE)
+
+        # Remove extra whitespace
+        text = re.sub(r"\s+", " ", text)
+
+        # Remove trailing punctuation
+        text = text.strip(" ,;:.")
+
+        # Remove leading "of" (e.g., "cup of flour" → "flour")
+        text = re.sub(r"^of\s+", "", text, flags=re.IGNORECASE)
+
+        return text.strip()
+
+    def _find_usda_match(self, ingredient_name: str) -> Optional[Dict]:
+        """
+        Find best USDA match for an ingredient name.
+        Tries multiple search strategies for better matching.
+        """
+        strategies = [
+            # Strategy 1: Direct search
+            ingredient_name,
+            # Strategy 2: Singular form (remove trailing 's')
+            (
+                ingredient_name.rstrip("s")
+                if ingredient_name.endswith("s")
+                else None
+            ),
+            # Strategy 3: Remove common suffixes
+            re.sub(
+                r"\s+(fresh|dried|ground|chopped|sliced)$",
+                "",
+                ingredient_name,
+                flags=re.IGNORECASE,
+            ),
+            # Strategy 4: Just the last word (sometimes works for simple ingredients)
+            (
+                ingredient_name.split()[-1]
+                if len(ingredient_name.split()) > 1
+                else None
+            ),
+        ]
+
+        for query in strategies:
+            if not query or len(query) < 2:
+                continue
+
+            try:
+                results = self.usda.search_foods(query, page_size=5)
+                if results:
+                    logger.debug(
+                        f"Found {query}: {results[0].get('description')}"
+                    )
+                    return results[0]
+            except Exception as e:
+                logger.warning(f"USDA search failed for '{query}': {e}")
+                continue
+
+        return None
+
+    def _convert_to_grams(
+        self, quantity: float, unit: str, ingredient_name: str
+    ) -> float:
+        """
+        Convert quantity to grams for more accurate nutrition calculation.
+        This is simplified - production code should use a proper conversion table.
+        """
+        # Base conversions (approximate)
+        volume_to_grams = {
+            "cup": 240,
+            "cups": 240,
+            "tablespoon": 15,
+            "tablespoons": 15,
+            "tbsp": 15,
+            "teaspoon": 5,
+            "teaspoons": 5,
+            "tsp": 5,
+            "ounce": 28,
+            "ounces": 28,
+            "oz": 28,
+            "pound": 454,
+            "pounds": 454,
+            "lb": 454,
+            "lbs": 454,
+            "gram": 1,
+            "grams": 1,
+            "g": 1,
+        }
+
+        # Get base weight in grams
+        base_grams = volume_to_grams.get(
+            unit, 100
+        )  # Default to 100g if unknown
+
+        # Adjust for ingredient type (very simplified)
+        if any(
+            word in ingredient_name.lower()
+            for word in ["flour", "sugar", "rice", "grain"]
+        ):
+            base_grams = volume_to_grams.get(unit, 125)  # Dry ingredients
+        elif any(
+            word in ingredient_name.lower()
+            for word in ["oil", "butter", "fat"]
+        ):
+            base_grams = volume_to_grams.get(unit, 220)  # Dense liquids
+        elif any(
+            word in ingredient_name.lower()
+            for word in ["milk", "water", "broth"]
+        ):
+            base_grams = volume_to_grams.get(unit, 240)  # Liquids
+
+        return quantity * base_grams
+
+    def calculate_nutrition(
+        self, ingredients: List[str], servings: int = 1
+    ) -> Dict:
+        """
+        Calculate total nutrition for a recipe from ingredient list.
+        Returns nutrition per serving.
+        """
+        totals = {
+            "calories": 0,
+            "protein": 0,
+            "fat": 0,
+            "carbohydrates": 0,
+            "fiber": 0,
+            "sugar": 0,
+            "sodium": 0,
+        }
+
+        matched_count = 0
+        unmatched = []
+
+        for ingredient in ingredients:
+            parsed = self.parse_ingredient(ingredient)
+
+            # Find USDA match
+            match = self._find_usda_match(
+                " ".join(
+                    [
+                        str(parsed["quantity"]),
+                        str(parsed["unit"]),
+                        str(parsed["ingredient"]),
+                    ]
+                )
+            )
+            if not match:
+                match = self._find_usda_match(parsed["ingredient"])
+
+            if match:
+                try:
+                    nutrients = self.usda.extract_nutrients(match)
+                    # Convert to grams for more accurate calculation
+                    grams = self._convert_to_grams(
+                        parsed["quantity"],
+                        parsed["unit"],
+                        parsed["ingredient"],
+                    )
+
+                    # USDA data is typically per 100g, so scale accordingly
+                    multiplier = grams / 100
+
+                    totals["calories"] += (
+                        nutrients.get("calories", 0) * multiplier
+                    )
+                    totals["protein"] += (
+                        nutrients.get("protein", 0) * multiplier
+                    )
+                    totals["fat"] += nutrients.get("fat", 0) * multiplier
+                    totals["carbohydrates"] += (
+                        nutrients.get("carbohydrates", 0) * multiplier
+                    )
+                    totals["fiber"] += nutrients.get("fiber", 0) * multiplier
+                    totals["sugar"] += nutrients.get("sugar", 0) * multiplier
+                    totals["sodium"] += nutrients.get("sodium", 0) * multiplier
+
+                    matched_count += 1
+
+                except Exception:
+                    unmatched.append(parsed["original"])
+            else:
+                unmatched.append(parsed["original"])
+
+        # Divide by servings for per-serving nutrition
+        if servings > 0:
+            for key in totals:
+                totals[key] = round(totals[key] / servings, 2)
+
+        # Add metadata
+        totals["_matched"] = matched_count
+        totals["_total"] = len(ingredients)
+        totals["_unmatched"] = unmatched
+
+        return totals

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/lifeevents/models.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 from django.apps import apps
 from django.db import models
 from django.urls import reverse

vrobbler/apps/lifeevents/views.py

@@ -1,12 +1,10 @@
-from django.views import generic
+from scrobbles.views import ScrobbleableDetailView, ScrobbleableListView
 from lifeevents.models import LifeEvent
 
 
-class LifeEventListView(generic.ListView):
+class LifeEventListView(ScrobbleableListView):
     model = LifeEvent
-    paginate_by = 20
 
 
-class LifeEventDetailView(generic.DetailView):
+class LifeEventDetailView(ScrobbleableDetailView):
     model = LifeEvent
-    slug_field = "uuid"

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,10 @@
+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/apps.py

@@ -3,4 +3,3 @@ from django.apps import AppConfig
 
 class LocationConfig(AppConfig):
     name = "locations"
-

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/locations/models.py

@@ -1,11 +1,13 @@
-from decimal import Decimal, getcontext
 import logging
+from dataclasses import dataclass
+from decimal import Decimal
 from typing import Dict
 
-from django.contrib.auth import get_user_model
 from django.conf import settings
+from django.contrib.auth import get_user_model
 from django.db import models
 from django.urls import reverse
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 
 logger = logging.getLogger(__name__)
@@ -16,6 +18,11 @@ GEOLOC_ACCURACY = int(getattr(settings, "GEOLOC_ACCURACY", 4))
 GEOLOC_PROXIMITY = Decimal(getattr(settings, "GEOLOC_PROXIMITY", "0.0001"))
 
 
+@dataclass
+class GeoLocationLogData(BaseLogData, WithPeopleLogData):
+    pass
+
+
 class GeoLocation(ScrobblableMixin):
     COMPLETION_PERCENT = getattr(settings, "LOCATION_COMPLETION_PERCENT", 100)
 
@@ -36,9 +43,13 @@ class GeoLocation(ScrobblableMixin):
 
     def get_absolute_url(self):
         return reverse(
-            "locations:geo_location_detail", kwargs={"slug": self.uuid}
+            "locations:geolocation_detail", kwargs={"slug": self.uuid}
         )
 
+    @property
+    def logdata_cls(self):
+        return GeoLocationLogData
+
     @classmethod
     def find_or_create(cls, data_dict: Dict) -> "GeoLocation":
         """Given a data dict from GPSLogger, does the heavy lifting of looking up

vrobbler/apps/locations/urls.py

@@ -8,11 +8,11 @@ urlpatterns = [
     path(
         "locations/",
         views.GeoLocationListView.as_view(),
-        name="geo_locations_list",
+        name="geolocation_list",
     ),
     path(
         "locations/<slug:slug>/",
         views.GeoLocationDetailView.as_view(),
-        name="geo_location_detail",
+        name="geolocation_detail",
     ),
 ]

vrobbler/apps/locations/views.py

@@ -9,7 +9,12 @@ class GeoLocationListView(generic.ListView):
     paginate_by = 75
 
     def get_queryset(self):
-        return super().get_queryset().filter(scrobble__user_id=self.request.user.id).order_by("-scrobble__timestamp")
+        return (
+            super()
+            .get_queryset()
+            .filter(scrobble__user_id=self.request.user.id)
+            .order_by("-scrobble__timestamp")
+        )
 
     def get_context_data(self, **kwargs):
         context_data = super().get_context_data(**kwargs)

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/moods/models.py

@@ -42,7 +42,7 @@ class Mood(ScrobblableMixin):
         return str(self.uuid)
 
     def get_absolute_url(self):
-        return reverse("moods:mood-detail", kwargs={"slug": self.uuid})
+        return reverse("moods:mood_detail", kwargs={"slug": self.uuid})
 
     @property
     def subtitle(self) -> str:

vrobbler/apps/moods/urls.py

@@ -5,10 +5,10 @@ app_name = "moods"
 
 
 urlpatterns = [
-    path("moods/", views.MoodListView.as_view(), name="mood-list"),
+    path("moods/", views.MoodListView.as_view(), name="mood_list"),
     path(
         "moods/<slug:slug>/",
         views.MoodDetailView.as_view(),
-        name="mood-detail",
+        name="mood_detail",
     ),
 ]

vrobbler/apps/music/aggregators.py

@@ -16,9 +16,7 @@ def scrobble_counts(user=None):
         now = now_user_timezone(user.profile)
         user_filter = Q(user=user)
 
-    start_of_today = datetime.combine(
+    start_of_today = datetime.combine(now.date(), datetime.min.time(), now.tzinfo)
-        now.date(), datetime.min.time(), now.tzinfo
-    )
     starting_day_of_current_week = now.date() - timedelta(
         days=now.today().isoweekday() % 7
     )
@@ -31,9 +29,7 @@ def scrobble_counts(user=None):
         media_type=Scrobble.MediaType.TRACK,
     )
     data = {}
-    data["today"] = finished_scrobbles_qs.filter(
+    data["today"] = finished_scrobbles_qs.filter(timestamp__gte=start_of_today).count()
-        timestamp__gte=start_of_today
-    ).count()
     data["week"] = finished_scrobbles_qs.filter(
         timestamp__gte=starting_day_of_current_week
     ).count()
@@ -47,9 +43,7 @@ def scrobble_counts(user=None):
     return data
 
 
-def week_of_scrobbles(
+def week_of_scrobbles(user=None, start=None, media: str = "tracks") -> dict[str, int]:
-    user=None, start=None, media: str = "tracks"
-) -> dict[str, int]:
 
     now = timezone.now()
     user_filter = Q()
@@ -89,6 +83,7 @@ def live_charts(
     media_type: str = "Track",
     chart_period: str = "all",
     limit: int = 15,
+    app_label: str = "music",
 ) -> QuerySet:
     now = timezone.now()
     tzinfo = now.tzinfo
@@ -100,13 +95,11 @@ def live_charts(
     seven_days_ago = now - timedelta(days=7)
     thirty_days_ago = now - timedelta(days=30)
     start_of_today = datetime.combine(now, datetime.min.time(), tzinfo)
-    start_day_of_week = start_of_today - timedelta(
+    start_day_of_week = start_of_today - timedelta(days=now.today().isoweekday() % 7)
-        days=now.today().isoweekday() % 7
-    )
     start_day_of_month = now.replace(day=1)
     start_day_of_year = now.replace(month=1, day=1)
 
-    media_model = apps.get_model(app_label="music", model_name=media_type)
+    media_model = apps.get_model(app_label=app_label, model_name=media_type)
 
     period_queries = {
         "today": {"scrobble__timestamp__gte": start_of_today},
@@ -119,17 +112,13 @@ def live_charts(
     }
 
     time_filter = Q()
-    completion_filter = Q(
+    completion_filter = Q(scrobble__user=user, scrobble__played_to_completion=True)
-        scrobble__user=user, scrobble__played_to_completion=True
-    )
     user_filter = Q(scrobble__user=user)
     count_field = "scrobble"
 
     if media_type == "Artist":
         for period, query_dict in period_queries.items():
-            period_queries[period] = {
+            period_queries[period] = {"track__" + k: v for k, v in query_dict.items()}
-                "track__" + k: v for k, v in query_dict.items()
-            }
         completion_filter = Q(
             track__scrobble__user=user,
             track__scrobble__played_to_completion=True,
@@ -154,3 +143,221 @@ def live_charts(
 
 def artist_scrobble_count(artist_id: int, filter: str = "today") -> int:
     return Scrobble.objects.filter(track__artist=artist_id).count()
+
+
+def live_tv_charts(
+    user: "User",
+    chart_period: str = "all",
+    limit: int = 15,
+) -> QuerySet:
+    from django.db.models import OuterRef, Subquery
+    from videos.models import Video, Series
+
+    now = timezone.now()
+    tzinfo = now.tzinfo
+    now = now.date()
+    if user.is_authenticated:
+        now = now_user_timezone(user.profile)
+        tzinfo = now.tzinfo
+
+    seven_days_ago = now - timedelta(days=7)
+    thirty_days_ago = now - timedelta(days=30)
+    start_of_today = datetime.combine(now, datetime.min.time(), tzinfo)
+    start_day_of_week = start_of_today - timedelta(days=now.today().isoweekday() % 7)
+    start_day_of_month = now.replace(day=1)
+    start_day_of_year = now.replace(month=1, day=1)
+
+    period_queries = {
+        "today": Q(timestamp__gte=start_of_today),
+        "week": Q(timestamp__gte=start_day_of_week),
+        "last7": Q(timestamp__gte=seven_days_ago),
+        "last30": Q(timestamp__gte=thirty_days_ago),
+        "month": Q(timestamp__gte=start_day_of_month),
+        "year": Q(timestamp__gte=start_day_of_year),
+        "all": Q(),
+    }
+
+    time_filter = period_queries[chart_period]
+    completion_filter = Q(
+        user=user,
+        played_to_completion=True,
+        video__video_type=Video.VideoType.TV_EPISODE,
+    )
+
+    scrobble_counts = (
+        Scrobble.objects.filter(
+            completion_filter,
+            time_filter,
+            video__tv_series=OuterRef("pk"),
+        )
+        .values("video__tv_series")
+        .annotate(c=Count("id"))
+        .values("c")
+    )
+
+    return (
+        Series.objects.annotate(num_scrobbles=Subquery(scrobble_counts))
+        .filter(num_scrobbles__gt=0)
+        .order_by("-num_scrobbles")[:limit]
+    )
+
+
+def live_youtube_channel_charts(
+    user: "User",
+    chart_period: str = "all",
+    limit: int = 15,
+) -> QuerySet:
+    from django.db.models import OuterRef, Subquery
+    from videos.models import Video, Channel
+
+    now = timezone.now()
+    tzinfo = now.tzinfo
+    now = now_user_timezone(user.profile)
+    tzinfo = now.tzinfo
+
+    seven_days_ago = now - timedelta(days=7)
+    thirty_days_ago = now - timedelta(days=30)
+    start_of_today = datetime.combine(now, datetime.min.time(), tzinfo)
+    start_day_of_week = start_of_today - timedelta(days=now.today().isoweekday() % 7)
+    start_day_of_year = now.replace(month=1, day=1)
+
+    period_queries = {
+        "today": Q(timestamp__gte=start_of_today),
+        "week": Q(timestamp__gte=start_day_of_week),
+        "last7": Q(timestamp__gte=seven_days_ago),
+        "last30": Q(timestamp__gte=thirty_days_ago),
+        "year": Q(timestamp__gte=start_day_of_year),
+        "all": Q(),
+    }
+
+    time_filter = period_queries[chart_period]
+    completion_filter = Q(
+        user=user,
+        played_to_completion=True,
+        video__video_type=Video.VideoType.YOUTUBE,
+    )
+
+    scrobble_counts = (
+        Scrobble.objects.filter(
+            completion_filter,
+            time_filter,
+            video__channel=OuterRef("pk"),
+        )
+        .values("video__channel")
+        .annotate(c=Count("id"))
+        .values("c")
+    )
+
+    return (
+        Channel.objects.annotate(num_scrobbles=Subquery(scrobble_counts))
+        .filter(num_scrobbles__gt=0)
+        .order_by("-num_scrobbles")[:limit]
+    )
+
+
+def batch_live_charts(
+    user: "User",
+    media_type: str = "Track",
+    limit: int = 15,
+    app_label: str = "music",
+) -> dict[str, list]:
+    from django.db.models import Count, Q
+
+    now = timezone.now()
+    tzinfo = now.tzinfo
+    now = now.date()
+    if user.is_authenticated:
+        now = now_user_timezone(user.profile)
+        tzinfo = now.tzinfo
+
+    seven_days_ago = now - timedelta(days=7)
+    thirty_days_ago = now - timedelta(days=30)
+    start_of_today = datetime.combine(now, datetime.min.time(), tzinfo)
+    start_day_of_year = now.replace(month=1, day=1)
+
+    media_model = apps.get_model(app_label=app_label, model_name=media_type)
+
+    if media_type == "Artist":
+        base_filter = Q(
+            track__scrobble__user=user, track__scrobble__played_to_completion=True
+        )
+        count_field = "track__scrobble"
+    else:
+        base_filter = Q(scrobble__user=user, scrobble__played_to_completion=True)
+        count_field = "scrobble"
+
+    scrobble_filter_prefix = (
+        "track__scrobble__" if media_type == "Artist" else "scrobble__"
+    )
+
+    queryset = media_model.objects.filter(
+        Q(track__scrobble__user=user)
+        if media_type == "Artist"
+        else Q(scrobble__user=user)
+    ).annotate(
+        num_scrobbles_today=Count(
+            count_field,
+            filter=Q(
+                **{
+                    f"{scrobble_filter_prefix}played_to_completion": True,
+                    f"{scrobble_filter_prefix}timestamp__gte": start_of_today,
+                }
+            ),
+            distinct=True,
+        ),
+        num_scrobbles_last7=Count(
+            count_field,
+            filter=Q(
+                **{
+                    f"{scrobble_filter_prefix}played_to_completion": True,
+                    f"{scrobble_filter_prefix}timestamp__gte": seven_days_ago,
+                }
+            ),
+            distinct=True,
+        ),
+        num_scrobbles_last30=Count(
+            count_field,
+            filter=Q(
+                **{
+                    f"{scrobble_filter_prefix}played_to_completion": True,
+                    f"{scrobble_filter_prefix}timestamp__gte": thirty_days_ago,
+                }
+            ),
+            distinct=True,
+        ),
+        num_scrobbles_year=Count(
+            count_field,
+            filter=Q(
+                **{
+                    f"{scrobble_filter_prefix}played_to_completion": True,
+                    f"{scrobble_filter_prefix}timestamp__gte": start_day_of_year,
+                }
+            ),
+            distinct=True,
+        ),
+        num_scrobbles=Count(
+            count_field,
+            filter=Q(
+                **{
+                    f"{scrobble_filter_prefix}played_to_completion": True,
+                }
+            ),
+            distinct=True,
+        ),
+    )
+
+    items = list(queryset)
+    for item in items:
+        item.count = item.num_scrobbles
+
+    def filter_by_count_attr(attr_name):
+        filtered = [item for item in items if getattr(item, attr_name) > 0]
+        return sorted(filtered, key=lambda x: -getattr(x, attr_name))[:limit]
+
+    return {
+        "today": filter_by_count_attr("num_scrobbles_today"),
+        "last7": filter_by_count_attr("num_scrobbles_last7"),
+        "last30": filter_by_count_attr("num_scrobbles_last30"),
+        "year": filter_by_count_attr("num_scrobbles_year"),
+        "all": filter_by_count_attr("num_scrobbles"),
+    }

vrobbler/apps/music/constants.py

@@ -90,6 +90,7 @@ JELLYFIN_POST_KEYS = {
     "TAGLINE": "TAGLINE",
     "PLAYBACK_POSITION_TICKS": "PlaybackPositionTicks",
     "PLAYBACK_POSITION": "PlaybackPosition",
+    "MEDIA_SOURCE_ID": "MediaSourceId",
     "ARTIST_MB_ID": "Provider_musicbrainzartist",
     "ALBUM_MB_ID": "Provider_musicbrainzalbum",
     "RELEASEGROUP_MB_ID": "Provider_musicbrainzreleasegroup",

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

@@ -1,5 +1,6 @@
 import logging
-from typing import Dict, Optional
+from dataclasses import dataclass
+from typing import Optional
 from uuid import uuid4
 
 import musicbrainzngs
@@ -15,24 +16,26 @@ from imagekit.processors import ResizeToFit
 from music.allmusic import get_allmusic_slug, scrape_data_from_allmusic
 from music.bandcamp import get_bandcamp_slug
 from music.musicbrainz import (
-    get_album_metadata,
     get_album_metadata_with_artist,
-    get_artist_metadata_extended,
     get_recording_mbid_exact,
     get_track_metadata_with_artist,
-    lookup_album_dict_from_mb,
-    lookup_album_from_mb,
-    lookup_track_from_mb,
-    lookup_artist_from_mb,
 )
 from music.theaudiodb import lookup_album_from_tadb, lookup_artist_from_tadb
 from music.utils import clean_artist_name
+from scrobbles.dataclasses import BaseLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 
 logger = logging.getLogger(__name__)
 BNULL = {"blank": True, "null": True}
 
 
+@dataclass
+class TrackLogData(BaseLogData):
+    mopidy_source: Optional[str] = None
+    rockbox_info: Optional[str] = None
+    rating: Optional[int] = None
+
+
 class Artist(TimeStampedModel):
     """Represents a music artist.
 
@@ -529,13 +532,15 @@ class Album(TimeStampedModel):
             logger.info(
                 f"Could not find album {name} with artist {artist.name} on musicbrainz"
             )
-            album, created = Album.objects.get_or_create(
+            album = Album.objects.filter(name=name).first()
-                name=name,
+            if not album:
-            )
+                album, created = Album.objects.get_or_create(
-            if created:
+                    name=name,
-                # album.fix_metadata()
+                )
-                # album.fetch_artwork()
+                if created:
-                ...
+                    # album.fix_metadata()
+                    # album.fetch_artwork()
+                    ...
             return album
 
         if not artist:
@@ -568,7 +573,7 @@ class Album(TimeStampedModel):
             alt_name = name
 
         album = Album.objects.filter(
-            name=found_name, musicbrainz_id=album_dict.get("mbid")
+            musicbrainz_id=album_dict.get("mbid")
         ).first()
 
         if not album:
@@ -605,6 +610,9 @@ class Track(ScrobblableMixin):
     def __str__(self):
         return f"{self.title} by {self.artist}"
 
+    def logdata_cls(self):
+        return TrackLogData()
+
     @property
     def primary_album(self):
         if self.album:
@@ -669,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:
@@ -691,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={
@@ -707,7 +715,9 @@ 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/music/utils.py

@@ -10,11 +10,11 @@ logger = logging.getLogger(__name__)
 def clean_artist_name(name: str) -> str:
     """Remove featured names from artist string."""
     if " feat. " in name.lower():
-        name = re.split("feat.", name, flags=re.IGNORECASE)[0].strip()
+        name = re.split(" feat. ", name, flags=re.IGNORECASE)[0].strip()
     if " w. " in name.lower():
-        name = re.split("feat.", name, flags=re.IGNORECASE)[0].strip()
+        name = re.split(" w. ", name, flags=re.IGNORECASE)[0].strip()
     if " featuring " in name.lower():
-        name = re.split("featuring", name, flags=re.IGNORECASE)[0].strip()
+        name = re.split(" featuring ", name, flags=re.IGNORECASE)[0].strip()
     # if " & " in name.lower() and "of the wand" not in name.lower():
     #    name = re.split("&", name, flags=re.IGNORECASE)[0].strip()
 

vrobbler/apps/people/admin.py

@@ -1,5 +1,5 @@
 from django.contrib import admin
-from people.models import Person
+from people.models import Person, PersonScrobble
 
 
 @admin.register(Person)
@@ -8,3 +8,11 @@ class PersonAdmin(admin.ModelAdmin):
     list_display = ("name", "bgg_username", "bgstats_id")
     ordering = ("-created",)
     search_fields = ("name",)
+
+
+@admin.register(PersonScrobble)
+class PersonScrobbleAdmin(admin.ModelAdmin):
+    list_display = ("person", "user", "scrobble", "created")
+    list_filter = ("created",)
+    ordering = ("-created",)
+    raw_id_fields = ("person", "user", "scrobble")

vrobbler/apps/people/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class PeopleConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "people"
+
+    def ready(self):
+        import people.signals  # noqa

vrobbler/apps/people/management/commands/backfill_scrobble_counts.py

@@ -0,0 +1,24 @@
+from django.core.management.base import BaseCommand
+
+from people.models import PersonScrobble
+from people.signals import get_person_ids_from_log
+from scrobbles.models import Scrobble
+
+
+class Command(BaseCommand):
+    help = "Backfill PersonScrobble junction table from existing scrobbles"
+
+    def handle(self, *args, **options):
+        count = 0
+        for scrobble in Scrobble.objects.all():
+            person_ids = get_person_ids_from_log(scrobble.log)
+            for person_id in person_ids:
+                obj, created = PersonScrobble.objects.get_or_create(
+                    person_id=person_id,
+                    user=scrobble.user,
+                    scrobble=scrobble,
+                )
+                if created:
+                    count += 1
+        self.stdout.write(f"Created {count} PersonScrobble records")
+        self.stdout.write(self.style.SUCCESS("Done!"))