[release] Bump to version 45.1

- Mopidy favorites or monthly playlist adds should look at all scrobbles

.gitea/workflows/build.yml

@@ -0,0 +1,68 @@
+name: build
+
+on:
+  push:
+    branches: ["**"]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    env:
+      VROBBLER_DATABASE_URL: sqlite:///test.db
+      VROBBLER_USDA_API_KEY: ${{ vars.VROBBLER_USDA_API_KEY }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Cache pip/poetry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/pip
+            ~/.cache/pypoetry
+          key: ${{ runner.os }}-py311-${{ hashFiles('**/poetry.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-py311-
+
+      - name: Install Poetry
+        run: |
+          python -m pip install --upgrade pip
+          pip install poetry
+
+      - name: Install deps
+        run: |
+          cp vrobbler.conf.test vrobbler.conf
+          poetry install --with test
+
+      - name: Pytest with coverage
+        run: |
+          poetry run pytest -n 5 --cov-report term:skip-covered --cov=vrobbler tests
+
+      - name: Notify success (ntfy)
+        if: success()
+        run: |
+          curl -fsS \
+            -H "Title: vrobbler CI success" \
+            -H "Priority: low" \
+            -H "Tags: success,vrobbler" \
+            -H "Actions: view, Changes, ${{ gitea.server_url }}/${{ gitea.repository }}/commit/${{ gitea.sha }}; view, Build, ${{ gitea.server_url }}/${{ gitea.repository }}/actions/runs/${{ gitea.run_id }}" \
+            -d "✅ Build succeeded: ${{ gitea.repository }} @ ${{ gitea.sha }}" \
+            https://ntfy.unbl.ink/drone
+
+      - name: Notify failure (ntfy)
+        if: failure()
+        run: |
+          curl -fsS \
+            -H "Title: vrobbler CI failure" \
+            -H "Priority: high" \
+            -H "Tags: failure,vrobbler" \
+            -H "Actions: view, Changes, ${{ gitea.server_url }}/${{ gitea.repository }}/commit/${{ gitea.sha }}; view, Build, ${{ gitea.server_url }}/${{ gitea.repository }}/actions/runs/${{ gitea.run_id }}" \
+            -d "❌ Build failed: ${{ gitea.repository }} @ ${{ gitea.sha }}" \
+            https://ntfy.unbl.ink/drone

.gitea/workflows/deploy.yml

@@ -1,10 +1,8 @@
-name: build & deploy
+name: deploy
 
 on:
   push:
-    branches: ["**"]
     tags: ["*"]
-  pull_request:
 
 jobs:
   test:
@@ -22,7 +20,6 @@ jobs:
         with:
           python-version: "3.11"
 
-      # Cache pip + Poetry caches (rough equivalent to your mounted pip_cache)
       - name: Cache pip/poetry
         uses: actions/cache@v4
         with:
@@ -47,7 +44,6 @@ jobs:
         run: |
           poetry run pytest -n 5 --cov-report term:skip-covered --cov=vrobbler tests
 
-      # Notifications (success/failure) for the test job
       - name: Notify success (ntfy)
         if: success()
         run: |
@@ -71,8 +67,6 @@ jobs:
             https://ntfy.unbl.ink/drone
 
   build-and-deploy:
-    # Only deploy on tags (equivalent to Drone when: ref: refs/tags/*)
-    # if: startsWith(gitea.ref, 'refs/tags/')
     needs: [test]
     runs-on: ubuntu-latest
 
@@ -97,12 +91,19 @@ jobs:
 
       - name: Build package with commit info
         run: |
-          # Write commit to _commit.py before build
           echo "commit = '$(echo ${{ gitea.sha }} | cut -c1-8)'" > vrobbler/_commit.py
           poetry build
-          # Restore original _commit.py
           git checkout vrobbler/_commit.py
 
+      - name: Clean old wheels from server
+        uses: appleboy/ssh-action@v1.0.3
+        with:
+          host: vrobbler.service
+          username: root
+          key: ${{ secrets.JAIL_KEY }}
+          script: |
+            rm -f /var/lib/vrobbler/dist/*.whl
+
       - name: Copy wheel to server and deploy
         uses: appleboy/scp-action@v1.0.0
         with:
@@ -120,10 +121,13 @@ jobs:
           key: ${{ secrets.JAIL_KEY }}
           command_timeout: 2m
           script: |
+            set -e
             mkdir -p /var/lib/vrobbler
             echo "${{ gitea.sha }}" | cut -c1-8 > /var/lib/vrobbler/commit.txt
             pip uninstall -y vrobbler
             pip install /var/lib/vrobbler/dist/*.whl
+            rm -f /var/lib/vrobbler/dist/*.whl
+            python3 -c "import vrobbler; print(f'vrobbler {vrobbler.__version__} installed OK')"
             vrobbler migrate
             vrobbler collectstatic --noinput
             immortalctl restart vrobbler-celery && immortalctl restart vrobbler-celerybeat && immortalctl restart vrobbler

PROJECT.org

@@ -93,7 +93,7 @@ fetching and simple saving.
 :LOGBOOK:
 CLOCK: [2025-07-09 Wed 09:55]--[2025-07-09 Wed 10:15] =>  0:20
 :END:
-* Backlog [26/42] :vrobbler:project:personal:
+* Backlog [0/13] :vrobbler:project:personal:
 ** TODO [#C] Add sentiment parsing for Scrobbles with notes :vrobbler:project:scrobbles:sentiment:
 :PROPERTIES:
 :ID:       37781d6a-f3b0-48b2-bf98-33c2c791cf85
@@ -400,10 +400,21 @@ CLOCK: [2025-07-09 Wed 09:55]--[2025-07-09 Wed 10:15] =>  0:20
 :PROPERTIES:
 :ID:       133bcf71-078f-4efa-a029-1eae4b4d146d
 :END:
-** TODO [#B] Add importer class for IMAP imports :vrobbler:feature:imap:importers:project:personal:
-:PROPERTIES:
-:ID:       b1426d92-2feb-4d15-9738-d5b7b0594f96
-:END:
+** TODO [#C] Fix exporting so it works reliably :exporting:project:feature:
+
+*** Description
+
+The existing export function is very naieve. It runs in the web process, takes
+too long and just dumps tracks. We should make it more robust by creating one
+CSV file per scrobble media type and writing them into a zip file that gets
+placed in the media directory:
+
+`/media/exports/user_<user_id>/<timestamp>-export.zip`
+
+And this should all be done in a celery task that is just kicked off by the
+"Export" button on the frontend
+
+
 ** TODO [#B] Add AllTrails as a source for Trail data :vrobbler:trails:feature:personal:project:
 :PROPERTIES:
 :ID:       39313362-cdfe-46e7-bbd4-9139a65c0b3c
@@ -414,7 +425,7 @@ 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:
+** TODO [#B] Add `garmin_activity_id` to the TrailLogData class :trails:feature:personal:project:
 :PROPERTIES:
 :ID:       5a4fb0f8-0555-40ec-b06f-93c26bd686f4
 :END:
@@ -423,12 +434,21 @@ AllTrails is the best source, though having TrailForks is nice to.
 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:
+** TODO [#B] Fix how we show notes and descriptions from scrobbles to users :metadata:notes:tasks:
+:PROPERTIES:
+:ID:       adf4c513-a417-4ec9-8831-f01ffcf63276
+:END:
+*** Description
+
+Currently the display of notes leaves something to be desired. The biggest issue
+is that they don't look good on mobile and are probably trying to be too cute.
+Rather than post-it note style, we should just put notes in a list under the
+description, above the Edit Log toggle, with timestamps for when they were
+added.
+
+They should also probably support markdown formatting and that should be
+displayed in the template.
 
-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] Scrape ComicBookRoundUp ratings for comic book metadata :vrobbler:books:feature:comicbook:personal:project:
@@ -436,11 +456,11 @@ https://app.todoist.com/app/task/add-a-csv-endpoint-for-users-book-reads-that-li
 - 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 [#A] Find page numbers for comic books from ComicVine :vrobbler:feature:books:personal:project:
+** TODO [#B] Find page numbers for comic books from ComicVine :feature:books:
 :PROPERTIES:
 :ID:       79f867c3-1288-4143-b6bf-2a452983ee9f
 :END:
-** TODO [#A] Fix koreader scrobble imports to use DST properly :vrobbler:personal:bug:books:imports:
+** TODO [#B] Fix koreader scrobble imports to use DST properly :bug:books:imports:
 :PROPERTIES:
 :ID:       79758cba-a440-48b6-a637-efb88827acf2
 :END:
@@ -466,16 +486,503 @@ whatever time KoReader reports, we need to know, given the date and the user
 profile's historic timezone, how many hours to adjust the KoReader time to get
 to GMT to save it in the database.
 
-** TODO [#A] When creating org-mode tasks, don't copy comments :vrobbler:bug:scrobbles:tasks:
+** TODO [#A] Make IMAP and WebDAV configurable :webdav:feature:imap:importers:
+:PROPERTIES:
+:ID:       b1426d92-2feb-4d15-9738-d5b7b0594f96
+:END:
+
+*** Description
+
+Currently we have webdav able to import post types of file-based incoming data,
+usually in the form of CSVs but also gpx files, bgstats json files, and
+audioscrobbler TSV files.
+
+What if the user could specify via their profile (settings) which imports they
+wanted to use IMAP for and which ones they wanted to use WebDAV for.
+
+Then we'd have two celery tasks that would be kicked off periodically via
+celerybeat, one for IMAP imports every 12 minutes and one for WebDAV every 3
+minutes. Both would be responsible for checking if a user has an configured
+imports of their type, check if an import needs to run, and dispatch the
+needed import celery task. This is how the WebDAV celery task currently works.
+
+This would also be an opporunity to clean up the code around WebDAV imports
+and make them more re-usable for other import services.
+
+* Version 45.1 [1/1]
+** DONE [#B] Mopidy favorites or monthly playlist adds should look at all scrobbles :bug:mopidy:favorites:tracks:
+:PROPERTIES:
+:ID:       0be7d11e-e268-2fd5-836a-e5b4d210e0fa
+:END:
+
+*** Description
+
+When favoriting a track and trying to add it to the Moidy favorite playlist, it
+sometimes happens that one scrobble did not come from Mopidy, but an earlier or
+later one did.
+
+Can we scan all the scrobbles of the track for a given user to see if any have
+`mopidy_uri` in the log and if so, use that to send along to Mopidy?
+
+
+* Version 45.0 [1/1]
+** DONE [#B] Add ability to add mopidy tracks to Monthly playlists :feature:favorites:tracks:
+:PROPERTIES:
+:ID:       c872ff0a-e71f-415f-b5a6-e62ea9634d14
+:END:
+
+*** Description
+
+Now that we can favorite a mopidy track and have it added to a Favorites playlist, it would
+be great if we could also populate a monthly_mopidy_playlist_pattern in a user profile and,
+if configured, you could press "Add to monthly playlist" button on a given track that has
+a  mopidy_uri in it's log, and it would be added to the playlist.
+
+The patterns would be based on traditional Django date formatting patterns: https://gregbrown.co/code/date-format
+
+So "Y m F" would yield "2026 05 May" if the link is clicked in May of 2026.
+
+
+* Version 44.0 [1/1]
+** DONE [#B] Add favorite feature for scrobbles :feature:favorites:scrobbles:
+:PROPERTIES:
+:ID:       2780ae5f-fe23-49a5-8b33-d19e7f3e8ec6
+:END:
+
+*** Description
+
+Would be great to have a FavoriteMedia data model that would accept any media_type ID and a user_id
+marking that media as a favorite for that user.
+
+Additionally, for tracks, we should add the ability to set a "favorites_mopidy_playlist" in a user profile
+and if populated, and a track media type is favorited, and the track has a mopidy_uri value in a scrobble log,
+send a POST to the mopidy server RPC endpoint for the favorite playlist and add the track.
+
+
+
+* Version 43.0 [5/5]
+** DONE [#B] Can we show a graph of all past Weigh-in tasks :scale:tasks:graphs:javascript:
+:PROPERTIES:
+:ID:       ae499d87-03bf-4e48-9b2c-1a421a46af11
+:END:
+
+*** Description
+
+I wonder if, as a special type of task, Weigh-in's could show a graph of the
+metrics that are stored against all the past weigh-ins?
+
+The graph would contain all Weigh-in scrobbles for that user, no matter which
+date is being viewed, and the highlighted value on the graph would be the date
+being viewed.
+
+Probably could use something like chart.js although maybe that's too heavy?
+
+And can we have each metric overlayed on the same graph?
+
+** DONE [#B] When viewing scrobbles by tag, sum the total time :scrobbles:tags:
+:PROPERTIES:
+:ID:       d51f23df-c2c5-4e1a-b000-67c89032af02
+:END:
+
+*** Description
+
+On scrobbles filtered by tags, we should see a sum of the time spent doing those tasks, in a human
+readable format like "X days, X hours, X minutes and X seconds"
+
+** DONE [#A] Orgmode tasks are not updated if in progress :tasks:orgmode:bug:
+:PROPERTIES:
+:ID:       7dcebb2c-7c4c-4ac5-bee6-c2e36c3811f9
+:END:
+
+*** Description
+
+Currently if you POST to the orgmode webhook with a task that's already in progress, the request just stops there.
+
+We should add logic where if the task is in-progress, instead of doing nothing,
+it checks the webhook payload against the in-progress tasks and updates the
+description of the scrobble.log with the incoming task description if it's
+different. And the same for comments. If a comment (by timestamp key) is
+different in the webhook than what's in the scrobble.log, update the comment in
+the scrobble.log
+
+** DONE [#A] Ignore tag 'inprogress' for Tasks :bug:tasks:tags:
+:PROPERTIES:
+:ID:       cd37c1ec-e2fc-b93c-daf8-6b329712c3f1
+:END:
+
+*** Description
+
+When scrobbling tasks from Todoist, the tag `inprogress` is always in the
+payload, because that's how we parse tasks starting from the Todoist webhooks.
+
+But we don't really need anything tagged as `inprogress` Can we ignore this tag
+when applying tags to Task scrobbles coming from Todoist?`
+
+
+
+** DONE [#A] Deploys are now throwing an unknown version error :bug:tooling:releases:
+:PROPERTIES:
+:ID:       3870f9d3-b5ed-4b87-9e8c-9bf905bfb766
+:END:
+ 
+*** Description
+
+Almost everything is working, but for some reason `__version__` does not seem to
+exist.
+
+#+begin_src sh
+out: Installing collected packages: vrobbler
+out: Successfully installed vrobbler-42.0
+err: WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+err: Traceback (most recent call last):
+err:   File "<string>", line 1, in <module>
+err: AttributeError: module 'vrobbler' has no attribute '__version__'
+2026/06/04 17:18:15 Process exited with status 1
+failed to remove container: Error response from daemon: removal of container c8ac64bee9b6bf5978d2c16f299e5ac271d8bbf7192b7a4023c3712bc2444f8b is already in progress
+  ❌  Failure - Main Install wheel and restart services
+exit with `FAILURE`: 1
+#+end_src
+
+
+* Version 42.0 [1/1]
+** DONE [#B] Add ability to add track to current Mopidy queue :feature:mopidy:tracks:
+:PROPERTIES:
+:ID:       79d5b580-4ea6-461b-4c6c-2c950d8b3e4c
+:END:
+
+
+* Version 41.0 [5/5]
+** DONE [#B] For any scrobble detail page with notes display them better :templates:notes:scrobbles:
+:PROPERTIES:
+:ID:       c0dcf9da-227f-4a22-bcd9-9d46053607d9
+:END:
+
+*** Description
+
+Currently notes are displayed as little post-it notes. This is cute, but not terribly useful.
+
+We should update note rendering to be a simple newest to oldest display in a
+single column with the timestamp has a small header, and the content rendered as
+markdown with a small bar or horizontal divider marking them from the next note.
+
+** DONE [#A] Imports should send notifications :feature:notifications:imports:
+:PROPERTIES:
+:ID:       6f78f8d5-ecaa-4d8a-a666-ae4e27653191
+:END:
+
+*** Description
+
+Currently importing board games sends out a ntfy message when a scrobble is
+created.
+
+We should do the same thing for other import types; namely: gpx, ebird, and scale.
+
+** DONE [#A] Board game imports send duplicate ntfy message :bug:notifications:boardgames:
+:PROPERTIES:
+:ID:       8f067432-0399-4b79-9e93-727edcccedbd
+:END:
+
+*** Description 
+
+When a board game scrobble is created via a bgstats import, ntfy messages are
+sent.
+
+But right now they are duplicated (two are sent at the same time). Can we review
+the code to see why this is happening and fix it?
+
+** DONE [#A] Too many geolocation notifications go out :bug:notifications:geolocations:
+:PROPERTIES:
+:ID:       6357ad7a-fe4e-49dd-a063-55d87e459c17
+:END:
+
+*** Description
+
+Currently ntfy gets overwhelemed when there's more than a hundred or so messages left in a queue on a client.
+
+It would be nice if we could not spam ntfy, and this is especially true with Geolocations, where we really
+don't need to alert folks unless they have a named Geolocation (has a title). Can we adjust the ntfy
+sending for Geolocations to only send if the scrobbled location has a title?
+
+
+** DONE [#C] Fix bug where Weigh-in imports do not set title :bug:tasks:scale:
+:PROPERTIES:
+:ID:       622e354a-8e66-4ecd-9e1c-a53f0a2ec362
+:END:
+
+*** Description
+
+Currently when we import a scale CSV row and create data, the title is left
+blank which makes it look funny in a list view. Let's save the weight as the
+title of the Weigh-in task.
+
+
+* Version 40.2 [1/1]
+** DONE [#A] Try fixing deploy bugs again :tooling:releases:bug:
+:PROPERTIES:
+:ID:       15894943-be1d-200f-8400-a136770ad9d2
+:END:
+
+
+* Version 40.1 [2/2]
+** DONE [#A] Releases are still broken :bug:releases:tooling:
+:PROPERTIES:
+:ID:       bca37a18-afa2-4ddd-a11b-ef0555f38bc9
+:END:
+ 
+*** Description
+
+Deploys are still broken, even with them being pulled apart and run separately.
+
+We need to address the way the commit ends up stashed in the codebase.
+
+** DONE [#C] Fix bug on chart pages where trail titles missing :bug:trails:charts:
+:PROPERTIES:
+:ID:       21075430-8a93-4e59-9a02-479315960ae6
+:END:
+
+*** Description
+
+When trails are rendered on the chart views, there are no titles, which means we don't see
+anything except the ranking number.
+
+
+* Version 40.0 [2/2]
+** DONE [#A] Fix error in org-mode task sync :emacs:orgmode:tasks:bug:
+:PROPERTIES:
+:ID:       03256d2a-48aa-4be7-aeb3-fa1cfddc86bf
+:END:
+ 
+*** Description
+#+begin_src python
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/tasks/webhooks.py", line 236, in post
+    emacs_scrobble_update_task(
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/scrobbles/scrobblers.py", line 844, in emacs_scrobble_update_task
+    for note in emacs_notes:
+TypeError: 'NoneType' object is not iterable
+#+end_src
+** DONE [#B] Adjust how similar artists are shown :feature:templates:artists:music:
+:PROPERTIES:
+:ID:       2a081620-a0a2-4851-a7cf-4043f9c2ee31
+:END:
+
+*** Description
+
+Currently we show the top 10 similar artists on the Artist detail page linked to
+the artist detail page on Vrobbler.
+
+First off, this is very slow. We should look into speeding up the rendering of
+the similar artists widget.
+
+Second, the artist name in the similar artist list should be a link to the
+Vrobbler artist detail page, but there should also be a [musicbrainz] link next
+to it, that links out to the musicbrainz page whether we have the artist in the
+Vrobbler database or not.
+
+
+
+* Version 39.3 [2/2]
+** DONE [#A] Issue found when doing a release :bug:tooling:release:cicd:
+:PROPERTIES:
+:ID:       a8fc3ec9-74ec-4190-8ac2-62cd8a33e828
+:END:
+
+*** Description
+#+begin_src sh
+err: ERROR: Cannot install vrobbler 0.16.1 (from /var/lib/vrobbler/dist/vrobbler-0.16.1-py3-none-any.whl) and vrobbler 38.0 (from /var/lib/vrobbler/dist/vrobbler-38.0-py3-none-any.whl) because these package versions have conflicting dependencies.
+out: The conflict is caused by:
+out:     The user requested vrobbler 0.16.1 (from /var/lib/vrobbler/dist/vrobbler-0.16.1-py3-none-any.whl)
+out:     The user requested vrobbler 38.0 (from /var/lib/vrobbler/dist/vrobbler-38.0-py3-none-any.whl)
+out: To fix this you could try to:
+out: 1. loosen the range of package versions you've specified
+out: 2. remove package versions to allow pip attempt to solve the dependency conflict
+err: ERROR: ResolutionImpossible: for help visit https://pip.pypa.io/en/latest/topics/dependency-resolution/#dealing-with-dependency-conflicts
+2026/06/01 14:15:00 Process exited with status 1
+failed to remove container: Error response from daemon: removal of container 3fe0eaf032c5518aca4ab71734b52bda7c54ed406136b82136ab7155bf5ff3c1 is already in progress
+#+end_src
+
+** DONE [#A] Fix deploy actions running twice :bug:tooling:cicd:
+:PROPERTIES:
+:ID:       aa56f2a6-2b61-4ddf-9e27-9eadcddf8412
+:END:
+
+*** Description
+
+Turns out we're now running the build-deploy action twice, once on branch push
+and once on tag push.
+
+We should do builds on each push and build and deploys only when a new tag is
+detected.
+
+        
+* Version 39.2 [2/2]
+** DONE [#B] Releases do not pin commit to the repo for display :bug:tooling:releases:
+:PROPERTIES:
+:ID:       2a9f2ff5-2642-47ab-ba1d-e41825411713
+:END:
+
+*** Description
+
+Somewhere in implementing the justfile release flow, we lost the capture of the
+latest commit in the relesae flow so the footer now always says: vXX.x (unknown)
+
+It should have the first bit of the commit in the parens at the end.
+
+** DONE [#B] Fix the way timestamps are stored for notes on tasks :bug:scrobbles:tasks:
+:PROPERTIES:
+:ID:       32973bb3-079b-8cdf-6495-82f8ae907299
+:END:
+
+*** Description
+:PROPERTIES:
+:ID:       d833a3df-6eb2-36bb-1863-e438e5d36151
+:END:
+
+Turns out Todoist uses a human-readable timestamp format for comments. We should
+adapt that for use from org-mode as well.
+
+Format should be: "%Y-%m-%dT%H:%M:%S.%fZ"
+  
+
+* Version 39.1 [1/1]
+** DONE [#A] Fix bug in tests for notes saving :bug:scrobbles:forms:
+:PROPERTIES:
+:ID:       68a011b2-bb6f-3ba8-2312-5947c41db9ac
+:END:
+
+* Version 39.0 [3/3]
+** DONE [#B] Clean up org-mode tasks metadata :bug:tasks:metadata:
 :PROPERTIES:
 :ID:       0c762d09-fc69-4e75-be40-7eaaf04f178e
 :END:
 
 *** Description
 
-It would be nice to not duplicate comments that exist on a task when it's first scrobbled.
+Org-mode tasks have a `Description` subheader, which should populate the
+"Description" of a task.
 
-** TODO [#A] Fix various artist album problem with Superwolves (track with multiple artists) :vrobbler:project:music:bug:artists:
+The title should come from the actual TODO content, with tags coming from the
+tags in colons after the task. This behaviour should already work.
+
+Next, any comments should go under a `Comments` subheader. Under these should be a list tag like:
+
+"Note taken on [2026-05-31 Sun 20:03]"
+
+Which declares it's a note with a timestamp like "YYYY-MM-DD d HH:MM".
+
+When scrobbling a task from org-mode, the description should always be copied to
+the scrobble's log["description"].
+
+Any comments that exist on the task when the scrobble is first created, should
+be ignored.
+
+Any comments on a task that is updated (a re-POST'd while the task is in
+progress, should add a comment in the log["notes"], a dictionary, keyed off the
+timestamp the note string. If a note for that datetime already exists, the
+content should be replaced with the new comment.
+
+Additionally, when a task is re-POST'd while the task is in progress, the
+description should also be compared, and if different, the newest description
+should be used.
+
+Note, the biggest change for this flow is making sure comments that already
+exist are not added to any new tasks and that both comments and descriptions are
+added or updated if the new values are different than what is already in the
+currently in-progress task.
+
+If the task is completed, don't touch it.
+
+*** Comments
+- Note taken on [2026-05-31 Sun 20:03]
+  
+** DONE [#A] Actually push branches up and add a just command to do it :release:justfile:tooling:
+:PROPERTIES:
+:ID:       50aa5daa-a802-6aa9-38a3-218b7a9d4b34
+:END:
+** DONE [#A] Try to fix deploy failing with bad release plan :release:tooling:pyproject:
+:PROPERTIES:
+:ID:       63dc633c-4382-e6a5-e663-b01871ce86ce
+:END:
+
+* Version 38.0 [38/38]
+** DONE [#A] Fix release flow to be easier to trigger :pyproject:release:tooling:
+:PROPERTIES:
+:ID:       e321f8a3-26ea-b316-8493-294b50c0b516
+:END:
+
+*** Description
+
+We should have a command like `just relesae <major|minor>` that can cut new
+releases on command by updating the PROJECT.org file with a release header for
+all DONE tasks and creating the appropriate release commits and tags based on
+either the new release version type.
+
+It should also update the pyproject file.
+
+** DONE [#A] Move imported retroarch lrtl files to processed/ directory on WebDAV :webdav:retroarch:importers:
+:PROPERTIES:
+:ID:       881b5af6-e96f-4e71-9e66-2d30824e5504
+:END:
+
+    - File: ~vrobbler/apps/scrobbles/importers/webdav.py~ (line 439)
+    - Same pattern as the GPX importer: after importing a =.csv= file from
+      WebDAV, move it to =var/retroarch/processed/= with a timestamp appended.
+
+** DONE [#A] Add listenbrainz support for similar tracks :feature:music:metadata:
+:PROPERTIES:
+:ID:       a3abba14-7603-db51-58e1-1941a47fa35e
+:END:
+** DONE [#B] Consolidate albums in the same musicbrainz_releasegroup_id :music:albums:metadata:
+:PROPERTIES:
+:ID:       6b331bdb-1516-bb86-7cb3-8cb9e3de59ce
+:END:
+
+*** Description
+
+When we look up albums, we should check if one already exists with the same
+musicbrainz_releasegroup_id and prefer that one, rather than creating a new
+album.
+
+Also, we should create a data migration to clean up albums with matching
+musicbrainz_releasegroup_id fields by consolidating tracks around the first
+album found.
+
+Whether the track was enriched by musicbrainz or not, the track should get
+tagged with `musicbrainz_enriched` or `musicbrainz_notfound`
+
+** DONE [#A] Clean up metadata on music tracks :music:tracks:metadata:musicbrainz:
+:PROPERTIES:
+:ID:       3a007bd7-b901-43cb-892e-102d39fffc85
+:END:
+
+*** Description 
+
+There's a over 3K tracks without a musicbrainz_id and almost 30K without a
+base_run_time_seconds. We should have a clean up script that can run through the
+ones missing musicbrainz_ids and see about getting metadata from musicbrainz and
+for the 30K without base_run_time_seconds, check with their musicbrainz_ids to
+see if we can look up the track length, and if not, tag the track with
+"missing-metadata" tag.
+
+Also, if the tracks without musicbrainz_ids actually are not in the MB database,
+we should tag those with "not-in-musicbrainz"
+
+And a big part of this work will probably involve checking for "Various Artists"
+tracks where the track erroneously got set with a generic artist. In those
+cases, we should try just looking up by track title.
+
+** DONE [#B] Make artists_m2m field source of artist truth for albums :music:bug:albums:
+:PROPERTIES:
+:ID:       05a24455-0e71-45ef-ac6e-c1b7b843047d
+:END:
+
+*** Description
+
+Albums have an FK for album_artist, but like artists, the M2M should be the
+source of truth. We should migrate all uses of album_artist to an `artist`
+property on the Album model and use a data migration to populate artists with
+the album_artist value.
+
+** DONE [#A] Fix various artist album problem with Superwolves (track with multiple artists) :vrobbler:project:music:bug:artists:
 :PROPERTIES:
 :ID:       590bc038-745f-710b-8272-4d8a3d2efa01
 :END:
@@ -496,7 +1003,55 @@ or at least make it optional, and then require a M2M between Track and Artist.
 Then this one would be a Track by both `Matt Sweeney` and `Bonnie "Prince"
 Billy`
 
-** TODO [#A] Allow special parameter to re-import already processed GPX files :imports:gpx:
+** DONE [#A] Move imported eBird CSV files to processed/ directory on WebDAV :webdav:ebird:importers:
+:PROPERTIES:
+:ID:       445e1253-d353-4b55-b1d8-39d0a0dcdd34
+:END:
+
+    - File: ~vrobbler/apps/scrobbles/importers/webdav.py~ (line 439)
+    - Same pattern as the GPX importer: after importing a =.csv= file from
+      WebDAV, move it to =var/ebird/processed/= with a timestamp appended.
+
+** DONE [#A] Move imported Board Game CSV files to processed/ directory on WebDAV :webdav:boardgames:importers:
+:PROPERTIES:
+:ID:       a3f8d30c-d2c3-4ee7-b062-f0f16bd9b0b4
+:END:
+
+    - File: ~vrobbler/apps/scrobbles/importers/webdav.py~ (line 496)
+    - Same pattern as the GPX importer: after importing a =.csv= file from
+      WebDAV, move it to =var/bgstats/processed/= with a timestamp appended.
+      
+** DONE [#A] Move imported Scale CSV files to processed/ directory on WebDAV :webdav:scale:importers:
+:PROPERTIES:
+:ID:       1a0de363-d1ea-466e-9966-e24941a6180b
+:END:
+    - File: ~vrobbler/apps/scrobbles/importers/webdav.py~ (line 496)
+    - Same pattern as the GPX importer: after importing a =.csv= file from
+      WebDAV, move it to =var/scale/processed/= with a timestamp appended.
+
+** DONE [#A] Allow special parameter to re-import already processed GPX files :imports:gpx:
+:PROPERTIES:
+:ID:       166c0809-c11a-4d02-8071-7a69dcb36e64
+:END:
+
+*** Description
+
+Now that we stash imported GPX files in the processed/ subdirectory on import,
+it would be nice to have a flag like --include-processed on the webdav importer
+that would import files both in the root of gpx/ and also in the processed
+directory. This would aide testing imports in staging quickly without constantly
+moving files back and forth.
+
+** DONE [#A] Move imported GPX files to processed/ directory on WebDAV :webdav:gpx:importers:
+:PROPERTIES:
+:ID:       db2b02fc-817c-4c39-bd51-13f9b77c7888
+:END:
+    - File: ~vrobbler/apps/scrobbles/importers/webdav.py~ (line 198)
+    - After importing a GPX/FIT file from WebDAV, move it to a =processed/=
+      subdirectory with a timestamp appended. This eliminates the DB lookup for
+      already-imported filenames — any file present in the top-level directory
+      is new. Also makes manual re-imports easy (just move a file back).
+
 ** DONE [#A] Add CSS Grid calendar view for scrobbles :vrobbler:personal:project:templates:feature:
 :PROPERTIES:
 :ID:       be915acf-d803-466a-8770-823819ebf2a9
@@ -738,6 +1293,7 @@ urllib.error.HTTPError: HTTP Error 500: Internal Server Error
 - Note taken on [2025-09-30 Tue 09:33]
 
   This may have already been resolved ... need to just confirm it.
+
 * Version 37.0 [4/4]
 ** DONE [#A] Tasks from org-mode should properly update notes and leave them out of the body :vrobbler:bug:tasks:
 :PROPERTIES:

justfile

@@ -14,3 +14,12 @@ celery:
 
 celery-beat:
     poetry run celery -A vrobbler beat -l info
+
+push:
+    git push && git push gitea
+    git push --tags && git push --tags gitea
+
+release kind="minor":
+    poetry run python scripts/release.py {{kind}}
+    @push
+    

poetry.lock

@@ -2509,144 +2509,146 @@ zookeeper = ["kazoo (>=2.8.0)"]
 
 [[package]]
 name = "lxml"
-version = "5.4.0"
+version = "6.1.1"
 description = "Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API."
 optional = false
-python-versions = ">=3.6"
+python-versions = ">=3.8"
 groups = ["main"]
 files = [
-    {file = "lxml-5.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e7bc6df34d42322c5289e37e9971d6ed114e3776b45fa879f734bded9d1fea9c"},
-    {file = "lxml-5.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6854f8bd8a1536f8a1d9a3655e6354faa6406621cf857dc27b681b69860645c7"},
-    {file = "lxml-5.4.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:696ea9e87442467819ac22394ca36cb3d01848dad1be6fac3fb612d3bd5a12cf"},
-    {file = "lxml-5.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ef80aeac414f33c24b3815ecd560cee272786c3adfa5f31316d8b349bfade28"},
-    {file = "lxml-5.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b9c2754cef6963f3408ab381ea55f47dabc6f78f4b8ebb0f0b25cf1ac1f7609"},
-    {file = "lxml-5.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7a62cc23d754bb449d63ff35334acc9f5c02e6dae830d78dab4dd12b78a524f4"},
-    {file = "lxml-5.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f82125bc7203c5ae8633a7d5d20bcfdff0ba33e436e4ab0abc026a53a8960b7"},
-    {file = "lxml-5.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:b67319b4aef1a6c56576ff544b67a2a6fbd7eaee485b241cabf53115e8908b8f"},
-    {file = "lxml-5.4.0-cp310-cp310-manylinux_2_28_ppc64le.whl", hash = "sha256:a8ef956fce64c8551221f395ba21d0724fed6b9b6242ca4f2f7beb4ce2f41997"},
-    {file = "lxml-5.4.0-cp310-cp310-manylinux_2_28_s390x.whl", hash = "sha256:0a01ce7d8479dce84fc03324e3b0c9c90b1ece9a9bb6a1b6c9025e7e4520e78c"},
-    {file = "lxml-5.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:91505d3ddebf268bb1588eb0f63821f738d20e1e7f05d3c647a5ca900288760b"},
-    {file = "lxml-5.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a3bcdde35d82ff385f4ede021df801b5c4a5bcdfb61ea87caabcebfc4945dc1b"},
-    {file = "lxml-5.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:aea7c06667b987787c7d1f5e1dfcd70419b711cdb47d6b4bb4ad4b76777a0563"},
-    {file = "lxml-5.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a7fb111eef4d05909b82152721a59c1b14d0f365e2be4c742a473c5d7372f4f5"},
-    {file = "lxml-5.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:43d549b876ce64aa18b2328faff70f5877f8c6dede415f80a2f799d31644d776"},
-    {file = "lxml-5.4.0-cp310-cp310-win32.whl", hash = "sha256:75133890e40d229d6c5837b0312abbe5bac1c342452cf0e12523477cd3aa21e7"},
-    {file = "lxml-5.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:de5b4e1088523e2b6f730d0509a9a813355b7f5659d70eb4f319c76beea2e250"},
-    {file = "lxml-5.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:98a3912194c079ef37e716ed228ae0dcb960992100461b704aea4e93af6b0bb9"},
-    {file = "lxml-5.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0ea0252b51d296a75f6118ed0d8696888e7403408ad42345d7dfd0d1e93309a7"},
-    {file = "lxml-5.4.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b92b69441d1bd39f4940f9eadfa417a25862242ca2c396b406f9272ef09cdcaa"},
-    {file = "lxml-5.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20e16c08254b9b6466526bc1828d9370ee6c0d60a4b64836bc3ac2917d1e16df"},
-    {file = "lxml-5.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7605c1c32c3d6e8c990dd28a0970a3cbbf1429d5b92279e37fda05fb0c92190e"},
-    {file = "lxml-5.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ecf4c4b83f1ab3d5a7ace10bafcb6f11df6156857a3c418244cef41ca9fa3e44"},
-    {file = "lxml-5.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0cef4feae82709eed352cd7e97ae062ef6ae9c7b5dbe3663f104cd2c0e8d94ba"},
-    {file = "lxml-5.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:df53330a3bff250f10472ce96a9af28628ff1f4efc51ccba351a8820bca2a8ba"},
-    {file = "lxml-5.4.0-cp311-cp311-manylinux_2_28_ppc64le.whl", hash = "sha256:aefe1a7cb852fa61150fcb21a8c8fcea7b58c4cb11fbe59c97a0a4b31cae3c8c"},
-    {file = "lxml-5.4.0-cp311-cp311-manylinux_2_28_s390x.whl", hash = "sha256:ef5a7178fcc73b7d8c07229e89f8eb45b2908a9238eb90dcfc46571ccf0383b8"},
-    {file = "lxml-5.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:d2ed1b3cb9ff1c10e6e8b00941bb2e5bb568b307bfc6b17dffbbe8be5eecba86"},
-    {file = "lxml-5.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:72ac9762a9f8ce74c9eed4a4e74306f2f18613a6b71fa065495a67ac227b3056"},
-    {file = "lxml-5.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f5cb182f6396706dc6cc1896dd02b1c889d644c081b0cdec38747573db88a7d7"},
-    {file = "lxml-5.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:3a3178b4873df8ef9457a4875703488eb1622632a9cee6d76464b60e90adbfcd"},
-    {file = "lxml-5.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e094ec83694b59d263802ed03a8384594fcce477ce484b0cbcd0008a211ca751"},
-    {file = "lxml-5.4.0-cp311-cp311-win32.whl", hash = "sha256:4329422de653cdb2b72afa39b0aa04252fca9071550044904b2e7036d9d97fe4"},
-    {file = "lxml-5.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:fd3be6481ef54b8cfd0e1e953323b7aa9d9789b94842d0e5b142ef4bb7999539"},
-    {file = "lxml-5.4.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b5aff6f3e818e6bdbbb38e5967520f174b18f539c2b9de867b1e7fde6f8d95a4"},
-    {file = "lxml-5.4.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942a5d73f739ad7c452bf739a62a0f83e2578afd6b8e5406308731f4ce78b16d"},
-    {file = "lxml-5.4.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:460508a4b07364d6abf53acaa0a90b6d370fafde5693ef37602566613a9b0779"},
-    {file = "lxml-5.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:529024ab3a505fed78fe3cc5ddc079464e709f6c892733e3f5842007cec8ac6e"},
-    {file = "lxml-5.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ca56ebc2c474e8f3d5761debfd9283b8b18c76c4fc0967b74aeafba1f5647f9"},
-    {file = "lxml-5.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a81e1196f0a5b4167a8dafe3a66aa67c4addac1b22dc47947abd5d5c7a3f24b5"},
-    {file = "lxml-5.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00b8686694423ddae324cf614e1b9659c2edb754de617703c3d29ff568448df5"},
-    {file = "lxml-5.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:c5681160758d3f6ac5b4fea370495c48aac0989d6a0f01bb9a72ad8ef5ab75c4"},
-    {file = "lxml-5.4.0-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:2dc191e60425ad70e75a68c9fd90ab284df64d9cd410ba8d2b641c0c45bc006e"},
-    {file = "lxml-5.4.0-cp312-cp312-manylinux_2_28_s390x.whl", hash = "sha256:67f779374c6b9753ae0a0195a892a1c234ce8416e4448fe1e9f34746482070a7"},
-    {file = "lxml-5.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:79d5bfa9c1b455336f52343130b2067164040604e41f6dc4d8313867ed540079"},
-    {file = "lxml-5.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3d3c30ba1c9b48c68489dc1829a6eede9873f52edca1dda900066542528d6b20"},
-    {file = "lxml-5.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1af80c6316ae68aded77e91cd9d80648f7dd40406cef73df841aa3c36f6907c8"},
-    {file = "lxml-5.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4d885698f5019abe0de3d352caf9466d5de2baded00a06ef3f1216c1a58ae78f"},
-    {file = "lxml-5.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea53d51859b6c64e7c51d522c03cc2c48b9b5d6172126854cc7f01aa11f52bc"},
-    {file = "lxml-5.4.0-cp312-cp312-win32.whl", hash = "sha256:d90b729fd2732df28130c064aac9bb8aff14ba20baa4aee7bd0795ff1187545f"},
-    {file = "lxml-5.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1dc4ca99e89c335a7ed47d38964abcb36c5910790f9bd106f2a8fa2ee0b909d2"},
-    {file = "lxml-5.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:773e27b62920199c6197130632c18fb7ead3257fce1ffb7d286912e56ddb79e0"},
-    {file = "lxml-5.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ce9c671845de9699904b1e9df95acfe8dfc183f2310f163cdaa91a3535af95de"},
-    {file = "lxml-5.4.0-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9454b8d8200ec99a224df8854786262b1bd6461f4280064c807303c642c05e76"},
-    {file = "lxml-5.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cccd007d5c95279e529c146d095f1d39ac05139de26c098166c4beb9374b0f4d"},
-    {file = "lxml-5.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0fce1294a0497edb034cb416ad3e77ecc89b313cff7adbee5334e4dc0d11f422"},
-    {file = "lxml-5.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:24974f774f3a78ac12b95e3a20ef0931795ff04dbb16db81a90c37f589819551"},
-    {file = "lxml-5.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:497cab4d8254c2a90bf988f162ace2ddbfdd806fce3bda3f581b9d24c852e03c"},
-    {file = "lxml-5.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:e794f698ae4c5084414efea0f5cc9f4ac562ec02d66e1484ff822ef97c2cadff"},
-    {file = "lxml-5.4.0-cp313-cp313-manylinux_2_28_ppc64le.whl", hash = "sha256:2c62891b1ea3094bb12097822b3d44b93fc6c325f2043c4d2736a8ff09e65f60"},
-    {file = "lxml-5.4.0-cp313-cp313-manylinux_2_28_s390x.whl", hash = "sha256:142accb3e4d1edae4b392bd165a9abdee8a3c432a2cca193df995bc3886249c8"},
-    {file = "lxml-5.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:1a42b3a19346e5601d1b8296ff6ef3d76038058f311902edd574461e9c036982"},
-    {file = "lxml-5.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4291d3c409a17febf817259cb37bc62cb7eb398bcc95c1356947e2871911ae61"},
-    {file = "lxml-5.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4f5322cf38fe0e21c2d73901abf68e6329dc02a4994e483adbcf92b568a09a54"},
-    {file = "lxml-5.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:0be91891bdb06ebe65122aa6bf3fc94489960cf7e03033c6f83a90863b23c58b"},
-    {file = "lxml-5.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:15a665ad90054a3d4f397bc40f73948d48e36e4c09f9bcffc7d90c87410e478a"},
-    {file = "lxml-5.4.0-cp313-cp313-win32.whl", hash = "sha256:d5663bc1b471c79f5c833cffbc9b87d7bf13f87e055a5c86c363ccd2348d7e82"},
-    {file = "lxml-5.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:bcb7a1096b4b6b24ce1ac24d4942ad98f983cd3810f9711bcd0293f43a9d8b9f"},
-    {file = "lxml-5.4.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:7be701c24e7f843e6788353c055d806e8bd8466b52907bafe5d13ec6a6dbaecd"},
-    {file = "lxml-5.4.0-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fb54f7c6bafaa808f27166569b1511fc42701a7713858dddc08afdde9746849e"},
-    {file = "lxml-5.4.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97dac543661e84a284502e0cf8a67b5c711b0ad5fb661d1bd505c02f8cf716d7"},
-    {file = "lxml-5.4.0-cp36-cp36m-manylinux_2_28_x86_64.whl", hash = "sha256:c70e93fba207106cb16bf852e421c37bbded92acd5964390aad07cb50d60f5cf"},
-    {file = "lxml-5.4.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:9c886b481aefdf818ad44846145f6eaf373a20d200b5ce1a5c8e1bc2d8745410"},
-    {file = "lxml-5.4.0-cp36-cp36m-musllinux_1_2_x86_64.whl", hash = "sha256:fa0e294046de09acd6146be0ed6727d1f42ded4ce3ea1e9a19c11b6774eea27c"},
-    {file = "lxml-5.4.0-cp36-cp36m-win32.whl", hash = "sha256:61c7bbf432f09ee44b1ccaa24896d21075e533cd01477966a5ff5a71d88b2f56"},
-    {file = "lxml-5.4.0-cp36-cp36m-win_amd64.whl", hash = "sha256:7ce1a171ec325192c6a636b64c94418e71a1964f56d002cc28122fceff0b6121"},
-    {file = "lxml-5.4.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:795f61bcaf8770e1b37eec24edf9771b307df3af74d1d6f27d812e15a9ff3872"},
-    {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:29f451a4b614a7b5b6c2e043d7b64a15bd8304d7e767055e8ab68387a8cacf4e"},
-    {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:891f7f991a68d20c75cb13c5c9142b2a3f9eb161f1f12a9489c82172d1f133c0"},
-    {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4aa412a82e460571fad592d0f93ce9935a20090029ba08eca05c614f99b0cc92"},
-    {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:ac7ba71f9561cd7d7b55e1ea5511543c0282e2b6450f122672a2694621d63b7e"},
-    {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:c5d32f5284012deaccd37da1e2cd42f081feaa76981f0eaa474351b68df813c5"},
-    {file = "lxml-5.4.0-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:ce31158630a6ac85bddd6b830cffd46085ff90498b397bd0a259f59d27a12188"},
-    {file = "lxml-5.4.0-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:31e63621e073e04697c1b2d23fcb89991790eef370ec37ce4d5d469f40924ed6"},
-    {file = "lxml-5.4.0-cp37-cp37m-win32.whl", hash = "sha256:be2ba4c3c5b7900246a8f866580700ef0d538f2ca32535e991027bdaba944063"},
-    {file = "lxml-5.4.0-cp37-cp37m-win_amd64.whl", hash = "sha256:09846782b1ef650b321484ad429217f5154da4d6e786636c38e434fa32e94e49"},
-    {file = "lxml-5.4.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:eaf24066ad0b30917186420d51e2e3edf4b0e2ea68d8cd885b14dc8afdcf6556"},
-    {file = "lxml-5.4.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2b31a3a77501d86d8ade128abb01082724c0dfd9524f542f2f07d693c9f1175f"},
-    {file = "lxml-5.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e108352e203c7afd0eb91d782582f00a0b16a948d204d4dec8565024fafeea5"},
-    {file = "lxml-5.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a11a96c3b3f7551c8a8109aa65e8594e551d5a84c76bf950da33d0fb6dfafab7"},
-    {file = "lxml-5.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:ca755eebf0d9e62d6cb013f1261e510317a41bf4650f22963474a663fdfe02aa"},
-    {file = "lxml-5.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:4cd915c0fb1bed47b5e6d6edd424ac25856252f09120e3e8ba5154b6b921860e"},
-    {file = "lxml-5.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:226046e386556a45ebc787871d6d2467b32c37ce76c2680f5c608e25823ffc84"},
-    {file = "lxml-5.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:b108134b9667bcd71236c5a02aad5ddd073e372fb5d48ea74853e009fe38acb6"},
-    {file = "lxml-5.4.0-cp38-cp38-win32.whl", hash = "sha256:1320091caa89805df7dcb9e908add28166113dcd062590668514dbd510798c88"},
-    {file = "lxml-5.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:073eb6dcdf1f587d9b88c8c93528b57eccda40209cf9be549d469b942b41d70b"},
-    {file = "lxml-5.4.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:bda3ea44c39eb74e2488297bb39d47186ed01342f0022c8ff407c250ac3f498e"},
-    {file = "lxml-5.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9ceaf423b50ecfc23ca00b7f50b64baba85fb3fb91c53e2c9d00bc86150c7e40"},
-    {file = "lxml-5.4.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:664cdc733bc87449fe781dbb1f309090966c11cc0c0cd7b84af956a02a8a4729"},
-    {file = "lxml-5.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67ed8a40665b84d161bae3181aa2763beea3747f748bca5874b4af4d75998f87"},
-    {file = "lxml-5.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b4a3bd174cc9cdaa1afbc4620c049038b441d6ba07629d89a83b408e54c35cd"},
-    {file = "lxml-5.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:b0989737a3ba6cf2a16efb857fb0dfa20bc5c542737fddb6d893fde48be45433"},
-    {file = "lxml-5.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:dc0af80267edc68adf85f2a5d9be1cdf062f973db6790c1d065e45025fa26140"},
-    {file = "lxml-5.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:639978bccb04c42677db43c79bdaa23785dc7f9b83bfd87570da8207872f1ce5"},
-    {file = "lxml-5.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5a99d86351f9c15e4a901fc56404b485b1462039db59288b203f8c629260a142"},
-    {file = "lxml-5.4.0-cp39-cp39-win32.whl", hash = "sha256:3e6d5557989cdc3ebb5302bbdc42b439733a841891762ded9514e74f60319ad6"},
-    {file = "lxml-5.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:a8c9b7f16b63e65bbba889acb436a1034a82d34fa09752d754f88d708eca80e1"},
-    {file = "lxml-5.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1b717b00a71b901b4667226bba282dd462c42ccf618ade12f9ba3674e1fabc55"},
-    {file = "lxml-5.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27a9ded0f0b52098ff89dd4c418325b987feed2ea5cc86e8860b0f844285d740"},
-    {file = "lxml-5.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b7ce10634113651d6f383aa712a194179dcd496bd8c41e191cec2099fa09de5"},
-    {file = "lxml-5.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:53370c26500d22b45182f98847243efb518d268374a9570409d2e2276232fd37"},
-    {file = "lxml-5.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c6364038c519dffdbe07e3cf42e6a7f8b90c275d4d1617a69bb59734c1a2d571"},
-    {file = "lxml-5.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b12cb6527599808ada9eb2cd6e0e7d3d8f13fe7bbb01c6311255a15ded4c7ab4"},
-    {file = "lxml-5.4.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5f11a1526ebd0dee85e7b1e39e39a0cc0d9d03fb527f56d8457f6df48a10dc0c"},
-    {file = "lxml-5.4.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48b4afaf38bf79109bb060d9016fad014a9a48fb244e11b94f74ae366a64d252"},
-    {file = "lxml-5.4.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de6f6bb8a7840c7bf216fb83eec4e2f79f7325eca8858167b68708b929ab2172"},
-    {file = "lxml-5.4.0-pp37-pypy37_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:5cca36a194a4eb4e2ed6be36923d3cffd03dcdf477515dea687185506583d4c9"},
-    {file = "lxml-5.4.0-pp37-pypy37_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:b7c86884ad23d61b025989d99bfdd92a7351de956e01c61307cb87035960bcb1"},
-    {file = "lxml-5.4.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:53d9469ab5460402c19553b56c3648746774ecd0681b1b27ea74d5d8a3ef5590"},
-    {file = "lxml-5.4.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:56dbdbab0551532bb26c19c914848d7251d73edb507c3079d6805fa8bba5b706"},
-    {file = "lxml-5.4.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14479c2ad1cb08b62bb941ba8e0e05938524ee3c3114644df905d2331c76cd57"},
-    {file = "lxml-5.4.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:32697d2ea994e0db19c1df9e40275ffe84973e4232b5c274f47e7c1ec9763cdd"},
-    {file = "lxml-5.4.0-pp38-pypy38_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:24f6df5f24fc3385f622c0c9d63fe34604893bc1a5bdbb2dbf5870f85f9a404a"},
-    {file = "lxml-5.4.0-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:151d6c40bc9db11e960619d2bf2ec5829f0aaffb10b41dcf6ad2ce0f3c0b2325"},
-    {file = "lxml-5.4.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:4025bf2884ac4370a3243c5aa8d66d3cb9e15d3ddd0af2d796eccc5f0244390e"},
-    {file = "lxml-5.4.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:9459e6892f59ecea2e2584ee1058f5d8f629446eab52ba2305ae13a32a059530"},
-    {file = "lxml-5.4.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:47fb24cc0f052f0576ea382872b3fc7e1f7e3028e53299ea751839418ade92a6"},
-    {file = "lxml-5.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:50441c9de951a153c698b9b99992e806b71c1f36d14b154592580ff4a9d0d877"},
-    {file = "lxml-5.4.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:ab339536aa798b1e17750733663d272038bf28069761d5be57cb4a9b0137b4f8"},
-    {file = "lxml-5.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:9776af1aad5a4b4a1317242ee2bea51da54b2a7b7b48674be736d463c999f37d"},
-    {file = "lxml-5.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:63e7968ff83da2eb6fdda967483a7a023aa497d85ad8f05c3ad9b1f2e8c84987"},
-    {file = "lxml-5.4.0.tar.gz", hash = "sha256:d12832e1dbea4be280b22fd0ea7c9b87f0d8fc51ba06e92dc62d52f804f78ebd"},
+    {file = "lxml-6.1.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:09dd5b7075dc2f7709654a46543ba1ea3c2e217b2ed8fbd413a8a945a0f40f60"},
+    {file = "lxml-6.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f6ac4ef4d82dff54670227a69c67782ae0b811b5cf6b17954f1e8f7502fc0d1d"},
+    {file = "lxml-6.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:556e94a63c9b04716f8e4de2abb65775061f846e89331b6c5be79183a24f98ea"},
+    {file = "lxml-6.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5c6bf403fbb3b3e348a561a5f4f0b9961835657981c802a1df03653eef8a9074"},
+    {file = "lxml-6.1.1-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1dde6131244bba38a17c745836ba190bc753fd73c9291666287fd0a3fa3dcf30"},
+    {file = "lxml-6.1.1-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98fc784c2c1440667aeedf8465bdfe10208acf0ead656a2c68627299f546b315"},
+    {file = "lxml-6.1.1-cp310-cp310-manylinux_2_28_i686.whl", hash = "sha256:add8cf6ddf9a65116119a28ece0f7886e30af27ba724a7594305f1d1b58a92a1"},
+    {file = "lxml-6.1.1-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:cf9d57306d848218f3601fee7601fab1a327c942d56e2e97610583cb4dd74206"},
+    {file = "lxml-6.1.1-cp310-cp310-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88136950da4d13c318bde414ce10219931937851327f44328f2df4d2c4614067"},
+    {file = "lxml-6.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cecdd5dfdc87b1fd87dbf81d4b037a544f47f4c744200a67013771682d67686a"},
+    {file = "lxml-6.1.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cd312b9692e831d2ffcad61eab31d91d4b4655a962e61de8fb410472cbcd37aa"},
+    {file = "lxml-6.1.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:5b7328b46d49fc9477d91ae8f6d55340347d827b7734ba3ea33faae0efef1383"},
+    {file = "lxml-6.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37a58976370f36d9329d118ad0b953c5aeb9119ac9c6a4e258942a225d0573a1"},
+    {file = "lxml-6.1.1-cp310-cp310-win32.whl", hash = "sha256:cea3f4c1af79af13cdb2da0c028111d8f8522d4f22a000c82385535f24e5cf3a"},
+    {file = "lxml-6.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:3abf332af33a74288675d936fe861fd4344da0dd6622193fbc4f2bfbb35536b5"},
+    {file = "lxml-6.1.1-cp310-cp310-win_arm64.whl", hash = "sha256:8dadbe5b217ff35b6a8d16610dd710219b59b76d13f0e3f0d9f36786206e4485"},
+    {file = "lxml-6.1.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:53b7d2b7a10b1c35c0a5e21e9224accf60c1bbfba523990732e521b2b73adef2"},
+    {file = "lxml-6.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ff3f333630ab480244a1bff72043e511a91eb22e7595dead8653ee5612dd8f3d"},
+    {file = "lxml-6.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a4bbea04c97f6d78a48e3fbc1cb9116d2780b1b39e03a23f6eb9b603fd61f510"},
+    {file = "lxml-6.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:db1d75f6617a49c1c01bc7023713e0ff59ab32c9579ae62a7674c0e34f3b0b0a"},
+    {file = "lxml-6.1.1-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a12689be69a28ddaa0ab99a5a1137da2afd5f8f16df7b5680b66f616d3eda1d"},
+    {file = "lxml-6.1.1-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18b73c339ae29b90fd2d06e58ebd555a751bde9cd6bbd36cc0281b9a2c94e9d8"},
+    {file = "lxml-6.1.1-cp311-cp311-manylinux_2_28_i686.whl", hash = "sha256:752d3bbfe874715ccd0aec7f88d7fc623c0f1fd7aa7b3238a084e017bad2a009"},
+    {file = "lxml-6.1.1-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:6b1761fbf9ec984e2e9d9c589ef5f5fd684b7c19f92aadd567a26c5224958db6"},
+    {file = "lxml-6.1.1-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d680fbcb768404c601ecb43519ecd8461f6954cb11c06a78962f666832ccfca8"},
+    {file = "lxml-6.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:162af1091cd785f2f27e62d3547ae9bc58ec5c86dd314d67021fd02463708d83"},
+    {file = "lxml-6.1.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:e9308ff8241c532df3f3e570f9a5aeed6c853f888512ba4b75638d7c11c95ef6"},
+    {file = "lxml-6.1.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5f6994074ebae6ffb04447268e37dc16edc304f9859cf91acb86e0af6c1b395c"},
+    {file = "lxml-6.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:80c2dfadb855da477cf73373ad29a333535dedb9b12bad02c9814c8e2b43bf08"},
+    {file = "lxml-6.1.1-cp311-cp311-win32.whl", hash = "sha256:30a89d3ac8faec007453fb541f3f46807eeec88edd5826f6e3fe001752a2c621"},
+    {file = "lxml-6.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:abbefa31eee84842140f67acef1c828e28bba8bbf0c3bc6e5492a9af88152c28"},
+    {file = "lxml-6.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:dcb292aa7fe485ceff7af4f92e46c5af397daec5dff64871a528f0fc47a3cc5b"},
+    {file = "lxml-6.1.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:104c09bda8d2a562824c0e319d0768ce26a779b7601e0931d33b09b53c392ef7"},
+    {file = "lxml-6.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:25c6997a9a534e016695a0ba06b2f07945de682731ff01065b6d5a4474179da1"},
+    {file = "lxml-6.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c921ba5c51e4e9f63b8b00267d06566e1f63407408a0496da2d1d0bfc819c7fc"},
+    {file = "lxml-6.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:54a7f95e4de5fb94e2f9f4b9055c6ba33bf3d628fd77a1d647c5923caa2cdcdc"},
+    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f2ec43df44b1f76249ee0a615334f9b5b060e1c8bd90e706dad2d14d02f383"},
+    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:70ef8a7e102a1508f8121aae5b0867abd663f72c14f0a9c937e6554cb4587b7b"},
+    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ebe6af670449830d6d9b752c256a983291c766a1365ba5d5460048f9e33a7818"},
+    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:27acc820660aaffa4f7c087f29120e12980f7779d56d8492d263170111284740"},
+    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:1db753c9115ec7100d073b744d17e25e88a8f90f5c39b2f5dd878149af59671f"},
+    {file = "lxml-6.1.1-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c4f469aebd783bb741c2ecb2a681008fd26bfe5c16a9a72ed5467f834e810df2"},
+    {file = "lxml-6.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:766b010012d59470072c1816b5b6c69f1d243e5db36ea5968e94accf430a4635"},
+    {file = "lxml-6.1.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b8d812c6011c08b8111a15e54dd990b8923692d80adf35488bee34026c35accf"},
+    {file = "lxml-6.1.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:fe0306bd29505a9177aac19f1877174b0e7422c222a59f70b2cd41633448c3dc"},
+    {file = "lxml-6.1.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:5ba186ad207446c65d3bb3d3e0412b032b1d9f595e59861e2354798c5703d955"},
+    {file = "lxml-6.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aa366a1e55b8ebfe8ca8ddc3cfe75c8ebade181aeb0f661d0cb05986b647f72a"},
+    {file = "lxml-6.1.1-cp312-cp312-win32.whl", hash = "sha256:126c93f7f56f0eda92f6d8c619edc463a4f23d9252f1c9d0405a76f25fa9f11a"},
+    {file = "lxml-6.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:26e6eda8d38c1fcab1090dd196ee87cbd13788e531937610e2589085de074e77"},
+    {file = "lxml-6.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:6540377fbd53fe1b629172288c464fb18db11ce1fa7dc15891da10aa9dcc3e7f"},
+    {file = "lxml-6.1.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:68a9198d0fc122d14bb76837de9aa80cf84caed990b5b237f532ed87d3706736"},
+    {file = "lxml-6.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7d47866cb32fb503450b6edc9df355d10dc49836af2e89901bd6ac6b0896d9d9"},
+    {file = "lxml-6.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb7c9811bfaa8b1ed5ed319f5d370dfbcaa59d52ea64be2a5a85e18195930354"},
+    {file = "lxml-6.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:762ff394d5bd56da0cf034a23dcce4e13923f15321a2adfa2ac00201dc6d3fca"},
+    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a088f287f7d8275a33c07f2cac6c50b9319309a0200a39e7e75d80c707723099"},
+    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e902da4b04e6b52e5893900d4b8ab46068f75f3561f01bf1080957f9fd932ed6"},
+    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1d4962d4c66bf830a7e59ed6cfc17d148149898a3aefa8ec6e59763e6e3ed085"},
+    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_28_i686.whl", hash = "sha256:581d4c8ae690a6609e64862dd6b7c2489635c2d13907fc2b20f2bc200ff1d21e"},
+    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:876e1ff5930ed8bf295ec5ef9a8155e9b6b1876bbf1deed8b3a8069311875a8f"},
+    {file = "lxml-6.1.1-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9eb9b5a968f6e0f6d640092a567e14529ff8cea2e29d00da6f78a79fa49f013c"},
+    {file = "lxml-6.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:aa49e06d94aba782c6a02eecb7e507969e7e7a41b267f1b359bb35585f295d5b"},
+    {file = "lxml-6.1.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:70cdfd80589d59e43e18005dd7244e8895e93db8ab6a620b7e23df5445a4e3d2"},
+    {file = "lxml-6.1.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:aad9aa39483ed8ec44d6d2e59e5b98a0d80676ef0d92f44bfc374836111f62f5"},
+    {file = "lxml-6.1.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:d49514be2f28d895c38cf9d2b72d7b9a07d00314519f456c0b50b53cfcf4c785"},
+    {file = "lxml-6.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:47402e62c52ff5988c1e8c6c63177f5708bccf48e366dea4e3dcf1e645e04947"},
+    {file = "lxml-6.1.1-cp313-cp313-win32.whl", hash = "sha256:3483644525531e1d5762b0c44a8e18b6efba321b6dcf8a8952de10b037618bca"},
+    {file = "lxml-6.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:a10bd2fd62e8ce916ececb342f348f190724a098c1faa056fdfb2a22ad5e8660"},
+    {file = "lxml-6.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:424aa57aca0897eb922aef34395bd1289b3b6f04e6bae20ea123c0c7e333cffc"},
+    {file = "lxml-6.1.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:19b7ab10b210b0b3ad7985d9ac4eb66ab09a90b20fe6e2f7ba55d01a234345d0"},
+    {file = "lxml-6.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c08e5c694306507275f2290073350c4f32e383db15213b2c69e7ff39c1193840"},
+    {file = "lxml-6.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:74a9717fd0d82effef5c2854f0d917231d5324b5a3eb7275c43ac9fa32f97a14"},
+    {file = "lxml-6.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efe0374196335f93b53269acd811b944f2e6bdc88e8894f214bd636455484909"},
+    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac931cdc9442c1763b8a8f6cd62c0c938737eafc5be75eff88df55fc73bc0d00"},
+    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:aee395f5d0927f947758b4ec119fd5fc8ec71f07a1c5c52077b30b04c0fa6955"},
+    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9395002973c827b3ed67db77e6ec09f092919a587022174554096a269378fb13"},
+    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_28_i686.whl", hash = "sha256:73bc2086f141224ebddb7fc5c6a36ca58b31b94b561e1dfe8e073e3270fad1e7"},
+    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:3779def59032b81e44a5f70096ef6bf2082f8d901937dca354474ba09782e245"},
+    {file = "lxml-6.1.1-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:86c89b9d55ebf820ad7c90bc533410f0d098054f293351f10603c0c46ff598f5"},
+    {file = "lxml-6.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19607c6bbff2a44cf3fe8250abccd20942d3462473e0a721d01d379ed017e462"},
+    {file = "lxml-6.1.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:c6ed5141a5c7507cf3ee76bd363b0d6f801e3321adc35b5d825a23115faa5465"},
+    {file = "lxml-6.1.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:62aeb7e85b5d60320b9d77eef2e773994e2c0ce10121b277e0a19804e1654a5a"},
+    {file = "lxml-6.1.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:b1b963fd8f5caa68e99dfae060d54de1fe9cba899b8718b44a00cdca53c3e590"},
+    {file = "lxml-6.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:63876be28efefa04a1df615b46770e82042cce445cfdce55160522f57b231ccb"},
+    {file = "lxml-6.1.1-cp314-cp314-win32.whl", hash = "sha256:7f7a92e8583f06b1fd49d01158143b8461cfcd135dcb10ec807270a3051bd603"},
+    {file = "lxml-6.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:b2d444f2e66624d68e9c6b211e28a76e22fff5fcabcfff4deac18b529b7d4137"},
+    {file = "lxml-6.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:3fd9728a2735fda14f4e8235830c86b539e9661e849665bf926d3f867943b4bf"},
+    {file = "lxml-6.1.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:787b2496d0dbe8cd180984e8d29e3a6f76e7ea34db781cb3bd55e4ba1ef8b4ee"},
+    {file = "lxml-6.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2c8daa471358dc2d6fcf02165e80ec68f77871a286df95bc5cc3816153b0fd2c"},
+    {file = "lxml-6.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:acd7d70b64c0aae0c7922cca83d288a16f5f6da523637697872253415269baef"},
+    {file = "lxml-6.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4f0dd2f01f9f8a89f565d000e03abcf0a13d692a346c8d22f628d49af098777a"},
+    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b7e8a14c8634bf6f7a568634cb395305a6d964aeb5b7ee32248094bed3a7e2c"},
+    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:86281fbdd6a8162756f8d603f37e3435bfa38043adb79c6dc6a2dfee065e7525"},
+    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5d7152ec39ca7c402d8fb9bad86140a15b9503bd0c54484e3f1bbe3dd37ceca"},
+    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_28_i686.whl", hash = "sha256:88d8cb75b9d82858497a5393e3c63cfbf03035225e4b35a49ed7ccb151e4dc0e"},
+    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:f64ec5397ea6a41fc1b4af0380d79b44a755b5531dcaccd9940fb260dca93038"},
+    {file = "lxml-6.1.1-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d34bbf07dbc7ca5970671b1512e928991fb5e9d95365636c9b2d8b4f53af405e"},
+    {file = "lxml-6.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:17e0e18d4ad8adbd0399291bc44845b69d9dd68439a3cdebdf35ff902ec05072"},
+    {file = "lxml-6.1.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:3ab541146f1f6968c462d6c2ac495148e8cdba2f8347700b2141b6ec5a75bf52"},
+    {file = "lxml-6.1.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2a0217714657e023ef4293500f65aa20fce6164c8fd6b08fa5bd4a859fb14b9b"},
+    {file = "lxml-6.1.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:05a82eb6e1530a64f26225b55cbd178113bd0b5af1c2b625f25e5296742c26d2"},
+    {file = "lxml-6.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9e36f163528fc50cbef305f02a5fd66d404edf7049cdaff211dbc2cba5a7013e"},
+    {file = "lxml-6.1.1-cp314-cp314t-win32.whl", hash = "sha256:649dda677cf3bd6ac9ae14007ba0c824ded8ce5808b53fc7431d9140399118c1"},
+    {file = "lxml-6.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:793033d6c5cdf33a573f910d9bea14ef8f5771820411d118da8e1182edb53d5e"},
+    {file = "lxml-6.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:58bb955caba94e467d2a96da17660d2d704e0675894cba21ab8a775b8621fd1c"},
+    {file = "lxml-6.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6689e828a94eee4f139408c337bb198e014724bb8a8c26d3cfac49d119ed69a6"},
+    {file = "lxml-6.1.1-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bdebcc8a75d38c7598dfb2c9ed852d7a9eb4a10d6e2d0764b919b802bf32ac88"},
+    {file = "lxml-6.1.1-cp38-cp38-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8be8ad51249698103d24b0571df35a10990fbe93dd043b6c024172189485f5e3"},
+    {file = "lxml-6.1.1-cp38-cp38-manylinux_2_28_i686.whl", hash = "sha256:76447f65250ed2501ead1a1552f5ce8edff159a86f308348e6a9c4acb5e1f1b4"},
+    {file = "lxml-6.1.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:ffecec8eb889b58ba9be5b95fb1cc78e22ea8eedea38e8736a1568fe1979250e"},
+    {file = "lxml-6.1.1-cp38-cp38-win32.whl", hash = "sha256:c674693f055fa2495de12292cb45e9944199d8eaef5a2dec45175c7c61cb73e3"},
+    {file = "lxml-6.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:55b03549819867ea141c0202242c4816c82e52ec36e7e648db9d8da5a3dc3ed6"},
+    {file = "lxml-6.1.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c9f79d5325907f13e1be0b3e4dacc1049d1dffc4aeee3c995284bea5fe0fab7d"},
+    {file = "lxml-6.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:83b6b30eb131da7a75b601f28c5d6971e6ed3e887919bf6b6a1ad3c2df289080"},
+    {file = "lxml-6.1.1-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:441dd227fa0690eb9fc81edabc63cdcefc212bba99b906dcf6e32cc1a9d3e533"},
+    {file = "lxml-6.1.1-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e07c65f443c887bbcf31cc1771d932ecc192a5273943589b3c7572b749f1ffb2"},
+    {file = "lxml-6.1.1-cp39-cp39-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5bec7d03d78d853597d6107854c2310ce3f761fd218fe9fe91d5101fcf6c2efe"},
+    {file = "lxml-6.1.1-cp39-cp39-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9f76acfb5f68ba982635a53fd985a8044be98a35b43232c2a1ee235ffab3e1dd"},
+    {file = "lxml-6.1.1-cp39-cp39-manylinux_2_28_i686.whl", hash = "sha256:8d43ca737b20e106e4aebc42b2f3ae19f00ba63d7eb731698ee083d72d15646f"},
+    {file = "lxml-6.1.1-cp39-cp39-manylinux_2_31_armv7l.whl", hash = "sha256:32ab449a5486f6c758e849bb86710d0e45edc24a04e250c01555f8f5653958f8"},
+    {file = "lxml-6.1.1-cp39-cp39-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53c909b62a0532183542fed00c5a7218258c56292d409bc789886fe1cb04c438"},
+    {file = "lxml-6.1.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:640f97d43d867bcb9c75b3af013b64850756b746cb6bce8ace83b70da3abba9d"},
+    {file = "lxml-6.1.1-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:469e3618338bd7ab5beb412d2439825479fcf0dab99e394ca563dbc4eaf6c834"},
+    {file = "lxml-6.1.1-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:aae97dfdb60715c164419ac2532a76d013c3918a665eb6cb7288098b5f349aaf"},
+    {file = "lxml-6.1.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:c9a4b821dc7055bf9e05ff5719e18ec501f75c0f0bbfabd573b277559780833d"},
+    {file = "lxml-6.1.1-cp39-cp39-win32.whl", hash = "sha256:639f6c857d91d9be29bd7502348d6736dab168b54b5158cd899abf11684dc186"},
+    {file = "lxml-6.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:34c2d737beabfe35baada43941ed519251e9a12e779031496bcd5d539fcfd730"},
+    {file = "lxml-6.1.1-cp39-cp39-win_arm64.whl", hash = "sha256:07a4a68e286ee7a1ed7dfb8af83e615757c0ccfe9f18c6b4ea6771388d9ba8c9"},
+    {file = "lxml-6.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:31033dc34636ea6b7d5cc11b1ddbda78a14de858ba9d3e1ed4b69a3085bc521e"},
+    {file = "lxml-6.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3893c14c4b6ac5b2d54ba8cf03e99fe5104e592de491f19bd6b82756c09f8004"},
+    {file = "lxml-6.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c07da4cebf6889f03ebac8d238f62318e29f495de0aa18a51ea14e61ae907e2e"},
+    {file = "lxml-6.1.1-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f6f0ce10945fab9c4c06ce14e22af9059d1a87493a9af4501a5b0b9187e21cf2"},
+    {file = "lxml-6.1.1-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f8844cd288697c6425c9beba919302241e3278871dc6519515e72b04e987abcf"},
+    {file = "lxml-6.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:ed21202aec73cda4d55d1ce57b389aadb90ffb044e6cd1080b8347efe1b1ec84"},
+    {file = "lxml-6.1.1.tar.gz", hash = "sha256:ba96ae44888e0185281e937633a743ea90d5a196c6000f82565ebb0580012d40"},
 ]
 
 [package.dependencies]
@@ -2657,7 +2659,6 @@ cssselect = ["cssselect (>=0.7)"]
 html-clean = ["lxml_html_clean"]
 html5 = ["html5lib"]
 htmlsoup = ["BeautifulSoup4"]
-source = ["Cython (>=3.0.11,<3.1.0)"]
 
 [[package]]
 name = "lxml-html-clean"
@@ -6003,5 +6004,5 @@ cffi = ["cffi (>=1.17,<2.0) ; platform_python_implementation != \"PyPy\" and pyt
 
 [metadata]
 lock-version = "2.1"
-python-versions = ">=3.11,<3.14"
-content-hash = "395bc627d9e2fa0434082fc574693e349cf0c604c47e8554b9a50a28bdd273d0"
+python-versions = ">=3.11,<3.15"
+content-hash = "bd3f14a9cfce403db426af98774f1e3c41b97283aa43f4bd80f84594ee0dd726"

pyproject.toml

@@ -1,11 +1,11 @@
 [tool.poetry]
 name = "vrobbler"
-version = "0.16.1"
+version = "45.1"
 description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]
 
 [tool.poetry.dependencies]
-python = ">=3.11,<3.14"
+python = ">=3.11,<3.15"
 Django = "^4.0.3"
 django-extensions = "^3.1.5"
 python-dateutil = "^2.8.2"
@@ -61,6 +61,7 @@ bgg-api = "^1.1.13"
 recipe-scrapers = "^15.11.0"
 gpxpy = "^1.6.2"
 fitparse = "^1.2.0"
+lxml = ">=5.5.0"
 
 [tool.poetry.group.test]
 optional = true
@@ -106,6 +107,8 @@ exclude_dirs = ["*/tests/*", "*/migrations/*"]
 [tool.poetry.scripts]
 vrobbler = "vrobbler.cli:main"
 
+[tool.poetry_bumpversion.file."vrobbler/__init__.py"]
+
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"

scripts/release.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""Cut a new release: collect DONE items from Backlog into a new Version section.
+
+Usage:
+    poetry run python scripts/release.py major
+    poetry run python scripts/release.py minor
+"""
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+PROJECT_FILE = Path("PROJECT.org")
+PYPROJECT_FILE = Path("pyproject.toml")
+
+BACKLOG_RE = re.compile(r"^\* Backlog\s+\[(\d+)/(\d+)\](.*)$")
+VERSION_RE = re.compile(r"^\* Version\s+(\d+\.\d+)\s+\[\d+/\d+\]")
+DONE_HEADER_RE = re.compile(r"^(\*\* DONE\s+)(.*)$")
+ITEM_HEADER_RE = re.compile(r"^\*\* ")
+
+
+def parse_done_line(line):
+    """Extract a clean title from a ** DONE line, stripping priority and tags."""
+    rest = line[8:].strip()  # remove "** DONE "
+    # strip priority marker like [#A]
+    rest = re.sub(r"^\[#[A-C]\]\s+", "", rest, count=1)
+    # strip org-mode tags at end (space-colon-tags)
+    rest = re.sub(r"\s+:\S.*:\s*$", "", rest)
+    return rest
+
+
+def bump_version(current_major, current_minor, kind):
+    if kind == "major":
+        return current_major + 1, 0
+    elif kind == "minor":
+        return current_major, current_minor + 1
+    else:
+        raise ValueError(f"Unknown bump kind: {kind}")
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] not in ("major", "minor"):
+        print(f"Usage: {sys.argv[0]} <major|minor>", file=sys.stderr)
+        sys.exit(1)
+
+    kind = sys.argv[1]
+
+    lines = PROJECT_FILE.read_text().splitlines(keepends=True)
+
+    # ---------------------------------------------------------------
+    # 1. Identify top-level sections
+    # ---------------------------------------------------------------
+    section_starts = []
+    for i, line in enumerate(lines):
+        if line.startswith("* ") and not line.startswith("** "):
+            section_starts.append(i)
+    section_starts.append(len(lines))
+
+    backlog_idx = None
+    version_idx = None
+
+    for idx, start in enumerate(section_starts[:-1]):
+        header = lines[start].strip()
+        if header.startswith("* Backlog"):
+            backlog_idx = idx
+        if header.startswith("* Version"):
+            version_idx = idx  # last occurrence wins
+
+    if backlog_idx is None:
+        print("ERROR: no Backlog section found", file=sys.stderr)
+        sys.exit(1)
+    if version_idx is None:
+        print("ERROR: no Version section found", file=sys.stderr)
+        sys.exit(1)
+
+    backlog_start = section_starts[backlog_idx]
+    backlog_end = section_starts[backlog_idx + 1]
+
+    # Find the newest Version section (first after Backlog) that matches
+    # our expected format (e.g. "37.0" not "0.11.4").
+    version_start = None
+    for idx in range(backlog_idx + 1, version_idx + 1):
+        header = lines[section_starts[idx]].strip()
+        if VERSION_RE.match(header):
+            version_start = section_starts[idx]
+            break
+
+    if version_start is None:
+        print("ERROR: no parseable Version header found", file=sys.stderr)
+        sys.exit(1)
+
+    version_header = lines[version_start].strip()
+
+    # ---------------------------------------------------------------
+    # 2. Parse current version from the newest * Version header
+    # ---------------------------------------------------------------
+    vm = VERSION_RE.match(version_header)
+    current_version = vm.group(1)
+    major_str, minor_str = current_version.split(".")
+    current_major = int(major_str)
+    current_minor = int(minor_str)
+    new_major, new_minor = bump_version(current_major, current_minor, kind)
+    new_version = f"{new_major}.{new_minor}"
+
+    # ---------------------------------------------------------------
+    # 3. Collect ** DONE items from the Backlog section
+    # ---------------------------------------------------------------
+    backlog_lines = lines[backlog_start:backlog_end]
+
+    # Split Backlog into items at each ** line (skip the section header)
+    items = []  # list of (start_idx, end_idx, is_done)
+    item_start = None
+    for i in range(1, len(backlog_lines)):
+        if ITEM_HEADER_RE.match(backlog_lines[i]):
+            if item_start is not None:
+                items.append((item_start, i, backlog_lines[item_start].startswith("** DONE")))
+            item_start = i
+    if item_start is not None:
+        items.append((item_start, len(backlog_lines), backlog_lines[item_start].startswith("** DONE")))
+
+    done_items = [(s, e) for s, e, is_done in items if is_done]
+    kept_items = [(s, e) for s, e, is_done in items if not is_done]
+
+    if not done_items:
+        print("No DONE items found in Backlog — nothing to release.")
+        sys.exit(0)
+
+    # ---------------------------------------------------------------
+    # 4. Build the new Version section text
+    # ---------------------------------------------------------------
+    version_section_lines = [f"* Version {new_version} [{len(done_items)}/{len(done_items)}]\n"]
+    for s, e in done_items:
+        version_section_lines.extend(backlog_lines[s:e])
+
+    # ---------------------------------------------------------------
+    # 5. Build updated Backlog section
+    # ---------------------------------------------------------------
+    backlog_header_line = backlog_lines[0]
+    bm = BACKLOG_RE.match(backlog_header_line.strip())
+    if not bm:
+        print(f"ERROR: could not parse backlog header: {backlog_header_line!r}", file=sys.stderr)
+        sys.exit(1)
+    done_count = int(bm.group(1))
+    total_count = int(bm.group(2))
+    tags = bm.group(3)
+
+    new_done = done_count - len(done_items)
+    new_total = total_count - len(done_items)
+    new_backlog_header = f"* Backlog [{new_done}/{new_total}]{tags}\n"
+
+    backlog_body = []
+    for s, e in kept_items:
+        backlog_body.extend(backlog_lines[s:e])
+
+    # ---------------------------------------------------------------
+    # 6. Assemble the new file
+    # ---------------------------------------------------------------
+    before_backlog = lines[:backlog_start]
+    after_backlog = lines[backlog_end:version_start]
+
+    # Everything from the first Version section onwards
+    from_version = lines[version_start:]
+
+    output = (
+        before_backlog
+        + [new_backlog_header]
+        + backlog_body
+        + version_section_lines
+        + ["\n"]
+        + after_backlog
+        + from_version
+    )
+
+    # ---------------------------------------------------------------
+    # 7. Update pyproject.toml
+    # ---------------------------------------------------------------
+    pyproject = PYPROJECT_FILE.read_text()
+    pyproject = re.sub(
+        r'^version = "[\d.]+"',
+        f'version = "{new_version}"',
+        pyproject,
+        count=1,
+        flags=re.MULTILINE,
+    )
+
+    # ---------------------------------------------------------------
+    # 8. Write files
+    # ---------------------------------------------------------------
+    PROJECT_FILE.write_text("".join(output))
+    PYPROJECT_FILE.write_text(pyproject)
+
+    # ---------------------------------------------------------------
+    # 9. Build commit body from done item titles
+    # ---------------------------------------------------------------
+    commit_lines = []
+    for s, e in done_items:
+        title = parse_done_line(backlog_lines[s])
+        if title:
+            commit_lines.append(f"- {title}")
+
+    commit_body = "\n".join(commit_lines)
+    commit_message = f"[release] Bump to version {new_version}\n\n{commit_body}"
+
+    # ---------------------------------------------------------------
+    # 10. Git commit + tag
+    # ---------------------------------------------------------------
+    subprocess.run(["git", "add", str(PROJECT_FILE), str(PYPROJECT_FILE)], check=True)
+    subprocess.run(["git", "commit", "-m", commit_message], check=True)
+    subprocess.run(["git", "tag", new_version], check=True)
+
+    print(f"\nReleased v{new_version} — tag {new_version} created.")
+    print(f"Moved {len(done_items)} DONE item(s) from Backlog to Version section.")
+
+
+if __name__ == "__main__":
+    main()

tests/scrobbles_tests/test_views.py

@@ -143,9 +143,10 @@ def test_mopidy_track_webhook_creates_track_and_scrobble(
     album = Album.objects.create(name="Sublime", album_artist=artist)
     track = Track.objects.create(
         title="Same in the End",
-        artist=artist,
+        artist_fk=artist,
         base_run_time_seconds=60,
     )
+    track.artists.add(artist)
     track.albums.add(album)
 
     mock_artist_fc.return_value = artist
@@ -181,9 +182,10 @@ def test_jellyfin_track_webhook_creates_track_and_scrobble(
     album = Album.objects.create(name="Emotion", album_artist=artist)
     track = Track.objects.create(
         title="Emotion",
-        artist=artist,
+        artist_fk=artist,
         base_run_time_seconds=60,
     )
+    track.artists.add(artist)
     track.albums.add(album)
 
     mock_artist_fc.return_value = artist
@@ -225,9 +227,10 @@ def test_mopidy_track_webhook_stores_raw_data(
     album = Album.objects.create(name="Sublime", album_artist=artist)
     track = Track.objects.create(
         title="Same in the End",
-        artist=artist,
+        artist_fk=artist,
         base_run_time_seconds=60,
     )
+    track.artists.add(artist)
     track.albums.add(album)
 
     mock_artist_fc.return_value = artist
@@ -265,10 +268,11 @@ def test_mopidy_track_webhook_stores_album_id(
     album = Album.objects.create(name="Sublime", album_artist=artist)
     track = Track.objects.create(
         title="Same in the End",
-        artist=artist,
+        artist_fk=artist,
         album=album,
         base_run_time_seconds=60,
     )
+    track.artists.add(artist)
 
     mock_artist_fc.return_value = artist
     mock_track_fc.return_value = track
@@ -303,9 +307,10 @@ def test_jellyfin_track_webhook_stores_raw_data(
     album = Album.objects.create(name="Emotion", album_artist=artist)
     track = Track.objects.create(
         title="Emotion",
-        artist=artist,
+        artist_fk=artist,
         base_run_time_seconds=60,
     )
+    track.artists.add(artist)
     track.albums.add(album)
 
     mock_artist_fc.return_value = artist
@@ -347,11 +352,11 @@ def test_jellyfin_track_webhook_stores_album_id(
     album = Album.objects.create(name="Emotion", album_artist=artist)
     track = Track.objects.create(
         title="Emotion",
-        artist=artist,
+        artist_fk=artist,
         album=album,
         base_run_time_seconds=60,
     )
-    track.albums.add(album)
+    track.artists.add(artist)
 
     mock_artist_fc.return_value = artist
     mock_track_fc.return_value = track
@@ -602,7 +607,8 @@ def test_scrobble_detail_view_post_updates_log(client):
 
     scrobble.refresh_from_db()
     assert scrobble.log["description"] == "Updated description"
-    assert scrobble.log["notes"] == ["Updated note"]
+    assert isinstance(scrobble.log["notes"], dict)
+    assert list(scrobble.log["notes"].values()) == ["Updated note"]
 
 
 @pytest.mark.skip("Need to refactor")

vrobbler/__init__.py

@@ -2,4 +2,5 @@
 # Django starts so that shared_task will use this app.
 from .celery import app as celery_app
 
-__all__ = ("celery_app",)
+__version__ = "42.0"
+__all__ = ("celery_app", "__version__")

vrobbler/apps/birds/importer.py

@@ -8,6 +8,7 @@ from django.contrib.auth import get_user_model
 
 from birds.models import Bird, BirdSightingEntry, BirdSightingLogData, BirdingLocation
 from scrobbles.models import Scrobble
+from scrobbles.notifications import ScrobbleNtfyNotification
 
 logger = logging.getLogger(__name__)
 User = get_user_model()
@@ -183,4 +184,6 @@ def import_birding_csv(file_path, user_id):
 
     created = Scrobble.objects.bulk_create(new_scrobbles)
     logger.info(f"Created {len(created)} birding scrobbles")
+    for scrobble in created:
+        ScrobbleNtfyNotification(scrobble).send()
     return created

vrobbler/apps/boardgames/models.py

@@ -90,6 +90,26 @@ class BoardGameLogData(BaseLogData, LongPlayLogData):
         "variant",
     }
 
+    @classmethod
+    def override_fields(cls) -> dict:
+        from scrobbles.forms import NotesDictField
+
+        fields = {}
+        for base in cls.mro()[1:]:
+            if hasattr(base, "override_fields"):
+                base_fields = base.override_fields()
+                fields.update(base_fields)
+        custom_fields = {
+            "notes": NotesDictField(required=False),
+            "location_id": forms.ModelChoiceField(
+                queryset=BoardGameLocation.objects.all(),
+                required=False,
+                widget=forms.Select(),
+            ),
+        }
+        fields.update(custom_fields)
+        return fields
+
     @cached_property
     def location(self):
         if not self.location_id:
@@ -133,23 +153,6 @@ class BoardGameLogData(BaseLogData, LongPlayLogData):
 
         return "".join(html_parts)
 
-    @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)

vrobbler/apps/charts/templates/charts/chart_index.html

@@ -83,6 +83,12 @@
     {% endfor %}
     <a href="#" class="btn btn-xs btn-outline-secondary" style="padding:1px 3px;font-size:9px;" onclick="var w=prompt('Week number (1-52):');if(w)this.href='/charts/?date={{ year }}-W'+w.padStart(2,'0');return false;">+</a>
 </div>
+<div class="row mb-3">
+    <div class="col-12">
+        <a href="{% url 'charts:spotify-tracks' %}" class="btn btn-sm btn-outline-secondary">🎵 Spotify Tracks</a>
+        <a href="{% url 'charts:bandcamp-tracks' %}" class="btn btn-sm btn-outline-secondary">🎵 Bandcamp Tracks</a>
+    </div>
+</div>
 {% if chart_type == "maloja" %}
 {% include "scrobbles/_top_charts.html" %}
 {% else %}

vrobbler/apps/charts/urls.py

@@ -1,4 +1,10 @@
-from charts.views import BirdsChartView, ChartDetailView, ChartRecordView, SpotifyTracksView
+from charts.views import (
+    BandcampTracksView,
+    BirdsChartView,
+    ChartDetailView,
+    ChartRecordView,
+    SpotifyTracksView,
+)
 from django.urls import path
 
 app_name = "charts"
@@ -6,6 +12,7 @@ app_name = "charts"
 urlpatterns = [
     path("charts/", ChartRecordView.as_view(), name="charts-home"),
     path("charts/spotify/", SpotifyTracksView.as_view(), name="spotify-tracks"),
+    path("charts/bandcamp/", BandcampTracksView.as_view(), name="bandcamp-tracks"),
     path("charts/birds/", BirdsChartView.as_view(), name="birds-chart"),
     path("charts/<slug:media_type>/", ChartDetailView.as_view(), name="chart-detail"),
 ]

vrobbler/apps/charts/utils.py

@@ -104,8 +104,8 @@ def build_charts(
 
     media_config = {
         "artist": {
-            "filter": Q(track__isnull=False) & Q(track__artist__isnull=False),
-            "values": "track__artist",
+            "filter": Q(track__isnull=False) & Q(track__artists__isnull=False),
+            "values": "track__artists",
             "annotate": Count("id", distinct=True),
         },
         "album": {

vrobbler/apps/charts/views.py

@@ -221,6 +221,7 @@ class ChartRecordView(TemplateView):
             context["period"] = "current"
             context["year"] = current_year
             context["month"] = current_month
+            context["month_name"] = calendar.month_name[current_month]
             context["week"] = current_week
             context["day"] = current_day
 
@@ -301,6 +302,7 @@ class ChartRecordView(TemplateView):
             context["period"] = "historical"
             context["year"] = year
             context["month"] = month
+            context["month_name"] = calendar.month_name[month] if month else None
             context["week"] = week
             context["day"] = day
 
@@ -604,9 +606,9 @@ class ChartRecordView(TemplateView):
                 if bird_id:
                     bird_counts[bird_id] = bird_counts.get(bird_id, 0) + quantity
 
-        sorted_birds = sorted(
-            bird_counts.items(), key=lambda x: x[1], reverse=True
-        )[:limit]
+        sorted_birds = sorted(bird_counts.items(), key=lambda x: x[1], reverse=True)[
+            :limit
+        ]
 
         bird_ids = [bid for bid, _ in sorted_birds]
         birds = Bird.objects.filter(id__in=bird_ids)
@@ -727,12 +729,22 @@ class SpotifyTracksView(TemplateView):
     template_name = "charts/spotify_tracks.html"
 
     def get_spotify_tracks(self, user, limit=50):
+        non_spotify_mopidy_tracks = (
+            Scrobble.objects.filter(
+                user=user,
+                source="Mopidy",
+                track__isnull=False,
+            )
+            .exclude(log__mopidy_source="spotify")
+            .values("track")
+        )
         track_ids = (
             Scrobble.objects.filter(
                 user=user,
                 track__isnull=False,
             )
             .filter(Q(source="Last.fm") | Q(log__mopidy_source="spotify"))
+            .exclude(track__in=non_spotify_mopidy_tracks)
             .values("track")
             .annotate(count=Count("id"))
             .order_by("-count")[:limit]
@@ -760,6 +772,53 @@ class SpotifyTracksView(TemplateView):
         return context
 
 
+class BandcampTracksView(TemplateView):
+    template_name = "charts/bandcamp_tracks.html"
+
+    def get_bandcamp_tracks(self, user, limit=50):
+        non_bandcamp_mopidy_tracks = (
+            Scrobble.objects.filter(
+                user=user,
+                source="Mopidy",
+                track__isnull=False,
+            )
+            .exclude(log__mopidy_source="bandcamp")
+            .values("track")
+        )
+        track_ids = (
+            Scrobble.objects.filter(
+                user=user,
+                track__isnull=False,
+                log__mopidy_source="bandcamp",
+            )
+            .exclude(track__in=non_bandcamp_mopidy_tracks)
+            .values("track")
+            .annotate(count=Count("id"))
+            .order_by("-count")[:limit]
+        )
+        from music.models import Track
+
+        track_id_list = [item["track"] for item in track_ids]
+        tracks = Track.objects.filter(id__in=track_id_list)
+        track_map = {t.id: t for t in tracks}
+        return [
+            {
+                "track": track_map[tid],
+                "count": next(
+                    (item["count"] for item in track_ids if item["track"] == tid), 0
+                ),
+            }
+            for tid in track_id_list
+            if tid in track_map
+        ]
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        user = self.request.user
+        context["bandcamp_tracks"] = self.get_bandcamp_tracks(user)
+        return context
+
+
 class BirdsChartView(TemplateView):
     template_name = "charts/birds_chart.html"
 
@@ -792,9 +851,9 @@ class BirdsChartView(TemplateView):
                 if bird_id:
                     bird_counts[bird_id] = bird_counts.get(bird_id, 0) + quantity
 
-        sorted_birds = sorted(
-            bird_counts.items(), key=lambda x: x[1], reverse=True
-        )[:limit]
+        sorted_birds = sorted(bird_counts.items(), key=lambda x: x[1], reverse=True)[
+            :limit
+        ]
 
         bird_ids = [bid for bid, _ in sorted_birds]
         birds = Bird.objects.filter(id__in=bird_ids)

vrobbler/apps/music/admin.py

@@ -1,7 +1,5 @@
 from django.contrib import admin
-
-from music.models import Artist, Album, Track
-
+from music.models import Album, Artist, Track
 from scrobbles.admin import ScrobbleInline
 
 
@@ -11,7 +9,7 @@ class AlbumAdmin(admin.ModelAdmin):
     list_display = (
         "name",
         "year",
-        "album_artist",
+        "artist",
         "theaudiodb_genre",
         "theaudiodb_mood",
         "musicbrainz_id",
@@ -54,12 +52,12 @@ class TrackAdmin(admin.ModelAdmin):
         "artist",
         "musicbrainz_id",
     )
-    raw_id_fields = ("artist", "albums", "album")
-    list_filter = ("album", "artist")
+    raw_id_fields = ("artist_fk", "artists", "albums", "album")
     search_fields = ("title",)
     ordering = ("-created",)
     filter_horizontal = [
         "albums",
+        "artists",
     ]
     inlines = [
         ScrobbleInline,

vrobbler/apps/music/aggregators.py

@@ -149,7 +149,7 @@ def live_charts(
 
 
 def artist_scrobble_count(artist_id: int, filter: str = "today") -> int:
-    return Scrobble.objects.filter(track__artist=artist_id).count()
+    return Scrobble.objects.filter(track__artists=artist_id).count()
 
 
 def live_tv_charts(
@@ -158,7 +158,7 @@ def live_tv_charts(
     limit: int = 15,
 ) -> QuerySet:
     from django.db.models import OuterRef, Subquery
-    from videos.models import Video, Series
+    from videos.models import Series, Video
 
     now = timezone.now()
     tzinfo = now.tzinfo
@@ -215,7 +215,7 @@ def live_youtube_channel_charts(
     limit: int = 15,
 ) -> QuerySet:
     from django.db.models import OuterRef, Subquery
-    from videos.models import Video, Channel
+    from videos.models import Channel, Video
 
     now = timezone.now()
     tzinfo = now.tzinfo

vrobbler/apps/music/api/serializers.py

@@ -1,3 +1,5 @@
+from taggit.serializers import TaggitSerializer, TagListSerializerField
+
 from music.models import Album, Artist, Track
 from rest_framework import serializers
 
@@ -14,7 +16,25 @@ class AlbumSerializer(serializers.HyperlinkedModelSerializer):
         fields = "__all__"
 
 
-class TrackSerializer(serializers.HyperlinkedModelSerializer):
+class TrackSerializer(TaggitSerializer, serializers.HyperlinkedModelSerializer):
+    tags = TagListSerializerField()
+    genre = TagListSerializerField()
+
     class Meta:
         model = Track
-        fields = "__all__"
+        fields = [
+            "url",
+            "id",
+            "uuid",
+            "title",
+            "artist_fk",
+            "artists",
+            "album",
+            "albums",
+            "musicbrainz_id",
+            "genre",
+            "tags",
+            "base_run_time_seconds",
+            "created",
+            "modified",
+        ]

vrobbler/apps/music/listenbrainz.py

@@ -0,0 +1,90 @@
+import logging
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+LB_LABS_API = "https://labs.api.listenbrainz.org"
+STANDARD_ALGORITHM = "session_based_days_180_session_300_contribution_5_threshold_15_limit_50_skip_30"
+MLHD_ALGORITHM = "session_based_mlhd_session_300_contribution_5_threshold_15_limit_50_skip_30"
+SIMILAR_ARTISTS_ALGORITHM = "session_based_days_1825_session_300_contribution_3_threshold_10_limit_100_filter_True_skip_30"
+
+
+def get_similar_recordings(recording_mbid: str) -> list[dict]:
+    """Fetch similar recordings from ListenBrainz.
+
+    Tries the standard dataset first, falls back to MLHD dataset.
+    Returns [] on error or no data.
+    """
+    if not recording_mbid:
+        return []
+
+    try:
+        resp = requests.post(
+            f"{LB_LABS_API}/similar-recordings/json",
+            json=[
+                {
+                    "recording_mbids": [recording_mbid],
+                    "algorithm": STANDARD_ALGORITHM,
+                }
+            ],
+            timeout=10,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        if data:
+            return data
+
+        resp = requests.post(
+            f"{LB_LABS_API}/mlhd-similar-recordings/json",
+            json=[
+                {
+                    "recording_mbids": [recording_mbid],
+                    "algorithm": MLHD_ALGORITHM,
+                }
+            ],
+            timeout=10,
+        )
+        resp.raise_for_status()
+        return resp.json()
+    except requests.RequestException as e:
+        logger.warning(
+            "ListenBrainz similar recordings error",
+            extra={
+                "recording_mbid": recording_mbid,
+                "error": str(e),
+            },
+        )
+        return []
+
+
+def get_similar_artists(artist_mbid: str) -> list[dict]:
+    """Fetch similar artists from ListenBrainz.
+
+    Returns [] on error or no data.
+    """
+    if not artist_mbid:
+        return []
+
+    try:
+        resp = requests.post(
+            f"{LB_LABS_API}/similar-artists/json",
+            json=[
+                {
+                    "artist_mbids": [artist_mbid],
+                    "algorithm": SIMILAR_ARTISTS_ALGORITHM,
+                }
+            ],
+            timeout=10,
+        )
+        resp.raise_for_status()
+        return resp.json()
+    except requests.RequestException as e:
+        logger.warning(
+            "ListenBrainz similar artists error",
+            extra={
+                "artist_mbid": artist_mbid,
+                "error": str(e),
+            },
+        )
+        return []

vrobbler/apps/music/management/commands/cleanup_track_metadata.py

@@ -0,0 +1,249 @@
+import logging
+import time
+
+import musicbrainzngs
+from django.core.management.base import BaseCommand
+from django.db import transaction
+
+from music.musicbrainz import resolve_track, get_track_metadata_with_artist, extract_featured_artists
+
+logger = logging.getLogger(__name__)
+
+VARIOUS_ARTISTS_NAMES = ["various artists", "va", "various"]
+
+
+def _is_various_artists(artist_name: str) -> bool:
+    return artist_name.strip().casefold() in VARIOUS_ARTISTS_NAMES
+
+
+def _get_artist_from_scrobble_logs(track_id: int):
+    from scrobbles.models import Scrobble
+
+    scrobbles = Scrobble.objects.filter(track_id=track_id)[:10]
+    for scrobble in scrobbles:
+        raw = scrobble.log.get("raw_data", {})
+        if not raw:
+            continue
+
+        provider_mbid = raw.get("Provider_musicbrainztrack")
+        if provider_mbid:
+            return {"artist_name": raw.get("Artist", ""), "recording_mbid": provider_mbid}
+
+        artist = raw.get("Artist", "")
+        if artist:
+            return {"artist_name": artist, "recording_mbid": None}
+    return None
+
+
+def _lookup_recording_by_mbid(mbid: str):
+    try:
+        result = musicbrainzngs.get_recording_by_id(mbid, includes=["artists"])
+        recording = result["recording"]
+        length_ms = recording.get("length")
+        artist_credit = recording.get("artist-credit", [{}])
+        primary_artist = artist_credit[0].get("artist", {}) if artist_credit else {}
+        return {
+            "recording_mbid": mbid,
+            "length_ms": int(length_ms) if length_ms else None,
+            "artist_name": primary_artist.get("name", ""),
+            "artist_mbid": primary_artist.get("id", ""),
+        }
+    except (musicbrainzngs.WebServiceError, musicbrainzngs.ResponseError) as e:
+        logger.warning(f"MusicBrainz error looking up {mbid}: {e}")
+        return None
+
+
+def _lookup_length_by_mbid(mbid: str):
+    try:
+        result = musicbrainzngs.get_recording_by_id(mbid)
+        recording = result["recording"]
+        length_ms = recording.get("length")
+        if length_ms:
+            return int(length_ms)
+        return None
+    except (musicbrainzngs.WebServiceError, musicbrainzngs.ResponseError) as e:
+        logger.warning(f"MusicBrainz error looking up {mbid}: {e}")
+        return None
+
+
+class Command(BaseCommand):
+    help = "Clean up metadata on music tracks from MusicBrainz"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--commit",
+            action="store_true",
+            help="Commit changes to the database",
+        )
+        parser.add_argument(
+            "--batch-size",
+            type=int,
+            default=100,
+            help="Number of tracks to process per batch (default: 100)",
+        )
+        parser.add_argument(
+            "--only-missing-mbid",
+            action="store_true",
+            help="Only process tracks missing musicbrainz_id",
+        )
+        parser.add_argument(
+            "--only-missing-length",
+            action="store_true",
+            help="Only process tracks missing base_run_time_seconds",
+        )
+
+    def handle(self, *args, **options):
+        from music.models import Track
+
+        commit = options["commit"]
+        batch_size = options["batch_size"]
+
+        if not commit:
+            self.stdout.write("Dry run — no changes will be saved. Use --commit to apply.")
+
+        musicbrainzngs.set_useragent("vrobbler", "0.3.0")
+
+        qs = Track.objects.all()
+
+        if options["only_missing_mbid"]:
+            qs = qs.filter(musicbrainz_id__isnull=True)
+        if options["only_missing_length"]:
+            qs = qs.filter(base_run_time_seconds__isnull=True)
+
+        total = qs.count()
+        self.stdout.write(f"Processing {total} tracks")
+
+        missing_mbid_qs = qs.filter(musicbrainz_id__isnull=True)
+        missing_length_qs = qs.filter(
+            musicbrainz_id__isnull=False, base_run_time_seconds__isnull=True
+        )
+
+        self.stdout.write(
+            f"  {missing_mbid_qs.count()} tracks without musicbrainz_id"
+        )
+        self.stdout.write(
+            f"  {missing_length_qs.count()} tracks with mbid but no run time"
+        )
+
+        if not commit:
+            self.stdout.write("\nSkipping API lookups in dry-run mode. Use --commit to run against MusicBrainz.")
+            return
+
+        found_count = 0
+        not_found_count = 0
+        length_fixed_count = 0
+        va_fixed_count = 0
+        track_ids = list(missing_mbid_qs.values_list("pk", flat=True))
+        i = 0
+
+        for batch_num, offset in enumerate(range(0, len(track_ids), batch_size)):
+            batch_pks = track_ids[offset : offset + batch_size]
+            with transaction.atomic():
+                for track in Track.objects.filter(pk__in=batch_pks).iterator():
+                    i += 1
+                    artist_name = ""
+                    artist_obj = track.artist
+                    if artist_obj:
+                        artist_name = artist_obj.name
+
+                    is_va = _is_various_artists(artist_name)
+                    result = None
+                    method = ""
+
+                    if is_va:
+                        scrobble_info = _get_artist_from_scrobble_logs(track.id)
+                        if scrobble_info:
+                            if scrobble_info["recording_mbid"]:
+                                result = _lookup_recording_by_mbid(
+                                    scrobble_info["recording_mbid"]
+                                )
+                                if result:
+                                    method = "provider"
+                                    self.stdout.write(
+                                        f"  VA track '{track.title}' matched via provider MBID "
+                                        f"{scrobble_info['recording_mbid']} (artist: {scrobble_info['artist_name']})"
+                                    )
+                            else:
+                                result, method = resolve_track(
+                                    track.title, scrobble_info["artist_name"]
+                                )
+                                if result:
+                                    self.stdout.write(
+                                        f"  VA track '{track.title}' matched via log artist "
+                                        f"'{scrobble_info['artist_name']}' as {result['recording_mbid']} ({method})"
+                                    )
+
+                        if not result:
+                            result, method = resolve_track(track.title)
+                            if result:
+                                self.stdout.write(
+                                    f"  VA track '{track.title}' matched by title alone "
+                                    f"as {result['recording_mbid']} ({method})"
+                                )
+
+                    if not result:
+                        result, method = resolve_track(track.title, artist_name)
+
+                    if result and result.get("recording_mbid"):
+                        track.musicbrainz_id = result["recording_mbid"]
+                        length_ms = result.get("length_ms")
+                        if length_ms and not track.base_run_time_seconds:
+                            track.base_run_time_seconds = int(int(length_ms) / 1000)
+                        track.save(update_fields=["musicbrainz_id", "base_run_time_seconds"])
+                        method_tag = f"musicbrainz-{method}" if method else "musicbrainz-enriched"
+                        track.tags.add(method_tag, "musicbrainz-enriched")
+                        from music.models import Artist
+                        cleaned_title, featured_names = extract_featured_artists(track.title)
+                        for feat_name in featured_names:
+                            artist = Artist.find_or_create(feat_name, track_name=track.title)
+                            if artist:
+                                track.artists.add(artist)
+                        self.stdout.write(
+                            f"  [{i}] FOUND {track} — mbid={track.musicbrainz_id} ({method})"
+                        )
+                        found_count += 1
+                    else:
+                        track.tags.add("musicbrainz-notfound")
+                        self.stdout.write(
+                            f"  [{i}] NOTFOUND {track}"
+                        )
+                        not_found_count += 1
+
+                    if is_va and result:
+                        va_fixed_count += 1
+
+            self.stdout.write(
+                f"  Batch {batch_num + 1}: {offset + len(batch_pks)}/{total} processed, "
+                f"found: {found_count}, not found: {not_found_count}"
+            )
+            time.sleep(1)
+
+        length_ids = list(missing_length_qs.values_list("pk", flat=True))
+        j = 0
+        for batch_num, offset in enumerate(range(0, len(length_ids), batch_size)):
+            batch_pks = length_ids[offset : offset + batch_size]
+            with transaction.atomic():
+                for track in Track.objects.filter(pk__in=batch_pks).iterator():
+                    j += 1
+                    length_ms = _lookup_length_by_mbid(track.musicbrainz_id)
+                    if length_ms:
+                        track.base_run_time_seconds = int(int(length_ms) / 1000)
+                        track.tags.add("musicbrainz-enriched")
+                        track.save(update_fields=["base_run_time_seconds"])
+                        self.stdout.write(
+                            f"  [{j}] LENGTH {track} — {track.base_run_time_seconds}s"
+                        )
+                        length_fixed_count += 1
+
+            self.stdout.write(
+                f"  Batch {batch_num + 1}: {j}/{len(length_ids)} length lookups"
+            )
+            time.sleep(1)
+
+        self.stdout.write(
+            f"\nResults (commit={commit}):\n"
+            f"  Found on MusicBrainz: {found_count}\n"
+            f"  Not found / tagged musicbrainz-notfound: {not_found_count}\n"
+            f"  Run times filled from MBID: {length_fixed_count}\n"
+            f"  Various Artists tracks resolved: {va_fixed_count}"
+        )

vrobbler/apps/music/management/commands/lookup_similar_artists.py

@@ -0,0 +1,123 @@
+import logging
+import time
+
+from django.core.management.base import BaseCommand
+
+from music.listenbrainz import get_similar_artists
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Fetch similar artists from ListenBrainz for artists with a musicbrainz_id"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--commit",
+            action="store_true",
+            help="Commit changes to the database",
+        )
+        parser.add_argument(
+            "--batch-size",
+            type=int,
+            default=100,
+            help="Number of artists to process per batch (default: 100)",
+        )
+        parser.add_argument(
+            "--artist-id",
+            type=str,
+            default="",
+            help="Only process the artist with this musicbrainz_id",
+        )
+        parser.add_argument(
+            "--overwrite",
+            action="store_true",
+            help="Re-fetch similar artists even if already populated",
+        )
+
+    def handle(self, *args, **options):
+        from music.models import Artist
+
+        commit = options["commit"]
+        batch_size = options["batch_size"]
+        artist_id = options["artist_id"]
+        overwrite = options["overwrite"]
+
+        if not commit:
+            self.stdout.write(
+                "Dry run — no changes will be saved. Use --commit to apply."
+            )
+
+        qs = Artist.objects.exclude(musicbrainz_id__isnull=True).exclude(
+            musicbrainz_id=""
+        )
+
+        if artist_id:
+            qs = qs.filter(musicbrainz_id=artist_id)
+            self.stdout.write(f"Filtering to artist with musicbrainz_id: {artist_id}")
+        elif not overwrite:
+            qs = qs.filter(similar_artists__isnull=True)
+        else:
+            qs = qs.all()
+
+        total = qs.count()
+        if total == 0:
+            self.stdout.write("No artists to process.")
+            return
+
+        self.stdout.write(
+            f"Found {total} artists with musicbrainz_id"
+            + (" (overwrite mode)" if overwrite else "")
+            + (" (--artist-id filter)" if artist_id else "")
+        )
+
+        if not commit:
+            self.stdout.write(
+                "\nSkipping API lookups in dry-run mode. Use --commit to run against ListenBrainz."
+            )
+            return
+
+        found_count = 0
+        empty_count = 0
+        error_count = 0
+        artist_ids = list(qs.values_list("pk", flat=True))
+        i = 0
+
+        for batch_num, offset in enumerate(
+            range(0, len(artist_ids), batch_size)
+        ):
+            batch_pks = artist_ids[offset : offset + batch_size]
+            for artist in Artist.objects.filter(pk__in=batch_pks).iterator():
+                i += 1
+                self.stdout.write(
+                    f"  [{i}/{total}] Fetching similar artists for {artist}...",
+                    ending="",
+                )
+                try:
+                    similar = get_similar_artists(artist.musicbrainz_id)
+                    if similar:
+                        artist.similar_artists = similar
+                        artist.save(update_fields=["similar_artists"])
+                        self.stdout.write(f" {len(similar)} similar artists found")
+                        found_count += 1
+                    else:
+                        artist.similar_artists = []
+                        artist.save(update_fields=["similar_artists"])
+                        self.stdout.write(" none found")
+                        empty_count += 1
+                except Exception as e:
+                    self.stdout.write(f" error: {e}")
+                    error_count += 1
+
+            self.stdout.write(
+                f"  Batch {batch_num + 1}: {offset + len(batch_pks)}/{total} processed, "
+                f"found: {found_count}, empty: {empty_count}, errors: {error_count}"
+            )
+            time.sleep(1)
+
+        self.stdout.write(
+            f"\nResults (commit={commit}):\n"
+            f"  Similar artists found: {found_count}\n"
+            f"  No similar artists: {empty_count}\n"
+            f"  Errors: {error_count}"
+        )

vrobbler/apps/music/management/commands/lookup_similar_recordings.py

@@ -0,0 +1,125 @@
+import logging
+import time
+
+from django.core.management.base import BaseCommand
+
+from music.listenbrainz import get_similar_recordings
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Fetch similar recordings from ListenBrainz for tracks with a musicbrainz_id"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--commit",
+            action="store_true",
+            help="Commit changes to the database",
+        )
+        parser.add_argument(
+            "--batch-size",
+            type=int,
+            default=100,
+            help="Number of tracks to process per batch (default: 100)",
+        )
+        parser.add_argument(
+            "--track-id",
+            type=str,
+            default="",
+            help="Only process the track with this musicbrainz_id",
+        )
+        parser.add_argument(
+            "--overwrite",
+            action="store_true",
+            help="Re-fetch similar recordings even if already populated",
+        )
+
+    def handle(self, *args, **options):
+        from music.models import Track
+
+        commit = options["commit"]
+        batch_size = options["batch_size"]
+        track_id = options["track_id"]
+        overwrite = options["overwrite"]
+
+        if not commit:
+            self.stdout.write(
+                "Dry run — no changes will be saved. Use --commit to apply."
+            )
+
+        qs = Track.objects.exclude(musicbrainz_id__isnull=True).exclude(
+            musicbrainz_id=""
+        )
+
+        if track_id:
+            qs = qs.filter(musicbrainz_id=track_id)
+            self.stdout.write(f"Filtering to track with musicbrainz_id: {track_id}")
+        elif not overwrite:
+            qs = qs.filter(similar_recordings__isnull=True)
+        else:
+            qs = qs.all()
+
+        total = qs.count()
+        if total == 0:
+            self.stdout.write("No tracks to process.")
+            return
+
+        self.stdout.write(
+            f"Found {total} tracks with musicbrainz_id"
+            + (" (overwrite mode)" if overwrite else "")
+            + (" (--track-id filter)" if track_id else "")
+        )
+
+        if not commit:
+            self.stdout.write(
+                "\nSkipping API lookups in dry-run mode. Use --commit to run against ListenBrainz."
+            )
+            return
+
+        found_count = 0
+        empty_count = 0
+        error_count = 0
+        track_ids = list(qs.values_list("pk", flat=True))
+        i = 0
+
+        for batch_num, offset in enumerate(
+            range(0, len(track_ids), batch_size)
+        ):
+            batch_pks = track_ids[offset : offset + batch_size]
+            for track in Track.objects.filter(pk__in=batch_pks).iterator():
+                i += 1
+                self.stdout.write(
+                    f"  [{i}/{total}] Fetching similar recordings for {track}...",
+                    ending="",
+                )
+                try:
+                    similar = get_similar_recordings(track.musicbrainz_id)
+                    if similar:
+                        track.similar_recordings = similar
+                        track.save(update_fields=["similar_recordings"])
+                        self.stdout.write(
+                            f" {len(similar)} similar recordings found"
+                        )
+                        found_count += 1
+                    else:
+                        track.similar_recordings = []
+                        track.save(update_fields=["similar_recordings"])
+                        self.stdout.write(" none found")
+                        empty_count += 1
+                except Exception as e:
+                    self.stdout.write(f" error: {e}")
+                    error_count += 1
+
+            self.stdout.write(
+                f"  Batch {batch_num + 1}: {offset + len(batch_pks)}/{total} processed, "
+                f"found: {found_count}, empty: {empty_count}, errors: {error_count}"
+            )
+            time.sleep(1)
+
+        self.stdout.write(
+            f"\nResults (commit={commit}):\n"
+            f"  Similar recordings found: {found_count}\n"
+            f"  No similar recordings: {empty_count}\n"
+            f"  Errors: {error_count}"
+        )

vrobbler/apps/music/migrations/0032_track_artist_fk_and_artists.py

@@ -0,0 +1,32 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("music", "0031_alter_track_genre"),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name="track",
+            old_name="artist",
+            new_name="artist_fk",
+        ),
+        migrations.AlterField(
+            model_name="track",
+            name="artist_fk",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=models.DO_NOTHING,
+                related_name="+",
+                to="music.artist",
+            ),
+        ),
+        migrations.AddField(
+            model_name="track",
+            name="artists",
+            field=models.ManyToManyField(to="music.artist"),
+        ),
+    ]

vrobbler/apps/music/migrations/0033_backfill_track_artists.py

@@ -0,0 +1,27 @@
+from django.db import migrations
+
+
+def backfill_artist_fk_to_artists(apps, schema_editor):
+    Track = apps.get_model("music", "Track")
+    TrackArtist = Track.artists.through
+    TrackArtist.objects.bulk_create(
+        [
+            TrackArtist(track_id=r["id"], artist_id=r["artist_fk_id"])
+            for r in Track.objects.filter(artist_fk__isnull=False).values("id", "artist_fk_id")
+        ],
+        ignore_conflicts=True,
+    )
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("music", "0032_track_artist_fk_and_artists"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            backfill_artist_fk_to_artists,
+            reverse_code=migrations.RunPython.noop,
+        ),
+    ]

vrobbler/apps/music/migrations/0034_backfill_album_artists.py

@@ -0,0 +1,29 @@
+from django.db import migrations
+
+
+def backfill_album_artist_to_artists(apps, schema_editor):
+    Album = apps.get_model("music", "Album")
+    AlbumArtist = Album.artists.through
+    AlbumArtist.objects.bulk_create(
+        [
+            AlbumArtist(album_id=r["id"], artist_id=r["album_artist_id"])
+            for r in Album.objects.filter(album_artist__isnull=False).values(
+                "id", "album_artist_id"
+            )
+        ],
+        ignore_conflicts=True,
+    )
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("music", "0033_backfill_track_artists"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            backfill_album_artist_to_artists,
+            reverse_code=migrations.RunPython.noop,
+        ),
+    ]

vrobbler/apps/music/migrations/0035_track_similar_recordings.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.30 on 2026-05-29 23:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("music", "0034_backfill_album_artists"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="track",
+            name="similar_recordings",
+            field=models.JSONField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/music/migrations/0036_artist_similar_artists.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.30 on 2026-05-30 00:00
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("music", "0035_track_similar_recordings"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="artist",
+            name="similar_artists",
+            field=models.JSONField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/music/models.py

@@ -16,9 +16,11 @@ 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 (
+    extract_featured_artists,
     get_album_metadata_with_artist,
     get_recording_mbid_exact,
     get_track_metadata_with_artist,
+    resolve_track,
 )
 from music.theaudiodb import lookup_album_from_tadb, lookup_artist_from_tadb
 from music.utils import clean_artist_name
@@ -54,6 +56,7 @@ class Artist(TimeStampedModel):
     theaudiodb_genre = models.CharField(max_length=255, **BNULL)
     theaudiodb_mood = models.CharField(max_length=255, **BNULL)
     musicbrainz_id = models.CharField(max_length=255, **BNULL)
+    similar_artists = models.JSONField(**BNULL)
     allmusic_id = models.CharField(max_length=100, **BNULL)
     bandcamp_id = models.CharField(max_length=100, **BNULL)
     thumbnail = models.ImageField(upload_to="artist/", **BNULL)
@@ -124,7 +127,7 @@ class Artist(TimeStampedModel):
     def charts(self):
         from scrobbles.models import ChartRecord
 
-        return ChartRecord.objects.filter(track__artist=self).order_by("-year")
+        return ChartRecord.objects.filter(track__artists=self).order_by("-year")
 
     def scrape_allmusic(self, force=False) -> None:
         if not self.allmusic_id or force:
@@ -294,7 +297,7 @@ class Album(TimeStampedModel):
     alt_names = models.TextField(**BNULL)
 
     def __str__(self) -> str:
-        return "{} by {}".format(self.name, self.album_artist)
+        return "{} by {}".format(self.name, self.artist)
 
     def get_absolute_url(self):
         return reverse("music:album_detail", kwargs={"slug": self.uuid})
@@ -320,6 +323,10 @@ class Album(TimeStampedModel):
             .order_by("-scrobble_count")
         )
 
+    @property
+    def artist(self):
+        return self.artists.first() or self.album_artist
+
     def fix_album_artist(self):
         from music.utils import get_or_create_various_artists
 
@@ -338,10 +345,10 @@ class Album(TimeStampedModel):
             )
             return
 
-        if self.album_artist and (not self.allmusic_id or force):
-            slug = get_allmusic_slug(self.album_artist.name, self.name)
+        if self.artist and (not self.allmusic_id or force):
+            slug = get_allmusic_slug(self.artist.name, self.name)
             if not slug:
-                logger.info(f"No allmsuic link for {self} by {self.album_artist}")
+                logger.info(f"No allmsuic link for {self} by {self.artist}")
                 return
             self.allmusic_id = slug
             self.save(update_fields=["allmusic_id"])
@@ -351,7 +358,7 @@ class Album(TimeStampedModel):
             allmusic_data = scrape_data_from_allmusic(self.allmusic_link)
 
         if not allmusic_data:
-            logger.info(f"No allmsuic data for {self} by {self.album_artist}")
+            logger.info(f"No allmsuic data for {self} by {self.artist}")
             return
 
         self.allmusic_review = allmusic_data["review"]
@@ -360,8 +367,8 @@ class Album(TimeStampedModel):
 
     def scrape_theaudiodb(self) -> None:
         artist = "Various Artists"
-        if self.album_artist:
-            artist = self.album_artist.name
+        if self.artist:
+            artist = self.artist.name
         album_data = lookup_album_from_tadb(self.name, artist)
         if not album_data.get("theaudiodb_id"):
             logger.info(f"No data for {self} found in TheAudioDB")
@@ -374,7 +381,7 @@ class Album(TimeStampedModel):
 
     def scrape_bandcamp(self, force=False) -> None:
         if not self.bandcamp_id or force:
-            slug = get_bandcamp_slug(self.album_artist.name, self.name)
+            slug = get_bandcamp_slug(self.artist.name, self.name)
             if not slug:
                 logger.info(f"No bandcamp link for {self}")
                 return
@@ -422,7 +429,8 @@ class Album(TimeStampedModel):
                 self.artists.add(new_artist)
             if not new_artist:
                 for t in self.track_set.all():
-                    self.artists.add(t.artist)
+                    for a in t.artists.all():
+                        self.artists.add(a)
             if not self.cover_image or self.cover_image == "default-image-replace-me":
                 self.fetch_artwork()
         self.fix_album_artist()
@@ -484,19 +492,19 @@ class Album(TimeStampedModel):
 
     @property
     def rym_link(self):
-        artist_slug = self.album_artist.name.lower().replace(" ", "-")
+        artist_slug = self.artist.name.lower().replace(" ", "-")
         album_slug = self.name.lower().replace(" ", "-")
         return f"https://rateyourmusic.com/release/album/{artist_slug}/{album_slug}/"
 
     @property
     def bandcamp_link(self):
-        if self.bandcamp_id and self.album_artist.bandcamp_id:
-            return f"https://{self.album_artist.bandcamp_id}.bandcamp.com/album/{self.bandcamp_id}"
+        if self.bandcamp_id and self.artist.bandcamp_id:
+            return f"https://{self.artist.bandcamp_id}.bandcamp.com/album/{self.bandcamp_id}"
         return ""
 
     @property
     def bandcamp_search_link(self):
-        artist = self.album_artist.name.lower()
+        artist = self.artist.name.lower()
         album = self.name.lower()
         return f"https://bandcamp.com/search?q={album} {artist}&item_type=a"
 
@@ -564,7 +572,7 @@ class Album(TimeStampedModel):
                 album_artist=artist,
                 alt_names=alt_name,
             )
-            album.artists.add(*extra_artists)
+            album.artists.add(artist, *extra_artists)
             album.fetch_artwork()
 
         return album
@@ -573,14 +581,22 @@ class Album(TimeStampedModel):
 class Track(ScrobblableMixin):
     COMPLETION_PERCENT = getattr(settings, "MUSIC_COMPLETION_PERCENT", 100)
 
-    artist = models.ForeignKey(Artist, on_delete=models.DO_NOTHING)
+    artist_fk = models.ForeignKey(
+        Artist, on_delete=models.DO_NOTHING, **BNULL, related_name="+"
+    )
+    artists = models.ManyToManyField(Artist)
     albums = models.ManyToManyField(Album, related_name="tracks")
     album = models.ForeignKey(Album, on_delete=models.DO_NOTHING, **BNULL)
     musicbrainz_id = models.CharField(max_length=255, **BNULL)
+    similar_recordings = models.JSONField(**BNULL)
 
     class Meta:
         unique_together = [["album", "musicbrainz_id"]]
 
+    @property
+    def artist(self):
+        return self.artists.first() or self.artist_fk
+
     def __str__(self):
         return f"{self.title} by {self.artist}"
 
@@ -615,8 +631,9 @@ class Track(ScrobblableMixin):
     @property
     def primary_image_url(self) -> str:
         url = ""
-        if self.artist.thumbnail:
-            url = self.artist.thumbnail_medium.url
+        primary_artist = self.artist
+        if primary_artist and primary_artist.thumbnail:
+            url = primary_artist.thumbnail_medium.url
         if self.primary_album and self.primary_album.cover_image:
             url = self.primary_album.cover_image_medium.url
         return url
@@ -625,6 +642,7 @@ class Track(ScrobblableMixin):
     def find_or_create(
         cls,
         title: str = "",
+        artist_names: list[str] | None = None,
         artist_name: str = "",
         album_name: str = "",
         run_time_seconds: int | None = None,
@@ -638,25 +656,40 @@ class Track(ScrobblableMixin):
         name
 
         Optionally, we can update any found artists with overwrite."""
+        from music.utils import parse_artist_names
+
+        if artist_names is None and artist_name:
+            artist_names = parse_artist_names(artist_name)
+
+        if not artist_names:
+            artist_names = []
+
         album = None
         if album_name:
             logger.info(f"Looking up album for: {album_name}")
-            album = Album.find_or_create(name=album_name, artist_name=artist_name)
-            artist = album.album_artist
-        else:
-            artist = Artist.find_or_create(artist_name, track_name=title)
-        if not artist:
-            artist = Artist.find_or_create(artist_name)
+            first_name = artist_names[0] if artist_names else ""
+            album = Album.find_or_create(name=album_name, artist_name=first_name)
+
+        artist_objs = []
+        for name in artist_names:
+            artist = Artist.find_or_create(name, track_name=title)
+            if artist:
+                artist_objs.append(artist)
+
+        track = None
+        if artist_objs:
+            track = cls.objects.filter(title=title, artists__in=artist_objs).first()
 
-        lookup_keys = {"title": title, "artist": artist}
-        if 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 not track:
-            track = cls.objects.filter(title=title, artist=artist).first()
-            if not track:
-                track, _ = cls.objects.get_or_create(title=title, artist=artist)
+            track = cls.objects.filter(title=title).first()
+
+        if not track:
+            track = cls(title=title)
+            track.save()
+            track.refresh_from_db()
+
+        if artist_objs:
+            track.artists.add(*artist_objs)
 
         if album:
             track.albums.add(album)
@@ -665,29 +698,37 @@ class Track(ScrobblableMixin):
             if mbid and run_time_seconds:
                 track.base_run_time_seconds = run_time_seconds
                 track.musicbrainz_id = mbid
+                track.tags.add("musicbrainz-provider", "musicbrainz-enriched")
             else:
+                artist_name_str = " & ".join(artist_names) if artist_names else ""
                 logger.info(
                     f"Enriching track {track}",
                     extra={
                         "title": title,
-                        "artist_name": artist_name,
+                        "artist_name": artist_name_str,
                         "track_id": track.id,
                     },
                 )
-                try:
-                    mbid, length = get_recording_mbid_exact(
-                        title, artist_name, album_name
-                    )
-                except Exception:
+                result, method = resolve_track(title, artist_name_str, album_name)
+                if result and result.get("recording_mbid"):
+                    track.musicbrainz_id = result["recording_mbid"]
+                    length_ms = result.get("length_ms")
+                    if length_ms and not track.base_run_time_seconds:
+                        track.base_run_time_seconds = int(int(length_ms) / 1000)
+                    method_tag = f"musicbrainz-{method}" if method else ""
+                    track.tags.add(method_tag, "musicbrainz-enriched")
+                    cleaned_title, featured_names = extract_featured_artists(title)
+                    for feat_name in featured_names:
+                        artist = Artist.find_or_create(feat_name, track_name=title)
+                        if artist:
+                            track.artists.add(artist)
+                else:
                     print("No musicbrainz result found, cannot enrich")
+                    track.tags.add("musicbrainz-notfound")
                     return track
-                track.base_run_time_seconds = run_time_seconds or int(length / 1000)
-                track.musicbrainz_id = mbid
             if commit:
                 track.save()
 
         return track
 
-    def fix_metadata(self, force_update=False):
-
-        ...
+    def fix_metadata(self, force_update=False): ...

vrobbler/apps/music/musicbrainz.py

@@ -1,11 +1,155 @@
-from datetime import datetime
 import logging
+import re
+from datetime import datetime
 
 import musicbrainzngs
 from dateutil.parser import parse
 
 logger = logging.getLogger(__name__)
 
+TRACK_SUFFIXES = [
+    r" - Bonus Track",
+    r" - Bonus",
+    r" - Remix",
+    r" - Live",
+    r" - Radio Edit",
+    r" - Extended Mix",
+    r" - Instrumental",
+    r" - Acoustic",
+    r" - Mix",
+    r" - Edit",
+    r" \[Explicit\]",
+]
+
+FEATURED_PATTERNS = [
+    (r"\(feat\. (.+?)\)", re.IGNORECASE),
+    (r"\(ft\. (.+?)\)", re.IGNORECASE),
+    (r"featuring (.+)", re.IGNORECASE),
+    (r"feat\. (.+)", re.IGNORECASE),
+    (r"ft\. (.+)", re.IGNORECASE),
+]
+
+
+def strip_track_suffixes(title: str) -> str:
+    for suffix in TRACK_SUFFIXES:
+        title = re.sub(suffix, "", title, flags=re.IGNORECASE)
+    return title.strip()
+
+
+def extract_featured_artists(title: str) -> tuple[str, list[str]]:
+    featured = []
+    cleaned = title
+    for pattern, flags in FEATURED_PATTERNS:
+        m = re.search(pattern, cleaned, flags)
+        if m:
+            featured.append(m.group(1).strip())
+            cleaned = re.sub(pattern, "", cleaned, flags=flags).strip()
+    return cleaned, featured
+
+
+def search_recordings(title: str, artist: str = "") -> list[dict]:
+    kwargs: dict = {"recording": title, "limit": 10}
+    if artist:
+        kwargs["artist"] = artist
+    try:
+        return musicbrainzngs.search_recordings(**kwargs).get("recording-list", [])
+    except (musicbrainzngs.WebServiceError, musicbrainzngs.ResponseError) as e:
+        logger.warning(f"MusicBrainz search error: {e}")
+        return []
+
+
+def pick_best_recording(
+    recordings: list[dict], title: str, artist: str = ""
+) -> tuple[dict | None, str]:
+    query_title = title.strip().casefold()
+    query_artist = artist.strip().casefold() if artist else ""
+    best_score: tuple[dict | None, str] = (None, "")
+
+    for rec in recordings:
+        rec_title = rec.get("title", "").strip()
+        score = int(rec.get("ext:score", 0))
+
+        if rec_title.casefold() != query_title:
+            if score >= 85 and not best_score[0]:
+                best_score = (rec, "score")
+            continue
+
+        if query_artist:
+            artist_credit = rec.get("artist-credit", [])
+            rec_artist = (
+                artist_credit[0]["artist"]["name"].strip()
+                if artist_credit
+                else ""
+            )
+            if rec_artist.casefold() != query_artist:
+                if score >= 85 and not best_score[0]:
+                    best_score = (rec, "score")
+                continue
+
+        return (rec, "exact")
+
+    return best_score
+
+
+def resolve_track(
+    title: str, artist: str = "", album: str = ""
+) -> tuple[dict | None, str]:
+    if not title:
+        return (None, "")
+
+    titles_to_try: list[tuple[str, str]] = [(title, "")]
+    stripped = strip_track_suffixes(title)
+    if stripped != title:
+        titles_to_try.append((stripped, "stripped-"))
+
+    for attempt_title, prefix in titles_to_try:
+        if album and not prefix:
+            try:
+                mbid, length = get_recording_mbid_exact(
+                    attempt_title, artist, album
+                )
+                return (
+                    {
+                        "recording_mbid": mbid,
+                        "length_ms": length,
+                    },
+                    "exact",
+                )
+            except Exception:
+                pass
+
+        if artist:
+            result = get_track_metadata_with_artist(attempt_title, artist)
+            if result and result.get("recording_mbid"):
+                return (result, f"{prefix}exact")
+
+            recordings = search_recordings(attempt_title, artist)
+            result, tag = pick_best_recording(recordings, attempt_title, artist)
+            if result:
+                length_ms = result.get("length")
+                return (
+                    {
+                        "recording_mbid": result["id"],
+                        "length_ms": int(length_ms) if length_ms else None,
+                    },
+                    f"{prefix}{tag}",
+                )
+
+        recordings = search_recordings(attempt_title)
+        result, tag = pick_best_recording(recordings, attempt_title)
+        if result:
+            tag = "title-only" if not prefix else f"{prefix}title-only"
+            length_ms = result.get("length")
+            return (
+                {
+                    "recording_mbid": result["id"],
+                    "length_ms": int(length_ms) if length_ms else None,
+                },
+                tag,
+            )
+
+    return (None, "")
+
 musicbrainzngs.set_useragent("Vrobbler", "1.0", "help@unbl.ink")
 
 

vrobbler/apps/music/utils.py

@@ -15,12 +15,26 @@ def clean_artist_name(name: str) -> str:
         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()
-    # if " & " in name.lower() and "of the wand" not in name.lower():
-    #    name = re.split("&", name, flags=re.IGNORECASE)[0].strip()
 
     return name
 
 
+def parse_artist_names(name: str) -> list[str]:
+    """Split a combined artist string (e.g. 'A & B') into individual names.
+
+    First strips feat./featuring/w. prefixes, then splits on ' & ' to
+    support collaboration-style credits like 'Matt Sweeney & Bonnie Prince Billy'.
+    """
+    name = clean_artist_name(name)
+    if " & " in name.lower():
+        return [
+            part.strip()
+            for part in re.split(r"\s+&\s+", name, flags=re.IGNORECASE)
+            if part.strip()
+        ]
+    return [name]
+
+
 def get_or_create_various_artists() -> "Artist":
     from music.models import Artist
 
@@ -35,19 +49,19 @@ def deduplicate_tracks(commit=False) -> int:
     from music.models import Track
 
     duplicates = (
-        Track.objects.values("artist", "title")
+        Track.objects.values("title")
         .annotate(dup_count=models.Count("id"))
         .filter(dup_count__gt=1)
     )
 
     query = models.Q()
     for dup in duplicates:
-        query |= models.Q(artist=dup["artist"], title=dup["title"])
+        query |= models.Q(title=dup["title"])
 
     duplicate_tracks = Track.objects.filter(query)
 
     for b in duplicate_tracks:
-        tracks = Track.objects.filter(artist=b.artist, title=b.title)
+        tracks = Track.objects.filter(title=b.title)
         first = tracks.first()
         for other in tracks.exclude(id=first.id):
             print("Moving scrobbles for", other.id, " to ", first.id)
@@ -74,7 +88,7 @@ def condense_albums(commit: bool = False):
     for track in Track.objects.all():
         albums_to_add = []
         duplicates = (
-            Track.objects.filter(title=track.title, artist=track.artist)
+            Track.objects.filter(title=track.title)
             .exclude(id=track.id)
             .exclude(id__in=processed_ids)
         )
@@ -88,7 +102,7 @@ def condense_albums(commit: bool = False):
                 track.albums.add(dup_track.album)
 
         # Find out if this track appears more than once
-        duplicates = Track.objects.filter(title=track.title, artist=track.artist)
+        duplicates = Track.objects.filter(title=track.title)
         if duplicates.count() > 1:
             logger.info(f"Track appears more than once, condensing: {track}")
 

vrobbler/apps/music/views.py

@@ -1,10 +1,9 @@
+from charts.models import ChartRecord
 from django.db.models import Count
 from django.views import generic
 from music.models import Album, Artist, Track
-from charts.models import ChartRecord
 from scrobbles.stats import get_scrobble_count_qs
-
-from scrobbles.views import ScrobbleableListView, ScrobbleableDetailView
+from scrobbles.views import ScrobbleableDetailView, ScrobbleableListView
 
 
 class TrackListView(ScrobbleableListView):
@@ -20,16 +19,24 @@ class ArtistListView(generic.ListView):
     paginate_by = 100
 
     def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .annotate(scrobble_count=Count("track__scrobble"))
-            .order_by("-scrobble_count")
-        )
+        qs = super().get_queryset().annotate(scrobble_count=Count("track__scrobble"))
+        genre = self.request.GET.get("genre")
+        if genre:
+            qs = qs.filter(theaudiodb_genre=genre)
+        mood = self.request.GET.get("mood")
+        if mood:
+            qs = qs.filter(theaudiodb_mood=mood)
+        return qs.order_by("-scrobble_count")
 
     def get_context_data(self, *, object_list=None, **kwargs):
         context_data = super().get_context_data(object_list=object_list, **kwargs)
         context_data["view"] = self.request.GET.get("view")
+        genre = self.request.GET.get("genre")
+        if genre:
+            context_data["active_filter"] = f"genre: {genre}"
+        mood = self.request.GET.get("mood")
+        if mood:
+            context_data["active_filter"] = f"mood: {mood}"
         return context_data
 
 
@@ -64,11 +71,38 @@ class ArtistDetailView(generic.DetailView):
         from scrobbles.models import Scrobble
 
         context_data["recent_scrobbles"] = (
-            Scrobble.objects.filter(track__artist=artist)
+            Scrobble.objects.filter(track__artists=artist)
             .select_related("track", "track__album")
             .order_by("-timestamp")[:100]
         )
 
+        similar = artist.similar_artists or []
+        if similar:
+            top = similar[:10]
+            mbids = [sa["artist_mbid"] for sa in top if sa.get("artist_mbid")]
+            local_artists = {
+                a.musicbrainz_id: a
+                for a in Artist.objects.filter(musicbrainz_id__in=mbids)
+            }
+            for sa in top:
+                local = local_artists.get(sa.get("artist_mbid"))
+                sa["local_url"] = local.get_absolute_url() if local else None
+                sa["musicbrainz_url"] = (
+                    f"https://musicbrainz.org/artist/{sa['artist_mbid']}"
+                    if sa.get("artist_mbid")
+                    else None
+                )
+            context_data["similar_artists"] = top
+
+        if artist.theaudiodb_genre:
+            context_data["genre_count"] = Artist.objects.filter(
+                theaudiodb_genre=artist.theaudiodb_genre
+            ).count()
+        if artist.theaudiodb_mood:
+            context_data["mood_count"] = Artist.objects.filter(
+                theaudiodb_mood=artist.theaudiodb_mood
+            ).count()
+
         return context_data
 
 

vrobbler/apps/profiles/forms.py

@@ -31,6 +31,9 @@ class UserProfileForm(forms.ModelForm):
             "webdav_auto_import",
             "ntfy_url",
             "ntfy_enabled",
+            "mopidy_api_url",
+            "favorites_mopidy_playlist",
+            "monthly_mopidy_playlist_pattern",
             "redirect_to_webpage",
             "enable_public_widgets",
             "widget_custom_css",

vrobbler/apps/profiles/migrations/0033_userprofile_mopidy_api_url.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.30 on 2026-06-04 16:27
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("profiles", "0032_userprofile_weigh_in_units"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="mopidy_api_url",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]

vrobbler/apps/profiles/migrations/0034_userprofile_favorites_mopidy_playlist.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.30 on 2026-06-05 14:55
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("profiles", "0033_userprofile_mopidy_api_url"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="favorites_mopidy_playlist",
+            field=models.CharField(
+                blank=True,
+                help_text="Playlist name (e.g. 'Favorites'). Will map to m3u:Favorites.m3u8",
+                max_length=255,
+                null=True,
+            ),
+        ),
+    ]

vrobbler/apps/profiles/migrations/0035_userprofile_monthly_mopidy_playlist_pattern.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.30 on 2026-06-05 17:22
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("profiles", "0034_userprofile_favorites_mopidy_playlist"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="monthly_mopidy_playlist_pattern",
+            field=models.CharField(
+                blank=True,
+                help_text="Django date format pattern for monthly playlists (e.g. 'Y F')",
+                max_length=255,
+                null=True,
+            ),
+        ),
+    ]

vrobbler/apps/profiles/models.py

@@ -64,6 +64,16 @@ class UserProfile(TimeStampedModel):
     ntfy_url = models.CharField(max_length=255, **BNULL)
     ntfy_enabled = models.BooleanField(default=False)
 
+    mopidy_api_url = models.CharField(max_length=255, **BNULL)
+    favorites_mopidy_playlist = models.CharField(
+        max_length=255, **BNULL,
+        help_text="Playlist name (e.g. 'Favorites'). Will map to m3u:Favorites.m3u8",
+    )
+    monthly_mopidy_playlist_pattern = models.CharField(
+        max_length=255, **BNULL,
+        help_text="Django date format pattern for monthly playlists (e.g. 'Y F')",
+    )
+
     redirect_to_webpage = models.BooleanField(default=True)
 
     enable_public_widgets = models.BooleanField(default=False)

vrobbler/apps/scrobbles/admin.py

@@ -4,6 +4,7 @@ from scrobbles.models import (
     AudioScrobblerTSVImport,
     BGStatsImport,
     EBirdCSVImport,
+    FavoriteMedia,
     KoReaderImport,
     LastFmImport,
     RetroarchImport,
@@ -164,3 +165,28 @@ class ScrobbleAdmin(admin.ModelAdmin):
     def get_queryset(self, request):
         qs = super().get_queryset(request).exclude(timestamp__year=None)
         return qs
+
+
+@admin.register(FavoriteMedia)
+class FavoriteMediaAdmin(admin.ModelAdmin):
+    list_display = ("user", "media_type", "sent_to_mopidy", "created")
+    list_filter = ("media_type", "sent_to_mopidy", "user")
+    date_hierarchy = "created"
+    raw_id_fields = (
+        "video",
+        "track",
+        "podcast_episode",
+        "sport_event",
+        "book",
+        "video_game",
+        "board_game",
+        "geo_location",
+        "task",
+        "mood",
+        "brick_set",
+        "trail",
+        "beer",
+        "web_page",
+        "life_event",
+        "birding_location",
+    )

vrobbler/apps/scrobbles/context_processors.py

@@ -4,6 +4,26 @@ from django.utils import timezone
 from scrobbles.constants import EXCLUDE_FROM_NOW_PLAYING
 from scrobbles.models import Scrobble
 
+MONTH_COLORS = [
+    "#db7a7a",  # Jan
+    "#db847a",  # Feb
+    "#b0db7a",  # Mar
+    "#7adb82",  # Apr
+    "#7adbb3",  # May
+    "#7ab6db",  # Jun
+    "#7a8edb",  # Jul
+    "#977adb",  # Aug
+    "#c47adb",  # Sep
+    "#db7ac5",  # Oct
+    "#db7a90",  # Nov
+    "#db7a7a",  # Dec
+]
+
+
+def month_color(request):
+    from datetime import date
+    return {"month_color": MONTH_COLORS[(date.today().month - 1) % 12]}
+
 
 def now_playing(request):
     user = request.user

vrobbler/apps/scrobbles/dataclasses.py

@@ -57,38 +57,136 @@ class BaseLogData(JSONDataclass):
         if not self.notes:
             return ""
 
+        if isinstance(self.notes, dict):
+            lines = []
+            for ts, text in self.notes.items():
+                note_text = " ".join(text.strip().split())
+                lines.append(f"{ts}: {note_text}")
+            return separator.join(lines)
+
         if isinstance(self.notes, str):
             return html.escape(re.sub(r"\s*\[start:\d+\|end:\d+\]$", "", self.notes))
 
         if isinstance(self.notes, list):
             cleaned_notes = []
             for note in self.notes:
-                cleaned = html.escape(re.sub(r"\s*\[start:\d+\|end:\d+\]$", "", note))
-                cleaned_notes.append(cleaned)
+                if isinstance(note, dict):
+                    timestamp, note_text = next(iter(note.items()))
+                    note_text = " ".join(note_text.strip().split())
+                    cleaned_notes.append(f"{timestamp}: {note_text}")
+                elif isinstance(note, str):
+                    cleaned = html.escape(
+                        re.sub(r"\s*\[start:\d+\|end:\d+\]$", "", note)
+                    )
+                    cleaned_notes.append(cleaned)
             return separator.join(cleaned_notes)
 
         return ""
 
+    @staticmethod
+    def _format_timestamp(ts: str) -> str:
+        from datetime import datetime, timezone
+        import re
+
+        cleaned = ts.strip().strip("[]")
+        dt = None
+
+        if cleaned.isdigit():
+            try:
+                seconds = int(cleaned)
+                dt = datetime.fromtimestamp(seconds, tz=timezone.utc)
+            except (ValueError, OSError):
+                pass
+
+        if dt is None:
+            for fmt in [
+                "%Y-%m-%dT%H:%M:%S.%fZ",
+                "%Y-%m-%dT%H:%M:%SZ",
+                "%Y-%m-%dT%H:%M:%S.%f",
+                "%Y-%m-%dT%H:%M:%S",
+            ]:
+                try:
+                    dt = datetime.strptime(cleaned, fmt)
+                    break
+                except ValueError:
+                    continue
+
+        if dt is None:
+            m = re.match(
+                r"(\d{4}-\d{2}-\d{2})\s+\w{3}\s+(\d{2}:\d{2})", cleaned
+            )
+            if m:
+                try:
+                    dt = datetime.strptime(
+                        f"{m.group(1)} {m.group(2)}", "%Y-%m-%d %H:%M"
+                    )
+                except ValueError:
+                    pass
+
+        if dt is None:
+            try:
+                dt = datetime.fromisoformat(cleaned)
+            except ValueError:
+                pass
+
+        if dt:
+            return dt.strftime("%b %-d, %Y %-I:%M %p")
+        return ts
+
     def notes_as_html(self) -> str:
-        import html
+        import bleach
+        import markdown
         from django.utils.safestring import mark_safe
 
         if not self.notes:
             return ""
 
-        notes_list = []
-        if isinstance(self.notes, str):
-            notes_list = [self.notes]
-        elif isinstance(self.notes, list):
-            notes_list = self.notes
+        md = markdown.Markdown(extensions=["extra"])
+        allowed_tags = [
+            "p", "br", "strong", "em", "a", "ul", "ol", "li",
+            "code", "pre", "blockquote", "h1", "h2", "h3", "h4", "h5", "h6",
+            "hr", "img",
+        ]
 
-        html_notes = []
-        for note in notes_list:
-            for line in note.split("\n"):
+        note_items = []
+
+        if isinstance(self.notes, dict):
+            for ts, text in sorted(self.notes.items(), reverse=True):
+                note_items.append((ts, text.strip()))
+        elif isinstance(self.notes, str):
+            for line in self.notes.split("\n"):
                 if line.strip():
-                    escaped_line = html.escape(line)
-                    html_notes.append(f'<div class="sticky-note">{escaped_line}</div>')
-        return mark_safe("".join(html_notes))
+                    note_items.append((None, line.strip()))
+        elif isinstance(self.notes, list):
+            for note in self.notes:
+                if isinstance(note, dict):
+                    timestamp, note_text = next(iter(note.items()))
+                    note_items.append((timestamp, note_text.strip()))
+                elif isinstance(note, str):
+                    for line in note.split("\n"):
+                        if line.strip():
+                            note_items.append((None, line.strip()))
+
+        html_parts = []
+        for i, (ts, text) in enumerate(note_items):
+            if i > 0:
+                html_parts.append('<hr class="note-divider">')
+
+            ts_html = ""
+            if ts:
+                ts_html = f'<h5 class="note-timestamp">{self._format_timestamp(ts)}</h5>'
+
+            content_html = bleach.clean(
+                md.convert(text),
+                tags=allowed_tags,
+                strip=True,
+            )
+
+            html_parts.append(
+                f'<div class="note-item">{ts_html}<div class="note-content">{content_html}</div></div>'
+            )
+
+        return mark_safe("".join(html_parts))
 
 
 @dataclass

vrobbler/apps/scrobbles/export.py

@@ -1,8 +1,8 @@
 import csv
 import tempfile
-from scrobbles.models import Scrobble
 
 from django.db.models import Q
+from scrobbles.models import Scrobble
 
 
 def export_scrobbles(start_date=None, end_date=None, format="AS"):
@@ -50,7 +50,7 @@ def export_scrobbles(start_date=None, end_date=None, format="AS"):
             track = scrobble.track
             track_number = 0  # TODO Add track number
             track_rating = "S"  # TODO implement ratings?
-            track_artist = track.artist or track.album.album_artist
+            track_artist = track.artist or track.album.artist
             row = [
                 track_artist,
                 track.album.name,

vrobbler/apps/scrobbles/forms.py

@@ -1,3 +1,4 @@
+import json
 from dataclasses import fields
 from typing import Union, get_args, get_origin
 
@@ -89,7 +90,7 @@ def form_from_dataclass(dataclass):
 
     form_cls = type(f"{dataclass.__name__}Form", (forms.Form,), form_fields)
 
-    if "notes" in form_cls.base_fields:
+    if "notes" in form_cls.base_fields and "notes" not in override_fields:
         form_cls.base_fields["notes"] = forms.CharField(
             required=False,
             widget=forms.Textarea(attrs={"rows": 4}),
@@ -101,3 +102,54 @@ def form_from_dataclass(dataclass):
 
         form_cls.clean_notes = clean_notes
     return form_cls
+
+
+class NotesDictWidget(forms.Widget):
+    template_name = "tasks/task_notes_widget.html"
+
+    class Media:
+        js = ("tasks/task_notes.js",)
+
+    def value_from_datadict(self, data, files, name):
+        timestamps = data.getlist(f"{name}_timestamps")
+        if timestamps:
+            contents = data.getlist(f"{name}_contents")
+            result = {}
+            for i, ts in enumerate(timestamps):
+                if i < len(contents) and ts:
+                    result[ts] = contents[i]
+            return result if result else ""
+        return data.get(name, "")
+
+    def get_context(self, name, value, attrs):
+        context = super().get_context(name, value, attrs)
+        notes = {}
+        if value:
+            if isinstance(value, str):
+                try:
+                    notes = json.loads(value)
+                except (json.JSONDecodeError, TypeError):
+                    notes = {}
+            elif isinstance(value, dict):
+                notes = value
+        context["widget"]["notes"] = notes
+        return context
+
+
+class NotesDictField(forms.Field):
+    widget = NotesDictWidget
+
+    def clean(self, value):
+        if not value:
+            return {}
+
+        if isinstance(value, str):
+            if value.strip():
+                from scrobbles.utils import make_note_timestamp
+                return {make_note_timestamp(): value.strip()}
+            return {}
+
+        if isinstance(value, dict):
+            return value
+
+        return {}

vrobbler/apps/scrobbles/importers/scale.py

@@ -5,6 +5,7 @@ from datetime import datetime, timedelta
 from django.contrib.auth import get_user_model
 
 from scrobbles.models import Scrobble
+from scrobbles.notifications import ScrobbleNtfyNotification
 from tasks.models import Task
 
 logger = logging.getLogger(__name__)
@@ -85,6 +86,11 @@ def import_scale_csv(file_path, user_id):
 
             log_dict["unit_type"] = user.profile.weigh_in_units
 
+            weight_val = log_dict.get("weight")
+            if weight_val is not None:
+                unit = "kg" if user.profile.weigh_in_units == "metric" else "lbs"
+                log_dict["title"] = f"{weight_val} {unit}"
+
             existing = Scrobble.objects.filter(
                 timestamp=start,
                 task=weigh_in,
@@ -110,4 +116,6 @@ def import_scale_csv(file_path, user_id):
 
     created = Scrobble.objects.bulk_create(new_scrobbles)
     logger.info(f"Created {len(created)} weigh-in scrobbles")
+    for scrobble in created:
+        ScrobbleNtfyNotification(scrobble).send()
     return created

vrobbler/apps/scrobbles/importers/trail_gpx.py

@@ -12,6 +12,7 @@ from django.core.files import File
 
 from locations.models import GeoLocation
 from scrobbles.models import Scrobble
+from scrobbles.notifications import ScrobbleNtfyNotification
 from trails.models import Trail, TrailLogData
 
 logger = logging.getLogger(__name__)
@@ -328,4 +329,6 @@ def import_trail_gpx(file_path, user_id, original_filename=None):
 
     created = Scrobble.objects.bulk_create(new_scrobbles)
     logger.info(f"Created {len(created)} trail scrobbles")
+    for scrobble in created:
+        ScrobbleNtfyNotification(scrobble).send()
     return created

vrobbler/apps/scrobbles/importers/webdav.py

@@ -22,7 +22,10 @@ DEFAULT_SCALE_PATH = "var/scale/"
 
 
 def import_from_webdav_for_all_users(
-    restart=False, update_retroarch_hash=False, update_koreader_etag=False
+    restart=False,
+    update_retroarch_hash=False,
+    update_koreader_etag=False,
+    include_processed=False,
 ):
     """Iterate all WebDAV-enabled users, scanning each media-type directory."""
     webdav_enabled_user_ids = UserProfile.objects.filter(
@@ -31,6 +34,12 @@ def import_from_webdav_for_all_users(
         webdav_pass__isnull=False,
         webdav_auto_import=True,
     ).values_list("user_id", flat=True)
+    if include_processed:
+        logger.warning(
+            "Re-importing previously-processed files from processed/ subdirectories "
+            "— this may create duplicate scrobbles."
+        )
+
     logger.info(f"Start import of {webdav_enabled_user_ids.count()} webdav accounts")
 
     ko_count = 0
@@ -49,15 +58,24 @@ def import_from_webdav_for_all_users(
             client, user_id, restart, update_etag_only=update_koreader_etag
         )
         logger.info("Scanning WebDAV gpx for user %s", user_id)
-        gpx_count += scan_webdav_for_gpx(client, user_id)
+        gpx_count += scan_webdav_for_gpx(
+            client, user_id, include_processed=include_processed
+        )
         logger.info("Scanning WebDAV retroarch for user %s", user_id)
         retro_count += scan_webdav_for_retroarch(
-            client, user_id, update_hash_only=update_retroarch_hash
+            client,
+            user_id,
+            update_hash_only=update_retroarch_hash,
+            include_processed=include_processed,
         )
         logger.info("Scanning WebDAV bgstats for user %s", user_id)
-        bgstats_count += scan_webdav_for_bgstats(client, user_id)
+        bgstats_count += scan_webdav_for_bgstats(
+            client, user_id, include_processed=include_processed
+        )
         logger.info("Scanning WebDAV ebird for user %s", user_id)
-        ebird_count += scan_webdav_for_ebird(client, user_id)
+        ebird_count += scan_webdav_for_ebird(
+            client, user_id, include_processed=include_processed
+        )
         logger.info("Scanning WebDAV scale for user %s", user_id)
         scale_count += scan_webdav_for_scale(client, user_id)
 
@@ -200,7 +218,7 @@ def scan_webdav_for_koreader(
     return 1
 
 
-def scan_webdav_for_gpx(webdav_client, user_id):
+def scan_webdav_for_gpx(webdav_client, user_id, include_processed=False):
     gpx_path = DEFAULT_GPX_PATH  # TODO allow this to be configured in user settings
     try:
         webdav_client.info(DEFAULT_GPX_PATH)
@@ -259,10 +277,47 @@ def scan_webdav_for_gpx(webdav_client, user_id):
         finally:
             os.unlink(tmp.name)
 
+    if include_processed:
+        try:
+            processed_files = webdav_client.list(processed_dir)
+        except Exception as e:
+            logger.warning(
+                "Could not list var/gpx/processed/",
+                extra={"user_id": user_id, "error": str(e)},
+            )
+            return new_imports
+
+        for fname in processed_files:
+            fname = os.path.basename(fname)
+            if not fname.lower().endswith(gpx_extensions):
+                continue
+
+            remote_path = f"{processed_dir}{fname}"
+            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=fname)
+            try:
+                webdav_client.download_sync(
+                    remote_path=remote_path, local_path=tmp.name
+                )
+                imp = TrailGPXImport.objects.create(
+                    user_id=user_id,
+                    original_filename=fname,
+                )
+                with open(tmp.name, "rb") as f:
+                    imp.gpx_file.save(fname, f, save=True)
+
+                process_trail_gpx_import.delay(imp.id)
+                new_imports += 1
+            except Exception as e:
+                logger.error(f"Failed to import processed GPX file {fname}: {e}")
+            finally:
+                os.unlink(tmp.name)
+
     return new_imports
 
 
-def scan_webdav_for_retroarch(webdav_client, user_id, update_hash_only=False):
+def scan_webdav_for_retroarch(
+    webdav_client, user_id, update_hash_only=False, include_processed=False
+):
     """Check for new .lrtl files on WebDAV, download+import if changed.
 
     Uses ETags from a single PROPFIND to detect changes without downloading
@@ -271,16 +326,24 @@ def scan_webdav_for_retroarch(webdav_client, user_id, update_hash_only=False):
     When *update_hash_only* is True, mismatched hashes update the last import's
     stored hash without re-downloading — useful when migrating to a new hash
     scheme to avoid a one-time re-import.
+
+    When *include_processed* is True, also imports files from the processed/
+    subdirectory.  These are sorted chronologically by their YYYYMMDDHHMM-
+    timestamp prefix so that the importer always sees the earliest snapshot
+    first, which is critical for correct incremental scrobbling since
+    retroarch overwrites the same .lrtl filename.
     """
     import hashlib
     import shutil
+    import re
     import zipfile
     from datetime import datetime
 
     from scrobbles.models import RetroarchImport
     from scrobbles.tasks import process_retroarch_import
 
-    retroarch_path = DEFAULT_RETROARCH_PATH + "playlogs/"
+    retroarch_path = DEFAULT_RETROARCH_PATH
+    processed_dir = f"{retroarch_path}processed/"
     try:
         webdav_client.info(retroarch_path)
     except:
@@ -288,7 +351,13 @@ def scan_webdav_for_retroarch(webdav_client, user_id, update_hash_only=False):
         return 0
 
     try:
-        files = webdav_client.list(retroarch_path, get_info=True)
+        webdav_client.mkdir(processed_dir, recursive=True)
+    except Exception:
+        pass
+
+    # Collect files from root directory
+    try:
+        root_files = webdav_client.list(retroarch_path, get_info=True)
     except Exception as e:
         logger.warning(
             "Could not list var/retroarch/",
@@ -296,14 +365,51 @@ def scan_webdav_for_retroarch(webdav_client, user_id, update_hash_only=False):
         )
         return 0
 
-    lrtl_files = sorted(
-        [f for f in files if (f.get("name") or "").lower().endswith(".lrtl")],
-        key=lambda x: (x.get("name") or ""),
-    )
+    # Extract basename from path since the webdav adapter returns name=None
+    for f in root_files:
+        if f.get("path") and not f.get("name"):
+            f["name"] = os.path.basename(f["path"])
+
+    lrtl_files = [
+        f for f in root_files
+        if (f.get("name") or "").lower().endswith(".lrtl")
+    ]
+
+    # Optionally include historical files from processed/
+    if include_processed:
+        try:
+            processed_files = webdav_client.list(processed_dir, get_info=True)
+        except Exception as e:
+            logger.warning(
+                "Could not list var/retroarch/processed/",
+                extra={"user_id": user_id, "error": str(e)},
+            )
+        else:
+            for f in processed_files:
+                if f.get("path") and not f.get("name"):
+                    f["name"] = os.path.basename(f["path"])
+            lrtl_files.extend([
+                f for f in processed_files
+                if (f.get("name") or "").lower().endswith(".lrtl")
+            ])
+
     if not lrtl_files:
         logger.info("No .lrtl files found on webdav", extra={"user_id": user_id})
         return 0
 
+    # Sort chronologically: processed files (timestamp prefixed) first,
+    # current root files last.
+    ts_pattern = re.compile(r"^(\d{12})-")
+    def sort_key(f):
+        name = f.get("name") or ""
+        m = ts_pattern.match(name)
+        if m:
+            return m.group(1)
+        # Root files (no timestamp) go after all historical snapshots
+        return "999999999999"
+
+    lrtl_files.sort(key=sort_key)
+
     # Don't queue if one is still being processed
     if RetroarchImport.objects.filter(
         user_id=user_id, processed_finished__isnull=True
@@ -321,7 +427,6 @@ def scan_webdav_for_retroarch(webdav_client, user_id, update_hash_only=False):
         hasher.update((f.get("etag") or f.get("modified") or "").encode())
     content_hash = hasher.hexdigest()
 
-    # Skip if the last completed import already has this hash
     last_import = (
         RetroarchImport.objects.filter(
             user_id=user_id, processed_finished__isnull=False
@@ -329,7 +434,9 @@ def scan_webdav_for_retroarch(webdav_client, user_id, update_hash_only=False):
         .order_by("-processed_finished")
         .first()
     )
-    if last_import and last_import.files_hash == content_hash:
+
+    # Skip unchanged root files only, never skip when re-processing history
+    if not include_processed and last_import and last_import.files_hash == content_hash:
         logger.info(
             "Retroarch lrtl files unchanged for user, skipping",
             extra={"user_id": user_id},
@@ -350,15 +457,32 @@ def scan_webdav_for_retroarch(webdav_client, user_id, update_hash_only=False):
     download_dir = tempfile.mkdtemp()
     try:
         downloaded = []
+        imported_filenames = []
         for f in lrtl_files:
             basename = f.get("name")
+            # Determine source directory: processed files already live under processed/
+            is_processed = ts_pattern.match(basename)
+            source_dir = processed_dir if is_processed else retroarch_path
+
+            remote_path = f"{source_dir}{basename}"
             dst = os.path.join(download_dir, basename)
             try:
                 webdav_client.download_sync(
-                    remote_path=f.get("path"),
+                    remote_path=remote_path,
                     local_path=dst,
                 )
                 downloaded.append(basename)
+
+                if is_processed:
+                    imported_filenames.append(basename)
+                else:
+                    ts = datetime.now().strftime("%Y%m%d%H%M%S")
+                    processed_name = f"{ts}-{basename}"
+                    imported_filenames.append(processed_name)
+                    webdav_client.move(
+                        remote_path,
+                        f"{processed_dir}{processed_name}",
+                    )
             except Exception as e:
                 logger.error("Failed to download retroarch %s: %s", basename, e)
 
@@ -375,7 +499,7 @@ def scan_webdav_for_retroarch(webdav_client, user_id, update_hash_only=False):
 
         imp = RetroarchImport.objects.create(
             user_id=user_id,
-            original_filename=f"batch-{len(downloaded)}-files",
+            original_filename=", ".join(imported_filenames),
             files_hash=content_hash,
         )
         with open(zip_path, "rb") as f:
@@ -392,8 +516,12 @@ def scan_webdav_for_retroarch(webdav_client, user_id, update_hash_only=False):
         shutil.rmtree(download_dir, ignore_errors=True)
 
 
-def scan_webdav_for_bgstats(webdav_client, user_id):
-    """Download .bgsplay files from WebDAV and queue imports for new files."""
+def scan_webdav_for_bgstats(webdav_client, user_id, include_processed=False):
+    """Download .bgsplay files from WebDAV and queue imports for new files.
+
+    After importing, files are moved to var/bgstats/processed/ so they are
+    not re-imported on subsequent scans unless *include_processed* is True.
+    """
     from scrobbles.models import BGStatsImport
     from scrobbles.tasks import process_bgstats_import
 
@@ -413,6 +541,12 @@ def scan_webdav_for_bgstats(webdav_client, user_id):
         )
         return 0
 
+    processed_dir = f"{bgstats_path}processed/"
+    try:
+        webdav_client.mkdir(processed_dir, recursive=True)
+    except Exception:
+        pass
+
     new_imports = 0
     already_imported = set(
         BGStatsImport.objects.filter(user_id=user_id).values_list(
@@ -424,6 +558,8 @@ def scan_webdav_for_bgstats(webdav_client, user_id):
         fname = os.path.basename(fname)
         if not fname.lower().endswith(".bgsplay"):
             continue
+        if fname == "processed":
+            continue
         if fname in already_imported:
             logger.debug(f"Skipping already-imported {fname}")
             continue
@@ -431,7 +567,7 @@ def scan_webdav_for_bgstats(webdav_client, user_id):
         tmp = tempfile.NamedTemporaryFile(delete=False, suffix=fname)
         try:
             webdav_client.download_sync(
-                remote_path=f"{bgstats_path}/{fname}", local_path=tmp.name
+                remote_path=f"{bgstats_path}{fname}", local_path=tmp.name
             )
             imp = BGStatsImport.objects.create(
                 user_id=user_id,
@@ -439,6 +575,14 @@ def scan_webdav_for_bgstats(webdav_client, user_id):
             )
             with open(tmp.name, "rb") as f:
                 imp.bgsplay_file.save(fname, f, save=True)
+
+            stem, ext = os.path.splitext(fname)
+            ts = datetime.now().strftime("%Y%m%dT%H%M%S")
+            webdav_client.move(
+                f"{bgstats_path}{fname}",
+                f"{processed_dir}{stem}_{ts}{ext}",
+            )
+
             process_bgstats_import.delay(imp.id)
             new_imports += 1
         except Exception as e:
@@ -446,11 +590,48 @@ def scan_webdav_for_bgstats(webdav_client, user_id):
         finally:
             os.unlink(tmp.name)
 
+    if include_processed:
+        try:
+            processed_files = webdav_client.list(processed_dir)
+        except Exception as e:
+            logger.warning(
+                "Could not list var/bgstats/processed/",
+                extra={"user_id": user_id, "error": str(e)},
+            )
+            return new_imports
+
+        for fname in processed_files:
+            fname = os.path.basename(fname)
+            if not fname.lower().endswith(".bgsplay"):
+                continue
+
+            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=fname)
+            try:
+                webdav_client.download_sync(
+                    remote_path=f"{processed_dir}{fname}", local_path=tmp.name
+                )
+                imp = BGStatsImport.objects.create(
+                    user_id=user_id,
+                    original_filename=fname,
+                )
+                with open(tmp.name, "rb") as f:
+                    imp.bgsplay_file.save(fname, f, save=True)
+                process_bgstats_import.delay(imp.id)
+                new_imports += 1
+            except Exception as e:
+                logger.error(f"Failed to import processed BG Stats file {fname}: {e}")
+            finally:
+                os.unlink(tmp.name)
+
     return new_imports
 
 
-def scan_webdav_for_ebird(webdav_client, user_id):
-    """Download .csv files from WebDAV var/ebird/ and queue imports for new files."""
+def scan_webdav_for_ebird(webdav_client, user_id, include_processed=False):
+    """Download .csv files from WebDAV var/ebird/ and queue imports for new files.
+
+    After importing, files are moved to var/ebird/processed/ so they are
+    not re-imported on subsequent scans unless *include_processed* is True.
+    """
     from scrobbles.models import EBirdCSVImport
     from scrobbles.tasks import process_ebird_csv_import
 
@@ -470,6 +651,12 @@ def scan_webdav_for_ebird(webdav_client, user_id):
         )
         return 0
 
+    processed_dir = f"{ebird_path}processed/"
+    try:
+        webdav_client.mkdir(processed_dir, recursive=True)
+    except Exception:
+        pass
+
     new_imports = 0
     already_imported = set(
         EBirdCSVImport.objects.filter(user_id=user_id).values_list(
@@ -481,6 +668,8 @@ def scan_webdav_for_ebird(webdav_client, user_id):
         fname = os.path.basename(fname)
         if not fname.lower().endswith(".csv"):
             continue
+        if fname == "processed":
+            continue
         if fname in already_imported:
             logger.debug(f"Skipping already-imported {fname}")
             continue
@@ -488,7 +677,7 @@ def scan_webdav_for_ebird(webdav_client, user_id):
         tmp = tempfile.NamedTemporaryFile(delete=False, suffix=fname)
         try:
             webdav_client.download_sync(
-                remote_path=f"{ebird_path}/{fname}", local_path=tmp.name
+                remote_path=f"{ebird_path}{fname}", local_path=tmp.name
             )
             imp = EBirdCSVImport.objects.create(
                 user_id=user_id,
@@ -496,6 +685,14 @@ def scan_webdav_for_ebird(webdav_client, user_id):
             )
             with open(tmp.name, "rb") as f:
                 imp.csv_file.save(fname, f, save=True)
+
+            stem, ext = os.path.splitext(fname)
+            ts = datetime.now().strftime("%Y%m%dT%H%M%S")
+            webdav_client.move(
+                f"{ebird_path}{fname}",
+                f"{processed_dir}{stem}_{ts}{ext}",
+            )
+
             process_ebird_csv_import.delay(imp.id)
             new_imports += 1
         except Exception as e:
@@ -503,11 +700,49 @@ def scan_webdav_for_ebird(webdav_client, user_id):
         finally:
             os.unlink(tmp.name)
 
+    if include_processed:
+        try:
+            processed_files = webdav_client.list(processed_dir)
+        except Exception as e:
+            logger.warning(
+                "Could not list var/ebird/processed/",
+                extra={"user_id": user_id, "error": str(e)},
+            )
+            return new_imports
+
+        for fname in processed_files:
+            fname = os.path.basename(fname)
+            if not fname.lower().endswith(".csv"):
+                continue
+
+            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=fname)
+            try:
+                webdav_client.download_sync(
+                    remote_path=f"{processed_dir}{fname}", local_path=tmp.name
+                )
+                imp = EBirdCSVImport.objects.create(
+                    user_id=user_id,
+                    original_filename=fname,
+                )
+                with open(tmp.name, "rb") as f:
+                    imp.csv_file.save(fname, f, save=True)
+                process_ebird_csv_import.delay(imp.id)
+                new_imports += 1
+            except Exception as e:
+                logger.error(f"Failed to import processed eBird CSV file {fname}: {e}")
+            finally:
+                os.unlink(tmp.name)
+
     return new_imports
 
 
 def scan_webdav_for_scale(webdav_client, user_id):
-    """Download .csv files from WebDAV var/scale/ and queue imports for new files."""
+    """Download .csv files from WebDAV var/scale/ and queue imports for new files.
+
+    Because the scale CSV always has the same filename but grows by appending
+    rows, we detect changes by downloading the file and comparing its content
+    hash against the last completed import, rather than checking the filename.
+    """
     from scrobbles.models import ScaleCSVImport
     from scrobbles.tasks import process_scale_csv_import
 
@@ -530,28 +765,41 @@ def scan_webdav_for_scale(webdav_client, user_id):
         return 0
 
     new_imports = 0
-    already_imported = set(
-        ScaleCSVImport.objects.filter(user_id=user_id).values_list(
-            "original_filename", flat=True
-        )
-    )
 
     for fname in files:
         fname = os.path.basename(fname)
         if not fname.lower().endswith(".csv"):
             continue
-        if fname in already_imported:
-            logger.debug(f"Skipping already-imported {fname}")
-            continue
 
         tmp = tempfile.NamedTemporaryFile(delete=False, suffix=fname)
         try:
             webdav_client.download_sync(
                 remote_path=f"{scale_path}/{fname}", local_path=tmp.name
             )
+
+            new_hash = get_file_md5_hash(tmp.name)
+
+            last_import = (
+                ScaleCSVImport.objects.filter(
+                    user_id=user_id,
+                    original_filename=fname,
+                    processed_finished__isnull=False,
+                )
+                .order_by("-processed_finished")
+                .first()
+            )
+            if last_import and last_import.file_hash == new_hash:
+                logger.debug(
+                    "Scale CSV %s unchanged (hash match), skipping",
+                    fname,
+                    extra={"user_id": user_id, "hash": new_hash},
+                )
+                continue
+
             imp = ScaleCSVImport.objects.create(
                 user_id=user_id,
                 original_filename=fname,
+                file_hash=new_hash,
             )
             with open(tmp.name, "rb") as f:
                 imp.csv_file.save(fname, f, save=True)

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

@@ -1,9 +1,7 @@
 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,
+    convert_tasks_notes_list_to_dict,
 )
 
 
@@ -21,7 +19,5 @@ class Command(BaseCommand):
             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_tasks_notes_list_to_dict(commit)
         convert_old_boardgame_log_to_new(commit)

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

@@ -1,4 +1,5 @@
 from django.core.management.base import BaseCommand
+
 from vrobbler.apps.scrobbles.importers import webdav
 
 
@@ -21,6 +22,12 @@ class Command(BaseCommand):
             help="Store current WebDAV ETag on last KoReader import "
             "without re-importing (migration helper)",
         )
+        parser.add_argument(
+            "--include-processed",
+            action="store_true",
+            help="Also import files already moved to processed/ subdirectories "
+            "(may produce duplicate scrobbles; use with care on production)",
+        )
 
     def handle(self, *args, **options):
         restart = False
@@ -28,8 +35,10 @@ class Command(BaseCommand):
             restart = True
         update_hash = options.get("update_retroarch_hash", False)
         update_etag = options.get("update_koreader_etag", False)
+        include_processed = options.get("include_processed", False)
         webdav.import_from_webdav_for_all_users(
             restart=restart,
             update_retroarch_hash=update_hash,
             update_koreader_etag=update_etag,
+            include_processed=include_processed,
         )

vrobbler/apps/scrobbles/migrations/0088_scalecsvimport_file_hash.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.29 on 2026-05-28
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("scrobbles", "0087_koreaderimport_webdav_etag"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="scalecsvimport",
+            name="file_hash",
+            field=models.CharField(blank=True, max_length=32, null=True),
+        ),
+    ]

vrobbler/apps/scrobbles/migrations/0089_favoritemedia.py

@@ -0,0 +1,287 @@
+# Generated by Django 4.2.30 on 2026-06-05 14:55
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("boardgames", "0015_alter_boardgame_genre"),
+        ("trails", "0009_trail_route_waypoint"),
+        ("moods", "0008_alter_mood_genre"),
+        ("birds", "0002_birdingcsvimport"),
+        ("bricksets", "0005_alter_brickset_genre"),
+        ("music", "0036_artist_similar_artists"),
+        ("puzzles", "0006_alter_puzzle_genre"),
+        ("videogames", "0015_alter_videogame_genre"),
+        ("lifeevents", "0005_alter_lifeevent_genre"),
+        ("beers", "0008_alter_beer_genre"),
+        ("foods", "0007_alter_food_genre"),
+        ("tasks", "0007_alter_task_genre"),
+        ("books", "0036_alter_book_genre_alter_paper_genre"),
+        ("videos", "0030_alter_channel_genre_alter_series_genre_and_more"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("podcasts", "0020_alter_podcast_genre_alter_podcastepisode_genre"),
+        ("webpages", "0009_alter_webpage_genre"),
+        ("sports", "0018_alter_sportevent_genre"),
+        ("locations", "0010_clean_start"),
+        ("scrobbles", "0088_scalecsvimport_file_hash"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="FavoriteMedia",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "created",
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name="created"
+                    ),
+                ),
+                (
+                    "modified",
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name="modified"
+                    ),
+                ),
+                (
+                    "uuid",
+                    models.UUIDField(
+                        blank=True, default=uuid.uuid4, editable=False, null=True
+                    ),
+                ),
+                (
+                    "media_type",
+                    models.CharField(
+                        choices=[
+                            ("Video", "Video"),
+                            ("Track", "Track"),
+                            ("PodcastEpisode", "Podcast episode"),
+                            ("SportEvent", "Sport event"),
+                            ("Book", "Book"),
+                            ("Paper", "Paper"),
+                            ("VideoGame", "Video game"),
+                            ("BoardGame", "Board game"),
+                            ("GeoLocation", "GeoLocation"),
+                            ("Trail", "Trail"),
+                            ("Beer", "Beer"),
+                            ("Puzzle", "Puzzle"),
+                            ("Food", "Food"),
+                            ("Task", "Task"),
+                            ("WebPage", "Web Page"),
+                            ("LifeEvent", "Life event"),
+                            ("Mood", "Mood"),
+                            ("BrickSet", "Brick set"),
+                            ("Channel", "Channel"),
+                            ("BirdingLocation", "Birding location"),
+                        ],
+                        max_length=20,
+                    ),
+                ),
+                ("sent_to_mopidy", models.BooleanField(default=False)),
+                (
+                    "beer",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="beers.beer",
+                    ),
+                ),
+                (
+                    "birding_location",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="birds.birdinglocation",
+                    ),
+                ),
+                (
+                    "board_game",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="boardgames.boardgame",
+                    ),
+                ),
+                (
+                    "book",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="books.book",
+                    ),
+                ),
+                (
+                    "brick_set",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="bricksets.brickset",
+                    ),
+                ),
+                (
+                    "channel",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="videos.channel",
+                    ),
+                ),
+                (
+                    "food",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="foods.food",
+                    ),
+                ),
+                (
+                    "geo_location",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="locations.geolocation",
+                    ),
+                ),
+                (
+                    "life_event",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="lifeevents.lifeevent",
+                    ),
+                ),
+                (
+                    "mood",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="moods.mood",
+                    ),
+                ),
+                (
+                    "paper",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="books.paper",
+                    ),
+                ),
+                (
+                    "podcast_episode",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="podcasts.podcastepisode",
+                    ),
+                ),
+                (
+                    "puzzle",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="puzzles.puzzle",
+                    ),
+                ),
+                (
+                    "sport_event",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="sports.sportevent",
+                    ),
+                ),
+                (
+                    "task",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="tasks.task",
+                    ),
+                ),
+                (
+                    "track",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="music.track",
+                    ),
+                ),
+                (
+                    "trail",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="trails.trail",
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+                (
+                    "video",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="videos.video",
+                    ),
+                ),
+                (
+                    "video_game",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="videogames.videogame",
+                    ),
+                ),
+                (
+                    "web_page",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="webpages.webpage",
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["-created"],
+            },
+        ),
+    ]

vrobbler/apps/scrobbles/models.py

@@ -287,6 +287,7 @@ class ScaleCSVImport(BaseFileImportMixin):
 
     csv_file = models.FileField(upload_to=get_path, **BNULL)
     original_filename = models.CharField(max_length=255, **BNULL)
+    file_hash = models.CharField(max_length=32, **BNULL)
 
     def process(self, force=False):
         from scrobbles.importers.scale import import_scale_csv
@@ -563,7 +564,7 @@ class ScrobbleQuerySet(models.QuerySet):
         return self.select_related("user").prefetch_related(
             "video",
             "track",
-            "track__artist",
+            "track__artist_fk",
             "podcast_episode",
             "podcast_episode__podcast",
             "sport_event",
@@ -1528,7 +1529,12 @@ class Scrobble(TimeStampedModel):
         scrobble_data: dict,
     ) -> "Scrobble":
         scrobble = cls.objects.create(**scrobble_data)
-        ScrobbleNtfyNotification(scrobble).send()
+        if not (
+            scrobble.media_type == cls.MediaType.GEO_LOCATION
+            and scrobble.media_obj
+            and not scrobble.media_obj.title
+        ):
+            ScrobbleNtfyNotification(scrobble).send()
         return scrobble
 
     def stop(self, timestamp=None, force_finish=False) -> None:
@@ -1713,3 +1719,131 @@ class Scrobble(TimeStampedModel):
 
         if commit and "pages_read" in self.log:
             self.save(update_fields=["log"])
+
+
+class FavoriteMedia(TimeStampedModel):
+
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+    user = models.ForeignKey(User, on_delete=models.CASCADE)
+
+    video = models.ForeignKey(Video, on_delete=models.CASCADE, **BNULL)
+    channel = models.ForeignKey("videos.Channel", on_delete=models.CASCADE, **BNULL)
+    track = models.ForeignKey(Track, on_delete=models.CASCADE, **BNULL)
+    podcast_episode = models.ForeignKey(
+        PodcastEpisode, on_delete=models.CASCADE, **BNULL
+    )
+    sport_event = models.ForeignKey(SportEvent, on_delete=models.CASCADE, **BNULL)
+    book = models.ForeignKey(Book, on_delete=models.CASCADE, **BNULL)
+    paper = models.ForeignKey(Paper, on_delete=models.CASCADE, **BNULL)
+    video_game = models.ForeignKey(VideoGame, on_delete=models.CASCADE, **BNULL)
+    board_game = models.ForeignKey(BoardGame, on_delete=models.CASCADE, **BNULL)
+    geo_location = models.ForeignKey(GeoLocation, on_delete=models.CASCADE, **BNULL)
+    beer = models.ForeignKey(Beer, on_delete=models.CASCADE, **BNULL)
+    puzzle = models.ForeignKey(Puzzle, on_delete=models.CASCADE, **BNULL)
+    food = models.ForeignKey(Food, on_delete=models.CASCADE, **BNULL)
+    trail = models.ForeignKey(Trail, on_delete=models.CASCADE, **BNULL)
+    task = models.ForeignKey(Task, on_delete=models.CASCADE, **BNULL)
+    web_page = models.ForeignKey(WebPage, on_delete=models.CASCADE, **BNULL)
+    life_event = models.ForeignKey(LifeEvent, on_delete=models.CASCADE, **BNULL)
+    mood = models.ForeignKey(Mood, on_delete=models.CASCADE, **BNULL)
+    brick_set = models.ForeignKey(BrickSet, on_delete=models.CASCADE, **BNULL)
+    birding_location = models.ForeignKey(
+        BirdingLocation, on_delete=models.CASCADE, **BNULL
+    )
+    media_type = models.CharField(
+        max_length=20, choices=Scrobble.MediaType.choices
+    )
+    sent_to_mopidy = models.BooleanField(default=False)
+
+    class Meta:
+        ordering = ["-created"]
+
+    def __str__(self):
+        return f"{self.user} favorites {self.media_obj}"
+
+    @property
+    def media_obj(self):
+        media_obj = None
+        if self.video:
+            media_obj = self.video
+        if self.track:
+            media_obj = self.track
+        if self.podcast_episode:
+            media_obj = self.podcast_episode
+        if self.sport_event:
+            media_obj = self.sport_event
+        if self.book:
+            media_obj = self.book
+        if self.video_game:
+            media_obj = self.video_game
+        if self.board_game:
+            media_obj = self.board_game
+        if self.geo_location:
+            media_obj = self.geo_location
+        if self.web_page:
+            media_obj = self.web_page
+        if self.life_event:
+            media_obj = self.life_event
+        if self.mood:
+            media_obj = self.mood
+        if self.brick_set:
+            media_obj = self.brick_set
+        if self.trail:
+            media_obj = self.trail
+        if self.beer:
+            media_obj = self.beer
+        if self.puzzle:
+            media_obj = self.puzzle
+        if self.task:
+            media_obj = self.task
+        if self.food:
+            media_obj = self.food
+        if self.channel:
+            media_obj = self.channel
+        if self.birding_location:
+            media_obj = self.birding_location
+        return media_obj
+
+    @classmethod
+    def toggle(cls, media_obj, user):
+        media_type = media_obj.__class__.__name__
+        if media_type not in Scrobble.MediaType.list():
+            raise ValueError(f"Unknown media type: {media_type}")
+
+        fk_map = {
+            "Video": "video",
+            "Channel": "channel",
+            "Track": "track",
+            "PodcastEpisode": "podcast_episode",
+            "SportEvent": "sport_event",
+            "Book": "book",
+            "Paper": "paper",
+            "VideoGame": "video_game",
+            "BoardGame": "board_game",
+            "GeoLocation": "geo_location",
+            "Beer": "beer",
+            "Puzzle": "puzzle",
+            "Food": "food",
+            "Trail": "trail",
+            "Task": "task",
+            "WebPage": "web_page",
+            "LifeEvent": "life_event",
+            "Mood": "mood",
+            "BrickSet": "brick_set",
+            "BirdingLocation": "birding_location",
+        }
+
+        fk = fk_map.get(media_type)
+        if not fk:
+            raise ValueError(f"No FK mapping for media type: {media_type}")
+
+        existing = cls.objects.filter(user=user, **{fk: media_obj}).first()
+        if existing:
+            existing.delete()
+            return None
+
+        return cls.objects.create(
+            user=user,
+            media_type=media_type,
+            **{fk: media_obj},
+        )

vrobbler/apps/scrobbles/notifications.py

@@ -83,7 +83,7 @@ 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.click_url = self.url_tmpl.format(path=reverse("moods:checkin"))
         self.title = "Mood Check-in!"
 
     def send(self):

vrobbler/apps/scrobbles/scrobblers.py

@@ -35,6 +35,7 @@ from scrobbles.notifications import ScrobbleNtfyNotification
 from scrobbles.utils import (
     convert_to_seconds,
     extract_domain,
+    make_note_timestamp,
     next_url_if_exists,
     remove_last_part,
 )
@@ -450,11 +451,11 @@ 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
+        comments = None
         if "comments" in play_dict.keys():
             for line in play_dict.get("comments", "").split("\n"):
                 if "Learning to play" in line:
@@ -469,7 +470,7 @@ def email_scrobble_board_game(
                     except IndexError:
                         second = 0
 
-            log_data["notes"] = [play_dict.get("comments")]
+            comments = play_dict.get("comments")
         log_data["expansion_ids"] = []
         try:
             base_game = base_games[play_dict.get("gameRefId")]
@@ -527,6 +528,9 @@ def email_scrobble_board_game(
             duration_seconds = base_game.run_time_seconds
         stop_timestamp = timestamp + timedelta(seconds=duration_seconds)
 
+        if comments:
+            log_data["notes"] = {make_note_timestamp(stop_timestamp): comments}
+
         logger.info(f"Creating scrobble for {base_game} at {timestamp}")
         log_data["raw_data"] = bgstat_data
         scrobble_dict = {
@@ -558,7 +562,6 @@ def email_scrobble_board_game(
         scrobble.played_to_completion = True
         scrobble.save()
         scrobbles_created.append(scrobble)
-        ScrobbleNtfyNotification(scrobble).send()
 
     return scrobbles_created
 
@@ -685,9 +688,10 @@ def todoist_scrobble_update_task(
         )
         return
 
+    timestamp = todoist_note.get("posted_at") or make_note_timestamp()
     if not scrobble.log.get("notes"):
-        scrobble.log["notes"] = []
-    scrobble.log["notes"].append(todoist_note.get("notes"))
+        scrobble.log["notes"] = {}
+    scrobble.log["notes"][timestamp] = todoist_note.get("notes")
     scrobble.save(update_fields=["log"])
     logger.info(
         "[todoist_scrobble_update_task] todoist note added",
@@ -757,7 +761,10 @@ def todoist_scrobble_task(
 
     todoist_task["title"] = todoist_task.pop("description")
     todoist_task["description"] = todoist_task.pop("details")
-    todoist_task["labels"] = todoist_task.pop("todoist_label_list", [])
+    labels = todoist_task.pop("todoist_label_list", [])
+    todoist_task["labels"] = [
+        l for l in labels if l.lower() != "inprogress"
+    ]
     todoist_task.pop("todoist_type")
     todoist_task.pop("todoist_event")
 
@@ -782,9 +789,37 @@ def todoist_scrobble_task(
     return scrobble
 
 
+ORG_HEADING_RE = re.compile(r"^(\*+\s+.*)$", re.MULTILINE)
+NOTE_CONTENT_SPLIT = re.compile(r"^\*{3,}\s", re.MULTILINE)
+
+
+def _truncate_at_org_header(text: str) -> str:
+    """Truncate text at the first org-mode heading (*** or more)."""
+    parts = NOTE_CONTENT_SPLIT.split(text, maxsplit=1)
+    return parts[0].strip()
+
+
+def _extract_org_section(body: str | None, heading: str) -> str | None:
+    """Extract content under a specific org-mode sub-heading (e.g. '*** Description')."""
+    if not body:
+        return None
+    sections = ORG_HEADING_RE.split(body)
+    # sections alternates: [prefix, heading1, content1, heading2, content2, ...]
+    for i, section in enumerate(sections):
+        if section.strip().startswith(heading):
+            if i + 1 < len(sections):
+                return sections[i + 1].strip()
+            return ""
+    return None
+
+
 def emacs_scrobble_update_task(
-    emacs_id: str, emacs_notes: dict, user_id: int
+    emacs_id: str,
+    emacs_notes: list,
+    user_id: int,
+    description: Optional[str] = None,
 ) -> Optional[Scrobble]:
+    description = _extract_org_section(description, "*** Description")
     scrobble = Scrobble.objects.filter(
         in_progress=True,
         user_id=user_id,
@@ -803,27 +838,35 @@ def emacs_scrobble_update_task(
         )
         return
 
-    notes_updated = False
+    log_updated = False
+
+    if not scrobble.log.get("notes"):
+        scrobble.log["notes"] = {}
+
     for note in emacs_notes:
-        try:
-            existing_note_ts = [
-                n.get("timestamp") for n in scrobble.log.get("notes", [])
-            ]
-        except AttributeError:
-            existing_note_ts = []
-        if not scrobble.log.get('notes"'):
-            scrobble.log["notes"] = []
-        if note.get("timestamp") not in existing_note_ts:
-            scrobble.log["notes"].append({note.get("timestamp"): note.get("content")})
-            notes_updated = True
+        timestamp = note.get("timestamp")
+        content = note.get("content")
+        if not content:
+            continue
+        content = _truncate_at_org_header(content)
+        if not content:
+            continue
+        if timestamp:
+            existing = scrobble.log["notes"].get(timestamp)
+            if existing != content:
+                scrobble.log["notes"][timestamp] = content
+                log_updated = True
 
-    if notes_updated:
+    if description is not None and scrobble.log.get("description") != description:
+        scrobble.log["description"] = description
+        log_updated = True
+
+    if log_updated:
         scrobble.save(update_fields=["log"])
-
         logger.info(
-            "[emacs_scrobble_update_task] emacs note added",
+            "[emacs_scrobble_update_task] emacs scrobble updated",
             extra={
-                "emacs_note": emacs_notes,
+                "emacs_id": emacs_id,
                 "user_id": user_id,
                 "media_type": Scrobble.MediaType.TASK,
             },
@@ -865,7 +908,7 @@ def emacs_scrobble_task(
         logger.info(
             "[emacs_scrobble_task] cannot start already started task",
             extra={
-                "ormode_id": orgmode_id,
+                "orgmode_id": orgmode_id,
             },
         )
         return in_progress_scrobble
@@ -884,11 +927,9 @@ def emacs_scrobble_task(
     if in_progress_scrobble:
         return in_progress_scrobble
 
-    notes = task_data.pop("notes")
-    if notes:
-        task_data["notes"] = [note.get("content") for note in notes]
+    task_data.pop("notes", None)
     task_data["title"] = task_data.pop("description")
-    task_data["description"] = task_data.pop("body")
+    task_data["description"] = _extract_org_section(task_data.pop("body"), "*** Description")
     task_data["labels"] = task_data.pop("labels")
 
     task_data["orgmode_id"] = task_data.pop("source_id")

vrobbler/apps/scrobbles/signals.py

@@ -4,8 +4,14 @@ from django.db.models.signals import post_delete, post_save
 from django.dispatch import receiver
 from django.utils import timezone
 
-from scrobbles.models import Scrobble
-from scrobbles.tasks import CHARTABLE_MEDIA_TYPES, SCROBBLES_WITHOUT_CHARTS, update_charts_for_timestamp
+from scrobbles.models import FavoriteMedia, Scrobble
+from scrobbles.tasks import (
+    add_favorite_to_mopidy_playlist,
+    CHARTABLE_MEDIA_TYPES,
+    remove_favorite_from_mopidy_playlist,
+    SCROBBLES_WITHOUT_CHARTS,
+    update_charts_for_timestamp,
+)
 from scrobbles.utils import tokenize_title_to_tags
 
 logger = logging.getLogger(__name__)
@@ -72,3 +78,28 @@ def add_tags_from_task_title(sender, instance, **kwargs):
     for tag in new_tags:
         if tag not in existing_tags:
             instance.tags.add(tag)
+
+
+@receiver(post_save, sender=FavoriteMedia)
+def add_to_mopidy_playlist_on_favorite(sender, instance, created, **kwargs):
+    if not created:
+        return
+    if instance.media_type != Scrobble.MediaType.TRACK:
+        return
+    if not instance.track:
+        return
+
+    add_favorite_to_mopidy_playlist.delay(instance.id)
+
+
+@receiver(post_delete, sender=FavoriteMedia)
+def remove_from_mopidy_playlist_on_unfavorite(sender, instance, **kwargs):
+    if instance.media_type != Scrobble.MediaType.TRACK:
+        return
+    if not instance.track_id:
+        return
+
+    remove_favorite_from_mopidy_playlist.delay(
+        user_id=instance.user_id,
+        track_id=instance.track_id,
+    )

vrobbler/apps/scrobbles/tasks.py

@@ -542,3 +542,125 @@ def send_mood_checkin():
     from vrobbler.apps.scrobbles.utils import send_mood_checkin_reminders
 
     send_mood_checkin_reminders()
+
+
+@shared_task
+def add_favorite_to_mopidy_playlist(favorite_id):
+    from scrobbles.models import FavoriteMedia
+    from scrobbles.utils import add_track_to_mopidy_favorites_playlist
+
+    favorite = FavoriteMedia.objects.filter(id=favorite_id).first()
+    if not favorite:
+        return
+    add_track_to_mopidy_favorites_playlist(favorite)
+
+
+@shared_task
+def remove_favorite_from_mopidy_playlist(user_id, track_id):
+    from music.models import Track
+    from scrobbles.utils import remove_track_from_mopidy_favorites_playlist
+
+    User = get_user_model()
+    try:
+        user = User.objects.get(id=user_id)
+        track = Track.objects.get(id=track_id)
+    except (User.DoesNotExist, Track.DoesNotExist):
+        return
+
+    import types
+
+    proxy = types.SimpleNamespace(
+        media_type="Track",
+        user=user,
+        user_id=user.id,
+        track=track,
+    )
+    remove_track_from_mopidy_favorites_playlist(proxy)
+
+
+@shared_task
+def add_scrobble_to_mopidy_queue(scrobble_id):
+    from scrobbles.models import Scrobble
+
+    scrobble = Scrobble.objects.filter(id=scrobble_id).first()
+    if not scrobble:
+        return
+
+    profile = scrobble.user.profile
+    mopidy_url = profile.mopidy_api_url
+    if not mopidy_url:
+        return
+
+    mopidy_uri = (scrobble.log or {}).get("raw_data", {}).get("mopidy_uri")
+    track = scrobble.track if scrobble.media_type == "Track" else None
+    if not mopidy_uri and track:
+        sibling = (
+            Scrobble.objects.filter(track=track, user=scrobble.user)
+            .order_by("-timestamp")
+            .iterator()
+        )
+        for s in sibling:
+            uri = (s.log or {}).get("raw_data", {}).get("mopidy_uri")
+            if uri:
+                mopidy_uri = uri
+                break
+
+    if not mopidy_uri:
+        logger.warning(
+            "No Mopidy URI found for scrobble",
+            extra={"scrobble_id": scrobble_id, "user_id": scrobble.user_id},
+        )
+        return
+
+    import requests
+
+    rpc_url = mopidy_url.rstrip("/") + "/rpc"
+    payload = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "core.tracklist.add",
+        "params": {"uris": [mopidy_uri]},
+    }
+    try:
+        resp = requests.post(rpc_url, json=payload, timeout=10)
+        resp.raise_for_status()
+        rpc_result = resp.json()
+        if rpc_result.get("error"):
+            logger.error(
+                "Mopidy error adding to queue",
+                extra={"error": rpc_result["error"], "scrobble_id": scrobble_id},
+            )
+        else:
+            logger.info(
+                "Added track to Mopidy queue",
+                extra={"scrobble_id": scrobble_id, "mopidy_uri": mopidy_uri},
+            )
+    except requests.RequestException as e:
+        logger.error(
+            "Failed to add track to Mopidy queue",
+            extra={"scrobble_id": scrobble_id, "error": str(e)},
+        )
+
+
+@shared_task
+def add_scrobble_to_mopidy_monthly_playlist(scrobble_id):
+    from scrobbles.models import Scrobble
+    from scrobbles.utils import add_track_to_mopidy_monthly_playlist
+
+    scrobble = Scrobble.objects.filter(id=scrobble_id).first()
+    if not scrobble:
+        return
+
+    track = scrobble.track if scrobble.media_type == "Track" else None
+    if track:
+        sibling = (
+            Scrobble.objects.filter(track=track, user=scrobble.user)
+            .order_by("-timestamp")
+            .iterator()
+        )
+        for s in sibling:
+            if (s.log or {}).get("raw_data", {}).get("mopidy_uri"):
+                scrobble = s
+                break
+
+    add_track_to_mopidy_monthly_playlist(scrobble)

vrobbler/apps/scrobbles/urls.py

@@ -158,7 +158,22 @@ urlpatterns = [
         views.ScrobbleDetailView.as_view(),
         name="detail",
     ),
+    path(
+        "scrobbles/<slug:uuid>/add-to-mopidy-queue/",
+        views.add_to_mopidy_queue,
+        name="add-to-mopidy-queue",
+    ),
+    path(
+        "scrobbles/<slug:uuid>/add-to-mopidy-monthly-playlist/",
+        views.add_to_mopidy_monthly_playlist,
+        name="add-to-mopidy-monthly-playlist",
+    ),
     path("scrobbles/<slug:uuid>/start/", views.scrobble_start, name="start"),
     path("scrobbles/<slug:uuid>/finish/", views.scrobble_finish, name="finish"),
     path("scrobbles/<slug:uuid>/cancel/", views.scrobble_cancel, name="cancel"),
+    path(
+        "favorite/<str:media_type>/<int:object_id>/toggle/",
+        views.toggle_favorite,
+        name="toggle-favorite",
+    ),
 ]

vrobbler/apps/scrobbles/utils.py

@@ -15,6 +15,7 @@ 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 django.utils.dateformat import DateFormat
 from profiles.models import UserProfile
 from profiles.utils import now_user_timezone
 from scrobbles.constants import LONG_PLAY_MEDIA
@@ -32,6 +33,16 @@ from webdav.client import get_webdav_client
 if TYPE_CHECKING:
     from scrobbles.models import Scrobble
 
+
+NOTE_TIMESTAMP_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
+
+
+def make_note_timestamp(dt: datetime | None = None) -> str:
+    if dt is None:
+        dt = timezone.now()
+    return dt.strftime(NOTE_TIMESTAMP_FORMAT)
+
+
 logger = logging.getLogger(__name__)
 User = get_user_model()
 
@@ -77,8 +88,7 @@ def get_scrobbles_for_media(media_obj, user: User) -> models.QuerySet:
     return Scrobble.objects.filter(media_query, user=user)
 
 
-def get_recently_played_board_games(user: User) -> dict:
-    ...
+def get_recently_played_board_games(user: User) -> dict: ...
 
 
 def get_long_plays_in_progress(user: User) -> dict:
@@ -413,6 +423,288 @@ def get_daily_calorie_dict_for_user(user_id: int) -> dict[date, int]:
     return {entry["day"]: entry["total_calories"] for entry in qs}
 
 
+def _mopidy_rpc(profile, method, params=None):
+    rpc_url = profile.mopidy_api_url.rstrip("/") + "/rpc"
+    payload = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": method,
+    }
+    if params:
+        payload["params"] = params
+    resp = requests.post(rpc_url, json=payload, timeout=10)
+    resp.raise_for_status()
+    result = resp.json()
+    if result.get("error"):
+        raise RuntimeError(f'Mopidy error: {result["error"]}')
+    return result.get("result")
+
+
+def _ensure_mopidy_playlist(profile):
+    playlist_name = profile.favorites_mopidy_playlist
+    # Strip any m3u: prefix and .m3u8 suffix the user may have included
+    playlist_name = playlist_name.removeprefix("m3u:").removesuffix(".m3u8")
+
+    try:
+        playlists = _mopidy_rpc(profile, "core.playlists.as_list") or []
+        for pl in playlists:
+            if pl.get("name") == playlist_name:
+                existing = _mopidy_rpc(
+                    profile, "core.playlists.lookup", {"uri": pl["uri"]}
+                )
+                if existing:
+                    return existing
+    except (requests.RequestException, RuntimeError):
+        pass
+
+    result = _mopidy_rpc(
+        profile, "core.playlists.create",
+        {"name": playlist_name, "uri_scheme": "m3u"},
+    )
+    logger.info(
+        "Created Mopidy favorites playlist",
+        extra={"uri": result.get("uri") if result else playlist_name},
+    )
+    return result
+
+
+def _scrobble_with_mopidy_uri(track, user):
+    """Find a scrobble for this track+user that has a mopidy_uri in its log."""
+    from scrobbles.models import Scrobble
+
+    for scrobble in (
+        Scrobble.objects.filter(track=track, user=user)
+        .order_by("-timestamp")
+        .iterator()
+    ):
+        raw_data = scrobble.log.get("raw_data") or {}
+        if raw_data.get("mopidy_uri"):
+            return scrobble
+    return None
+
+
+def add_track_to_mopidy_favorites_playlist(favorite):
+    if favorite.media_type != "Track" or not favorite.track:
+        return
+
+    profile = favorite.user.profile
+    if not profile.favorites_mopidy_playlist or not profile.mopidy_api_url:
+        return
+
+    track = favorite.track
+    scrobble = _scrobble_with_mopidy_uri(track, favorite.user)
+
+    if not scrobble:
+        logger.warning(
+            "No Mopidy URI found for track",
+            extra={"track_id": track.id, "user_id": favorite.user_id},
+        )
+        return
+
+    mopidy_uri = (scrobble.log or {}).get("raw_data", {}).get("mopidy_uri")
+
+    try:
+        playlist = _ensure_mopidy_playlist(profile)
+        if playlist and playlist.get("uri"):
+            existing_tracks = playlist.get("tracks") or []
+            track_uris = [t["uri"] for t in existing_tracks if isinstance(t, dict)]
+            if mopidy_uri in track_uris:
+                logger.info(
+                    "Track already in Mopidy favorites playlist",
+                    extra={"track_id": track.id, "mopidy_uri": mopidy_uri},
+                )
+                favorite.sent_to_mopidy = True
+                favorite.save(update_fields=["sent_to_mopidy"])
+                return
+
+            new_track = {"__model__": "Track", "uri": mopidy_uri}
+            existing_tracks.append(new_track)
+            _mopidy_rpc(
+                profile,
+                "core.playlists.save",
+                {
+                    "playlist": {
+                        "__model__": "Playlist",
+                        "uri": playlist["uri"],
+                        "name": playlist.get("name", "Favorites"),
+                        "tracks": existing_tracks,
+                        "last_modified": playlist.get("last_modified"),
+                    },
+                },
+            )
+        else:
+            _mopidy_rpc(profile, "core.tracklist.add", {"uris": [mopidy_uri]})
+
+        favorite.sent_to_mopidy = True
+        favorite.save(update_fields=["sent_to_mopidy"])
+        logger.info(
+            "Added track to Mopidy favorites playlist",
+            extra={"track_id": track.id, "user_id": favorite.user_id},
+        )
+    except (requests.RequestException, RuntimeError) as e:
+        logger.debug(e)
+        logger.error(
+            "Failed to add track to Mopidy favorites playlist",
+            extra={"track_id": track.id, "user_id": favorite.user_id, "error": str(e)},
+        )
+
+
+def resubmit_favorites_to_mopidy(user):
+    from scrobbles.models import FavoriteMedia
+
+    favorites = FavoriteMedia.objects.filter(
+        user=user,
+        media_type="Track",
+        track__isnull=False,
+    )
+    for favorite in favorites:
+        add_track_to_mopidy_favorites_playlist(favorite)
+
+
+def remove_track_from_mopidy_favorites_playlist(favorite):
+    if favorite.media_type != "Track" or not favorite.track:
+        return
+
+    profile = favorite.user.profile
+    if not profile.favorites_mopidy_playlist or not profile.mopidy_api_url:
+        return
+
+    track = favorite.track
+    scrobble = _scrobble_with_mopidy_uri(track, favorite.user)
+
+    if not scrobble:
+        logger.warning(
+            "No Mopidy URI found for track",
+            extra={"track_id": track.id, "user_id": favorite.user_id},
+        )
+        return
+
+    mopidy_uri = (scrobble.log or {}).get("raw_data", {}).get("mopidy_uri")
+
+    try:
+        playlist = _ensure_mopidy_playlist(profile)
+        if playlist and playlist.get("uri"):
+            existing_tracks = playlist.get("tracks") or []
+            filtered = [
+                t for t in existing_tracks
+                if not (isinstance(t, dict) and t.get("uri") == mopidy_uri)
+            ]
+            if len(filtered) == len(existing_tracks):
+                logger.info(
+                    "Track not found in Mopidy favorites playlist",
+                    extra={"track_id": track.id, "mopidy_uri": mopidy_uri},
+                )
+                return
+
+            _mopidy_rpc(
+                profile,
+                "core.playlists.save",
+                {
+                    "playlist": {
+                        "__model__": "Playlist",
+                        "uri": playlist["uri"],
+                        "name": playlist.get("name", "Favorites"),
+                        "tracks": filtered,
+                        "last_modified": playlist.get("last_modified"),
+                    },
+                },
+            )
+            logger.info(
+                "Removed track from Mopidy favorites playlist",
+                extra={"track_id": track.id, "user_id": favorite.user_id},
+            )
+    except (requests.RequestException, RuntimeError) as e:
+        logger.debug(e)
+        logger.error(
+            "Failed to remove track from Mopidy favorites playlist",
+            extra={"track_id": track.id, "user_id": favorite.user_id, "error": str(e)},
+        )
+
+
+def _ensure_mopidy_playlist_by_name(profile, playlist_name):
+    """Find or create a Mopidy playlist by name (without m3u: prefix handling)."""
+    playlist_name = playlist_name.removeprefix("m3u:").removesuffix(".m3u8")
+    try:
+        playlists = _mopidy_rpc(profile, "core.playlists.as_list") or []
+        for pl in playlists:
+            if pl.get("name") == playlist_name:
+                existing = _mopidy_rpc(
+                    profile, "core.playlists.lookup", {"uri": pl["uri"]}
+                )
+                if existing:
+                    return existing
+    except (requests.RequestException, RuntimeError):
+        pass
+
+    result = _mopidy_rpc(
+        profile, "core.playlists.create",
+        {"name": playlist_name, "uri_scheme": "m3u"},
+    )
+    return result
+
+
+def add_track_to_mopidy_monthly_playlist(scrobble):
+    """Add a scrobbled track to a monthly Mopidy playlist based on the user's pattern."""
+    profile = scrobble.user.profile
+    pattern = profile.monthly_mopidy_playlist_pattern
+    if not pattern or not profile.mopidy_api_url:
+        return
+
+    mopidy_uri = (scrobble.log or {}).get("raw_data", {}).get("mopidy_uri")
+    if not mopidy_uri:
+        return
+
+    now = now_user_timezone(profile)
+    playlist_name = DateFormat(now).format(pattern)
+    if not playlist_name:
+        return
+
+    try:
+        playlist = _ensure_mopidy_playlist_by_name(profile, playlist_name)
+        if playlist and playlist.get("uri"):
+            existing_tracks = playlist.get("tracks") or []
+            track_uris = [t["uri"] for t in existing_tracks if isinstance(t, dict)]
+            if mopidy_uri in track_uris:
+                logger.info(
+                    "Track already in monthly Mopidy playlist",
+                    extra={"playlist": playlist_name, "mopidy_uri": mopidy_uri},
+                )
+                return
+
+            new_track = {"__model__": "Track", "uri": mopidy_uri}
+            existing_tracks.append(new_track)
+            _mopidy_rpc(
+                profile,
+                "core.playlists.save",
+                {
+                    "playlist": {
+                        "__model__": "Playlist",
+                        "uri": playlist["uri"],
+                        "name": playlist.get("name", playlist_name),
+                        "tracks": existing_tracks,
+                        "last_modified": playlist.get("last_modified"),
+                    },
+                },
+            )
+        else:
+            _mopidy_rpc(profile, "core.tracklist.add", {"uris": [mopidy_uri]})
+
+        logger.info(
+            "Added track to monthly Mopidy playlist",
+            extra={
+                "playlist": playlist_name,
+                "track_id": scrobble.media_obj.id,
+                "user_id": scrobble.user_id,
+            },
+        )
+    except (requests.RequestException, RuntimeError) as e:
+        logger.debug(e)
+        logger.error(
+            "Failed to add track to monthly Mopidy playlist",
+            extra={"playlist": playlist_name, "error": str(e)},
+        )
+
+
 def remove_last_part(url: str) -> str:
     url = url.rstrip("/")
     if "/" not in url:
@@ -507,8 +799,6 @@ def tokenize_title_to_tags(title: str) -> list[str]:
     cleaned = re.sub(r"[^\w\s]", "", cleaned)
 
     words = [
-        w.lower()
-        for w in cleaned.split()
-        if w.lower() not in STOPWORDS and len(w) > 2
+        w.lower() for w in cleaned.split() if w.lower() not in STOPWORDS and len(w) > 2
     ]
     return words

vrobbler/apps/scrobbles/views.py

@@ -4,6 +4,8 @@ import logging
 from datetime import datetime, timedelta
 from uuid import uuid4
 
+import requests
+
 import pendulum
 import pytz
 from dateutil.relativedelta import relativedelta
@@ -12,7 +14,7 @@ from django.contrib import messages
 from django.contrib.auth import get_user_model
 from django.contrib.auth.mixins import LoginRequiredMixin
 from django.core.paginator import EmptyPage, PageNotAnInteger, Paginator
-from django.db.models import Count, Max, Q
+from django.db.models import Count, Max, Q, Sum
 from django.db.models.query import QuerySet
 from rest_framework.authentication import TokenAuthentication
 from rest_framework.authtoken.models import Token
@@ -30,10 +32,12 @@ from django.http import (
     HttpResponseRedirect,
     JsonResponse,
 )
-from django.shortcuts import redirect
+from django.shortcuts import get_object_or_404, redirect
 from django.urls import reverse_lazy
 from django.utils import timezone
+from django.utils.dateformat import DateFormat
 from django.views.decorators.csrf import csrf_exempt
+from django.views.decorators.http import require_POST
 from django.views.generic import DetailView, FormView, TemplateView
 from django.views.generic.edit import CreateView
 from django.views.generic.list import ListView
@@ -72,6 +76,7 @@ from scrobbles.models import (
     AudioScrobblerTSVImport,
     BGStatsImport,
     EBirdCSVImport,
+    FavoriteMedia,
     KoReaderImport,
     LastFmImport,
     RetroarchImport,
@@ -226,7 +231,7 @@ class RecentScrobbleList(ListView):
 
             # Get user's home scrobble limit (default 20)
             home_limit = 20
-            if hasattr(user, 'profile') and user.profile.home_scrobble_limit:
+            if hasattr(user, "profile") and user.profile.home_scrobble_limit:
                 home_limit = user.profile.home_scrobble_limit
 
             today = timezone.localtime(timezone.now())
@@ -364,6 +369,7 @@ class ScrobbleListView(LoginRequiredMixin, ListView):
         else:
             tag_list = []
         self.tag_list = tag_list
+        self._full_queryset = qs
         return qs
 
     def _compute_overlap_groups(self, scrobbles):
@@ -430,6 +436,13 @@ class ScrobbleListView(LoginRequiredMixin, ListView):
         ctx["tag_list"] = getattr(self, "tag_list", [])
         scrobbles = list(ctx.get("object_list", []))
         ctx["overlap_map"] = self._compute_overlap_groups(scrobbles)
+        full_qs = getattr(self, "_full_queryset", None)
+        if full_qs is not None and getattr(self, "tag_list", []):
+            total = (
+                full_qs.aggregate(total=Sum("playback_position_seconds"))["total"]
+                or 0
+            )
+            ctx["total_time_seconds"] = total
         return ctx
 
 
@@ -612,9 +625,7 @@ class KoReaderImportCreateView(LoginRequiredMixin, JsonableResponseMixin, Create
         return HttpResponseRedirect(self.request.META.get("HTTP_REFERER"))
 
 
-class ScaleCSVImportCreateView(
-    LoginRequiredMixin, JsonableResponseMixin, CreateView
-):
+class ScaleCSVImportCreateView(LoginRequiredMixin, JsonableResponseMixin, CreateView):
     model = ScaleCSVImport
     fields = ["csv_file"]
     template_name = "scrobbles/upload_form.html"
@@ -623,17 +634,13 @@ class ScaleCSVImportCreateView(
     def form_valid(self, form):
         self.object = form.save(commit=False)
         self.object.user = self.request.user
-        self.object.original_filename = (
-            form.cleaned_data["csv_file"].name
-        )
+        self.object.original_filename = form.cleaned_data["csv_file"].name
         self.object.save()
         self.object.process()
         return HttpResponseRedirect(self.request.META.get("HTTP_REFERER"))
 
 
-class TrailGPXImportCreateView(
-    LoginRequiredMixin, JsonableResponseMixin, CreateView
-):
+class TrailGPXImportCreateView(LoginRequiredMixin, JsonableResponseMixin, CreateView):
     model = TrailGPXImport
     fields = ["gpx_file"]
     template_name = "scrobbles/upload_form.html"
@@ -852,7 +859,9 @@ def scrobble_start(request, uuid):
                     book=media_obj,
                     user_id=user_id,
                 )
-                .filter(Q(long_play_complete=False) | Q(long_play_complete__isnull=True))
+                .filter(
+                    Q(long_play_complete=False) | Q(long_play_complete__isnull=True)
+                )
                 .filter(log__page_end__isnull=False)
                 .order_by("-timestamp")
                 .first()
@@ -967,6 +976,113 @@ def scrobble_cancel(request, uuid):
     return HttpResponseRedirect(request.META.get("HTTP_REFERER"))
 
 
+@require_POST
+def add_to_mopidy_queue(request, uuid):
+    if not request.user.is_authenticated:
+        return redirect("scrobbles:detail", uuid=uuid)
+
+    scrobble = get_object_or_404(Scrobble, uuid=uuid, user=request.user)
+    mopidy_url = request.user.profile.mopidy_api_url
+
+    if not mopidy_url:
+        messages.add_message(
+            request,
+            messages.ERROR,
+            "Mopidy API URL not configured in your profile settings.",
+        )
+        return redirect("scrobbles:detail", uuid=uuid)
+
+    from scrobbles.tasks import add_scrobble_to_mopidy_queue as task
+
+    task.delay(scrobble.id)
+    msg = f'Adding "{scrobble.media_obj}" to Mopidy queue.'
+    messages.add_message(request, messages.SUCCESS, msg)
+    return redirect("scrobbles:detail", uuid=uuid)
+
+
+@require_POST
+def add_to_mopidy_monthly_playlist(request, uuid):
+    if not request.user.is_authenticated:
+        return redirect("scrobbles:detail", uuid=uuid)
+
+    scrobble = get_object_or_404(Scrobble, uuid=uuid, user=request.user)
+    profile = request.user.profile
+    pattern = profile.monthly_mopidy_playlist_pattern
+
+    if not pattern or not profile.mopidy_api_url:
+        messages.add_message(
+            request,
+            messages.ERROR,
+            "Monthly playlist pattern or Mopidy API URL not configured in your profile.",
+        )
+        return redirect("scrobbles:detail", uuid=uuid)
+
+    now = now_user_timezone(profile)
+    playlist_name = DateFormat(now).format(pattern)
+
+    from scrobbles.tasks import add_scrobble_to_mopidy_monthly_playlist as task
+
+    task.delay(scrobble.id)
+    messages.add_message(
+        request,
+        messages.SUCCESS,
+        f'Adding "{scrobble.media_obj}" to monthly playlist "{playlist_name}".',
+    )
+    return redirect("scrobbles:detail", uuid=uuid)
+
+
+@require_POST
+def toggle_favorite(request, media_type, object_id):
+    if not request.user.is_authenticated:
+        return HttpResponseRedirect(request.META.get("HTTP_REFERER", "/"))
+
+    app_model_map = {
+        "Video": ("videos", "Video"),
+        "Channel": ("videos", "Channel"),
+        "Track": ("music", "Track"),
+        "PodcastEpisode": ("podcasts", "PodcastEpisode"),
+        "SportEvent": ("sports", "SportEvent"),
+        "Book": ("books", "Book"),
+        "Paper": ("books", "Paper"),
+        "VideoGame": ("videogames", "VideoGame"),
+        "BoardGame": ("boardgames", "BoardGame"),
+        "GeoLocation": ("locations", "GeoLocation"),
+        "Beer": ("beers", "Beer"),
+        "Puzzle": ("puzzles", "Puzzle"),
+        "Food": ("foods", "Food"),
+        "Trail": ("trails", "Trail"),
+        "Task": ("tasks", "Task"),
+        "WebPage": ("webpages", "WebPage"),
+        "LifeEvent": ("lifeevents", "LifeEvent"),
+        "Mood": ("moods", "Mood"),
+        "BrickSet": ("bricksets", "BrickSet"),
+        "BirdingLocation": ("birds", "BirdingLocation"),
+    }
+
+    app_label, model_name = app_model_map.get(media_type, (None, None))
+    if not app_label:
+        messages.add_message(
+            request, messages.ERROR, f"Unknown media type: {media_type}"
+        )
+        return HttpResponseRedirect(request.META.get("HTTP_REFERER", "/"))
+
+    model = apps.get_model(app_label, model_name)
+    media_obj = get_object_or_404(model, id=object_id)
+    result = FavoriteMedia.toggle(media_obj, request.user)
+
+    is_favorited = result is not None
+    if not is_favorited:
+        msg = f'Removed "{media_obj}" from favorites.'
+    else:
+        msg = f'Added "{media_obj}" to favorites.'
+
+    if request.headers.get("x-requested-with") == "XMLHttpRequest":
+        return JsonResponse({"is_favorited": is_favorited, "message": msg})
+
+    messages.add_message(request, messages.SUCCESS, msg)
+    return HttpResponseRedirect(request.META.get("HTTP_REFERER", "/"))
+
+
 @api_view(["GET"])
 @permission_classes([IsAuthenticated])
 def export(request):
@@ -1028,7 +1144,11 @@ class ScrobbleDetailView(DetailView):
         FormClass = self.get_form_class()
 
         log = self.object.log or {}
-        log["notes"] = self.object.logdata.notes_as_str(separator="\n")
+        notes = log.get("notes")
+        if isinstance(notes, dict):
+            log["notes"] = notes
+        else:
+            log["notes"] = self.object.logdata.notes_as_str(separator="\n")
 
         return FormClass(initial=log)
 
@@ -1113,6 +1233,24 @@ class ScrobbleDetailView(DetailView):
         except EmptyPage:
             context["related_scrobbles"] = paginator.page(paginator.num_pages)
 
+        if self.request.user.is_authenticated:
+            fk_field = self.MEDIA_FK_MAP.get(media_type)
+            if fk_field and media_obj:
+                context["is_favorited"] = FavoriteMedia.objects.filter(
+                    user=self.request.user, **{fk_field: media_obj}
+                ).exists()
+
+        if media_type == "Track" and media_obj:
+            scrobbles = Scrobble.objects.filter(
+                track=media_obj, user=self.object.user
+            ).order_by("-timestamp")[:20]
+            context["has_mopidy_uri"] = any(
+                (s.log or {}).get("raw_data", {}).get("mopidy_uri")
+                for s in scrobbles
+            )
+        else:
+            context["has_mopidy_uri"] = False
+
         return context
 
 
@@ -1328,6 +1466,7 @@ class ScrobbleCalendarView(LoginRequiredMixin, TemplateView):
 
     def _day_color(self, month_index, day_num, total_days):
         import colorsys
+
         hue = (month_index - 1) * 30 / 360
         lightness = 0.80 + (day_num / total_days) * 0.15
         r, g, b = colorsys.hls_to_rgb(hue, lightness, 0.5)
@@ -1355,7 +1494,9 @@ class ScrobbleCalendarView(LoginRequiredMixin, TemplateView):
         if media_type_filter and media_type_filter in self.CALENDAR_MEDIA_TYPES:
             active_types = [media_type_filter]
         else:
-            active_types = [t for t in self.CALENDAR_MEDIA_TYPES if t not in self.DEFAULT_EXCLUDE]
+            active_types = [
+                t for t in self.CALENDAR_MEDIA_TYPES if t not in self.DEFAULT_EXCLUDE
+            ]
 
         scrobbles = (
             Scrobble.objects.filter(
@@ -1364,19 +1505,35 @@ class ScrobbleCalendarView(LoginRequiredMixin, TemplateView):
                 timestamp__date__lte=month_end,
                 media_type__in=active_types,
             )
-            .select_related("task", "birding_location", "food", "trail", "video_game", "book", "mood", "video", "board_game")
+            .select_related(
+                "task",
+                "birding_location",
+                "food",
+                "trail",
+                "video_game",
+                "book",
+                "mood",
+                "video",
+                "board_game",
+            )
             .order_by("timestamp")
         )
 
-        from django.db.models import Count
+        from django.db.models import Count, Q
         from django.db.models.functions import TruncDate
+
         total_by_day = dict(
             Scrobble.objects.filter(
                 user=self.request.user,
                 timestamp__date__gte=month_start,
                 timestamp__date__lte=month_end,
             )
-            .annotate(local_date=TruncDate("timestamp", tzinfo=timezone.get_current_timezone()))
+            .exclude(Q(media_type="GeoLocation") & Q(geo_location__title__isnull=True))
+            .annotate(
+                local_date=TruncDate(
+                    "timestamp", tzinfo=timezone.get_current_timezone()
+                )
+            )
             .values("local_date")
             .annotate(count=Count("id"))
             .values_list("local_date", "count")
@@ -1402,17 +1559,27 @@ class ScrobbleCalendarView(LoginRequiredMixin, TemplateView):
                     {
                         "uuid": scrobble.uuid,
                         "emoji": self.MEDIA_EMOJI.get(scrobble.media_type, "📌"),
-                        "title": str(scrobble.media_obj) if scrobble.media_obj else scrobble.media_type,
+                        "title": (
+                            str(scrobble.media_obj)
+                            if scrobble.media_obj
+                            else scrobble.media_type
+                        ),
                         "media_type": scrobble.media_type,
                     }
                 )
-            calendar_days.append({
-                "day": day_num,
-                "scrobbles": day_scrobbles,
-                "total_count": total_by_day.get(datetime(year, month, day_num).date(), 0),
-                "is_today": year == today.year and month == today.month and day_num == today.day,
-                "color": self._day_color(month, day_num, total_days),
-            })
+            calendar_days.append(
+                {
+                    "day": day_num,
+                    "scrobbles": day_scrobbles,
+                    "total_count": total_by_day.get(
+                        datetime(year, month, day_num).date(), 0
+                    ),
+                    "is_today": year == today.year
+                    and month == today.month
+                    and day_num == today.day,
+                    "color": self._day_color(month, day_num, total_days),
+                }
+            )
 
         ctx.update(
             {
@@ -1429,7 +1596,10 @@ class ScrobbleCalendarView(LoginRequiredMixin, TemplateView):
                 "day_names": ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
                 "month_color": month_color,
                 "active_filter": media_type_filter or "",
-                "media_types": [{"name": mt, "emoji": self.MEDIA_EMOJI.get(mt, "📌")} for mt in self.CALENDAR_MEDIA_TYPES],
+                "media_types": [
+                    {"name": mt, "emoji": self.MEDIA_EMOJI.get(mt, "📌")}
+                    for mt in self.CALENDAR_MEDIA_TYPES
+                ],
             }
         )
         return ctx
@@ -1440,7 +1610,7 @@ class ScrobbleSearchView(LoginRequiredMixin, TemplateView):
 
     MEDIA_FIELDS = {
         "Video": ["video__title", "video__overview"],
-        "Track": ["track__title", "track__artist__name", "track__album__name"],
+        "Track": ["track__title", "track__artists__name", "track__album__name"],
         "PodcastEpisode": ["podcast_episode__title", None],
         "Book": ["book__title", "book__summary"],
         "Paper": ["paper__title", None],

vrobbler/apps/tasks/forms.py

@@ -0,0 +1,47 @@
+import json
+
+from django import forms
+
+
+class TaskNotesWidget(forms.Widget):
+    template_name = "tasks/task_notes_widget.html"
+
+    class Media:
+        js = ("tasks/task_notes.js",)
+
+    def value_from_datadict(self, data, files, name):
+        timestamps = data.getlist(f"{name}_timestamps")
+        contents = data.getlist(f"{name}_contents")
+        return {
+            "timestamps": timestamps,
+            "contents": contents,
+        }
+
+    def get_context(self, name, value, attrs):
+        context = super().get_context(name, value, attrs)
+        notes = {}
+        if value:
+            if isinstance(value, str):
+                try:
+                    notes = json.loads(value)
+                except (json.JSONDecodeError, TypeError):
+                    notes = {}
+            elif isinstance(value, dict):
+                notes = value
+        context["widget"]["notes"] = notes
+        return context
+
+
+class TaskNotesField(forms.Field):
+    widget = TaskNotesWidget
+
+    def clean(self, value):
+        if not value:
+            return {}
+        result = {}
+        timestamps = value.get("timestamps", [])
+        contents = value.get("contents", [])
+        for i, ts in enumerate(timestamps):
+            if i < len(contents) and ts and contents[i].strip():
+                result[ts] = contents[i].strip()
+        return result if result else {}

vrobbler/apps/tasks/models.py

@@ -38,6 +38,18 @@ class TaskLogData(BaseLogData):
         "todoist_project_id",
     }
 
+    @classmethod
+    def override_fields(cls) -> dict:
+        from scrobbles.forms import NotesDictField
+
+        fields = {}
+        for base in cls.mro()[1:]:
+            if hasattr(base, "override_fields"):
+                base_fields = base.override_fields()
+                fields.update(base_fields)
+        fields["notes"] = NotesDictField(required=False)
+        return fields
+
     def notes_as_str(self, separator: str = " | ") -> str:
         """Return formatted notes with line breaks and no keys"""
         labels_str = ""
@@ -47,13 +59,14 @@ class TaskLogData(BaseLogData):
         lines = []
         if self.notes:
             notes = self.notes
+            if isinstance(notes, dict):
+                notes = [{k: v} for k, v in notes.items()]
             if isinstance(notes, str):
                 notes = [notes]
 
             for note in notes:
                 if isinstance(note, dict):
                     timestamp, note_text = next(iter(note.items()))
-                    # Flatten newlines and clean whitespace
                     note_text = " ".join(note_text.strip().split())
                     lines.append(f"{timestamp}: {note_text}")
                 if isinstance(note, list):
@@ -63,31 +76,62 @@ class TaskLogData(BaseLogData):
         return separator.join(lines).encode("utf-8").decode("unicode_escape")
 
     def notes_as_html(self) -> str:
+        import bleach
+        import markdown
+        from django.utils.safestring import mark_safe
+        from scrobbles.dataclasses import BaseLogData
+
         if not self.notes:
             return ""
 
+        md = markdown.Markdown(extensions=["extra"])
+        allowed_tags = [
+            "p", "br", "strong", "em", "a", "ul", "ol", "li",
+            "code", "pre", "blockquote", "h1", "h2", "h3", "h4", "h5", "h6",
+            "hr", "img",
+        ]
+
         notes = self.notes
+        if isinstance(notes, dict):
+            notes = [{k: v} for k, v in notes.items()]
         if isinstance(notes, str):
             notes = [notes]
 
-        html_notes = []
+        note_items = []
         for note in notes:
             if isinstance(note, dict):
                 timestamp, note_text = next(iter(note.items()))
-                note_text = " ".join(note_text.strip().split())
-                html_notes.append(
-                    f'<div class="sticky-note">{timestamp}: {note_text}</div>'
-                )
+                note_items.append((timestamp, note_text.strip()))
             elif isinstance(note, str):
                 escaped = note.encode("utf-8").decode("unicode_escape")
                 for line in escaped.split("\n"):
                     if line.strip():
-                        html_notes.append(f'<div class="sticky-note">{line}</div>')
+                        note_items.append((None, line.strip()))
             elif isinstance(note, list):
                 for item in note:
                     if isinstance(item, str):
-                        html_notes.append(f'<div class="sticky-note">{item}</div>')
-        return "".join(html_notes)
+                        note_items.append((None, item.strip()))
+
+        html_parts = []
+        for i, (ts, text) in enumerate(note_items):
+            if i > 0:
+                html_parts.append('<hr class="note-divider">')
+
+            ts_html = ""
+            if ts:
+                ts_html = f'<h5 class="note-timestamp">{BaseLogData._format_timestamp(ts)}</h5>'
+
+            content_html = bleach.clean(
+                md.convert(text),
+                tags=allowed_tags,
+                strip=True,
+            )
+
+            html_parts.append(
+                f'<div class="note-item">{ts_html}<div class="note-content">{content_html}</div></div>'
+            )
+
+        return mark_safe("".join(html_parts))
 
 
 class Task(LongPlayScrobblableMixin):

vrobbler/apps/tasks/static/tasks/task_notes.js

@@ -0,0 +1,36 @@
+(function() {
+    function addNoteRow(container, widgetName, timestamp, content) {
+        var row = document.createElement('div');
+        row.className = 'task-note-row row mb-2 align-items-start';
+        row.innerHTML =
+            '<div class="col-md-3">' +
+                '<input type="hidden" name="' + widgetName + '_timestamps" value="' + timestamp + '">' +
+            '</div>' +
+            '<div class="col-md-7">' +
+                '<textarea name="' + widgetName + '_contents" class="form-control" rows="2">' + (content || '') + '</textarea>' +
+            '</div>' +
+            '<div class="col-md-2">' +
+                '<button type="button" class="btn btn-sm btn-outline-danger remove-note">&times;</button>' +
+            '</div>';
+        container.appendChild(row);
+    }
+
+    document.addEventListener('click', function(e) {
+        var addBtn = e.target.closest('.add-note');
+        if (addBtn) {
+            e.preventDefault();
+            var container = document.getElementById('task-notes-container');
+            var now = Math.floor(Date.now() / 1000);
+            var widgetName = addBtn.getAttribute('data-widget-name');
+            addNoteRow(container, widgetName, String(now), '');
+        }
+    });
+
+    document.addEventListener('click', function(e) {
+        var removeBtn = e.target.closest('.remove-note');
+        if (removeBtn) {
+            e.preventDefault();
+            removeBtn.closest('.task-note-row').remove();
+        }
+    });
+})();

vrobbler/apps/tasks/templates/tasks/task_notes_widget.html

@@ -0,0 +1,17 @@
+{% load static %}
+<div id="task-notes-container" class="task-notes-widget">
+  {% for timestamp, content in widget.notes.items %}
+  <div class="task-note-row row mb-2 align-items-start">
+    <div class="col-md-3">
+      <input type="hidden" name="{{widget.name}}_timestamps" value="{{timestamp}}">
+    </div>
+    <div class="col-md-7">
+      <textarea name="{{widget.name}}_contents" class="form-control" rows="2">{{content}}</textarea>
+    </div>
+    <div class="col-md-2">
+      <button type="button" class="btn btn-sm btn-outline-danger remove-note">&times;</button>
+    </div>
+  </div>
+  {% endfor %}
+</div>
+<button type="button" class="btn btn-sm btn-outline-primary add-note" data-widget-name="{{widget.name}}">+ Add Note</button>

vrobbler/apps/tasks/utils.py

@@ -64,6 +64,8 @@ def convert_old_todoist_log_to_new(commit=False):
 
 
 def convert_notes_to_dict(commit=False):
+    from scrobbles.utils import make_note_timestamp
+
     scrobbles = Scrobble.objects.filter(log__notes__isnull=False)
     count = 0
     for scrobble in scrobbles:
@@ -71,7 +73,7 @@ def convert_notes_to_dict(commit=False):
             print(f"Converting {scrobble} string note to dict")
             if scrobble.log.get("notes") == "":
                 scrobble.log.pop("notes")
-            key = str(int(scrobble.timestamp.timestamp()))
+            key = make_note_timestamp(scrobble.timestamp)
             notes = scrobble.log.pop("notes")
             scrobble.log = {}
             scrobble.log["notes"] = {key: notes}
@@ -83,18 +85,54 @@ def convert_notes_to_dict(commit=False):
                 scrobble.log["notes"] = [
                     value for d in note_list for value in d.values()
                 ]
+            else:
+                scrobble.log["notes"] = note_list
             count += 1
         if commit:
             scrobble.save(update_fields=["log"])
     print(f"Updated {count} todoist tasks scrobbles")
 
 
-def convert_old_boardgame_log_to_new(commit=False):
-    scrobbles = Scrobble.objects.filter(board_game__isnull=False, log__has_key="notes")
-    for scrobble in scrobbles:
-        if isinstance(scrobble.log.get("notes"), str):
-            scrobble.log["notes"] = [scrobble.log.pop("notes")]
+def convert_tasks_notes_list_to_dict(commit=False):
+    from scrobbles.utils import make_note_timestamp
 
+    scrobbles = Scrobble.objects.filter(task__isnull=False, log__notes__isnull=False)
+    count = 0
+    for scrobble in scrobbles:
+        notes = scrobble.log.get("notes")
+        if isinstance(notes, list):
+            key = make_note_timestamp(scrobble.timestamp + timedelta(seconds=10))
+            parts = []
+            for note in notes:
+                if isinstance(note, dict):
+                    parts.append(next(iter(note.values()), ""))
+                elif isinstance(note, list):
+                    parts.extend(str(x) for x in note)
+                else:
+                    parts.append(str(note))
+            scrobble.log["notes"] = {key: "\n".join(parts)}
+            count += 1
+            if commit:
+                scrobble.save(update_fields=["log"])
+    print(f"Updated {count} task scrobbles notes from list to dict")
+
+
+def convert_old_boardgame_log_to_new(commit=False):
+    from scrobbles.utils import make_note_timestamp
+
+    scrobbles = Scrobble.objects.filter(board_game__isnull=False, log__has_key="notes")
+    count = 0
+    for scrobble in scrobbles:
+        notes = scrobble.log.get("notes")
+        if isinstance(notes, str):
+            scrobble.log["notes"] = [notes]
+            notes = [notes]
+        if isinstance(notes, list):
+            key_ts = scrobble.stop_timestamp or scrobble.timestamp
+            scrobble.log["notes"] = {make_note_timestamp(key_ts): "\n".join(
+                str(n) for n in notes
+            )}
+            count += 1
         if commit:
             scrobble.save(update_fields=["log"])
-    print(f"Updated {scrobbles.count()} board game scrobbles")
+    print(f"Updated {count} board game scrobbles")

vrobbler/apps/tasks/views.py

@@ -1,5 +1,6 @@
 import logging
 
+import pendulum
 from django.contrib import messages
 from django.http import HttpResponseRedirect
 from django.urls import reverse_lazy
@@ -8,6 +9,7 @@ from rest_framework import status
 from rest_framework.decorators import api_view, permission_classes
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
+from scrobbles.models import Scrobble
 from scrobbles.views import ScrobbleableDetailView, ScrobbleableListView
 from tasks.models import Task
 
@@ -23,6 +25,72 @@ class TaskListView(ScrobbleableListView):
 class TaskDetailView(ScrobbleableDetailView):
     model = Task
 
+    def get_context_data(self, **kwargs):
+        ctx = super().get_context_data(**kwargs)
+        if self.object.title != "Weigh-in":
+            return ctx
+
+        scrobbles = list(
+            Scrobble.objects.filter(
+                user=self.request.user,
+                task=self.object,
+                log__weight__isnull=False,
+            ).order_by("timestamp")
+        )
+        if not scrobbles:
+            return ctx
+
+        labels = []
+        weight_data = []
+        body_fat_data = []
+        bmi_data = []
+        for s in scrobbles:
+            ts = s.timestamp
+            if isinstance(ts, str):
+                ts = pendulum.parse(ts)
+            labels.append(ts.strftime("%Y-%m-%d"))
+            log = s.log if isinstance(s.log, dict) else {}
+            raw_weight = log.get("weight")
+            weight_data.append(
+                float(raw_weight) if raw_weight is not None else None
+            )
+            raw_bf = log.get("body_fat")
+            body_fat_data.append(
+                float(raw_bf) if raw_bf is not None else None
+            )
+            raw_bmi = log.get("bmi")
+            bmi_data.append(
+                float(raw_bmi) if raw_bmi is not None else None
+            )
+
+        ctx["weighin_chart"] = {
+            "labels": labels,
+            "datasets": [
+                {
+                    "label": "Weight",
+                    "data": weight_data,
+                    "borderColor": "#4bc0c0",
+                    "fill": False,
+                    "yAxisID": "y",
+                },
+                {
+                    "label": "Body Fat %",
+                    "data": body_fat_data,
+                    "borderColor": "#ff6384",
+                    "fill": False,
+                    "yAxisID": "y1",
+                },
+                {
+                    "label": "BMI",
+                    "data": bmi_data,
+                    "borderColor": "#36a2eb",
+                    "fill": False,
+                    "yAxisID": "y2",
+                },
+            ],
+        }
+        return ctx
+
 
 @api_view(["GET"])
 @permission_classes([IsAuthenticated])

vrobbler/apps/tasks/webhooks.py

@@ -136,6 +136,7 @@ class TodoistWebhookView(APIView):
                 "todoist_type": todoist_type,
                 "todoist_event": todoist_event,
                 "updated_at": task_data.get("updated_at"),
+                "posted_at": event_data.get("posted_at"),
                 "details": task_data.get("description"),
                 "notes": event_data.get("content"),
                 "is_deleted": (
@@ -231,11 +232,12 @@ class EmacsWebhookView(APIView):
                 status=status.HTTP_304_NOT_MODIFIED,
             )
 
-        if task_in_progress and post_data.get("notes"):
+        if scrobble and scrobble.in_progress:
             emacs_scrobble_update_task(
                 post_data.get("source_id"),
-                post_data.get("notes"),
+                post_data.get("notes") or [],
                 user_id,
+                description=post_data.get("body"),
             )
 
         self.logger.info(

vrobbler/apps/videogames/templatetags/naturalduration.py

@@ -8,21 +8,20 @@ def natural_duration(value):
     if not value:
         return
     value = int(value)
-    total_minutes = int(value / 60)
-    hours = int(total_minutes / 60)
-    minutes = total_minutes - (hours * 60)
-    seconds = value % 60
-    value_str = ""
-    if seconds:
-        value_str = f"{seconds} seconds"
-    if minutes:
-        if value_str:
-            value_str = f"{minutes} minutes, " + value_str
-        else:
-            value_str = f"{minutes} minutes"
+    days = int(value / 86400)
+    remainder = value % 86400
+    hours = int(remainder / 3600)
+    minutes = int((remainder % 3600) / 60)
+    seconds = remainder % 60
+    parts = []
+    if days:
+        parts.append(f"{days} day{'s' if days != 1 else ''}")
     if hours:
-        if value_str:
-            value_str = f"{hours} hours, " + value_str
-        else:
-            value_str = f"{hours} hours"
-    return value_str
+        parts.append(f"{hours} hour{'s' if hours != 1 else ''}")
+    if minutes:
+        parts.append(f"{minutes} minute{'s' if minutes != 1 else ''}")
+    if seconds or not parts:
+        parts.append(f"{seconds} second{'s' if seconds != 1 else ''}")
+    if len(parts) == 1:
+        return parts[0]
+    return ", ".join(parts[:-1]) + " and " + parts[-1]

vrobbler/apps/videos/sources/imdb.py

@@ -1,48 +0,0 @@
-import logging
-
-from cinemagoerng import web as imdb
-from videos.metadata import VideoMetadata, VideoType
-
-logger = logging.getLogger(__name__)
-
-
-def lookup_video_from_imdb(imdb_id: str) -> VideoMetadata:
-    if not imdb_id.startswith("tt"):
-        logger.warning("This method requires an IMDB ID starting with 'tt'")
-        return VideoMetadata()
-
-    video_metadata = VideoMetadata(imdb_id=imdb_id)
-    imdb_result: dict = {}
-
-    imdb_result = imdb.get_title(imdb_id)
-    logger.debug(f"Found result from IMDB: {imdb_result.title}")
-
-    if not imdb_result:
-        logger.info(
-            f"[lookup_video_from_imdb] no video found on imdb",
-            extra={"name_or_id": name_or_id},
-        )
-        return None
-
-    if imdb_result.type_id.lower() in ["movie", "tvepisode"]:
-        video_metadata.base_run_time_seconds = imdb_result.runtime * 60
-    video_metadata.imdb_id = imdb_id
-    video_metadata.title = imdb_result.title
-    video_metadata.year = imdb_result.year
-    video_metadata.plot = imdb_result.plot.get("en-US", "")
-    video_metadata.imdb_rating = imdb_result.rating
-    video_metadata.genres = imdb_result.genres
-    video_metadata.cover_url = imdb_result.primary_image
-
-    video_metadata.video_type = VideoType.MOVIE.value
-    if imdb_result.type_id == "tvEpisode":
-        video_metadata.video_type = VideoType.TV_EPISODE.value
-
-        series = imdb_result.series
-        video_metadata.tv_series_imdb_id = series.imdb_id
-        video_metadata.tv_series_title = series.title
-        video_metadata.episode_number = imdb_result.episode
-        video_metadata.season_number = imdb_result.season
-        video_metadata.next_imdb_id = imdb_result.next_episode_id
-
-    return video_metadata

vrobbler/context_processors.py

@@ -14,11 +14,12 @@ def version_info(request):
     if not commit:
         # Try to import from _commit.py module first
         try:
-            from vrobbler._commit import commit
+            from vrobbler._commit import commit as _commit
         except ImportError:
             pass
         else:
-            return {"app_version": app_version, "git_commit": commit}
+            if _commit and _commit != "unknown":
+                return {"app_version": app_version, "git_commit": _commit}
 
         # Try to read from commit file (written during deploy)
         commit_file = Path("/var/lib/vrobbler/commit.txt")

vrobbler/settings.py

@@ -144,7 +144,7 @@ CELERY_BEAT_SCHEDULE = {
     },
     "import-from-webdav": {
         "task": "scrobbles.tasks.import_from_webdav_all_users",
-        "schedule": crontab(minute="*/5"),
+        "schedule": crontab(minute="*/3"),
     },
     # Deprecated: BG Stats files now picked up from WebDAV var/bgstats/
     # "import-from-imap": {
@@ -244,6 +244,7 @@ TEMPLATES = [
                 "videos.context_processors.video_lists",
                 "music.context_processors.music_lists",
                 "scrobbles.context_processors.now_playing",
+                "scrobbles.context_processors.month_color",
                 "vrobbler.context_processors.version_info",
             ],
         },

vrobbler/templates/base.html

@@ -138,9 +138,9 @@
         */
 
         .navbar-brand {
-        padding-top: .75rem;
-        padding-bottom: .75rem;
-        font-size: 1rem;
+        padding-top: .5rem;
+        padding-bottom: .5rem;
+        font-size: 1.3rem;
         background-color: rgba(0, 0, 0, .25);
         box-shadow: inset -1px 0 0 rgba(0, 0, 0, .25);
         }
@@ -168,6 +168,35 @@
         }
         #scrobble-form { width: 100% }
 
+        .notes-list {
+            max-width: 600px;
+        }
+
+        .note-item {
+            padding: 4px 0;
+        }
+
+        .note-timestamp {
+            font-size: 0.8em;
+            color: #666;
+            margin: 0 0 4px;
+        }
+
+        .note-content {
+            font-size: 0.95em;
+            line-height: 1.5;
+        }
+
+        .note-content p:last-child {
+            margin-bottom: 0;
+        }
+
+        .note-divider {
+            margin: 8px 0;
+            border: 0;
+            border-top: 1px solid #ddd;
+        }
+
         .sticky-notes-container {
             display: flex;
             flex-wrap: wrap;
@@ -198,12 +227,41 @@
         .sticky-note:nth-child(5n) {
             background: #e1bee7;
         }
+
+        .sidebar {
+            background-color: color-mix(in srgb, var(--accent) 8%, #f8f9fa) !important;
+        }
+        .sidebar .nav-link.active {
+            color: var(--accent) !important;
+        }
+        .navbar-brand {
+            background-color: color-mix(in srgb, var(--accent) 70%, #000) !important;
+            color: var(--accent) !important;
+        }
+        .sidebar .nav-link:hover {
+            color: var(--accent);
+        }
+        a:not(.nav-link):not(.btn):not(.page-link) {
+            color: color-mix(in srgb, var(--accent) 70%, #000);
+        }
+        a:not(.nav-link):not(.btn):not(.page-link):hover {
+            color: var(--accent);
+        }
+        a.badge {
+            color: #fff !important;
+        }
+        .table-striped > tbody > tr:nth-of-type(odd) {
+            background-color: color-mix(in srgb, var(--accent) 6%, #fff);
+        }
+        .table > tbody > tr:hover {
+            background-color: color-mix(in srgb, var(--accent) 10%, #fff);
+        }
         </style>
         {% block head_extra %}{% endblock %}
 
         <link rel="apple-touch-icon" href="{% static 'images/apple-touch-icon.png' %}">
     </head>
-    <body>
+    <body style="--accent:{{ month_color|default:'#db7a7a' }}">
         <header class="navbar navbar-dark sticky-top bg-dark flex-md-nowrap p-0 shadow">
             <a class="navbar-brand col-md-3 col-lg-2 me-0 px-3" href="/">Vrobbler</a>
             <button class="navbar-toggler position-absolute d-md-none collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#sidebarMenu" aria-controls="sidebarMenu" aria-expanded="false" aria-label="Toggle navigation">

vrobbler/templates/base_list.html

@@ -13,7 +13,6 @@
             </div>
             <div class="btn-group me-2">
               <a href="{% url 'charts:charts-home' %}" class="btn btn-sm btn-outline-secondary">Charts</a>
-              <a href="{% url 'charts:spotify-tracks' %}" class="btn btn-sm btn-outline-secondary">Spotify Tracks</a>
             </div>
             {% endif %}
             <div class="btn-group me-2">

vrobbler/templates/charts/bandcamp_tracks.html

@@ -0,0 +1,34 @@
+{% extends "base_list.html" %}
+
+{% block title %}Bandcamp Tracks{% endblock %}
+
+{% block head_extra %}
+<style>
+    .container { margin-bottom: 100px; }
+</style>
+{% endblock %}
+
+{% block lists %}
+<div class="row">
+    <div class="col-12">
+        <h2>🎵 Top Bandcamp Tracks</h2>
+        <p class="text-muted">Shows tracks scrobbled from Bandcamp via Mopidy</p>
+    </div>
+</div>
+
+<div class="row">
+    <div class="col-md-6 col-lg-4 chart-section">
+        <ul class="list-group">
+            {% for item in bandcamp_tracks %}
+            <li class="list-group-item d-flex justify-content-between align-items-center">
+                <span class="me-2"><strong>#{{ forloop.counter }}</strong></span>
+                <a href="{{ item.track.get_absolute_url }}">{{ item.track.title }}</a>
+                <span class="badge bg-success rounded-pill">{{ item.count }}</span>
+            </li>
+            {% empty %}
+            <li class="list-group-item">No Bandcamp tracks found.</li>
+            {% endfor %}
+        </ul>
+    </div>
+</div>
+{% endblock %}

vrobbler/templates/charts/chart_index.html

@@ -17,6 +17,13 @@
 
 {% block lists %}
 
+<div class="row mb-3">
+    <div class="col-12">
+        <a href="{% url 'charts:spotify-tracks' %}" class="btn btn-sm btn-outline-secondary">🎵 Spotify Tracks</a>
+        <a href="{% url 'charts:bandcamp-tracks' %}" class="btn btn-sm btn-outline-secondary">🎵 Bandcamp Tracks</a>
+    </div>
+</div>
+
 {% if chart_type == "maloja" %}
 {% include "scrobbles/_top_charts.html" %}
 {% else %}
@@ -24,9 +31,16 @@
 <div class="row">
     <div class="col-12">
         <div class="btn-group mb-3" role="group">
-            {% if year %}<a href="?date={{year}}{% if month %}-{{month}}{% endif %}" class="btn btn-outline-secondary{% if not week and not day %} active{% endif %}">{{year}}{% if month %} {{month|date:"F"}}{% endif %}</a>{% endif %}
-            {% if week %}<span class="btn btn-outline-secondary active">Week {{week}}</span>{% endif %}
-            {% if day %}<span class="btn btn-outline-secondary active">{{day}}</span>{% endif %}
+            <a href="?date={{ year }}" class="btn btn-outline-secondary{% if period_type == 'year' %} active{% endif %}">{{ year }}</a>
+            {% if month %}
+            <a href="?date={{ year }}-{{ month|stringformat:'02d' }}" class="btn btn-outline-secondary{% if period_type == 'month' %} active{% endif %}">{{ month_name }}</a>
+            {% endif %}
+            {% if week %}
+            <a href="?date={{ year }}-W{{ week|stringformat:'02d' }}" class="btn btn-outline-secondary{% if period_type == 'week' %} active{% endif %}">Week {{ week }}</a>
+            {% endif %}
+            {% if day %}
+            <a href="?date={{ year }}-{{ month|stringformat:'02d' }}-{{ day|stringformat:'02d' }}" class="btn btn-outline-secondary{% if period_type == 'day' %} active{% endif %}">{{ day }}</a>
+            {% endif %}
         </div>
         <span class="ms-2">
             {% if period_type == "day" %}
@@ -50,6 +64,30 @@
     </div>
 </div>
 
+{% if period_type == "month" and month %}
+<div class="row mb-2">
+    <div class="col-12">
+        <small class="text-muted me-2">Time machine:</small>
+        {% for y in chart_years %}
+        {% if y != year %}
+        <a href="?date={{ y }}-{{ month|stringformat:'02d' }}" class="btn btn-xs btn-outline-secondary" style="padding:1px 4px;font-size:10px;">{{ y }}</a>
+        {% endif %}
+        {% endfor %}
+    </div>
+</div>
+{% elif period_type == "week" and week %}
+<div class="row mb-2">
+    <div class="col-12">
+        <small class="text-muted me-2">Time machine:</small>
+        {% for y in chart_years %}
+        {% if y != year %}
+        <a href="?date={{ y }}-W{{ week|stringformat:'02d' }}" class="btn btn-xs btn-outline-secondary" style="padding:1px 4px;font-size:10px;">{{ y }}</a>
+        {% endif %}
+        {% endfor %}
+    </div>
+</div>
+{% endif %}
+
 <div class="row">
     {% if charts.artist %}
     <div class="col-md-6 col-lg-4 chart-section">
@@ -220,7 +258,7 @@
             {% for chart in charts.trail|slice:":20" %}
             <li class="list-group-item d-flex justify-content-between align-items-center">
                 <span class="me-2"><strong>#{{chart.rank}}</strong></span>
-                <a href="{{chart.trail.get_absolute_url}}">{{chart.trail.name}}</a>
+                <a href="{{chart.trail.get_absolute_url}}">{{chart.trail.title}}</a>
                 <span class="badge bg-primary rounded-pill">{{chart.count}}</span>
             </li>
             {% endfor %}

vrobbler/templates/music/album_list.html

@@ -56,7 +56,7 @@
                     <tr>
                         <td>{{album.scrobbles.count}}</td>
                         <td><a href="{{album.get_absolute_url}}">{{album}}</a></td>
-                        <td><a href="{{album.album_artist.get_absolute_url}}">{{album.album_artist}}</a></td>
+                        <td><a href="{{album.artist.get_absolute_url}}">{{album.artist}}</a></td>
                     </tr>
                     {% endfor %}
                 </tbody>

vrobbler/templates/music/artist_detail.html

@@ -29,6 +29,14 @@
             {% if artist.bandcamp_link %}<a href="{{artist.bandcamp_link}}"><img src="{% static "images/bandcamp-logo.png" %}" width=35></a>{% endif %}
             {% if artist.allmusic_link %}<a href="{{artist.allmusic_link}}"><img src="{% static "images/allmusic-logo.png" %}" width=35></a>{% endif %}
         </p>
+        <p>
+            {% if artist.theaudiodb_genre %}
+            <a href="{% url "music:artist_list" %}?genre={{artist.theaudiodb_genre|urlencode}}">{{artist.theaudiodb_genre}}</a> ({{genre_count}}){% if artist.theaudiodb_mood %} &middot; {% endif %}
+            {% endif %}
+            {% if artist.theaudiodb_mood %}
+            <a href="{% url "music:artist_list" %}?mood={{artist.theaudiodb_mood|urlencode}}">{{artist.theaudiodb_mood}}</a> ({{mood_count}})
+            {% endif %}
+        </p>
     </div>
 </div>
 <div class="row">
@@ -37,6 +45,29 @@
     {% include "scrobbles/_chart_links.html" %}
     {% endif %}
     <div class="col-md">
+        {% if similar_artists %}
+        <h3>Similar artists</h3>
+        <div class="table-responsive">
+            <table class="table table-striped table-sm">
+            <thead>
+                <tr>
+                    <th scope="col">Artist</th>
+                    <th scope="col">Score</th>
+                    <th scope="col"></th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for sa in similar_artists %}
+                <tr>
+                    <td>{% if sa.local_url %}<a href="{{sa.local_url}}">{{sa.name}}</a>{% else %}{{sa.name}}{% endif %}</td>
+                    <td>{{sa.score}}</td>
+                    <td>{% if sa.musicbrainz_url %}<a href="{{sa.musicbrainz_url}}">musicbrainz</a>{% endif %}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+            </table>
+        </div>
+        {% endif %}
         <h3>Top tracks</h3>
         <div class="table-responsive">
             <table class="table table-striped table-sm">

vrobbler/templates/music/track_detail.html

@@ -14,6 +14,29 @@
     {% include "scrobbles/_chart_links.html" %}
     {% endif %}
     <div class="col-md">
+        {% if object.similar_recordings %}
+        <h3>Similar recordings</h3>
+        <div class="table-responsive">
+            <table class="table table-striped table-sm">
+                <thead>
+                    <tr>
+                        <th scope="col">Track</th>
+                        <th scope="col">Artist</th>
+                        <th scope="col">Score</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {% for sr in object.similar_recordings|slice:":10" %}
+                    <tr>
+                        <td><a href="https://musicbrainz.org/recording/{{sr.recording_mbid}}">{{sr.recording_name}}</a></td>
+                        <td>{{sr.artist_credit_name}}</td>
+                        <td>{{sr.score}}</td>
+                    </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+        {% endif %}
         <h3>Last scrobbles</h3>
         <div class="table-responsive">
             <table class="table table-striped table-sm">

vrobbler/templates/scrobbles/calendar.html

@@ -144,6 +144,33 @@ header.navbar { display: none !important; }
 .calendar-footer a:hover {
     color: #fff;
 }
+
+@media (max-width: 768px) {
+    .calendar-wrapper {
+        padding: 4px;
+        overflow-y: auto;
+    }
+    .calendar-grid {
+        grid-template-columns: 1fr;
+        flex: none;
+    }
+    .month-banner {
+        grid-column: 1;
+        font-size: 1.4rem;
+        padding: 12px 10px;
+        gap: 12px;
+    }
+    .month-banner a { font-size: 1.1rem; }
+    .day-header { display: none; }
+    .day-cell {
+        min-height: auto;
+        padding: 8px 10px;
+        border-bottom: 1px solid {{ month_color }}33;
+    }
+    .day-cell[style*="background:transparent"] { display: none; }
+    .day-number { margin-bottom: 2px; }
+    .calendar-footer { grid-column: 1; }
+}
 </style>
 {% endblock %}
 
@@ -164,8 +191,6 @@ header.navbar { display: none !important; }
             {{ month_name }} {{ year }}
             <a href="?date={{ next_month }}{% if active_filter %}&media_type={{ active_filter }}{% endif %}">&rarr;</a>
         </div>
-        <div style="grid-column:1/-1;text-align:center;padding:4px 0;background:{{ month_color }};">
-        </div>
 
         {% for name in day_names %}
         <div class="day-header">{{ name }}</div>

vrobbler/templates/scrobbles/scrobble_all_list.html

@@ -9,6 +9,9 @@
             <h1 class="h2">All Scrobbles</h1>
             {% if tag_list %}
             <h6 class="text-muted">Tagged {{ tag_list|join:", " }}</h6>
+            {% if total_time_seconds %}
+            <p class="text-muted small mb-0">Total time: {{ total_time_seconds|natural_duration }}</p>
+            {% endif %}
             {% endif %}
         </div>
     </div>

vrobbler/templates/scrobbles/scrobble_detail.html

@@ -26,6 +26,21 @@
             height: 400px;
             border-radius: 4px;
         }
+        .heart-icon {
+            cursor: pointer;
+            transition: fill 0.2s, stroke 0.2s;
+        }
+        .heart-icon.favorited {
+            fill: #e74c3c;
+            stroke: #e74c3c;
+        }
+        .heart-icon:not(.favorited) {
+            fill: none;
+            stroke: #888;
+        }
+        .heart-icon:not(.favorited):hover {
+            stroke: #e74c3c;
+        }
         </style>
 {% endblock %}
 
@@ -33,13 +48,36 @@
 
 <div class="row">
 
-<h1>
+<h1 class="d-flex align-items-center gap-2">
 {% if object.media_type == "Video" %}🎬{% elif object.media_type == "Track" %}🎵{% elif object.media_type == "PodcastEpisode" %}🎙️{% elif object.media_type == "SportEvent" %}⚽{% elif object.media_type == "Book" %}📚{% elif object.media_type == "Paper" %}📄{% elif object.media_type == "VideoGame" %}🎮{% elif object.media_type == "BoardGame" %}🎲{% elif object.media_type == "GeoLocation" %}📍{% elif object.media_type == "Trail" %}🥾{% elif object.media_type == "Beer" %}🍺{% elif object.media_type == "Puzzle" %}🧩{% elif object.media_type == "Food" %}🍔{% elif object.media_type == "Task" %}✅{% elif object.media_type == "WebPage" %}🌐{% elif object.media_type == "LifeEvent" %}🎉{% elif object.media_type == "Mood" %}😊{% elif object.media_type == "BrickSet" %}🧱{% elif object.media_type == "Channel" %}📺{% endif %}
-{% if object.media_obj.get_absolute_url %}<a href="{{ object.media_obj.get_absolute_url }}">{% endif %}{{ object.media_obj }}{% if object.media_obj.get_absolute_url %}</a>{% endif %}</h1>
+{% if object.media_obj.get_absolute_url %}<a href="{{ object.media_obj.get_absolute_url }}">{% endif %}{{ object.media_obj }}{% if object.media_obj.get_absolute_url %}</a>{% endif %}
+{% if user.is_authenticated and object.media_obj %}
+<button id="favorite-btn"
+  data-url="{% url 'scrobbles:toggle-favorite' object.media_type object.media_obj.id %}"
+  data-favorited="{{ is_favorited|yesno:'true,false' }}"
+  class="btn btn-sm p-0 border-0 bg-transparent">
+  <svg width="20" height="20" viewBox="0 0 24 24" class="heart-icon{% if is_favorited %} favorited{% endif %}" id="heart-svg">
+    <path d="M12 21.35l-1.45-1.32C5.4 15.36 2 12.28 2 8.5 2 5.42 4.42 3 7.5 3c1.74 0 3.41.81 4.5 2.09C13.09 3.81 14.76 3 16.5 3 19.58 3 22 5.42 22 8.5c0 3.78-3.4 6.86-8.55 11.54L12 21.35z"/>
+  </svg>
+</button>
+{% endif %}
+</h1>
 {% if object.media_type == "Task" and object.logdata.title %}
 <h2>{{ object.logdata.title }}</h2>
 {% endif %}
 <h3 class="text-muted">{{ object.local_timestamp }}</h3>
+{% if object.media_type == "Track" and has_mopidy_uri and user.profile.mopidy_api_url %}
+<form method="post" action="{% url 'scrobbles:add-to-mopidy-queue' object.uuid %}" class="mb-1">
+  {% csrf_token %}
+    <button type="submit" class="btn btn-sm btn-outline-secondary">add to mopidy queue</button>
+</form>
+{% if user.profile.monthly_mopidy_playlist_pattern %}
+<form method="post" action="{% url 'scrobbles:add-to-mopidy-monthly-playlist' object.uuid %}" class="mb-1">
+  {% csrf_token %}
+    <button type="submit" class="btn btn-sm btn-outline-secondary">add to monthly playlist</button>
+</form>
+{% endif %}
+{% endif %}
 {% if object.media_type == "Track" %}
 <p class="text-muted small">Source: {{ object.source }}{% if object.log.mopidy_source %} ({{ object.log.mopidy_source|capfirst }}){% endif %}</p>
 {% endif %}
@@ -115,8 +153,8 @@
 {% with notes_html=object.logdata.notes_as_html %}
 {% if notes_html %}
 <div class="mb-3">
-  <h5>Notes</h5>
-  <div class="sticky-notes-container">
+  <h4>Notes</h4>
+  <div class="notes-list">
     {{ notes_html|safe }}
   </div>
 </div>
@@ -220,6 +258,30 @@
 {% block extra_js %}
 {{ block.super }}
 {{ log_form.media }}
+<script>
+function getCookie(name) {
+    let value = "; " + document.cookie;
+    let parts = value.split("; " + name + "=");
+    if (parts.length === 2) return parts.pop().split(";").shift();
+}
+document.getElementById("favorite-btn")?.addEventListener("click", function() {
+    var btn = this;
+    var url = btn.dataset.url;
+    fetch(url, {
+        method: "POST",
+        headers: {
+            "X-CSRFToken": getCookie("csrftoken"),
+            "X-Requested-With": "XMLHttpRequest",
+        },
+    })
+    .then(function(r) { return r.json(); })
+    .then(function(data) {
+        var heart = document.getElementById("heart-svg");
+        btn.dataset.favorited = data.is_favorited ? "true" : "false";
+        heart.classList.toggle("favorited", data.is_favorited);
+    });
+});
+</script>
 {% if object.media_type == "Trail" and object.gpx_file %}
 <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/leaflet-gpx@2.2.0/gpx.min.js"></script>

vrobbler/templates/tasks/task_detail.html

@@ -2,6 +2,7 @@
 {% load mathfilters %}
 {% load static %}
 {% load naturalduration %}
+{% load l10n %}
 
 {% block title %}{{object.title}}{% endblock %}
 
@@ -39,6 +40,15 @@
         </p>
     </div>
 </div>
+
+{% if weighin_chart %}
+<div class="row mb-4">
+    <div class="col-md-8">
+        <canvas id="weighinChart" width="800" height="300"></canvas>
+    </div>
+</div>
+{% endif %}
+
 <div class="row">
     <p>{{scrobbles.count}} scrobbles</p>
     <p>
@@ -94,3 +104,61 @@
     {% endif %}
 </div>
 {% endblock %}
+
+{% block extra_js %}
+{% if weighin_chart %}
+<script src="https://cdn.jsdelivr.net/npm/chart.js@2.9.4/dist/Chart.min.js"></script>
+<script>
+var ctx = document.getElementById('weighinChart').getContext('2d');
+new Chart(ctx, {
+    type: 'line',
+    data: {
+        labels: {{ weighin_chart.labels|safe }},
+        datasets: [
+            {
+                label: 'Weight',
+                data: {{ weighin_chart.datasets.0.data|safe }},
+                borderColor: '{{ weighin_chart.datasets.0.borderColor }}',
+                backgroundColor: 'transparent',
+                pointRadius: 2,
+                fill: false,
+                yAxisID: 'y',
+            },
+            {
+                label: 'Body Fat %',
+                data: {{ weighin_chart.datasets.1.data|safe }},
+                borderColor: '{{ weighin_chart.datasets.1.borderColor }}',
+                backgroundColor: 'transparent',
+                pointRadius: 2,
+                fill: false,
+                yAxisID: 'y1',
+            },
+            {
+                label: 'BMI',
+                data: {{ weighin_chart.datasets.2.data|safe }},
+                borderColor: '{{ weighin_chart.datasets.2.borderColor }}',
+                backgroundColor: 'transparent',
+                pointRadius: 2,
+                fill: false,
+                yAxisID: 'y2',
+            },
+        ]
+    },
+    options: {
+        responsive: true,
+        scales: {
+            xAxes: [{
+                ticks: { maxTicksLimit: 25, maxRotation: 45 },
+            }],
+            yAxes: [
+                { id: 'y', type: 'linear', position: 'left', scaleLabel: { display: true, labelString: 'Weight' } },
+                { id: 'y1', type: 'linear', position: 'right', scaleLabel: { display: true, labelString: 'Body Fat %' }, gridLines: { display: false } },
+                { id: 'y2', type: 'linear', position: 'right', scaleLabel: { display: true, labelString: 'BMI' }, gridLines: { display: false } },
+            ]
+        },
+        legend: { position: 'bottom' },
+    }
+});
+</script>
+{% endif %}
+{% endblock %}