[release] Bump to version 57.1

- Write poetry lock file

PROJECT.org

@@ -88,7 +88,7 @@ fetching and simple saving.
 *** Metadata sources
 **** Scraper
 
-* Backlog [0/19] :vrobbler:project:personal:
+* Backlog [0/22] :vrobbler:project:personal:
 ** TODO [#C] Create small utility to clean up tracks scrobbled with wonky playback times :bug:music:scrobbles:
 :PROPERTIES:
 :ID:       702462cf-d54b-48c6-8a7c-78b8de751deb
@@ -579,6 +579,318 @@ named constants for maintainability.
   - ~vrobbler/apps/scrobbles/importers/tsv.py~ (line 55) -- ="S"= completion status
 
     
+** TODO [#A] Deduplicate BGG plays before posting :boardgames:bgg:duplication:
+:PROPERTIES:
+:ID:       e9b842bf-0049-42e7-a060-f3ebd0067d2f
+:END:
+
+*** Description
+
+No check for existing BGG plays before posting, which can create duplicates.
+Should look up past plays by =bggeek_id= first.
+  
+File: ~vrobbler/apps/boardgames/bgg.py~ (line 117)
+
+** TODO [#C] Clean up naming of =bgsplay= parsing :importers:refactoring:
+:PROPERTIES:
+:ID:       c751dbbc-464a-4e63-9fe3-e034303f7b54
+:END:
+
+*** Description
+
+We should rename `email_scrobble_board_game` to reflect the fact that it's just
+a helper method to create board game scrobbles given a json blob. It's
+independent of the email flow it was originally creatdd for
+
+** TODO [#B] Is there way to create unique slugs for media instances :media_types:
+
+* Version 57.1 [1/1]
+** DONE [#A] Write poetry lock file :bug:deps:
+:PROPERTIES:
+:ID:       0f5a6f4b-a486-ba7e-bbce-f7581274398c
+:END:
+
+* Version 57.0 [5/5]
+** DONE [#A] Scrobble button on some media list pages dont work :bug:scrobbles:
+:PROPERTIES:
+:ID:       a3a5c707-2e3d-a6b1-0f7f-4c6f7433aa1f
+:END:
+** DONE [#B] Use HTMx to update the Now Playing widget :feature:templates:
+:PROPERTIES:
+:ID:       5f5631fc-9ee1-d5a5-d0f8-94fea6fbbfa4
+:END:
+** DONE [#B] Add a live page that updates the scrobble list via JS polling :feature:templates:
+:PROPERTIES:
+:ID:       58790d76-dc6e-8aa5-2dc0-e64fe786fbf1
+:END:
+** DONE [#A] Turns out we cant cache the now playing widget :bug:templates:
+:PROPERTIES:
+:ID:       9ce669ea-c000-cdfe-a634-ad5cdaeae81c
+:END:
+** DONE [#C] What would it look like to add an MCP server to expose scrobbles and media items? :mcpserver:feature:
+:PROPERTIES:
+:ID:       c5fca159-c7e0-5795-7c05-bbc48f539650
+:END:
+
+* Version 56.4 [3/3]
+** DONE [#B] Add ability to do reverse address lookup on lat-long pairs :geolocations:feature:
+:PROPERTIES:
+:ID:       86c071ff-7638-41ba-6b65-1382df1cb5aa
+:END:
+** DONE [#B] Add address fields to GeoLocation :addresses:geolocation:
+:PROPERTIES:
+:ID:       a55ae508-07ab-ccdd-e453-846bd3fca6fb
+:END:
+** DONE [#B] Add better detail template for Disc Golf Courses :discgolf:templates:
+:PROPERTIES:
+:ID:       12cee67c-f723-0fa3-848a-cbc6e4d65fc3
+:END:
+
+* Version 56.3 [1/1]
+** DONE [#A] Fix bug in importer script from discgolf being added :bug:
+:PROPERTIES:
+:ID:       c3733f96-18f1-eef8-f5d9-edaf97e35623
+:END:
+
+* Version 56.2 [1/1]
+** DONE [#A] Fix bug in creating people when importing course plays :discgolf:bug:
+:PROPERTIES:
+:ID:       255e9886-098b-39ae-1077-25e43223660e
+:END:
+
+* Version 56.1 [1/1]
+** DONE [#A] Add tests to discgolf app :discgolf:tests:
+:PROPERTIES:
+:ID:       28e8344e-c3cf-19af-ce1c-cb821d4fcb5f
+:END:
+
+* Version 56.0 [1/1]
+** DONE [#B] Add DiscGolf as a scrobbleable media :discgolf:
+:PROPERTIES:
+:ID:       8cdde5d3-0ae5-7d5a-99d2-200c86afae03
+:END:
+
+*** Description
+
+I have a csv file fro the uDisc disc golf scoring app that looks like:
+
+Singles round. Note second row is the par for the course
+#+begin_src csv
+PlayerName,CourseName,LayoutName,StartDate,EndDate,Total,+/-,RoundRating,Hole1,Hole2,Hole3,Hole4,Hole5,Hole6,Hole7,Hole8,Hole9
+Par,DR Front 9,Custom Layout,2026-06-19 1535-0400,2026-06-19 1725-0400,27,,,3,3,3,3,3,3,3,3,3
+Colin Powell,DR Front 9,Custom Layout,2026-06-19 1535-0400,2026-06-19 1725-0400,30,3,,2,3,4,4,3,4,3,3,4
+Asa Sewell,DR Front 9,Custom Layout,2026-06-19 1535-0400,2026-06-19 1725-0400,44,17,,5,4,4,8,5,5,4,4,5
+Emma Sweet,DR Front 9,Custom Layout,2026-06-19 1535-0400,2026-06-19 1725-0400,41,14,,5,4,5,6,3,4,3,5,6
+Jane Sewell,DR Front 9,Custom Layout,2026-06-19 1535-0400,2026-06-19 1725-0400,44,17,,4,5,5,5,5,5,4,6,5
+Nabby Sewell,DR Front 9,Custom Layout,2026-06-19 1535-0400,2026-06-19 1725-0400,59,32,,6,6,7,7,6,7,6,6,8
+Silas Sewell,DR Front 9,Custom Layout,2026-06-19 1535-0400,2026-06-19 1725-0400,41,14,,5,5,4,5,3,5,4,4,6`
+#+end_src
+
+Teams of two or more persons. Note second row is the par for the course
+#+begin_src csv
+PlayerName,CourseName,LayoutName,StartDate,EndDate,Total,+/-,RoundRating,Hole1,Hole2,Hole3,Hole4,Hole5,Hole6,Hole7,Hole8,Hole9
+Par,Peninsula Links,Main,2026-06-19 2322-0400,2026-06-19 2323-0400,27,,,3,3,3,3,3,3,3,3,3
+Colin Powell + Asa Sewell,Peninsula Links,Main,2026-06-19 2322-0400,2026-06-19 2323-0400,29,2,,3,4,2,3,2,3,5,3,4
+Emma Sweet + Jane Sewell,Peninsula Links,Main,2026-06-19 2322-0400,2026-06-19 2323-0400,28,1,,4,3,4,2,3,4,3,3,2
+#+end_src
+
+We should add a new app called discgolf that has the following data models:
+
+- DiscGolfRound - scrobblable media + course_id, round_type (Singles, Teams)
+- DiscGolfCourse - name, layoutname, number_of_holes
+
+And the logdata for a DiscGolfOuting scrobble should have:
+  + {person: {hole_number: score}, total: int}
+  + {team: {name: "", people: [person, person], hole_number: score}, total: int}
+  + weather
+  + fun_factor (miserable, not great, so-so, good, excellent,  party time)
+
+
+* Version 55.6 [1/1]
+** DONE [#A] Figure out why historical Lastfm imports don't work :importers:lastfm:music:
+:PROPERTIES:
+:ID:       71b18c1b-de96-6d93-20fa-de2ec0df1288
+:END:
+
+* Version 55.5 [1/1]
+** DONE [#B] Fix bug in lastfm import for new users :importers:lastfm:music:
+:PROPERTIES:
+:ID:       d034966d-0c7f-e512-4cf8-7329c9026b6f
+:END:
+
+* Version 55.4 [1/1]
+** DONE [#A] Tighten up the speed of startup and first request :perf:
+:PROPERTIES:
+:ID:       9ee8834c-6be2-d04b-df6d-56375504083f
+:END:
+
+
+* Version 55.3 [3/3]
+** DONE [#C] =alt_names= feature for artists (commented out / dead code) :music:dead-code:
+:PROPERTIES:
+:ID:       e22060a2-5f7a-4f33-9056-309ecd27159c
+:END:
+
+*** Description
+
+File: ~vrobbler/apps/music/models.py~ (line 236)
+
+An entire block of code for tracking alternate artist names is commented
+out. The TODO questions whether it even works. Review: either implement
+properly or remove the dead code.
+    
+** DONE [#A] Put chart rebuilds in a lower priority task queue :charts:tasks:
+:PROPERTIES:
+:ID:       43c90de0-fc1c-1139-dac7-9b7c82006b2e
+:END:
+** DONE [#A] Check for existing book scrobble and update page count :books:scrobbling:
+:PROPERTIES:
+:ID:       1a0609bc-6b16-4da4-96c1-59588229e4b4
+:END:
+
+*** Description
+
+File: ~vrobbler/apps/scrobbles/scrobblers.py~ (line 330)
+
+When scrobbling a book (comic), the code doesn't check for prior scrobbles to
+update reading progress. Needed for proper page-count tracking.
+
+
+* Version 55.2 [2/2]
+** DONE [#A] Fix bug in scrobble id in calendar view :templates:
+:PROPERTIES:
+:ID:       8cb34852-b18f-e794-cd9b-fb1ecad70a0d
+:END:
+** DONE [#A] Video game cleanup script should clear out broken images :metadata:videogames:
+:PROPERTIES:
+:ID:       ca1f1ea9-0f79-082c-5ff7-867671faff4b
+:END:
+
+* Version 55.1 [1/1]
+** DONE [#A] Clean up metadata scrapping for video games :metadata:videogames:
+:PROPERTIES:
+:ID:       fbc421b5-21a3-4aed-9062-c59192ead065
+:END:
+
+* Version 55.0 [3/3]
+** DONE [#B] Use pk ID for scrobble detail view, not uuid :scrobbles:
+:PROPERTIES:
+:ID:       9cc3b285-e478-041e-394b-3d550aefbe1d
+:END:
+** DONE [#B] Display videogame screenshots on scrobble detail if they exist :videogames:templates:
+:PROPERTIES:
+:ID:       0406d082-20f6-0d12-76e2-f281c4801468
+:END:
+** DONE [#B] Add autotagging to webpages based on domain, title :webpages:metadata:
+:PROPERTIES:
+:ID:       f658435b-f7a0-42e6-b9f6-226678a77a55
+:END:
+
+*** Description
+
+For easier filtering, like we do with tasks, we should auto tag WebPage instances
+based on the domain name split part by periods (so news.ycombinator.com tags: news, ycombinator, com)
+
+And also based on the nouns in the title.
+
+
+* Version 54.5 [1/1]
+** DONE Fix bug in generating mood trends :trends:
+:PROPERTIES:
+:ID:       8e75abfa-8e70-d85b-00a4-a4813bbce879
+:END:
+
+* Version 54.4 [2/2]
+** DONE [#A] Remove all-time trends :trends:
+:PROPERTIES:
+:ID:       53b231d1-7677-8cd3-1d88-dae110aba1e6
+:END:
+
+*** Description
+
+All time trends take forever to calculate and don't provide too much data
+
+** DONE [#B] Add a trend around moods :moods:trends:
+:PROPERTIES:
+:ID:       fba3f4ae-8f97-ee0b-e762-31630884518a
+:END:
+
+* Version 54.3 [1/1]
+** DONE [#B] Fix bug in series metadata cleanup script :videos:metadta:
+:PROPERTIES:
+:ID:       85448702-907c-5d63-f5af-7795661d7c46
+:END:
+
+* Version 54.2 [4/4]
+** DONE [#B] Add script to clean up TV series metadata :videos:metadata:
+:PROPERTIES:
+:ID:       a468b328-59d9-f84b-9ddb-087216783453
+:END:
+** DONE [#A] Update youtube video detail pages with links to channel :videos:templates:
+:PROPERTIES:
+:ID:       8b87cb42-09e5-a3f5-136f-182f967fa81f
+:END:
+** DONE [#A] Concurrent reading trend does not consolidate on single book :trends:reading:
+:PROPERTIES:
+:ID:       fe220f55-7e0d-2a17-2477-a5aa7c4a1f2c
+:END:
+** DONE [#B] Trends dont seem to look very far back :trends:
+:PROPERTIES:
+:ID:       ffcfba3f-5a93-9ee0-9680-666e6eccd684
+:END:
+
+*** Description
+
+Specificially, looking at reading-pace when run on prod, it claims that I've
+only had one reading session without music. Which may be true, but perhaps we
+need to indicate what the time frame we're looking at is (month, week, year)
+and provide a way to jump back and forward through time, same as charts.
+
+
+* Version 54.1 [1/1]
+** DONE [#A] Concurrent listening trend is inefficient and should be disabled :trends:scrobbles:
+:PROPERTIES:
+:ID:       4aa3b719-6b22-cae9-85f0-fac67b4fc753
+:END:
+
+* Version 54.0 [3/3]
+** DONE [#B] Add peak hour, weekly rhythm and activity dist trends :trends:scrobbles:
+:PROPERTIES:
+:ID:       5fa52fac-d5f0-4369-bcaa-589c886b07d3
+:END:
+
+** DONE [#A] Implement YouTube channel info scraping :videos:youtube:stub:
+:PROPERTIES:
+:ID:       1d3beafd-62cb-4735-a465-edb37bf885db
+:END:
+
+*** Description
+File: ~vrobbler/apps/videos/models.py~ (line 140)
+
+=Video.fix_metadata()= is a stub that logs "Not implemented yet" and returns.
+Needs actual implementation to scrape channel metadata from YouTube.
+
+** DONE [#A] Fix Amazon book scraper :amazon:scraper:broken:
+:PROPERTIES:
+:ID:       c38aba25-0171-49ab-a9f3-acf2003da429
+:END:
+
+*** Description
+
+File: ~vrobbler/apps/books/amazon.py~ (line 56)
+
+The =scrape_data_from_amazon()= function is likely broken due to Amazon blocking
+scrapers and changing HTML structure. Needs rewrite or replacement with a proper
+API.
+
+
+* Version 53.1 [1/1]
+** DONE [#A] Error with loading logdict :scrobbles:bug:logdata:
+:PROPERTIES:
+:ID:       92d4fa16-4b90-47e0-95ae-472bdca582ce
+:END:
+
+
 * Version 53.0 [5/5]
 ** DONE [#B] Add a /trends/ page that shows trends based on scrobble data :feature:trends:scrobbles:
 :PROPERTIES:

Procfile

@@ -1,2 +1,2 @@
 web: python manage.py runserver 0.0.0.0:8014
-worker: celery -A vrobbler worker -l DEBUG
+worker: celery -A vrobbler worker -Q default,charts -l DEBUG

poetry.lock

@@ -1512,6 +1512,25 @@ files = [
     {file = "django_mathfilters-1.0.0-py3-none-any.whl", hash = "sha256:64200a21bb249fbf27be601d4bbb788779e09c6e063170c097cd82c4d18ebb83"},
 ]
 
+[[package]]
+name = "django-mcp-server"
+version = "0.5.7"
+description = "Django MCP Server is a Django extensions to easily enable AI Agents to interact with Django Apps through the Model Context Protocol it works equally well on WSGI and ASGI"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "django_mcp_server-0.5.7-py3-none-any.whl", hash = "sha256:04b58bf02623aaee59708c3661ffe17981acd4532587c38b6cfe2c9e7090c6d3"},
+    {file = "django_mcp_server-0.5.7.tar.gz", hash = "sha256:5077f8fabf5fb621b5ce490afd0db60f21e57b3a451ed14a9f44aef545ea4eee"},
+]
+
+[package.dependencies]
+django = ">=4.0"
+djangorestframework = ">=3.15.0"
+inflection = ">=0.5.1,<0.6.0"
+mcp = ">=1.8.0"
+uritemplate = ">=4.1.1,<5.0.0"
+
 [[package]]
 name = "django-oauth-toolkit"
 version = "3.2.0"
@@ -2156,6 +2175,18 @@ http2 = ["h2 (>=3,<5)"]
 socks = ["socksio (==1.*)"]
 zstd = ["zstandard (>=0.18.0)"]
 
+[[package]]
+name = "httpx-sse"
+version = "0.4.3"
+description = "Consume Server-Sent Event (SSE) messages with HTTPX."
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc"},
+    {file = "httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d"},
+]
+
 [[package]]
 name = "idna"
 version = "3.11"
@@ -2196,6 +2227,18 @@ perf = ["ipython"]
 test = ["packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"]
 type = ["pytest-mypy (>=1.0.1) ; platform_python_implementation != \"PyPy\""]
 
+[[package]]
+name = "inflection"
+version = "0.5.1"
+description = "A port of Ruby on Rails inflector to Python"
+optional = false
+python-versions = ">=3.5"
+groups = ["main"]
+files = [
+    {file = "inflection-0.5.1-py2.py3-none-any.whl", hash = "sha256:f38b2b640938a4f35ade69ac3d053042959b62a0f1076a5bbaa1b9526605a8a2"},
+    {file = "inflection-0.5.1.tar.gz", hash = "sha256:1a29730d366e996aaacffb2f1f1cb9593dc38e2ddd30c91250c6dde09ea9b417"},
+]
+
 [[package]]
 name = "iniconfig"
 version = "2.3.0"
@@ -2399,6 +2442,43 @@ files = [
     {file = "jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d"},
 ]
 
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+description = "An implementation of JSON Schema validation for Python"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce"},
+    {file = "jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326"},
+]
+
+[package.dependencies]
+attrs = ">=22.2.0"
+jsonschema-specifications = ">=2023.03.6"
+referencing = ">=0.28.4"
+rpds-py = ">=0.25.0"
+
+[package.extras]
+format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"]
+format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "rfc3987-syntax (>=1.1.0)", "uri-template", "webcolors (>=24.6.0)"]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe"},
+    {file = "jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d"},
+]
+
+[package.dependencies]
+referencing = ">=0.31.0"
+
 [[package]]
 name = "jstyleson"
 version = "0.0.2"
@@ -2745,6 +2825,48 @@ files = [
     {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
 ]
 
+[[package]]
+name = "mcp"
+version = "1.28.0"
+description = "Model Context Protocol SDK"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "mcp-1.28.0-py3-none-any.whl", hash = "sha256:9c1e7cf3a9125557e418ecd4fed8e9adddce81b0dfdae4d6601d700f5beb71a4"},
+    {file = "mcp-1.28.0.tar.gz", hash = "sha256:559d3f9943674cafbe5744c5d3794f3237e8b47f9bbc58e20c0fad680d8487c2"},
+]
+
+[package.dependencies]
+anyio = ">=4.5"
+httpx = ">=0.27.1,<1.0.0"
+httpx-sse = ">=0.4"
+jsonschema = ">=4.20.0"
+pydantic = [
+    {version = ">=2.11.0,<3.0.0", markers = "python_version < \"3.14\""},
+    {version = ">=2.12.0,<3.0.0", markers = "python_version >= \"3.14\""},
+]
+pydantic-settings = ">=2.5.2"
+pyjwt = {version = ">=2.10.1", extras = ["crypto"]}
+python-multipart = ">=0.0.9"
+pywin32 = [
+    {version = ">=310", markers = "sys_platform == \"win32\" and python_version < \"3.14\""},
+    {version = ">=311", markers = "sys_platform == \"win32\" and python_version >= \"3.14\""},
+]
+sse-starlette = ">=1.6.1"
+starlette = [
+    {version = ">=0.27", markers = "python_version < \"3.14\""},
+    {version = ">=0.48.0", markers = "python_version >= \"3.14\""},
+]
+typing-extensions = ">=4.9.0"
+typing-inspection = ">=0.4.1"
+uvicorn = {version = ">=0.31.1", markers = "sys_platform != \"emscripten\""}
+
+[package.extras]
+cli = ["python-dotenv (>=1.0.0)", "typer (>=0.16.0)"]
+rich = ["rich (>=13.9.4)"]
+ws = ["websockets (>=15.0.1)"]
+
 [[package]]
 name = "mdurl"
 version = "0.1.2"
@@ -3980,6 +4102,30 @@ files = [
 [package.dependencies]
 typing-extensions = ">=4.14.1"
 
+[[package]]
+name = "pydantic-settings"
+version = "2.14.2"
+description = "Settings management using Pydantic"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "pydantic_settings-2.14.2-py3-none-any.whl", hash = "sha256:a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440"},
+    {file = "pydantic_settings-2.14.2.tar.gz", hash = "sha256:c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f"},
+]
+
+[package.dependencies]
+pydantic = ">=2.7.0"
+python-dotenv = ">=0.21.0"
+typing-inspection = ">=0.4.0"
+
+[package.extras]
+aws-secrets-manager = ["boto3 (>=1.35.0)", "types-boto3[secretsmanager]"]
+azure-key-vault = ["azure-identity (>=1.16.0)", "azure-keyvault-secrets (>=4.8.0)"]
+gcp-secret-manager = ["google-cloud-secret-manager (>=2.23.1)"]
+toml = ["tomli (>=2.0.1)"]
+yaml = ["pyyaml (>=6.0.1)"]
+
 [[package]]
 name = "pyflakes"
 version = "3.4.0"
@@ -4270,6 +4416,29 @@ six = "*"
 [package.extras]
 testing = ["filelock"]
 
+[[package]]
+name = "python-amazon-paapi"
+version = "6.3.0"
+description = "Amazon Product Advertising API 5.0 wrapper for Python"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "python_amazon_paapi-6.3.0-py3-none-any.whl", hash = "sha256:b7cd852084a49d53c3ba2195531fccbc8c7f4124b2e82e2fda02b53d3b8de521"},
+    {file = "python_amazon_paapi-6.3.0.tar.gz", hash = "sha256:e525d69efcbe4f9566ec2b9b43fa3183c484d166d3852edb38b4df9c0b19cf1f"},
+]
+
+[package.dependencies]
+certifi = ">=2023.0.0"
+pydantic = ">=2.0.0"
+python-dateutil = ">=2.8.0"
+requests = ">=2.28.0"
+six = ">=1.16.0"
+urllib3 = ">=1.26.0,<3"
+
+[package.extras]
+async = ["httpx (>=0.27.0)", "typing-extensions (>=4.15.0)"]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
@@ -4307,14 +4476,14 @@ testing = ["covdefaults (>=2.3)", "coverage (>=7.5.4)", "pytest (>=8.3.5)", "pyt
 
 [[package]]
 name = "python-dotenv"
-version = "0.20.0"
+version = "1.2.2"
 description = "Read key-value pairs from a .env file and set them as environment variables"
 optional = false
-python-versions = ">=3.5"
+python-versions = ">=3.10"
 groups = ["main"]
 files = [
-    {file = "python-dotenv-0.20.0.tar.gz", hash = "sha256:b7e3b04a59693c42c36f9ab1cc2acc46fa5df8c78e178fc33a8d4cd05c8d498f"},
+    {file = "python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a"},
-    {file = "python_dotenv-0.20.0-py3-none-any.whl", hash = "sha256:d92a187be61fe482e4fd675b6d52200e7be63a12b724abbf931a40ce4fa92938"},
+    {file = "python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3"},
 ]
 
 [package.extras]
@@ -4332,6 +4501,18 @@ files = [
     {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"},
 ]
 
+[[package]]
+name = "python-multipart"
+version = "0.0.32"
+description = "A streaming multipart parser for Python"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23"},
+    {file = "python_multipart-0.0.32.tar.gz", hash = "sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e"},
+]
+
 [[package]]
 name = "python3-openid"
 version = "3.2.0"
@@ -4363,6 +4544,38 @@ files = [
     {file = "pytz-2022.7.1.tar.gz", hash = "sha256:01a0681c4b9684a28304615eba55d1ab31ae00bf68ec157ec3708a8182dbbcd0"},
 ]
 
+[[package]]
+name = "pywin32"
+version = "312"
+description = "Python for Windows Extensions"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+markers = "sys_platform == \"win32\""
+files = [
+    {file = "pywin32-312-cp310-cp310-win32.whl", hash = "sha256:772235332b5d1024c696f11cea1ae4be7930f0a8b894bb43db14e3f435f1ff7e"},
+    {file = "pywin32-312-cp310-cp310-win_amd64.whl", hash = "sha256:5dbc35d2b5320dc07f25fa31269cfb767471002b17de5eb067d03da68c7cb2db"},
+    {file = "pywin32-312-cp310-cp310-win_arm64.whl", hash = "sha256:3020656e34f1cf7faeb7bccd2b84653a607c6ff0c55ada85e6487d61716deabd"},
+    {file = "pywin32-312-cp311-cp311-win32.whl", hash = "sha256:17948aeadbdb091f0ced6ef0841620794e68327b94ee415571c1203594b7215c"},
+    {file = "pywin32-312-cp311-cp311-win_amd64.whl", hash = "sha256:d11417d84412f859b722fad0841b3614459ed0047f7542d8362e77884f6b6e8a"},
+    {file = "pywin32-312-cp311-cp311-win_arm64.whl", hash = "sha256:b2200a054ca6d6625c4842fc56a4976a4b47f96b73dbe5538c3f813a80359f47"},
+    {file = "pywin32-312-cp312-cp312-win32.whl", hash = "sha256:dab4f65ac9c4e48400a2a0530c46c3c579cd5905ecd11b80692373915269208b"},
+    {file = "pywin32-312-cp312-cp312-win_amd64.whl", hash = "sha256:b457f6d628a47e8a7346ce22acb7e1a46a4a78b52e1d17e1af56871bd19a93bc"},
+    {file = "pywin32-312-cp312-cp312-win_arm64.whl", hash = "sha256:6017c58e12f6809fbb0555b75df144c2922a9ffd18e4b9b5afa863b6c1a9d950"},
+    {file = "pywin32-312-cp313-cp313-win32.whl", hash = "sha256:7a27df850933d16a8eabfbaeb73d52b273e2da667f80d70b01a89d1f6828d02c"},
+    {file = "pywin32-312-cp313-cp313-win_amd64.whl", hash = "sha256:c53e878d15a1c44788082bfe712a905433473aa38f86375b7cf8b45e3acbaaf9"},
+    {file = "pywin32-312-cp313-cp313-win_arm64.whl", hash = "sha256:59aba5d5940842075343a5ddc6b11f1cdf0d1567fe745290359dfbcc7c2eb831"},
+    {file = "pywin32-312-cp314-cp314-win32.whl", hash = "sha256:a77a90fbb6881238d2ca9c6fd797b25817f3768fe78d214a90137ff055a75f5b"},
+    {file = "pywin32-312-cp314-cp314-win_amd64.whl", hash = "sha256:a4dd3a848290ef724347b19f301045831d8e802fa4464f491b98b1e0a081432e"},
+    {file = "pywin32-312-cp314-cp314-win_arm64.whl", hash = "sha256:9fce94568364e0155e6dfb781ac5d95903be8baf28670632beab1b523f300daa"},
+    {file = "pywin32-312-cp315-cp315-win32.whl", hash = "sha256:5c1fbe4a937a73ae9297384a3da38518cbc694c68ad8a809b2e19acd350f03ed"},
+    {file = "pywin32-312-cp315-cp315-win_amd64.whl", hash = "sha256:c2f03a0f73f804a13c2735b99392b0cd426bb4f2c4d0178e5ac966a0f21618d5"},
+    {file = "pywin32-312-cp315-cp315-win_arm64.whl", hash = "sha256:a8597d28f267b39074aef51fa593530082b39cbe5a074226096857b1fed2dfb9"},
+    {file = "pywin32-312-cp39-cp39-win32.whl", hash = "sha256:d620900033cc7531e50727c3c8333091df5dd3ffe6d68cdca38c03f5821408d5"},
+    {file = "pywin32-312-cp39-cp39-win_amd64.whl", hash = "sha256:dc90147579a905b8635e1b0ec6514967dcb07e6e0d9c42f1477feef14cac23bb"},
+    {file = "pywin32-312-cp39-cp39-win_arm64.whl", hash = "sha256:02ebca0f0242b75292e218065004310d6a477407c09fa449bfe4f6022bc0c0fc"},
+]
+
 [[package]]
 name = "pywin32-ctypes"
 version = "0.2.3"
@@ -4623,6 +4836,23 @@ async-timeout = {version = ">=4.0.2", markers = "python_full_version <= \"3.11.2
 hiredis = ["hiredis (>=1.0.0)"]
 ocsp = ["cryptography (>=36.0.1)", "pyopenssl (==20.0.1)", "requests (>=2.26.0)"]
 
+[[package]]
+name = "referencing"
+version = "0.37.0"
+description = "JSON Referencing + Python"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231"},
+    {file = "referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8"},
+]
+
+[package.dependencies]
+attrs = ">=22.2.0"
+rpds-py = ">=0.7.0"
+typing-extensions = {version = ">=4.4.0", markers = "python_version < \"3.13\""}
+
 [[package]]
 name = "regex"
 version = "2026.2.28"
@@ -4851,6 +5081,146 @@ pygments = ">=2.13.0,<3.0.0"
 [package.extras]
 jupyter = ["ipywidgets (>=7.5.1,<9)"]
 
+[[package]]
+name = "rpds-py"
+version = "2026.5.1"
+description = "Python bindings to Rust's persistent data structures (rpds)"
+optional = false
+python-versions = ">=3.11"
+groups = ["main"]
+files = [
+    {file = "rpds_py-2026.5.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:3397a5ed7174dc2786bb214030232fc36fe8e5584fec43a9952cc542b1a12036"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:99ab6ba7bfa2cb0f96a04e3652355bf04e3f51aceb1e943b8541dab7ba4828cc"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0efbe45632665e53e3db8fe1e5692db58fc5cb9bab4459d570b83efefe11164"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:01d17b29c0c23d82b1f4751147ec49cf451f1fc2554eb9ef5f957e55d2656ead"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7559f72b94ae52659086c595dfa017cde03155f7832071d30959049052cb3ece"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e25b7088f9ccbfc0dfcaa52bf969300ca229e10ecf758974ebcbb080a4b37bb"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:613fc4ee9eaef26dc5840666214dd6fbcebcf32f46e76f4abc473059f4e13dda"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:85264a90ff4c05c1568dd65f5921c837614b67c60358fb4c17df3b7f2e90690a"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe71bca7d547acb17027c7fd1624ff8aae623499c498d3e7011182c4de5c25e0"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05fa4f41f37ec97c9c260441a940450a192f78d774d2b097eee1379f1e1246a"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df1d2a1996755b24b9ecee92cb4d36c28f86f464a6a173349c26bab41e94b8c2"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8895840ac4809e5f60c88fd07617cd71326e73d6e5a8aa783c5c0f7c24985de2"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-win32.whl", hash = "sha256:3684a59b158a7683aaeb8e25352e9a9dd2122cec78f2d8530266e4f91b4c7b3f"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:7bd530e6a530bb3ea892f194fafa455f3516ac25ecf7143fd33c09be62b0470a"},
+    {file = "rpds_py-2026.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:0a5ae4dbe43c1076983b72616496919872ae7bbe7a1e21cc48336bc3154d130b"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3abe24a66e57adcfa645d718063a5fa5103ecc71ddbf26d78af8f9368018ff1d"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:58b1d94308ddf0b1982f61f2eb54bf92997c9ece8a8093ef014250f4a517906c"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fa92420128dadce7f54bd73ba1825a273e9268fe9e35dbf7e6362890efa4e08"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ca653c6546386227cd9800d1bef6a348099acf8db4250341da6d90f663d6dfcb"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66c93681c4729e4e3ecba31b8179fae083ff3118841672835140338b4b9867c1"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40ff257542e04796880e011e15cd4dc21c2599975df2aaa8f2c8495ca574e1a5"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6825cc329b290e93c5f6a9be2393118a763f6ccf6abd83704e0c102ca583644"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:de42116e69cb53b911cc34aee5ab98f36c597b822545045d49e938818b99e5e4"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c0f920015df2a504bebaba6d4c31ccf3fcf942f92655c086da30b671aad19aa6"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0408a24e44feb919423dc6d9da677cb5cddb894d2ca9e763967d156d9c60fab4"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cea68bcd53467561ae2f96a6bdad1544299ba97b5b0ddcd5ac3d376e5c781c24"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4be8b1d2a705cc37d08256004e1d07de143fa0075c8e85a3df020b776f62b732"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-win32.whl", hash = "sha256:6736718bd4fc49cbcb538ba30516fdbef161522acefb739657d48b97bd864fed"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:0a7d1eec967df0e9b22614a5e177622e0c89611d03727fa0cb48e45028907870"},
+    {file = "rpds_py-2026.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:1841d067089e117142d79b98aa0df2f08b52f2ecc1819dd2700636c0db74a473"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:efef4ac29c6ff495531eb17ee705b62841ecaa291b7c7077e848ea03e237164d"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c39f5b67a8a2e67179ada2a954227d670fe65fa9098457f698f56ddf248709b3"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5c30f3f04eef4fbd362226a6f31d7c8895ca4fbb6e0b790f6890a98d8da8559"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:277f6c82f0580848796c7ecc8a7173aa3bfb928e4ff831261c2f60a81dc270db"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:63c2c4c213f1a4e3f3de28ecab029dbdee976324e729c0d7a55211be72576b02"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3350ec808fb538fe71a1f94dfaa0e29c598dfad805ce49f0caec5ae3183c652b"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b1b964e3ab599e718dc46c018d104b1ebc007cbc6567d827c94a687fca56d77e"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:19cb09fab7b7fc96b2a6e28f2e34b72a3705ff27b37edb77455316e5d3f3dc9b"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:abe76bcdba31e576cb83eeb8797aa0d882b738fef6dc65d0601fc753806a5b46"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8bff7073db3899158fff55ebf57b113a67030af26f80a18978f9f0aa60250ddf"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:8ba264fa49be666cd9cc56bf34ec7002fb3d27a4aee5bcb4d43d0d18feb1bb6f"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4860b603ddda0475a8885499b3729e90229d480105b42651962a5397d995fa89"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-win32.whl", hash = "sha256:7944270ae71383f6e2657dd7d5ce4eeb4ac2d0059a6738f0510583d462ab4842"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:88647f43a73c4e01be19b04ceef0c8d3a1958153604d13c773becd8016f2a0cf"},
+    {file = "rpds_py-2026.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:453895624ecf7db7063b1004e44037522bbaef9ff6a945e59bc71662d7a03abd"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:b4e4bc98639ec915f512fde3aa7a95e0041d95d9c3cc86eea841fa63cb1e8600"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cacedb7a6e167680acba45ad5716e89067d225dc80da0d7040cae8c81d4572fa"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68700371c5d7ae1412862ddfa719090925c93ecf351c566d66f09d04b136ea00"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:296c799becfa849c779c8725494fe9ed94959ed886787df4364b058465bad7f0"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d3858b908218ee108d0bbfb2095ccc237648053c9bf98affad7cb079acaf1d97"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4fb8d2e7cb2f850b169806d61d1b991738acec96500a75c30f49caf064ce7cef"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:27b74c10ed6a8f190f4287f53bcfea348b92a84a9c9f70d30183d1e6172d580d"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:b9a6528956191c48c52294a592dbd4a8386d7048bdb25c0efcb6b966466c6d83"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:af03e34e860047bc7a352b842856fcf78798fbb81132cc98bd2f907ab4eb9cd2"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:fea6e836d10abbe191d557d33bd58bd5987725fe63aa1eefe557d230209855bd"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:fc0c0f878ea770a0a8a462456c5ad36fc9fe6358e6b76fdadc7f17575e0b8bf1"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e0b360f316d966b048b085857630b3cc51f3db2f07b06f440eac8f695374d1e3"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-win32.whl", hash = "sha256:a2999883eedf72fdfb7520b92c7d4ec2572a71ff40239377aa604cc529eecafc"},
+    {file = "rpds_py-2026.5.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e07be2a9d7122bd6e82dea89814ef8dc893feb1aae97fec1630f3263bbb30e55"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:1f2c391c3059798093b65df23aca2cac150460ae9c630d99dec83d703d9485b9"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:413b424f7c4ee65ab5e5be91f5731be0f8b41a1ee2b12dfe810d716312e95a78"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c595a1d9255dce0599e13130d1440ab2506654f2b50294226ee06402f8fef63"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1c27c5f6102eac8c03e7595a00827a53b271ba40a53b59ff8709170e0855ea4a"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c7fcf61d44cacecaf3aea542b0e053db77972a4573e7ceda16fb2b399161195"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2c817a189d4ee14290420e5ff051e4dd6baa13f3edf84685071dee07a6d538ee"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21846aac0ed2e0589f38c12dc44e77bb64e494b771eadbcf169cba00566ba7ba"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b317c87a13f769a4e787819bd508aaa5d69aa09b0880de9af6d3a8a54571cdec"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce87129d9f2c14fa6c4a8601fb80eb4488c80d38a20cd13758ef11123e14995d"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9cdddb6c1207d284d94fd1530adf57fbd797fe7c4b8704ba85f49414f2557e7d"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:4e237e139f94d3c036fd28eb9f564c99055476ff4ff05cd42be55ce349b5aa02"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ed0954b524873214369184a9c82b0eaa45a3fbb9a798cd95b17e0d98499e7ea0"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-win32.whl", hash = "sha256:2d88621d6a7d4dfa633d21abe90f280bb205274e16b1d1e61c6ad4640b2453b7"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:cef8ac28d26f4dda3533060c20fbf80a325458fa9fd23ea72a73cdfa8e978838"},
+    {file = "rpds_py-2026.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:eaaea962c68cdc68d4a533ba985ab8e9484277910bbfaa2ab3ef7732667bfed8"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:21942f52dbbd5f8758bf021213d28bd45c39e873e65e2407faf5f1846f5761ad"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f414556f6e3958300ff941e40c9f97e3dc9774ddd1b3434c475d73dd354bbed3"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ef1013a8625c74043210190b246f5b1551e09757c1f356c6e4160ef96c5bc081"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cc68e231a77a5f0d774ae278a1f8e55c0456501820847c1e4efb3829f3441df6"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9baffb505aff33acc69b422a19f77806680f3c8632227d79f48de8a810d1c2c5"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8d2f912928d426e8cfa396f7f3f8d29a59e6689c86dcca3c420730c1096322b"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90f628283be835db980c941767d41c9a27b5239e54ba0a9c1335247e82406964"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:1ebb2f0ab7e16132995a72de805170e0203df0c3dd22e1ef1cd1fdd90bd7a131"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f3df3d16ded76f1f8c9cdebd0e1ea55fdf4c23b812de189814da7cf229c22a81"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9af8905b8f854990e40d5206aa5ac58d9b0fe0b7f351ff2bb086c20f6c8c6a47"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:036a36a87fb1cd3b214d11c4b3c4f7d2ddad933625dca1c900b56a057c07740a"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:62ae3853454fe9ef283a03c96c2d835d39e84b14643a9d62c82ef0fb87d702ca"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-win32.whl", hash = "sha256:6c3d771a46ec18b12af06ce36243a9a80b07a5d0515236332d90863ca8bb326a"},
+    {file = "rpds_py-2026.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c93c629be4636cf54337bd5f06c104d55e42ced54d681f6fe21ae510a65116f6"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:3574b55c604b8f75dacb007136508bbc0db406e626301778096a133327e7f2fb"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:94068eb3ae6d43f5a786b7db96a406a34e6d5c24489feef32fd6e8946ea7b291"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a5b10e8ce894825f380a8f1b6444cf73c294dfea62afbb2d13e3a9e630cec1"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fc09f82e63d4bcd58149572f857a431bae851dc747e313c3b5bdf7abb907fda8"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e10464d17df3b582745c25cec695cb9558bca2cb6ddb631aee1787fc72c767b2"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ba05adbf15d994c38ec0b7ab32e858e5110c21e9009a00a86545fd220f84e038"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77c004fdc7b891967106f78ddfd7b076bfe6813c6139c6fff6aed3bcaa960b26"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:83bcf894486c9d78dd290d3c0124ff6dd8875d3025e2090a8ec49fcc37c55fdd"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c3df104083952a0e0c6f10de33e440eabe98fb6317d23e1a58c68f6df08d01b9"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:980450826cf22e133c57e0835070bdd0dd3f73b9b708c3ce223def2cb9469e14"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:205dde846f24332ab0c1188699a043b8d165b79bb84529ce272c45048ff6be01"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:3966b82dd563176396df030f3dd52a6e54cb69b718e95e78bd555ed3d1e0185d"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-win32.whl", hash = "sha256:7818f8d0a415be74d2be3590b0a1c1f463a642f4d0217e7d10602dceef5b79aa"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:b3cc20c0d800af78fd0fac68086e28c1856cec51ea528bb81ea851aa40d39325"},
+    {file = "rpds_py-2026.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:3609e9939a8a76cd904cf98a3f1f13b5dc7e150adeaee89e0ea09652ea213e16"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:5d333a7127d4b307601ac37792bee01bb95c867cbfacf21b6375b804d6bbd723"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:b5f077b44a4f7808520f66dae234988d867deb9aed9be5da057ce9ba831b2a41"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55d8f9b7b78c9538fc9e04e82ec0e888ff0c3cffcfad152c77e57cd09351a98a"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e3a8ae58895ac107ed934a6bf51e5846f95c53b9b940c2c6d310838fd5846358"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0957cf3c2b8632ec7aaebffebea8005b353cc2a237b6e2ae3c2cac0820704cfb"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c396c1304de421050b3681ea70f371874b54d41b0151e96109758144c231e30b"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aad1bff7f666b9598e573815affd666aac6a13a585dde336f843e33350c7fadc"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:656a042550878f12d45752452d47094b7cfe5ad1e9d7b87b5a22ad3ae5ff8015"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:73c4bd4f70294737b5206a3e8e30ccadbf8a60301831c8ea23eec5dbeea1ecfa"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:43bca78665423cabae77146f2fe7ce55272b6c8d55d82cca83effd42c7e13972"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:42d0f20e85e549c870749d0e247f0c10d318a45b7e9676d575d2dcb04a1b2e66"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:b1be5c35683684d5331b93600c210e8367c254683d8a6df6bd21bd2da3a334fb"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-win32.whl", hash = "sha256:75808f6c38ce7749bb68cc2770161aae5045e6c6f6781a9782e74b93304399df"},
+    {file = "rpds_py-2026.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:90bd6630002a1c7f09e7843dd79f0d24f3d2897cc25a753480917865d14f15b3"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:edf2765d84e42447f112ad877af8fe1db0089aaec5b28e88d6eab45e7fe99cea"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ad3773236e95f7f33991eb125224b7da66f206504d032a253a02da7e134519fb"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a04df86b3f0fade39ec8fd0e0aab089b1da9fbd2b48df778a57ef96f5e7d38df"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6142dbd80c4df62a5d899f0d616d417f84e0bc8d32526c8e5589019d75d028a7"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0b35217adefe87f2fe4db7e9766cabe84744bfe9616d9667be18988928c7f2dc"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b95d5e11fc712b752081183a55a244c03cd00570489edd7014d8899f8ceb8162"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:141c9498daf2ace9eda35d2b0e376f9ea8b058d84f2aef4f96fccfd449a2f251"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:6f249f8b860a200ad35193af961183ebe9132710484e6f6ce0cf89fd83c63a9a"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e4abbf391a70be864920858bf360f4fb380577c9a0f732438a1996726e2c195b"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:c74005a7bb87752acf351c93897ec63ad77a07a0da7ecad9c050e32e7286ba34"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:8213afbe8a3a906fb9acb2014423fe3359ee783d0bf90995f70623a3217bfa6c"},
+    {file = "rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:8c43a8a973270fd173bf48cdf80bbe66312421cba68d40845034f174f2389049"},
+    {file = "rpds_py-2026.5.1.tar.gz", hash = "sha256:07b24fea40541e28570e5b795a4a38fbdcd12550c06bd0748005ecc8116ca256"},
+]
+
 [[package]]
 name = "s3transfer"
 version = "0.16.0"
@@ -4994,6 +5364,29 @@ files = [
 dev = ["build"]
 doc = ["sphinx"]
 
+[[package]]
+name = "sse-starlette"
+version = "3.4.5"
+description = "SSE plugin for Starlette"
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "sse_starlette-3.4.5-py3-none-any.whl", hash = "sha256:e71bad53323f65573c3864a6c3bd0c1eb6e5f092b2e48082b0c35927d19ca296"},
+    {file = "sse_starlette-3.4.5.tar.gz", hash = "sha256:83072538bc211a2f68b7b0422226c4af3e9b62e106e07034664b832ca019842a"},
+]
+
+[package.dependencies]
+anyio = ">=4.7.0"
+starlette = ">=0.49.1"
+
+[package.extras]
+daphne = ["daphne (>=4.2.0)"]
+examples = ["fastapi (>=0.115.12)", "pydantic (>=2)", "uvicorn (>=0.34.0)"]
+examples-db = ["aiosqlite (>=0.21.0)", "sqlalchemy[asyncio] (>=2.0.41)"]
+granian = ["granian (>=2.3.1)"]
+uvicorn = ["uvicorn (>=0.34.0)"]
+
 [[package]]
 name = "stack-data"
 version = "0.6.3"
@@ -5014,6 +5407,25 @@ pure-eval = "*"
 [package.extras]
 tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"]
 
+[[package]]
+name = "starlette"
+version = "1.3.1"
+description = "The little ASGI library that shines."
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+files = [
+    {file = "starlette-1.3.1-py3-none-any.whl", hash = "sha256:c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6"},
+    {file = "starlette-1.3.1.tar.gz", hash = "sha256:05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0"},
+]
+
+[package.dependencies]
+anyio = ">=3.6.2,<5"
+typing-extensions = {version = ">=4.10.0", markers = "python_version < \"3.13\""}
+
+[package.extras]
+full = ["httpx (>=0.27.0,<0.29.0)", "httpx2 (>=2.0.0)", "itsdangerous", "jinja2", "python-multipart (>=0.0.18)", "pyyaml"]
+
 [[package]]
 name = "stevedore"
 version = "5.7.0"
@@ -5416,6 +5828,18 @@ tzdata = {version = "*", markers = "platform_system == \"Windows\""}
 [package.extras]
 devenv = ["check-manifest", "pytest (>=4.3)", "pytest-cov", "pytest-mock (>=3.3)", "zest.releaser"]
 
+[[package]]
+name = "uritemplate"
+version = "4.2.0"
+description = "Implementation of RFC 6570 URI Templates"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "uritemplate-4.2.0-py3-none-any.whl", hash = "sha256:962201ba1c4edcab02e60f9a0d3821e82dfc5d2d6662a21abd533879bdb8a686"},
+    {file = "uritemplate-4.2.0.tar.gz", hash = "sha256:480c2ed180878955863323eea31b0ede668795de182617fef9c6ca09e6ec9d0e"},
+]
+
 [[package]]
 name = "url-normalize"
 version = "2.2.1"
@@ -5451,6 +5875,26 @@ brotli = ["brotli (==1.0.9) ; os_name != \"nt\" and python_version < \"3\" and p
 secure = ["certifi", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "ipaddress ; python_version == \"2.7\"", "pyOpenSSL (>=0.14)", "urllib3-secure-extra"]
 socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"]
 
+[[package]]
+name = "uvicorn"
+version = "0.49.0"
+description = "The lightning-fast ASGI server."
+optional = false
+python-versions = ">=3.10"
+groups = ["main"]
+markers = "sys_platform != \"emscripten\""
+files = [
+    {file = "uvicorn-0.49.0-py3-none-any.whl", hash = "sha256:ba3d14c3ee7e41c6c654c46c9eb489d33213cdd30aa1696eab1374337c13f68f"},
+    {file = "uvicorn-0.49.0.tar.gz", hash = "sha256:ebf4271aa580d9de97f93192d4595176df6e91f9aae919ca73e4fc07df1e66a3"},
+]
+
+[package.dependencies]
+click = ">=7.0"
+h11 = ">=0.8"
+
+[package.extras]
+standard = ["colorama (>=0.4) ; sys_platform == \"win32\"", "httptools (>=0.8.0)", "python-dotenv (>=0.13)", "pyyaml (>=5.1)", "uvloop (>=0.15.1) ; sys_platform != \"win32\" and sys_platform != \"cygwin\" and platform_python_implementation != \"PyPy\"", "watchfiles (>=0.20)", "websockets (>=10.4)"]
+
 [[package]]
 name = "vadersentiment"
 version = "3.3.2"
@@ -6032,4 +6476,4 @@ cffi = ["cffi (>=1.17,<2.0) ; platform_python_implementation != \"PyPy\" and pyt
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.11,<3.15"
-content-hash = "cc5b3b44071d6b0ab4f05189580232cc129b4ed694ab3f0673c3d838c3af0f8a"
+content-hash = "02f8b551a54c53fa2a51622af17ef844e40aa8505c395ed02a7b87eb05647cc5"

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vrobbler"
-version = "53.0"
+version = "57.1"
 description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]
 
@@ -9,7 +9,7 @@ python = ">=3.11,<3.15"
 Django = "^4.0.3"
 django-extensions = "^3.1.5"
 python-dateutil = "^2.8.2"
-python-dotenv = "^0.20.0"
+python-dotenv = ">=0.20.0,<2"
 python-json-logger = "^2.0.2"
 colorlog = "^6.6.0"
 httpx = "<=0.27.2"
@@ -43,6 +43,7 @@ ipython = "^8.14.0"
 pendulum = "^3"
 trafilatura = "^1.6.3"
 django-imagekit = "^5.0.0"
+django-mcp-server = "^0.5.7"
 thefuzz = "^0.22.1"
 dataclass-wizard = "^0.35.0"
 webdavclient3 = "^3.14.6"
@@ -64,6 +65,7 @@ fitparse = "^1.2.0"
 lxml = ">=5.5.0"
 vaderSentiment = "^3.3.2"
 sqids = "^0.5.2"
+python-amazon-paapi = "^6.3.0"
 
 [tool.poetry.group.test]
 optional = true

tests/discgolf_tests/conftest.py

@@ -0,0 +1,63 @@
+import tempfile
+
+import pytest
+from django.contrib.auth import get_user_model
+
+User = get_user_model()
+
+
+@pytest.fixture
+def user(db):
+    return User.objects.create(email="golfer@example.com")
+
+
+@pytest.fixture
+def udisc_singles_csv_content():
+    return """PlayerName,CourseName,LayoutName,StartDate,Hole1,Hole2,Hole3,Total
+Par,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",3,3,3,9
+Alice,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",4,2,3,9
+Bob,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",3,4,5,12
+"""
+
+
+@pytest.fixture
+def udisc_singles_csv_file(udisc_singles_csv_content):
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".csv", delete=False, encoding="utf-8-sig"
+    ) as f:
+        f.write(udisc_singles_csv_content)
+        return f.name
+
+
+@pytest.fixture
+def udisc_teams_csv_content():
+    return """PlayerName,CourseName,LayoutName,StartDate,Hole1,Hole2,Hole3,Total
+Par,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",3,3,3,9
+Alice+Bob,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",4,2,3,9
+Charlie+Diana,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",3,4,5,12
+"""
+
+
+@pytest.fixture
+def udisc_teams_csv_file(udisc_teams_csv_content):
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".csv", delete=False, encoding="utf-8-sig"
+    ) as f:
+        f.write(udisc_teams_csv_content)
+        return f.name
+
+
+@pytest.fixture
+def udisc_csv_no_par_content():
+    return """PlayerName,CourseName,LayoutName,StartDate,Hole1,Hole2,Hole3,Total
+Alice,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",4,2,3,9
+"""
+
+
+@pytest.fixture
+def udisc_csv_no_par_file(udisc_csv_no_par_content):
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".csv", delete=False, encoding="utf-8-sig"
+    ) as f:
+        f.write(udisc_csv_no_par_content)
+        return f.name

tests/discgolf_tests/test_models.py

@@ -0,0 +1,102 @@
+from discgolf.models import DiscGolfCourse, DiscGolfLogData
+from scrobbles.dataclasses import BaseLogData
+
+
+class TestDiscGolfCourseModel:
+    def test_create_course(self, db):
+        course = DiscGolfCourse.objects.create(
+            title="Maple Hill",
+            layout_name="Mountains",
+            number_of_holes=18,
+            par_total=54,
+            par_per_hole={"hole_1": 3, "hole_2": 3},
+        )
+        assert course.uuid is not None
+        assert str(course) == "Maple Hill (Mountains)"
+        assert course.subtitle == "Mountains"
+
+    def test_subtitle_fallback(self, db):
+        course = DiscGolfCourse.objects.create(title="Maple Hill")
+        assert course.subtitle == ""
+
+    def test_logdata_cls(self, db):
+        course = DiscGolfCourse.objects.create(title="Maple Hill")
+        assert course.logdata_cls is DiscGolfLogData
+        assert issubclass(course.logdata_cls, BaseLogData)
+
+    def test_strings(self, db):
+        course = DiscGolfCourse.objects.create(title="Maple Hill")
+        assert course.strings.verb == "Playing"
+        assert course.strings.tags == "golf"
+
+    def test_primary_image_url(self, db):
+        course = DiscGolfCourse.objects.create(title="Maple Hill")
+        assert course.primary_image_url == ""
+
+    def test_get_absolute_url(self, db):
+        course = DiscGolfCourse.objects.create(title="Maple Hill")
+        url = course.get_absolute_url()
+        assert str(course.uuid) in url
+        assert url.startswith("/disc-golf/")
+
+    def test_find_or_create_new(self, db):
+        course = DiscGolfCourse.find_or_create(
+            "New Course", layout_name="Default"
+        )
+        assert course.title == "New Course"
+        assert course.layout_name == "Default"
+
+    def test_find_or_create_existing(self, db):
+        created = DiscGolfCourse.objects.create(
+            title="Existing", layout_name="Alpha"
+        )
+        found = DiscGolfCourse.find_or_create("Existing", layout_name="Beta")
+        assert found.id == created.id
+        assert found.layout_name == "Alpha"
+
+    def test_scrobbles_method(self, db, user):
+        from datetime import datetime
+
+        import pytz
+
+        from scrobbles.models import Scrobble
+
+        course = DiscGolfCourse.objects.create(title="Maple Hill")
+        dt1 = datetime(2026, 6, 15, 14, 0, 0, tzinfo=pytz.UTC)
+        dt2 = datetime(2026, 6, 14, 14, 0, 0, tzinfo=pytz.UTC)
+        s1 = Scrobble.objects.create(
+            user=user,
+            disc_golf_course=course,
+            media_type=Scrobble.MediaType.DISC_GOLF,
+            timestamp=dt1,
+        )
+        s2 = Scrobble.objects.create(
+            user=user,
+            disc_golf_course=course,
+            media_type=Scrobble.MediaType.DISC_GOLF,
+            timestamp=dt2,
+        )
+        qs = course.scrobbles(user.id)
+        assert list(qs) == [s1, s2]
+
+
+class TestDiscGolfLogData:
+    def test_basic_logdata(self):
+        data = DiscGolfLogData()
+        assert data.scores is None
+        assert data.weather is None
+        assert data.fun_factor is None
+        assert data.course_name is None
+
+    def test_logdata_with_scores(self):
+        data = DiscGolfLogData(
+            scores={"Alice": {"person_id": 1, "total": 9}},
+            weather="Sunny",
+            fun_factor="High",
+            course_name="Maple Hill",
+            par=9,
+            round_type="Singles",
+        )
+        assert data.scores["Alice"]["total"] == 9
+        assert data.weather == "Sunny"
+        assert data.round_type == "Singles"

tests/discgolf_tests/test_utils.py

@@ -0,0 +1,150 @@
+from unittest.mock import patch
+
+from discgolf.models import DiscGolfCourse
+from discgolf.utils import _parse_udisc_datetime, import_udisc_csv
+from people.models import Person
+from scrobbles.models import Scrobble
+
+
+class TestParserHelpers:
+    def test_parse_udisc_datetime(self):
+        dt = _parse_udisc_datetime("Jun 15, 2026 10:00 AM")
+        assert dt is not None
+        assert dt.year == 2026
+        assert dt.month == 6
+        assert dt.day == 15
+        assert dt.hour == 10
+        assert dt.minute == 0
+
+    def test_parse_udisc_datetime_date_only(self):
+        dt = _parse_udisc_datetime("Jun 15, 2026")
+        assert dt is not None
+        assert dt.year == 2026
+
+
+class TestImportUdiscCSV:
+    def test_import_singles_creates_course(self, user, udisc_singles_csv_file):
+        import_udisc_csv(udisc_singles_csv_file, user.id)
+        course = DiscGolfCourse.objects.filter(title="Maple Hill").first()
+        assert course is not None
+        assert course.layout_name == "Mountains"
+        assert course.number_of_holes == 3
+        assert course.par_total == 9
+        assert course.par_per_hole == {"hole_1": 3, "hole_2": 3, "hole_3": 3}
+
+    def test_import_singles_creates_scrobble(self, user, udisc_singles_csv_file):
+        import_udisc_csv(udisc_singles_csv_file, user.id)
+        assert Scrobble.objects.filter(source="uDisc").count() == 1
+
+    def test_import_singles_logdata(self, user, udisc_singles_csv_file):
+        import_udisc_csv(udisc_singles_csv_file, user.id)
+        scrobble = Scrobble.objects.filter(source="uDisc").first()
+        log = scrobble.log
+        assert log["course_name"] == "Maple Hill"
+        assert log["par"] == 9
+        assert log["round_type"] == "Singles"
+        assert "Alice" in log["scores"]
+        assert "Bob" in log["scores"]
+        assert log["scores"]["Alice"]["total"] == 9
+        assert log["scores"]["Bob"]["total"] == 12
+
+    def test_import_singles_creates_people(self, user, udisc_singles_csv_file):
+        import_udisc_csv(udisc_singles_csv_file, user.id)
+        assert Person.objects.filter(name="Alice").exists()
+        assert Person.objects.filter(name="Bob").exists()
+
+    def test_import_teams_creates_scrobble(self, user, udisc_teams_csv_file):
+        import_udisc_csv(udisc_teams_csv_file, user.id)
+        assert Scrobble.objects.filter(source="uDisc").count() == 1
+
+    def test_import_teams_logdata(self, user, udisc_teams_csv_file):
+        import_udisc_csv(udisc_teams_csv_file, user.id)
+        scrobble = Scrobble.objects.filter(source="uDisc").first()
+        assert scrobble.log["round_type"] == "Teams"
+        alice_bob = scrobble.log["scores"]["Alice+Bob"]
+        assert "person_ids" in alice_bob
+        assert len(alice_bob["person_ids"]) == 2
+
+    def test_import_creates_team_people(self, user, udisc_teams_csv_file):
+        import_udisc_csv(udisc_teams_csv_file, user.id)
+        assert Person.objects.filter(name="Alice").exists()
+        assert Person.objects.filter(name="Bob").exists()
+        assert Person.objects.filter(name="Charlie").exists()
+        assert Person.objects.filter(name="Diana").exists()
+
+    def test_import_teams_par_per_hole(self, user, udisc_teams_csv_file):
+        import_udisc_csv(udisc_teams_csv_file, user.id)
+        course = DiscGolfCourse.objects.get(title="Maple Hill")
+        assert course.par_per_hole == {"hole_1": 3, "hole_2": 3, "hole_3": 3}
+
+    def test_import_no_par_returns_empty(self, user, udisc_csv_no_par_file):
+        result = import_udisc_csv(udisc_csv_no_par_file, user.id)
+        assert result == []
+
+    def test_import_empty_csv(self, user, db):
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".csv", delete=False, encoding="utf-8-sig"
+        ) as f:
+            f.write("PlayerName,CourseName,LayoutName,StartDate,Hole1,Total\n")
+            path = f.name
+
+        result = import_udisc_csv(path, user.id)
+        assert result == []
+
+    def test_import_idempotent(self, user, udisc_singles_csv_file):
+        import_udisc_csv(udisc_singles_csv_file, user.id)
+        import_udisc_csv(udisc_singles_csv_file, user.id)
+        assert DiscGolfCourse.objects.filter(title="Maple Hill").count() == 1
+        assert Scrobble.objects.filter(source="uDisc").count() == 2
+
+    def test_import_course_defaults_only_on_create(
+        self, user, udisc_singles_csv_file
+    ):
+        import_udisc_csv(udisc_singles_csv_file, user.id)
+        course = DiscGolfCourse.objects.get(title="Maple Hill")
+        assert course.layout_name == "Mountains"
+
+        course.layout_name = "Updated"
+        course.save()
+
+        import_udisc_csv(udisc_singles_csv_file, user.id)
+        course.refresh_from_db()
+        assert course.layout_name == "Updated"
+
+    @patch("discgolf.utils.ScrobbleNtfyNotification")
+    def test_import_sends_notification(self, mock_notification_class, user, udisc_singles_csv_file):
+        import_udisc_csv(udisc_singles_csv_file, user.id)
+        mock_notification_class.assert_called_once()
+        mock_notification_class.return_value.send.assert_called_once()
+
+    def test_import_hole_scores_per_player(self, user, udisc_singles_csv_file):
+        import_udisc_csv(udisc_singles_csv_file, user.id)
+        scrobble = Scrobble.objects.filter(source="uDisc").first()
+        alice = scrobble.log["scores"]["Alice"]
+        assert alice["hole_1"] == 4
+        assert alice["hole_2"] == 2
+        assert alice["hole_3"] == 3
+        bob = scrobble.log["scores"]["Bob"]
+        assert bob["hole_1"] == 3
+        assert bob["hole_2"] == 4
+        assert bob["hole_3"] == 5
+
+    def test_import_record_error_on_bad_data(self, user, db):
+        import tempfile
+
+        content = """PlayerName,CourseName,LayoutName,StartDate,Hole1,Hole2,Hole3,Total
+Par,,Mountains,"Jun 15, 2026 10:00 AM",3,3,3,9
+"""
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".csv", delete=False, encoding="utf-8-sig"
+        ) as f:
+            f.write(content)
+            path = f.name
+
+        errors = []
+        result = import_udisc_csv(path, user.id, record_error=errors.append)
+        assert len(result) == 1
+        course = DiscGolfCourse.objects.first()
+        assert course.title == ""

tests/discgolf_tests/test_views.py

@@ -0,0 +1,58 @@
+from datetime import datetime
+
+import pytz
+from django.contrib.auth import get_user_model
+from django.test import Client
+from django.urls import reverse
+
+from discgolf.models import DiscGolfCourse
+from scrobbles.models import Scrobble
+
+User = get_user_model()
+
+
+class TestDiscGolfCourseViews:
+    def _make_scrobble(self, user, course):
+        dt = datetime(2026, 6, 15, 14, 0, 0, tzinfo=pytz.UTC)
+        return Scrobble.objects.create(
+            user=user,
+            disc_golf_course=course,
+            media_type=Scrobble.MediaType.DISC_GOLF,
+            timestamp=dt,
+        )
+
+    def test_course_list_anonymous(self, db, user):
+        course = DiscGolfCourse.objects.create(title="Maple Hill")
+        self._make_scrobble(user, course)
+        client = Client()
+        response = client.get(reverse("discgolf:course_list"))
+        assert response.status_code == 200
+
+    def test_course_list_shows_course(self, db, user):
+        course = DiscGolfCourse.objects.create(title="Maple Hill")
+        self._make_scrobble(user, course)
+        client = Client()
+        response = client.get(reverse("discgolf:course_list"))
+        assert response.status_code == 200
+        assert "Maple Hill" in response.content.decode()
+
+    def test_course_detail_anonymous(self, db, user):
+        course = DiscGolfCourse.objects.create(title="Maple Hill")
+        self._make_scrobble(user, course)
+        client = Client()
+        response = client.get(
+            reverse("discgolf:course_detail", kwargs={"slug": course.uuid})
+        )
+        assert response.status_code == 200
+
+    def test_course_detail_shows_course(self, db, user):
+        course = DiscGolfCourse.objects.create(
+            title="Maple Hill", layout_name="Mountains"
+        )
+        self._make_scrobble(user, course)
+        client = Client()
+        response = client.get(
+            reverse("discgolf:course_detail", kwargs={"slug": course.uuid})
+        )
+        assert response.status_code == 200
+        assert "Maple Hill" in response.content.decode()

tests/scrobbles_tests/test_views.py

@@ -519,7 +519,7 @@ def test_scrobble_detail_view_with_notes_as_flat_list(client):
             "description": "Test description",
         },
     )
-    url = reverse("scrobbles:detail", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:detail", kwargs={"pk": scrobble.id})
     response = client.get(url)
     assert response.status_code == 200
     assert "First note" in response.content.decode()
@@ -545,7 +545,7 @@ def test_scrobble_detail_view_with_notes_as_dict_timestamps(client):
             "description": "Test description",
         },
     )
-    url = reverse("scrobbles:detail", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:detail", kwargs={"pk": scrobble.id})
     response = client.get(url)
     assert response.status_code == 200
     content = response.content.decode()
@@ -574,7 +574,7 @@ def test_scrobble_detail_view_with_notes_and_labels(client):
             "description": "Test description",
         },
     )
-    url = reverse("scrobbles:detail", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:detail", kwargs={"pk": scrobble.id})
     response = client.get(url)
     assert response.status_code == 200
     content = response.content.decode()
@@ -597,7 +597,7 @@ def test_scrobble_detail_view_post_updates_log(client):
             "description": "Original description",
         },
     )
-    url = reverse("scrobbles:detail", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:detail", kwargs={"pk": scrobble.id})
 
     client.force_login(user)
     response = client.post(
@@ -896,7 +896,7 @@ def test_change_visibility_owner_can_change(client):
     )
 
     client.force_login(user)
-    url = reverse("scrobbles:change-visibility", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:change-visibility", kwargs={"pk": scrobble.id})
     response = client.post(url, {"visibility": "shared"})
     assert response.status_code == 302
 
@@ -919,7 +919,7 @@ def test_change_visibility_non_owner_gets_404(client):
     )
 
     client.force_login(other)
-    url = reverse("scrobbles:change-visibility", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:change-visibility", kwargs={"pk": scrobble.id})
     response = client.post(url, {"visibility": "shared"})
     assert response.status_code == 404
 
@@ -937,7 +937,7 @@ def test_change_visibility_anonymous_redirects_to_login(client):
         task=task, media_type="Task", user=user, visibility="private",
         timestamp=timezone.now(),
     )
-    url = reverse("scrobbles:change-visibility", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:change-visibility", kwargs={"pk": scrobble.id})
     response = client.post(url, {"visibility": "shared"})
     assert response.status_code == 302
     assert "/login/" in response.url
@@ -956,7 +956,7 @@ def test_regenerate_share_token_invalidates_old_sqid(client):
     old_sqid = encode_scrobble_share(scrobble.id, scrobble.share_token_version)
 
     client.force_login(user)
-    url = reverse("scrobbles:regenerate-share-token", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:regenerate-share-token", kwargs={"pk": scrobble.id})
     response = client.post(url)
     assert response.status_code == 302
 
@@ -985,7 +985,7 @@ def test_share_analytics_owner_can_view(client):
     )
 
     client.force_login(user)
-    url = reverse("scrobbles:share-analytics", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:share-analytics", kwargs={"pk": scrobble.id})
     response = client.get(url)
     assert response.status_code == 200
 
@@ -1005,7 +1005,7 @@ def test_share_analytics_non_owner_gets_404(client):
     )
 
     client.force_login(other)
-    url = reverse("scrobbles:share-analytics", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:share-analytics", kwargs={"pk": scrobble.id})
     response = client.get(url)
     assert response.status_code == 404
 
@@ -1027,7 +1027,7 @@ def test_share_analytics_shows_view_logs(client):
     client.get(share_url)
 
     client.force_login(user)
-    url = reverse("scrobbles:share-analytics", kwargs={"uuid": scrobble.uuid})
+    url = reverse("scrobbles:share-analytics", kwargs={"pk": scrobble.id})
     response = client.get(url)
     assert response.status_code == 200
     content = response.content.decode()

tests/test_context_processors.py

@@ -4,9 +4,15 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
+from vrobbler import context_processors
 from vrobbler.context_processors import version_info
 
 
+@pytest.fixture(autouse=True)
+def reset_git_cache():
+    context_processors._GIT_COMMIT = None
+
+
 @pytest.fixture
 def mock_request():
     return MagicMock()

vrobbler/apps/books/amazon.py

@@ -1,128 +0,0 @@
-from enum import Enum
-from typing import Optional
-from bs4 import BeautifulSoup
-import requests
-import logging
-
-logger = logging.getLogger(__name__)
-
-USER_AGENT = "Mozilla/5.0 (Android 4.4; Mobile; rv:41.0) Gecko/41.0 Firefox/41.0"
-AMAZON_SEARCH_URL = "https://www.amazon.com/s?k={amazon_id}"
-
-
-class AmazonAttribute(Enum):
-    SERIES = 0
-    PAGES = 1
-    LANGUAGE = 2
-    PUBLISHER = 3
-    PUB_DATE = 4
-    DIMENSIONS = 5
-    ISBN_10 = 6
-    ISBN_13 = 7
-
-
-def strip_and_clean(text):
-    return text.strip("\n").rstrip().lstrip()
-
-
-def get_rating_from_soup(soup) -> Optional[int]:
-    rating = None
-    try:
-        potential_rating = soup.find("div", class_="allmusic-rating")
-        if potential_rating:
-            rating = int(strip_and_clean(potential_rating.get_text()))
-    except ValueError:
-        pass
-    return rating
-
-
-def get_review_from_soup(soup) -> str:
-    review = ""
-    try:
-        potential_text = soup.find("div", class_="text")
-        if potential_text:
-            review = strip_and_clean(potential_text.get_text())
-    except ValueError:
-        pass
-    return review
-
-
-def scrape_data_from_amazon(url) -> dict:
-    data_dict = {}
-    headers = {"User-Agent": USER_AGENT}
-    r = requests.get(url, headers=headers)
-    if r.status_code == 200:
-        soup = BeautifulSoup(r.text, "html.parser")
-        # TODO Fix this scraper
-        data_dict["rating"] = get_rating_from_soup(soup)
-        data_dict["review"] = get_review_from_soup(soup)
-    return data_dict
-
-
-def get_amazon_product_dict(amazon_id: str) -> dict:
-    data_dict = {}
-    url = ""
-
-    search_url = AMAZON_SEARCH_URL.format(amazon_id=amazon_id)
-    headers = {
-        "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36",
-        "accept-language": "en-GB,en;q=0.9",
-    }
-
-    response = requests.get(search_url, headers=headers)
-
-    if response.status_code != 200:
-        logger.info(f"Bad http response from Amazon {response}")
-        return data_dict
-
-    soup = BeautifulSoup(response.text, "html.parser")
-    results = soup.find("a", class_="a-link-normal")
-
-    if not results:
-        logger.info(f"No search results for {amazon_id}")
-        return data_dict
-
-    product_url = "https://www.amazon.com" + str(results.get("href", ""))
-
-    data_dict = {}
-    response = requests.get(product_url, headers=headers)
-
-    if response.status_code != 200:
-        logger.info(f"Bad http response from Amazon {response}")
-        return data_dict
-
-    soup = BeautifulSoup(response.text, "html.parser")
-    try:
-        data_dict["title"] = soup.findAll("span", class_="celwidget")[1].text.strip()
-        data_dict["cover_url"] = soup.find("img", class_="frontImage").get("src")
-        data_dict["summary"] = soup.findAll("div", class_="a-expander-content")[1].text
-        meta = soup.findAll("div", class_="rpi-attribute-value")
-        data_dict["isbn"] = meta[AmazonAttribute.ISBN_10.value].text.strip()
-        pages = meta[AmazonAttribute.PAGES.value].text
-        if "pages" in pages:
-            data_dict["pages"] = (
-                meta[AmazonAttribute.PAGES.value].text.split("pages")[0].strip()
-            )
-    except IndexError as e:
-        logger.error(f"Amazon lookup is failing for this product {amazon_id}: {e}")
-    except AttributeError as e:
-        logger.error(f"Amazon lookup is failing for this product {amazon_id}: {e}")
-
-    return data_dict
-
-
-def lookup_book_from_amazon(amazon_id: str) -> dict:
-    top = {}
-
-    return {
-        "title": top.get("title"),
-        "isbn": isbn,
-        "openlibrary_id": ol_id,
-        "goodreads_id": get_first("id_goodreads", top),
-        "first_publish_year": top.get("first_publish_year"),
-        "first_sentence": first_sentence,
-        "pages": top.get("number_of_pages_median", None),
-        "cover_url": COVER_URL.format(id=ol_id),
-        "ol_author_id": ol_author_id,
-        "subject_key_list": top.get("subject_key", []),
-    }

vrobbler/apps/books/constants.py

@@ -17,6 +17,7 @@ class MediaSourceTag(str, Enum):
     LOCG = "source_locg"
     KOREADER = "source_koreader"
     SEMANTIC_SCHOLAR = "source_semantic_scholar"
+    AMAZON = "source_amazon"
 
     @classmethod
     def choices(cls):

vrobbler/apps/books/models.py

@@ -23,6 +23,7 @@ from books.sources.comicvine import (
     lookup_issue_by_comicvine_id,
 )
 from books.sources.google import lookup_book_from_google
+from books.sources.amazon import lookup_book_from_amazon
 from books.sources.openlibrary import (
     lookup_book_from_openlibrary as lookup_book_from_ol,
 )
@@ -224,7 +225,7 @@ class Book(LongPlayScrobblableMixin):
 
     @property
     def resume_start_url(self):
-        return reverse("scrobbles:start", kwargs={"uuid": self.uuid}) + "?resume=1"
+        return reverse("scrobbles:start", kwargs={"media_uuid": self.uuid}) + "?resume=1"
 
     @classmethod
     def get_from_comicvine(
@@ -260,6 +261,7 @@ class Book(LongPlayScrobblableMixin):
         url: str = "",
         enrich: bool = True,
         commit: bool = True,
+        amazon_id: str | None = None,
     ):
         """Given a title, get a Book instance.
 
@@ -321,6 +323,13 @@ class Book(LongPlayScrobblableMixin):
                         book_dict.setdefault(k, v)
                 source_tag = MediaSourceTag.COMICVINE
 
+        # Try Amazon PAAPI as a fallback when given an ASIN
+        if amazon_id and not book_dict:
+            amazon_data = lookup_book_from_amazon(amazon_id)
+            if amazon_data:
+                book_dict.update(amazon_data)
+                source_tag = MediaSourceTag.AMAZON
+
         if not book_dict:
             logger.warning(
                 "No book found in any source, using data as is",

vrobbler/apps/books/sources/amazon.py

@@ -0,0 +1,123 @@
+import logging
+import warnings
+
+from django.conf import settings
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", DeprecationWarning)
+    from amazon_paapi import AmazonApi
+
+logger = logging.getLogger(__name__)
+
+_amazon_client = None
+
+
+def _get_client() -> AmazonApi | None:
+    global _amazon_client
+    if _amazon_client is not None:
+        return _amazon_client
+
+    key = settings.AMAZON_PAAPI_ACCESS_KEY
+    secret = settings.AMAZON_PAAPI_SECRET_KEY
+    tag = settings.AMAZON_PAAPI_ASSOCIATE_TAG
+    country = settings.AMAZON_PAAPI_COUNTRY
+
+    if not all([key, secret, tag]):
+        logger.warning("Amazon PAAPI credentials not configured")
+        return None
+
+    _amazon_client = AmazonApi(key, secret, tag, country)
+    return _amazon_client
+
+
+def lookup_book_from_amazon(asin: str) -> dict:
+    book_dict: dict = {}
+
+    client = _get_client()
+    if not client:
+        return book_dict
+
+    try:
+        items = client.get_items(
+            items=[asin],
+            Condition="New",
+            LanguagesOfPreference=["en_US"],
+        )
+    except Exception as e:
+        logger.warning(f"Amazon PAAPI lookup failed for {asin}: {e}")
+        return book_dict
+
+    if not items:
+        logger.info(f"No Amazon item found for {asin}")
+        return book_dict
+
+    item = items[0]
+    raw = item.to_dict()
+    item_info = raw.get("item_info", {}) or {}
+
+    book_dict["title"] = _get_nested(item_info, "title", "display_value")
+    if not book_dict.get("title"):
+        book_dict["title"] = _get_nested(item_info, "title", "value")
+
+    contributors = _get_nested(item_info, "by_line_info", "contributors") or []
+    authors = [
+        c["name"]
+        for c in contributors
+        if c.get("role", "").lower() in ("author", "artist", "writer")
+    ]
+    if authors:
+        book_dict["authors"] = authors
+
+    publisher = _get_nested(item_info, "by_line_info", "manufacturer")
+    if publisher:
+        book_dict["publisher"] = publisher
+
+    isb_ns = _get_nested(item_info, "external_ids", "isb_ns")
+    if isb_ns and isinstance(isb_ns, list):
+        for isb in isb_ns:
+            if isinstance(isb, dict):
+                if isb.get("type") == "ISBN_13":
+                    book_dict["isbn_13"] = isb.get("value")
+                elif isb.get("type") == "ISBN_10":
+                    book_dict["isbn_10"] = isb.get("value")
+
+    pages_count = _get_nested(item_info, "content_info", "pages_count")
+    if pages_count and isinstance(pages_count, dict):
+        book_dict["pages"] = pages_count.get("value") or pages_count.get("display_value")
+
+    languages = _get_nested(item_info, "content_info", "languages") or []
+    if languages and isinstance(languages, list):
+        lang = languages[0]
+        if isinstance(lang, dict):
+            book_dict["language"] = lang.get("display_value") or lang.get("value")
+
+    pub_date = _get_nested(item_info, "content_info", "publication_date")
+    if not pub_date:
+        pub_date = _get_nested(item_info, "product_info", "release_date")
+    if pub_date and isinstance(pub_date, dict):
+        book_dict["publish_date"] = pub_date.get("display_value") or pub_date.get("value")
+
+    features = item_info.get("features") or []
+    if features and isinstance(features, list):
+        book_dict["summary"] = " ".join(features[:5])
+
+    images = raw.get("images", {}) or {}
+    primary = images.get("primary", {}) or {}
+    for size in ("large", "hi_res", "medium"):
+        candidate = primary.get(size, {}) or {}
+        url = candidate.get("url")
+        if url:
+            book_dict["cover_url"] = url
+            break
+
+    book_dict["detail_page_url"] = raw.get("detail_page_url")
+
+    return book_dict
+
+
+def _get_nested(d: dict, *keys):
+    for key in keys:
+        if not isinstance(d, dict):
+            return None
+        d = d.get(key)
+    return d

vrobbler/apps/charts/migrations/0003_chartrecord_unique_chart_artist_period_and_more.py

@@ -0,0 +1,109 @@
+# Generated by Django 4.2.29 on 2026-06-19 16:25
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("charts", "0002_chartrecord_charts_char_user_id_1adcde_idx_and_more"),
+    ]
+
+    operations = [
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("artist__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "artist"),
+                name="unique_chart_artist_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("album__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "album"),
+                name="unique_chart_album_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("track__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "track"),
+                name="unique_chart_track_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("tv_series__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "tv_series"),
+                name="unique_chart_tv_series_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("video__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "video"),
+                name="unique_chart_video_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("podcast__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "podcast"),
+                name="unique_chart_podcast_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("podcast_episode__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "podcast_episode"),
+                name="unique_chart_podcast_episode_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("board_game__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "board_game"),
+                name="unique_chart_board_game_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("trail__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "trail"),
+                name="unique_chart_trail_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("geo_location__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "geo_location"),
+                name="unique_chart_geo_location_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("food__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "food"),
+                name="unique_chart_food_period",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="chartrecord",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("book__isnull", False)),
+                fields=("user", "year", "month", "week", "day", "book"),
+                name="unique_chart_book_period",
+            ),
+        ),
+    ]

vrobbler/apps/charts/models.py

@@ -2,6 +2,7 @@ import calendar
 
 from django.contrib.auth import get_user_model
 from django.db import models
+from django.db.models import Q
 from django.urls import reverse
 from django_extensions.db.models import TimeStampedModel
 
@@ -84,6 +85,68 @@ class ChartRecord(TimeStampedModel):
             models.Index(fields=["user", "year", "month", "day", "album", "rank"]),
             models.Index(fields=["user", "year", "month", "day", "tv_series", "rank"]),
         ]
+        constraints = [
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "artist"],
+                condition=Q(artist__isnull=False),
+                name="unique_chart_artist_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "album"],
+                condition=Q(album__isnull=False),
+                name="unique_chart_album_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "track"],
+                condition=Q(track__isnull=False),
+                name="unique_chart_track_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "tv_series"],
+                condition=Q(tv_series__isnull=False),
+                name="unique_chart_tv_series_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "video"],
+                condition=Q(video__isnull=False),
+                name="unique_chart_video_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "podcast"],
+                condition=Q(podcast__isnull=False),
+                name="unique_chart_podcast_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "podcast_episode"],
+                condition=Q(podcast_episode__isnull=False),
+                name="unique_chart_podcast_episode_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "board_game"],
+                condition=Q(board_game__isnull=False),
+                name="unique_chart_board_game_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "trail"],
+                condition=Q(trail__isnull=False),
+                name="unique_chart_trail_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "geo_location"],
+                condition=Q(geo_location__isnull=False),
+                name="unique_chart_geo_location_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "food"],
+                condition=Q(food__isnull=False),
+                name="unique_chart_food_period",
+            ),
+            models.UniqueConstraint(
+                fields=["user", "year", "month", "week", "day", "book"],
+                condition=Q(book__isnull=False),
+                name="unique_chart_book_period",
+            ),
+        ]
 
     @property
     def media_obj(self):

vrobbler/apps/charts/utils.py

@@ -6,6 +6,7 @@ from typing import Optional
 import pytz
 from django.apps import apps
 from django.conf import settings
+from django.db import transaction
 from django.db.models import Count, Q
 from django.utils import timezone
 
@@ -186,60 +187,64 @@ def build_charts(
         ranks = {count: rank for rank, count in enumerate(unique_counts, start=1)}
 
         media_field = f"{media_type}_id"
-        records_to_create = []
-        records_to_update = []
 
-        existing = ChartRecord.objects.filter(
+        with transaction.atomic():
-            period_filter, user=user, **{media_field + "__isnull": False}
+            records_to_create = []
-        )
+            records_to_update = []
-        existing_by_media_id = {getattr(r, media_field): r for r in existing}
-        found_media_ids = set()
 
-        for result in results:
+            existing = ChartRecord.objects.select_for_update().filter(
-            media_id = result[config["values"]]
+                period_filter, user=user, **{media_field + "__isnull": False}
-            if media_id is None:
-                continue
-
-            found_media_ids.add(media_id)
-
-            chart_record_data = {
-                "user_id": user.id,
-                "year": year,
-                "month": month,
-                "week": week,
-                "day": day,
-                "rank": ranks[result["scrobble_count"]],
-                "count": result["scrobble_count"],
-            }
-            chart_record_data[media_field] = media_id
-
-            if media_id in existing_by_media_id:
-                existing_record = existing_by_media_id[media_id]
-                existing_record.rank = chart_record_data["rank"]
-                existing_record.count = chart_record_data["count"]
-                records_to_update.append(existing_record)
-            else:
-                records_to_create.append(ChartRecord(**chart_record_data))
-
-        ids_to_delete = [
-            r.id for r in existing if getattr(r, media_field) not in found_media_ids
-        ]
-        if ids_to_delete:
-            ChartRecord.objects.filter(id__in=ids_to_delete).delete()
-
-        if records_to_update:
-            ChartRecord.objects.bulk_update(
-                records_to_update, ["rank", "count"], batch_size=500
             )
+            existing_by_media_id = {getattr(r, media_field): r for r in existing}
+            found_media_ids = set()
 
-        if records_to_create:
+            for result in results:
-            ChartRecord.objects.bulk_create(records_to_create, batch_size=500)
+                media_id = result[config["values"]]
+                if media_id is None:
+                    continue
 
-        logger.info(
+                found_media_ids.add(media_id)
-            f"Built {len(records_to_create)} new, {len(records_to_update)} updated "
+
-            f"chart records for {media_type}, period "
+                chart_record_data = {
-            f"{year}-{month or ''}-{week or ''}-{day or ''} for {user}"
+                    "user_id": user.id,
-        )
+                    "year": year,
+                    "month": month,
+                    "week": week,
+                    "day": day,
+                    "rank": ranks[result["scrobble_count"]],
+                    "count": result["scrobble_count"],
+                }
+                chart_record_data[media_field] = media_id
+
+                if media_id in existing_by_media_id:
+                    existing_record = existing_by_media_id[media_id]
+                    existing_record.rank = chart_record_data["rank"]
+                    existing_record.count = chart_record_data["count"]
+                    records_to_update.append(existing_record)
+                else:
+                    records_to_create.append(ChartRecord(**chart_record_data))
+
+            ids_to_delete = [
+                r.id
+                for r in existing
+                if getattr(r, media_field) not in found_media_ids
+            ]
+            if ids_to_delete:
+                ChartRecord.objects.filter(id__in=ids_to_delete).delete()
+
+            if records_to_update:
+                ChartRecord.objects.bulk_update(
+                    records_to_update, ["rank", "count"], batch_size=500
+                )
+
+            if records_to_create:
+                ChartRecord.objects.bulk_create(records_to_create, batch_size=500)
+
+            logger.info(
+                f"Built {len(records_to_create)} new, {len(records_to_update)} updated "
+                f"chart records for {media_type}, period "
+                f"{year}-{month or ''}-{week or ''}-{day or ''} for {user}"
+            )
 
 
 def build_yesterdays_charts(user, media_types: Optional[list] = None) -> None:

vrobbler/apps/discgolf/admin.py

@@ -0,0 +1,14 @@
+from discgolf.models import DiscGolfCourse
+from django.contrib import admin
+from scrobbles.admin import ScrobbleInline
+
+
+@admin.register(DiscGolfCourse)
+class DiscGolfCourseAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("title", "layout_name", "number_of_holes", "par_total", "pdga_slug", "udisc_id")
+    raw_id_fields = ("trail",)
+    search_fields = ("title", "layout_name")
+    inlines = [
+        ScrobbleInline,
+    ]

vrobbler/apps/discgolf/api/serializers.py

@@ -0,0 +1,14 @@
+from discgolf import models
+from rest_framework import serializers
+
+
+class DiscGolfCourseSerializer(serializers.HyperlinkedModelSerializer):
+    pdga_link = serializers.ReadOnlyField()
+    udisc_link = serializers.ReadOnlyField()
+
+    class Meta:
+        model = models.DiscGolfCourse
+        fields = "__all__"
+
+
+

vrobbler/apps/discgolf/api/views.py

@@ -0,0 +1,13 @@
+from rest_framework import permissions, viewsets
+
+from discgolf.api import serializers
+from discgolf import models
+
+
+class DiscGolfCourseViewSet(viewsets.ModelViewSet):
+    queryset = models.DiscGolfCourse.objects.all().order_by("-created")
+    serializer_class = serializers.DiscGolfCourseSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+

vrobbler/apps/discgolf/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class DiscgolfConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "discgolf"

vrobbler/apps/discgolf/migrations/0001_initial.py

@@ -0,0 +1,83 @@
+# Generated by Django 4.2.29 on 2026-06-20 04:19
+
+from django.db import migrations, models
+import django_extensions.db.fields
+import taggit.managers
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("taggit", "0004_alter_taggeditem_content_type_alter_taggeditem_tag"),
+        ("scrobbles", "0098_scrobble_long_play_last_scrobble"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="DiscGolfCourse",
+            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
+                    ),
+                ),
+                ("title", models.CharField(blank=True, max_length=255, null=True)),
+                ("base_run_time_seconds", models.IntegerField(blank=True, null=True)),
+                ("description", models.TextField(blank=True, null=True)),
+                (
+                    "layout_name",
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                ("number_of_holes", models.IntegerField(blank=True, null=True)),
+                ("par_total", models.IntegerField(blank=True, null=True)),
+                (
+                    "genre",
+                    taggit.managers.TaggableManager(
+                        blank=True,
+                        help_text="A comma-separated list of tags.",
+                        through="scrobbles.ObjectWithGenres",
+                        to="scrobbles.Genre",
+                        verbose_name="Genre",
+                    ),
+                ),
+                (
+                    "tags",
+                    taggit.managers.TaggableManager(
+                        blank=True,
+                        help_text="A comma-separated list of tags.",
+                        through="taggit.TaggedItem",
+                        to="taggit.Tag",
+                        verbose_name="Tags",
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+    ]

vrobbler/apps/discgolf/migrations/0002_discgolfcourse_trail.py

@@ -0,0 +1,25 @@
+# Generated by Django 4.2.29 on 2026-06-20 04:29
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("trails", "0009_trail_route_waypoint"),
+        ("discgolf", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="discgolfcourse",
+            name="trail",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to="trails.trail",
+            ),
+        ),
+    ]

vrobbler/apps/discgolf/migrations/0003_discgolfcourse_par_per_hole.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.29 on 2026-06-20 04:35
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("discgolf", "0002_discgolfcourse_trail"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="discgolfcourse",
+            name="par_per_hole",
+            field=models.JSONField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/discgolf/migrations/0004_discgolfcourse_pdga_slug_discgolfcourse_udisc_id.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.29 on 2026-06-21 04:16
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("discgolf", "0003_discgolfcourse_par_per_hole"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="discgolfcourse",
+            name="pdga_slug",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name="discgolfcourse",
+            name="udisc_id",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]

vrobbler/apps/discgolf/models.py

@@ -0,0 +1,90 @@
+from dataclasses import dataclass
+from typing import Optional, TypedDict
+
+from django.apps import apps
+from django.db import models
+from django.urls import reverse
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData
+from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
+
+BNULL = {"blank": True, "null": True}
+
+
+class DiscGolfSingleScores(TypedDict, total=False):
+    person_id: int
+    total: int
+
+
+class DiscGolfTeamScores(TypedDict, total=False):
+    person_ids: list[int]
+    total: int
+
+
+@dataclass
+class DiscGolfLogData(BaseLogData, WithPeopleLogData):
+    scores: Optional[dict[str, DiscGolfSingleScores | DiscGolfTeamScores]] = None
+    weather: Optional[str] = None
+    fun_factor: Optional[str] = None
+    course_name: Optional[str] = None
+    par: Optional[int] = None
+    round_type: Optional[str] = None
+
+
+class DiscGolfCourse(ScrobblableMixin):
+    description = models.TextField(**BNULL)
+    layout_name = models.CharField(max_length=255, **BNULL)
+    number_of_holes = models.IntegerField(**BNULL)
+    par_total = models.IntegerField(**BNULL)
+    par_per_hole = models.JSONField(**BNULL)
+    trail = models.ForeignKey(
+        "trails.Trail", on_delete=models.DO_NOTHING, **BNULL
+    )
+    pdga_slug = models.CharField(max_length=255, **BNULL)
+    udisc_id = models.CharField(max_length=255, **BNULL)
+
+    @property
+    def pdga_link(self) -> str:
+        if self.pdga_slug:
+            return f"https://www.pdga.com/course-directory/course/{self.pdga_slug}/"
+        return ""
+
+    @property
+    def udisc_link(self) -> str:
+        if self.udisc_id:
+            return f"https://udisc.com/courses/{self.udisc_id}/"
+        return ""
+
+    def get_absolute_url(self) -> str:
+        return reverse("discgolf:course_detail", kwargs={"slug": self.uuid})
+
+    def __str__(self):
+        return f"{self.title} ({self.layout_name or 'Default'})"
+
+    @property
+    def logdata_cls(self):
+        return DiscGolfLogData
+
+    @property
+    def subtitle(self):
+        return self.layout_name or ""
+
+    @property
+    def strings(self) -> ScrobblableConstants:
+        return ScrobblableConstants(verb="Playing", tags="golf")
+
+    @property
+    def primary_image_url(self) -> str:
+        return ""
+
+    @classmethod
+    def find_or_create(cls, name: str, **defaults) -> "DiscGolfCourse":
+        course = cls.objects.filter(title=name).first()
+        if not course:
+            course = cls.objects.create(title=name, **defaults)
+        return course
+
+    def scrobbles(self, user_id):
+        Scrobble = apps.get_model("scrobbles", "Scrobble")
+        return Scrobble.objects.filter(user_id=user_id, disc_golf_course=self).order_by(
+            "-timestamp"
+        )

vrobbler/apps/discgolf/urls.py

@@ -0,0 +1,14 @@
+from django.urls import path
+from discgolf import views
+
+app_name = "discgolf"
+
+
+urlpatterns = [
+    path("disc-golf/", views.DiscGolfCourseListView.as_view(), name="course_list"),
+    path(
+        "disc-golf/<slug:slug>/",
+        views.DiscGolfCourseDetailView.as_view(),
+        name="course_detail",
+    ),
+]

vrobbler/apps/discgolf/utils.py

@@ -0,0 +1,129 @@
+import csv
+import logging
+from datetime import datetime
+
+from dateutil.parser import parse as parse_datetime
+from django.utils import timezone
+from people.models import Person
+from scrobbles.models import Scrobble
+from scrobbles.notifications import ScrobbleNtfyNotification
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_udisc_datetime(raw: str) -> datetime:
+    return parse_datetime(raw)
+
+
+def _resolve_player(name: str, user_id: int) -> Person:
+    name = name.strip()
+    existing = Person.objects.filter(name=name, created_by_id=user_id).first()
+    if existing:
+        return existing
+    return Person.objects.create(name=name, created_by_id=user_id)
+
+
+def import_udisc_csv(
+    file_path: str, user_id: int, record_error=None
+) -> list[Scrobble]:
+    from discgolf.models import DiscGolfCourse
+
+    new_scrobbles = []
+
+    with open(file_path, newline="", encoding="utf-8-sig") as f:
+        reader = csv.DictReader(f)
+        rows = list(reader)
+
+    if not rows:
+        return []
+
+    par_row = None
+    player_rows = []
+    for row in rows:
+        name = row.get("PlayerName", "").strip()
+        if name.lower() == "par":
+            par_row = row
+        else:
+            player_rows.append(row)
+
+    if not par_row:
+        return []
+
+    course_name = par_row.get("CourseName", "").strip()
+    layout_name = par_row.get("LayoutName", "").strip()
+    start_date_raw = par_row.get("StartDate", "").strip()
+    start_dt = _parse_udisc_datetime(start_date_raw) if start_date_raw else timezone.now()
+
+    number_of_holes = sum(1 for k in par_row if k.startswith("Hole") and k[4:].isdigit())
+    par_total_str = par_row.get("Total", "").strip()
+    par_total = int(par_total_str) if par_total_str.isdigit() else None
+
+    par_per_hole = {}
+    for k, v in par_row.items():
+        if k.startswith("Hole") and k[4:].isdigit() and v:
+            hole_num = int(k[4:])
+            try:
+                par_per_hole[f"hole_{hole_num}"] = int(v)
+            except (ValueError, TypeError):
+                pass
+
+    course, _ = DiscGolfCourse.objects.get_or_create(
+        title=course_name,
+        defaults={
+            "layout_name": layout_name,
+            "number_of_holes": number_of_holes,
+            "par_total": par_total,
+            "par_per_hole": par_per_hole or None,
+        },
+    )
+
+    is_teams = "+" in player_rows[0].get("PlayerName", "") if player_rows else False
+    round_type = "Teams" if is_teams else "Singles"
+
+    scores = {}
+    for row in player_rows:
+        player_name = row.get("PlayerName", "").strip()
+        hole_scores = {}
+        for k, v in row.items():
+            if k.startswith("Hole") and k[4:].isdigit() and v:
+                hole_num = int(k[4:])
+                try:
+                    hole_scores[f"hole_{hole_num}"] = int(v)
+                except (ValueError, TypeError):
+                    pass
+        total_str = row.get("Total", "").strip()
+        total = int(total_str) if total_str.isdigit() else None
+        if total is not None:
+            hole_scores["total"] = total
+
+        if is_teams:
+            people = player_name.split("+")
+            person_ids = [_resolve_player(p.strip(), user_id).id for p in people]
+            hole_scores["person_ids"] = person_ids
+        else:
+            person = _resolve_player(player_name, user_id)
+            hole_scores["person_id"] = person.id
+
+        scores[player_name] = hole_scores
+
+    log = {
+        "scores": scores,
+        "course_name": course_name,
+        "par": par_total,
+        "round_type": round_type,
+    }
+
+    scrobble_dict = {
+        "user_id": user_id,
+        "timestamp": start_dt,
+        "source": "uDisc",
+        "playback_position_seconds": 0,
+        "log": log,
+    }
+
+    scrobble = Scrobble.create_or_update(course, user_id, scrobble_dict)
+    if scrobble:
+        new_scrobbles.append(scrobble)
+        ScrobbleNtfyNotification(scrobble).send()
+
+    return new_scrobbles

vrobbler/apps/discgolf/views.py

@@ -0,0 +1,32 @@
+from django.apps import apps
+
+from discgolf.models import DiscGolfCourse
+
+from scrobbles.views import (
+    ScrobbleableListView,
+    ScrobbleableDetailView,
+    ChartContextMixin,
+)
+
+
+class DiscGolfCourseListView(ScrobbleableListView):
+    model = DiscGolfCourse
+
+
+class DiscGolfCourseDetailView(ScrobbleableDetailView, ChartContextMixin):
+    model = DiscGolfCourse
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        Scrobble = apps.get_model("scrobbles", "Scrobble")
+        context["trail_gpx_url"] = None
+        latest = (
+            Scrobble.objects.filter(
+                trail=self.object.trail, gpx_file__isnull=False
+            )
+            .order_by("-timestamp")
+            .first()
+        )
+        if latest and latest.gpx_file:
+            context["trail_gpx_url"] = latest.gpx_file.url
+        return context

vrobbler/apps/locations/admin.py

@@ -1,4 +1,7 @@
+import time
+
 from django.contrib import admin
+from django.http import HttpRequest
 
 from locations.models import GeoLocation
 
@@ -14,9 +17,29 @@ class GeoLocationAdmin(admin.ModelAdmin):
         "lon",
         "title",
         "altitude",
+        "city",
+        "state_province",
+        "country",
     )
     ordering = ("-created",)
     search_fields = ("title",)
+    actions = ["reverse_geocode_selected"]
     inlines = [
         ScrobbleInline,
     ]
+
+    @admin.action(description="Reverse geocode selected locations")
+    def reverse_geocode_selected(self, request: HttpRequest, queryset):
+        updated = 0
+        errors = 0
+        for i, location in enumerate(queryset.iterator()):
+            if location.reverse_geocode():
+                updated += 1
+            else:
+                errors += 1
+            if i < queryset.count() - 1:
+                time.sleep(1.1)
+        msg = f"Reverse geocoded {updated} locations"
+        if errors:
+            msg += f", {errors} failed"
+        self.message_user(request, msg)

vrobbler/apps/locations/migrations/0011_geolocation_city_geolocation_country_and_more.py

@@ -0,0 +1,38 @@
+# Generated by Django 4.2.29 on 2026-06-21 04:26
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("locations", "0010_clean_start"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="geolocation",
+            name="city",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name="geolocation",
+            name="country",
+            field=models.CharField(blank=True, max_length=100, null=True),
+        ),
+        migrations.AddField(
+            model_name="geolocation",
+            name="postal_code",
+            field=models.CharField(blank=True, max_length=20, null=True),
+        ),
+        migrations.AddField(
+            model_name="geolocation",
+            name="state_province",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name="geolocation",
+            name="street",
+            field=models.TextField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/locations/models.py

@@ -45,6 +45,11 @@ class GeoLocation(ScrobblableMixin):
     truncated_lat = models.FloatField(**BNULL)
     truncated_lon = models.FloatField(**BNULL)
     altitude = models.FloatField(**BNULL)
+    street = models.TextField(**BNULL)
+    city = models.CharField(max_length=255, **BNULL)
+    state_province = models.CharField(max_length=255, **BNULL)
+    postal_code = models.CharField(max_length=20, **BNULL)
+    country = models.CharField(max_length=100, **BNULL)
 
     class Meta:
         unique_together = [["lat", "lon", "altitude"]]
@@ -55,6 +60,11 @@ class GeoLocation(ScrobblableMixin):
 
         return f"{self.lat} x {self.lon}"
 
+    @property
+    def display_address(self) -> str:
+        parts = [self.street, self.city, self.state_province, self.postal_code, self.country]
+        return ", ".join(p for p in parts if p)
+
     def get_absolute_url(self):
         return reverse("locations:geolocation_detail", kwargs={"slug": self.uuid})
 
@@ -121,6 +131,17 @@ class GeoLocation(ScrobblableMixin):
 
         return fetch_current_weather(self.lat, self.lon)
 
+    def reverse_geocode(self) -> bool:
+        from locations.utils import reverse_geocode
+
+        result = reverse_geocode(self.lat, self.lon)
+        if result is None:
+            return False
+        for field, value in result.items():
+            setattr(self, field, value)
+        self.save(update_fields=list(result.keys()))
+        return True
+
     def loc_diff(self, old_lat_lon: tuple) -> tuple:
         return (
             abs(Decimal(old_lat_lon[0]) - Decimal(self.lat)),

vrobbler/apps/locations/utils.py

@@ -201,6 +201,50 @@ def detect_movement(
     return result
 
 
+NOMINATIM_URL = "https://nominatim.openstreetmap.org/reverse"
+
+USER_AGENT = "Vrobbler/1.0 (https://github.com/secstate/vrobbler)"
+
+
+def reverse_geocode(lat: float, lon: float) -> Optional[dict]:
+    """Reverse geocode lat/lon to an address using Nominatim.
+
+    Returns a dict with address fields, or None on failure.
+    Nominatim usage policy: max 1 request per second.
+    """
+    params = {
+        "lat": lat,
+        "lon": lon,
+        "format": "json",
+    }
+    headers = {"User-Agent": USER_AGENT}
+    try:
+        resp = requests.get(NOMINATIM_URL, params=params, headers=headers, timeout=10)
+        resp.raise_for_status()
+    except requests.RequestException as e:
+        logger.warning("Failed to reverse geocode %s,%s: %s", lat, lon, e)
+        return None
+
+    data = resp.json()
+    if "error" in data:
+        logger.warning("Nominatim error for %s,%s: %s", lat, lon, data["error"])
+        return None
+
+    address = data.get("address", {})
+    return {
+        "street": address.get("road")
+        or address.get("pedestrian")
+        or address.get("footway"),
+        "city": address.get("city")
+        or address.get("town")
+        or address.get("village")
+        or address.get("hamlet"),
+        "state_province": address.get("state"),
+        "postal_code": address.get("postcode"),
+        "country": address.get("country"),
+    }
+
+
 NWS_URL = "https://forecast.weather.gov/MapClick.php"
 
 

vrobbler/apps/music/context_processors.py

@@ -1,8 +1,22 @@
+from django.core.cache import cache
+
 from music.models import Artist, Album
 
+CACHE_TTL = 300
+
 
 def music_lists(request):
+    artist_list = cache.get("music_lists_artist_list")
+    if artist_list is None:
+        artist_list = list(Artist.objects.all().only("id", "name"))
+        cache.set("music_lists_artist_list", artist_list, CACHE_TTL)
+
+    album_list = cache.get("music_lists_album_list")
+    if album_list is None:
+        album_list = list(Album.objects.all().only("id", "name"))
+        cache.set("music_lists_album_list", album_list, CACHE_TTL)
+
     return {
-        "artist_list": Artist.objects.all(),
+        "artist_list": artist_list,
-        "album_list": Album.objects.all(),
+        "album_list": album_list,
     }

vrobbler/apps/music/models.py

@@ -236,19 +236,6 @@ class Artist(TimeStampedModel):
             )
             artist.fix_metadata()
 
-        # TODO: See if this alt_names stuff actually works or causes hard to debug problems
-        # If we did find our artist, but the found name is slightly differnt, record that
-        # if artist and alt_name:
-        #    if not artist.alt_names:
-        #        artist.alt_names = alt_name
-        #    else:
-        #        artist.alt_names += f"\\{alt_name}"
-        #    logger.info(
-        #        f"Add alt_name {alt_name} to artist {artist}",
-        #        extra={"alt_name": alt_name, "artist_id": artist.id},
-        #    )
-        #    artist.save(update_fields=["alt_names"])
-
         return artist
 
 
@@ -600,8 +587,9 @@ class Track(ScrobblableMixin):
     def __str__(self):
         return f"{self.title} by {self.artist}"
 
+    @property
     def logdata_cls(self):
-        return TrackLogData()
+        return TrackLogData
 
     @property
     def primary_album(self):

vrobbler/apps/profiles/forms.py

@@ -40,6 +40,7 @@ class UserProfileForm(forms.ModelForm):
             "enable_public_widgets",
             "widget_custom_css",
             "home_scrobble_limit",
+            "live_now_playing",
             "weigh_in_units",
         ]
         widgets = {

vrobbler/apps/profiles/migrations/0039_userprofile_live_now_playing.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.29 on 2026-06-22 02:44
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("profiles", "0038_userprofile_media_type_visibility"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="live_now_playing",
+            field=models.BooleanField(default=False),
+        ),
+    ]

vrobbler/apps/profiles/models.py

@@ -98,6 +98,8 @@ class UserProfile(TimeStampedModel):
 
     home_scrobble_limit = models.IntegerField(default=20)
 
+    live_now_playing = models.BooleanField(default=False)
+
     weigh_in_units = models.CharField(
         max_length=16,
         choices=WeighUnit.choices,

vrobbler/apps/scrobbles/admin.py

@@ -12,6 +12,7 @@ from scrobbles.models import (
     Scrobble,
     ShareViewLog,
     TrailGPXImport,
+    UDiscCSVImport,
 )
 from scrobbles.mixins import Genre
 
@@ -73,6 +74,10 @@ class ScaleCSVImportAdmin(ImportBaseAdmin): ...
 class TrailGPXImportAdmin(ImportBaseAdmin): ...
 
 
+@admin.register(UDiscCSVImport)
+class UDiscCSVImportAdmin(ImportBaseAdmin): ...
+
+
 @admin.register(Genre)
 class GenreAdmin(admin.ModelAdmin):
     list_display = (
@@ -118,6 +123,7 @@ class ScrobbleAdmin(admin.ModelAdmin):
         "web_page",
         "life_event",
         "birding_location",
+        "disc_golf_course",
         "long_play_last_scrobble",
     )
     list_filter = (
@@ -179,4 +185,5 @@ class FavoriteMediaAdmin(admin.ModelAdmin):
         "web_page",
         "life_event",
         "birding_location",
+        "disc_golf_course",
     )

vrobbler/apps/scrobbles/constants.py

@@ -25,17 +25,26 @@ AUTO_FINISH_MEDIA = {
 }
 
 PLAY_AGAIN_MEDIA = {
-    "videogames": "VideoGame",
+    "videos": "Video",
+    "music": "Track",
+    "podcasts": "PodcastEpisode",
+    "sports": "SportEvent",
     "books": "Book",
+    "videogames": "VideoGame",
     "boardgames": "BoardGame",
-    "moods": "Mood",
+    "locations": "GeoLocation",
-    "bricksets": "BrickSet",
     "trails": "Trail",
     "beers": "Beer",
+    "puzzles": "Puzzle",
     "foods": "Food",
-    "locations": "GeoLocation",
+    "tasks": "Task",
-    "videos": "Video",
+    "webpages": "WebPage",
+    "lifeevents": "LifeEvent",
+    "moods": "Mood",
+    "bricksets": "BrickSet",
+    "channels": "Channel",
     "birds": "BirdingLocation",
+    "discgolf": "DiscGolfCourse",
 }
 
 MEDIA_END_PADDING_SECONDS = {
@@ -73,6 +82,7 @@ MANUAL_SCROBBLE_FNS = {
     "-c": "manual_scrobble_book",
     "-f": "manual_scrobble_food",
     "-h": "manual_scrobble_twitch_channel",
+    "-dg": "manual_scrobble_discgolf",
 }
 
 

vrobbler/apps/scrobbles/context_processors.py

@@ -27,15 +27,19 @@ def month_color(request):
 
 def now_playing(request):
     user = request.user
-    now = timezone.now()
     if not user.is_authenticated:
         return {}
+
     return {
-        "now_playing_list": Scrobble.objects.filter(
+        "now_playing_list": list(
-            in_progress=True,
+            Scrobble.objects.filter(
-            is_paused=False,
+                in_progress=True,
-            user=user,
+                is_paused=False,
-        ).exclude(
+                user=user,
-            media_type__in=EXCLUDE_FROM_NOW_PLAYING,
+            )
-        )
+            .exclude(
+                media_type__in=EXCLUDE_FROM_NOW_PLAYING,
+            )
+            .select_related("track", "video", "podcast_episode")
+        ),
     }

vrobbler/apps/scrobbles/importers/webdav.py

@@ -19,6 +19,7 @@ DEFAULT_RETROARCH_PATH = "var/retroarch/"
 DEFAULT_BGSTATS_PATH = "var/bgstats/"
 DEFAULT_EBIRD_PATH = "var/ebird/"
 DEFAULT_SCALE_PATH = "var/scale/"
+DEFAULT_UDISC_PATH = "var/udisc/"
 
 
 def import_from_webdav_for_all_users(
@@ -48,6 +49,7 @@ def import_from_webdav_for_all_users(
     bgstats_count = 0
     ebird_count = 0
     scale_count = 0
+    udisc_count = 0
 
     for user_id in webdav_enabled_user_ids:
         client = get_webdav_client(user_id)
@@ -78,15 +80,20 @@ def import_from_webdav_for_all_users(
         )
         logger.info("Scanning WebDAV scale for user %s", user_id)
         scale_count += scan_webdav_for_scale(client, user_id)
+        logger.info("Scanning WebDAV udisc for user %s", user_id)
+        udisc_count += scan_webdav_for_udisc(
+            client, user_id, include_processed=include_processed
+        )
 
     logger.info(
-        "Started %d KOReader, %d Trail GPX, %d Retroarch, %d BGStats, %d eBird, %d Scale WebDAV imports",
+        "Started %d KOReader, %d Trail GPX, %d Retroarch, %d BGStats, %d eBird, %d Scale, %d uDisc WebDAV imports",
         ko_count,
         gpx_count,
         retro_count,
         bgstats_count,
         ebird_count,
         scale_count,
+        udisc_count,
         extra={
             "koreader": ko_count,
             "trail_gpx": gpx_count,
@@ -94,9 +101,10 @@ def import_from_webdav_for_all_users(
             "bgstats": bgstats_count,
             "ebird": ebird_count,
             "scale": scale_count,
+            "udisc": udisc_count,
         },
     )
-    return ko_count, gpx_count, retro_count, bgstats_count, ebird_count, scale_count
+    return ko_count, gpx_count, retro_count, bgstats_count, ebird_count, scale_count, udisc_count
 
 
 def scan_webdav_for_koreader(
@@ -811,3 +819,115 @@ def scan_webdav_for_scale(webdav_client, user_id):
             os.unlink(tmp.name)
 
     return new_imports
+
+
+def scan_webdav_for_udisc(webdav_client, user_id, include_processed=False):
+    """Download .csv files from WebDAV var/udisc/ and queue imports for new files.
+
+    After importing, files are moved to var/udisc/processed/ so they are
+    not re-imported on subsequent scans unless *include_processed* is True.
+    """
+    from scrobbles.models import UDiscCSVImport
+    from scrobbles.tasks import process_udisc_csv_import
+
+    udisc_path = DEFAULT_UDISC_PATH
+    try:
+        webdav_client.info(udisc_path)
+    except:
+        logger.info("No var/udisc/ directory on webdav", extra={"user_id": user_id})
+        return 0
+
+    try:
+        files = webdav_client.list(udisc_path)
+    except Exception as e:
+        logger.warning(
+            "Could not list var/udisc/",
+            extra={"user_id": user_id, "error": str(e)},
+        )
+        return 0
+
+    processed_dir = f"{udisc_path}processed/"
+    try:
+        webdav_client.mkdir(processed_dir, recursive=True)
+    except Exception:
+        pass
+
+    new_imports = 0
+    already_imported = set(
+        UDiscCSVImport.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 == "processed":
+            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"{udisc_path}{fname}", local_path=tmp.name
+            )
+            imp = UDiscCSVImport.objects.create(
+                user_id=user_id,
+                original_filename=fname,
+            )
+            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"{udisc_path}{fname}",
+                f"{processed_dir}{stem}_{ts}{ext}",
+            )
+
+            process_udisc_csv_import.delay(imp.id)
+            new_imports += 1
+        except Exception as e:
+            logger.error(f"Failed to import uDisc CSV file {fname}: {e}")
+        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/udisc/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 = UDiscCSVImport.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_udisc_csv_import.delay(imp.id)
+                new_imports += 1
+            except Exception as e:
+                logger.error(
+                    f"Failed to import processed uDisc CSV file {fname}: {e}"
+                )
+            finally:
+                os.unlink(tmp.name)
+
+    return new_imports

vrobbler/apps/scrobbles/mcp.py

@@ -0,0 +1,518 @@
+from mcp_server import MCPToolset
+from scrobbles.models import Scrobble
+from scrobbles.constants import LONG_PLAY_MEDIA
+
+
+class ScrobbleToolset(MCPToolset):
+    def list_recent_scrobbles(
+        self,
+        days: int = 7,
+        media_type: str | None = None,
+        limit: int = 50,
+    ) -> list[dict]:
+        """List scrobbles from the last N days, optionally filtered by media type.
+        Valid media_type values: Video, Track, PodcastEpisode, SportEvent, Book,
+        Paper, VideoGame, BoardGame, GeoLocation, Trail, Beer, Puzzle, Food, Task,
+        WebPage, LifeEvent, Mood, BrickSet, Channel, BirdingLocation, DiscGolfCourse
+        """
+        qs = (
+            Scrobble.objects.filter(user=self.request.user)
+            .select_related(
+                "video", "track", "book", "video_game", "board_game",
+                "beer", "puzzle", "food", "trail", "task", "web_page",
+                "life_event", "mood", "brick_set", "podcast_episode",
+                "sport_event", "geo_location", "birding_location",
+                "disc_golf_course", "channel",
+            )
+            .order_by("-timestamp")
+        )
+        from django.utils import timezone
+        import datetime
+        qs = qs.filter(timestamp__gte=timezone.now() - datetime.timedelta(days=days))
+        if media_type:
+            qs = qs.filter(media_type=media_type)
+        qs = qs[:limit]
+        return [_scrobble_to_dict(s) for s in qs]
+
+    def get_scrobble(self, uuid: str) -> dict | None:
+        """Get a single scrobble by its UUID."""
+        try:
+            s = Scrobble.objects.filter(user=self.request.user).get(uuid=uuid)
+        except Scrobble.DoesNotExist:
+            return None
+        return _scrobble_to_dict(s)
+
+    def search_scrobbles(
+        self, query: str, media_type: str | None = None, limit: int = 20
+    ) -> list[dict]:
+        """Search scrobbles by text in their log data or related media titles."""
+        from django.db.models import Q
+        qs = Scrobble.objects.filter(user=self.request.user).order_by("-timestamp")
+        if media_type:
+            qs = qs.filter(media_type=media_type)
+        qs = qs.filter(
+            Q(log__icontains=query)
+            | Q(video__title__icontains=query)
+            | Q(track__title__icontains=query)
+            | Q(book__title__icontains=query)
+            | Q(video_game__title__icontains=query)
+            | Q(board_game__title__icontains=query)
+            | Q(beer__title__icontains=query)
+            | Q(food__title__icontains=query)
+            | Q(trail__title__icontains=query)
+            | Q(task__title__icontains=query)
+            | Q(web_page__title__icontains=query)
+            | Q(life_event__title__icontains=query)
+            | Q(puzzle__title__icontains=query)
+            | Q(brick_set__title__icontains=query)
+            | Q(podcast_episode__title__icontains=query)
+        )[:limit]
+        return [_scrobble_to_dict(s) for s in qs]
+
+    def get_scrobbles_by_date(
+        self, date: str, media_type: str | None = None
+    ) -> list[dict]:
+        """Get scrobbles for a specific date (YYYY-MM-DD format)."""
+        import datetime
+        try:
+            dt = datetime.datetime.strptime(date, "%Y-%m-%d").date()
+        except ValueError:
+            return []
+        qs = Scrobble.objects.filter(
+            user=self.request.user,
+            timestamp__date=dt,
+        ).order_by("-timestamp")
+        if media_type:
+            qs = qs.filter(media_type=media_type)
+        return [_scrobble_to_dict(s) for s in qs]
+
+    def get_in_progress_scrobbles(
+        self, media_type: str | None = None
+    ) -> list[dict]:
+        """Get scrobbles currently in progress (started but not finished).
+        These are long-play items like books, video games, brick sets, or tasks."""
+        qs = Scrobble.objects.filter(
+            user=self.request.user,
+            in_progress=True,
+        ).order_by("-timestamp")
+        if media_type:
+            qs = qs.filter(media_type=media_type)
+        return [_scrobble_to_dict(s) for s in qs]
+
+    def get_long_play_scrobbles(
+        self, status: str = "in_progress", media_type: str | None = None
+    ) -> list[dict]:
+        """Get long-play scrobbles (books, video games, brick sets, tasks).
+        Status can be 'in_progress' or 'completed'."""
+        types = list(LONG_PLAY_MEDIA.values())
+        qs = Scrobble.objects.filter(
+            user=self.request.user,
+            media_type__in=types,
+        ).order_by("-timestamp")
+        if media_type:
+            qs = qs.filter(media_type=media_type)
+        if status == "in_progress":
+            qs = qs.filter(in_progress=True)
+        elif status == "completed":
+            qs = qs.filter(in_progress=False)
+        return [_scrobble_to_dict(s) for s in qs]
+
+
+class MediaToolset(MCPToolset):
+    def get_book(self, uuid: str) -> dict | None:
+        """Get a book by UUID."""
+        from books.models import Book
+        try:
+            b = Book.objects.get(uuid=uuid)
+        except Book.DoesNotExist:
+            return None
+        return _media_to_dict(b, fields=["title", "pages", "language",
+                                          "first_publish_year", "isbn_13",
+                                          "publisher", "summary"])
+
+    def list_books(self, author: str | None = None, limit: int = 20) -> list[dict]:
+        """List books, optionally filtered by author name."""
+        from books.models import Book
+        qs = Book.objects.all().order_by("title")
+        if author:
+            qs = qs.filter(authors__name__icontains=author)
+        return [_media_to_dict(b, fields=["title", "pages", "language",
+                                           "first_publish_year", "isbn_13",
+                                           "publisher"]) for b in qs[:limit]]
+
+    def get_track(self, uuid: str) -> dict | None:
+        """Get a music track by UUID."""
+        from music.models import Track
+        try:
+            t = Track.objects.select_related("artist_fk").get(uuid=uuid)
+        except Track.DoesNotExist:
+            return None
+        return _media_to_dict(t, fields=["title", "base_run_time_seconds",
+                                          "artist_fk__name", "genre"])
+
+    def list_tracks(self, artist: str | None = None, limit: int = 20) -> list[dict]:
+        """List music tracks, optionally filtered by artist name."""
+        from music.models import Track
+        qs = Track.objects.select_related("artist_fk").all().order_by("title")
+        if artist:
+            qs = qs.filter(artist_fk__name__icontains=artist)
+        return [_media_to_dict(t, fields=["title", "base_run_time_seconds",
+                                           "artist_fk__name", "genre"])
+                for t in qs[:limit]]
+
+    def get_video(self, uuid: str) -> dict | None:
+        """Get a video by UUID."""
+        from videos.models import Video
+        try:
+            v = Video.objects.select_related("tv_series", "channel").get(uuid=uuid)
+        except Video.DoesNotExist:
+            return None
+        return _media_to_dict(v, fields=["title", "year", "overview",
+                                          "imdb_id", "imdb_rating",
+                                          "tv_series__name", "channel__title",
+                                          "season_number", "episode_number"])
+
+    def list_videos(self, series: str | None = None, limit: int = 20) -> list[dict]:
+        """List videos, optionally filtered by series name."""
+        from videos.models import Video
+        qs = Video.objects.select_related("tv_series", "channel").all().order_by("title")
+        if series:
+            qs = qs.filter(tv_series__name__icontains=series)
+        return [_media_to_dict(v, fields=["title", "year", "overview",
+                                           "tv_series__name", "channel__title",
+                                           "season_number", "episode_number"])
+                for v in qs[:limit]]
+
+    def get_board_game(self, uuid: str) -> dict | None:
+        """Get a board game by UUID."""
+        from boardgames.models import BoardGame
+        try:
+            bg = BoardGame.objects.get(uuid=uuid)
+        except BoardGame.DoesNotExist:
+            return None
+        return _media_to_dict(bg, fields=["title", "genre"])
+
+    def list_board_games(self, limit: int = 20) -> list[dict]:
+        """List board games."""
+        from boardgames.models import BoardGame
+        qs = BoardGame.objects.all().order_by("title")[:limit]
+        return [_media_to_dict(bg, fields=["title", "genre"]) for bg in qs]
+
+    def get_podcast_episode(self, uuid: str) -> dict | None:
+        """Get a podcast episode by UUID."""
+        from podcasts.models import PodcastEpisode
+        try:
+            pe = PodcastEpisode.objects.select_related("podcast", "producer").get(
+                uuid=uuid
+            )
+        except PodcastEpisode.DoesNotExist:
+            return None
+        return _media_to_dict(pe, fields=["title", "podcast__title",
+                                           "producer__name", "base_run_time_seconds"])
+
+    def get_beer(self, uuid: str) -> dict | None:
+        """Get a beer by UUID."""
+        from beers.models import Beer
+        try:
+            b = Beer.objects.select_related("style", "producer").get(uuid=uuid)
+        except Beer.DoesNotExist:
+            return None
+        return _media_to_dict(b, fields=["title", "style__name",
+                                          "producer__name", "abv"])
+
+    def get_brick_set(self, uuid: str) -> dict | None:
+        """Get a brick set (LEGO) by UUID."""
+        from bricksets.models import BrickSet
+        try:
+            bs = BrickSet.objects.get(uuid=uuid)
+        except BrickSet.DoesNotExist:
+            return None
+        return _media_to_dict(bs, fields=["title", "piece_count", "set_number"])
+
+    def get_video_game(self, uuid: str) -> dict | None:
+        """Get a video game by UUID."""
+        from videogames.models import VideoGame
+        try:
+            vg = VideoGame.objects.get(uuid=uuid)
+        except VideoGame.DoesNotExist:
+            return None
+        return _media_to_dict(vg, fields=["title", "genre",
+                                           "base_run_time_seconds"])
+
+    def get_puzzle(self, uuid: str) -> dict | None:
+        """Get a puzzle by UUID."""
+        from puzzles.models import Puzzle
+        try:
+            p = Puzzle.objects.select_related("manufacturer").get(uuid=uuid)
+        except Puzzle.DoesNotExist:
+            return None
+        return _media_to_dict(p, fields=["title", "piece_count",
+                                          "manufacturer__name"])
+
+    def get_web_page(self, uuid: str) -> dict | None:
+        """Get a web page by UUID."""
+        from webpages.models import WebPage
+        try:
+            wp = WebPage.objects.select_related("domain").get(uuid=uuid)
+        except WebPage.DoesNotExist:
+            return None
+        return _media_to_dict(wp, fields=["title", "url", "domain__name"])
+
+    def get_task(self, uuid: str) -> dict | None:
+        """Get a task by UUID."""
+        from tasks.models import Task
+        try:
+            t = Task.objects.get(uuid=uuid)
+        except Task.DoesNotExist:
+            return None
+        return _media_to_dict(t, fields=["title", "completed"])
+
+    def get_trail(self, uuid: str) -> dict | None:
+        """Get a trail by UUID."""
+        from trails.models import Trail
+        try:
+            t = Trail.objects.get(uuid=uuid)
+        except Trail.DoesNotExist:
+            return None
+        return _media_to_dict(t, fields=["title", "genre", "base_run_time_seconds"])
+
+    def get_geo_location(self, uuid: str) -> dict | None:
+        """Get a geo location by UUID."""
+        from locations.models import GeoLocation
+        try:
+            gl = GeoLocation.objects.get(uuid=uuid)
+        except GeoLocation.DoesNotExist:
+            return None
+        return _media_to_dict(gl, fields=["title", "latitude", "longitude"])
+
+    def get_life_event(self, uuid: str) -> dict | None:
+        """Get a life event by UUID."""
+        from lifeevents.models import LifeEvent
+        try:
+            le = LifeEvent.objects.get(uuid=uuid)
+        except LifeEvent.DoesNotExist:
+            return None
+        return _media_to_dict(le, fields=["title", "event_date", "genre"])
+
+    def get_mood(self, uuid: str) -> dict | None:
+        """Get a mood entry by UUID."""
+        from moods.models import Mood
+        try:
+            m = Mood.objects.get(uuid=uuid)
+        except Mood.DoesNotExist:
+            return None
+        return _media_to_dict(m, fields=["title", "mood_type", "mood_quality"])
+
+    def get_food(self, uuid: str) -> dict | None:
+        """Get a food entry by UUID."""
+        from foods.models import Food
+        try:
+            f = Food.objects.select_related("category").get(uuid=uuid)
+        except Food.DoesNotExist:
+            return None
+        return _media_to_dict(f, fields=["title", "category__name"])
+
+    def get_bird_sighting(self, uuid: str) -> dict | None:
+        """Get a bird sighting by UUID."""
+        from birds.models import BirdSighting
+        try:
+            bs = BirdSighting.objects.select_related("bird").get(uuid=uuid)
+        except BirdSighting.DoesNotExist:
+            return None
+        return _media_to_dict(bs, fields=["title", "bird__common_name",
+                                           "bird__scientific_name", "location"])
+
+    def get_disc_golf_course(self, uuid: str) -> dict | None:
+        """Get a disc golf course by UUID."""
+        from discgolf.models import DiscGolfCourse
+        try:
+            dg = DiscGolfCourse.objects.get(uuid=uuid)
+        except DiscGolfCourse.DoesNotExist:
+            return None
+        return _media_to_dict(dg, fields=["title", "holes", "location"])
+
+
+class StatsToolset(MCPToolset):
+    def get_scrobble_counts(self, days: int = 30) -> list[dict]:
+        """Get scrobble counts grouped by media type for the last N days."""
+        from django.utils import timezone
+        import datetime
+        from django.db.models import Count
+
+        cutoff = timezone.now() - datetime.timedelta(days=days)
+        qs = (
+            Scrobble.objects.filter(user=self.request.user, timestamp__gte=cutoff)
+            .values("media_type")
+            .annotate(count=Count("id"))
+            .order_by("-count")
+        )
+        return list(qs)
+
+    def get_top_media(
+        self, media_type: str, days: int = 30, limit: int = 10
+    ) -> list[dict]:
+        """Get the most-scrobbled items of a given media type in the last N days.
+        Valid media_type values: Video, Track, Book, BoardGame, Beer, etc."""
+        from django.utils import timezone
+        import datetime
+        from django.db.models import Count
+
+        cutoff = timezone.now() - datetime.timedelta(days=days)
+
+        rel_field = _media_type_to_rel_field(media_type)
+        if not rel_field:
+            return []
+
+        qs = (
+            Scrobble.objects.filter(
+                user=self.request.user,
+                media_type=media_type,
+                timestamp__gte=cutoff,
+            )
+            .values(rel_field)
+            .annotate(count=Count("id"))
+            .order_by("-count")
+        )[:limit]
+
+        results = []
+        for row in qs:
+            obj_id = row[rel_field]
+            if obj_id is None:
+                continue
+            results.append({"id": obj_id, "count": row["count"]})
+        return results
+
+
+def _media_type_to_rel_field(media_type: str) -> str | None:
+    mapping = {
+        "Video": "video",
+        "Track": "track",
+        "PodcastEpisode": "podcast_episode",
+        "SportEvent": "sport_event",
+        "Book": "book",
+        "Paper": "paper",
+        "VideoGame": "video_game",
+        "BoardGame": "board_game",
+        "GeoLocation": "geo_location",
+        "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",
+        "DiscGolfCourse": "disc_golf_course",
+    }
+    return mapping.get(media_type)
+
+
+def _scrobble_to_dict(s: Scrobble) -> dict:
+    result = {
+        "uuid": str(s.uuid),
+        "media_type": s.media_type,
+        "timestamp": s.timestamp.isoformat() if s.timestamp else None,
+        "stop_timestamp": s.stop_timestamp.isoformat() if s.stop_timestamp else None,
+        "in_progress": s.in_progress,
+        "played_to_completion": s.played_to_completion,
+        "source": s.source,
+        "visibility": s.visibility,
+        "timezone": s.timezone,
+    }
+    if s.log:
+        result["log"] = s.log
+
+    rel = _scrobble_related_to_dict(s)
+    if rel:
+        result["media"] = rel
+
+    return result
+
+
+def _scrobble_related_to_dict(s: Scrobble) -> dict | None:
+    if s.video:
+        return _media_to_dict(s.video, fields=["title", "year", "imdb_id",
+                                                "imdb_rating"])
+    if s.track:
+        return _media_to_dict(s.track, fields=["title",
+                                                "base_run_time_seconds"])
+    if s.book:
+        return _media_to_dict(s.book, fields=["title", "pages"])
+    if s.video_game:
+        return _media_to_dict(s.video_game, fields=["title",
+                                                     "base_run_time_seconds"])
+    if s.board_game:
+        return _media_to_dict(s.board_game, fields=["title"])
+    if s.beer:
+        return _media_to_dict(s.beer, fields=["title"])
+    if s.puzzle:
+        return _media_to_dict(s.puzzle, fields=["title", "piece_count"])
+    if s.food:
+        return _media_to_dict(s.food, fields=["title"])
+    if s.trail:
+        return _media_to_dict(s.trail, fields=["title",
+                                                "base_run_time_seconds"])
+    if s.task:
+        return _media_to_dict(s.task, fields=["title"])
+    if s.web_page:
+        return _media_to_dict(s.web_page, fields=["title", "url"])
+    if s.life_event:
+        return _media_to_dict(s.life_event, fields=["title", "event_date"])
+    if s.mood:
+        return _media_to_dict(s.mood, fields=["title"])
+    if s.brick_set:
+        return _media_to_dict(s.brick_set, fields=["title", "set_number"])
+    if s.podcast_episode:
+        return _media_to_dict(s.podcast_episode, fields=["title"])
+    if s.sport_event:
+        return {"title": str(s.sport_event)}
+    if s.geo_location:
+        return _media_to_dict(s.geo_location, fields=["title", "latitude",
+                                                       "longitude"])
+    if s.birding_location:
+        return _media_to_dict(s.birding_location, fields=["title"])
+    if s.disc_golf_course:
+        return _media_to_dict(s.disc_golf_course, fields=["title", "holes"])
+    if s.channel:
+        return _media_to_dict(s.channel, fields=["title"])
+    return None
+
+
+def _media_to_dict(obj, fields: list[str] | None = None) -> dict:
+    if obj is None:
+        return {}
+    result = {}
+    if hasattr(obj, "uuid"):
+        result["uuid"] = str(obj.uuid)
+    if hasattr(obj, "title"):
+        result["title"] = obj.title
+
+    if fields is None:
+        return result
+
+    resolved = _resolve_fields(obj, fields)
+    for k, v in resolved.items():
+        if k not in result:
+            result[k] = v
+
+    return result
+
+
+def _resolve_fields(obj, fields: list[str]) -> dict:
+    result = {}
+    for field in fields:
+        parts = field.split("__")
+        val = obj
+        try:
+            for part in parts:
+                val = getattr(val, part)
+        except AttributeError:
+            continue
+        if val is not None:
+            if hasattr(val, "all"):
+                val = [str(v) for v in val.all()]
+            result[field] = val
+    return result

vrobbler/apps/scrobbles/migrations/0099_favoritemedia_disc_golf_scrobble_disc_golf_and_more.py

@@ -0,0 +1,156 @@
+# Generated by Django 4.2.29 on 2026-06-20 04:19
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+import scrobbles.models
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("discgolf", "0001_initial"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("scrobbles", "0098_scrobble_long_play_last_scrobble"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="favoritemedia",
+            name="disc_golf",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                to="discgolf.discgolfcourse",
+            ),
+        ),
+        migrations.AddField(
+            model_name="scrobble",
+            name="disc_golf",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to="discgolf.discgolfcourse",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="favoritemedia",
+            name="media_type",
+            field=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"),
+                    ("DiscGolf", "Disc golf"),
+                ],
+                max_length=20,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="scrobble",
+            name="media_type",
+            field=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"),
+                    ("DiscGolf", "Disc golf"),
+                ],
+                default="Video",
+                max_length=20,
+            ),
+        ),
+        migrations.CreateModel(
+            name="UDiscCSVImport",
+            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(default=uuid.uuid4, editable=False)),
+                ("processing_started", models.DateTimeField(blank=True, null=True)),
+                ("processed_finished", models.DateTimeField(blank=True, null=True)),
+                ("process_log", models.TextField(blank=True, null=True)),
+                ("process_count", models.IntegerField(blank=True, null=True)),
+                ("error_log", models.TextField(blank=True, null=True)),
+                (
+                    "csv_file",
+                    models.FileField(
+                        blank=True,
+                        null=True,
+                        upload_to=scrobbles.models.UDiscCSVImport.get_path,
+                    ),
+                ),
+                (
+                    "original_filename",
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        related_name="scrobbles_udisccsvimport_set",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "uDisc CSV Import",
+            },
+        ),
+    ]

vrobbler/apps/scrobbles/migrations/0100_rename_disc_golf_favoritemedia_disc_golf_course_and_more.py

@@ -0,0 +1,84 @@
+# Generated by Django 4.2.29 on 2026-06-20 04:53
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("scrobbles", "0099_favoritemedia_disc_golf_scrobble_disc_golf_and_more"),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name="favoritemedia",
+            old_name="disc_golf",
+            new_name="disc_golf_course",
+        ),
+        migrations.RenameField(
+            model_name="scrobble",
+            old_name="disc_golf",
+            new_name="disc_golf_course",
+        ),
+        migrations.AlterField(
+            model_name="favoritemedia",
+            name="media_type",
+            field=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"),
+                    ("DiscGolfCourse", "Disc golf"),
+                ],
+                max_length=20,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="scrobble",
+            name="media_type",
+            field=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"),
+                    ("DiscGolfCourse", "Disc golf"),
+                ],
+                default="Video",
+                max_length=20,
+            ),
+        ),
+    ]

vrobbler/apps/scrobbles/mixins.py

@@ -114,7 +114,7 @@ class ScrobblableMixin(TimeStampedModel):
 
     @property
     def start_url(self):
-        return reverse("scrobbles:start", kwargs={"uuid": self.uuid})
+        return reverse("scrobbles:start", kwargs={"media_uuid": self.uuid})
 
     @property
     def strings(self) -> ScrobblableConstants:
@@ -162,7 +162,7 @@ class LongPlayScrobblableMixin(ScrobblableMixin):
         return False
 
     def get_longplay_finish_url(self):
-        return reverse("scrobbles:longplay-finish", kwargs={"uuid": self.uuid})
+        return reverse("scrobbles:longplay-finish", kwargs={"media_uuid": self.uuid})
 
     def first_long_play_scrobble_for_user(self, user) -> Optional["Scrobble"]:
         last = self.last_long_play_scrobble_for_user(user)

vrobbler/apps/scrobbles/models.py

@@ -11,6 +11,7 @@ import pendulum
 import pytz
 from beers.models import Beer
 from birds.models import BirdingLocation
+from discgolf.models import DiscGolfCourse
 from boardgames.models import BoardGame
 from books.koreader import process_koreader_sqlite_file
 from books.models import Book, BookLogData, BookPageLogData, Paper
@@ -617,6 +618,60 @@ class EBirdCSVImport(BaseFileImportMixin):
             self.mark_finished()
 
 
+class UDiscCSVImport(BaseFileImportMixin):
+    class Meta:
+        verbose_name = "uDisc CSV Import"
+
+    user = models.ForeignKey(
+        User,
+        on_delete=models.DO_NOTHING,
+        **BNULL,
+        related_name="scrobbles_udisccsvimport_set",
+    )
+
+    @property
+    def import_type(self) -> str:
+        return "uDisc"
+
+    def get_absolute_url(self):
+        return reverse("scrobbles:udisc-csv-import-detail", kwargs={"slug": self.uuid})
+
+    def get_path(instance, filename):
+        extension = filename.split(".")[-1]
+        uuid = instance.uuid
+        return f"udisc-csv-uploads/{uuid}.{extension}"
+
+    @property
+    def upload_file_path(self):
+        if getattr(settings, "USE_S3_STORAGE"):
+            path = self.csv_file.url
+        else:
+            path = self.csv_file.path
+        return path
+
+    csv_file = models.FileField(upload_to=get_path, **BNULL)
+    original_filename = models.CharField(max_length=255, **BNULL)
+
+    def process(self, force=False):
+        from discgolf.utils import import_udisc_csv
+
+        if self.processed_finished and not force:
+            logger.info(f"{self} already processed on {self.processed_finished}")
+            return
+
+        self.mark_started()
+        try:
+            scrobbles = import_udisc_csv(
+                self.upload_file_path, self.user_id, record_error=self.record_error
+            )
+            self.record_log(scrobbles)
+        except Exception as e:
+            self.record_error(f"Import failed: {e}")
+            logger.exception(f"Import failed for {self}")
+        finally:
+            self.mark_finished()
+
+
 TYPE_FK_PREFETCHES: dict[str, tuple[str, ...]] = {
     "Video": ("video",),
     "Track": ("track", "track__artist_fk"),
@@ -638,6 +693,7 @@ TYPE_FK_PREFETCHES: dict[str, tuple[str, ...]] = {
     "BrickSet": ("brick_set",),
     "Channel": ("channel",),
     "BirdingLocation": ("birding_location",),
+    "DiscGolfCourse": ("disc_golf_course",),
 }
 
 
@@ -665,6 +721,7 @@ class ScrobbleQuerySet(models.QuerySet):
             "mood",
             "brick_set",
             "birding_location",
+            "disc_golf_course",
         )
 
     def with_related_for_types(self, media_types: list[str]):
@@ -715,6 +772,7 @@ class Scrobble(TimeStampedModel):
         BRICKSET = "BrickSet", "Brick set"
         CHANNEL = "Channel", "Channel"
         BIRDING_LOCATION = "BirdingLocation", "Birding location"
+        DISC_GOLF = "DiscGolfCourse", "Disc golf"
 
         @classmethod
         def list(cls):
@@ -745,6 +803,9 @@ class Scrobble(TimeStampedModel):
     birding_location = models.ForeignKey(
         BirdingLocation, on_delete=models.DO_NOTHING, **BNULL
     )
+    disc_golf_course = models.ForeignKey(
+        DiscGolfCourse, on_delete=models.DO_NOTHING, **BNULL
+    )
     media_type = models.CharField(
         max_length=20, choices=MediaType.choices, default=MediaType.VIDEO
     )
@@ -798,6 +859,12 @@ class Scrobble(TimeStampedModel):
         format="JPEG",
         options={"quality": 75},
     )
+    screenshot_large = ImageSpecField(
+        source="screenshot",
+        processors=[ResizeToFit(800, 800)],
+        format="JPEG",
+        options={"quality": 85},
+    )
     long_play_seconds = models.BigIntegerField(**BNULL)
     long_play_complete = models.BooleanField(**BNULL)
     long_play_last_scrobble = models.ForeignKey(
@@ -900,7 +967,7 @@ class Scrobble(TimeStampedModel):
 
     @property
     def finish_url(self) -> str:
-        return reverse("scrobbles:finish", kwargs={"uuid": self.uuid})
+        return reverse("scrobbles:finish", kwargs={"pk": self.pk})
 
     def save(self, *args, **kwargs):
         class_name = self.media_obj.__class__.__name__
@@ -942,10 +1009,7 @@ class Scrobble(TimeStampedModel):
         return super(Scrobble, self).save(*args, **kwargs)
 
     def get_absolute_url(self):
-        if not self.uuid:
+        return reverse("scrobbles:detail", kwargs={"pk": self.pk})
-            self.uuid = uuid4()
-            self.save(update_fields=["uuid"])
-        return reverse("scrobbles:detail", kwargs={"uuid": self.uuid})
 
     def get_share_url(self):
         if self.visibility == Visibility.PRIVATE:
@@ -1313,6 +1377,8 @@ class Scrobble(TimeStampedModel):
             media_obj = self.channel
         if self.birding_location:
             media_obj = self.birding_location
+        if self.disc_golf_course:
+            media_obj = self.disc_golf_course
         return media_obj
 
     def __str__(self):
@@ -1871,6 +1937,9 @@ class FavoriteMedia(TimeStampedModel):
     birding_location = models.ForeignKey(
         BirdingLocation, on_delete=models.CASCADE, **BNULL
     )
+    disc_golf_course = models.ForeignKey(
+        DiscGolfCourse, on_delete=models.CASCADE, **BNULL
+    )
     media_type = models.CharField(max_length=20, choices=Scrobble.MediaType.choices)
     sent_to_mopidy = models.BooleanField(default=False)
 
@@ -1921,6 +1990,8 @@ class FavoriteMedia(TimeStampedModel):
             media_obj = self.channel
         if self.birding_location:
             media_obj = self.birding_location
+        if self.disc_golf_course:
+            media_obj = self.disc_golf_course
         return media_obj
 
     @classmethod
@@ -1950,6 +2021,7 @@ class FavoriteMedia(TimeStampedModel):
             "Mood": "mood",
             "BrickSet": "brick_set",
             "BirdingLocation": "birding_location",
+            "DiscGolfCourse": "disc_golf_course",
         }
 
         fk = fk_map.get(media_type)

vrobbler/apps/scrobbles/scrobblers.py

@@ -13,6 +13,7 @@ from books.models import Book, BookLogData, BookPageLogData
 from books.utils import parse_readcomicsonline_uri
 from bricksets.models import BrickSet
 from dateutil.parser import parse
+from discgolf.models import DiscGolfCourse
 from django.utils import timezone
 from foods.models import Food
 from foods.sources.rscraper import RecipeScraperService
@@ -330,8 +331,6 @@ def manual_scrobble_book(
 
         source = READCOMICSONLINE_URL.replace("https://", "")
 
-    # TODO: Check for scrobble of this book already and if so, update the page count
-
     book = Book.find_or_create(title, url=url, enrich=True)
 
     scrobble_dict = {
@@ -1329,3 +1328,32 @@ def manual_scrobble_food(
     )
 
     return Scrobble.create_or_update(food, user_id, scrobble_dict)
+
+
+def manual_scrobble_discgolf(
+    item_id: str,
+    user_id: int,
+    source: str = "Vrobbler",
+    action: Optional[str] = None,
+):
+    from discgolf.models import DiscGolfCourse
+
+    course, _ = DiscGolfCourse.objects.get_or_create(title=item_id.strip())
+
+    scrobble_dict = {
+        "user_id": user_id,
+        "timestamp": timezone.now(),
+        "playback_position_seconds": 0,
+        "source": source,
+    }
+
+    logger.info(
+        "[scrobblers] manual disc golf scrobble request received",
+        extra={
+            "course_id": course.id,
+            "user_id": user_id,
+            "scrobble_dict": scrobble_dict,
+        },
+    )
+
+    return Scrobble.create_or_update(course, user_id, scrobble_dict)

vrobbler/apps/scrobbles/signals.py

@@ -1,5 +1,6 @@
 import logging
 
+from django.core.cache import cache
 from django.db.models.signals import post_delete, post_save
 from django.dispatch import receiver
 from django.utils import timezone
@@ -9,6 +10,7 @@ from scrobbles.tasks import (
     add_favorite_to_mopidy_playlist,
     CHARTABLE_MEDIA_TYPES,
     remove_favorite_from_mopidy_playlist,
+    reverse_geocode_geolocation,
     SCROBBLES_WITHOUT_CHARTS,
     update_charts_for_timestamp,
 )
@@ -52,6 +54,11 @@ def _update_charts_for_timestamp(user, ts):
     if ts is None:
         return
 
+    lock_key = f"chart_update_{user.id}"
+    if not cache.add(lock_key, "locked", timeout=30):
+        logger.info(f"Chart update already queued for user {user.id}, skipping")
+        return
+
     if timezone.is_naive(ts):
         ts = timezone.make_aware(ts)
 
@@ -80,6 +87,31 @@ def add_tags_from_task_title(sender, instance, **kwargs):
             instance.tags.add(tag)
 
 
+@receiver(post_save, sender=Scrobble)
+def reverse_geocode_on_scrobble_creation(sender, instance, created, **kwargs):
+    if not created:
+        return
+    if not instance.geo_location_id:
+        logger.info(
+            "Skipping reverse geocode: scrobble %s has no geo_location",
+            instance.id,
+        )
+        return
+    if instance.geo_location.postal_code:
+        logger.info(
+            "Skipping reverse geocode: geo_location %s already has postal_code %s",
+            instance.geo_location_id,
+            instance.geo_location.postal_code,
+        )
+        return
+
+    logger.info(
+        "Enqueuing reverse geocode for geo_location %s",
+        instance.geo_location_id,
+    )
+    reverse_geocode_geolocation.delay(instance.geo_location_id)
+
+
 @receiver(post_save, sender=FavoriteMedia)
 def add_to_mopidy_playlist_on_favorite(sender, instance, created, **kwargs):
     if not created:

vrobbler/apps/scrobbles/tasks.py

@@ -12,6 +12,7 @@ from charts.utils import (
 from django.apps import apps
 from django.conf import settings
 from django.contrib.auth import get_user_model
+from django.core.cache import cache
 from django.db import models
 from django.utils import timezone
 
@@ -170,6 +171,16 @@ def process_ebird_csv_import(import_id):
     birding_import.process()
 
 
+@shared_task
+def process_udisc_csv_import(import_id):
+    UDiscCSVImport = apps.get_model("scrobbles", "UDiscCSVImport")
+    udisc_import = UDiscCSVImport.objects.filter(id=import_id).first()
+    if not udisc_import:
+        logger.warn(f"UDiscCSVImport not found with id {import_id}")
+        return
+    udisc_import.process()
+
+
 @shared_task
 def process_scale_csv_import(import_id):
     ScaleCSVImport = apps.get_model("scrobbles", "ScaleCSVImport")
@@ -241,6 +252,11 @@ def update_charts_for_timestamp(user_id, year, month, day, week):
         logger.error(f"User with id {user_id} not found")
         return
 
+    lock_key = f"chart_update_running_{user_id}"
+    if not cache.add(lock_key, "locked", timeout=300):
+        logger.info(f"Chart update already running for user {user_id}, skipping")
+        return
+
     try:
         build_daily_charts(user, year, month, day, CHARTABLE_MEDIA_TYPES)
         build_weekly_charts(user, year, week, CHARTABLE_MEDIA_TYPES)
@@ -250,6 +266,8 @@ def update_charts_for_timestamp(user_id, year, month, day, week):
         logger.info(f"[charts] Updated charts for {user} on {date_str}")
     except Exception as e:
         logger.error(f"[charts] Failed to update charts: {e}")
+    finally:
+        cache.delete(lock_key)
 
 
 @shared_task
@@ -708,3 +726,41 @@ def add_scrobble_to_mopidy_monthly_playlist(scrobble_id):
                 break
 
     add_track_to_mopidy_monthly_playlist(scrobble)
+
+
+@shared_task
+def reverse_geocode_geolocation(geo_location_id):
+    from locations.models import GeoLocation
+
+    location = GeoLocation.objects.filter(id=geo_location_id).first()
+    if not location:
+        logger.info(
+            "Skipping reverse geocode: geo_location %s not found",
+            geo_location_id,
+        )
+        return
+    if location.postal_code:
+        logger.info(
+            "Skipping reverse geocode: geo_location %s already has postal_code %s",
+            geo_location_id,
+            location.postal_code,
+        )
+        return
+
+    logger.info(
+        "Reverse geocoding geo_location %s (%s, %s)",
+        geo_location_id,
+        location.lat,
+        location.lon,
+    )
+    if location.reverse_geocode():
+        logger.info(
+            "Reverse geocode succeeded for geo_location %s: %s",
+            geo_location_id,
+            location.display_address,
+        )
+    else:
+        logger.warning(
+            "Reverse geocode failed for geo_location %s",
+            geo_location_id,
+        )

vrobbler/apps/scrobbles/urls.py

@@ -5,6 +5,7 @@ from tasks.webhooks import EmacsWebhookView, TodoistWebhookView
 app_name = "scrobbles"
 
 urlpatterns = [
+    path("now-playing/", views.NowPlayingPartialView.as_view(), name="now-playing-partial"),
     path("calendar/", views.ScrobbleCalendarView.as_view(), name="calendar"),
     path("search/", views.ScrobbleSearchView.as_view(), name="search"),
     path("status/", views.ScrobbleStatusView.as_view(), name="status"),
@@ -44,7 +45,7 @@ urlpatterns = [
         name="lookup-manual-scrobble",
     ),
     path(
-        "long-play-finish/<slug:uuid>/",
+        "long-play-finish/<slug:media_uuid>/",
         views.scrobble_longplay_finish,
         name="longplay-finish",
     ),
@@ -147,6 +148,11 @@ urlpatterns = [
         views.ScrobbleBirdingCSVImportDetailView.as_view(),
         name="ebird-csv-import-detail",
     ),
+    path(
+        "imports/udisc-csv/<slug:slug>/",
+        views.ScrobbleUDiscCSVImportDetailView.as_view(),
+        name="udisc-csv-import-detail",
+    ),
     path(
         "long-plays/",
         views.ScrobbleLongPlaysView.as_view(),
@@ -160,38 +166,38 @@ urlpatterns = [
         name="shared-detail",
     ),
     path(
-        "scrobbles/<slug:uuid>/",
+        "scrobbles/<int:pk>/",
         views.ScrobbleDetailView.as_view(),
         name="detail",
     ),
     path(
-        "scrobbles/<slug:uuid>/regenerate-share-token/",
+        "scrobbles/<int:pk>/regenerate-share-token/",
         views.RegenerateShareTokenView.as_view(),
         name="regenerate-share-token",
     ),
     path(
-        "scrobbles/<slug:uuid>/change-visibility/",
+        "scrobbles/<int:pk>/change-visibility/",
         views.ChangeVisibilityView.as_view(),
         name="change-visibility",
     ),
     path(
-        "scrobbles/<slug:uuid>/share-analytics/",
+        "scrobbles/<int:pk>/share-analytics/",
         views.ScrobbleShareAnalyticsView.as_view(),
         name="share-analytics",
     ),
     path(
-        "scrobbles/<slug:uuid>/add-to-mopidy-queue/",
+        "scrobbles/<int:pk>/add-to-mopidy-queue/",
         views.add_to_mopidy_queue,
         name="add-to-mopidy-queue",
     ),
     path(
-        "scrobbles/<slug:uuid>/add-to-mopidy-monthly-playlist/",
+        "scrobbles/<int:pk>/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:media_uuid>/start/", views.scrobble_start, name="start"),
-    path("scrobbles/<slug:uuid>/finish/", views.scrobble_finish, name="finish"),
+    path("scrobbles/<int:pk>/finish/", views.scrobble_finish, name="finish"),
-    path("scrobbles/<slug:uuid>/cancel/", views.scrobble_cancel, name="cancel"),
+    path("scrobbles/<int:pk>/cancel/", views.scrobble_cancel, name="cancel"),
     path(
         "favorite/<str:media_type>/<int:object_id>/toggle/",
         views.toggle_favorite,

vrobbler/apps/scrobbles/utils.py

@@ -1,4 +1,5 @@
 import hashlib
+import html
 import logging
 import requests
 import re
@@ -153,10 +154,11 @@ def import_lastfm_for_all_users(restart=False):
             last_processed = lfm_import.processed_finished
         else:
             logger.info(
-                f"Not resuming failed LastFM import {lfm_import.id} for user {user_id}, use restart=True to restart"
+                "No existing LastFM import for user %s, "
-                "No existing LastFM import, we should start a monthly parsing of lastFm for this user going back to 2002"
+                "starting a full parse",
+                user_id,
             )
-            continue
+            last_processed = None
 
         lfm_client = LastFM(user=get_user_model().objects.filter(id=user_id).first())
 
@@ -795,6 +797,7 @@ def tokenize_title_to_tags(title: str) -> list[str]:
     if not title:
         return []
 
+    title = html.unescape(title)
     cleaned = re.sub(r"[\(\)\[\]\{\}]", "", title)
     cleaned = re.sub(r"[^\w\s]", "", cleaned)
 

vrobbler/apps/scrobbles/views.py

@@ -87,6 +87,7 @@ from scrobbles.models import (
     ScrobbleQuerySet,
     ShareViewLog,
     TrailGPXImport,
+    UDiscCSVImport,
 )
 from scrobbles.scrobblers import *
 from scrobbles.tasks import (
@@ -360,11 +361,35 @@ class RecentScrobbleList(ListView):
         return Scrobble.objects.all().order_by("-timestamp")
 
 
+class NowPlayingPartialView(LoginRequiredMixin, TemplateView):
+    template_name = "scrobbles/_now_playing.html"
+
+    def get_context_data(self, **kwargs):
+        ctx = super().get_context_data(**kwargs)
+        from scrobbles.constants import EXCLUDE_FROM_NOW_PLAYING
+
+        ctx["now_playing_list"] = list(
+            Scrobble.objects.filter(
+                in_progress=True,
+                is_paused=False,
+                user=self.request.user,
+            )
+            .exclude(media_type__in=EXCLUDE_FROM_NOW_PLAYING)
+            .select_related("track", "video", "podcast_episode")
+        )
+        return ctx
+
+
 class ScrobbleListView(LoginRequiredMixin, ListView):
     model = Scrobble
     paginate_by = 100
     template_name = "scrobbles/scrobble_all_list.html"
 
+    def get_template_names(self):
+        if self.request.headers.get("HX-Request"):
+            return ["scrobbles/_scrobble_all_content.html"]
+        return ["scrobbles/scrobble_all_list.html"]
+
     def get_queryset(self):
         qs = Scrobble.objects.filter(user=self.request.user).order_by("-timestamp")
         tags_param = self.request.GET.get("tags", "")
@@ -535,6 +560,8 @@ class BaseScrobbleImportDetailView(DetailView):
             title = "Scale CSV Import"
         if self.model == TrailGPXImport:
             title = "Trail GPX Import"
+        if self.model == UDiscCSVImport:
+            title = "uDisc CSV Import"
         context_data["title"] = title
         return context_data
 
@@ -571,6 +598,10 @@ class ScrobbleBirdingCSVImportDetailView(BaseScrobbleImportDetailView):
     model = EBirdCSVImport
 
 
+class ScrobbleUDiscCSVImportDetailView(BaseScrobbleImportDetailView):
+    model = UDiscCSVImport
+
+
 class ManualScrobbleView(FormView):
     form_class = ScrobbleForm
     template_name = "scrobbles/manual_form.html"
@@ -839,10 +870,10 @@ def import_audioscrobbler_file(request):
 
 @api_view(["GET"])
 @permission_classes([IsAuthenticated])
-def scrobble_start(request, uuid):
+def scrobble_start(request, media_uuid):
     logger.info(
         "[scrobble_start] called",
-        extra={"request": request, "uuid": uuid},
+        extra={"request": request, "media_uuid": media_uuid},
     )
     user = request.user
     success_url = request.META.get("HTTP_REFERER")
@@ -853,14 +884,14 @@ def scrobble_start(request, uuid):
     media_obj = None
     for app, model in PLAY_AGAIN_MEDIA.items():
         media_model = apps.get_model(app_label=app, model_name=model)
-        media_obj = media_model.objects.filter(uuid=uuid).first()
+        media_obj = media_model.objects.filter(uuid=media_uuid).first()
         if media_obj:
             break
 
     if not media_obj:
         logger.info(
             "[scrobble_start] media object not found",
-            extra={"uuid": uuid, "user_id": user.id},
+            extra={"media_uuid": media_uuid, "user_id": user.id},
         )
         raise Exception("No media object provided to scrobble")
 
@@ -887,7 +918,7 @@ def scrobble_start(request, uuid):
             if last_scrobble and last_scrobble.logdata:
                 next_page = last_scrobble.logdata.page_end + 1
                 log_data = {"page_start": next_page}
-        media_obj.scrobble_for_user(user_id, log=log_data)
+        scrobble = media_obj.scrobble_for_user(user_id, log=log_data)
 
     if scrobble:
         messages.add_message(
@@ -897,7 +928,7 @@ def scrobble_start(request, uuid):
         )
     else:
         messages.add_message(
-            request, messages.ERROR, f"Media with uuid {uuid} not found."
+            request, messages.ERROR, f"Media with uuid {media_uuid} not found."
         )
 
     if (
@@ -915,7 +946,7 @@ def scrobble_start(request, uuid):
 
 
 @api_view(["GET"])
-def scrobble_longplay_finish(request, uuid):
+def scrobble_longplay_finish(request, media_uuid):
     user = request.user
     success_url = request.META.get("HTTP_REFERER")
 
@@ -923,7 +954,7 @@ def scrobble_longplay_finish(request, uuid):
         return HttpResponseRedirect(success_url)
 
     # Try scrobble UUID first
-    scrobble = Scrobble.objects.filter(uuid=uuid, user=user).first()
+    scrobble = Scrobble.objects.filter(uuid=media_uuid, user=user).first()
     if scrobble:
         if scrobble.long_play_complete == True:
             scrobble.long_play_complete = None
@@ -947,13 +978,13 @@ def scrobble_longplay_finish(request, uuid):
     media_obj = None
     for app, model in LONG_PLAY_MEDIA.items():
         media_model = apps.get_model(app_label=app, model_name=model)
-        media_obj = media_model.objects.filter(uuid=uuid).first()
+        media_obj = media_model.objects.filter(uuid=media_uuid).first()
         if media_obj:
             break
 
     if not media_obj:
         messages.add_message(
-            request, messages.ERROR, f"Media with uuid {uuid} not found."
+            request, messages.ERROR, f"Media with uuid {media_uuid} not found."
         )
         return HttpResponseRedirect(success_url)
 
@@ -976,14 +1007,14 @@ def scrobble_longplay_finish(request, uuid):
         )
     else:
         messages.add_message(
-            request, messages.ERROR, f"Media with uuid {uuid} not found."
+            request, messages.ERROR, f"Media with uuid {media_uuid} not found."
         )
     return HttpResponseRedirect(success_url)
 
 
 @api_view(["GET"])
 @permission_classes([IsAuthenticated])
-def scrobble_finish(request, uuid):
+def scrobble_finish(request, pk):
     user = request.user
     success_url = request.META.get("HTTP_REFERER")
     if not success_url:
@@ -992,7 +1023,7 @@ def scrobble_finish(request, uuid):
     if not user.is_authenticated:
         return HttpResponseRedirect(success_url)
 
-    scrobble = Scrobble.objects.filter(user=user, uuid=uuid).first()
+    scrobble = Scrobble.objects.filter(user=user, pk=pk).first()
     if scrobble:
         scrobble.stop(force_finish=True)
         messages.add_message(
@@ -1007,14 +1038,14 @@ def scrobble_finish(request, uuid):
 
 @api_view(["GET"])
 @permission_classes([IsAuthenticated])
-def scrobble_cancel(request, uuid):
+def scrobble_cancel(request, pk):
     user = request.user
     success_url = reverse_lazy("vrobbler-home")
 
     if not user.is_authenticated:
         return HttpResponseRedirect(success_url)
 
-    scrobble = Scrobble.objects.filter(user=user, uuid=uuid).first()
+    scrobble = Scrobble.objects.filter(user=user, pk=pk).first()
     if scrobble:
         scrobble.cancel()
         messages.add_message(
@@ -1028,11 +1059,11 @@ def scrobble_cancel(request, uuid):
 
 
 @require_POST
-def add_to_mopidy_queue(request, uuid):
+def add_to_mopidy_queue(request, pk):
     if not request.user.is_authenticated:
-        return redirect("scrobbles:detail", uuid=uuid)
+        return redirect("scrobbles:detail", pk=pk)
 
-    scrobble = get_object_or_404(Scrobble, uuid=uuid, user=request.user)
+    scrobble = get_object_or_404(Scrobble, pk=pk, user=request.user)
     mopidy_url = request.user.profile.mopidy_api_url
 
     if not mopidy_url:
@@ -1041,22 +1072,22 @@ def add_to_mopidy_queue(request, uuid):
             messages.ERROR,
             "Mopidy API URL not configured in your profile settings.",
         )
-        return redirect("scrobbles:detail", uuid=uuid)
+        return redirect("scrobbles:detail", pk=pk)
 
     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)
+    return redirect("scrobbles:detail", pk=pk)
 
 
 @require_POST
-def add_to_mopidy_monthly_playlist(request, uuid):
+def add_to_mopidy_monthly_playlist(request, pk):
     if not request.user.is_authenticated:
-        return redirect("scrobbles:detail", uuid=uuid)
+        return redirect("scrobbles:detail", pk=pk)
 
-    scrobble = get_object_or_404(Scrobble, uuid=uuid, user=request.user)
+    scrobble = get_object_or_404(Scrobble, pk=pk, user=request.user)
     profile = request.user.profile
     pattern = profile.monthly_mopidy_playlist_pattern
 
@@ -1066,7 +1097,7 @@ def add_to_mopidy_monthly_playlist(request, uuid):
             messages.ERROR,
             "Monthly playlist pattern or Mopidy API URL not configured in your profile.",
         )
-        return redirect("scrobbles:detail", uuid=uuid)
+        return redirect("scrobbles:detail", pk=pk)
 
     now = now_user_timezone(profile)
     playlist_name = DateFormat(now).format(pattern)
@@ -1079,7 +1110,7 @@ def add_to_mopidy_monthly_playlist(request, uuid):
         messages.SUCCESS,
         f'Adding "{scrobble.media_obj}" to monthly playlist "{playlist_name}".',
     )
-    return redirect("scrobbles:detail", uuid=uuid)
+    return redirect("scrobbles:detail", pk=pk)
 
 
 @require_POST
@@ -1108,6 +1139,7 @@ def toggle_favorite(request, media_type, object_id):
         "Mood": ("moods", "Mood"),
         "BrickSet": ("bricksets", "BrickSet"),
         "BirdingLocation": ("birds", "BirdingLocation"),
+        "DiscGolfCourse": ("discgolf", "DiscGolfCourse"),
     }
 
     app_label, model_name = app_model_map.get(media_type, (None, None))
@@ -1184,8 +1216,6 @@ class ScrobbleStatusView(LoginRequiredMixin, TemplateView):
 
 class ScrobbleDetailView(DetailView):
     model = Scrobble
-    slug_field = "uuid"
-    slug_url_kwarg = "uuid"
     paginate_by = 100
 
     def get_object(self, queryset=None):
@@ -1385,15 +1415,15 @@ class ScrobbleExploreView(ListView):
 
 
 class RegenerateShareTokenView(LoginRequiredMixin, View):
-    def post(self, request, uuid):
+    def post(self, request, pk):
-        scrobble = get_object_or_404(Scrobble, uuid=uuid, user=request.user)
+        scrobble = get_object_or_404(Scrobble, pk=pk, user=request.user)
         scrobble.regenerate_share_token()
         return redirect(scrobble.get_absolute_url())
 
 
 class ChangeVisibilityView(LoginRequiredMixin, View):
-    def post(self, request, uuid):
+    def post(self, request, pk):
-        scrobble = get_object_or_404(Scrobble, uuid=uuid, user=request.user)
+        scrobble = get_object_or_404(Scrobble, pk=pk, user=request.user)
         visibility = request.POST.get("visibility")
         if visibility not in (Visibility.PUBLIC, Visibility.SHARED, Visibility.PRIVATE):
             return redirect(scrobble.get_absolute_url())
@@ -1404,8 +1434,6 @@ class ChangeVisibilityView(LoginRequiredMixin, View):
 
 class ScrobbleShareAnalyticsView(LoginRequiredMixin, DetailView):
     model = Scrobble
-    slug_field = "uuid"
-    slug_url_kwarg = "uuid"
     template_name = "scrobbles/scrobble_share_analytics.html"
 
     def get_queryset(self):
@@ -1721,6 +1749,7 @@ class ScrobbleCalendarView(LoginRequiredMixin, TemplateView):
             for scrobble in day_map[day_num]:
                 day_scrobbles.append(
                     {
+                        "id": scrobble.pk,
                         "uuid": scrobble.uuid,
                         "emoji": self.MEDIA_EMOJI.get(scrobble.media_type, "📌"),
                         "title": (

vrobbler/apps/trends/admin.py

@@ -1,5 +1,4 @@
 from django.contrib import admin
-
 from trends.models import TrendResult
 
 

vrobbler/apps/trends/management/commands/compute_trends.py

@@ -1,8 +1,12 @@
+import logging
+
 from django.contrib.auth import get_user_model
 from django.core.management.base import BaseCommand
+from django.utils import timezone
+from trends.trends import TREND_REGISTRY
+from trends.utils import compute_and_save_trend, get_supported_periods
 
-from trends.tasks import compute_user_trends
+logger = logging.getLogger(__name__)
-
 User = get_user_model()
 
 
@@ -25,16 +29,54 @@ class Command(BaseCommand):
                 )
                 return
             users = [user]
-            self.stdout.write(f"Computing trends for user: {user}")
         else:
             users = User.objects.filter(is_active=True)
-            self.stdout.write(f"Computing trends for {users.count()} users...")
+
+        total_users = len(users)
+        self.stdout.write(f"Computing trends for {total_users} user(s)...")
+
+        overall_start = timezone.now()
+        ok_count = 0
+        fail_count = 0
 
         for user in users:
-            try:
+            total_trends = len(TREND_REGISTRY)
-                compute_user_trends(user.id)
+            self.stdout.write(f"  {user} ({user.id}): {total_trends} trends...")
-                self.stdout.write(self.style.SUCCESS(f"  OK {user}"))
+            user_start = timezone.now()
-            except Exception as e:
+            user_ok = 0
-                self.stderr.write(self.style.ERROR(f"  FAILED {user}: {e}"))
+            user_fail = 0
 
-        self.stdout.write(self.style.SUCCESS("Done!"))
+            for idx, (slug, _) in enumerate(TREND_REGISTRY.items(), start=1):
+                periods = get_supported_periods(slug)
+                self.stdout.write(f"    [{idx}/{total_trends}] {slug}...\n")
+                for period in periods:
+                    trend_start = timezone.now()
+                    self.stdout.write(f"      {period}... ", ending="")
+                    try:
+                        elapsed = compute_and_save_trend(user, slug, period)
+                        self.stdout.write(self.style.SUCCESS(f"OK ({elapsed:.1f}s)"))
+                        user_ok += 1
+                    except Exception as e:
+                        elapsed = (timezone.now() - trend_start).total_seconds()
+                        self.stdout.write(
+                            self.style.ERROR(f"FAILED after {elapsed:.1f}s: {e}")
+                        )
+                        user_fail += 1
+
+            user_elapsed = (timezone.now() - user_start).total_seconds()
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"  {user}: {user_ok} OK, {user_fail} failed "
+                    f"({user_elapsed:.1f}s total)"
+                )
+            )
+            ok_count += user_ok
+            fail_count += user_fail
+
+        overall_elapsed = (timezone.now() - overall_start).total_seconds()
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"Done! {ok_count} OK, {fail_count} failed "
+                f"({overall_elapsed:.1f}s across {total_users} user(s))"
+            )
+        )

vrobbler/apps/trends/migrations/0001_initial.py

@@ -1,9 +1,9 @@
 # Generated by Django 4.2.29 on 2026-06-16 14:52
 
-from django.conf import settings
-from django.db import migrations, models
 import django.db.models.deletion
 import django_extensions.db.fields
+from django.conf import settings
+from django.db import migrations, models
 
 
 class Migration(migrations.Migration):

vrobbler/apps/trends/migrations/0002_alter_trendresult_unique_together_trendresult_period_and_more.py

@@ -0,0 +1,37 @@
+# Generated by Django 4.2.29 on 2026-06-17 14:32
+
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("trends", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name="trendresult",
+            unique_together=set(),
+        ),
+        migrations.AddField(
+            model_name="trendresult",
+            name="period",
+            field=models.CharField(
+                choices=[
+                    ("last_30", "Last 30 days"),
+                    ("last_90", "Last 90 days"),
+                    ("last_year", "Last year"),
+                    ("all_time", "All time"),
+                ],
+                default="all_time",
+                max_length=20,
+            ),
+        ),
+        migrations.AlterUniqueTogether(
+            name="trendresult",
+            unique_together={("user", "trend_slug", "period")},
+        ),
+    ]

vrobbler/apps/trends/migrations/0003_alter_trendresult_period.py

@@ -0,0 +1,29 @@
+# Generated by Django 4.2.29 on 2026-06-22 02:44
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        (
+            "trends",
+            "0002_alter_trendresult_unique_together_trendresult_period_and_more",
+        ),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="trendresult",
+            name="period",
+            field=models.CharField(
+                choices=[
+                    ("last_30", "Last 30 days"),
+                    ("last_90", "Last 90 days"),
+                    ("last_year", "Last year"),
+                ],
+                default="last_30",
+                max_length=20,
+            ),
+        ),
+    ]

vrobbler/apps/trends/models.py

@@ -4,15 +4,26 @@ from django_extensions.db.models import TimeStampedModel
 
 User = get_user_model()
 
+PERIOD_CHOICES = [
+    ("last_30", "Last 30 days"),
+    ("last_90", "Last 90 days"),
+    ("last_year", "Last year"),
+]
+
 
 class TrendResult(TimeStampedModel):
     user = models.ForeignKey(User, on_delete=models.CASCADE)
     trend_slug = models.CharField(max_length=100, db_index=True)
+    period = models.CharField(
+        max_length=20,
+        choices=PERIOD_CHOICES,
+        default="last_30",
+    )
     computed_at = models.DateTimeField(auto_now_add=True)
     data = models.JSONField(default=dict)
 
     class Meta:
-        unique_together = ["user", "trend_slug"]
+        unique_together = ["user", "trend_slug", "period"]
 
     def __str__(self):
-        return f"{self.user} - {self.trend_slug} ({self.computed_at})"
+        return f"{self.user} - {self.trend_slug} ({self.period})"

vrobbler/apps/trends/tasks.py

@@ -3,9 +3,8 @@ import logging
 from celery import shared_task
 from django.contrib.auth import get_user_model
 from django.utils import timezone
-
-from trends.models import TrendResult
 from trends.trends import TREND_REGISTRY
+from trends.utils import compute_and_save_trend, get_supported_periods
 
 logger = logging.getLogger(__name__)
 User = get_user_model()
@@ -13,8 +12,10 @@ User = get_user_model()
 
 @shared_task
 def compute_all_trends():
-    for user in User.objects.filter(is_active=True):
+    user_ids = list(User.objects.filter(is_active=True).values_list("id", flat=True))
-        compute_user_trends.delay(user.id)
+    logger.info("Dispatching trend computation for %d users", len(user_ids))
+    for uid in user_ids:
+        compute_user_trends.delay(uid)
 
 
 @shared_task
@@ -25,15 +26,44 @@ def compute_user_trends(user_id):
         logger.warning("User %s not found, skipping trends", user_id)
         return
 
-    for slug, fn in TREND_REGISTRY.items():
+    total = len(TREND_REGISTRY)
+    logger.info(
+        "Computing %d trends for user %s (%d)",
+        total,
+        user,
+        user_id,
+    )
+
+    for idx, (slug, _) in enumerate(TREND_REGISTRY.items(), start=1):
+        compute_single_trend.delay(user_id, slug)
+
+    logger.info("Dispatched all %d trends for user %s (%d)", total, user, user_id)
+
+
+@shared_task
+def compute_single_trend(user_id, slug):
+    try:
+        user = User.objects.get(id=user_id)
+    except User.DoesNotExist:
+        logger.warning("User %d not found for trend '%s', skipping", user_id, slug)
+        return
+
+    if slug not in TREND_REGISTRY:
+        logger.warning("Unknown trend slug '%s' for user %d", slug, user_id)
+        return
+
+    periods = get_supported_periods(slug)
+
+    for period in periods:
+        logger.info("[%s/%s] Computing for user %d...", slug, period, user_id)
         try:
-            data = fn(user)
+            elapsed = compute_and_save_trend(user, slug, period)
-            TrendResult.objects.update_or_create(
+            logger.info(
-                user=user,
+                "[%s/%s] Completed for user %d in %.1fs",
-                trend_slug=slug,
+                slug,
-                defaults={"data": data, "computed_at": timezone.now()},
+                period,
+                user_id,
+                elapsed,
             )
         except Exception:
-            logger.exception(
+            logger.exception("[%s/%s] Failed for user %d", slug, period, user_id)
-                "Failed to compute trend '%s' for user %s", slug, user_id
-            )

vrobbler/apps/trends/templates/trends/_activity_distribution.html

@@ -0,0 +1,47 @@
+<div class="row">
+  <div class="col-12">
+    {% if data.distribution %}
+    <p class="text-muted mb-3">
+      Total scrobbles{% if current_period_label %} ({{ current_period_label }}){% endif %}: <strong>{{ data.total_count }}</strong>
+    </p>
+    <div class="table-responsive">
+      <table class="table table-striped table-sm">
+        <thead>
+          <tr>
+            <th>Media Type</th>
+            <th class="text-end">Total</th>
+            <th class="text-end">Completed</th>
+            <th class="text-end">%</th>
+            <th>Distribution</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% with max=data.distribution.0.count %}
+          {% for entry in data.distribution %}
+          <tr>
+            <td>{{ entry.media_type }}</td>
+            <td class="text-end">{{ entry.count }}</td>
+            <td class="text-end">{{ entry.completed }}</td>
+            <td class="text-end">{{ entry.pct }}%</td>
+            <td style="width: 30%;">
+              {% if max > 0 %}
+              <div class="progress" style="height: 12px;">
+                <div class="progress-bar" role="progressbar"
+                     style="width: {{ entry.pct }}%;"
+                     aria-valuenow="{{ entry.count }}"
+                     aria-valuemin="0" aria-valuemax="{{ max }}">
+                </div>
+              </div>
+              {% endif %}
+            </td>
+          </tr>
+          {% endfor %}
+          {% endwith %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="text-muted">No activity data found.</p>
+    {% endif %}
+  </div>
+</div>

vrobbler/apps/trends/templates/trends/_mood_by_time.html

@@ -0,0 +1,78 @@
+<div class="row">
+  <div class="col-md-6">
+    <h5 class="mb-3">By Hour of Day</h5>
+    {% if data.hours %}
+    <div class="table-responsive">
+      <table class="table table-striped table-sm">
+        <thead>
+          <tr>
+            <th>Hour</th>
+            <th class="text-end">Avg Quality</th>
+            <th class="text-end">Check-ins</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% for entry in data.hours %}
+          {% if entry.count > 0 %}
+          <tr>
+            <td>
+              {% if entry.hour == 0 %}
+              12 AM
+              {% elif entry.hour < 12 %}
+              {{ entry.hour }} AM
+              {% elif entry.hour == 12 %}
+              12 PM
+              {% else %}
+              {{ entry.hour|add:"-12" }} PM
+              {% endif %}
+            </td>
+            <td class="text-end">
+              <span class="{% if entry.avg_quality >= 5 %}text-success{% elif entry.avg_quality >= 4 %}text-info{% elif entry.avg_quality >= 3 %}text-warning{% else %}text-danger{% endif %}">
+                {{ entry.avg_quality }}
+              </span>
+            </td>
+            <td class="text-end">{{ entry.count }}</td>
+          </tr>
+          {% endif %}
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="text-muted">No hourly data.</p>
+    {% endif %}
+  </div>
+  <div class="col-md-6">
+    <h5 class="mb-3">By Day of Week</h5>
+    {% if data.days %}
+    <div class="table-responsive">
+      <table class="table table-striped table-sm">
+        <thead>
+          <tr>
+            <th>Day</th>
+            <th class="text-end">Avg Quality</th>
+            <th class="text-end">Check-ins</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% for entry in data.days %}
+          {% if entry.count > 0 %}
+          <tr>
+            <td>{{ entry.day_name }}</td>
+            <td class="text-end">
+              <span class="{% if entry.avg_quality >= 5 %}text-success{% elif entry.avg_quality >= 4 %}text-info{% elif entry.avg_quality >= 3 %}text-warning{% else %}text-danger{% endif %}">
+                {{ entry.avg_quality }}
+              </span>
+            </td>
+            <td class="text-end">{{ entry.count }}</td>
+          </tr>
+          {% endif %}
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="text-muted">No daily data.</p>
+    {% endif %}
+  </div>
+</div>

vrobbler/apps/trends/templates/trends/_mood_distribution.html

@@ -0,0 +1,45 @@
+<div class="row">
+  <div class="col-12">
+    {% if data.moods %}
+    <p class="text-muted mb-3">
+      Total mood check-ins{% if current_period_label %} ({{ current_period_label }}){% endif %}: <strong>{{ data.total }}</strong>
+      &middot; Positive: <strong>{{ data.positive_count }}</strong>
+      &middot; Negative: <strong>{{ data.negative_count }}</strong>
+    </p>
+    <div class="table-responsive">
+      <table class="table table-striped table-sm">
+        <thead>
+          <tr>
+            <th>Mood</th>
+            <th class="text-end">Count</th>
+            <th>Distribution</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% with max=data.moods.0.count %}
+          {% for entry in data.moods %}
+          <tr>
+            <td>{{ entry.mood }}</td>
+            <td class="text-end">{{ entry.count }}</td>
+            <td style="width: 40%;">
+              {% if max > 0 %}
+              <div class="progress" style="height: 12px;">
+                <div class="progress-bar" role="progressbar"
+                     style="width: {% widthratio entry.count max 100 %}%;"
+                     aria-valuenow="{{ entry.count }}"
+                     aria-valuemin="0" aria-valuemax="{{ max }}">
+                </div>
+              </div>
+              {% endif %}
+            </td>
+          </tr>
+          {% endfor %}
+          {% endwith %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="text-muted">No mood distribution data found.</p>
+    {% endif %}
+  </div>
+</div>

vrobbler/apps/trends/templates/trends/_mood_streaks.html

@@ -0,0 +1,47 @@
+<div class="row">
+  <div class="col-12">
+    {% if data.current_streak %}
+    <div class="alert alert-info">
+      <strong>Current streak:</strong>
+      {{ data.current_streak.length }} consecutive
+      <span class="{% if data.current_streak.mood_type == 'positive' %}text-success{% else %}text-danger{% endif %}">
+        {{ data.current_streak.mood_type }}
+      </span>
+      check-ins since {{ data.current_streak.start_date }}.
+    </div>
+    {% endif %}
+
+    {% if data.streaks %}
+    <div class="table-responsive">
+      <table class="table table-striped table-sm">
+        <thead>
+          <tr>
+            <th>#</th>
+            <th>Mood Type</th>
+            <th class="text-end">Length</th>
+            <th>Start</th>
+            <th>End</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% for streak in data.streaks %}
+          <tr>
+            <td>{{ forloop.counter }}</td>
+            <td>
+              <span class="{% if streak.mood_type == 'positive' %}text-success{% elif streak.mood_type == 'negative' %}text-danger{% endif %}">
+                {{ streak.mood_type|title }}
+              </span>
+            </td>
+            <td class="text-end">{{ streak.length }}</td>
+            <td>{{ streak.start_date }}</td>
+            <td>{{ streak.end_date }}</td>
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="text-muted">No streak data found.</p>
+    {% endif %}
+  </div>
+</div>

vrobbler/apps/trends/templates/trends/_mood_trajectory.html

@@ -0,0 +1,39 @@
+<div class="row">
+  <div class="col-12">
+    {% if data.trajectory %}
+    <div class="table-responsive">
+      <table class="table table-striped table-sm">
+        <thead>
+          <tr>
+            <th>Date</th>
+            <th class="text-end">Avg Quality</th>
+            <th class="text-end">Check-ins</th>
+            <th>Mood Bar</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% for entry in data.trajectory %}
+          <tr>
+            <td>{{ entry.date }}</td>
+            <td class="text-end">{{ entry.avg_quality }}</td>
+            <td class="text-end">{{ entry.count }}</td>
+            <td style="width: 40%;">
+              <div class="progress" style="height: 16px;">
+                <div class="progress-bar {% if entry.avg_quality >= 5 %}bg-success{% elif entry.avg_quality >= 4 %}bg-info{% elif entry.avg_quality >= 3 %}bg-warning{% else %}bg-danger{% endif %}"
+                     role="progressbar"
+                     style="width: {% widthratio entry.avg_quality 7 100 %}%;"
+                     aria-valuenow="{{ entry.avg_quality }}"
+                     aria-valuemin="1" aria-valuemax="7">
+                </div>
+              </div>
+            </td>
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="text-muted">No mood check-in data found.</p>
+    {% endif %}
+  </div>
+</div>

vrobbler/apps/trends/templates/trends/_mood_weather.html

@@ -0,0 +1,64 @@
+<div class="row">
+  <div class="col-md-6">
+    <h5 class="mb-3">By Weather Condition</h5>
+    {% if data.conditions %}
+    <div class="table-responsive">
+      <table class="table table-striped table-sm">
+        <thead>
+          <tr>
+            <th>Condition</th>
+            <th class="text-end">Avg Quality</th>
+            <th class="text-end">Check-ins</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% for entry in data.conditions %}
+          <tr>
+            <td>{{ entry.condition }}</td>
+            <td class="text-end">
+              <span class="{% if entry.avg_quality >= 5 %}text-success{% elif entry.avg_quality >= 4 %}text-info{% elif entry.avg_quality >= 3 %}text-warning{% else %}text-danger{% endif %}">
+                {{ entry.avg_quality }}
+              </span>
+            </td>
+            <td class="text-end">{{ entry.count }}</td>
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="text-muted">No weather-linked mood data found.</p>
+    {% endif %}
+  </div>
+  <div class="col-md-6">
+    <h5 class="mb-3">By Temperature Range</h5>
+    {% if data.temp_ranges %}
+    <div class="table-responsive">
+      <table class="table table-striped table-sm">
+        <thead>
+          <tr>
+            <th>Temp Range</th>
+            <th class="text-end">Avg Quality</th>
+            <th class="text-end">Check-ins</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% for entry in data.temp_ranges %}
+          <tr>
+            <td>{{ entry.range }}</td>
+            <td class="text-end">
+              <span class="{% if entry.avg_quality >= 5 %}text-success{% elif entry.avg_quality >= 4 %}text-info{% elif entry.avg_quality >= 3 %}text-warning{% else %}text-danger{% endif %}">
+                {{ entry.avg_quality }}
+              </span>
+            </td>
+            <td class="text-end">{{ entry.count }}</td>
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="text-muted">No temperature-linked mood data found.</p>
+    {% endif %}
+  </div>
+</div>

vrobbler/apps/trends/templates/trends/_peak_hours.html

@@ -0,0 +1,52 @@
+<div class="row">
+  <div class="col-12">
+    {% if data.hours %}
+    <div class="table-responsive">
+      <table class="table table-striped table-sm">
+        <thead>
+          <tr>
+            <th>Hour</th>
+            <th class="text-end">Scrobbles</th>
+            <th>Distribution</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% with total=data.hours|dictsortreversed:"count"|first %}
+          {% with max_count=total.count %}
+          {% for entry in data.hours %}
+          <tr>
+            <td>
+              {% if entry.hour == 0 %}
+              12 AM
+              {% elif entry.hour < 12 %}
+              {{ entry.hour }} AM
+              {% elif entry.hour == 12 %}
+              12 PM
+              {% else %}
+              {{ entry.hour|add:"-12" }} PM
+              {% endif %}
+            </td>
+            <td class="text-end">{{ entry.count }}</td>
+            <td style="width: 40%;">
+              {% if max_count > 0 %}
+              <div class="progress" style="height: 12px;">
+                <div class="progress-bar" role="progressbar"
+                     style="width: {{ entry.count|floatformat:0 }}%;"
+                     aria-valuenow="{{ entry.count }}"
+                     aria-valuemin="0" aria-valuemax="{{ max_count }}">
+                </div>
+              </div>
+              {% endif %}
+            </td>
+          </tr>
+          {% endfor %}
+          {% endwith %}
+          {% endwith %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="text-muted">No activity data found.</p>
+    {% endif %}
+  </div>
+</div>

vrobbler/apps/trends/templates/trends/_reading_pace.html

@@ -1,4 +1,9 @@
 <div class="row">
+  {% if current_period_label %}
+  <div class="col-12 mb-2">
+    <small class="text-muted">Period: {{ current_period_label }}</small>
+  </div>
+  {% endif %}
   <div class="col-md-6 mb-3">
     <div class="card">
       <div class="card-body">

vrobbler/apps/trends/templates/trends/_trending_up.html

@@ -6,8 +6,8 @@
         <thead>
           <tr>
             <th>Media Type</th>
-            <th class="text-end">Recent (30 days)</th>
+            <th class="text-end">Recent ({{ current_period_label }})</th>
-            <th class="text-end">Previous (30 days)</th>
+            <th class="text-end">Previous ({{ current_period_label }})</th>
             <th class="text-end">Change</th>
           </tr>
         </thead>

vrobbler/apps/trends/templates/trends/_weekly_rhythm.html

@@ -0,0 +1,42 @@
+<div class="row">
+  <div class="col-12">
+    {% if data.days %}
+    <div class="table-responsive">
+      <table class="table table-striped table-sm">
+        <thead>
+          <tr>
+            <th>Day</th>
+            <th class="text-end">Scrobbles</th>
+            <th>Distribution</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% with total=data.days|dictsortreversed:"count"|first %}
+          {% with max_count=total.count %}
+          {% for entry in data.days %}
+          <tr>
+            <td>{{ entry.day_name }}</td>
+            <td class="text-end">{{ entry.count }}</td>
+            <td style="width: 40%;">
+              {% if max_count > 0 %}
+              <div class="progress" style="height: 12px;">
+                <div class="progress-bar" role="progressbar"
+                     style="width: {{ entry.count|floatformat:0 }}%;"
+                     aria-valuenow="{{ entry.count }}"
+                     aria-valuemin="0" aria-valuemax="{{ max_count }}">
+                </div>
+              </div>
+              {% endif %}
+            </td>
+          </tr>
+          {% endfor %}
+          {% endwith %}
+          {% endwith %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="text-muted">No weekly data found.</p>
+    {% endif %}
+  </div>
+</div>

vrobbler/apps/trends/templates/trends/trend_detail.html

@@ -8,6 +8,30 @@
     <a href="{% url 'trends:trends-home' %}" class="btn btn-sm btn-outline-secondary mb-2">&larr; All Trends</a>
     <h2>{{ trend.icon }} {{ trend.title }}</h2>
     <p class="text-muted">{{ trend.description }}</p>
+
+    {% if supported_periods|length > 1 %}
+    <div class="d-flex align-items-center gap-2 mb-2 flex-wrap">
+      <nav class="btn-group btn-group-sm" role="group">
+        {% for period_slug, period_label in supported_periods.items %}
+        <a href="?period={{ period_slug }}"
+           class="btn btn-sm {% if period_slug == current_period %}btn-primary{% else %}btn-outline-secondary{% endif %}">
+          {{ period_label }}
+        </a>
+        {% endfor %}
+      </nav>
+      {% if prev_period or next_period %}
+      <div class="btn-group btn-group-sm">
+        {% if prev_period %}
+        <a href="?period={{ prev_period }}" class="btn btn-outline-secondary">&laquo; Prev</a>
+        {% endif %}
+        {% if next_period %}
+        <a href="?period={{ next_period }}" class="btn btn-outline-secondary">Next &raquo;</a>
+        {% endif %}
+      </div>
+      {% endif %}
+    </div>
+    {% endif %}
+
     {% if computed_at %}
     <small class="text-muted">Last computed: {{ computed_at|date:"F j, Y H:i" }}</small>
     {% endif %}
@@ -19,7 +43,7 @@
 
 {% elif data is None %}
 <div class="alert alert-info">
-  No data computed yet. Trends are updated once daily, check back later.
+  No data computed yet for this period. Trends are updated once daily, check back later.
 </div>
 
 {% elif trend.slug == "concurrent-listening" %}
@@ -34,5 +58,29 @@
 {% elif trend.slug == "trending-up" %}
   {% include "trends/_trending_up.html" %}
 
+{% elif trend.slug == "peak-hours" %}
+  {% include "trends/_peak_hours.html" %}
+
+{% elif trend.slug == "weekly-rhythm" %}
+  {% include "trends/_weekly_rhythm.html" %}
+
+{% elif trend.slug == "activity-distribution" %}
+  {% include "trends/_activity_distribution.html" %}
+
+{% elif trend.slug == "mood-trajectory" %}
+  {% include "trends/_mood_trajectory.html" %}
+
+{% elif trend.slug == "mood-by-time" %}
+  {% include "trends/_mood_by_time.html" %}
+
+{% elif trend.slug == "mood-distribution" %}
+  {% include "trends/_mood_distribution.html" %}
+
+{% elif trend.slug == "mood-streaks" %}
+  {% include "trends/_mood_streaks.html" %}
+
+{% elif trend.slug == "mood-weather" %}
+  {% include "trends/_mood_weather.html" %}
+
 {% endif %}
 {% endblock %}

vrobbler/apps/trends/trends/__init__.py

@@ -1,25 +1,48 @@
-from trends.trends.concurrent import compute_concurrent_listening, compute_concurrent_reading
+from trends.trends.activity import (
+    compute_activity_distribution,
+    compute_peak_hours,
+    compute_weekly_rhythm,
+)
+from trends.trends.concurrent import (
+    compute_concurrent_listening,
+    compute_concurrent_reading,
+)
+from trends.trends.mood import (
+    compute_mood_by_time,
+    compute_mood_distribution,
+    compute_mood_streaks,
+    compute_mood_trajectory,
+    compute_mood_weather,
+)
 from trends.trends.reading import compute_reading_pace_vs_activity
 from trends.trends.trending import compute_trending_up
 
 TREND_REGISTRY = {}
 
+
 def register(slug):
     def decorator(fn):
         TREND_REGISTRY[slug] = fn
         return fn
+
     return decorator
 
 
-compute_concurrent_listening = register("concurrent-listening")(
+compute_activity_distribution = register("activity-distribution")(
-    compute_concurrent_listening
+    compute_activity_distribution
-)
-compute_concurrent_reading = register("concurrent-reading")(
-    compute_concurrent_reading
 )
+# compute_concurrent_listening = register("concurrent-listening")(
+#    compute_concurrent_listening
+# )
+compute_concurrent_reading = register("concurrent-reading")(compute_concurrent_reading)
+compute_mood_by_time = register("mood-by-time")(compute_mood_by_time)
+compute_mood_distribution = register("mood-distribution")(compute_mood_distribution)
+compute_mood_streaks = register("mood-streaks")(compute_mood_streaks)
+compute_mood_trajectory = register("mood-trajectory")(compute_mood_trajectory)
+compute_mood_weather = register("mood-weather")(compute_mood_weather)
+compute_peak_hours = register("peak-hours")(compute_peak_hours)
 compute_reading_pace_vs_activity = register("reading-pace-vs-activity")(
     compute_reading_pace_vs_activity
 )
-compute_trending_up = register("trending-up")(
+compute_trending_up = register("trending-up")(compute_trending_up)
-    compute_trending_up
+compute_weekly_rhythm = register("weekly-rhythm")(compute_weekly_rhythm)
-)

vrobbler/apps/trends/trends/activity.py

@@ -0,0 +1,113 @@
+from collections import OrderedDict, defaultdict
+
+from django.db.models import Count, Q
+from django.db.models.functions import Extract
+from django.utils import timezone
+from scrobbles.models import Scrobble
+
+
+def compute_peak_hours(user, period="all_time"):
+    """Group scrobbles by hour of day (0-23) and count them.
+
+    Returns dict: {"hours": [{"hour": N, "count": N}, ...]} sorted by hour.
+    """
+    hours_qs = (
+        Scrobble.objects.filter(user=user, timestamp__isnull=False)
+        .annotate(hour=Extract("timestamp", "hour"))
+        .values("hour")
+        .annotate(count=Count("id"))
+        .order_by("hour")
+    )
+
+    hours = []
+    raw = {row["hour"]: row["count"] for row in hours_qs}
+    for h in range(24):
+        hours.append({"hour": h, "count": raw.get(h, 0)})
+
+    return {"hours": hours}
+
+
+def compute_weekly_rhythm(user, period="all_time"):
+    """Group scrobble counts by day of the week.
+
+    Uses iso_week_day (1=Monday, 7=Sunday). Returns dict sorted by day index
+    with human-readable day names.
+    """
+    DAY_NAMES = OrderedDict(
+        [
+            (1, "Monday"),
+            (2, "Tuesday"),
+            (3, "Wednesday"),
+            (4, "Thursday"),
+            (5, "Friday"),
+            (6, "Saturday"),
+            (7, "Sunday"),
+        ]
+    )
+
+    days_qs = (
+        Scrobble.objects.filter(user=user, timestamp__isnull=False)
+        .annotate(day=Extract("timestamp", "iso_week_day"))
+        .values("day")
+        .annotate(count=Count("id"))
+        .order_by("day")
+    )
+
+    raw = {row["day"]: row["count"] for row in days_qs}
+    days = []
+    for idx, name in DAY_NAMES.items():
+        days.append(
+            {
+                "day_index": idx,
+                "day_name": name,
+                "count": raw.get(idx, 0),
+            }
+        )
+
+    return {"days": days}
+
+
+def compute_activity_distribution(user, period="all_time"):
+    """Proportion of total scrobbles per media type.
+
+    Returns dict: {"distribution": [{"media_type": "...", "count": N,
+    "completed": N, "pct": float}, ...]} sorted by count desc, plus
+    "total_count".
+    """
+    from trends.utils import get_date_range
+
+    start, end = get_date_range(period)
+    filters = Q(user=user)
+    if start:
+        filters &= Q(timestamp__gte=start)
+    if end:
+        filters &= Q(timestamp__lte=end)
+
+    dist_qs = (
+        Scrobble.objects.filter(filters)
+        .values("media_type")
+        .annotate(
+            count=Count("id"),
+            completed=Count("id", filter=Q(played_to_completion=True)),
+        )
+        .order_by("-count")
+    )
+
+    rows = list(dist_qs)
+    total = sum(r["count"] for r in rows) or 1
+
+    distribution = []
+    for row in rows:
+        distribution.append(
+            {
+                "media_type": row["media_type"],
+                "count": row["count"],
+                "completed": row["completed"],
+                "pct": round((row["count"] / total) * 100, 1),
+            }
+        )
+
+    return {
+        "distribution": distribution,
+        "total_count": sum(r["count"] for r in rows),
+    }

vrobbler/apps/trends/trends/concurrent.py

@@ -1,6 +1,7 @@
 import datetime
 from collections import defaultdict
 
+from django.db.models import Q
 from scrobbles.models import Scrobble
 
 
@@ -21,12 +22,8 @@ def _find_concurrent(anchor_scrobbles, paired_scrobbles):
     Returns a dict mapping each anchor scrobble PK to a list of
     paired scrobble PKs that overlap with it.
     """
-    anchor_ranges = {
+    anchor_ranges = {s.pk: _range_for(s) for s in anchor_scrobbles}
-        s.pk: _range_for(s) for s in anchor_scrobbles
+    paired_ranges = {s.pk: _range_for(s) for s in paired_scrobbles}
-    }
-    paired_ranges = {
-        s.pk: _range_for(s) for s in paired_scrobbles
-    }
 
     anchor_to_paired = defaultdict(list)
 
@@ -41,7 +38,10 @@ def _find_concurrent(anchor_scrobbles, paired_scrobbles):
 def _get_media_name(scrobble):
     """Return the name of the media object associated with a scrobble."""
     for attr in [
-        "trail", "geo_location", "book", "track",
+        "trail",
+        "geo_location",
+        "book",
+        "track",
     ]:
         obj = getattr(scrobble, attr, None)
         if obj is not None:
@@ -49,22 +49,45 @@ def _get_media_name(scrobble):
     return "Unknown"
 
 
-def compute_concurrent_listening(user):
+def compute_concurrent_listening(user, period="all_time"):
     """Find what music was listened to while on trails or at locations.
 
     Returns a dict with two keys: 'trails' and 'locations', each containing
     a list of entries with the trail/location name and the tracks listened to.
     """
-    media_types_to_exclude_from_anchor = ("Track", "Book", "Video", "PodcastEpisode",
+    from trends.utils import get_date_range
-                                          "VideoGame", "BoardGame", "Puzzle", "Food",
+
-                                          "Beer", "Task", "WebPage", "LifeEvent",
+    start, end = get_date_range(period)
-                                          "Mood", "BrickSet", "Channel", "BirdingLocation",
+    base_filters = Q(user=user, timestamp__isnull=False)
-                                          "Paper", "SportEvent")
+    if start:
+        base_filters &= Q(timestamp__gte=start)
+    if end:
+        base_filters &= Q(timestamp__lte=end)
+
+    media_types_to_exclude_from_anchor = (
+        "Track",
+        "Book",
+        "Video",
+        "PodcastEpisode",
+        "VideoGame",
+        "BoardGame",
+        "Puzzle",
+        "Food",
+        "Beer",
+        "Task",
+        "WebPage",
+        "LifeEvent",
+        "Mood",
+        "BrickSet",
+        "Channel",
+        "BirdingLocation",
+        "Paper",
+        "SportEvent",
+    )
 
     anchor_scrobbles = list(
         Scrobble.objects.filter(
-            user=user,
+            base_filters,
-            timestamp__isnull=False,
             played_to_completion=True,
         )
         .exclude(media_type__in=media_types_to_exclude_from_anchor)
@@ -74,9 +97,8 @@ def compute_concurrent_listening(user):
 
     paired_scrobbles = list(
         Scrobble.objects.filter(
-            user=user,
+            base_filters,
             media_type="Track",
-            timestamp__isnull=False,
             stop_timestamp__isnull=False,
             played_to_completion=True,
         )
@@ -131,29 +153,45 @@ def compute_concurrent_listening(user):
         }
 
         if anchor.media_type == "Trail":
-            entry["uuid"] = str(anchor.trail.uuid) if anchor.trail and anchor.trail.uuid else ""
+            entry["uuid"] = (
+                str(anchor.trail.uuid) if anchor.trail and anchor.trail.uuid else ""
+            )
             trails.append(entry)
         else:
-            entry["uuid"] = str(anchor.geo_location.uuid) if anchor.geo_location and anchor.geo_location.uuid else ""
+            entry["uuid"] = (
+                str(anchor.geo_location.uuid)
+                if anchor.geo_location and anchor.geo_location.uuid
+                else ""
+            )
             locations.append(entry)
 
     return {
         "trails": sorted(trails, key=lambda x: x["total_sessions"], reverse=True)[:20],
-        "locations": sorted(locations, key=lambda x: x["total_sessions"], reverse=True)[:20],
+        "locations": sorted(locations, key=lambda x: x["total_sessions"], reverse=True)[
+            :20
+        ],
     }
 
 
-def compute_concurrent_reading(user):
+def compute_concurrent_reading(user, period="all_time"):
     """Find what music was listened to while reading books.
 
     Returns a dict with key 'books' containing a list of entries with the
     book title and the tracks listened to while reading.
     """
+    from trends.utils import get_date_range
+
+    start, end = get_date_range(period)
+    base_filters = Q(user=user, timestamp__isnull=False)
+    if start:
+        base_filters &= Q(timestamp__gte=start)
+    if end:
+        base_filters &= Q(timestamp__lte=end)
+
     anchor_scrobbles = list(
         Scrobble.objects.filter(
-            user=user,
+            base_filters,
             media_type="Book",
-            timestamp__isnull=False,
             stop_timestamp__isnull=False,
             played_to_completion=True,
         )
@@ -163,9 +201,8 @@ def compute_concurrent_reading(user):
 
     paired_scrobbles = list(
         Scrobble.objects.filter(
-            user=user,
+            base_filters,
             media_type="Track",
-            timestamp__isnull=False,
             stop_timestamp__isnull=False,
             played_to_completion=True,
         )
@@ -179,43 +216,59 @@ def compute_concurrent_reading(user):
     anchor_to_paired = _find_concurrent(anchor_scrobbles, paired_scrobbles)
     paired_by_pk = {s.pk: s for s in paired_scrobbles}
 
-    books = []
+    books_by_uuid = {}
 
     for anchor in anchor_scrobbles:
         paired_pks = anchor_to_paired.get(anchor.pk, [])
         if not paired_pks:
             continue
 
-        tracks_by_name = defaultdict(int)
+        book = anchor.book
-        track_details = {}
+        book_uuid = str(book.uuid) if book and book.uuid else ""
+        book_key = book_uuid or str(book) if book else "Unknown"
+
+        if book_key not in books_by_uuid:
+            books_by_uuid[book_key] = {
+                "book_title": str(book) if book else "Unknown",
+                "book_uuid": book_uuid,
+                "total_sessions": 0,
+                "tracks_by_name": defaultdict(int),
+                "track_details": {},
+            }
+
+        books_by_uuid[book_key]["total_sessions"] += len(paired_pks)
+
         for p_pk in paired_pks:
             ps = paired_by_pk[p_pk]
             track = ps.track
             if track is None:
                 continue
             name = str(track)
-            tracks_by_name[name] += 1
+            books_by_uuid[book_key]["tracks_by_name"][name] += 1
-            if name not in track_details:
+            if name not in books_by_uuid[book_key]["track_details"]:
-                track_details[name] = {
+                books_by_uuid[book_key]["track_details"][name] = {
                     "track_name": name,
                     "track_uuid": str(track.uuid) if track.uuid else "",
                     "artist_name": str(track.artist) if track.artist else "",
                 }
 
-        book = anchor.book
+    books = []
-        books.append({
+    for bd in books_by_uuid.values():
-            "book_title": str(book) if book else "Unknown",
+        books.append(
-            "book_uuid": str(book.uuid) if book and book.uuid else "",
+            {
-            "total_sessions": len(paired_pks),
+                "book_title": bd["book_title"],
-            "tracks": sorted(
+                "book_uuid": bd["book_uuid"],
-                [
+                "total_sessions": bd["total_sessions"],
-                    {**track_details[name], "count": count}
+                "tracks": sorted(
-                    for name, count in tracks_by_name.items()
+                    [
-                ],
+                        {**bd["track_details"][name], "count": count}
-                key=lambda x: x["count"],
+                        for name, count in bd["tracks_by_name"].items()
-                reverse=True,
+                    ],
-            )[:20],
+                    key=lambda x: x["count"],
-        })
+                    reverse=True,
+                )[:5],
+            }
+        )
 
     return {
         "books": sorted(books, key=lambda x: x["total_sessions"], reverse=True)[:20],

vrobbler/apps/trends/trends/mood.py

@@ -0,0 +1,208 @@
+from collections import Counter, defaultdict
+
+from django.db.models import Q
+from scrobbles.models import Scrobble
+
+
+def _mood_scrobbles(user, period="last_30"):
+    from trends.utils import get_date_range
+
+    start, end = get_date_range(period)
+    filters = Q(user=user, media_type=Scrobble.MediaType.MOOD)
+    if start:
+        filters &= Q(timestamp__gte=start)
+    if end:
+        filters &= Q(timestamp__lte=end)
+    return Scrobble.objects.filter(filters).select_related("mood")
+
+
+def _parse_quality(raw):
+    try:
+        return int(raw)
+    except (TypeError, ValueError):
+        return None
+
+
+def _avg_quality(values):
+    nums = [v for v in values if v is not None]
+    if not nums:
+        return 0.0
+    return round(sum(nums) / len(nums), 2)
+
+
+def compute_mood_trajectory(user, period="last_30"):
+    scrobbles = _mood_scrobbles(user, period).order_by("timestamp")
+    by_date = defaultdict(list)
+    for s in scrobbles:
+        quality = _parse_quality(s.log.get("mood_quality"))
+        if quality is not None:
+            day_key = s.timestamp.strftime("%Y-%m-%d")
+            by_date[day_key].append(quality)
+
+    trajectory = []
+    for date_key in sorted(by_date):
+        values = by_date[date_key]
+        trajectory.append(
+            {
+                "date": date_key,
+                "avg_quality": _avg_quality(values),
+                "count": len(values),
+            }
+        )
+
+    return {"trajectory": trajectory}
+
+
+def compute_mood_by_time(user, period="last_30"):
+    scrobbles = _mood_scrobbles(user, period)
+    by_hour = defaultdict(list)
+    by_day = defaultdict(list)
+
+    for s in scrobbles:
+        quality = _parse_quality(s.log.get("mood_quality"))
+        if quality is not None and s.timestamp:
+            by_hour[s.timestamp.hour].append(quality)
+            by_day[s.timestamp.isoweekday()].append(quality)
+
+    hours = []
+    for h in range(24):
+        vals = by_hour.get(h, [])
+        hours.append(
+            {
+                "hour": h,
+                "avg_quality": _avg_quality(vals),
+                "count": len(vals),
+            }
+        )
+
+    DAY_NAMES = {
+        1: "Monday",
+        2: "Tuesday",
+        3: "Wednesday",
+        4: "Thursday",
+        5: "Friday",
+        6: "Saturday",
+        7: "Sunday",
+    }
+    days = []
+    for d in range(1, 8):
+        vals = by_day.get(d, [])
+        days.append(
+            {
+                "day_index": d,
+                "day_name": DAY_NAMES[d],
+                "avg_quality": _avg_quality(vals),
+                "count": len(vals),
+            }
+        )
+
+    return {"hours": hours, "days": days}
+
+
+def compute_mood_distribution(user, period="last_30"):
+    scrobbles = _mood_scrobbles(user, period)
+    mood_counts = Counter()
+    type_counts = Counter()
+
+    for s in scrobbles:
+        if s.mood and s.mood.title:
+            mood_counts[s.mood.title] += 1
+        mood_type = s.log.get("mood_type")
+        if mood_type:
+            type_counts[mood_type] += 1
+
+    moods = [
+        {"mood": mood, "count": count}
+        for mood, count in mood_counts.most_common()
+    ]
+    total = sum(mood_counts.values())
+
+    return {
+        "moods": moods,
+        "total": total,
+        "positive_count": type_counts.get("positive", 0),
+        "negative_count": type_counts.get("negative", 0),
+    }
+
+
+def compute_mood_streaks(user, period="last_30"):
+    scrobbles = list(
+        _mood_scrobbles(user, period).order_by("timestamp")
+    )
+    if not scrobbles:
+        return {"streaks": [], "current_streak": None}
+
+    streaks = []
+    current_start = scrobbles[0].timestamp.date()
+    current_type = scrobbles[0].log.get("mood_type") or "unknown"
+    current_length = 1
+
+    for s in scrobbles[1:]:
+        mood_type = s.log.get("mood_type") or "unknown"
+        if mood_type == current_type:
+            current_length += 1
+        else:
+            streaks.append(
+                {
+                    "start_date": current_start.isoformat(),
+                    "end_date": scrobbles[scrobbles.index(s) - 1].timestamp.date().isoformat(),
+                    "mood_type": current_type,
+                    "length": current_length,
+                }
+            )
+            current_start = s.timestamp.date()
+            current_type = mood_type
+            current_length = 1
+
+    streaks.append(
+        {
+            "start_date": current_start.isoformat(),
+            "end_date": scrobbles[-1].timestamp.date().isoformat(),
+            "mood_type": current_type,
+            "length": current_length,
+        }
+    )
+
+    streaks.sort(key=lambda x: x["length"], reverse=True)
+
+    current_streak = {
+        "mood_type": current_type,
+        "length": current_length,
+        "start_date": current_start.isoformat(),
+    }
+
+    return {"streaks": streaks[:10], "current_streak": current_streak}
+
+
+def compute_mood_weather(user, period="last_30"):
+    scrobbles = _mood_scrobbles(user, period)
+    by_condition = defaultdict(list)
+    by_temp_range = defaultdict(list)
+
+    for s in scrobbles:
+        quality = _parse_quality(s.log.get("mood_quality"))
+        if quality is None:
+            continue
+        desc = s.log.get("weather_description")
+        temp = s.log.get("weather_temp")
+        if desc:
+            by_condition[desc].append(quality)
+        if temp is not None:
+            try:
+                temp_f = float(temp)
+            except (TypeError, ValueError):
+                continue
+            bucket = f"{(int(temp_f) // 10) * 10}-{(int(temp_f) // 10) * 10 + 9}F"
+            by_temp_range[bucket].append(quality)
+
+    conditions = [
+        {"condition": cond, "avg_quality": _avg_quality(vals), "count": len(vals)}
+        for cond, vals in sorted(by_condition.items(), key=lambda x: len(x[1]), reverse=True)
+    ]
+
+    temp_ranges = [
+        {"range": rng, "avg_quality": _avg_quality(vals), "count": len(vals)}
+        for rng, vals in sorted(by_temp_range.items())
+    ]
+
+    return {"conditions": conditions, "temp_ranges": temp_ranges}

vrobbler/apps/trends/trends/reading.py

@@ -1,21 +1,30 @@
 import datetime
 from collections import defaultdict
 
+from django.db.models import Q
 from scrobbles.models import Scrobble
 
 
-def compute_reading_pace_vs_activity(user):
+def compute_reading_pace_vs_activity(user, period="all_time"):
     """Compare reading pace (seconds per session) when music is playing vs. not.
 
     For each Book scrobble with a playback_position_seconds value, checks
     whether there is an overlapping Track scrobble and groups the data.
     Returns average session duration for both groups.
     """
+    from trends.utils import get_date_range
+
+    start, end = get_date_range(period)
+    base_filters = Q(user=user, timestamp__isnull=False)
+    if start:
+        base_filters &= Q(timestamp__gte=start)
+    if end:
+        base_filters &= Q(timestamp__lte=end)
+
     book_scrobbles = list(
         Scrobble.objects.filter(
-            user=user,
+            base_filters,
             media_type="Book",
-            timestamp__isnull=False,
             playback_position_seconds__isnull=False,
             played_to_completion=True,
         )
@@ -28,12 +37,10 @@ def compute_reading_pace_vs_activity(user):
 
     track_scrobbles = list(
         Scrobble.objects.filter(
-            user=user,
+            base_filters,
             media_type="Track",
-            timestamp__isnull=False,
             played_to_completion=True,
-        )
+        ).order_by("-timestamp")
-        .order_by("-timestamp")
     )
 
     track_ranges = []

vrobbler/apps/trends/trends/trending.py

@@ -2,18 +2,21 @@ from collections import defaultdict
 
 from django.db.models import Count
 from django.utils import timezone
-
 from scrobbles.models import Scrobble
 
 
-def compute_trending_up(user, days=30):
+def compute_trending_up(user, period="last_30"):
     """Compare scrobble counts per media type between two periods.
 
     Compares the most recent N days against the N days before that,
     returning the count for each period and the percentage change.
+    The period controls the window size (e.g. 30, 90, 365 days).
 
     Returns a dict keyed by media_type with count and change info.
     """
+    from trends.utils import get_period_days
+
+    days = get_period_days(period) or 30
     now = timezone.now()
     recent_start = now - timezone.timedelta(days=days)
     previous_start = recent_start - timezone.timedelta(days=days)

vrobbler/apps/trends/urls.py

@@ -1,5 +1,4 @@
 from django.urls import path
-
 from trends.views import TrendDetailView, TrendListView
 
 app_name = "trends"

vrobbler/apps/trends/utils.py

@@ -0,0 +1,84 @@
+import logging
+from datetime import timedelta
+
+from django.utils import timezone
+from trends.models import PERIOD_CHOICES, TrendResult
+
+logger = logging.getLogger(__name__)
+
+PERIOD_DAYS = {
+    "last_30": 30,
+    "last_90": 90,
+    "last_year": 365,
+}
+
+PERIOD_LABELS = dict(PERIOD_CHOICES)
+
+TIME_BOUND_TRENDS = {
+    "activity-distribution",
+    "concurrent-reading",
+    "concurrent-listening",
+    "mood-by-time",
+    "mood-distribution",
+    "mood-streaks",
+    "mood-trajectory",
+    "mood-weather",
+    "peak-hours",
+    "reading-pace-vs-activity",
+    "trending-up",
+    "weekly-rhythm",
+}
+
+TREND_PERIOD_OVERRIDES = {
+    "trending-up": ["last_30", "last_90", "last_year"],
+}
+
+
+def get_supported_periods(trend_slug):
+    if trend_slug in TREND_PERIOD_OVERRIDES:
+        slugs = TREND_PERIOD_OVERRIDES[trend_slug]
+        return {s: PERIOD_LABELS[s] for s in slugs}
+    return dict(PERIOD_LABELS)
+
+
+def get_period_days(period):
+    return PERIOD_DAYS.get(period)
+
+
+def get_date_range(period):
+    days = get_period_days(period)
+    if days is None:
+        return None, None
+    now = timezone.now()
+    return now - timedelta(days=days), now
+
+
+def get_period_nav(current_period, trend_slug):
+    supported = get_supported_periods(trend_slug)
+    keys = list(supported.keys())
+    try:
+        idx = keys.index(current_period)
+    except ValueError:
+        return None, None
+    prev_period = keys[idx - 1] if idx > 0 else None
+    next_period = keys[idx + 1] if idx < len(keys) - 1 else None
+    return prev_period, next_period
+
+
+def compute_and_save_trend(user, slug, period="last_30"):
+    """Compute a single trend for a given period and persist the result.
+
+    Returns elapsed seconds on success, raises on failure.
+    """
+    from trends.trends import TREND_REGISTRY
+
+    fn = TREND_REGISTRY[slug]
+    start = timezone.now()
+    data = fn(user, period=period)
+    TrendResult.objects.update_or_create(
+        user=user,
+        trend_slug=slug,
+        period=period,
+        defaults={"data": data, "computed_at": timezone.now()},
+    )
+    return (timezone.now() - start).total_seconds()

vrobbler/apps/trends/views.py

@@ -1,10 +1,15 @@
 from django.contrib.auth.mixins import LoginRequiredMixin
 from django.views.generic import TemplateView
-
 from trends.models import TrendResult
 from trends.trends import TREND_REGISTRY
+from trends.utils import get_period_nav, get_supported_periods
 
 TREND_METADATA = {
+    "activity-distribution": {
+        "title": "Activity Distribution",
+        "description": "How your scrobbles are divided across media types.",
+        "icon": "📊",
+    },
     "concurrent-listening": {
         "title": "Concurrent Listening",
         "description": "What music were you listening to while on trails or at locations?",
@@ -15,6 +20,36 @@ TREND_METADATA = {
         "description": "What music did you listen to while reading books?",
         "icon": "📖",
     },
+    "mood-trajectory": {
+        "title": "Mood Trajectory",
+        "description": "How your mood quality has changed over time.",
+        "icon": "📈",
+    },
+    "mood-by-time": {
+        "title": "Mood by Time",
+        "description": "How your mood varies by hour of day and day of week.",
+        "icon": "🕐",
+    },
+    "mood-distribution": {
+        "title": "Mood Distribution",
+        "description": "Which moods you feel most often.",
+        "icon": "🎭",
+    },
+    "mood-streaks": {
+        "title": "Mood Streaks",
+        "description": "Your longest runs of positive and negative moods.",
+        "icon": "🔥",
+    },
+    "mood-weather": {
+        "title": "Mood & Weather",
+        "description": "How weather conditions correlate with your mood.",
+        "icon": "🌤",
+    },
+    "peak-hours": {
+        "title": "Peak Activity Hours",
+        "description": "What time of day are you most active?",
+        "icon": "🕐",
+    },
     "reading-pace-vs-activity": {
         "title": "Reading Pace vs Music",
         "description": "Compare how long you read per session with and without concurrent music.",
@@ -25,6 +60,11 @@ TREND_METADATA = {
         "description": "Which media types have you been consuming more or less of recently?",
         "icon": "📈",
     },
+    "weekly-rhythm": {
+        "title": "Weekly Rhythm",
+        "description": "Which days of the week see the most scrobble activity?",
+        "icon": "📅",
+    },
 }
 
 
@@ -33,24 +73,29 @@ class TrendListView(LoginRequiredMixin, TemplateView):
 
     def get_context_data(self, **kwargs):
         ctx = super().get_context_data(**kwargs)
-        results = {
+        results = TrendResult.objects.filter(
-            r.trend_slug: r
+            user=self.request.user,
-            for r in TrendResult.objects.filter(
+        ).order_by("trend_slug", "-computed_at")
-                user=self.request.user
+
-            )
+        latest_by_slug = {}
-        }
+        for r in results:
+            if r.trend_slug not in latest_by_slug:
+                latest_by_slug[r.trend_slug] = r
+
         trends = []
         for slug in TREND_REGISTRY:
             meta = TREND_METADATA.get(slug, {})
-            result = results.get(slug)
+            result = latest_by_slug.get(slug)
-            trends.append({
+            trends.append(
-                "slug": slug,
+                {
-                "title": meta.get("title", slug),
+                    "slug": slug,
-                "description": meta.get("description", ""),
+                    "title": meta.get("title", slug),
-                "icon": meta.get("icon", ""),
+                    "description": meta.get("description", ""),
-                "computed_at": result.computed_at if result else None,
+                    "icon": meta.get("icon", ""),
-                "has_data": result is not None,
+                    "computed_at": result.computed_at if result else None,
-            })
+                    "has_data": result is not None,
+                }
+            )
         ctx["trends"] = trends
         return ctx
 
@@ -66,6 +111,8 @@ class TrendDetailView(LoginRequiredMixin, TemplateView):
             ctx["trend_not_found"] = True
             return ctx
 
+        period = self.request.GET.get("period", "last_30")
+
         meta = TREND_METADATA.get(slug, {})
         ctx["trend"] = {
             "slug": slug,
@@ -74,9 +121,19 @@ class TrendDetailView(LoginRequiredMixin, TemplateView):
             "icon": meta.get("icon", ""),
         }
 
+        supported = get_supported_periods(slug)
+        ctx["supported_periods"] = supported
+        ctx["current_period"] = period
+        ctx["current_period_label"] = supported.get(period, "")
+
+        prev_period, next_period = get_period_nav(period, slug)
+        ctx["prev_period"] = prev_period
+        ctx["next_period"] = next_period
+
         result = TrendResult.objects.filter(
             user=self.request.user,
             trend_slug=slug,
+            period=period,
         ).first()
 
         if result:

vrobbler/apps/videogames/howlongtobeat.py

@@ -10,26 +10,27 @@ def hrs_to_secs(hrs: float) -> int:
     return int(hrs * 60 * 60)
 
 
-def lookup_game_from_hltb(name_or_id: str) -> Optional[dict]:
+def lookup_game_from_hltb(name_or_id: str, search_by_title: bool = False) -> Optional[dict]:
     """Lookup game on HowLongToBeat.com via HLtB ID or a name string and return
     the data in a dictonary mapped to our internal game fields
 
     """
     hltb_game = {}
 
-    try:
+    if not search_by_title:
-        hltb_id = int(name_or_id)
+        try:
-    except ValueError:
+            hltb_id = int(name_or_id)
-        hltb_id = None
+        except ValueError:
+            hltb_id = None
 
-    if hltb_id:
+        if hltb_id:
-        hltb_game = HowLongToBeat().search_from_id(hltb_id)
+            hltb_game = HowLongToBeat().search_from_id(hltb_id)
-        logger.info(f"Found game on HLtB for ID {hltb_id}")
+            logger.info(f"Found game on HLtB for ID {hltb_id}")
 
     if not hltb_game:
         results = HowLongToBeat().search(name_or_id)
         if not results:
-            logger.warn(f"Lookup of game on HLtB failed for ID {name_or_id}")
+            logger.warn(f"Lookup of game on HLtB failed via search {name_or_id!r}")
             return
 
         hltb_game = results[0]

vrobbler/apps/videogames/igdb.py

@@ -19,6 +19,7 @@ GAMES_URL = "https://api.igdb.com/v4/games"
 ALT_NAMES_URL = "https://api.igdb.com/v4/alternative_names"
 SCREENSHOT_URL = "https://api.igdb.com/v4/screenshots"
 COVER_URL = "https://api.igdb.com/v4/covers"
+PLATFORMS_URL = "https://api.igdb.com/v4/platforms"
 
 IGDB_CLIENT_ID = getattr(settings, "IGDB_CLIENT_ID")
 IGDB_CLIENT_SECRET = getattr(settings, "IGDB_CLIENT_SECRET")
@@ -35,6 +36,20 @@ def get_igdb_token() -> str:
     return results.get("access_token")
 
 
+def lookup_platform_names(platform_ids: list, headers: dict) -> list:
+    """Resolve IGDB platform IDs to platform names"""
+    if not platform_ids:
+        return []
+    ids_str = ",".join(str(pid) for pid in platform_ids)
+    body = f"fields name; where id = ({ids_str});"
+    resp = requests.post(PLATFORMS_URL, data=body, headers=headers)
+    if resp.status_code != 200:
+        logger.warn(f"Failed to resolve platform IDs {platform_ids}")
+        return []
+    results = json.loads(resp.content)
+    return [p["name"] for p in results if "name" in p]
+
+
 def lookup_game_id_from_gdb(name: str) -> str:
 
     headers = {
@@ -62,9 +77,10 @@ def lookup_game_id_from_gdb(name: str) -> str:
                 "details": results.get("details"),
             },
         )
-    # Sort our result by IDs so we always get the lowest ID, which is likely to be the least esoteric game
+    # Sort results by release date (oldest first) to prefer the original game
-    results = sorted(results, key=lambda k: k.get("game", 250000))
+    results = [r for r in results if r.get("game")]
-    return results[0].get("game", "")
+    results = sorted(results, key=lambda k: k.get("published_at") or 9999999999)
+    return results[0].get("game", "") if results else ""
 
 
 def lookup_game_from_igdb(name_or_igdb_id: str) -> Dict:
@@ -118,6 +134,16 @@ def lookup_game_from_igdb(name_or_igdb_id: str) -> Dict:
         for genre in game.get("genres"):
             genres.append(genre["name"])
 
+    platforms = []
+    if "release_dates" in game.keys():
+        platform_ids = set()
+        for rd in game["release_dates"]:
+            pid = rd.get("platform")
+            if pid is not None:
+                platform_ids.add(pid)
+        if platform_ids:
+            platforms = lookup_platform_names(list(platform_ids), headers)
+
     game_dict = {
         "igdb_id": game.get("id"),
         "title": game.get("name"),
@@ -129,6 +155,7 @@ def lookup_game_from_igdb(name_or_igdb_id: str) -> Dict:
         "release_date": release_date,
         "summary": game.get("summary"),
         "genres": genres,
+        "platforms": platforms,
     }
 
     return game_dict

vrobbler/apps/videogames/management/commands/cleanup_videogame_metadata.py

@@ -0,0 +1,529 @@
+import logging
+import time
+
+from django.core.management.base import BaseCommand
+
+logger = logging.getLogger(__name__)
+
+MISSING_ALL = [
+    "cover",
+    "screenshot",
+    "summary",
+    "rating",
+    "release_date",
+    "release_year",
+    "igdb_id",
+    "hltb_id",
+]
+
+MISSING_GROUPS = {
+    "cover": lambda g: not bool(g.cover),
+    "screenshot": lambda g: not bool(g.screenshot),
+    "summary": lambda g: not g.summary,
+    "rating": lambda g: g.rating is None,
+    "release_date": lambda g: g.release_date is None,
+    "release_year": lambda g: g.release_year is None,
+    "igdb_id": lambda g: g.igdb_id is None,
+    "hltb_id": lambda g: g.hltb_id is None,
+}
+
+
+def _game_matches(game, flags):
+    if not flags:
+        return False
+    for flag in flags:
+        fn = MISSING_GROUPS.get(flag)
+        if fn and fn(game):
+            return True
+    return False
+
+
+class Command(BaseCommand):
+    help = "Backfill missing metadata on video games from IGDB and HowLongToBeat"
+
+    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 games to process per batch (default: 100)",
+        )
+        parser.add_argument(
+            "--sleep",
+            type=float,
+            default=0.5,
+            help="Seconds to sleep between API calls (default: 0.5)",
+        )
+        parser.add_argument(
+            "--force",
+            action="store_true",
+            help="Re-fetch metadata even if data already exists",
+        )
+        parser.add_argument(
+            "--game-id",
+            type=int,
+            help="Only process a specific game by ID",
+        )
+        parser.add_argument(
+            "--fix-broken-images",
+            action="store_true",
+            help="Check and refetch broken/deleted game images (cover, screenshot, hltb_cover)",
+        )
+        for flag in MISSING_ALL:
+            parser.add_argument(
+                f"--missing-{flag}",
+                dest="missing_flags",
+                action="append_const",
+                const=flag,
+                help=f"Process games missing {flag}",
+            )
+        parser.add_argument(
+            "--all",
+            action="store_true",
+            dest="all_missing",
+            help="Process games missing any metadata field",
+        )
+
+    def handle(self, *args, **options):
+        from videogames.models import VideoGame
+
+        commit = options["commit"]
+        batch_size = options["batch_size"]
+        sleep_secs = options["sleep"]
+        force = options["force"]
+        game_id = options["game_id"]
+        fix_broken_images = options.get("fix_broken_images", False)
+        flags = options.get("missing_flags") or []
+        all_missing = options["all_missing"]
+
+        if all_missing:
+            flags = MISSING_ALL
+
+        if not flags and not game_id and not force and not fix_broken_images:
+            self.stdout.write(
+                "No filters specified. Use --all, --missing-*, --game-id, --force, or --fix-broken-images."
+            )
+            return
+
+        if game_id:
+            qs = VideoGame.objects.filter(id=game_id)
+        else:
+            qs = VideoGame.objects.all()
+
+        if flags:
+            qs = [g for g in qs.iterator() if _game_matches(g, flags)]
+        else:
+            qs = list(qs)
+
+        total = len(qs)
+        self.stdout.write(f"Found {total} games to process")
+
+        if not commit:
+            self.stdout.write(
+                "Dry run — no API calls will be made. Use --commit to run lookups."
+            )
+            return
+
+        title_mismatches = []
+        enriched = 0
+        skipped = 0
+        stats = {
+            "cover_fixed": 0,
+            "screenshot_fixed": 0,
+            "summary_fixed": 0,
+            "rating_fixed": 0,
+            "release_date_fixed": 0,
+            "release_year_fixed": 0,
+            "igdb_id_found": 0,
+            "hltb_id_found": 0,
+            "images_fixed": 0,
+        }
+
+        enriched_any = bool(flags or game_id or force)
+
+        if enriched_any:
+            for batch_num, offset in enumerate(range(0, len(qs), batch_size)):
+                batch = qs[offset : offset + batch_size]
+                for game in batch:
+                    result = self._enrich_game(game, sleep_secs, force)
+                    self._check_retroarch_name(game, title_mismatches)
+                    if result:
+                        enriched += 1
+                        for key in stats:
+                            if result.get(key):
+                                stats[key] += 1
+                    else:
+                        skipped += 1
+
+                self.stdout.write(
+                    f"  Batch {batch_num + 1}: {offset + len(batch)}/{total} — "
+                    f"enriched: {enriched}, skipped: {skipped}"
+                )
+
+        if fix_broken_images:
+            broken_stats = self._fix_broken_images(qs, sleep_secs)
+            stats["images_fixed"] = broken_stats["images_fixed"]
+
+        self.stdout.write(
+            f"\nResults (commit={commit}):\n"
+            f"  Games enriched:      {enriched}\n"
+            f"  Games skipped:       {skipped}\n"
+            f"  Covers fixed:        {stats['cover_fixed']}\n"
+            f"  Screenshots fixed:   {stats['screenshot_fixed']}\n"
+            f"  Summaries fixed:     {stats['summary_fixed']}\n"
+            f"  Ratings fixed:       {stats['rating_fixed']}\n"
+            f"  Release dates fixed: {stats['release_date_fixed']}\n"
+            f"  Release years fixed: {stats['release_year_fixed']}\n"
+            f"  IGDB IDs found:      {stats['igdb_id_found']}\n"
+            f"  HLtB IDs found:      {stats['hltb_id_found']}"
+        )
+        if fix_broken_images:
+            self.stdout.write(f"  Broken images fixed: {stats['images_fixed']}")
+
+        if title_mismatches:
+            self.stdout.write("\nTitle vs retroarch_name mismatches (not auto-fixed):")
+            for retroarch_name, title, game_id in title_mismatches:
+                self.stdout.write(
+                    f"  Game #{game_id}: retroarch_name={retroarch_name!r} vs title={title!r}"
+                )
+
+    def _clean_retroarch_name(self, name):
+        if not name:
+            return ""
+        name = name.strip()
+        if "(" in name:
+            name = name.split("(")[0].strip()
+        return name
+
+    def _check_retroarch_name(self, game, mismatches):
+        if not game.retroarch_name:
+            return
+        cleaned = self._clean_retroarch_name(game.retroarch_name)
+        if cleaned.lower() != game.title.lower():
+            mismatches.append((game.retroarch_name, game.title, game.id))
+            if "retroarch-mismatch" not in game.tags.names():
+                game.tags.add("retroarch-mismatch")
+                self.stdout.write(
+                    f"  [TAG] {game} — tagged as retroarch-mismatch"
+                )
+
+    def _enrich_game(self, game, sleep_secs, force):
+        from videogames.igdb import lookup_game_id_from_gdb, lookup_game_from_igdb
+        from videogames.howlongtobeat import lookup_game_from_hltb
+
+        search_name = self._clean_retroarch_name(game.retroarch_name) or game.title
+
+        changed = {}
+
+        if not game.hltb_id:
+            hltb_data = None
+            if search_name:
+                hltb_data = lookup_game_from_hltb(search_name, search_by_title=True)
+                time.sleep(sleep_secs)
+            if not hltb_data and game.title and game.title != search_name:
+                hltb_data = lookup_game_from_hltb(game.title, search_by_title=True)
+                time.sleep(sleep_secs)
+            if hltb_data:
+                result = self._apply_hltb_data(game, hltb_data, force)
+                if result:
+                    changed.update(result)
+
+        igdb_data = None
+        if not game.igdb_id and search_name:
+            igdb_id = lookup_game_id_from_gdb(search_name)
+            time.sleep(sleep_secs)
+            if igdb_id:
+                igdb_data = lookup_game_from_igdb(str(igdb_id))
+                time.sleep(sleep_secs)
+        elif game.igdb_id:
+            igdb_data = lookup_game_from_igdb(str(game.igdb_id))
+            time.sleep(sleep_secs)
+
+        if igdb_data:
+            igdb_title = igdb_data.get("title", "")
+            igdb_title_clean = self._clean_retroarch_name(igdb_title)
+            if igdb_title_clean.lower() == search_name.lower():
+                if game.igdb_id is None and igdb_data.get("igdb_id"):
+                    game.igdb_id = int(igdb_data["igdb_id"])
+                    game.save(update_fields=["igdb_id"])
+                    changed["igdb_id_found"] = True
+                    self.stdout.write(f"  [IGDB_ID] {game} — found IGDB ID {game.igdb_id}")
+                result = self._apply_igdb_data(game, igdb_data, force)
+                if result:
+                    changed.update(result)
+            else:
+                self.stdout.write(
+                    f"  [IGDB] {game} — title mismatch (IGDB: {igdb_title!r} vs expected: {search_name!r}), re-searching…"
+                )
+                resolved = False
+                for candidate in (search_name, game.title if game.title != search_name else None):
+                    if not candidate:
+                        continue
+                    new_id = lookup_game_id_from_gdb(candidate)
+                    time.sleep(sleep_secs)
+                    if not new_id:
+                        continue
+                    new_data = lookup_game_from_igdb(str(new_id))
+                    time.sleep(sleep_secs)
+                    if not new_data:
+                        continue
+                    new_title = new_data.get("title", "")
+                    new_title_clean = self._clean_retroarch_name(new_title)
+                    if new_title_clean.lower() == candidate.lower():
+                        game.igdb_id = int(new_id)
+                        if new_title and new_title != game.title:
+                            game.title = new_title
+                            changed["title_updated"] = True
+                            self.stdout.write(f"  [TITLE] {game} — updated title to {new_title!r} from IGDB")
+                        game.save(update_fields=["igdb_id"] + (["title"] if changed.get("title_updated") else []))
+                        changed["igdb_id_found"] = True
+                        self.stdout.write(f"  [IGDB_ID] {game} — re-found IGDB ID {game.igdb_id}")
+                        if "igdb-mismatch" in game.tags.names():
+                            game.tags.remove("igdb-mismatch")
+                            self.stdout.write(f"  [TAG] {game} — removed igdb-mismatch tag")
+                        result = self._apply_igdb_data(game, new_data, force)
+                        if result:
+                            changed.update(result)
+                        resolved = True
+                        break
+
+                if not resolved and "igdb-mismatch" not in game.tags.names():
+                    game.tags.add("igdb-mismatch")
+                    self.stdout.write(f"  [TAG] {game} — tagged igdb-mismatch")
+
+        # If retroarch-mismatch tag exists but no longer applies, remove it
+        if "retroarch-mismatch" in game.tags.names():
+            cleaned = self._clean_retroarch_name(game.retroarch_name or "")
+            if cleaned.lower() == game.title.lower():
+                game.tags.remove("retroarch-mismatch")
+                self.stdout.write(f"  [TAG] {game} — removed retroarch-mismatch tag (title now matches)")
+
+        return changed if changed else None
+
+    def _apply_igdb_data(self, game, data, force):
+        from django.core.files.base import ContentFile
+
+        import requests
+
+        changed = {
+            "cover_fixed": False,
+            "screenshot_fixed": False,
+            "summary_fixed": False,
+            "rating_fixed": False,
+            "release_date_fixed": False,
+        }
+
+        update_fields = []
+
+        if data.get("alternative_name") and not game.alternative_name:
+            game.alternative_name = data["alternative_name"]
+            update_fields.append("alternative_name")
+
+        if data.get("summary") and (not game.summary or force):
+            game.summary = data["summary"]
+            update_fields.append("summary")
+            changed["summary_fixed"] = True
+
+        if data.get("rating") is not None and (game.rating is None or force):
+            game.rating = data["rating"]
+            update_fields.append("rating")
+            changed["rating_fixed"] = True
+
+        if data.get("rating_count") is not None and (game.rating_count is None or force):
+            game.rating_count = data["rating_count"]
+            update_fields.append("rating_count")
+
+        if data.get("release_date") and (game.release_date is None or force):
+            game.release_date = data["release_date"]
+            update_fields.append("release_date")
+            changed["release_date_fixed"] = True
+
+        if update_fields:
+            game.save(update_fields=update_fields)
+            self.stdout.write(f"  [IGDB] {game} — {', '.join(update_fields)}")
+
+        cover_url = data.get("cover_url")
+        if cover_url:
+            r = requests.get(cover_url)
+            if r.status_code == 200:
+                fname = f"{game.title}_{game.uuid}.jpg"
+                game.cover.save(fname, ContentFile(r.content), save=True)
+                changed["cover_fixed"] = True
+                self.stdout.write(f"  [COVER] {game} — cover saved from IGDB")
+
+        screenshot_url = data.get("screenshot_url")
+        if screenshot_url:
+            r = requests.get(screenshot_url)
+            if r.status_code == 200:
+                fname = f"{game.title}_{game.uuid}.jpg"
+                game.screenshot.save(fname, ContentFile(r.content), save=True)
+                changed["screenshot_fixed"] = True
+                self.stdout.write(f"  [SCREENSHOT] {game} — screenshot saved from IGDB")
+
+        genres = data.get("genres", [])
+        if genres:
+            existing = set(game.genre.names())
+            new_genres = [g for g in genres if g not in existing]
+            if new_genres:
+                game.genre.add(*new_genres)
+                self.stdout.write(f"  [GENRES] {game} — added {len(new_genres)} genres")
+
+        platforms = data.get("platforms", [])
+        if platforms:
+            existing = set(game.platforms.values_list("name", flat=True))
+            new_platforms = [p for p in platforms if p not in existing]
+            if new_platforms:
+                from videogames.models import VideoGamePlatform
+
+                for name in new_platforms:
+                    p, _ = VideoGamePlatform.objects.get_or_create(name=name)
+                    game.platforms.add(p)
+                self.stdout.write(f"  [PLATFORMS] {game} — added {len(new_platforms)} platforms")
+
+        if "igdb-enriched" not in game.tags.names():
+            game.tags.add("igdb-enriched")
+            self.stdout.write(f"  [TAG] {game} — tagged igdb-enriched")
+
+        return changed if any(changed.values()) else None
+
+    def _apply_hltb_data(self, game, data, force):
+        from django.core.files.base import ContentFile
+
+        import requests
+
+        changed = {
+            "hltb_id_found": False,
+            "release_year_fixed": False,
+        }
+
+        update_fields = []
+
+        hltb_title = data.get("title", "")
+        if hltb_title and hltb_title != game.title:
+            game.title = hltb_title
+            update_fields.append("title")
+            self.stdout.write(f"  [TITLE] {game} — updated title to {hltb_title!r}")
+
+        if data.get("hltb_id") and (game.hltb_id is None or force):
+            game.hltb_id = data["hltb_id"]
+            update_fields.append("hltb_id")
+            changed["hltb_id_found"] = True
+            self.stdout.write(f"  [HLTB_ID] {game} — found HLtB ID {data['hltb_id']}")
+
+        if data.get("release_year") and (game.release_year is None or force):
+            game.release_year = data["release_year"]
+            update_fields.append("release_year")
+            changed["release_year_fixed"] = True
+
+        if data.get("main_story_time") and (game.main_story_time is None or force):
+            game.main_story_time = data["main_story_time"]
+            update_fields.append("main_story_time")
+
+        if data.get("main_extra_time") and (game.main_extra_time is None or force):
+            game.main_extra_time = data["main_extra_time"]
+            update_fields.append("main_extra_time")
+
+        if data.get("completionist_time") and (game.completionist_time is None or force):
+            game.completionist_time = data["completionist_time"]
+            update_fields.append("completionist_time")
+
+        if data.get("hltb_score") is not None and (game.hltb_score is None or force):
+            game.hltb_score = data["hltb_score"]
+            update_fields.append("hltb_score")
+
+        if update_fields:
+            game.save(update_fields=update_fields)
+            self.stdout.write(f"  [HLTB] {game} — {', '.join(update_fields)}")
+
+        cover_url = data.get("cover_url")
+        if cover_url:
+            headers = {"User-Agent": "Vrobbler 0.11.12"}
+            r = requests.get(cover_url, headers=headers)
+            if r.status_code == 200:
+                fname = f"{game.title}_cover_{game.uuid}.jpg"
+                game.hltb_cover.save(fname, ContentFile(r.content), save=True)
+                self.stdout.write(f"  [HLTB_COVER] {game} — cover saved from HLtB")
+
+        platforms = data.get("platforms", [])
+        if platforms:
+            existing = set(game.platforms.values_list("name", flat=True))
+            new_platforms = [p for p in platforms if p not in existing]
+            if new_platforms:
+                from videogames.models import VideoGamePlatform
+
+                for name in new_platforms:
+                    p, _ = VideoGamePlatform.objects.get_or_create(name=name)
+                    game.platforms.add(p)
+                self.stdout.write(f"  [PLATFORMS] {game} — added {len(new_platforms)} platforms")
+
+        if "hltb-enriched" not in game.tags.names():
+            game.tags.add("hltb-enriched")
+            self.stdout.write(f"  [TAG] {game} — tagged hltb-enriched")
+
+        return changed if any(changed.values()) else None
+
+    def _fix_broken_images(self, games, sleep_secs):
+        from django.core.files.base import ContentFile
+
+        import requests
+
+        from videogames.igdb import lookup_game_from_igdb
+        from videogames.howlongtobeat import lookup_game_from_hltb
+
+        stats = {"cover_fixed": 0, "screenshot_fixed": 0, "images_fixed": 0}
+
+        for game in games:
+            for field_name, source in [
+                ("cover", "igdb"),
+                ("screenshot", "igdb"),
+                ("hltb_cover", "hltb"),
+            ]:
+                field = getattr(game, field_name)
+                if not field.name:
+                    continue
+                if field.storage.exists(field.name):
+                    continue
+
+                self.stdout.write(
+                    f"  [IMAGE] {game} — {field_name} is broken (file missing), refetching…"
+                )
+
+                if source == "igdb" and game.igdb_id:
+                    data = lookup_game_from_igdb(str(game.igdb_id))
+                    time.sleep(sleep_secs)
+                    if not data:
+                        continue
+                    url = data.get("cover_url" if field_name == "cover" else "screenshot_url")
+                    if not url:
+                        continue
+                    r = requests.get(url)
+                    if r.status_code != 200:
+                        continue
+                    fname = f"{game.title}_{game.uuid}.jpg"
+                    getattr(game, field_name).save(fname, ContentFile(r.content), save=True)
+                    stats["images_fixed"] += 1
+                    self.stdout.write(f"  [IMAGE] {game} — {field_name} refetched from IGDB")
+
+                elif source == "hltb" and game.hltb_id:
+                    data = lookup_game_from_hltb(str(game.hltb_id))
+                    time.sleep(sleep_secs)
+                    if not data:
+                        continue
+                    url = data.get("cover_url")
+                    if not url:
+                        continue
+                    headers = {"User-Agent": "Vrobbler 0.11.12"}
+                    r = requests.get(url, headers=headers)
+                    if r.status_code != 200:
+                        continue
+                    fname = f"{game.title}_cover_{game.uuid}.jpg"
+                    game.hltb_cover.save(fname, ContentFile(r.content), save=True)
+                    stats["images_fixed"] += 1
+                    self.stdout.write(f"  [IMAGE] {game} — hltb_cover refetched from HLtB")
+
+        return stats

vrobbler/apps/videogames/models.py

@@ -215,12 +215,16 @@ class VideoGame(LongPlayScrobblableMixin):
     def fix_metadata(self, force_update: bool = False):
         from videogames.utils import (
             get_or_create_videogame,
+            load_game_data_from_hltb,
             load_game_data_from_igdb,
         )
 
         if self.hltb_id and force_update:
             get_or_create_videogame(str(self.hltb_id), force_update)
 
+        if not self.hltb_id:
+            load_game_data_from_hltb(self.id)
+
         if not self.igdb_id:
             # This almost never works without intervention
             self.igdb_id = lookup_game_id_from_gdb(self.title)

vrobbler/apps/videogames/retroarch.py

@@ -153,6 +153,13 @@ def import_retroarch_lrtl_files(playlog_path: str, user_id: int) -> List[dict]:
             continue
 
         logger.info(f"Queued scrobble for game {found_game.id}")
+
+        log_data = {"emulated": True}
+        if last_scrobble and last_scrobble.log:
+            prev = last_scrobble.log
+            if prev.get("emulator"):
+                log_data["emulator"] = prev["emulator"]
+
         new_scrobbles.append(
             Scrobble(
                 video_game_id=found_game.id,
@@ -168,6 +175,7 @@ def import_retroarch_lrtl_files(playlog_path: str, user_id: int) -> List[dict]:
                 user_id=user_id,
                 source="Retroarch",
                 media_type=Scrobble.MediaType.VIDEO_GAME,
+                log=log_data,
             )
         )
     created_scrobbles = Scrobble.objects.bulk_create(new_scrobbles)

vrobbler/apps/videogames/templatetags/naturalduration.py

@@ -15,13 +15,11 @@ def natural_duration(value):
     seconds = remainder % 60
     parts = []
     if days:
-        parts.append(f"{days} day{'s' if days != 1 else ''}")
+        parts.append(f"{days} d")
     if hours:
-        parts.append(f"{hours} hour{'s' if hours != 1 else ''}")
+        parts.append(f"{hours} hr")
     if minutes:
-        parts.append(f"{minutes} minute{'s' if minutes != 1 else ''}")
+        parts.append(f"{minutes} min")
     if seconds or not parts:
-        parts.append(f"{seconds} second{'s' if seconds != 1 else ''}")
+        parts.append(f"{seconds} sec")
-    if len(parts) == 1:
+    return ", ".join(parts)
-        return parts[0]
-    return ", ".join(parts[:-1]) + " and " + parts[-1]

vrobbler/apps/videogames/utils.py

@@ -7,8 +7,6 @@ from videogames.howlongtobeat import lookup_game_from_hltb
 from videogames.igdb import lookup_game_from_igdb
 from videogames.models import VideoGame, VideoGamePlatform
 
-from vrobbler.apps.videogames.exceptions import GameNotFound
-
 logger = logging.getLogger(__name__)
 
 
@@ -16,22 +14,33 @@ def get_or_create_videogame(
     name_or_id: str,
     force_update: bool = False,
 ) -> Optional[VideoGame]:
-    """Look up game by name or ID from HowLongToBeat"""
+    """Look up game by name or ID from HowLongToBeat, then enrich with IGDB"""
 
-    game_dict = lookup_game_from_hltb(name_or_id)
+    hltb_data = lookup_game_from_hltb(name_or_id)
 
-    if not game_dict:
+    if hltb_data:
-        game_dict = lookup_game_from_igdb(name_or_id)
+        game = _create_update_from_dict(hltb_data, force_update)
+    else:
+        igdb_data = lookup_game_from_igdb(name_or_id)
+        if igdb_data:
+            game = _create_update_from_dict(igdb_data, force_update)
+        else:
+            return None
 
-    if not game_dict:
+    if game:
-        return
+        game.fix_metadata()
+    return game
+
+
+def _create_update_from_dict(
+    game_dict: dict, force_update: bool = False
+) -> Optional[VideoGame]:
 
-    # Create missing platforms and prep for loading after create
     platform_ids = []
     if "platforms" in game_dict.keys():
         platforms = game_dict.get("platforms", [])
         if platforms:
-            for platform in game_dict.get("platforms", []):
+            for platform in platforms:
                 p, _created = VideoGamePlatform.objects.get_or_create(name=platform)
                 platform_ids.append(p.id)
         game_dict.pop("platforms")
@@ -48,7 +57,7 @@ def get_or_create_videogame(
 
     title = game_dict.get("title")
     if not title:
-        raise GameNotFound(name_or_id)
+        return None
 
     hltb_id = game_dict.get("hltb_id")
     igdb_id = game_dict.get("igdb_id")
@@ -69,21 +78,19 @@ def get_or_create_videogame(
         VideoGame.objects.filter(pk=game.id).update(**game_dict)
         game.refresh_from_db()
 
-        # Associate plaforms
         if platform_ids:
             game.platforms.add(*platform_ids)
 
         if genres:
             game.genre.add(*genres)
 
-        if not game.screenshot and screenshot_url:
+        if screenshot_url:
             r = requests.get(screenshot_url)
             if r.status_code == 200:
                 fname = f"{game.title}_{game.uuid}.jpg"
                 game.screenshot.save(fname, ContentFile(r.content), save=True)
 
-        # Go get cover image if the URL is present
+        if cover_url:
-        if cover_url and not game.hltb_cover:
             headers = {"User-Agent": "Vrobbler 0.11.12"}
             r = requests.get(cover_url, headers=headers)
             logger.debug(r.status_code)
@@ -91,12 +98,89 @@ def get_or_create_videogame(
                 fname = f"{game.title}_cover_{game.uuid}.jpg"
                 game.hltb_cover.save(fname, ContentFile(r.content), save=True)
                 logger.debug("Loaded cover image from HLtB")
-        game.fix_metadata()
+
+        tag = "hltb-enriched" if hltb_id else "igdb-enriched"
+        if tag not in game.tags.names():
+            game.tags.add(tag)
+            logger.info(f"Game {game} tagged {tag}")
 
     return game
 
 
-def load_game_data_from_igdb(game_id: int, igdb_id: str = "") -> Optional[VideoGame]:
+def load_game_data_from_hltb(
+    game_id: int, expected_title: str = ""
+) -> Optional[VideoGame]:
+    """Look up HLtB data for an existing game and apply it"""
+    game = VideoGame.objects.filter(id=game_id).first()
+    if not game:
+        logger.warn(f"Video game with ID {game_id} not found")
+        return
+
+    logger.info(f"Looking up HLtB data for {game}")
+    hltb_data = lookup_game_from_hltb(game.title, search_by_title=True)
+    if not hltb_data:
+        logger.warn(f"No HLtB data found for {game}")
+        return
+
+    update_fields = []
+
+    hltb_title = hltb_data.get("title", "")
+    if hltb_title and hltb_title != game.title:
+        game.title = hltb_title
+        update_fields.append("title")
+        logger.info(f"Game {game.id} title updated to {hltb_title!r}")
+
+    if hltb_data.get("hltb_id") and (game.hltb_id is None):
+        game.hltb_id = hltb_data["hltb_id"]
+        update_fields.append("hltb_id")
+
+    if hltb_data.get("release_year") and (game.release_year is None):
+        game.release_year = hltb_data["release_year"]
+        update_fields.append("release_year")
+
+    if hltb_data.get("main_story_time") and (game.main_story_time is None):
+        game.main_story_time = hltb_data["main_story_time"]
+        update_fields.append("main_story_time")
+
+    if hltb_data.get("main_extra_time") and (game.main_extra_time is None):
+        game.main_extra_time = hltb_data["main_extra_time"]
+        update_fields.append("main_extra_time")
+
+    if hltb_data.get("completionist_time") and (game.completionist_time is None):
+        game.completionist_time = hltb_data["completionist_time"]
+        update_fields.append("completionist_time")
+
+    if hltb_data.get("hltb_score") is not None and (game.hltb_score is None):
+        game.hltb_score = hltb_data["hltb_score"]
+        update_fields.append("hltb_score")
+
+    if update_fields:
+        game.save(update_fields=update_fields)
+
+    platforms = hltb_data.get("platforms", [])
+    if platforms:
+        for name in platforms:
+            p, _ = VideoGamePlatform.objects.get_or_create(name=name)
+            game.platforms.add(p)
+
+    cover_url = hltb_data.get("cover_url")
+    if cover_url:
+        headers = {"User-Agent": "Vrobbler 0.11.12"}
+        r = requests.get(cover_url, headers=headers)
+        if r.status_code == 200:
+            fname = f"{game.title}_cover_{game.uuid}.jpg"
+            game.hltb_cover.save(fname, ContentFile(r.content), save=True)
+
+    if "hltb-enriched" not in game.tags.names():
+        game.tags.add("hltb-enriched")
+        logger.info(f"Game {game} tagged hltb-enriched")
+
+    return game
+
+
+def load_game_data_from_igdb(
+    game_id: int, igdb_id: str = "", expected_title: str = ""
+) -> Optional[VideoGame]:
     """Look up game, if it doesn't exist, lookup data from igdb"""
     game = VideoGame.objects.filter(id=game_id).first()
     if not game:
@@ -116,25 +200,68 @@ def load_game_data_from_igdb(game_id: int, igdb_id: str = "") -> Optional[VideoG
         logger.warn(f"No game data found on IGDB for ID {igdb_id}")
         return
 
+    igdb_title = game_dict.get("title", "")
+    igdb_title_clean = igdb_title.split(" (")[0].strip() if " (" in igdb_title else igdb_title
+    expected = expected_title or game.title
+    if igdb_title_clean.lower() != expected.lower():
+        logger.info(
+            f"IGDB title {igdb_title!r} doesn't match expected {expected!r} for {game} — re-searching…"
+        )
+        from videogames.igdb import lookup_game_id_from_gdb
+
+        new_id = lookup_game_id_from_gdb(expected)
+        if new_id:
+            new_data = lookup_game_from_igdb(str(new_id))
+            if new_data:
+                new_title = new_data.get("title", "")
+                new_title_clean = new_title.split(" (")[0].strip() if " (" in new_title else new_title
+                if new_title_clean.lower() == expected.lower():
+                    game_dict = new_data
+                    igdb_id = int(new_id)
+                    if game.igdb_id != igdb_id:
+                        game.igdb_id = igdb_id
+                        game.save(update_fields=["igdb_id"])
+                        logger.info(f"Game {game} IGDB ID updated to {igdb_id}")
+
+        igdb_title = game_dict.get("title", "")
+        igdb_title_clean = igdb_title.split(" (")[0].strip() if " (" in igdb_title else igdb_title
+        if igdb_title_clean.lower() != expected.lower():
+            if "igdb-mismatch" not in game.tags.names():
+                game.tags.add("igdb-mismatch")
+                logger.info(
+                    f"Game {game} tagged igdb-mismatch (IGDB: {igdb_title!r} vs expected: {expected!r})"
+                )
+            return
+
     screenshot_url = game_dict.pop("screenshot_url")
     cover_url = game_dict.pop("cover_url")
     genres = game_dict.pop("genres")
+    platforms = game_dict.pop("platforms", [])
 
     VideoGame.objects.filter(pk=game.id).update(**game_dict)
     game.refresh_from_db()
 
     game.genre.add(*genres)
 
-    if not game.screenshot and screenshot_url:
+    if platforms:
+        for name in platforms:
+            p, _ = VideoGamePlatform.objects.get_or_create(name=name)
+            game.platforms.add(p)
+
+    if screenshot_url:
         r = requests.get(screenshot_url)
         if r.status_code == 200:
             fname = f"{game.title}_{game.uuid}.jpg"
             game.screenshot.save(fname, ContentFile(r.content), save=True)
 
-    if not game.cover and cover_url:
+    if cover_url:
         r = requests.get(cover_url)
         if r.status_code == 200:
             fname = f"{game.title}_{game.uuid}.jpg"
             game.cover.save(fname, ContentFile(r.content), save=True)
 
+    if "igdb-enriched" not in game.tags.names():
+        game.tags.add("igdb-enriched")
+        logger.info(f"Game {game} tagged igdb-enriched")
+
     return game

vrobbler/apps/videos/context_processors.py

@@ -1,8 +1,24 @@
+from django.core.cache import cache
+
 from videos.models import Video, Series
 
+CACHE_TTL = 300
+
 
 def video_lists(request):
+    movie_list = cache.get("video_lists_movie_list")
+    if movie_list is None:
+        movie_list = list(
+            Video.objects.filter(video_type=Video.VideoType.MOVIE).only("id", "title")
+        )
+        cache.set("video_lists_movie_list", movie_list, CACHE_TTL)
+
+    series_list = cache.get("video_lists_series_list")
+    if series_list is None:
+        series_list = list(Series.objects.all().only("id", "name"))
+        cache.set("video_lists_series_list", series_list, CACHE_TTL)
+
     return {
-        "movie_list": Video.objects.filter(video_type=Video.VideoType.MOVIE),
+        "movie_list": movie_list,
-        "series_list": Series.objects.all(),
+        "series_list": series_list,
     }

vrobbler/apps/videos/management/commands/cleanup_channel_metadata.py

@@ -0,0 +1,82 @@
+import logging
+
+from django.core.management.base import BaseCommand
+from django.db import models, transaction
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Enrich YouTube and Twitch channel metadata from upstream APIs"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--force",
+            action="store_true",
+            help="Overwrite existing channel name and cover image",
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show what would be done without making changes",
+        )
+        parser.add_argument(
+            "--youtube-only",
+            action="store_true",
+            help="Only process channels with a youtube_id",
+        )
+        parser.add_argument(
+            "--twitch-only",
+            action="store_true",
+            help="Only process channels with a twitch_id",
+        )
+
+    def handle(self, *args, **options):
+        from videos.models import Channel
+
+        force = options["force"]
+        dry_run = options["dry_run"]
+        youtube_only = options["youtube_only"]
+        twitch_only = options["twitch_only"]
+
+        qs = Channel.objects.all()
+
+        if youtube_only:
+            qs = qs.exclude(youtube_id__isnull=True).exclude(youtube_id="")
+        elif twitch_only:
+            qs = qs.exclude(twitch_id__isnull=True).exclude(twitch_id="")
+        else:
+            qs = qs.filter(
+                models.Q(youtube_id__isnull=False) | models.Q(twitch_id__isnull=False)
+            ).exclude(youtube_id="", twitch_id="")
+
+        total = qs.count()
+        self.stdout.write(f"Processing {total} channels")
+
+        if dry_run:
+            for channel in qs.iterator():
+                source = "youtube" if channel.youtube_id else "twitch"
+                identifier = channel.youtube_id or channel.twitch_id
+                self.stdout.write(
+                    f"  [DRY RUN] Would fix {channel.name} ({source}: {identifier})"
+                )
+            return
+
+        updated = 0
+        errors = 0
+        for channel in qs.iterator():
+            try:
+                with transaction.atomic():
+                    channel.fix_metadata(force=force)
+                updated += 1
+                source = "youtube" if channel.youtube_id else "twitch"
+                self.stdout.write(f"  [{updated}/{total}] {channel.name} ({source})")
+            except Exception as e:
+                errors += 1
+                self.stdout.write(
+                    self.style.ERROR(f"  Error updating channel {channel.name}: {e}")
+                )
+
+        self.stdout.write(
+            self.style.SUCCESS(f"\nDone! {updated} channels updated, {errors} errors")
+        )

vrobbler/apps/videos/management/commands/cleanup_series_metadata.py

@@ -0,0 +1,85 @@
+import logging
+
+from django.core.management.base import BaseCommand
+from django.db import models, transaction
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Enrich TV series metadata from TMDB/OMDB APIs"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--force",
+            action="store_true",
+            help="Overwrite existing cover image",
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show what would be done without making changes",
+        )
+        parser.add_argument(
+            "--imdb-id",
+            type=str,
+            help="Only process series with this imdb_id",
+        )
+        parser.add_argument(
+            "--needs-metadata",
+            action="store_true",
+            help="Only process series missing imdb_id or cover image",
+        )
+
+    def handle(self, *args, **options):
+        from videos.models import Series
+
+        force = options["force"]
+        dry_run = options["dry_run"]
+        imdb_id = options["imdb_id"]
+        needs_metadata = options["needs_metadata"]
+
+        qs = Series.objects.all()
+        if imdb_id:
+            qs = qs.filter(imdb_id=imdb_id)
+        if needs_metadata:
+            qs = qs.filter(
+                models.Q(imdb_id__isnull=True)
+                | models.Q(imdb_id="")
+                | models.Q(cover_image__isnull=True)
+                | models.Q(cover_image="")
+            )
+
+        total = qs.count()
+        self.stdout.write(f"Processing {total} series")
+
+        if dry_run:
+            for series in qs.iterator():
+                has_imdb = bool(series.imdb_id)
+                has_image = bool(series.cover_image)
+                self.stdout.write(
+                    f"  [DRY RUN] Would fix {series.name}"
+                    f" (imdb_id={'✓' if has_imdb else '✗'}"
+                    f", image={'✓' if has_image else '✗'})"
+                )
+            return
+
+        updated = 0
+        errors = 0
+        for series in qs.iterator():
+            try:
+                with transaction.atomic():
+                    series.fix_metadata(force_update=force)
+                updated += 1
+                self.stdout.write(f"  [{updated}/{total}] {series.name}")
+            except Exception as e:
+                errors += 1
+                self.stdout.write(
+                    self.style.ERROR(
+                        f"  Error updating series {series.name} (imdb_id={series.imdb_id}): {e}"
+                    )
+                )
+
+        self.stdout.write(
+            self.style.SUCCESS(f"\nDone! {updated} series updated, {errors} errors")
+        )

vrobbler/apps/videos/migrations/0031_channel_custom_url_channel_description.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.29 on 2026-06-16 19:33
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("videos", "0030_alter_channel_genre_alter_series_genre_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="channel",
+            name="custom_url",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name="channel",
+            name="description",
+            field=models.TextField(blank=True, null=True),
+        ),
+    ]

vrobbler/apps/videos/models.py

@@ -1,3 +1,4 @@
+import json
 import logging
 import re
 from dataclasses import dataclass
@@ -58,6 +59,8 @@ class Channel(ScrobblableMixin):
     )
     youtube_id = models.CharField(max_length=255, **BNULL)
     twitch_id = models.CharField(max_length=255, **BNULL)
+    description = models.TextField(**BNULL)
+    custom_url = models.CharField(max_length=255, **BNULL)
     genre = TaggableManager(through=ObjectWithGenres, blank=True, verbose_name="Genre")
 
     class Meta:
@@ -77,6 +80,28 @@ class Channel(ScrobblableMixin):
     def title(self):
         return self.name
 
+    @property
+    def safe_cover_image_url(self) -> str:
+        if self.cover_image:
+            try:
+                if self.cover_image.storage.exists(self.cover_image.name):
+                    return self.cover_medium.url
+            except Exception:
+                pass
+        return "/static/images/not-found.jpg"
+
+    @property
+    def youtube_url(self) -> str:
+        if self.youtube_id:
+            return YOUTUBE_CHANNEL_URL + self.youtube_id
+        return ""
+
+    @property
+    def twitch_url(self) -> str:
+        if self.twitch_id:
+            return f"https://www.twitch.tv/{self.twitch_id}"
+        return ""
+
     def save_image_from_url(self, url: str, force_update: bool = False):
         if not self.cover_image or (force_update and url):
             r = requests.get(url)
@@ -92,7 +117,7 @@ class Channel(ScrobblableMixin):
             played_query = models.Q()
         return Scrobble.objects.filter(
             played_query,
-            channel=self,
+            models.Q(channel=self) | models.Q(video__channel=self),
             user=user_id,
         ).order_by("-timestamp")
 
@@ -138,8 +163,74 @@ class Channel(ScrobblableMixin):
         )
 
     def fix_metadata(self, force: bool = False):
-        # TODO Scrape channel info from Youtube
+        if self.youtube_id:
-        logger.warning("Not implemented yet")
+            GOOGLE_CHANNELS_URL = "https://www.googleapis.com/youtube/v3/channels?part=snippet,topicDetails&id={channel_id}&key={key}"
+            url = GOOGLE_CHANNELS_URL.format(
+                channel_id=self.youtube_id,
+                key=settings.GOOGLE_API_KEY,
+            )
+            headers = {"User-Agent": "Vrobbler 0.11.12"}
+            response = requests.get(url, headers=headers)
+
+            if response.status_code != 200:
+                logger.warning(
+                    "Bad response from Google for channel",
+                    extra={"response": response},
+                )
+                return
+
+            items = json.loads(response.content).get("items", [])
+            if not items:
+                logger.warning(f"No YouTube channel data for {self.youtube_id}")
+                return
+
+            snippet = items[0].get("snippet", {})
+            channel_name = snippet.get("title", "")
+            if channel_name and (not self.name or force):
+                self.name = channel_name
+
+            channel_description = snippet.get("description", "")
+            if channel_description and (not self.description or force):
+                self.description = channel_description
+
+            custom_url = snippet.get("customUrl", "")
+            if custom_url and (not self.custom_url or force):
+                self.custom_url = custom_url
+
+            thumbnails = snippet.get("thumbnails", {})
+            cover_url = (
+                thumbnails.get("high", {}).get("url")
+                or thumbnails.get("medium", {}).get("url")
+                or thumbnails.get("default", {}).get("url")
+            )
+            if cover_url:
+                self.save_image_from_url(cover_url, force_update=force)
+
+            topic_details = items[0].get("topicDetails", {})
+            topic_categories = topic_details.get("topicCategories", [])
+            if topic_categories:
+                if force:
+                    self.genre.clear()
+                for category_url in topic_categories:
+                    topic_name = category_url.rstrip("/").split("/")[-1]
+                    topic_name = topic_name.replace("_", " ").replace("-", " ")
+                    self.genre.add(topic_name)
+
+            self.save()
+            return
+
+        if self.twitch_id:
+            from videos.sources.twitch import lookup_channel_from_twitch
+
+            metadata = lookup_channel_from_twitch(self.twitch_id)
+            if metadata.name and (not self.name or force):
+                self.name = metadata.name
+            if metadata.profile_image_url:
+                self.save_image_from_url(metadata.profile_image_url, force_update=force)
+            self.save()
+            return
+
+        logger.warning(f"No youtube_id or twitch_id set for channel {self}")
         return
 
 
@@ -230,25 +321,41 @@ class Series(TimeStampedModel):
         return not last_scrobble.played_to_completion
 
     def fix_metadata(self, force_update=False):
-        name_or_id = self.name
+        from tmdbv3api import TV
-        if self.imdb_id:
-            name_or_id = self.imdb_id
-        video_metadata: VideoMetadata = lookup_video_from_tmdb(name_or_id)
 
-        if not video_metadata.title:
+        if not self.imdb_id:
-            logger.warning(f"No imdb data for {self}")
+            tv = TV()
+            results = tv.search(self.name)
+            if results:
+                show_id = results[0].id
+                external_ids = tv.external_ids(show_id)
+                if external_ids and external_ids.imdb_id:
+                    self.imdb_id = external_ids.imdb_id
+                    self.save(update_fields=["imdb_id"])
+                else:
+                    logger.warning(f"No IMDB ID found on TMDB for {self}")
+                    return
+            else:
+                logger.warning(f"No results on TMDB for {self.name}")
+                return
+
+        video_metadata = lookup_video_from_tmdb(self.imdb_id)
+        if not video_metadata or not video_metadata.title:
+            logger.warning(f"No metadata for {self}")
             return
 
-        cover_url = imdb_dict.get("cover_url")
+        if video_metadata.cover_url and (not self.cover_image or force_update):
-
+            r = requests.get(video_metadata.cover_url)
-        if (not self.cover_image or force_update) and cover_url:
-            r = requests.get(cover_url)
             if r.status_code == 200:
                 fname = f"{self.name}_{self.uuid}.jpg"
                 self.cover_image.save(fname, ContentFile(r.content), save=True)
 
-        if genres := imdb_dict.get("genres"):
+        self.plot = video_metadata.plot or ""
-            self.genre.add(*genres)
+        self.imdb_rating = getattr(video_metadata, "imdb_rating", None)
+        self.save()
+
+        if video_metadata.genres:
+            self.genre.add(*video_metadata.genres)
 
     @classmethod
     def find_or_create(cls, imdb_id: str, overwrite: bool = True):
@@ -452,9 +559,7 @@ class Video(ScrobblableMixin):
             if metadata.channel_id:
                 from videos.models import Channel
 
-                self.channel = Channel.objects.filter(
+                self.channel = Channel.objects.filter(id=metadata.channel_id).first()
-                    id=metadata.channel_id
-                ).first()
 
             self.save()
 
@@ -476,9 +581,7 @@ class Video(ScrobblableMixin):
                 logger.warning(f"No metadata found for {self} from TMDB or OMDB")
                 return
 
-            vdict, series_id, cover, genres = (
+            vdict, series_id, cover, genres = metadata.as_dict_with_cover_and_genres()
-                metadata.as_dict_with_cover_and_genres()
-            )
 
             for k, v in vdict.items():
                 setattr(self, k, v)