[release] Bump to version 57.0

- Scrobble button on some media list pages dont work
- Use HTMx to update the Now Playing widget
- Add a live page that updates the scrobble list via JS polling
- Turns out we cant cache the now playing widget
- What would it look like to add an MCP server to expose scrobbles and media items?

PROJECT.org

@@ -604,6 +604,121 @@ 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.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:

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vrobbler"
-version = "55.3"
+version = "57.0"
 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"

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/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/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(
-            period_filter, user=user, **{media_field + "__isnull": False}
-        )
-        existing_by_media_id = {getattr(r, media_field): r for r in existing}
-        found_media_ids = set()
+        with transaction.atomic():
+            records_to_create = []
+            records_to_update = []
 
-        for result in results:
-            media_id = result[config["values"]]
-            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 = ChartRecord.objects.select_for_update().filter(
+                period_filter, user=user, **{media_field + "__isnull": False}
             )
+            existing_by_media_id = {getattr(r, media_field): r for r in existing}
+            found_media_ids = set()
 
-        if records_to_create:
-            ChartRecord.objects.bulk_create(records_to_create, batch_size=500)
+            for result in results:
+                media_id = result[config["values"]]
+                if media_id is None:
+                    continue
 
-        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}"
-        )
+                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
+                )
+
+            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(),
-        "album_list": Album.objects.all(),
+        "artist_list": artist_list,
+        "album_list": album_list,
     }

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",
-    "bricksets": "BrickSet",
+    "locations": "GeoLocation",
     "trails": "Trail",
     "beers": "Beer",
+    "puzzles": "Puzzle",
     "foods": "Food",
-    "locations": "GeoLocation",
-    "videos": "Video",
+    "tasks": "Task",
+    "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(
-            in_progress=True,
-            is_paused=False,
-            user=user,
-        ).exclude(
-            media_type__in=EXCLUDE_FROM_NOW_PLAYING,
-        )
+        "now_playing_list": list(
+            Scrobble.objects.filter(
+                in_progress=True,
+                is_paused=False,
+                user=user,
+            )
+            .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/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
     )
@@ -1316,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):
@@ -1874,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)
 
@@ -1924,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
@@ -1953,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
@@ -1327,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"),
@@ -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(),

vrobbler/apps/scrobbles/utils.py

@@ -154,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, we should start a monthly parsing of lastFm for this user going back to 2002"
+                "No existing LastFM import for user %s, "
+                "starting a full parse",
+                user_id,
             )
-            continue
+            last_processed = None
 
         lfm_client = LastFM(user=get_user_model().objects.filter(id=user_id).first())
 

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"
@@ -887,7 +918,7 @@ def scrobble_start(request, media_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(
@@ -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))

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/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 ''}")
-    if len(parts) == 1:
-        return parts[0]
-    return ", ".join(parts[:-1]) + " and " + parts[-1]
+        parts.append(f"{seconds} sec")
+    return ", ".join(parts)

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),
-        "series_list": Series.objects.all(),
+        "movie_list": movie_list,
+        "series_list": series_list,
     }

vrobbler/context_processors.py

@@ -4,46 +4,55 @@ from importlib.metadata import version as get_version
 from pathlib import Path
 
 
+_GIT_COMMIT = None
+
+
 def version_info(request):
+    global _GIT_COMMIT
+
     try:
         app_version = get_version("vrobbler")
     except Exception:
         app_version = "unknown"
 
     commit = os.environ.get("VROBBLER_COMMIT")
-    if not commit:
-        # Try to import from _commit.py module first
+    if commit:
+        return {"app_version": app_version, "git_commit": commit}
+
+    if _GIT_COMMIT is not None:
+        return {"app_version": app_version, "git_commit": _GIT_COMMIT}
+
+    try:
+        from vrobbler._commit import commit as _commit
+    except ImportError:
+        pass
+    else:
+        if _commit and _commit != "unknown":
+            _GIT_COMMIT = _commit
+            return {"app_version": app_version, "git_commit": _GIT_COMMIT}
+
+    commit_file = Path("/var/lib/vrobbler/commit.txt")
+    if commit_file.exists():
         try:
-            from vrobbler._commit import commit as _commit
-        except ImportError:
+            commit = commit_file.read_text().strip()
+            if commit:
+                _GIT_COMMIT = commit
+                return {"app_version": app_version, "git_commit": _GIT_COMMIT}
+        except OSError:
             pass
-        else:
-            if _commit and _commit != "unknown":
-                return {"app_version": app_version, "git_commit": _commit}
 
-        # Try to read from commit file (written during deploy)
-        commit_file = Path("/var/lib/vrobbler/commit.txt")
-        if commit_file.exists():
-            try:
-                commit = commit_file.read_text().strip()
-                if commit:
-                    return {"app_version": app_version, "git_commit": commit}
-            except OSError:
-                pass
-
-        # Fall back to git command
-        PROJECT_ROOT = Path(__file__).resolve().parent.parent
-        try:
-            commit = (
-                subprocess.check_output(
-                    ["git", "rev-parse", "--short", "HEAD"],
-                    cwd=PROJECT_ROOT,
-                    stderr=subprocess.DEVNULL,
-                )
-                .decode("utf-8")
-                .strip()
+    PROJECT_ROOT = Path(__file__).resolve().parent.parent
+    try:
+        _GIT_COMMIT = (
+            subprocess.check_output(
+                ["git", "rev-parse", "--short", "HEAD"],
+                cwd=PROJECT_ROOT,
+                stderr=subprocess.DEVNULL,
             )
-        except (subprocess.SubprocessError, FileNotFoundError):
-            commit = "unknown"
+            .decode("utf-8")
+            .strip()
+        )
+    except (subprocess.SubprocessError, FileNotFoundError):
+        _GIT_COMMIT = "unknown"
 
-    return {"app_version": app_version, "git_commit": commit}
+    return {"app_version": app_version, "git_commit": _GIT_COMMIT}

vrobbler/settings.py

@@ -228,6 +228,7 @@ INSTALLED_APPS = [
     "foods",
     "lifeevents",
     "moods",
+    "discgolf",
     "birds",
     "mathfilters",
     "rest_framework",
@@ -235,6 +236,7 @@ INSTALLED_APPS = [
     "allauth.account",
     "allauth.socialaccount",
     "django_celery_results",
+    "mcp_server",
 ]
 
 SITE_ID = 1
@@ -328,6 +330,13 @@ REST_FRAMEWORK = {
     "PAGE_SIZE": 200,
 }
 
+DJANGO_MCP_AUTHENTICATION_CLASSES = [
+    "oauth2_provider.contrib.rest_framework.OAuth2Authentication",
+    "rest_framework.authentication.TokenAuthentication",
+    "rest_framework.authentication.SessionAuthentication",
+]
+DJANGO_MCP_GET_SERVER_INSTRUCTIONS_TOOL = True
+
 LOGIN_REDIRECT_URL = "/"
 
 AUTH_PASSWORD_VALIDATORS = [
@@ -361,11 +370,11 @@ USE_TZ = True
 # Static files (CSS, JavaScript, Images)
 # https://docs.djangoproject.com/en/3.1/howto/static-files/
 #
-from storages.backends import s3boto3
-
 USE_S3_STORAGE = os.getenv("VROBBLER_USE_S3", "False").lower() in TRUTHY
 
 if USE_S3_STORAGE:
+    from storages.backends import s3boto3
+
     AWS_S3_ENDPOINT_URL = os.getenv("AWS_S3_ENDPOINT_URL", "")
     AWS_STORAGE_BUCKET_NAME = os.getenv("AWS_STORAGE_BUCKET_NAME", "")
     AWS_S3_ACCESS_KEY_ID = os.getenv("AWS_S3_ACCESS_KEY_ID")

vrobbler/templates/base.html

@@ -13,6 +13,7 @@
         <script src="https://cdn.jsdelivr.net/npm/popper.js@1.12.9/dist/umd/popper.min.js" crossorigin="anonymous"></script>
         <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>
         <script src="https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.10/clipboard.min.js"></script>
+        <script src="https://unpkg.com/htmx.org@2.0.4"></script>
         <style type="text/css">
         dl {
             display: flex;
@@ -310,26 +311,13 @@
                         {% endblock %}
 
                         {% if now_playing_list and user.is_authenticated %}
-                        <ul>
-                            <b>Now playing</b>
-                            {% for scrobble in now_playing_list %}
-                            <div class="now-playing">
-                                {% if scrobble.media_obj.primary_image_url %}<div style="float:left;padding-right:10px;padding-bottom:10px;"><img src="{{scrobble.media_obj.primary_image_url}}" /></div>{% endif %}
-                                <p><a href="{{scrobble.get_absolute_url}}">{{scrobble.media_obj}}</a></p>
-                                {% if scrobble.logdata %}{% if scrobble.logdata.title%}<p><em>{{scrobble.logdata.title}}</em></p>{% endif %}{% endif %}
-                                <p><small>{{scrobble.local_timestamp|naturaltime}} from {{scrobble.source}}</small></p>
-                                <div class="progress-bar" style="margin-right:5px;">
-                                    <span class="progress-bar-fill" style="width: {{scrobble.percent_played}}%;"></span>
-                                </div>
-                                <p class="action-buttons">
-                                    <a href="{% url "scrobbles:cancel" scrobble.id %}">Cancel</a>
-                                    <a class="right" href="{% url "scrobbles:finish" scrobble.id %}">Finish</a>
-                                </p>
-                                {% if not forloop.last %}<hr/>{% endif %}
-                            </div>
-                            {% endfor %}
-                        </ul>
-                        {% if now_playing_list|length > 1 %}<hr/>{% endif %}
+                        {% if user.profile.live_now_playing %}
+                        <div id="now-playing-container" hx-get="{% url 'scrobbles:now-playing-partial' %}" hx-trigger="every 7s" hx-swap="innerHTML">
+                            {% include "scrobbles/_now_playing.html" %}
+                        </div>
+                        {% else %}
+                        {% include "scrobbles/_now_playing.html" %}
+                        {% endif %}
                         {% endif %}
 
                         {% if active_imports %}

vrobbler/templates/discgolf/discgolfcourse_detail.html

@@ -0,0 +1,101 @@
+{% extends "base_list.html" %}
+{% load static %}
+
+{% block title %}{{object.title}}{% endblock %}
+
+{% block head_extra %}
+<link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
+<style>
+    #map {
+        height: 400px;
+    }
+</style>
+{% endblock %}
+
+{% block lists %}
+{% if object.description %}
+<div class="row">
+    <div class="col-md">
+        <p>{{object.description}}</p>
+    </div>
+</div>
+{% endif %}
+{% if trail_gpx_url %}
+<div class="row">
+    <div class="col-md mb-3">
+        <div id="map"></div>
+    </div>
+</div>
+{% endif %}
+<div class="row">
+    <div class="col-md">
+        {% if object.trail.trailhead_location.display_address %}
+        <p>{{ object.trail.trailhead_location.display_address }}</p>
+        {% endif %}
+        {% if object.pdga_link or object.udisc_link %}
+        <p>
+            {% if object.pdga_link %}
+            <a href="{{ object.pdga_link }}" target="_blank">PDGA</a>
+            {% endif %}
+            {% if object.udisc_link %}
+            <a href="{{ object.udisc_link }}" target="_blank">uDisc</a>
+            {% endif %}
+        </p>
+        {% endif %}
+    </div>
+</div>
+{% if charts %}
+<div class="row">
+    <div class="col-md">
+        {% include "scrobbles/_chart_links.html" %}
+    </div>
+</div>
+{% endif %}
+<div class="row">
+    <div class="col-md">
+        <h3>Last scrobbles</h3>
+        <div class="table-responsive">
+            <table class="table table-striped table-sm">
+            <thead>
+                <tr>
+                    <th scope="col">Date</th>
+                    <th scope="col">Notes</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for scrobble in scrobbles.all %}
+                <tr>
+                    <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
+                    <td>{{scrobble.logdata.notes_as_str}}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+            </table>
+        </div>
+    </div>
+</div>
+{% endblock %}
+
+{% block extra_js %}
+{{ block.super }}
+{% if trail_gpx_url %}
+<script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/leaflet-gpx@2.2.0/gpx.min.js"></script>
+<script>
+var map = L.map('map');
+L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
+    maxZoom: 19,
+    attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>',
+    referrerPolicy: 'origin'
+}).addTo(map);
+var gpx = new L.GPX("{{ trail_gpx_url|escapejs }}", {
+    async: true,
+    polyline_options: { color: '#e74c3c' }
+});
+gpx.on('loaded', function(e) {
+    map.fitBounds(e.target.getBounds());
+});
+gpx.addTo(map);
+</script>
+{% endif %}
+{% endblock %}

vrobbler/templates/discgolf/discgolfcourse_list.html

@@ -0,0 +1,13 @@
+{% extends "base_list.html" %}
+
+{% block title %}Disc Golf Rounds{% endblock %}
+
+{% block lists %}
+<div class="row">
+    <div class="col-md">
+        <div class="table-responsive">
+            {% include "_scrobblable_list.html" %}
+        </div>
+    </div>
+</div>
+{% endblock %}

vrobbler/templates/scrobbles/_last_scrobbles.html

@@ -81,6 +81,15 @@
         <p>No trails hiked today</p>
         {% endif %}
 
+        <h3><a href="{% url 'discgolf:course_list' %}">Disc Golf</a></h3>
+        {% if DiscGolfCourse %}
+        {% with scrobbles=DiscGolfCourse count=DiscGolfCourse_count time=DiscGolfCourse_time %}
+        {% include "scrobbles/_scrobble_table.html" %}
+        {% endwith %}
+        {% else %}
+        <p>No courses played today</p>
+        {% endif %}
+
     </div>
     <div class="col-md">
 

vrobbler/templates/scrobbles/_now_playing.html

@@ -0,0 +1,21 @@
+{% load humanize %}
+<ul>
+    <b>Now playing</b>
+    {% for scrobble in now_playing_list %}
+    <div class="now-playing">
+        {% if scrobble.media_obj.primary_image_url %}<div style="float:left;padding-right:10px;padding-bottom:10px;"><img src="{{scrobble.media_obj.primary_image_url}}" /></div>{% endif %}
+        <p><a href="{{scrobble.get_absolute_url}}">{{scrobble.media_obj}}</a></p>
+        {% if scrobble.logdata %}{% if scrobble.logdata.title%}<p><em>{{scrobble.logdata.title}}</em></p>{% endif %}{% endif %}
+        <p><small>{{scrobble.local_timestamp|naturaltime}} from {{scrobble.source}}</small></p>
+        <div class="progress-bar" style="margin-right:5px;">
+            <span class="progress-bar-fill" style="width: {{scrobble.percent_played}}%;"></span>
+        </div>
+        <p class="action-buttons">
+            <a href="{% url "scrobbles:cancel" scrobble.id %}">Cancel</a>
+            <a class="right" href="{% url "scrobbles:finish" scrobble.id %}">Finish</a>
+        </p>
+        {% if not forloop.last %}<hr/>{% endif %}
+    </div>
+    {% endfor %}
+</ul>
+{% if now_playing_list|length > 1 %}<hr/>{% endif %}

vrobbler/templates/scrobbles/_scrobble_all_content.html

@@ -0,0 +1,146 @@
+{% load humanize %}
+{% load naturalduration %}
+<main class="col-md-9 ms-sm-auto col-lg-10 px-md-4" hx-get="{% url 'scrobbles:scrobble-list' %}{% if request.META.QUERY_STRING %}?{{ request.META.QUERY_STRING }}{% endif %}" hx-trigger="every 7s" hx-swap="outerHTML">
+    <div class="d-flex justify-content-between flex-wrap flex-md-nowrap align-items-center pt-3 pb-2 mb-3 border-bottom">
+        <div>
+            <h1 class="h2">All Scrobbles</h1>
+            {% if tag_list %}
+            <h6 class="text-muted">Tagged {{ tag_list|join:", " }}</h6>
+            {% if total_time_seconds %}
+            <p class="text-muted small mb-0">Total time: {{ total_time_seconds|natural_duration }}</p>
+            {% endif %}
+            {% endif %}
+            {% if request.GET.visibility %}
+            <h6 class="text-muted">Filter: {{ request.GET.visibility|title }} scrobbles only</h6>
+            {% endif %}
+        </div>
+    </div>
+
+    <div class="table-responsive">
+        <table class="table table-striped table-sm">
+            <thead>
+                <tr>
+                    <th scope="col">Date</th>
+                    <th scope="col">Type</th>
+                    <th scope="col">Title</th>
+                    <th scope="col">Time</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for scrobble in object_list %}
+                <tr class="{% if scrobble.id in overlap_map %}{{ overlap_map.scrobble.id }}{% endif %}">
+                    <td>
+                        {% if scrobble.id in overlap_map %}⏱ {% endif %}
+                        <a href="{{scrobble.get_absolute_url}}">{{ scrobble.timestamp|naturaltime }}</a>
+                    </td>
+                    <td>
+                        {% if scrobble.video %}
+                        🎬 Video
+                        {% elif scrobble.track %}
+                        🎵 Track
+                        {% elif scrobble.podcast_episode %}
+                        🎙️ Podcast episode
+                        {% elif scrobble.sport_event %}
+                        ⚽ Sport event
+                        {% elif scrobble.book %}
+                        📖 Book
+                        {% elif scrobble.paper %}
+                        📄 Paper
+                        {% elif scrobble.video_game %}
+                        🎮 Video game
+                        {% elif scrobble.board_game %}
+                        🎲 Board game
+                        {% elif scrobble.geo_location %}
+                        📍 GeoLocation
+                        {% elif scrobble.trail %}
+                        🥾 Trail
+                        {% elif scrobble.beer %}
+                        🍺 Beer
+                        {% elif scrobble.puzzle %}
+                        🧩 Puzzle
+                        {% elif scrobble.food %}
+                        🍔 Food
+                        {% elif scrobble.task %}
+                        ✅ Task
+                        {% elif scrobble.web_page %}
+                        🌐 Web Page
+                        {% elif scrobble.life_event %}
+                        🎉 Life event
+                        {% elif scrobble.mood %}
+                        😊 Mood
+                        {% elif scrobble.brick_set %}
+                        🧱 Brick set
+                        {% elif scrobble.channel %}
+                        📺 Channel
+                        {% else %}
+                        Unknown
+                        {% endif %}
+                    </td>
+                    <td>
+                        {% if scrobble.video %}
+                        <a href="{% url 'videos:video_detail' scrobble.video.uuid %}">{{ scrobble.video.title }}</a>
+                        {% elif scrobble.track %}
+                        <a href="{% url 'music:track_detail' scrobble.track.uuid %}">{{ scrobble.track.title }}</a>
+                        {% elif scrobble.video_game %}
+                        <a href="{% url 'videogames:videogame_detail' scrobble.video_game.uuid %}">{{ scrobble.video_game.title }}</a>
+                        {% elif scrobble.book %}
+                        <a href="{% url 'books:book_detail' scrobble.book.uuid %}">{{ scrobble.book.title }}</a>
+                        {% elif scrobble.food %}
+                        <a href="{% url 'foods:food_detail' scrobble.food.uuid %}">{{ scrobble.food.title }}</a>
+                        {% elif scrobble.beer %}
+                        <a href="{% url 'beers:beer_detail' scrobble.beer.uuid %}">{{ scrobble.beer.title }}</a>
+                        {% elif scrobble.web_page %}
+                        <a href="{% url 'webpages:webpage_detail' scrobble.web_page.uuid %}">{{ scrobble.web_page.title }}</a>
+                        {% elif scrobble.podcast_episode %}
+                        <a href="{% url 'podcasts:podcast_detail' scrobble.podcast_episode.podcast.id %}">{{ scrobble.podcast_episode.title }}</a>
+                        {% elif scrobble.board_game %}
+                        <a href="{% url 'boardgames:boardgame_detail' scrobble.board_game.uuid %}">{{ scrobble.board_game.title }}</a>
+                        {% elif scrobble.trail %}
+                        <a href="{% url 'trails:trail_detail' scrobble.trail.uuid %}">{{ scrobble.trail.title }}</a>
+                        {% elif scrobble.puzzle %}
+                        <a href="{% url 'puzzles:puzzle_detail' scrobble.puzzle.uuid %}">{{ scrobble.puzzle.title }}</a>
+                        {% elif scrobble.brick_set %}
+                        <a href="{% url 'bricksets:brickset_detail' scrobble.brick_set.uuid %}">{{ scrobble.brick_set.title }}</a>
+                        {% elif scrobble.task %}
+                        <a href="{% url 'tasks:task_detail' scrobble.task.uuid %}">{{scrobble.media_obj}}{% if scrobble.log.title  %} - {{ scrobble.log.title }}{% endif %}</a>
+                        {% elif scrobble.life_event %}
+                        <a href="{% url 'lifeevents:lifeevent_detail' scrobble.life_event.uuid %}">{{ scrobble.life_event.title }}</a>
+                        {% elif scrobble.mood %}
+                        <a href="{% url 'moods:mood_detail' scrobble.mood.uuid %}">{{ scrobble.mood.title}}</a>
+                        {% elif scrobble.geo_location %}
+                        <a href="{% url 'locations:geolocation_detail' scrobble.geo_location.uuid %}">{{ scrobble.geo_location.title }}</a>
+                        {% else %}
+                        Unknown
+                        {% endif %}
+                    </td>
+                    <td>
+                        {% if scrobble.in_progress and not scrobble.played_to_completion %}
+                        In progress ...
+                        {% elif scrobble.playback_position_seconds %}
+                        {{ scrobble.playback_position_seconds|natural_duration }}
+                        {% endif %}
+                    </td>
+                </tr>
+                {% empty %}
+                <tr>
+                    <td colspan="4">No scrobbles found.</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+
+    {% if page_obj.has_previous or page_obj.has_next %}
+    <nav>
+        <ul class="pagination">
+            {% if page_obj.has_previous %}
+            <li class="page-item"><a class="page-link" href="?page={{ page_obj.previous_page_number }}{% if tags_param %}&tags={{ tags_param }}{% endif %}">Previous</a></li>
+            {% endif %}
+            <li class="page-item"><span class="page-link">Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}</span></li>
+            {% if page_obj.has_next %}
+            <li class="page-item"><a class="page-link" href="?page={{ page_obj.next_page_number }}{% if tags_param %}&tags={{ tags_param }}{% endif %}">Next</a></li>
+            {% endif %}
+        </ul>
+    </nav>
+    {% endif %}
+</main>

vrobbler/templates/scrobbles/scrobble_all_list.html

@@ -1,148 +1,4 @@
 {% extends "base.html" %}
-{% load humanize %}
-{% load naturalduration %}
-
 {% block content %}
-<main class="col-md-9 ms-sm-auto col-lg-10 px-md-4">
-    <div class="d-flex justify-content-between flex-wrap flex-md-nowrap align-items-center pt-3 pb-2 mb-3 border-bottom">
-        <div>
-            <h1 class="h2">All Scrobbles</h1>
-            {% if tag_list %}
-            <h6 class="text-muted">Tagged {{ tag_list|join:", " }}</h6>
-            {% if total_time_seconds %}
-            <p class="text-muted small mb-0">Total time: {{ total_time_seconds|natural_duration }}</p>
-            {% endif %}
-            {% endif %}
-            {% if request.GET.visibility %}
-            <h6 class="text-muted">Filter: {{ request.GET.visibility|title }} scrobbles only</h6>
-            {% endif %}
-        </div>
-    </div>
-
-    <div class="table-responsive">
-        <table class="table table-striped table-sm">
-            <thead>
-                <tr>
-                    <th scope="col">Date</th>
-                    <th scope="col">Type</th>
-                    <th scope="col">Title</th>
-                    <th scope="col">Time</th>
-                </tr>
-            </thead>
-            <tbody>
-                {% for scrobble in object_list %}
-                <tr class="{% if scrobble.id in overlap_map %}{{ overlap_map.scrobble.id }}{% endif %}">
-                    <td>
-                        {% if scrobble.id in overlap_map %}⏱ {% endif %}
-                        <a href="{{scrobble.get_absolute_url}}">{{ scrobble.timestamp|naturaltime }}</a>
-                    </td>
-                    <td>
-                        {% if scrobble.video %}
-                        🎬 Video
-                        {% elif scrobble.track %}
-                        🎵 Track
-                        {% elif scrobble.podcast_episode %}
-                        🎙️ Podcast episode
-                        {% elif scrobble.sport_event %}
-                        ⚽ Sport event
-                        {% elif scrobble.book %}
-                        📖 Book
-                        {% elif scrobble.paper %}
-                        📄 Paper
-                        {% elif scrobble.video_game %}
-                        🎮 Video game
-                        {% elif scrobble.board_game %}
-                        🎲 Board game
-                        {% elif scrobble.geo_location %}
-                        📍 GeoLocation
-                        {% elif scrobble.trail %}
-                        🥾 Trail
-                        {% elif scrobble.beer %}
-                        🍺 Beer
-                        {% elif scrobble.puzzle %}
-                        🧩 Puzzle
-                        {% elif scrobble.food %}
-                        🍔 Food
-                        {% elif scrobble.task %}
-                        ✅ Task
-                        {% elif scrobble.web_page %}
-                        🌐 Web Page
-                        {% elif scrobble.life_event %}
-                        🎉 Life event
-                        {% elif scrobble.mood %}
-                        😊 Mood
-                        {% elif scrobble.brick_set %}
-                        🧱 Brick set
-                        {% elif scrobble.channel %}
-                        📺 Channel
-                        {% else %}
-                        Unknown
-                        {% endif %}
-                    </td>
-                    <td>
-                        {% if scrobble.video %}
-                        <a href="{% url 'videos:video_detail' scrobble.video.uuid %}">{{ scrobble.video.title }}</a>
-                        {% elif scrobble.track %}
-                        <a href="{% url 'music:track_detail' scrobble.track.uuid %}">{{ scrobble.track.title }}</a>
-                        {% elif scrobble.video_game %}
-                        <a href="{% url 'videogames:videogame_detail' scrobble.video_game.uuid %}">{{ scrobble.video_game.title }}</a>
-                        {% elif scrobble.book %}
-                        <a href="{% url 'books:book_detail' scrobble.book.uuid %}">{{ scrobble.book.title }}</a>
-                        {% elif scrobble.food %}
-                        <a href="{% url 'foods:food_detail' scrobble.food.uuid %}">{{ scrobble.food.title }}</a>
-                        {% elif scrobble.beer %}
-                        <a href="{% url 'beers:beer_detail' scrobble.beer.uuid %}">{{ scrobble.beer.title }}</a>
-                        {% elif scrobble.web_page %}
-                        <a href="{% url 'webpages:webpage_detail' scrobble.web_page.uuid %}">{{ scrobble.web_page.title }}</a>
-                        {% elif scrobble.podcast_episode %}
-                        <a href="{% url 'podcasts:podcast_detail' scrobble.podcast_episode.podcast.id %}">{{ scrobble.podcast_episode.title }}</a>
-                        {% elif scrobble.board_game %}
-                        <a href="{% url 'boardgames:boardgame_detail' scrobble.board_game.uuid %}">{{ scrobble.board_game.title }}</a>
-                        {% elif scrobble.trail %}
-                        <a href="{% url 'trails:trail_detail' scrobble.trail.uuid %}">{{ scrobble.trail.title }}</a>
-                        {% elif scrobble.puzzle %}
-                        <a href="{% url 'puzzles:puzzle_detail' scrobble.puzzle.uuid %}">{{ scrobble.puzzle.title }}</a>
-                        {% elif scrobble.brick_set %}
-                        <a href="{% url 'bricksets:brickset_detail' scrobble.brick_set.uuid %}">{{ scrobble.brick_set.title }}</a>
-                        {% elif scrobble.task %}
-                        <a href="{% url 'tasks:task_detail' scrobble.task.uuid %}">{{scrobble.media_obj}}{% if scrobble.log.title  %} - {{ scrobble.log.title }}{% endif %}</a>
-                        {% elif scrobble.life_event %}
-                        <a href="{% url 'lifeevents:lifeevent_detail' scrobble.life_event.uuid %}">{{ scrobble.life_event.title }}</a>
-                        {% elif scrobble.mood %}
-                        <a href="{% url 'moods:mood_detail' scrobble.mood.uuid %}">{{ scrobble.mood.title}}</a>
-                        {% elif scrobble.geo_location %}
-                        <a href="{% url 'locations:geolocation_detail' scrobble.geo_location.uuid %}">{{ scrobble.geo_location.title }}</a>
-                        {% else %}
-                        Unknown
-                        {% endif %}
-                    </td>
-                    <td>
-                        {% if scrobble.playback_position_seconds %}
-                        {{ scrobble.playback_position_seconds|natural_duration }}
-                        {% endif %}
-                    </td>
-                </tr>
-                {% empty %}
-                <tr>
-                    <td colspan="4">No scrobbles found.</td>
-                </tr>
-                {% endfor %}
-            </tbody>
-        </table>
-    </div>
-
-    {% if page_obj.has_previous or page_obj.has_next %}
-    <nav>
-        <ul class="pagination">
-            {% if page_obj.has_previous %}
-            <li class="page-item"><a class="page-link" href="?page={{ page_obj.previous_page_number }}{% if tags_param %}&tags={{ tags_param }}{% endif %}">Previous</a></li>
-            {% endif %}
-            <li class="page-item"><span class="page-link">Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}</span></li>
-            {% if page_obj.has_next %}
-            <li class="page-item"><a class="page-link" href="?page={{ page_obj.next_page_number }}{% if tags_param %}&tags={{ tags_param }}{% endif %}">Next</a></li>
-            {% endif %}
-        </ul>
-    </nav>
-    {% endif %}
-</main>
+{% include "scrobbles/_scrobble_all_content.html" %}
 {% endblock %}

vrobbler/templates/scrobbles/scrobble_list.html

@@ -73,24 +73,19 @@
             <div class="btn-group me-2">
               <a href="{% url 'charts:charts-home' %}" class="btn btn-sm btn-outline-secondary">Charts</a>
             </div>
+            <div class="btn-group me-2">
+              <a href="{% url 'scrobbles:scrobble-list' %}" class="btn btn-sm btn-outline-secondary">Live</a>
+            </div>
+            <div class="btn-group me-2">
+              <a href="{% url 'trends:trends-home' %}" class="btn btn-sm btn-outline-secondary">Trends</a>
+            </div>
             <div class="btn-group me-2">
                 {% if user.profile.lastfm_username and not user.profile.lastfm_auto_import %}
                 <form action="{% url 'scrobbles:lastfm-import' %}" method="get">
                     <button type="submit" class="btn btn-sm btn-outline-secondary">Last.fm Sync</button>
                 </form>
                 {% endif %}
-                {% if prev_link %}
-                <a type="button" class="btn btn-sm btn-outline-secondary" href="{{prev_link}}"
-                    data-bs-target="#">Previous</a>
-                {% endif %}
-                {% if today_link %}
-                <a type="button" class="btn btn-sm btn-outline-secondary" href="{{today_link}}"
-                    data-bs-target="#">Today</a>
-                {% endif %}
-                {% if next_link %}
-                <a type="button" class="btn btn-sm btn-outline-secondary" href="{{next_link}}"
-                    data-bs-target="#">Next</a>
-                {% endif %}
+
             </div>
             <div class="btn-group me-2">
                 {% if user.profile.lastfm_username and not user.profile.lastfm_auto_import %}
@@ -105,19 +100,6 @@
                     data-bs-target="#exportModal">Export</button>
             </div>
             {% endif %}
-            <div class="dropdown">
-                <button type="button" class="btn btn-sm btn-outline-secondary dropdown-toggle" id="graphDateButton"
-                    data-bs-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
-                    <div data-feather="calendar"></div>
-                    {{title}}
-                </button>
-                <div class="dropdown-menu" data-bs-toggle="#graphDataChange" aria-labelledby="graphDateButton">
-                    <a class="dropdown-item" href="?date=today">Today</a>
-                    <a class="dropdown-item" href="?date=this_week">This week</a>
-                    <a class="dropdown-item" href="?date=this_month">This month</a>
-                    <a class="dropdown-item" href="?date=this_year">This year</a>
-                </div>
-            </div>
         </div>
     </div>
 

vrobbler/urls.py

@@ -7,6 +7,9 @@ from rest_framework import routers
 
 import vrobbler.apps.scrobbles.views as scrobbles_views
 
+from vrobbler.apps.discgolf import urls as discgolf_urls
+from vrobbler.apps.discgolf.api.views import DiscGolfCourseViewSet
+
 from vrobbler.apps.boardgames import urls as boardgame_urls
 from vrobbler.apps.boardgames.api.views import (
     BoardGameViewSet,
@@ -153,7 +156,7 @@ router.register(r"lifeevents", LifeEventViewSet)
 
 router.register(r"birds", BirdViewSet)
 router.register(r"birding-locations", BirdingLocationViewSet)
-
+router.register(r"disc-golf-courses", DiscGolfCourseViewSet)
 urlpatterns = [
     path("api/v1/", include(router.urls)),
     path("api/v1/auth", include("rest_framework.urls")),
@@ -171,6 +174,7 @@ urlpatterns = [
     path("", include(locations_urls, namespace="locations")),
     path("", include(trails_urls, namespace="trails")),
     path("", include(beers_urls, namespace="beers")),
+    path("", include(discgolf_urls, namespace="discgolf")),
     path("", include(foods_urls, namespace="foods")),
     path("", include(puzzles_urls, namespace="puzzles")),
     path("", include(tasks_urls, namespace="tasks")),
@@ -184,6 +188,7 @@ urlpatterns = [
     path("", include(people_urls, namespace="people")),
     path("", include(charts_urls, namespace="charts")),
     path("", include(trends_urls, namespace="trends")),
+    path("", include("mcp_server.urls")),
     path("", scrobbles_views.RecentScrobbleList.as_view(), name="vrobbler-home"),
 ]
 if settings.DEBUG: