[release] Update project log for 37

Ultimately these should probably be templated

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,85 +92,8 @@ fetching and simple saving.
 :LOGBOOK:
 CLOCK: [2025-07-09 Wed 09:55]--[2025-07-09 Wed 10:15] =>  0:20
 :END:
-* Backlog [4/27]
+* Backlog [0/19]
-** STRT Only create a LastFM import if there are files to import :vrobbler:feature:lastfm:importers:project:personal:
+** TODO [#C] Create small utility to clean up tracks scrobbled with wonky playback times :vrobbler:personal:bug:music:scrobbles:
-:PROPERTIES:
-:ID:       7a1456af-c5f1-6385-b34f-0be24a6b65b0
-:END:
-- 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.
-** TODO Add timezone awarness to IMAP importer :personal:project:vrobbler:feature:importer:imap:timezones:
-** DONE Track timezone changes for profiles :vrobbler:feature:profiles:personal:project:
-:PROPERTIES:
-:ID:       89ec867f-29fd-82f1-be17-b49dddc30c78
-:END:
-[2025-07-11 14:23]
-** TODO [#A] Add classmethod for metadata fetching to tracks :vrobbler:feature:music:personal:project:
-: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
@@ -456,6 +392,323 @@ 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:
+** TODO [#B] Add importer class for IMAP imports :vrobbler:feature:imap:importers:project:personal:
+** TODO [#B] Clean up follow up notifications for board games and beer that ask if you're still scrobbling :vrobbler:personal:project:beers:boardgames:notifications:feature:
+
+- 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
+
+** 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] Fix raw text webpage title not truncating to 254 chars :vrobbler:personal:bug:webpages:
+
+- Note taken on [2025-09-30 Tue 09:33]
+
+  This may have already been resolved ... need to just confirm it.
+** TODO [#A] Find page numbers for comic books from ComicVine :vrobbler:feature:books:personal:project:
+** TODO [#A] Fix koreader scrobble imports to use DST properly :vrobbler:personal:bug:books:imports:
+
+- Note taken on [2025-09-25 Thu 10:37] \\
+
+  This may already be fixed ... need to check.
+
+- Note taken on [2025-02-25 12:34] \\
+
+  The page data has the canonical date something was read in it, but it seems
+  to be an hour off. I traced this back to being off during DST, so we just need
+  the importer to be aware of whether a user is using DST or not and roll back
+  an hour for part of the year. Also, we'd need to adjust any old scrobbles that
+  took place with DST off to roll them back by an hour.
+
+* Version 37.0 [4/4]
+** DONE [#A] Tasks from org-mode should properly update notes and leave them out of the body :vrobbler:bug:tasks:
+:PROPERTIES:
+:ID:       c8410001-dbb7-1536-bd89-9784189e058f
+:END:
+** DONE [#A] Allow scrobbling from the Food list page's start links :vrobbler:bug:food:scrobbling:personal:project:
+:PROPERTIES:
+:ID:       00f99f60-ac00-6cde-311d-c31f41a01353
+:END:
+https://life.lab.unbl.ink/scrobble/e39779c8-62a5-46a6-bdef-fb7662810dc6/start/
+** DONE [#B] Food scrobbles should inherit calories from obj if missing :vrobbler:feature:food:personal:project:
+:PROPERTIES:
+:ID:       3322ff69-4252-db65-36b3-fae56c1b9327
+:END:
+** DONE [#A] Puzzles (and all longplays) should have a "Completed?" column on their detail page :vrobbler:bug:puzzles:personal:project:
+:PROPERTIES:
+:ID:       e3e49a9a-67d2-8ad8-1114-6f05effee9b7
+:END:
+* Version 36.0 [1/1]
+** DONE [#A] Refactor how videos are scrobbled :vrobbler:vidoes:feature:personal:project:
+:PROPERTIES:
+:ID:       6034a11d-5376-994d-9a4b-e1640e258cfa
+:END:
+* Version 35.0 [3/3]
+** DONE [#B] Add youtube link in place of IMDB on video detail page :vrobbler:feature:videos:personal:project:
+:PROPERTIES:
+:ID:       84064bd6-2258-a4de-f048-b131db9465c9
+:END:
+** DONE [#B] Add missing API lookups to resolve broken scrobbles endpoint :vrobbler:feature:api:scrobbles:personal:project:
+:PROPERTIES:
+:ID:       0f668a54-f587-3b17-353e-3a56969d3a82
+:END:
+** DONE [#A] IMDB lookups are not working :vrobbler:bug:videos:personal:project:
+:PROPERTIES:
+:ID:       d1ba1ca1-509b-13a9-1307-b2dc94a2eafe
+:END:
+* Version 34.0 [4/4]
+** DONE [#A] Use bgg-api for BoardGameGeek lookups :vrobbler:feature:boardgames:personal:project:
+:PROPERTIES:
+:ID:       738abb5a-c796-b16b-fe10-6e5639a0e10d
+:END:
+** DONE [#A] Add classmethod for metadata fetching to tracks :vrobbler:feature:music:personal:project:
+:PROPERTIES:
+:ID:       bc4b45e5-4c65-13c5-ab7b-1937d3fbf5c2
+:END:
+
+- 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 [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 [2/2]
+** DONE Track timezone changes for profiles :vrobbler:feature:profiles:personal:project:
+:PROPERTIES:
+:ID:       89ec867f-29fd-82f1-be17-b49dddc30c78
+:END:
+[2025-07-11 14:23]
+** DONE Only create a LastFM import if there are files to import :vrobbler:feature:lastfm:importers:project:personal:
+:PROPERTIES:
+:ID:       7a1456af-c5f1-6385-b34f-0be24a6b65b0
+:END:
+- 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 [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 [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
+:END:
 ** DONE Import from BG stats a "learning" log field when "Learning to play" is in the comment :vrobbler:feature:boardgames:project:personal:
 :PROPERTIES:
 :ID:       fda59fab-4349-e99e-54c6-9f1392a1c474
@@ -572,7 +825,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
@@ -635,7 +888,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
@@ -740,7 +993,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:

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,9 @@ 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"
 
 [tool.poetry.group.test]
 optional = true

tests/boardgames_tests/test_bgg.py

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

tests/scrobbles_tests/conftest.py

@@ -7,23 +7,24 @@ from rest_framework.authtoken.models import Token
 from boardgames.models import BoardGame
 from music.models import Track, Artist
 from scrobbles.models import Scrobble
+from people.models import Person
 
 User = get_user_model()
 
 
 @pytest.fixture
 def boardgame_scrobble():
-    user = User.objects.create(
+    first = Person.objects.create(name="First Player")
-        email="test@exmaple.com", first_name="Test", last_name="User"
+    second = Person.objects.create(name="Second Player")
-    )
     return Scrobble.objects.create(
         board_game=BoardGame.objects.create(title="Test Board Game"),
         media_type="BoardGame",
         played_to_completion=True,
         log={
             "players": [
-                {"user_id": user.id, "win": True, "score": 30, "color": "Blue"}
+                {"person_id": first.id, "win": True, "score": 30, "color": "Blue"},
-            ]
+                {"person_id": second.id, "win": False, "score": 28, "color": "Red"}
+            ],
         },
     )
 
@@ -33,7 +34,7 @@ def test_track():
     Track.objects.create(
         title="Emotion",
         artist=Artist.objects.create(name="Carly Rae Jepsen"),
-        run_time_seconds=60,
+        base_run_time_seconds=60,
     )
 
 
@@ -114,6 +115,12 @@ def mopidy_podcast_request_data():
         mopidy_uri=mopidy_uri, artist="NPR", album="Up First"
     ).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"

tests/scrobbles_tests/test_metadata.py

@@ -1,16 +1,15 @@
 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")
 @pytest.mark.django_db
 def test_boardgame_log_data(boardgame_scrobble):
-    assert not boardgame_scrobble.geo_location
     assert boardgame_scrobble.logdata == BoardGameLogData(
         players=[
             BoardGameScoreLogData(
-                user_id=1,
+                person_id=1,
-                name_str="",
                 bgg_username="",
                 color="Blue",
                 character=None,
@@ -18,10 +17,24 @@ def test_boardgame_log_data(boardgame_scrobble):
                 score=30,
                 win=True,
                 new=None,
-            )
+                rank=None,
+                seat_order=None,
+                role=None
+            ),
+            BoardGameScoreLogData(
+                person_id=2,
+                bgg_username="",
+                color="Red",
+                character=None,
+                team=None,
+                score=28,
+                win=False,
+                new=None,
+                rank=None,
+                seat_order=None,
+                role=None
+            ),
         ],
-        location=None,
-        geo_location_id=None,
         difficulty=None,
         solo=None,
         two_handed=None,

tests/videos_tests/test_imdb.py

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

vrobbler/apps/beers/api/serializers.py

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

vrobbler/apps/beers/api/views.py

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

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

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

vrobbler/apps/beers/models.py

@@ -1,18 +1,25 @@
+from dataclasses import dataclass
+from typing import Optional
 from uuid import uuid4
 
-from beers.untappd import get_beer_from_untappd_id, get_rating_from_soup
+from beers.untappd import get_beer_from_untappd_id
 from django.apps import apps
 from django.db import models
 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 BeerLogData
+from scrobbles.dataclasses import BaseLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 
 BNULL = {"blank": True, "null": True}
 
 
+@dataclass
+class BeerLogData(BaseLogData):
+    rating: Optional[str] = None
+
+
 class BeerStyle(TimeStampedModel):
     uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
     name = models.CharField(max_length=255)

vrobbler/apps/boardgames/api/serializers.py

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

vrobbler/apps/boardgames/api/views.py

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

vrobbler/apps/boardgames/bgg.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Optional
 import requests
 from bs4 import BeautifulSoup
 from django.contrib.auth import get_user_model
+from django.conf import settings
 
 User = get_user_model()
 if TYPE_CHECKING:
@@ -17,6 +18,8 @@ SEARCH_ID_URL = (
     "https://boardgamegeek.com/xmlapi/search?search={query}&exact=1"
 )
 GAME_ID_URL = "https://boardgamegeek.com/xmlapi/boardgame/{id}"
+BGG_ACCESS_TOKEN = getattr(settings, "BGG_ACCESS_TOKEN", "")
+BASE_HEADERS = {"User-Agent": "Vrobbler 31.0", "Authorization": f"Bearer {BGG_ACCESS_TOKEN}"}
 
 
 def take_first(thing: Optional[list]) -> str:
@@ -37,10 +40,9 @@ def take_first(thing: Optional[list]) -> str:
 
 def lookup_boardgame_id_from_bgg(title: str) -> Optional[int]:
     soup = None
-    headers = {"User-Agent": "Vrobbler 0.11.12"}
     game_id = None
     url = SEARCH_ID_URL.format(query=title)
-    r = requests.get(url, headers=headers)
+    r = requests.get(url, headers=BASE_HEADERS)
     if r.status_code == 200:
         soup = BeautifulSoup(r.text, "xml")
 
@@ -57,7 +59,6 @@ def lookup_boardgame_id_from_bgg(title: str) -> Optional[int]:
 def lookup_boardgame_from_bgg(lookup_id: str) -> dict:
     soup = None
     game_dict = {}
-    headers = {"User-Agent": "Vrobbler 0.11.12"}
 
     title = ""
     bgg_id = None
@@ -73,7 +74,7 @@ def lookup_boardgame_from_bgg(lookup_id: str) -> dict:
         bgg_id = lookup_boardgame_id_from_bgg(title)
 
     url = GAME_ID_URL.format(id=bgg_id)
-    r = requests.get(url, headers=headers)
+    r = requests.get(url, headers=BASE_HEADERS)
     if r.status_code == 200:
         soup = BeautifulSoup(r.text, "xml")
 
@@ -109,7 +110,8 @@ def push_scrobble_to_bgg(scrobble: "Scrobble", user: User) -> Optional[bool]:
     login_payload = {
         "credentials": {"username": bgg_username, "password": bgg_password}
     }
-    headers = {"content-type": "application/json"}
+    headers = BASE_HEADERS
+    headers["content-type"] = "application/json"
 
     # TODO Look up past plays for scrobble.media_obj.bggeek_id, and make sure we haven't scrobbled this before
 
@@ -119,8 +121,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 +153,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,10 +1,13 @@
+from functools import cached_property
 import logging
+from dataclasses import dataclass
 from datetime import datetime
-from typing import Optional
+from typing import Optional, Any
 from uuid import uuid4
 
+from django import forms
 import requests
-from boardgames.bgg import lookup_boardgame_from_bgg
+from boardgames.sources.bgg import lookup_boardgame_from_bgg
 from django.conf import settings
 from django.core.files.base import ContentFile
 from django.db import models
@@ -12,14 +15,115 @@ 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 BoardGameLogData
-from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 from locations.models import GeoLocation
+from people.models import Person
+from scrobbles.dataclasses import BaseLogData, LongPlayLogData
+from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 
 logger = logging.getLogger(__name__)
 BNULL = {"blank": True, "null": True}
 
 
+@dataclass
+class BoardGameScoreLogData(BaseLogData):
+    person_id: Optional[int] = None
+    bgg_username: Optional[str] = None
+    color: Optional[str] = None
+    character: Optional[str] = None
+    team: Optional[str] = None
+    score: Optional[int] = None
+    win: Optional[bool] = None
+    new: Optional[bool] = None
+    rank: Optional[int] = None
+    seat_order: Optional[int] = None
+    role: Optional[str] = None
+    rank: Optional[int] = None
+    seat_order: Optional[int] = None
+    role: Optional[str] = None
+    lichess_username: Optional[str] = None
+
+    @property
+    def person(self) -> Optional[Person]:
+        return Person.objects.filter(id=self.person_id).first()
+
+    @property
+    def name(self) -> str:
+        name = ""
+        if self.person:
+            name = self.person.name
+        return name
+
+    def __str__(self) -> str:
+        out = self.name
+        if self.score:
+            out += f" {self.score}"
+        if self.color:
+            out += f" ({self.color})"
+        if self.win:
+            out += f" [W]"
+        return out
+
+
+@dataclass
+class BoardGameLogData(BaseLogData, LongPlayLogData):
+    players: Optional[list[BoardGameScoreLogData]] = None
+    location_id: Optional[int] = None
+    difficulty: Optional[int] = None
+    solo: Optional[bool] = None
+    two_handed: Optional[bool] = None
+    expansion_ids: Optional[int] = None
+    moves: Optional[list] = None
+    rated: Optional[str] = None
+    speed: Optional[str] = None
+    variant: Optional[str] = None
+    lichess_id: Optional[int] = None
+    board: Optional[str] = None
+    rounds: Optional[int] = None
+    details: Optional[str] = None
+
+    _excluded_fields = {
+        "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:
+        if self.players:
+            return ", ".join(
+                [
+                    BoardGameScoreLogData(**player).__str__()
+                    for player in self.players
+                ]
+            )
+        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)
     uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
@@ -87,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",
@@ -120,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)
@@ -197,29 +306,58 @@ class BoardGame(ScrobblableMixin):
 
             # Go get cover image if the URL is present
             if cover_url and not self.cover:
-                headers = {"User-Agent": "Vrobbler 0.11.12"}
+                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 data or not boardgame:
+        if game:
-            data = lookup_boardgame_from_bgg(lookup_id)
+            logger.info("Board game exists in database.", extra={"lookup_id": lookup_id, "data": data})
+            return game
 
-        if data and not boardgame:
+        bgg_data = lookup_boardgame_from_bgg(data.get("name"))
-            boardgame, created = cls.objects.get_or_create(
-                title=data["title"], bggeek_id=lookup_id
-            )
-            if created:
-                boardgame.fix_metadata(data=data)
 
-        return boardgame
+        mechanics = bgg_data.pop("mechanics", [])
+        designers = bgg_data.pop("designers", [])
+        categories = bgg_data.pop("categories", [])
+        publishers = bgg_data.pop("publishers", [])
+        cover_url = bgg_data.pop("cover_url")
+
+        game = cls.objects.create(
+            **bgg_data
+        )
+
+        game.save_image_from_url(cover_url)
+        game.cooperative = data.get("cooperative", False)
+        game.highest_wins = data.get("highestWins", True)
+        game.no_points = data.get("noPoints", False)
+        game.uses_teams = data.get("useTeams", False)
+        game.bgstats_id = data.get("uuid", None)
+        game.save()
+
+        if designers:
+            for designer_name in designers:
+                designer, created = BoardGameDesigner.objects.get_or_create(
+                    name=designer_name
+                )
+                game.designers.add(designer.id)
+
+        if publishers:
+            for name in publishers:
+                publisher, _ = BoardGamePublisher.objects.get_or_create(
+                    name=name
+                )
+                game.publishers.add(publisher)
+
+        return game

vrobbler/apps/boardgames/sources/bgg.py

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

vrobbler/apps/boardgames/sources/lichess.py

@@ -3,7 +3,7 @@ from boardgames.models import BoardGame
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from scrobbles.models import Scrobble
-from scrobbles.notifications import NtfyNotification
+from scrobbles.notifications import ScrobbleNtfyNotification
 
 User = get_user_model()
 
@@ -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"),
@@ -124,5 +124,5 @@ def import_chess_games_for_all_users():
     if scrobbles_to_create:
         created = Scrobble.objects.bulk_create(scrobbles_to_create)
         for scrobble in created:
-            NtfyNotification(scrobble).send()
+            ScrobbleNtfyNotification(scrobble).send()
     return scrobbles_to_create

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

@@ -3,16 +3,14 @@ import re
 import sqlite3
 from datetime import datetime, timedelta
 from enum import Enum
-
-import pendulum
 from zoneinfo import ZoneInfo
+
 import requests
 from books.constants import BOOKS_TITLES_TO_IGNORE
 from django.apps import apps
 from django.contrib.auth import get_user_model
+from scrobbles.notifications import ScrobbleNtfyNotification
 from stream_sqlite import stream_sqlite
-from scrobbles.notifications import NtfyNotification
-from vrobbler.apps.profiles.utils import one_off_fix_colins_profile
 from webdav.client import get_webdav_client
 
 logger = logging.getLogger(__name__)
@@ -116,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()
@@ -287,17 +285,12 @@ def build_scrobbles_from_book_map(
                     datetime.fromtimestamp(int(last_page.get("end_ts")))
                 )
 
-                if user.id == 1 and not user.profile.timezone_change_log:
-                    one_off_fix_colins_profile(user.profile)
-
                 # 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,
@@ -414,7 +407,7 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:
     if new_scrobbles:
         created = Scrobble.objects.bulk_create(new_scrobbles)
         if created:
-            NtfyNotification(created[-1]).send()
+            ScrobbleNtfyNotification(created[-1]).send()
         fix_long_play_stats_for_scrobbles(created)
         logger.info(
             f"Created {len(created)} scrobbles",

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

@@ -1,13 +1,19 @@
-from collections import OrderedDict
 import logging
-from datetime import timedelta, datetime
+from collections import OrderedDict
+from dataclasses import dataclass
+from datetime import 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
@@ -16,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 vrobbler.apps.books.sources.google import lookup_book_from_google
+from vrobbler.apps.books.sources.comicvine import (
-from vrobbler.apps.books.sources.semantic import lookup_paper_from_semantic
+    ComicVineClient,
-from vrobbler.apps.scrobbles.dataclasses import BookLogData
+    lookup_comic_from_comicvine,
+)
 
 COMICVINE_API_KEY = getattr(settings, "COMICVINE_API_KEY", "")
 
@@ -46,6 +49,34 @@ User = get_user_model()
 BNULL = {"blank": True, "null": True}
 
 
+@dataclass
+class BookPageLogData(BaseLogData):
+    page_number: Optional[int] = None
+    end_ts: Optional[int] = None
+    start_ts: Optional[int] = None
+    duration: Optional[int] = None
+
+
+@dataclass
+class BookLogData(BaseLogData, LongPlayLogData):
+    koreader_hash: Optional[str] = None
+    page_data: Optional[dict[int, BookPageLogData]] = None
+    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):
     name = models.CharField(max_length=255)
     uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
@@ -107,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)
@@ -117,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(
@@ -135,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
@@ -161,7 +204,45 @@ class Book(LongPlayScrobblableMixin):
         return reverse("books:book_detail", kwargs={"slug": self.uuid})
 
     @classmethod
-    def find_or_create(cls, title: str, enrich: bool = False, commit: bool = True):
+    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, url: str = "", enrich: bool = False, commit: bool = True
+    ):
         """Given a title, get a Book instance.
 
         If the book is not already in our database, or overwrite is True,
@@ -171,23 +252,35 @@ 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})
+            logger.info(
+                "Found exact match for book by title", extra={"title": title}
+            )
 
         if not enrich:
-            logger.info("Found book by title, but not enriching", extra={"title": title})
+            logger.info(
+                "Found book by title, but not enriching",
+                extra={"title": title},
+            )
             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:
@@ -213,7 +306,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"
@@ -309,7 +402,7 @@ class Book(LongPlayScrobblableMixin):
                     self.cover.save(fname, ContentFile(r.content), save=True)
 
             if self.pages:
-                self.run_time_seconds = int(self.pages) * int(
+                self.base_run_time_seconds = int(self.pages) * int(
                     self.AVG_PAGE_READING_SECONDS
                 )
 

vrobbler/apps/books/sources/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

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

vrobbler/apps/books/utils.py

@@ -0,0 +1,59 @@
+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,15 +1,25 @@
-from django.apps import apps
+from dataclasses import dataclass
+
 from django.db import models
 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 BrickSetLogData
 from scrobbles.mixins import LongPlayScrobblableMixin
 
+from vrobbler.apps.scrobbles.dataclasses import (
+    BaseLogData,
+    LongPlayLogData,
+    WithPeopleLogData,
+)
+
 BNULL = {"blank": True, "null": True}
 
 
+@dataclass
+class BrickSetLogData(BaseLogData, WithPeopleLogData, LongPlayLogData):
+    pass
+
+
 class BrickSet(LongPlayScrobblableMixin):
     """"""
 

vrobbler/apps/foods/api/serializers.py

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

vrobbler/apps/foods/api/views.py

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

vrobbler/apps/foods/migrations/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/models.py

@@ -1,3 +1,5 @@
+from dataclasses import dataclass
+from typing import Optional
 from uuid import uuid4
 
 from django.apps import apps
@@ -6,12 +8,18 @@ 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 FoodLogData
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 
 BNULL = {"blank": True, "null": True}
 
 
+@dataclass
+class FoodLogData(BaseLogData, WithPeopleLogData):
+    calories: Optional[int] = None
+    meal: Optional[str] = None
+
+
 class FoodCategory(TimeStampedModel):
     uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
     name = models.CharField(max_length=255)
@@ -40,6 +48,7 @@ class FoodCategory(TimeStampedModel):
 
 class Food(ScrobblableMixin):
     description = models.TextField(**BNULL)
+    calories = models.IntegerField(**BNULL)
     allrecipe_image = models.ImageField(upload_to="food/recipe/", **BNULL)
     allrecipe_image_small = ImageSpecField(
         source="allrecipe_image",
@@ -64,7 +73,8 @@ class Food(ScrobblableMixin):
 
     @property
     def subtitle(self):
-        return self.category.name
+        if self.category:
+            return self.category.name
 
     @property
     def strings(self) -> ScrobblableConstants:

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,12 +1,18 @@
+from dataclasses import dataclass
 from django.apps import apps
 from django.db import models
 from django.urls import reverse
-from scrobbles.dataclasses import LifeEventLogData
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 
 BNULL = {"blank": True, "null": True}
 
 
+@dataclass
+class LifeEventLogData(BaseLogData, WithPeopleLogData):
+    pass
+
+
 class LifeEvent(ScrobblableMixin):
     description = models.TextField(**BNULL)
 

vrobbler/apps/locations/api/serializers.py

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

vrobbler/apps/locations/api/views.py

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

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

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

vrobbler/apps/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__)
@@ -15,6 +17,9 @@ User = get_user_model()
 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 +41,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/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

@@ -1,19 +1,25 @@
 import logging
+from dataclasses import dataclass
+from typing import Optional
 
 from django.contrib.auth import get_user_model
 from django.db import models
 from django.urls import reverse
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
+from scrobbles.dataclasses import BaseLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 
-from vrobbler.apps.scrobbles.dataclasses import MoodLogData
-
 logger = logging.getLogger(__name__)
 BNULL = {"blank": True, "null": True}
 User = get_user_model()
 
 
+@dataclass
+class MoodLogData(BaseLogData):
+    reasons: Optional[str] = None
+
+
 class Mood(ScrobblableMixin):
     description = models.TextField(**BNULL)
     image = models.ImageField(upload_to="moods/", **BNULL)
@@ -36,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/migrations/0028_alter_track_albums.py

@@ -0,0 +1,20 @@
+# Generated by Django 4.2.19 on 2025-07-25 14:41
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("music", "0027_track_albums"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="track",
+            name="albums",
+            field=models.ManyToManyField(
+                related_name="tracks", to="music.album"
+            ),
+        ),
+    ]

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.
 
@@ -229,7 +232,7 @@ class Artist(TimeStampedModel):
             alt_name = found_name
 
         artist = cls.objects.filter(
-            name=name, musicbrainz_id=musicbrainz_id
+            name=found_name, musicbrainz_id=musicbrainz_id
         ).first()
         if not artist:
             artist = cls.objects.create(
@@ -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,7 @@ class Track(ScrobblableMixin):
             except Exception:
                 print("No musicbrainz result found, cannot enrich")
                 return track
-            track.run_time_seconds = run_time_seconds or int(length / 1000)
+            track.base_run_time_seconds = run_time_seconds or int(length / 1000)
             track.musicbrainz_id = mbid
             if commit:
                 track.save()

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

@@ -15,3 +15,6 @@ class Person(TimeStampedModel):
     bgg_username = models.CharField(max_length=100, **BNULL)
     lichess_username = models.CharField(max_length=100, **BNULL)
     bio = models.TextField(**BNULL)
+
+    def __str__(self):
+        return self.name

vrobbler/apps/podcasts/api/serializers.py

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

vrobbler/apps/podcasts/api/views.py

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

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

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

vrobbler/apps/podcasts/models.py

@@ -143,43 +143,46 @@ class PodcastEpisode(ScrobblableMixin):
     def find_or_create(
         cls,
         title: str,
-        podcast_name: str,
         pub_date: str,
-        number: int = 0,
+        episode_num: int = 0,
+        base_run_time_seconds: int = 2400,
         mopidy_uri: str = "",
-        producer_name: str = "",
+        podcast_name: str = "",
-        run_time_seconds: int = 1800,
+        podcast_producer: str = "",
+        podcast_description: str = "",
         enrich: bool = True,
     ) -> "PodcastEpisode":
         """Given a data dict from Mopidy, finds or creates a podcast and
         producer before saving the epsiode so it can be scrobbled.
 
         """
+        log_context={"mopidy_uri": mopidy_uri, "media_type": "Podcast"}
         producer = None
-        if producer_name:
+        if podcast_producer:
-            producer = Producer.find_or_create(producer_name)
+            producer = Producer.find_or_create(podcast_producer)
 
-        podcast = Podcast.objects.filter(
+        podcast, created = Podcast.objects.get_or_create(name=podcast_name, defaults={"description": podcast_description})
-            name__iexact=podcast_name,
+        log_context["podcast_id"] = podcast.id
-        ).first()
+        log_context["podcast_name"] = podcast.name
-        if not podcast:
+        if created:
-            podcast = Podcast.objects.create(
+            logger.info("Created new podcast", extra=log_context)
-                name=podcast_name, producer=producer
+        if enrich and created:
-            )
+            logger.info("Enriching new podcast", extra=log_context)
-            if enrich:
+            podcast.fix_metadata()
-                podcast.fix_metadata()
 
-        episode = cls.objects.filter(
+        episode, created = cls.objects.get_or_create(
-            title__iexact=title, podcast=podcast
+            title=title,
-        ).first()
+            podcast=podcast,
-        if not episode:
+            defaults={
-            episode = cls.objects.create(
+                "base_run_time_seconds": base_run_time_seconds,
-                title=title,
+                "number": episode_num,
-                podcast=podcast,
+                "pub_date": pub_date,
-                run_time_seconds=run_time_seconds,
+                "mopidy_uri": mopidy_uri,
-                number=number,
+            }
-                pub_date=pub_date,
+        )
-                mopidy_uri=mopidy_uri,
+        if created:
-            )
+            log_context["episode_id"] = episode.id
+            log_context["episode_title"] = episode.title
+            logger.info("Created new podcast episode", extra=log_context)
 
         return episode

vrobbler/apps/podcasts/utils.py

@@ -1,7 +1,10 @@
 import logging
 import os
+from typing import Any
 from urllib.parse import unquote
 
+import feedparser
+import requests
 from dateutil.parser import ParserError, parse
 from podcasts.models import PodcastEpisode
 
@@ -10,26 +13,95 @@ logger = logging.getLogger(__name__)
 # TODO This should be configurable in settings or per deploy
 PODCAST_DATE_FORMAT = "YYYY-MM-DD"
 
+def parse_duration(d):
+    if not d:
+        return None
+    if d.isdigit():
+        return int(d)
+    parts = [int(p) for p in d.split(":")]
+    while len(parts) < 3:
+        parts.insert(0, 0)
+    h, m, s = parts
+    return h * 3600 + m * 60 + s
+
+def fetch_metadata_from_rss(uri: str) -> dict[str, Any]:
+    log_context = {"mopidy_uri": uri, "media_type": "Podcast"}
+    podcast_data: dict[str, Any] = {}
+
+    rss_url = uri.split("#")[0].split("podcast+")[1]
+    target_guid = uri.split("#")[1]
+
+    log_context["rss_url"] = rss_url
+    log_context["target_guid"] = target_guid
+
+    try:
+        resp = requests.get(rss_url, timeout=10)
+        feed = feedparser.parse(resp.text)
+    except IndexError:
+        logger.warning("Tried to parse uri as RSS feed, but no target found", extra=log_context)
+        return podcast_data
+
+    podcast_publisher = getattr(feed.feed, "itunes_publisher", "")
+    try:
+        podcast_owner = feed.feed.itunes_owner.get("name") if isinstance(feed.feed.itunes_owner, dict) else feed.feed.itunes_owner
+        podcast_other = feed.feed.get("managingeditor") or feed.feed.get("copyright")
+    except AttributeError:
+        podcast_owner = None
+        podcast_other = None
+
+    podcast_data = {
+        "podcast_name": getattr(feed.feed, "title", ""),
+        # "podcast_description": getattr(feed.feed, "description", ""),
+        # "podcast_link": getattr(feed.feed, "link", ""),
+        "podcast_producer": podcast_publisher or podcast_owner or podcast_other
+    }
+
+    for entry in feed.entries:
+        if entry.get("guid") == target_guid:
+            logger.info("🎧 Episode found in RSS feed", extra=log_context)
+            podcast_data["title"] = entry.title
+            podcast_data["episode_num"] = int(entry.get("itunes_episode", 0))
+            podcast_data["pub_date"] = parse(entry.get("published", None))
+            podcast_data["base_run_time_seconds"] = parse_duration(entry.get("itunes_duration", None))
+            # podcast_data["description"] = entry.get("description", None)
+            # podcast_data["episode_url"] = entry.enclosures[0].href if entry.get("enclosures") else None
+            return podcast_data
+    else:
+        logger.info("Episode not found in RSS feed.")
+
+
+def parse_mopidy_uri(uri: str) -> dict[str, Any]:
+    podcast_data: dict[str, Any] = {}
 
-def parse_mopidy_uri(uri: str) -> dict:
     logger.debug(f"Parsing URI: {uri}")
+    if "podcast+https" in uri:
+        return fetch_metadata_from_rss(uri)
+
+
     parsed_uri = os.path.splitext(unquote(uri))[0].split("/")
 
+    podcast_data = {
+        "title": parsed_uri[-1],
+        "episode_num": None,
+        "podcast_name": parsed_uri[-2].strip(),
+        "pub_date": None,
+    }
+
+
     episode_str = parsed_uri[-1]
-    podcast_name = parsed_uri[-2].strip()
     episode_num = None
     episode_num_pad = 0
 
     try:
         # Without episode numbers the date will lead
-        pub_date = parse(episode_str[0:10])
+        podcast_data["pub_date"] = parse(episode_str[0:10])
     except ParserError:
-        episode_num = int(episode_str.split("-")[0])
+        podcast_data["episode_num"] = int(episode_str.split("-")[0])
-        episode_num_pad = len(str(episode_num)) + 1
+        episode_num_pad = len(str(podcast_data["episode_num"])) + 1
 
         try:
             # Beacuse we have epsiode numbers on
-            pub_date = parse(
+            podcast_data["pub_date"] = parse(
                 episode_str[
                     episode_num_pad : len(PODCAST_DATE_FORMAT)
                     + episode_num_pad
@@ -39,41 +111,19 @@ def parse_mopidy_uri(uri: str) -> dict:
             pub_date = ""
 
     gap_to_strip = 0
-    if pub_date:
+    if podcast_data["pub_date"]:
         gap_to_strip += len(PODCAST_DATE_FORMAT)
-    if episode_num:
+    if podcast_data["episode_num"]:
         gap_to_strip += episode_num_pad
 
-    episode_name = episode_str[gap_to_strip:].replace("-", " ").strip()
+    podcast_data["title"] = episode_str[gap_to_strip:].replace("-", " ").strip()
 
-    return {
+    return podcast_data
-        "episode_filename": episode_name,
-        "episode_num": episode_num,
-        "podcast_name": podcast_name,
-        "pub_date": pub_date,
-    }
 
 
 def get_or_create_podcast(post_data: dict) -> PodcastEpisode:
+    logger.info("Looking up podcast", extra={"post_data": post_data, "media_type": "Podcast"})
     mopidy_uri = post_data.get("mopidy_uri", "")
     parsed_data = parse_mopidy_uri(mopidy_uri)
 
-    producer_dict = {"name": post_data.get("artist")}
+    return PodcastEpisode.find_or_create(**parsed_data)
-
-    podcast_name = post_data.get("album")
-    if not podcast_name:
-        podcast_name = parsed_data.get("podcast_name")
-    podcast_dict = {"name": podcast_name}
-
-    episode_name = parsed_data.get("episode_filename")
-    episode_dict = {
-        "title": episode_name,
-        "run_time_seconds": post_data.get("run_time"),
-        "number": parsed_data.get("episode_num"),
-        "pub_date": parsed_data.get("pub_date"),
-        "mopidy_uri": mopidy_uri,
-    }
-
-    return PodcastEpisode.find_or_create(
-        podcast_dict, producer_dict, episode_dict
-    )

vrobbler/apps/podcasts/views.py

@@ -1,6 +1,7 @@
 from django.views import generic
 from podcasts.models import Podcast
 
+from scrobbles.views import ScrobbleableListView, ScrobbleableDetailView
 
 class PodcastListView(generic.ListView):
     model = Podcast

vrobbler/apps/profiles/admin.py

@@ -7,6 +7,7 @@ from profiles.models import UserProfile
 class UserProfileAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
     ordering = ("-created",)
+    readonly_fields = ("timezone_change_log",)
     exclude = (
         "twitch_token",
         "twitch_client_secret",

vrobbler/apps/profiles/migrations/0027_userprofile_mood_checkin_enabled_and_more.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.19 on 2025-07-30 22:27
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('profiles', '0026_userprofile_timezone_change_log'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='mood_checkin_enabled',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name='userprofile',
+            name='mood_checkin_frequency',
+            field=models.CharField(default='hourly', max_length=20),
+        ),
+    ]

vrobbler/apps/profiles/models.py

@@ -1,6 +1,5 @@
 from zoneinfo import ZoneInfo
 import pendulum
-from datetime import datetime
 from django.utils import timezone
 import logging
 from django.conf import settings
@@ -16,6 +15,7 @@ BNULL = {"blank": True, "null": True}
 
 logger = logging.getLogger(__name__)
 
+
 class UserProfile(TimeStampedModel):
     user = models.OneToOneField(
         User, on_delete=models.CASCADE, related_name="profile"
@@ -55,6 +55,9 @@ class UserProfile(TimeStampedModel):
     imap_pass = EncryptedField(**BNULL)
     imap_auto_import = models.BooleanField(default=False)
 
+    mood_checkin_enabled = models.BooleanField(default=False)
+    mood_checkin_frequency = models.CharField(max_length=20, default="hourly")
+
     ntfy_url = models.CharField(max_length=255, **BNULL)
     ntfy_enabled = models.BooleanField(default=False)
 
@@ -72,7 +75,10 @@ class UserProfile(TimeStampedModel):
             old_instance = UserProfile.objects.get(pk=self.pk)
             is_timezone_change = self.timezone != old_instance.timezone
             if is_timezone_change:
-                logger.info("Updating timezone changelog for user", extra={"profile_id": self.id})
+                logger.info(
+                    "Updating timezone changelog for user",
+                    extra={"profile_id": self.id},
+                )
                 previous_changes = old_instance.timezone_change_log
                 now = timezone.now().replace(microsecond=0)
                 new_log = f"{self.timezone} - {now}"
@@ -98,7 +104,7 @@ class UserProfile(TimeStampedModel):
             change_list = self.historic_timezone_changes
             for idx, start in enumerate(change_list):
                 try:
-                    end = change_list[idx+1]
+                    end = change_list[idx + 1]
                 except IndexError:
                     end = None
 
@@ -111,14 +117,34 @@ class UserProfile(TimeStampedModel):
 
         return timestamp.replace(tzinfo=timezone)
 
+    def adjust_timezone_of_scrobbles(self, commit=False):
+        current_dt = None
+        scrobbles_to_change_qs_list = []
+        for boundry_dt in self.historic_timezone_changes:
+            if current_dt and boundry_dt:
+                logger.info(
+                    f"Checking for scrobbles between {current_dt} and {boundry_dt} to update to {current_dt.tzinfo.name}"
+                )
+                scrobbles = self.user.scrobble_set.filter(
+                    timestamp__gte=current_dt,
+                    timestamp__lt=boundry_dt,
+                ).exclude(timezone=current_dt.tzinfo.name)
+                scrobbles_to_change_qs_list.append(scrobbles)
+                logger.info(
+                    f"Updating {scrobbles.count()} scrobble timezones to {current_dt.tzinfo.name}"
+                )
+                if commit:
+                    scrobbles.update(timezone=current_dt.tzinfo.name)
+
+            current_dt = boundry_dt
+        return scrobbles_to_change_qs_list
+
     @cached_property
     def task_context_tags(self) -> list[str]:
-        tag_list = [
+        tag_list = settings.DEFAULT_TASK_CONTEXT_TAGS
-            t.strip().capitalize()
+        tags = ""
-            for t in self.task_context_tags_str.split(",")
+        if self.task_context_tags_str:
-        ]
+            tags = self.task_context_tags_str
-
+            tag_list = [t.strip().capitalize() for t in tags.split(",")]
-        if not tag_list:
-            tag_list = settings.DEFAULT_TASK_CONTEXT_TAG_LIST
 
         return tag_list

vrobbler/apps/profiles/utils.py

@@ -59,25 +59,27 @@ def start_of_year(dt, profile) -> datetime:
     return start_of_day(dt, profile).replace(month=1, day=1)
 
 
-def one_off_fix_colins_profile(profile):
+def fix_profile_historic_timezones(profile):
     home_tz = "America/New_York"
 
-    europe = "2022-10-15"
+    europe = "2023-10-15 06:00:00"
+    europe_end = "2023-12-16 12:00:00"
     europe_tz = "Europe/Paris"
-    europe_end = "2023-12-15"
 
-    washington = "2023-04-28"
+    washington = "2024-04-28 06:00:00"
+    washington_end = "2024-05-04 12:00:00"
     washington_tz = "America/Los_Angeles"
-    washington_end = "2023-05-04"
 
-    camp = "2024-08-04"
+    camp = "2024-08-04 17:00:00"
-    camp_end = "2024-08-10"
+    camp_end = "2024-08-10 12:00:00"
     camp_tz = "America/Halifax"
 
-    summer = "2025-07-09 12:00:00"
+    summer = "2025-07-09 06:00:00"
-    summer_end = "2025-07-13 20:30:00"
+    summer_end = "2025-07-11 23:30:00"
     summer_tz = "America/Los_Angeles"
 
+    profile.timezone_change_log = None
+
     profile.timezone_change_log = ""
     profile.timezone_change_log += f"{europe_tz} - {pendulum.parse(europe)}\n"
     profile.timezone_change_log += (

vrobbler/apps/puzzles/api/serializers.py

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

vrobbler/apps/puzzles/api/views.py

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

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

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

vrobbler/apps/puzzles/models.py

@@ -1,3 +1,5 @@
+from dataclasses import dataclass
+from typing import Optional
 from uuid import uuid4
 
 import requests
@@ -9,12 +11,17 @@ from django_extensions.db.models import TimeStampedModel
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
 from puzzles.sources import ipdb
-from scrobbles.dataclasses import PuzzleLogData
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData, LongPlayLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 
 BNULL = {"blank": True, "null": True}
 
 
+@dataclass
+class PuzzleLogData(BaseLogData, WithPeopleLogData, LongPlayLogData):
+    rating: Optional[str] = None
+
+
 class PuzzleManufacturer(TimeStampedModel):
     uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
     name = models.CharField(max_length=255)
@@ -58,6 +65,10 @@ class Puzzle(ScrobblableMixin):
     def __str__(self):
         return f"{self.title} ({self.pieces_count}) by {self.manufacturer}"
 
+    @property
+    def logdata_cls(self):
+        return PuzzleLogData
+
     @property
     def subtitle(self):
         return self.manufacturer.name

vrobbler/apps/scrobbles/admin.py

@@ -102,7 +102,7 @@ class ChartRecordAdmin(admin.ModelAdmin):
 
 @admin.register(Scrobble)
 class ScrobbleAdmin(admin.ModelAdmin):
-    # date_hierarchy = "timestamp"
+    date_hierarchy = "timestamp"
     list_display = (
         "timestamp",
         "media_name",
@@ -112,6 +112,7 @@ class ScrobbleAdmin(admin.ModelAdmin):
         "in_progress",
         "is_paused",
         "played_to_completion",
+        "user",
     )
     raw_id_fields = (
         "video",
@@ -140,6 +141,7 @@ class ScrobbleAdmin(admin.ModelAdmin):
         "long_play_complete",
         "source",
         "timezone",
+        "user",
     )
     ordering = ("-timestamp",)
 
@@ -148,3 +150,7 @@ class ScrobbleAdmin(admin.ModelAdmin):
 
     def playback_percent(self, obj):
         return obj.percent_played
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request).exclude(timestamp__year=None)
+        return qs

vrobbler/apps/scrobbles/constants.py

@@ -18,6 +18,9 @@ PLAY_AGAIN_MEDIA = {
     "bricksets": "BrickSet",
     "trails": "Trail",
     "beers": "Beer",
+    "foods": "Food",
+    "locations": "GeoLocation",
+    "videos": "Video",
 }
 
 MEDIA_END_PADDING_SECONDS = {
@@ -35,6 +38,7 @@ SCROBBLE_CONTENT_URLS = {
     "-t": ["https://app.todoist.com/app/task/{id}"],
     "-p": ["https://www.ipdb.plus/IPDb/puzzle.php?id="],
     "-l": ["https://brickset.com/sets/"],
+    "-c": ["https://readcomicsonline.ru"],
 }
 
 EXCLUDE_FROM_NOW_PLAYING = ("GeoLocation",)
@@ -50,6 +54,7 @@ MANUAL_SCROBBLE_FNS = {
     "-t": "manual_scrobble_task",
     "-p": "manual_scrobble_puzzle",
     "-l": "manual_scrobble_brickset",
+    "-c": "manual_scrobble_book",
 }
 
 

vrobbler/apps/scrobbles/dataclasses.py

@@ -1,19 +1,22 @@
-from functools import cached_property
-import inspect
 import json
 from dataclasses import asdict, dataclass
 from typing import Optional
 
 from dataclass_wizard import JSONWizard
+from django import forms
 from django.contrib.auth import get_user_model
-from locations.models import GeoLocation
+from people.models import Person
+from scrobbles.forms import form_from_dataclass
 
 User = get_user_model()
 
 
 class ScrobbleLogDataEncoder(json.JSONEncoder):
     def default(self, o):
-        return o.__dict__
+        try:
+            return o.__dict__
+        except AttributeError:
+            return {}
 
 
 class ScrobbleLogDataDecoder(json.JSONDecoder):
@@ -32,190 +35,54 @@ class JSONDataclass(JSONWizard):
 
 
 @dataclass
-class ScrobbleLogData(JSONDataclass):
+class BaseLogData(JSONDataclass):
     description: Optional[str] = None
+    notes: Optional[list[str]] = None
+
+    _excluded_fields = {}
+
+    @classmethod
+    def form(cls):
+        return form_from_dataclass(cls)
+
+    @classmethod
+    def override_fields(cls) -> dict:
+        return {}
 
 
+@dataclass
 class LongPlayLogData(JSONDataclass):
-    serial_scrobble_id: Optional[int]
     long_play_complete: bool = False
 
 
-class WithOthersLogData(JSONDataclass):
+@dataclass
-    with_user_ids: Optional[list[int]] = None
+class WithPeopleLogData(JSONDataclass):
-    with_names_str: Optional[list[str]] = None
+    with_people_ids: Optional[list[int]] = None
 
     @property
-    def with_names(self) -> list[str]:
+    def with_people(self) -> list["Person"]:
-        with_names = []
+        from people.models import Person
-        if self.with_user_ids:
-            with_names += [u.full_name for u in self.with_users if u]
-        if self.with_names_str:
-            with_names += [u for u in self.with_names_str]
-        return with_names
 
-    @property
+        if not self.with_people_ids:
-    def with_users(self) -> list[User]:
+            return []
-        with_users = []
+        return [
-        if self.with_user_ids:
+            Person.objects.filter(id=pid).first()
-            with_users = [
+            for pid in self.with_people_ids
-                User.objects.filter(id=i).first() for i in self.with_user_ids
+        ]
-            ]
-        return with_users
 
-
+    @classmethod
-@dataclass
+    def override_fields(cls) -> dict:
-class BoardGameScoreLogData(JSONDataclass):
+        fields = {}
-    user_id: Optional[int] = None
+        for base in cls.mro()[1:]:
-    name_str: str = ""
+            if hasattr(base, "override_fields"):
-    bgg_username: str = ""
+                base_fields = base.override_fields()
-    color: Optional[str] = None
+                fields.update(base_fields)
-    character: Optional[str] = None
+        custom_fields = {
-    team: Optional[str] = None
+            "with_people_ids": forms.ModelMultipleChoiceField(
-    score: Optional[int] = None
+                queryset=Person.objects.all(),
-    win: Optional[bool] = None
+                required=False,
-    new: Optional[bool] = None
+                widget=forms.SelectMultiple(attrs={"size": 10}),
-
+            )
-    @property
+        }
-    def user(self) -> Optional[User]:
+        fields.update(custom_fields)
-        user = None
+        return fields
-        if self.user_id:
-            user = User.objects.filter(id=self.user_id).first()
-        return user
-
-    @property
-    def name(self) -> str:
-        name = self.name_str
-        if self.user_id:
-            name = self.user.first_name
-        return name
-
-    def __str__(self) -> str:
-        out = self.name
-        if self.score:
-            out += f" {self.score}"
-        if self.color:
-            out += f" ({self.color})"
-        if self.win:
-            out += f" [W]"
-        return out
-
-
-@dataclass
-class BoardGameLogData(LongPlayLogData):
-    serial_scrobble_id: Optional[int] = None
-    long_play_complete: Optional[bool] = None
-    players: Optional[list[BoardGameScoreLogData]] = None
-    location: Optional[str] = None
-    geo_location_id: Optional[int] = None
-    difficulty: Optional[int] = None
-    solo: Optional[bool] = None
-    two_handed: Optional[bool] = None
-
-    @cached_property
-    def geo_location(self) -> Optional[GeoLocation]:
-        if self.geo_location_id:
-            return GeoLocation.objects.filter(id=self.geo_location_id).first()
-
-
-@dataclass
-class BookPageLogData(JSONDataclass):
-    page_number: Optional[int] = None
-    end_ts: Optional[int] = None
-    start_ts: Optional[int] = None
-    duration: Optional[int] = None
-
-
-@dataclass
-class BookLogData(LongPlayLogData):
-    long_play_complete: Optional[bool] = None
-    koreader_hash: Optional[str] = None
-    page_data: Optional[dict[int, BookPageLogData]] = None
-    pages_read: Optional[int] = None
-    page_start: Optional[int] = None
-    page_end: Optional[int] = None
-    serial_scrobble_id: Optional[int] = None
-    details: Optional[str] = None
-
-
-@dataclass
-class LifeEventLogData(WithOthersLogData):
-    with_user_ids: Optional[list[int]] = None
-    with_names_str: Optional[list[str]] = None
-    location: Optional[str] = None
-    geo_location_id: Optional[int] = None
-    details: Optional[str] = None
-
-    def geo_location(self):
-        return GeoLocation.objects.filter(id=self.geo_location_id).first()
-
-
-@dataclass
-class MoodLogData(JSONDataclass):
-    reasons: Optional[str] = None
-
-
-@dataclass
-class VideoLogData(JSONDataclass):
-    title: str
-    video_type: str
-    run_time_seconds: int
-    kind: str
-    year: Optional[int]
-    episode_number: Optional[int] = None
-    source_url: Optional[str] = None
-    imdbID: Optional[str] = None
-    season_number: Optional[int] = None
-    cover_url: Optional[str] = None
-    next_imdb_id: Optional[int] = None
-    tv_series_id: Optional[str] = None
-
-
-@dataclass
-class VideoGameLogData(LongPlayLogData):
-    serial_scrobble_id: Optional[int] = None
-    long_play_complete: Optional[bool] = False
-    console: Optional[str] = None
-    emulated: Optional[bool] = False
-    emulator: Optional[str] = None
-
-
-@dataclass
-class BrickSetLogData(LongPlayLogData, WithOthersLogData):
-    serial_scrobble_id: Optional[int]
-    long_play_complete: bool = False
-    with_user_ids: Optional[list[int]] = None
-    with_names_str: Optional[list[str]] = None
-
-
-@dataclass
-class TrailLogData(WithOthersLogData):
-    with_user_ids: Optional[list[int]] = None
-    with_names_str: Optional[list[str]] = None
-    details: Optional[str] = None
-    effort: Optional[str] = None
-    difficulty: Optional[str] = None
-
-
-@dataclass
-class BeerLogData(WithOthersLogData):
-    with_user_ids: Optional[list[int]] = None
-    with_names_str: Optional[list[str]] = None
-    details: Optional[str] = None
-    rating: Optional[str] = None
-    notes: Optional[str] = None
-
-
-@dataclass
-class FoodLogData(JSONDataclass):
-    meal: Optional[str] = None
-    details: Optional[str] = None
-    rating: Optional[str] = None
-    notes: Optional[str] = None
-
-
-@dataclass
-class PuzzleLogData(JSONDataclass):
-    with_others: Optional[str] = None
-    rating: Optional[str] = None
-    notes: Optional[str] = None

vrobbler/apps/scrobbles/forms.py

@@ -1,3 +1,6 @@
+from dataclasses import fields
+from typing import Union, get_args, get_origin
+
 from django import forms
 
 
@@ -23,3 +26,84 @@ class ScrobbleForm(forms.Form):
             }
         ),
     )
+
+
+# Mapping of types to Django form field classes
+TYPE_FIELD_MAP = {
+    int: forms.IntegerField,
+    float: forms.FloatField,
+    bool: forms.BooleanField,
+    str: forms.CharField,
+    dict: forms.JSONField,
+    list: forms.JSONField,
+}
+
+# Optional: type-to-widget mapping
+TYPE_WIDGET_MAP = {
+    str: forms.TextInput(attrs={"size": 80}),
+    dict: forms.Textarea(attrs={"rows": 10, "cols": 80}),
+    list: forms.Textarea(attrs={"rows": 6, "cols": 80}),
+    bool: forms.CheckboxInput(),
+}
+
+
+def django_form_field_from_type(field_type, required=True):
+    origin = get_origin(field_type)
+
+    # Handle Optional / Union
+    if origin is Union:
+        args = get_args(field_type)
+        if type(None) in args:
+            required = False
+            non_none_type = [arg for arg in args if arg is not type(None)][0]
+            return django_form_field_from_type(
+                non_none_type, required=required
+            )
+
+    # Determine actual type
+    base_type = origin if origin else field_type
+    field_class = TYPE_FIELD_MAP.get(base_type, forms.CharField)
+    widget = TYPE_WIDGET_MAP.get(base_type)
+
+    return (
+        field_class(required=required, widget=widget)
+        if widget
+        else field_class(required=required)
+    )
+
+
+def form_from_dataclass(dataclass):
+    form_fields = {}
+    override_fields = {}
+    for klass in dataclass.mro():
+        if hasattr(klass, "override_fields"):
+            override_fields.update(klass.override_fields())
+    for f in fields(dataclass):
+        if f.name in override_fields:
+            form_fields[f.name] = override_fields[f.name]
+            continue
+
+        required = f.default is None and f.default_factory is None
+        form_fields[f.name] = django_form_field_from_type(
+            f.type, required=required
+        )
+
+        if f.name in dataclass._excluded_fields:
+            form_fields[f.name].disabled = True
+
+    form_cls = type(f"{dataclass.__name__}Form", (forms.Form,), form_fields)
+
+    if "notes" in form_cls.base_fields:
+        form_cls.base_fields["notes"] = forms.CharField(
+            required=False,
+            widget=forms.Textarea(attrs={"rows": 4}),
+        )
+
+        def clean_notes(self):
+            notes_str = self.cleaned_data.get("notes", "")
+            return [
+                line.strip() for line in notes_str.splitlines() if line.strip()
+            ]
+
+        form_cls.clean_notes = clean_notes
+    return form_cls

vrobbler/apps/scrobbles/importers/lastfm.py

@@ -50,20 +50,23 @@ class LastFM:
                 enrich=True,
             )
 
-            timezone = settings.TIME_ZONE
+            tz_timestamp = self.vrobbler_user.profile.get_timestamp_with_tz(
-            if self.vrobbler_user.profile:
+                lfm_scrobble.get("timestamp")
-                timezone = self.vrobbler_user.profile.timezone
+            )
-
             timestamp = lfm_scrobble.get("timestamp")
+            stop_timestamp = timestamp + timedelta(
+                seconds=track.run_time_seconds
+            )
             new_scrobble = Scrobble(
                 user=self.vrobbler_user,
                 timestamp=timestamp,
+                stop_timestamp=stop_timestamp,
                 source=source,
                 track=track,
-                timezone=timezone,
                 played_to_completion=True,
                 in_progress=False,
                 media_type=Scrobble.MediaType.TRACK,
+                timezone=tz_timestamp.tzinfo.name,
             )
             # Vrobbler scrobbles on finish, LastFM scrobbles on start
             seconds_eariler = timestamp - timedelta(seconds=20)
@@ -91,7 +94,7 @@ class LastFM:
         )
         return created
 
-    def get_last_scrobbles(self, time_from=None, time_to=None):
+    def get_last_scrobbles(self, time_from=None, time_to=None, check=False):
         """Given a user, Last.fm api key, and secret key, grab a list of scrobbled
         tracks"""
         lfm_params = {}
@@ -107,6 +110,9 @@ class LastFM:
         found_scrobbles = self.user.get_recent_tracks(**lfm_params)
         # TOOD spin this out into a celery task over certain threshold of found scrobbles?
 
+        if check and found_scrobbles:
+            return True
+
         for scrobble in found_scrobbles:
             logger.info(f"Processing {scrobble}")
             run_time = None

vrobbler/apps/scrobbles/importers/tsv.py

@@ -2,6 +2,7 @@ import codecs
 import csv
 import logging
 from datetime import datetime, timedelta
+from zoneinfo import ZoneInfo
 
 import requests
 from django.contrib.auth import get_user_model
@@ -61,10 +62,10 @@ def import_audioscrobbler_tsv_file(file_path, user_id):
                 },
             )
             continue
-
+        timestamp = datetime.fromtimestamp(
-        timestamp = user.profile.get_timestamp_with_tz(
+            int(row[AsTsvColumn["TIMESTAMP"].value])
-            datetime.fromtimestamp(int(row[AsTsvColumn["TIMESTAMP"].value]))
+        ).astimezone(ZoneInfo("UTC"))
-        )
+        timestamp = user.profile.get_timestamp_with_tz(timestamp)
         stop_timestamp = timestamp + timedelta(seconds=track.run_time_seconds)
 
         new_scrobble = Scrobble(

vrobbler/apps/scrobbles/importers/webdav.py

@@ -1,9 +1,11 @@
+import logging
+
 from books.koreader import fetch_file_from_webdav
 from profiles.models import UserProfile
 from scrobbles.models import KoReaderImport
 from scrobbles.tasks import process_koreader_import
+from scrobbles.utils import get_file_md5_hash
 from webdav.client import get_webdav_client
-import logging
 
 logger = logging.getLogger(__name__)
 
@@ -11,7 +13,7 @@ logger = logging.getLogger(__name__)
 def import_from_webdav_for_all_users(restart=False):
     """Grab a list of all users with WebDAV enabled and kickoff imports for them"""
 
-    # LastFmImport = apps.get_model("scrobbles", "LastFMImport")
+    # WebDavImport = apps.get_model("scrobbles", "WebDavImport")
     webdav_enabled_user_ids = UserProfile.objects.filter(
         webdav_url__isnull=False,
         webdav_user__isnull=False,
@@ -42,7 +44,7 @@ def import_from_webdav_for_all_users(restart=False):
                 KoReaderImport.objects.filter(
                     user_id=user_id, processed_finished__isnull=False
                 )
-                .order_by("Processed_finished")
+                .order_by("processed_finished")
                 .last()
             )
 

vrobbler/apps/scrobbles/management/commands/convert_task_log_data.py

@@ -0,0 +1,27 @@
+from django.core.management.base import BaseCommand
+from vrobbler.apps.tasks.utils import (
+    convert_notes_to_dict,
+    convert_old_boardgame_log_to_new,
+    convert_old_orgmode_log_to_new,
+    convert_old_todoist_log_to_new,
+)
+
+
+class Command(BaseCommand):
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--commit",
+            action="store_true",
+            help="Commit changes",
+        )
+
+    def handle(self, *args, **options):
+        commit = False
+        if options["commit"]:
+            commit = True
+        else:
+            print("No changes will be saved, use --commit to save")
+        convert_old_orgmode_log_to_new(commit)
+        convert_old_todoist_log_to_new(commit)
+        convert_notes_to_dict(commit)
+        convert_old_boardgame_log_to_new(commit)

vrobbler/apps/scrobbles/management/commands/send_mood_checkin.py

@@ -0,0 +1,10 @@
+from django.core.management.base import BaseCommand
+from vrobbler.apps.scrobbles.utils import (
+    send_mood_checkin_reminders
+)
+
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        sent_count = send_mood_checkin_reminders()
+        print(f"Sent {sent_count} mood check-in notifications")

vrobbler/apps/scrobbles/mixins.py

@@ -57,14 +57,24 @@ class ScrobblableMixin(TimeStampedModel):
 
     uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
     title = models.CharField(max_length=255, **BNULL)
-    run_time_seconds = models.IntegerField(default=900)
+    base_run_time_seconds = models.IntegerField(**BNULL)
-    run_time_ticks = models.PositiveBigIntegerField(**BNULL)
 
     genre = TaggableManager(through=ObjectWithGenres, blank=True)
 
     class Meta:
         abstract = True
 
+    @property
+    def run_time_seconds(self) -> int:
+        run_time = 900
+        if self.base_run_time_seconds:
+            run_time = self.base_run_time_seconds
+        return run_time
+
+    @classmethod
+    def is_long_play_media(cls) -> bool:
+        return False
+
     def scrobble_for_user(
         self,
         user_id,
@@ -89,7 +99,7 @@ class ScrobblableMixin(TimeStampedModel):
             "[scrobble_for_user] called",
             extra={
                 "id": self.id,
-                "media_type": self.__class__,
+                "media_type": self.__class__.__name__,
                 "user_id": user_id,
                 "scrobble_data": scrobble_data,
             },
@@ -111,9 +121,9 @@ class ScrobblableMixin(TimeStampedModel):
 
     @property
     def logdata_cls(self) -> None:
-        from scrobbles.dataclasses import ScrobbleLogData
+        from scrobbles.dataclasses import BaseLogData
 
-        return ScrobbleLogData
+        return BaseLogData
 
     @property
     def subtitle(self) -> str:
@@ -136,6 +146,15 @@ class LongPlayScrobblableMixin(ScrobblableMixin):
     class Meta:
         abstract = True
 
+    @classmethod
+    def is_long_play_media(cls) -> bool:
+        return True
+
+    def is_complete(self) -> bool:
+        if self.log:
+            return bool(self.log.get("long_play_complete", None))
+        return False
+
     def get_longplay_finish_url(self):
         return reverse("scrobbles:longplay-finish", kwargs={"uuid": self.uuid})
 

vrobbler/apps/scrobbles/models.py

@@ -12,8 +12,9 @@ import pytz
 from beers.models import Beer
 from boardgames.models import BoardGame
 from books.koreader import process_koreader_sqlite_file
-from books.models import Book, Paper
+from books.models import Book, Paper, BookPageLogData, BookLogData
 from bricksets.models import BrickSet
+from dataclass_wizard.errors import ParseError
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.files import File
@@ -21,7 +22,7 @@ from django.db import models
 from django.urls import reverse
 from django.utils import timezone
 from django_extensions.db.models import TimeStampedModel
-from foods.models import Food
+from foods.models import Food, FoodLogData
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
 from lifeevents.models import LifeEvent
@@ -33,6 +34,7 @@ from profiles.utils import (
     end_of_day,
     end_of_month,
     end_of_week,
+    fix_profile_historic_timezones,
     start_of_day,
     start_of_month,
     start_of_week,
@@ -41,7 +43,7 @@ from puzzles.models import Puzzle
 from scrobbles import dataclasses as logdata
 from scrobbles.constants import LONG_PLAY_MEDIA, MEDIA_END_PADDING_SECONDS
 from scrobbles.importers.lastfm import LastFM
-from scrobbles.notifications import NtfyNotification
+from scrobbles.notifications import ScrobbleNtfyNotification
 from scrobbles.stats import build_charts
 from scrobbles.utils import get_file_md5_hash, media_class_to_foreign_key
 from sports.models import SportEvent
@@ -205,6 +207,9 @@ class KoReaderImport(BaseFileImportMixin):
 
     def process(self, force=False):
 
+        if self.user.id == 1:
+            fix_profile_historic_timezones(self.user.profile)
+
         if self.processed_finished and not force:
             logger.info(
                 f"{self} already processed on {self.processed_finished}"
@@ -250,6 +255,9 @@ class AudioScrobblerTSVImport(BaseFileImportMixin):
     def process(self, force=False):
         from scrobbles.importers.tsv import import_audioscrobbler_tsv_file
 
+        if self.user.id == 1:
+            fix_profile_historic_timezones(self.user.profile)
+
         if self.processed_finished and not force:
             logger.info(
                 f"{self} already processed on {self.processed_finished}"
@@ -280,6 +288,10 @@ class LastFmImport(BaseFileImportMixin):
 
     def process(self, import_all=False):
         """Import scrobbles found on LastFM"""
+
+        if self.user.id == 1:
+            fix_profile_historic_timezones(self.user.profile)
+
         if self.processed_finished:
             logger.info(
                 f"{self} already processed on {self.processed_finished}"
@@ -327,6 +339,9 @@ class RetroarchImport(BaseFileImportMixin):
 
     def process(self, import_all=False, force=False):
         """Import scrobbles found on Retroarch"""
+        if self.user.id == 1:
+            fix_profile_historic_timezones(self.user.profile)
+
         if self.processed_finished and not force:
             logger.info(
                 f"{self} already processed on {self.processed_finished}"
@@ -640,6 +655,13 @@ class Scrobble(TimeStampedModel):
                 (scrobble.elapsed_time)
             )
 
+        # Remove any locations without titles
+        if "GeoLocation" in scrobbles_by_type.keys():
+            for loc_scrobble in scrobbles_by_type["GeoLocation"]:
+                if not loc_scrobble.media_obj.title:
+                    scrobbles_by_type["GeoLocation"].remove(loc_scrobble)
+                    scrobbles_by_type["GeoLocation_count"] -= 1
+
         return scrobbles_by_type
 
     @classmethod
@@ -682,6 +704,12 @@ class Scrobble(TimeStampedModel):
 
         return super(Scrobble, self).save(*args, **kwargs)
 
+    def get_absolute_url(self):
+        if not self.uuid:
+            self.uuid = uuid4()
+            self.save()
+        return reverse("scrobbles:detail", kwargs={"uuid": self.uuid})
+
     def push_to_archivebox(self):
         pushable_media = hasattr(
             self.media_obj, "push_to_archivebox"
@@ -704,11 +732,11 @@ class Scrobble(TimeStampedModel):
                 )
 
     @property
-    def logdata(self) -> Optional[logdata.JSONDataclass]:
+    def logdata(self) -> Optional[logdata.BaseLogData]:
         if self.media_obj:
             logdata_cls = self.media_obj.logdata_cls
         else:
-            logdata_cls = logdata.ScrobbleLogData
+            logdata_cls = logdata.BaseLogData
 
         log_dict = self.log
         if isinstance(self.log, str):
@@ -722,7 +750,20 @@ class Scrobble(TimeStampedModel):
         if not log_dict:
             log_dict = {}
 
-        return logdata_cls.from_dict(log_dict)
+        try:
+            return logdata_cls(**log_dict)
+        except ParseError as e:
+            logger.warning(
+                "Could not parse log data",
+                extra={
+                    "log_dict": log_dict,
+                    "scrobble_id": self.id,
+                    "error": e,
+                },
+            )
+            return logdata_cls()
+        except TypeError as e:
+            return logdata_cls()
 
     def redirect_url(self, user_id) -> str:
         user = User.objects.filter(id=user_id).first()
@@ -734,7 +775,7 @@ class Scrobble(TimeStampedModel):
             and user.profile.redirect_to_webpage
         ):
             logger.info(f"Redirecting to {self.media_obj.url}")
-            redirect_url = self.media_obj.get_read_url()
+            redirect_url = self.media_obj.url
 
         if (
             self.media_type == self.MediaType.VIDEO
@@ -781,7 +822,7 @@ class Scrobble(TimeStampedModel):
         """
         is_stale = False
         now = timezone.now()
-        seconds_since_last_update = (now - self.modified).seconds
+        seconds_since_last_update = (now - self.modified).total_seconds()
         if seconds_since_last_update >= self.media_obj.SECONDS_TO_STALE:
             is_stale = True
         return is_stale
@@ -858,8 +899,9 @@ class Scrobble(TimeStampedModel):
         if self.played_to_completion:
             if self.playback_position_seconds:
                 return self.playback_position_seconds
-            if self.media_obj.run_time_seconds:
+            if self.media_obj and self.media_obj.run_time_seconds:
                 return self.media_obj.run_time_seconds
+
         return (timezone.now() - self.timestamp).seconds
 
     @property
@@ -949,7 +991,7 @@ class Scrobble(TimeStampedModel):
 
     @property
     def can_be_updated(self) -> bool:
-        if self.media_obj.__class__.__name__ in LONG_PLAY_MEDIA.values():
+        if self.media_obj.__class__.__name__ in LONG_PLAY_MEDIA.values() and self.source != "readcomicsonline.ru":
             logger.info(
                 "[scrobbling] cannot be updated, long play media",
                 extra={
@@ -1036,11 +1078,12 @@ class Scrobble(TimeStampedModel):
             media_obj = self.puzzle
         if self.task:
             media_obj = self.task
+        if self.food:
+            media_obj = self.food
         return media_obj
 
     def __str__(self):
-        timestamp = self.timestamp.strftime("%Y-%m-%d")
+        return f"Scrobble of {self.media_obj} ({self.timestamp})"
-        return f"Scrobble of {self.media_obj} ({timestamp})"
 
     def calc_reading_duration(self) -> int:
         duration = 0
@@ -1087,6 +1130,9 @@ class Scrobble(TimeStampedModel):
         key = media_class_to_foreign_key(media.__class__.__name__)
         media_query = models.Q(**{key: media})
         scrobble_data[key + "_id"] = media.id
+        skip_in_progress_check = kwargs.get("skip_in_progress_check", False)
+        read_log_page = kwargs.get("read_log_page", None)
+
 
         # Find our last scrobble of this media item (track, video, etc)
         scrobble = (
@@ -1110,27 +1156,51 @@ class Scrobble(TimeStampedModel):
             )
             return scrobble
 
-        logger.info(
+        if not skip_in_progress_check or read_log_page:
-            f"[create_or_update] check for existing scrobble to update ",
+            logger.info(
-            extra={
+                f"[create_or_update] check for existing scrobble to update ",
-                "scrobble_id": scrobble.id if scrobble else None,
+                extra={
-                "media_type": mtype,
+                    "scrobble_id": scrobble.id if scrobble else None,
-                "media_id": media.id,
+                    "media_type": mtype,
-                "scrobble_data": scrobble_data,
+                    "media_id": media.id,
-            },
+                    "scrobble_data": scrobble_data,
-        )
+                },
-        scrobble_data["playback_status"] = scrobble_data.pop("status", None)
+            )
-        # If it's marked as stopped, send it through our update mechanism, which will complete it
+            scrobble_data["playback_status"] = scrobble_data.pop(
-        if scrobble and (
+                "status", None
-            scrobble.can_be_updated
+            )
-            or scrobble_data["playback_status"] == "stopped"
+            # If it's marked as stopped, send it through our update mechanism, which will complete it
-        ):
+            if scrobble and (
-            if "log" in scrobble_data.keys() and scrobble.log:
+                scrobble.can_be_updated
-                scrobble_data["log"] = scrobble.log | scrobble_data["log"]
+                or (read_log_page and scrobble.can_be_updated)
-            return scrobble.update(scrobble_data)
+                or scrobble_data["playback_status"] == "stopped"
+            ):
+                if read_log_page:
+                    page_list = scrobble.log.get("page_data", [])
+                    if page_list:
+                        for page in page_list:
+                            if not page.get("end_ts", None):
+                                page["end_ts"] = int(timezone.now().timestamp())
+                                page["duration"] = page["end_ts"] - page.get("start_ts")
+
+                    page_list.append(
+                        BookPageLogData(
+                            page_number=read_log_page,
+                            start_ts=int(timezone.now().timestamp())
+                        )
+                    )
+                    scrobble.log["page_data"] = page_list
+                    scrobble.save(update_fields=["log"])
+                elif "log" in scrobble_data.keys() and scrobble.log:
+                    scrobble_data["log"] = scrobble.log | scrobble_data["log"]
+                return scrobble.update(scrobble_data)
+
+            # Discard status before creating
+            scrobble_data.pop("playback_status")
+
+        if read_log_page:
+            scrobble_data["log"] = BookLogData(page_data=[BookPageLogData(page_number=read_log_page, start_ts=int(timezone.now().timestamp()))])
 
-        # Discard status before creating
-        scrobble_data.pop("playback_status")
         logger.info(
             f"[scrobbling] creating new scrobble",
             extra={
@@ -1140,6 +1210,9 @@ class Scrobble(TimeStampedModel):
                 "source": source,
             },
         )
+        if mtype == cls.MediaType.FOOD and not scrobble_data.get("log", {}).get("calories", None):
+            if media.calories:
+                scrobble_data["log"] = FoodLogData(calories=media.calories)
 
         scrobble = cls.create(scrobble_data)
         return scrobble
@@ -1297,7 +1370,7 @@ class Scrobble(TimeStampedModel):
         scrobble_data: dict,
     ) -> "Scrobble":
         scrobble = cls.objects.create(**scrobble_data)
-        NtfyNotification(scrobble).send()
+        ScrobbleNtfyNotification(scrobble).send()
         return scrobble
 
     def stop(self, timestamp=None, force_finish=False) -> None:
@@ -1323,6 +1396,9 @@ class Scrobble(TimeStampedModel):
         if class_name in LONG_PLAY_MEDIA.values():
             self.finish_long_play()
 
+        if class_name == "Book":
+            self.calculate_reading_stats()
+
         logger.info(
             f"[scrobbling] stopped",
             extra={
@@ -1418,3 +1494,40 @@ class Scrobble(TimeStampedModel):
             beyond_completion = False
 
         return beyond_completion
+
+    def calculate_reading_stats(self, commit=True):
+        # --- Sort safely by numeric page_number ---
+        def safe_page_number(entry):
+            try:
+                return int(getattr("page_number", entry), 0)
+            except (ValueError, TypeError):
+                return float("inf")  # push invalid entries to the end
+
+        page_data = self.log.get("page_data")
+
+        if not page_data:
+            logger.warning("No page data found to calculate")
+            return
+
+        if isinstance(page_data, dict):
+            logger.warning("Page data is dict, migrate koreader data")
+            return
+
+        page_data.sort(key=safe_page_number)
+
+        # --- Extract valid numeric page numbers ---
+        valid_pages = []
+        for page in page_data:
+            try:
+                valid_pages.append(int(page["page_number"]))
+            except (ValueError, TypeError):
+                continue
+
+        # --- Compute stats ---
+        if valid_pages:
+            self.log["page_start"] = min(valid_pages)
+            self.log["page_end"] = max(valid_pages)
+            self.log["pages_read"] = len(set(valid_pages))
+
+            if commit:
+                self.save(update_fields=["log"])

vrobbler/apps/scrobbles/notifications.py

@@ -3,13 +3,26 @@ import requests
 
 from django.conf import settings
 from django.contrib.sites.models import Site
+from django.urls import reverse
 
-class Notification(ABC):
+class BasicNtfyNotification(ABC):
-    scrobble: "Scrobble"
     ntfy_headers: dict = {}
     ntfy_url: str = ""
     title: str = ""
 
+    def __init__(self, profile: "UserProfile"):
+        self.profile = profile.user
+        protocol = "http" if settings.DEBUG else "https"
+        domain = Site.objects.get_current().domain
+        self.url_tmpl = f'{protocol}://{domain}' + '{path}'
+
+    @abstractmethod
+    def send(self) -> None:
+        pass
+
+class ScrobbleNotification(BasicNtfyNotification):
+    scrobble: "Scrobble"
+
     def __init__(self, scrobble: "Scrobble"):
         self.scrobble = scrobble
         self.user = scrobble.user
@@ -19,13 +32,12 @@ class Notification(ABC):
         self.url_tmpl = f'{protocol}://{domain}' + '{path}'
 
 
-
     @abstractmethod
     def send(self) -> None:
         pass
 
 
-class NtfyNotification(Notification):
+class ScrobbleNtfyNotification(ScrobbleNotification):
     def __init__(self, scrobble, **kwargs):
         super().__init__(scrobble)
         self.ntfy_str: str = f"{self.scrobble.media_obj}"
@@ -35,8 +47,8 @@ class NtfyNotification(Notification):
             self.click_url = self.url_tmpl.format(path=self.scrobble.finish_url)
             self.title = "Finish " + self.media_obj.strings.verb.lower() + "?"
 
-        if self.scrobble.log and isinstance(self.scrobble.log, dict) and self.scrobble.log.get("description"):
+        if self.scrobble.log and isinstance(self.scrobble.log, dict) and self.scrobble.log.get("title"):
-            self.ntfy_str += f" - {self.scrobble.log.get('description')}"
+            self.ntfy_str += f" - {self.scrobble.log.get('title')}"
 
     def send(self):
         if (
@@ -55,3 +67,27 @@ class NtfyNotification(Notification):
                     "Click": self.click_url,
                 },
             )
+
+class MoodNtfyNotification(BasicNtfyNotification):
+    def __init__(self, profile, **kwargs):
+        super().__init__(profile)
+        self.ntfy_str: str = "Would you like to check in about your mood?"
+        self.click_url = self.url_tmpl.format(path=reverse("moods:mood_list"))
+        self.title = "Mood Check-in!"
+
+    def send(self):
+        if (
+            self.profile
+            and self.profile.ntfy_enabled
+            and self.profile.ntfy_url
+        ):
+            requests.post(
+                self.profile.ntfy_url,
+                data=self.ntfy_str.encode(encoding="utf-8"),
+                headers={
+                    "Title": self.title,
+                    "Priority": "high",
+                    "Tags": "smiley, check",
+                    "Click": self.click_url,
+                },
+            )

vrobbler/apps/scrobbles/scrobblers.py

@@ -7,7 +7,9 @@ import pendulum
 import pytz
 from beers.models import Beer
 from boardgames.models import BoardGame, BoardGameDesigner, BoardGameLocation
-from books.models import Book
+from books.constants import READCOMICSONLINE_URL
+from books.models import Book, BookLogData, BookPageLogData
+from books.utils import parse_readcomicsonline_uri
 from bricksets.models import BrickSet
 from dateutil.parser import parse
 from django.utils import timezone
@@ -18,6 +20,7 @@ from music.models import Track
 from people.models import Person
 from podcasts.models import PodcastEpisode
 from podcasts.utils import parse_mopidy_uri
+from profiles.models import UserProfile
 from puzzles.models import Puzzle
 from scrobbles.constants import (
     JELLYFIN_AUDIO_ITEM_TYPES,
@@ -25,7 +28,13 @@ from scrobbles.constants import (
     SCROBBLE_CONTENT_URLS,
 )
 from scrobbles.models import Scrobble
-from scrobbles.utils import convert_to_seconds, extract_domain
+from scrobbles.notifications import ScrobbleNtfyNotification
+from scrobbles.utils import (
+    convert_to_seconds,
+    extract_domain,
+    remove_last_part,
+    next_url_if_exists,
+)
 from sports.models import SportEvent
 from sports.thesportsdb import lookup_event_from_thesportsdb
 from tasks.models import Task
@@ -54,18 +63,11 @@ def mopidy_scrobble_media(post_data: dict, user_id: int) -> Scrobble:
 
     if media_type == Scrobble.MediaType.PODCAST_EPISODE:
         parsed_data = parse_mopidy_uri(post_data.get("mopidy_uri", ""))
-        podcast_name = post_data.get(
+        if not parsed_data:
-            "album", parsed_data.get("podcast_name", "")
+            logger.warning("Tried to scrobble podcast but no uri found", extra={"post_data": post_data})
-        )
+            return Scrobble()
 
-        media_obj = PodcastEpisode.find_or_create(
+        media_obj = PodcastEpisode.find_or_create(**parsed_data)
-            title=parsed_data.get("episode_filename", ""),
-            podcast_name=podcast_name,
-            producer_name=post_data.get("artist", ""),
-            number=parsed_data.get("episode_num", ""),
-            pub_date=parsed_data.get("pub_date", ""),
-            mopidy_uri=post_data.get("mopidy_uri", ""),
-        )
     else:
         media_obj = Track.find_or_create(
             title=post_data.get("name", ""),
@@ -121,9 +123,8 @@ def jellyfin_scrobble_media(
         / 10000000
     )
     if media_type == Scrobble.MediaType.VIDEO:
-        media_obj = Video.get_from_imdb_id(
+        imdb_id = post_data.get("Provider_imdb", "")
-            post_data.get("Provider_imdb", "").replace("tt", "")
+        media_obj = Video.find_or_create(imdb_id)
-        )
     else:
         media_obj = Track.find_or_create(
             title=post_data.get("Name", ""),
@@ -160,21 +161,16 @@ def jellyfin_scrobble_media(
 def web_scrobbler_scrobble_media(
     youtube_id: str, user_id: int, status: str = "started"
 ) -> Optional[Scrobble]:
-    video = Video.get_from_youtube_id(youtube_id)
+    video = Video.find_or_create(youtube_id)
     return video.scrobble_for_user(user_id, status, source="Web Scrobbler")
 
 
 def manual_scrobble_video(
-    video_id: str, user_id: int, action: Optional[str] = None
+        video_id: str, user_id: int, source: str = "IMDb", action: Optional[str] = None
 ):
-    if "tt" in video_id:
+    video = Video.find_or_create(video_id)
-        video = Video.get_from_imdb_id(video_id)
-
-    else:
-        video = Video.get_from_youtube_id(video_id)
 
     # When manually scrobbling, try finding a source from the series
-    source = "Vrobbler"
     if video.tv_series:
         source = video.tv_series.preferred_source
     scrobble_dict = {
@@ -203,7 +199,7 @@ def manual_scrobble_video(
 
 
 def manual_scrobble_event(
-    thesportsdb_id: str, user_id: int, action: Optional[str] = None
+    thesportsdb_id: str, user_id: int, source: str = "TheSportsDB", action: Optional[str] = None
 ):
     data_dict = lookup_event_from_thesportsdb(thesportsdb_id)
 
@@ -218,7 +214,7 @@ def manual_scrobble_event(
 
 
 def manual_scrobble_video_game(
-    hltb_id: str, user_id: int, action: Optional[str] = None
+    hltb_id: str, user_id: int, source: str = "HLTB", action: Optional[str] = None
 ):
     game = VideoGame.objects.filter(hltb_id=hltb_id).first()
     if not game:
@@ -240,7 +236,7 @@ def manual_scrobble_video_game(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
         "long_play_complete": False,
     }
 
@@ -258,15 +254,44 @@ def manual_scrobble_video_game(
 
 
 def manual_scrobble_book(
-    title: str, user_id: int, action: Optional[str] = None
+    title: str, user_id: int, source: str = "Google Books", action: Optional[str] = None
 ):
-    book = Book.find_or_create(title)
+    log = {}
+    page = None
+    url = ""
+
+    if READCOMICSONLINE_URL in title:
+        url = title
+        title, volume, page = parse_readcomicsonline_uri(title)
+        if not title:
+            logger.info(
+                "[scrobblers] manual book scrobble request failed",
+                extra={
+                    "title": title,
+                    "user_id": user_id,
+                    "media_type": Scrobble.MediaType.BOOK,
+                },
+            )
+            return
+
+        title = f"{title} - Issue {volume}"
+
+        if not page:
+            page = 1
+
+        logger.info("[scrobblers] Book page included in scrobble, should update!")
+
+        source = READCOMICSONLINE_URL.replace("https://", "")
+
+    # TODO: Check for scrobble of this book already and if so, update the page count
+
+    book = Book.find_or_create(title, url=url, enrich=True)
 
     scrobble_dict = {
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
         "long_play_complete": False,
     }
 
@@ -280,11 +305,23 @@ def manual_scrobble_book(
         },
     )
 
-    return Scrobble.create_or_update(book, user_id, scrobble_dict)
+
+    scrobble = Scrobble.create_or_update(book, user_id, scrobble_dict, read_log_page=page)
+
+    if action == "stop":
+        if url:
+            if isinstance(scrobble.log, "BookLogData"):
+                scrobble.log.resume_url = next_url_if_exists(url)
+            else:
+                scrobble.log["resume_url"] = next_url_if_exists(url)
+            scrobble.save(update_fields=["log"])
+        scrobble.stop(force_finish=True)
+
+    return scrobble
 
 
 def manual_scrobble_board_game(
-    bggeek_id: str, user_id: int, action: Optional[str] = None
+    bggeek_id: str, user_id: int, source: str = "BGG", action: Optional[str] = None
 ) -> Scrobble | None:
     boardgame = BoardGame.find_or_create(bggeek_id)
 
@@ -296,7 +333,7 @@ def manual_scrobble_board_game(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
     }
     logger.info(
         "[vrobbler-scrobble] board game scrobble request received",
@@ -311,29 +348,6 @@ def manual_scrobble_board_game(
     return Scrobble.create_or_update(boardgame, user_id, scrobble_dict)
 
 
-def find_and_enrich_board_game_data(game_dict: dict) -> BoardGame | None:
-    """TODO Move this to a utility somewhere"""
-    game = BoardGame.find_or_create(game_dict.get("bggId"))
-
-    if game:
-        game.cooperative = game_dict.get("cooperative", False)
-        game.highest_wins = game_dict.get("highestWins", True)
-        game.no_points = game_dict.get("noPoints", False)
-        game.uses_teams = game_dict.get("useTeams", False)
-        game.bgstats_id = game_dict.get("uuid", None)
-        if not game.rating:
-            game.rating = game_dict.get("rating") / 10
-        game.save()
-
-        if game_dict.get("designers"):
-            for designer_name in game_dict.get("designers", "").split(", "):
-                designer, created = BoardGameDesigner.objects.get_or_create(
-                    name=designer_name
-                )
-                game.designers.add(designer.id)
-    return game
-
-
 def email_scrobble_board_game(
     bgstat_data: dict[str, Any], user_id: int
 ) -> list[Scrobble]:
@@ -363,11 +377,11 @@ def email_scrobble_board_game(
     log_data = {}
     for game in game_list:
         logger.info(f"Finding and enriching {game.get('name')}")
-        enriched_game = find_and_enrich_board_game_data(game)
+        game_obj = BoardGame.find_or_create(game.get("bggId"), data=game)
         if game.get("isBaseGame"):
-            base_games[game.get("id")] = enriched_game
+            base_games[game.get("id")] = game_obj
-        elif game.get("isExpansion"):
+        if game.get("isExpansion"):
-            expansions[game.get("id")] = enriched_game
+            expansions[game.get("id")] = game_obj
 
     locations = {}
     for location_dict in bgstat_data.get("locations", []):
@@ -390,11 +404,26 @@ def email_scrobble_board_game(
         locations[location_dict.get("id")] = location
 
     scrobbles_created = []
+    second = 0
     for play_dict in bgstat_data.get("plays", []):
+        hour = None
+        minute = None
+        second = None
         if "comments" in play_dict.keys():
-            if "Learning to play" in play_dict.get("comments"):
+            for line in play_dict.get("comments", "").split("\n"):
-                log_data["learning"] = True
+                if "Learning to play" in line:
-            log_data["details"] = play_dict.get("comments")
+                    log_data["learning"] = True
+                if "Start time:" in line:
+                    start_time = line.split(": ")[1]
+                    pieces = start_time.split(":")
+                    hour = int(pieces[0])
+                    minute = int(pieces[1])
+                    try:
+                        second = int(pieces[2])
+                    except IndexError:
+                        second = 0
+
+            log_data["notes"] = [play_dict.get("comments")]
         log_data["expansion_ids"] = []
         try:
             base_game = base_games[play_dict.get("gameRefId")]
@@ -402,7 +431,6 @@ def email_scrobble_board_game(
             try:
                 base_game = expansions[play_dict.get("gameRefId")]
             except KeyError:
-                print(play_dict)
                 logger.info(
                     "Skipping scrobble of play, can't find game",
                     extra={"play_dict": play_dict},
@@ -440,41 +468,62 @@ def email_scrobble_board_game(
                 }
             )
 
-        start = parse(play_dict.get("playDate"))
+        timestamp = parse(play_dict.get("playDate"))
+        if hour and minute:
+            logger.info(f"Scrobble playDate has manual start time {timestamp}")
+            timestamp = timestamp.replace(
+                hour=hour, minute=minute, second=second or 0
+            )
+            logger.info(f"Update to {timestamp}")
+
+        profile = UserProfile.objects.filter(user_id=user_id).first()
+        timestamp = profile.get_timestamp_with_tz(timestamp)
+
         if play_dict.get("durationMin") > 0:
             duration_seconds = play_dict.get("durationMin") * 60
         else:
             duration_seconds = base_game.run_time_seconds
-        stop = start + timedelta(seconds=duration_seconds)
+        stop_timestamp = timestamp + timedelta(seconds=duration_seconds)
+
+        logger.info(f"Creating scrobble for {base_game} at {timestamp}")
         scrobble_dict = {
             "user_id": user_id,
-            "timestamp": start,
+            "timestamp": timestamp,
             "playback_position_seconds": duration_seconds,
             "source": "BG Stats",
             "log": log_data,
         }
 
-        scrobble = Scrobble.objects.filter(
+        scrobble = None
-            board_game=base_game, user_id=user_id, timestamp=start
+        if timestamp.year > 2023:
-        ).first()
+            logger.info(
+                "Scrobbles older than 2024 likely have no time associated just create it"
+            )
+            scrobble = Scrobble.objects.filter(
+                board_game=base_game, user_id=user_id, timestamp=timestamp
+            ).first()
         if scrobble:
             logger.info(
                 "Scrobble already exists, skipping",
                 extra={"scrobble_dict": scrobble_dict, "user_id": user_id},
             )
             continue
-        scrobble = Scrobble.create_or_update(base_game, user_id, scrobble_dict)
+        scrobble = Scrobble.create_or_update(
-        scrobble.stop_timestamp = stop
+            base_game, user_id, scrobble_dict, skip_in_progress_check=True
+        )
+        scrobble.timezone = timestamp.tzinfo.name
+        scrobble.stop_timestamp = stop_timestamp
         scrobble.in_progress = False
         scrobble.played_to_completion = True
         scrobble.save()
         scrobbles_created.append(scrobble)
+        ScrobbleNtfyNotification(scrobble).send()
 
     return scrobbles_created
 
 
 def manual_scrobble_from_url(
-    url: str, user_id: int, action: Optional[str] = None
+        url: str, user_id: int, source: str = "Vrobbler", action: Optional[str] = None
 ) -> Scrobble:
     """We have scrobblable media URLs, and then any other webpages that
     we want to scrobble as a media type in and of itself. This checks whether
@@ -502,11 +551,13 @@ def manual_scrobble_from_url(
 
     if content_key == "-i" and "v=" in url:
         item_id = url.split("v=")[1].split("&")[0]
+    elif content_key == "-c" and "comics" in url:
+        item_id = url
     elif content_key == "-i" and "title/tt" in url:
         item_id = "tt" + str(item_id)
 
     scrobble_fn = MANUAL_SCROBBLE_FNS[content_key]
-    return eval(scrobble_fn)(item_id, user_id, action=action)
+    return eval(scrobble_fn)(item_id, user_id, source=source, action=action)
 
 
 def todoist_scrobble_task_finish(
@@ -550,9 +601,9 @@ def todoist_scrobble_update_task(
         )
         return
 
-    existing_notes = scrobble.log.get("notes", {})
+    if not scrobble.log.get("notes"):
-    existing_notes[todoist_note.get("todoist_id")] = todoist_note.get("notes")
+        scrobble.log["notes"] = []
-    scrobble.log["notes"] = existing_notes
+    scrobble.log["notes"].append(todoist_note.get("notes"))
     scrobble.save(update_fields=["log"])
     logger.info(
         "[todoist_scrobble_update_task] todoist note added",
@@ -578,7 +629,7 @@ def todoist_scrobble_task(
     )
     task = Task.find_or_create(title)
 
-    timestamp = pendulum.parse(todoist_task.get("updated_at", timezone.now()))
+    timestamp = pendulum.parse(todoist_task.pop("updated_at", timezone.now()))
     in_progress_scrobble = Scrobble.objects.filter(
         user_id=user_id,
         in_progress=True,
@@ -620,8 +671,12 @@ def todoist_scrobble_task(
         )
         return todoist_scrobble_task_finish(todoist_task, user_id, timestamp)
 
-    # Default to create new scrobble "if not in_progress_scrobble and in_progress_in_todoist"
+    todoist_task["title"] = todoist_task.pop("description")
-    # TODO Should use updated_at from TOdoist, but parsing isn't working
+    todoist_task["description"] = todoist_task.pop("details")
+    todoist_task["labels"] = todoist_task.pop("todoist_label_list", [])
+    todoist_task.pop("todoist_type")
+    todoist_task.pop("todoist_event")
+
     scrobble_dict = {
         "user_id": user_id,
         "timestamp": timestamp,
@@ -649,8 +704,8 @@ def emacs_scrobble_update_task(
     scrobble = Scrobble.objects.filter(
         in_progress=True,
         user_id=user_id,
-        log__source_id=emacs_id,
+        log__orgmode_id=emacs_id,
-        log__source="orgmode",
+        source="Org-mode",
     ).first()
 
     if not scrobble:
@@ -699,19 +754,18 @@ def emacs_scrobble_task(
     stopped: bool = False,
     user_context_list: list[str] = [],
 ) -> Scrobble | None:
-    source_id = task_data.get("source_id")
+    orgmode_id = task_data.get("source_id")
     title = get_title_from_labels(
         task_data.get("labels", []), user_context_list
     )
 
     task = Task.find_or_create(title)
 
-    timestamp = pendulum.parse(task_data.get("updated_at", timezone.now()))
+    timestamp = pendulum.parse(task_data.pop("updated_at", timezone.now()))
     in_progress_scrobble = Scrobble.objects.filter(
         user_id=user_id,
         in_progress=True,
-        log__source_id=source_id,
+        log__orgmode_id=orgmode_id,
-        log__source="orgmode",
         task=task,
     ).last()
 
@@ -719,7 +773,7 @@ def emacs_scrobble_task(
         logger.info(
             "[emacs_scrobble_task] cannot stop already stopped task",
             extra={
-                "emacs_id": source_id,
+                "orgmode_id": orgmode_id,
             },
         )
         return
@@ -728,7 +782,7 @@ def emacs_scrobble_task(
         logger.info(
             "[emacs_scrobble_task] cannot start already started task",
             extra={
-                "emacs_id": source_id,
+                "ormode_id": orgmode_id,
             },
         )
         return in_progress_scrobble
@@ -738,7 +792,7 @@ def emacs_scrobble_task(
         logger.info(
             "[emacs_scrobble_task] finishing",
             extra={
-                "emacs_id": source_id,
+                "orgmode_id": orgmode_id,
             },
         )
         in_progress_scrobble.stop(timestamp=timestamp, force_finish=True)
@@ -749,11 +803,17 @@ def emacs_scrobble_task(
 
     notes = task_data.pop("notes")
     if notes:
-        task_data["notes"] = []
+        task_data["notes"] = [note.get("content") for note in notes]
-        for note in notes:
+    task_data["title"] = task_data.pop("description")
-            task_data["notes"].append(
+    task_data["description"] = task_data.pop("body")
-                {note.get("timestamp"): note.get("content")}
+    task_data["labels"] = task_data.pop("labels")
-            )
+
+    task_data["orgmode_id"] = task_data.pop("source_id")
+    task_data["orgmode_state"] = task_data.pop("state")
+    task_data["orgmode_properties"] = task_data.pop("properties")
+    task_data["orgmode_drawers"] = task_data.pop("drawers")
+    task_data["orgmode_timestamps"] = task_data.pop("timestamps")
+    task_data.pop("source")
 
     scrobble_dict = {
         "user_id": user_id,
@@ -776,9 +836,10 @@ def emacs_scrobble_task(
     return scrobble
 
 
-def manual_scrobble_task(url: str, user_id: int, action: Optional[str] = None):
+def manual_scrobble_task(url: str, user_id: int, source: str = "Vrobbler", action: Optional[str] = None):
     source_id = re.findall(r"\d+", url)[0]
 
+    description = ""
     if "todoist" in url:
         source = "Todoist"
         title = "Generic Todoist task"
@@ -807,7 +868,7 @@ def manual_scrobble_task(url: str, user_id: int, action: Optional[str] = None):
 
 
 def manual_scrobble_webpage(
-    url: str, user_id: int, action: Optional[str] = None
+        url: str, user_id: int, source: str = "Bookmarklet", action: Optional[str] = None
 ):
     webpage = WebPage.find_or_create({"url": url})
 
@@ -815,7 +876,7 @@ def manual_scrobble_webpage(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
     }
     logger.info(
         "[vrobbler-scrobble] webpage scrobble request received",
@@ -828,8 +889,13 @@ def manual_scrobble_webpage(
     )
 
     scrobble = Scrobble.create_or_update(webpage, user_id, scrobble_dict)
-    # possibly async this?
+
-    scrobble.push_to_archivebox()
+    if action == "stop":
+        scrobble.stop(force_finish=True)
+    else:
+        # possibly async this?
+        scrobble.push_to_archivebox()
+
     return scrobble
 
 
@@ -929,7 +995,7 @@ def web_scrobbler_scrobble_video_or_song(
 
 
 def manual_scrobble_beer(
-    untappd_id: str, user_id: int, action: Optional[str] = None
+        untappd_id: str, user_id: int, source: str = "Untappd", action: Optional[str] = None
 ):
     beer = Beer.find_or_create(untappd_id)
 
@@ -941,7 +1007,7 @@ def manual_scrobble_beer(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
     }
     logger.info(
         "[vrobbler-scrobble] beer scrobble request received",
@@ -958,7 +1024,7 @@ def manual_scrobble_beer(
 
 
 def manual_scrobble_puzzle(
-    ipdb_id: str, user_id: int, action: Optional[str] = None
+        ipdb_id: str, user_id: int, source: str = "IPDb", action: Optional[str] = None
 ):
     puzzle = Puzzle.find_or_create(ipdb_id)
 
@@ -970,7 +1036,7 @@ def manual_scrobble_puzzle(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
     }
     logger.info(
         "[vrobbler-scrobble] puzzle scrobble request received",
@@ -987,7 +1053,7 @@ def manual_scrobble_puzzle(
 
 
 def manual_scrobble_brickset(
-    brickset_id: str, user_id: int, action: Optional[str] = None
+        brickset_id: str, user_id: int, source: str = "BrickSet", action: Optional[str] = None
 ):
     brickset = BrickSet.find_or_create(brickset_id)
 
@@ -999,7 +1065,7 @@ def manual_scrobble_brickset(
         "user_id": user_id,
         "timestamp": timezone.now(),
         "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
         "log": {"serial_scrobble_id": ""},
     }
     logger.info(

vrobbler/apps/scrobbles/templatetags/form_tags.py

@@ -0,0 +1,11 @@
+from django import template
+
+register = template.Library()
+
+
+@register.filter(name="add_class")
+def add_class(field, css_class):
+    # If the widget is CheckboxInput, skip adding 'form-control'
+    if field.field.widget.__class__.__name__ == "CheckboxInput":
+        return field.as_widget()
+    return field.as_widget(attrs={"class": css_class})

vrobbler/apps/scrobbles/urls.py

@@ -95,6 +95,11 @@ urlpatterns = [
         views.ScrobbleLongPlaysView.as_view(),
         name="long-plays",
     ),
+    path(
+        "scrobble/<slug:uuid>/",
+        views.ScrobbleDetailView.as_view(),
+        name="detail",
+    ),
     path("scrobble/<slug:uuid>/start/", views.scrobble_start, name="start"),
     path("scrobble/<slug:uuid>/finish/", views.scrobble_finish, name="finish"),
     path("scrobble/<slug:uuid>/cancel/", views.scrobble_cancel, name="cancel"),

vrobbler/apps/scrobbles/utils.py

@@ -1,19 +1,27 @@
 import hashlib
 import logging
+import requests
 import re
-from datetime import datetime, timedelta
+from datetime import date, datetime, timedelta
+from typing import TYPE_CHECKING, Optional
 from urllib.parse import urlparse
 from zoneinfo import ZoneInfo
 
+import pendulum
 import pytz
 from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.db import models
+from django.db.models.fields.json import KeyTextTransform
+from django.db.models.functions import Cast, TruncDate
 from django.utils import timezone
 from profiles.models import UserProfile
 from profiles.utils import now_user_timezone
 from scrobbles.constants import LONG_PLAY_MEDIA
-from scrobbles.notifications import NtfyNotification
+from scrobbles.notifications import (
+    MoodNtfyNotification,
+    ScrobbleNtfyNotification,
+)
 from scrobbles.tasks import (
     process_koreader_import,
     process_lastfm_import,
@@ -21,6 +29,9 @@ from scrobbles.tasks import (
 )
 from webdav.client import get_webdav_client
 
+if TYPE_CHECKING:
+    from scrobbles.models import Scrobble
+
 logger = logging.getLogger(__name__)
 User = get_user_model()
 
@@ -114,6 +125,8 @@ def get_long_plays_completed(user: User) -> list:
 
 def import_lastfm_for_all_users(restart=False):
     """Grab a list of all users with LastFM enabled and kickoff imports for them"""
+    from scrobbles.importers.lastfm import LastFM
+
     LastFmImport = apps.get_model("scrobbles", "LastFMImport")
     lastfm_enabled_user_ids = UserProfile.objects.filter(
         lastfm_username__isnull=False,
@@ -124,6 +137,31 @@ def import_lastfm_for_all_users(restart=False):
     lastfm_import_count = 0
 
     for user_id in lastfm_enabled_user_ids:
+
+        lfm_import = LastFmImport.objects.filter(
+            user_id=user_id, processed_finished__isnull=False
+        ).last()
+        if lfm_import:
+            last_processed = lfm_import.processed_finished
+        else:
+            logger.info(
+                f"Not resuming failed LastFM import {lfm_import.id} for user {user_id}, use restart=True to restart"
+                "No existing LastFM import, we should start a monthly parsing of lastFm for this user going back to 2002"
+            )
+            continue
+
+        lfm_client = LastFM(
+            user=get_user_model().objects.filter(id=user_id).first()
+        )
+
+        has_scrobbles = lfm_client.get_last_scrobbles(
+            time_from=last_processed, check=True
+        )
+
+        if not has_scrobbles:
+            logger.info("No new scrobbles to import from LastFM")
+            continue
+
         lfm_import, created = LastFmImport.objects.get_or_create(
             user_id=user_id, processed_finished__isnull=True
         )
@@ -291,7 +329,20 @@ def send_stop_notifications_for_in_progress_scrobbles() -> int:
         ).seconds
 
         if elapsed_scrobble_seconds > scrobble.media_obj.run_time_seconds:
-            NtfyNotification(scrobble, end=True).send()
+            ScrobbleNtfyNotification(scrobble, end=True).send()
+            notifications_sent += 1
+
+    return notifications_sent
+
+def send_mood_checkin_reminders() -> int:
+    """Get all profiles with mood check-ins enabled and checkin!"""
+    from profiles.models import UserProfile
+
+    now = timezone.now()
+    notifications_sent = 0
+    for profile in UserProfile.objects.filter(mood_checkin_enabled=True):
+        if profile.mood_checkin_frequency == "hourly" and now.minute == 0:
+            MoodNtfyNotification(profile).send()
             notifications_sent += 1
 
     return notifications_sent
@@ -305,3 +356,98 @@ def extract_domain(url):
         + parsed_url.netloc.split(".")[-1]
     )
     return domain
+
+def fix_playback_position_seconds(*scrobbles: "Scrobble", commit=True) -> list["Scrobble"]:
+    updated_scrobbles = list()
+    for scrobble in scrobbles:
+        if not scrobble.media_obj:
+            logger.info(f"No media object found for scrobble {scrobble.id}, cannot update elapsed time")
+            continue
+
+        if scrobble.media_type == "Track" and scrobble.media_obj.run_time_seconds:
+            too_long = scrobble.playback_position_seconds > scrobble.media_obj.run_time_seconds
+            zero = scrobble.playback_position_seconds == 0
+            null = not scrobble.playback_position_seconds
+            if too_long or zero or null:
+                scrobble.playback_position_seconds = scrobble.media_obj.run_time_seconds
+                updated_scrobbles.append(scrobble)
+                if commit:
+                    scrobble.save(update_fields=["playback_position_seconds"])
+
+    return updated_scrobbles
+
+
+def base_scrobble_qs(user_id: int) -> models.QuerySet:
+    """Base queryset with calories extracted as integer and day annotated."""
+    from scrobbles.models import Scrobble
+
+    return (
+        Scrobble.objects
+        .annotate(day=TruncDate("timestamp"))
+        .annotate(calories_int=Cast(KeyTextTransform("calories", "log"), models.IntegerField()))
+        .filter(calories_int__isnull=False, user_id=user_id)
+    )
+
+def get_daily_calories_for_user_by_day(user_id: int, date: date| str) -> int:
+    """Return total calories for a user on a specific day."""
+
+    if isinstance(date, str):
+        date = pendulum.parse(date)
+
+    try:
+        qs = base_scrobble_qs(user_id).filter(day=date)
+        agg = qs.aggregate(total_calories=models.Sum("calories_int"))
+    except AttributeError as e:
+        logger.warning(f"Can't generate calorie total: {e}")
+        agg = {}
+
+    return agg.get("total_calories") or 0
+
+def get_daily_calorie_dict_for_user(user_id: int) -> dict[date, int]:
+    """Return {day: total_calories} for all days with scrobbles, in one query."""
+    qs = (
+        base_scrobble_qs(user_id)
+        .values("day")
+        .annotate(total_calories=models.Sum("calories_int"))
+        .order_by("day")
+    )
+
+    return {entry["day"]: entry["total_calories"] for entry in qs}
+
+def remove_last_part(url: str) -> str:
+    url = url.rstrip('/')
+    if '/' not in url:
+        return url
+    return url.rsplit('/', 1)[0]
+
+def next_url_if_exists(url: str) -> str:
+    # Normalize (remove trailing slash)
+    url = url.rstrip('/')
+
+    # Find last number in the URL path
+    match = re.search(r'(\d+)(?:/?$)', url)
+    if not match:
+        logger.info("No numeric segment found in the URL", extra={"url": url})
+        return ""
+
+    number = int(match.group(1))
+    new_number = number + 1
+
+    # Replace only the last occurrence of that number
+    new_url = re.sub(rf'{number}(?:/?$)', f'{new_number}/', url + '/', 1)
+
+    # Check if the new URL exists
+    try:
+        resp = requests.head(new_url, allow_redirects=True, timeout=5)
+        if resp.status_code == 200:
+            return new_url
+        else:
+            # Fallback: some sites may not support HEAD well — try GET
+            resp = requests.get(new_url, timeout=5)
+            if resp.status_code == 200:
+                return new_url
+    except requests.RequestException:
+        pass
+
+    # If it doesn’t exist
+    return ""

vrobbler/apps/scrobbles/views.py

@@ -2,23 +2,27 @@ import calendar
 import json
 import logging
 from datetime import datetime, timedelta
-from dateutil.relativedelta import relativedelta
 
 import pendulum
 import pytz
+from dateutil.relativedelta import relativedelta
 from django.apps import apps
 from django.contrib import messages
 from django.contrib.auth.mixins import LoginRequiredMixin
-from django.db.models import Count, Q
+from django.core.paginator import EmptyPage, PageNotAnInteger, Paginator
+from django.db.models import Count, Max, Q
 from django.db.models.query import QuerySet
 from django.http import FileResponse, HttpResponseRedirect, JsonResponse
+from django.shortcuts import redirect
 from django.urls import reverse_lazy
 from django.utils import timezone
 from django.views.decorators.csrf import csrf_exempt
 from django.views.generic import DetailView, FormView, TemplateView
 from django.views.generic.edit import CreateView
 from django.views.generic.list import ListView
+from moods.models import Mood
 from music.aggregators import live_charts, scrobble_counts, week_of_scrobbles
+from pendulum.parsing.exceptions import ParserError
 from rest_framework import status
 from rest_framework.decorators import (
     api_view,
@@ -51,6 +55,7 @@ from scrobbles.tasks import (
     process_tsv_import,
 )
 from scrobbles.utils import (
+    get_daily_calories_for_user_by_day,
     get_long_plays_completed,
     get_long_plays_in_progress,
 )
@@ -64,15 +69,22 @@ class ScrobbleableListView(ListView):
 
     def get_queryset(self):
         queryset = super().get_queryset()
+        if self.model == Mood:
+            return queryset
+
+        user_filter = Q()
         if not self.request.user.is_anonymous:
-            queryset = queryset.annotate(
+            user_filter = Q(scrobble__user=self.request.user)
-                scrobble_count=Count("scrobble"),
+
-                filter=Q(scrobble__user=self.request.user),
+        queryset = (
-            ).order_by("-scrobble_count")
+            queryset.filter(user_filter)
-        else:
+            .annotate(
-            queryset = queryset.annotate(
+                scrobble_count=Count("scrobble", distinct=True),
-                scrobble_count=Count("scrobble")
+                last_scrobble=Max("scrobble__timestamp"),
-            ).order_by("-scrobble_count")
+            )
+            .filter(scrobble_count__gt=0)
+            .order_by("-last_scrobble")
+        )
         return queryset
 
 
@@ -80,13 +92,30 @@ class ScrobbleableDetailView(DetailView):
     model = None
     slug_field = "uuid"
 
+    paginate_by = 200  # You can set this to whatever page size you want
+
     def get_context_data(self, **kwargs):
         context_data = super().get_context_data(**kwargs)
-        context_data["scrobbles"] = list()
+        scrobbles = []
         if not self.request.user.is_anonymous:
-            context_data["scrobbles"] = self.object.scrobble_set.filter(
+            scrobbles = self.object.scrobble_set.filter(
                 user=self.request.user
-            )
+            ).order_by("-timestamp")
+
+        paginator = Paginator(scrobbles, self.paginate_by)
+        page_number = self.request.GET.get("page")
+
+        try:
+            page_obj = paginator.page(page_number)
+        except PageNotAnInteger:
+            page_obj = paginator.page(1)
+        except EmptyPage:
+            page_obj = paginator.page(paginator.num_pages)
+
+        context_data["page_obj"] = page_obj
+        context_data["scrobbles"] = page_obj.object_list
+        context_data["is_paginated"] = paginator.num_pages > 1
+
         return context_data
 
 
@@ -98,8 +127,9 @@ class RecentScrobbleList(ListView):
         if user.is_authenticated:
             if scrobble_url := self.request.GET.get("scrobble_url", ""):
                 action = self.request.GET.get("action", "")
+                source = self.request.GET.get("source", "Bookmarklet")
                 scrobble = manual_scrobble_from_url(
-                    scrobble_url, self.request.user.id, action
+                    scrobble_url, self.request.user.id, source, action
                 )
                 return HttpResponseRedirect(scrobble.redirect_url(user.id))
         return super().get(*args, **kwargs)
@@ -118,7 +148,7 @@ class RecentScrobbleList(ListView):
             if date_str:
                 try:
                     date = pendulum.parse(date_str)
-                except:
+                except ParserError:
                     pass
             if date_str:
                 if date_str == "this_week" or "-W" in date_str:
@@ -201,7 +231,8 @@ class RecentScrobbleList(ListView):
                 processed_finished__isnull=True,
                 user=self.request.user,
             )
-            data["counts"] = [] #scrobble_counts(user)
+            data["counts"] = []  # scrobble_counts(user)
+            data["daily_calories"] = get_daily_calories_for_user_by_day(self.request.user.id, date)
         else:
             data["weekly_data"] = week_of_scrobbles()
             data["counts"] = scrobble_counts()
@@ -574,8 +605,7 @@ def scrobble_start(request, uuid):
             "[scrobble_start] media object not found",
             extra={"uuid": uuid, "user_id": user.id},
         )
-        # TODO Log that we couldn't find a media obj to scrobble
+        raise Exception("No media object provided to scrobble")
-        return
 
     scrobble = None
     user_id = request.user.id
@@ -595,9 +625,9 @@ def scrobble_start(request, uuid):
 
     if (
         user.profile.redirect_to_webpage
-        and media_obj.__class__.__name__ == Scrobble.MediaType.WEBPAGE
+        and (media_obj.__class__.__name__ == Scrobble.MediaType.WEBPAGE or media_obj.__class__.__name__ == Scrobble.MediaType.BOOK)
     ):
-        logger.info(f"Redirecting to {media_obj} detail apge")
+        logger.info(f"Redirecting to {media_obj} detail page")
         return HttpResponseRedirect(media_obj.url)
 
     return HttpResponseRedirect(success_url)
@@ -904,3 +934,63 @@ class ScrobbleStatusView(LoginRequiredMixin, TemplateView):
         ).first()
 
         return data
+
+
+class ScrobbleDetailView(DetailView):
+    model = Scrobble
+    slug_field = "uuid"
+    slug_url_kwarg = "uuid"
+
+    def get_form_class(self):
+        return self.object.media_obj.logdata_cls().form()
+
+    def get_form(self):
+        FormClass = self.get_form_class()
+
+        log = self.object.log or {}
+        initial_notes = log.get("notes", [])
+        if isinstance(initial_notes, list) and len(initial_notes) > 0 and isinstance(initial_notes[0], dict):
+            notes_str = note_list_to_str(notes)
+        else:
+            notes_str = "\n".join(initial_notes) if initial_notes else ""
+
+        notes_str_fixed = notes_str.encode("utf-8").decode(
+            "unicode_escape"
+        )
+        log["notes"] = notes_str_fixed
+
+        return FormClass(initial=log)
+
+    def post(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        FormClass = self.get_form_class()
+        form = FormClass(request.POST)
+
+        if form.is_valid():
+            data = form.cleaned_data.copy()
+
+            for field_name, field in form.fields.items():
+                if field.disabled:
+                    original_value = (self.object.log or {}).get(field_name)
+                    data[field_name] = original_value
+
+            if data.get("with_people_ids", False):
+                data["with_people_ids"] = [
+                    p.id for p in data["with_people_ids"]
+                ]
+
+            if data.get("platform_id", False):
+                data["platform_id"] = data["platform_id"].id
+
+            self.object.log = data
+            self.object.save(update_fields=["log"])
+            return redirect(self.object.get_absolute_url())
+
+        context = self.get_context_data(log_form=form)
+        return self.render_to_response(context)
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        if "log_form" not in context:
+            context["log_form"] = self.get_form()
+        return context

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

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