Bump version to 0.11.9

Fix bad image templates
Bump version to 0.11.8
2023-03-03 02:41:47 -05:00 · 2023-03-03 02:41:27 -05:00 · 2023-03-03 02:32:55 -05:00 · 2023-03-03 02:32:32 -05:00 · 2023-03-03 02:29:56 -05:00 · 2023-03-03 02:29:32 -05:00
169 changed files with 10658 additions and 911 deletions
--- a/.coveragerc
+++ b/.coveragerc
@ -0,0 +1,7 @@
+[run]
+omit=
+  vrobbler/wsgi.py
+  vrobbler/asgi.py
+  vrobbler/cli.py
+  *admin.py
+  migrations/*
--- a/.drone.yml
+++ b/.drone.yml
@ -8,15 +8,15 @@ name: run_tests

 steps:
  # Run tests against Python/Flask engine backend (with pytest)
-  - name: django_tests
+  - name: pytest with coverage
    image: python:3.10.4
    commands:
      # Install dependencies
-      - cp vrobbler.conf.example vrobbler.conf
+      - cp vrobbler.conf.test vrobbler.conf
      - pip install poetry
      - poetry install
      # Start with a fresh database (which is already running as a service from Drone)
-      - poetry run python manage.py test
+      - poetry run pytest --cov-report term:skip-covered --cov=vrobbler tests
    environment:
      VROBBLER_DATABASE_URL: sqlite:///test.db
    volumes:
--- a/.gitignore
+++ b/.gitignore
@ -1,4 +1,5 @@
 db.sqlite3
 vrobbler.conf
-/media/
-/dist/
+media/
+dist/
+.coverage
--- a/2
+++ b/2
@ -0,0 +1,2 @@
+web: python manage.py runserver 0.0.0.0:8014
+worker: celery -A vrobbler worker -l DEBUG
--- a/README.org
+++ b/README.org
@ -1,4 +1,7 @@
-#+title: Readme
+Vrobbler
+========
+
+[![Build Status](https://ci.unbl.ink/api/badges/secstate/vrobbler/status.svg?ref=refs/heads/main)](https://ci.unbl.ink/secstate/vrobbler)

 Vrobbler is a pretty simple Django-powered web app for scrobbling video plays from you favorite Jellyfin installation.

--- a/envrc.sample
+++ b/envrc.sample
@ -0,0 +1,4 @@
+export ENV_PATH=$(poetry env info --path)
+source "${ENV_PATH}/bin/activate"
+
+export PYPI_PASSWORD="$(pass personal/apikey/pypi)"
--- a/poetry.lock
+++ b/poetry.lock
--- a/pyproject.toml
+++ b/pyproject.toml
@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vrobbler"
-version = "0.2.0"
+version = "0.11.9"
 description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]

@ -16,7 +16,7 @@ djangorestframework = "^3.13.1"
 Markdown = "^3.3.6"
 django-filter = "^21.1"
 Pillow = "^9.0.1"
-psycopg2 = {version = "^2.9.3", extras = ["production"]}
+psycopg2 = "^2.9.3"
 dj-database-url = "^0.5.0"
 django-mathfilters = "^1.0.0"
 django-allauth = "^0.50.0"
@ -27,24 +27,40 @@ django-markdownify = "^0.9.1"
 gunicorn = "^20.1.0"
 django-simple-history = "^3.1.1"
 whitenoise = "^6.3.0"
+musicbrainzngs = "^0.7.1"
+cinemagoer = "^2022.12.27"
+pysportsdb = "^0.1.0"
+pytz = "^2022.7.1"
+django-redis = "^5.2.0"
+pylast = "^5.1.0"
+django-encrypted-field = "^1.0.5"
+celery = "^5.2.7"
+honcho = "^1.1.0"

 [tool.poetry.dev-dependencies]
 Werkzeug = "2.0.3"
 black = "^22.3"
-freezegun = "^1.2"
+coverage = "^7.0.5"
 mypy = "^0.961"
 pytest = "^7.1"
 pytest-black = "^0.3.12"
 pytest-cov = "^3.0"
+pytest-django = "^4.5.2"
 pytest-flake8 = "^1.1"
 pytest-isort = "^3.0"
 pytest-runner = "^6.0"
 pytest-selenium = "^2.0.1"
+time-machine = "^2.9.0"
 types-pytz = "^2022.1"
 types-requests = "^2.27"
-types-freezegun = "^1.1"
 bandit = "^1.7.4"

+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q"
+testpaths = ["tests"]
+DJANGO_SETTINGS_MODULE='vrobbler.settings'
+
 [tool.black]
 line-length = 79
 skip-string-normalization = true
--- a/templates/base.html
+++ b/templates/base.html
@ -1,25 +0,0 @@
-<!doctype html>
-<html class="no-js" lang="">
-    <head>
-        <meta charset="utf-8">
-        <meta http-equiv="x-ua-compatible" content="ie=edge">
-        <title>Untitled</title>
-        <meta name="description" content="">
-        <meta name="viewport" content="width=device-width, initial-scale=1">
-
-        <link rel="apple-touch-icon" href="/apple-touch-icon.png">
-        <!-- Place favicon.ico in the root directory -->
-
-    </head>
-    <body>
-        <!--[if lt IE 8]>
-            <p class="browserupgrade">
-            You are using an <strong>outdated</strong> browser. Please
-            <a href="http://browsehappy.com/">upgrade your browser</a> to improve
-            your experience.
-            </p>
-        <![endif]-->
-
-
-    </body>
-</html>
--- a/tests/scrobbles_tests/init.py
+++ b/tests/scrobbles_tests/init.py
--- a/tests/scrobbles_tests/initpy
+++ b/tests/scrobbles_tests/initpy
--- a/tests/scrobbles_tests/conftest.py
+++ b/tests/scrobbles_tests/conftest.py
@ -0,0 +1,84 @@
+import json
+import pytest
+
+from scrobbles.models import Scrobble
+from rest_framework.authtoken.models import Token
+from django.contrib.auth import get_user_model
+
+User = get_user_model()
+
+
+class MopidyRequest:
+    name = "Same in the End"
+    artist = "Sublime"
+    album = "Sublime"
+    track_number = 4
+    run_time_ticks = 156604
+    run_time = "156"
+    playback_time_ticks = 15045
+    musicbrainz_track_id = "54214d63-5adf-4909-87cd-c65c37a6d558"
+    musicbrainz_album_id = "03b864cd-7761-314c-a892-05a89ddff00d"
+    musicbrainz_artist_id = "95f5b748-d370-47fe-85bd-0af2dc450bc0"
+    mopidy_uri = "local:track:Sublime%20-%20Sublime/Disc%201%20-%2004%20-%20Same%20in%20the%20End.mp3"
+    status = "resumed"
+
+    def __init__(self, **kwargs):
+        self.request_data = {
+            "name": kwargs.get('name', self.name),
+            "artist": kwargs.get("artist", self.artist),
+            "album": kwargs.get("album", self.album),
+            "track_number": int(kwargs.get("track_number", self.track_number)),
+            "run_time_ticks": int(
+                kwargs.get("run_time_ticks", self.run_time_ticks)
+            ),
+            "run_time": int(kwargs.get("run_time", self.run_time)),
+            "playback_time_ticks": int(
+                kwargs.get("playback_time_ticks", self.playback_time_ticks)
+            ),
+            "musicbrainz_track_id": kwargs.get(
+                "musicbrainz_track_id", self.musicbrainz_track_id
+            ),
+            "musicbrainz_album_id": kwargs.get(
+                "musicbrainz_album_id", self.musicbrainz_album_id
+            ),
+            "musicbrainz_artist_id": kwargs.get(
+                "musicbrainz_artist_id", self.musicbrainz_artist_id
+            ),
+            "mopidy_uri": kwargs.get("mopidy_uri", self.mopidy_uri),
+            "status": kwargs.get("status", self.status),
+        }
+
+    def __eq__(self, other):
+        for key in self.request_data.keys():
+            if self.request_data[key] != getattr(self, key):
+                return False
+        return True
+
+    @property
+    def request_json(self):
+        return json.dumps(self.request_data)
+
+
+@pytest.fixture
+def valid_auth_token():
+    user = User.objects.create(email='test@exmaple.com')
+    return Token.objects.create(user=user).key
+
+
+@pytest.fixture
+def mopidy_track_request_data():
+    return MopidyRequest().request_json
+
+
+@pytest.fixture
+def mopidy_track_diff_album_request_data(**kwargs):
+    mb_album_id = "0c56c457-afe1-4679-baab-759ba8dd2a58"
+    return MopidyRequest(
+        album="Gold", musicbrainz_album_id=mb_album_id
+    ).request_json
+
+
+@pytest.fixture
+def mopidy_podcast_request_data():
+    mopidy_uri = "local:podcast:Up%20First/2022-01-01%20Up%20First.mp3"
+    return MopidyRequest(mopidy_uri=mopidy_uri).request_json
--- a/tests/scrobbles_tests/test_aggregators.py
+++ b/tests/scrobbles_tests/test_aggregators.py
@ -0,0 +1,102 @@
+from datetime import datetime, timedelta
+
+import pytest
+import time_machine
+from django.contrib.auth import get_user_model
+from django.urls import reverse
+from django.utils import timezone
+from music.aggregators import live_charts, scrobble_counts, week_of_scrobbles
+from profiles.models import UserProfile
+from scrobbles.models import Scrobble
+
+
+def build_scrobbles(client, request_data, num=7, spacing=2):
+    url = reverse('scrobbles:mopidy-webhook')
+    user = get_user_model().objects.create(username='Test User')
+    UserProfile.objects.create(user=user, timezone='US/Eastern')
+    for i in range(num):
+        client.post(url, request_data, content_type='application/json')
+        s = Scrobble.objects.last()
+        s.user = user
+        s.timestamp = timezone.now() - timedelta(days=i * spacing)
+        s.played_to_completion = True
+        s.save()
+
+
+@pytest.mark.django_db
+@time_machine.travel(datetime(2022, 3, 4, 1, 24))
+def test_scrobble_counts_data(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data)
+    user = get_user_model().objects.first()
+    count_dict = scrobble_counts(user)
+    assert count_dict == {
+        'alltime': 7,
+        'month': 2,
+        'today': 1,
+        'week': 3,
+        'year': 7,
+    }
+
+
+@pytest.mark.django_db
+def test_week_of_scrobbles_data(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    week = week_of_scrobbles(user)
+    assert list(week.values()) == [1, 1, 1, 1, 1, 1, 1]
+
+
+@pytest.mark.django_db
+def test_top_tracks_by_day(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = live_charts(user)
+    assert tops[0].title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_top_tracks_by_week(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = live_charts(user, chart_period='week')
+    assert tops[0].title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_top_tracks_by_month(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = live_charts(user, chart_period='month')
+    assert tops[0].title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_top_tracks_by_year(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = live_charts(user, chart_period='year')
+    assert tops[0].title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_top__artists_by_week(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = live_charts(user, chart_period='week', media_type="Artist")
+    assert tops[0].name == "Sublime"
+
+
+@pytest.mark.django_db
+def test_top__artists_by_month(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = live_charts(user, chart_period='month', media_type="Artist")
+    assert tops[0].name == "Sublime"
+
+
+@pytest.mark.django_db
+def test_top__artists_by_year(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = live_charts(user, chart_period='year', media_type="Artist")
+    assert tops[0].name == "Sublime"
--- a/tests/scrobbles_tests/test_imdb.py
+++ b/tests/scrobbles_tests/test_imdb.py
@ -0,0 +1,11 @@
+import pytest
+
+from vrobbler.apps.scrobbles.imdb import lookup_video_from_imdb
+
+
+@pytest.mark.skip(reason="Need to sort out third party API testing")
+def test_lookup_imdb_bad_id(caplog):
+    data = lookup_video_from_imdb('3409324')
+    assert data is None
+    assert caplog.records[0].levelname == "WARNING"
+    assert caplog.records[0].msg == "IMDB ID should begin with 'tt' 3409324"
--- a/tests/scrobbles_tests/test_views.py
+++ b/tests/scrobbles_tests/test_views.py
@ -0,0 +1,100 @@
+import json
+import pytest
+
+from django.urls import reverse
+
+from scrobbles.models import Scrobble
+from music.models import Track
+from podcasts.models import Episode
+
+
+@pytest.mark.django_db
+def test_get_not_allowed_from_mopidy(client, valid_auth_token):
+    url = reverse('scrobbles:mopidy-webhook')
+    headers = {'Authorization': f'Token {valid_auth_token}'}
+    response = client.get(url, headers=headers)
+    assert response.status_code == 405
+
+
+@pytest.mark.django_db
+def test_bad_mopidy_request_data(client, valid_auth_token):
+    url = reverse('scrobbles:mopidy-webhook')
+    headers = {'Authorization': f'Token {valid_auth_token}'}
+    response = client.post(url, headers)
+    assert response.status_code == 400
+    assert (
+        response.data['detail']
+        == 'JSON parse error - Expecting value: line 1 column 1 (char 0)'
+    )
+
+
+@pytest.mark.django_db
+def test_scrobble_mopidy_track(
+    client, mopidy_track_request_data, valid_auth_token
+):
+    url = reverse('scrobbles:mopidy-webhook')
+    headers = {'Authorization': f'Token {valid_auth_token}'}
+    response = client.post(
+        url,
+        mopidy_track_request_data,
+        content_type='application/json',
+        headers=headers,
+    )
+    assert response.status_code == 200
+    assert response.data == {'scrobble_id': 1}
+
+    scrobble = Scrobble.objects.get(id=1)
+    assert scrobble.media_obj.__class__ == Track
+    assert scrobble.media_obj.title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_scrobble_mopidy_same_track_different_album(
+    client,
+    mopidy_track_request_data,
+    mopidy_track_diff_album_request_data,
+    valid_auth_token,
+):
+    url = reverse('scrobbles:mopidy-webhook')
+    headers = {'Authorization': f'Token {valid_auth_token}'}
+    response = client.post(
+        url,
+        mopidy_track_request_data,
+        content_type='application/json',
+        headers=headers,
+    )
+    assert response.status_code == 200
+    assert response.data == {'scrobble_id': 1}
+    scrobble = Scrobble.objects.get(id=1)
+    assert scrobble.media_obj.album.name == "Sublime"
+
+    response = client.post(
+        url,
+        mopidy_track_diff_album_request_data,
+        content_type='application/json',
+    )
+
+    scrobble = Scrobble.objects.get(id=2)
+    assert scrobble.media_obj.__class__ == Track
+    assert scrobble.media_obj.album.name == "Gold"
+    assert scrobble.media_obj.title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_scrobble_mopidy_podcast(
+    client, mopidy_podcast_request_data, valid_auth_token
+):
+    url = reverse('scrobbles:mopidy-webhook')
+    headers = {'Authorization': f'Token {valid_auth_token}'}
+    response = client.post(
+        url,
+        mopidy_podcast_request_data,
+        content_type='application/json',
+        headers=headers,
+    )
+    assert response.status_code == 200
+    assert response.data == {'scrobble_id': 1}
+
+    scrobble = Scrobble.objects.get(id=1)
+    assert scrobble.media_obj.__class__ == Episode
+    assert scrobble.media_obj.title == "Up First"
--- a/todos.org
+++ b/todos.org
@ -0,0 +1,382 @@
+#+title: TODOs
+
+A fun way to keep track of things in the project to fix or improve.
+
+* DONE [#A] Fix fetching artwork without release group :bug:
+CLOSED: [2023-01-29 Sun 14:27]
+
+When we get artwork from Musicbrianz, and it's not found, we should check for
+release groups as well. This will stop issues with missing artwork because of
+obscure MB release matches.
+
+* DONE [#A] Fix Jellyfin music scrobbling N+1 past 90 completion percent :bug:
+CLOSED: [2023-01-30 Mon 18:31]
+:LOGBOOK:
+CLOCK: [2023-01-30 Mon 18:00]--[2023-01-30 Mon 18:31] =>  0:31
+:END:
+
+If we play music from Jellyfin and the track reaches 90% completion, the
+scrobbling goes crazy and starts creating new scrobbles with every update.
+
+The cause is pretty simple, but the solution is hard. We want to mark a scrobble
+as complete for the following conditions:
+
+- Play stopped and percent played beyond 90%
+- Play completely finished
+
+But if we keep listening beyond 90, we should basically ignore updates (or just
+update the existing scrobble)
+* DONE [#A] Add support for Audioscrobbler tab-separated file uploads :improvement:
+CLOSED: [2023-02-03 Fri 16:52]
+
+An example of the format:
+#+begin_src csv
+,
+#AUDIOSCROBBLER/1.1
+#TZ/UNKNOWN
+#CLIENT/Rockbox sansaclipplus $Revision$
+75 Dollar Bill	I Was Real	I Was Real	4	1015	S	1740494944	64ff5f53-d187-4512-827e-7606c69e66ff
+75 Dollar Bill	I Was Real	I Was Real	4	1015	S	1740494990	64ff5f53-d187-4512-827e-7606c69e66ff
+311	311	Down	1	173	S	1740495003	00476c23-fd9e-464b-9b27-a62d69f3d4f4
+311	311	Down	1	173	L	1740495049	00476c23-fd9e-464b-9b27-a62d69f3d4f4
+311	311	Down	1	173	L	1740495113	00476c23-fd9e-464b-9b27-a62d69f3d4f4
+311	311	Random	2	187	S	1740495190	530c09f3-46fe-4d90-b11f-7b63bcb4b373
+311	311	Random	2	187	L	1740495194	530c09f3-46fe-4d90-b11f-7b63bcb4b373
+311	311	Jackolantern’s Weather	3	204	L	1740495382	cc3b2dec-5d99-47ea-8930-20bf258be4ea
+311	311	All Mixed Up	4	182	L	1740495586	980a78b5-5bdd-4f50-9e3a-e13261e2817b
+311	311	Hive	5	179	L	1740495768	18f6dc98-d3a2-4f81-b967-97359d14c68c
+311	311	Guns (Are for Pussies)	6	137	L	1740495948	5e97ed9f-c8cc-4282-9cbe-f8e17aee5128
+311	311	Misdirected Hostility	7	179	S	1740496085	61ff2c1a-fc9c-44c3-8da1-5e50a44245af
+,
+#+end_src
+* DONE [#B] Allow scrobbling music without MB IDs by grabbing them before scrobble :improvement:
+CLOSED: [2023-02-17 Fri 00:10]
+
+This would allow a few nice flows. One, you'd be able to record the play of an
+entire album by just dropping the muscibrainz_id in. This could be helpful for
+offline listening. It would also mean bad metadata from mopidy would not break
+scrobbling.
+* DONE When updating musicbrainz IDs, clear and run fetch artwrok :improvement:
+CLOSED: [2023-02-17 Fri 00:11]
+* TODO [#A] Add ability to manually scrobble albums or tracks from MB :improvement:
+
+Given a UUID from musicbrainz, we should be able to scrobble an album or
+individual track.
+
+* TODO [#A] Add django-storage to store files on S3 :improvement:
+* TODO [#B] Adjust cancel/finish task to use javascript to submit :improvement:
+* TODO [#B] Implement a detail view for TV shows :improvement:
+* TODO [#B] Implement a detail view for Moviews :improvement:
+* TODO [#C] Implement keeping track of week/month/year chart-toppers :improvement:
+:LOGBOOK:
+CLOCK: [2023-01-30 Mon 16:30]--[2023-01-30 Mon 18:00] =>  1:30
+:END:
+
+Maloja does this cool thing where artists and tracks get recorded as the top
+track of a given week, month or year. They get gold, silver or bronze stars for
+their place in the time period.
+
+I could see this being implemented as a separate Chart table which gets
+populated at the end of a time period and has a start and end date that defines
+a period, along with a one, two, three instance.
+
+Of course, it could also be a data model without a table, where it runs some fun
+calculations, stores it's values in Redis as a long-term lookup table and just
+has to re-populate when the server restarts.
+* TODO [#C] Move to using more robust mopidy-webhooks pacakge form pypi :improvement:
+** Example payloads from mopidy-webhooks
+*** Podcast playback ended
+#+begin_src json
+{
+    "type": "event",
+    "event": "track_playback_ended",
+    "data": {
+        "tl_track": {
+            "__model__": "TlTrack",
+            "tlid": 13,
+            "track": {
+                "__model__": "Track",
+                "uri": "file:///var/lib/mopidy/media/podcasts/The%20Prince/2022-09-28-Wolf-warriors.mp3",
+                "name": "Wolf warriors",
+                "artists": [
+                    {
+                        "__model__": "Artist",
+                        "name": "The Economist"
+                    }
+                ],
+                "album": {
+                    "__model__": "Album",
+                    "name": "The Prince",
+                    "date": "2022"
+                },
+                "genre": "Blues",
+                "date": "2022",
+                "length": 2437778,
+                "bitrate": 127988
+            }
+        },
+        "time_position": 3290
+    }
+}
+#+end_src
+*** Podcast playback state changes
+#+begin_src json
+{
+    "type": "event",
+    "event": "playback_state_changed",
+    "data": {
+        "old_state": "paused",
+        "new_state": "playing"
+    }
+}
+#+end_src
+
+#+begin_src json
+{
+    "type": "event",
+    "event": "playback_state_changed",
+    "data": {
+        "old_state": "stopped",
+        "new_state": "playing"
+    }
+}
+#+end_src
+*** Podcast playback started
+#+begin_src json
+{
+    "type": "event",
+    "event": "track_playback_started",
+    "data": {
+        "tl_track": {
+            "__model__": "TlTrack",
+            "tlid": 13,
+            "track": {
+                "__model__": "Track",
+                "uri": "file:///var/lib/mopidy/media/podcasts/The%20Prince/2022-09-28-Wolf-warriors.mp3",
+                "name": "Wolf warriors",
+                "artists": [
+                    {
+                        "__model__": "Artist",
+                        "name": "The Economist"
+                    }
+                ],
+                "album": {
+                    "__model__": "Album",
+                    "name": "The Prince",
+                    "date": "2022"
+                },
+                "genre": "Blues",
+                "date": "2022",
+                "length": 2437778,
+                "bitrate": 127988
+            }
+        }
+    }
+}
+#+end_src
+*** Podcast playback paused
+#+begin_src  json
+{
+    "type": "status",
+    "data": {
+        "state": "paused",
+        "current_track": {
+            "__model__": "Track",
+            "uri": "file:///var/lib/mopidy/media/podcasts/The%20Prince/2022-09-28-Wolf-warriors.mp3",
+            "name": "Wolf warriors",
+            "artists": [
+                {
+                    "__model__": "Artist",
+                    "name": "The Economist"
+                }
+            ],
+            "album": {
+                "__model__": "Album",
+                "name": "The Prince",
+                "date": "2022"
+            },
+            "genre": "Blues",
+            "date": "2022",
+            "length": 2437778,
+            "bitrate": 127988
+        },
+        "time_position": 2350
+    }
+}
+
+#+end_src
+*** Track playback started
+#+begin_src json
+{
+    "type": "event",
+    "event": "track_playback_started",
+    "data": {
+        "tl_track": {
+            "__model__": "TlTrack",
+            "tlid": 14,
+            "track": {
+                "__model__": "Track",
+                "uri": "local:track:Various%20Artists%20-%202008%20-%20Twilight%20OST/01-muse-supermassive_black_hole.mp3",
+                "name": "Supermassive Black Hole",
+                "artists": [
+                    {
+                        "__model__": "Artist",
+                        "uri": "local:artist:md5:250dd6551b66a58a6b4897aa697f200c",
+                        "name": "Muse",
+                        "musicbrainz_id": "9c9f1380-2516-4fc9-a3e6-f9f61941d090"
+                    }
+                ],
+                "album": {
+                    "__model__": "Album",
+                    "uri": "local:album:md5:455343d54cdd89cb5a3b5ad537ea99d0",
+                    "name": "Twilight: Original Motion Picture Soundtrack",
+                    "artists": [
+                        {
+                            "__model__": "Artist",
+                            "uri": "local:artist:md5:54e4db2d5624f80b0cc290346e696756",
+                            "name": "Various Artists",
+                            "musicbrainz_id": "89ad4ac3-39f7-470e-963a-56509c546377"
+                        }
+                    ],
+                    "num_tracks": 12,
+                    "num_discs": 1,
+                    "date": "2008-11-04",
+                    "musicbrainz_id": "b4889eaf-d9f4-434c-a68d-69227b12b6a4"
+                },
+                "composers": [
+                    {
+                        "__model__": "Artist",
+                        "uri": "local:artist:md5:4d49cbca0b347e0a89047bb019d2779d",
+                        "name": "Matt Bellamy"
+                    }
+                ],
+                "genre": "Rock",
+                "track_no": 1,
+                "disc_no": 1,
+                "date": "2008-11-04",
+                "length": 211121,
+                "musicbrainz_id": "ff1e3e1a-f6e8-4692-b426-355880383bb6",
+                "last_modified": 1672712949510
+            }
+        }
+    }
+}
+#+end_src
+*** Track playback in progress
+#+begin_src json
+{
+    "type": "status",
+    "data": {
+        "state": "playing",
+        "current_track": {
+            "__model__": "Track",
+            "uri": "local:track:Various%20Artists%20-%202008%20-%20Twilight%20OST/01-muse-supermassive_black_hole.mp3",
+            "name": "Supermassive Black Hole",
+            "artists": [
+                {
+                    "__model__": "Artist",
+                    "uri": "local:artist:md5:250dd6551b66a58a6b4897aa697f200c",
+                    "name": "Muse",
+                    "musicbrainz_id": "9c9f1380-2516-4fc9-a3e6-f9f61941d090"
+                }
+            ],
+            "album": {
+                "__model__": "Album",
+                "uri": "local:album:md5:455343d54cdd89cb5a3b5ad537ea99d0",
+                "name": "Twilight: Original Motion Picture Soundtrack",
+                "artists": [
+                    {
+                        "__model__": "Artist",
+                        "uri": "local:artist:md5:54e4db2d5624f80b0cc290346e696756",
+                        "name": "Various Artists",
+                        "musicbrainz_id": "89ad4ac3-39f7-470e-963a-56509c546377"
+                    }
+                ],
+                "num_tracks": 12,
+                "num_discs": 1,
+                "date": "2008-11-04",
+                "musicbrainz_id": "b4889eaf-d9f4-434c-a68d-69227b12b6a4"
+            },
+            "composers": [
+                {
+                    "__model__": "Artist",
+                    "uri": "local:artist:md5:4d49cbca0b347e0a89047bb019d2779d",
+                    "name": "Matt Bellamy"
+                }
+            ],
+            "genre": "Rock",
+            "track_no": 1,
+            "disc_no": 1,
+            "date": "2008-11-04",
+            "length": 211121,
+            "musicbrainz_id": "ff1e3e1a-f6e8-4692-b426-355880383bb6",
+            "last_modified": 1672712949510
+        },
+        "time_position": 17031
+    }
+}
+#+end_src
+*** Track event playback paused
+#+begin_src json
+{
+    "type": "event",
+    "event": "track_playback_paused",
+    "data": {
+        "tl_track": {
+            "__model__": "TlTrack",
+            "tlid": 14,
+            "track": {
+                "__model__": "Track",
+                "uri": "local:track:Various%20Artists%20-%202008%20-%20Twilight%20OST/01-muse-supermassive_black_hole.mp3",
+                "name": "Supermassive Black Hole",
+                "artists": [
+                    {
+                        "__model__": "Artist",
+                        "uri": "local:artist:md5:250dd6551b66a58a6b4897aa697f200c",
+                        "name": "Muse",
+                        "musicbrainz_id": "9c9f1380-2516-4fc9-a3e6-f9f61941d090"
+                    }
+                ],
+                "album": {
+                    "__model__": "Album",
+                    "uri": "local:album:md5:455343d54cdd89cb5a3b5ad537ea99d0",
+                    "name": "Twilight: Original Motion Picture Soundtrack",
+                    "artists": [
+                        {
+                            "__model__": "Artist",
+                            "uri": "local:artist:md5:54e4db2d5624f80b0cc290346e696756",
+                            "name": "Various Artists",
+                            "musicbrainz_id": "89ad4ac3-39f7-470e-963a-56509c546377"
+                        }
+                    ],
+                    "num_tracks": 12,
+                    "num_discs": 1,
+                    "date": "2008-11-04",
+                    "musicbrainz_id": "b4889eaf-d9f4-434c-a68d-69227b12b6a4"
+                },
+                "composers": [
+                    {
+                        "__model__": "Artist",
+                        "uri": "local:artist:md5:4d49cbca0b347e0a89047bb019d2779d",
+                        "name": "Matt Bellamy"
+                    }
+                ],
+                "genre": "Rock",
+                "track_no": 1,
+                "disc_no": 1,
+                "date": "2008-11-04",
+                "length": 211121,
+                "musicbrainz_id": "ff1e3e1a-f6e8-4692-b426-355880383bb6",
+                "last_modified": 1672712949510
+            }
+        },
+        "time_position": 67578
+    }
+}
+#+end_src
+* TODO [#C] Consider a purge command for duplicated and stuck in-progress scrobbles :improvement:
+* TODO [#C] Figure out how to add to web-scrobbler :imropvement:
+
+An example:
+https://github.com/web-scrobbler/web-scrobbler/blob/master/src/core/background/scrobbler/maloja-scrobbler.js
+
--- a/vrobbler.conf.test
+++ b/vrobbler.conf.test
@ -0,0 +1,8 @@
+# Local configuration for Emus
+
+VROBBLER_DUMP_REQUEST_DATA=True
+VROBBLER_LOG_TO_CONSOLE=True
+VROBBLER_DEBUG=True
+VROBBLER_LOG_LEVEL="DEBUG"
+VROBBLER_MEDIA_ROOT = "/tmp/media/"
+VROBBLER_KEEP_DETAILED_SCROBBLE_LOGS=True
--- a/vrobbler/init.py
+++ b/vrobbler/init.py
@ -0,0 +1,5 @@
+# This will make sure the app is always imported when
+# Django starts so that shared_task will use this app.
+from .celery import app as celery_app
+
+__all__ = ('celery_app',)
--- a/vrobbler/apps/books/admin.py
+++ b/vrobbler/apps/books/admin.py
@ -0,0 +1,25 @@
+from django.contrib import admin
+
+from books.models import Author, Book
+
+from scrobbles.admin import ScrobbleInline
+
+
+@admin.register(Author)
+class AlbumAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("name", "openlibrary_id")
+    ordering = ("name",)
+
+
+@admin.register(Book)
+class ArtistAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = (
+        "title",
+        "isbn",
+        "first_publish_year",
+        "pages",
+        "openlibrary_id",
+    )
+    ordering = ("title",)
--- a/vrobbler/apps/books/api/serializers.py
+++ b/vrobbler/apps/books/api/serializers.py
@ -0,0 +1,14 @@
+from books.models import Author, Book
+from rest_framework import serializers
+
+
+class AuthorSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Author
+        fields = "__all__"
+
+
+class BookSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Book
+        fields = "__all__"
--- a/vrobbler/apps/books/api/views.py
+++ b/vrobbler/apps/books/api/views.py
@ -0,0 +1,19 @@
+from rest_framework import permissions, viewsets
+
+from books.api.serializers import (
+    AuthorSerializer,
+    BookSerializer,
+)
+from books.models import Author, Book
+
+
+class AuthorViewSet(viewsets.ModelViewSet):
+    queryset = Author.objects.all().order_by('-created')
+    serializer_class = AuthorSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class BookViewSet(viewsets.ModelViewSet):
+    queryset = Book.objects.all().order_by('-created')
+    serializer_class = BookSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/books/migrations/0001_initial.py
+++ b/vrobbler/apps/books/migrations/0001_initial.py
@ -0,0 +1,128 @@
+# Generated by Django 4.1.5 on 2023-02-19 20:17
+
+from django.db import migrations, models
+import django_extensions.db.fields
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name='Author',
+            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'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'openlibrary_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Book',
+            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,
+                    ),
+                ),
+                (
+                    'run_time',
+                    models.CharField(blank=True, max_length=8, null=True),
+                ),
+                (
+                    'run_time_ticks',
+                    models.PositiveBigIntegerField(blank=True, null=True),
+                ),
+                ('title', models.CharField(max_length=255)),
+                (
+                    'openlibrary_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'goodreads_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                ('koreader_id', models.IntegerField(blank=True, null=True)),
+                (
+                    'koreader_authors',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'koreader_md5',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'isbn',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                ('pages', models.IntegerField(blank=True, null=True)),
+                (
+                    'language',
+                    models.CharField(blank=True, max_length=4, null=True),
+                ),
+                (
+                    'first_publish_year',
+                    models.IntegerField(blank=True, null=True),
+                ),
+                ('authors', models.ManyToManyField(to='books.author')),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/books/migrations/init.py
+++ b/vrobbler/apps/books/migrations/init.py
--- a/vrobbler/apps/books/models.py
+++ b/vrobbler/apps/books/models.py
@ -0,0 +1,73 @@
+import logging
+from typing import Dict
+
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.db import models
+from django.urls import reverse
+from django_extensions.db.models import TimeStampedModel
+from scrobbles.mixins import ScrobblableMixin
+
+from books.utils import lookup_book_from_openlibrary
+from scrobbles.utils import get_scrobbles_for_media
+
+logger = logging.getLogger(__name__)
+User = get_user_model()
+BNULL = {"blank": True, "null": True}
+
+
+class Author(TimeStampedModel):
+    name = models.CharField(max_length=255)
+    openlibrary_id = models.CharField(max_length=255, **BNULL)
+
+    def __str__(self):
+        return f"{self.name}"
+
+    def fix_metadata(self):
+        logger.warn("Not implemented yet")
+
+
+class Book(ScrobblableMixin):
+    COMPLETION_PERCENT = getattr(settings, 'BOOK_COMPLETION_PERCENT', 95)
+
+    title = models.CharField(max_length=255)
+    authors = models.ManyToManyField(Author)
+    openlibrary_id = models.CharField(max_length=255, **BNULL)
+    goodreads_id = models.CharField(max_length=255, **BNULL)
+    koreader_id = models.IntegerField(**BNULL)
+    koreader_authors = models.CharField(max_length=255, **BNULL)
+    koreader_md5 = models.CharField(max_length=255, **BNULL)
+    isbn = models.CharField(max_length=255, **BNULL)
+    pages = models.IntegerField(**BNULL)
+    language = models.CharField(max_length=4, **BNULL)
+    first_publish_year = models.IntegerField(**BNULL)
+
+    def __str__(self):
+        return f"{self.title} by {self.author}"
+
+    def fix_metadata(self):
+        if not self.openlibrary_id:
+            book_meta = lookup_book_from_openlibrary(self.title, self.author)
+            self.openlibrary_id = book_meta.get("openlibrary_id")
+            self.isbn = book_meta.get("isbn")
+            self.goodreads_id = book_meta.get("goodreads_id")
+            self.first_pubilsh_year = book_meta.get("first_publish_year")
+            self.save()
+
+    @property
+    def author(self):
+        return self.authors.first()
+
+    def get_absolute_url(self):
+        return reverse("books:book_detail", kwargs={'slug': self.uuid})
+
+    @property
+    def pages_for_completion(self) -> int:
+        if not self.pages:
+            logger.warn(f"{self} has no pages, no completion percentage")
+            return 0
+        return int(self.pages * (self.COMPLETION_PERCENT / 100))
+
+    def progress_for_user(self, user: User) -> int:
+        last_scrobble = get_scrobbles_for_media(self, user).last()
+        return int((last_scrobble.book_pages_read / self.pages) * 100)
--- a/vrobbler/apps/books/utils.py
+++ b/vrobbler/apps/books/utils.py
@ -0,0 +1,47 @@
+import json
+from typing import Optional
+import requests
+import logging
+
+logger = logging.getLogger(__name__)
+
+SEARCH_URL = "https://openlibrary.org/search.json?title={title}"
+ISBN_URL = "https://openlibrary.org/isbn/{isbn}.json"
+
+
+def get_first(key: str, result: dict) -> str:
+    obj = ""
+    if obj_list := result.get(key):
+        obj = obj_list[0]
+    return obj
+
+
+def lookup_book_from_openlibrary(title: str, author: str = None) -> dict:
+    search_url = SEARCH_URL.format(title=title)
+    response = requests.get(search_url)
+
+    if response.status_code != 200:
+        logger.warn(f"Bad response from OL: {response.status_code}")
+        return {}
+
+    results = json.loads(response.content)
+
+    if len(results.get('docs')) == 0:
+        logger.warn(f"No results found from OL for {title}")
+        return {}
+
+    top = results.get('docs')[0]
+    if author and author not in top['author_name']:
+        logger.warn(
+            f"Lookup for {title} found top result with mismatched author"
+        )
+
+    return {
+        "title": top.get("title"),
+        "isbn": top.get("isbn")[0],
+        "openlibrary_id": top.get("cover_edition_key"),
+        "author_name": get_first("author_name", top),
+        "author_openlibrary_id": get_first("author_key", top),
+        "goodreads_id": get_first("id_goodreads", top),
+        "first_publish_year": top.get("first_publish_year"),
+    }
--- a/vrobbler/apps/music/admin.py
+++ b/vrobbler/apps/music/admin.py
@ -2,12 +2,29 @@ from django.contrib import admin

 from music.models import Artist, Album, Track

+from scrobbles.admin import ScrobbleInline
+
+
@admin.register(Album)
 class AlbumAdmin(admin.ModelAdmin):
    date_hierarchy = "created"
-    list_display = ("name", "year", "musicbrainz_id")
-    list_filter = ("year",)
+    list_display = (
+        "name",
+        "year",
+        "primary_artist",
+        "theaudiodb_genre",
+        "theaudiodb_mood",
+        "musicbrainz_id",
+    )
+    list_filter = (
+        "theaudiodb_score",
+        "theaudiodb_genre",
+    )
    ordering = ("name",)
+    filter_horizontal = [
+        'artists',
+    ]
+

@admin.register(Artist)
 class ArtistAdmin(admin.ModelAdmin):
@ -15,6 +32,7 @@ class ArtistAdmin(admin.ModelAdmin):
    list_display = ("name", "musicbrainz_id")
    ordering = ("name",)

+
@admin.register(Track)
 class TrackAdmin(admin.ModelAdmin):
    date_hierarchy = "created"
@ -27,3 +45,6 @@ class TrackAdmin(admin.ModelAdmin):
    )
    list_filter = ("album", "artist")
    ordering = ("-created",)
+    inlines = [
+        ScrobbleInline,
+    ]
--- a/vrobbler/apps/music/aggregators.py
+++ b/vrobbler/apps/music/aggregators.py
@ -1,70 +1,150 @@
-from django.db.models import Q, Count, Sum
-from typing import List, Optional
-from scrobbles.models import Scrobble
-from music.models import Track, Artist
-from videos.models import Video
-
-from django.utils import timezone
 from datetime import datetime, timedelta
+from typing import List
+
+from django.apps import apps
+from django.db.models import Count, Q, QuerySet
+from django.utils import timezone
+from music.models import Artist, Track
+from scrobbles.models import Scrobble
+from videos.models import Video
+from vrobbler.apps.profiles.utils import now_user_timezone


-NOW = timezone.now()
-START_OF_TODAY = datetime.combine(NOW.date(), datetime.min.time(), NOW.tzinfo)
-STARTING_DAY_OF_CURRENT_WEEK = NOW.date() - timedelta(days=NOW.today().isoweekday() % 7)
-STARTING_DAY_OF_CURRENT_MONTH = NOW.date().replace(day=1)
-STARTING_DAY_OF_CURRENT_YEAR = NOW.date().replace(month=1, day=1)
+def scrobble_counts(user=None):

+    now = timezone.now()
+    user_filter = Q()
+    if user and user.is_authenticated:
+        now = now_user_timezone(user.profile)
+        user_filter = Q(user=user)

-def scrobble_counts():
-    finished_scrobbles_qs = Scrobble.objects.filter(in_progress=False)
+    start_of_today = datetime.combine(
+        now.date(), datetime.min.time(), now.tzinfo
+    )
+    starting_day_of_current_week = now.date() - timedelta(
+        days=now.today().isoweekday() % 7
+    )
+    starting_day_of_current_month = now.date().replace(day=1)
+    starting_day_of_current_year = now.date().replace(month=1, day=1)
+
+    finished_scrobbles_qs = Scrobble.objects.filter(
+        user_filter, played_to_completion=True
+    )
    data = {}
-    data['today'] = finished_scrobbles_qs.filter(timestamp__gte=START_OF_TODAY).count()
-    data['week'] = finished_scrobbles_qs.filter(timestamp__gte=STARTING_DAY_OF_CURRENT_WEEK).count()
-    data['month'] = finished_scrobbles_qs.filter(timestamp__gte=STARTING_DAY_OF_CURRENT_MONTH).count()
-    data['year'] = finished_scrobbles_qs.filter(timestamp__gte=STARTING_DAY_OF_CURRENT_YEAR).count()
+    data['today'] = finished_scrobbles_qs.filter(
+        timestamp__gte=start_of_today
+    ).count()
+    data['week'] = finished_scrobbles_qs.filter(
+        timestamp__gte=starting_day_of_current_week
+    ).count()
+    data['month'] = finished_scrobbles_qs.filter(
+        timestamp__gte=starting_day_of_current_month
+    ).count()
+    data['year'] = finished_scrobbles_qs.filter(
+        timestamp__gte=starting_day_of_current_year
+    ).count()
    data['alltime'] = finished_scrobbles_qs.count()
    return data

-def week_of_scrobbles(media: str='tracks') -> dict[str, int]:
-    scrobble_day_dict= {}
-    media_filter = Q(track__isnull=True)

-    for day in range(1,8):
-        start = START_OF_TODAY - timedelta(days=day)
-        end = datetime.combine(start, datetime.max.time(), NOW.tzinfo)
-        day_of_week = start.strftime('%A')
-        if media == 'movies':
-            media_filter = Q(video__videotype=Video.VideoType.MOVIE)
-        if media == 'series':
-            media_filter = Q(video__videotype=Video.VideoType.MOVIE)
-        scrobble_day_dict[day_of_week] = Scrobble.objects.filter(media_filter).filter(timestamp__lte=START_OF_TODAY, timestamp__gt=end, in_progress=False).count()
+def week_of_scrobbles(
+    user=None, start=None, media: str = 'tracks'
+) -> dict[str, int]:
+
+    now = timezone.now()
+    user_filter = Q()
+    if user and user.is_authenticated:
+        now = now_user_timezone(user.profile)
+        user_filter = Q(user=user)
+
+    if not start:
+        start = datetime.combine(now.date(), datetime.min.time(), now.tzinfo)
+
+    scrobble_day_dict = {}
+    base_qs = Scrobble.objects.filter(user_filter, played_to_completion=True)
+
+    media_filter = Q(track__isnull=False)
+    if media == 'movies':
+        media_filter = Q(video__video_type=Video.VideoType.MOVIE)
+    if media == 'series':
+        media_filter = Q(video__video_type=Video.VideoType.TV_EPISODE)
+
+    for day in range(6, -1, -1):
+        start_day = start - timedelta(days=day)
+        end = datetime.combine(start_day, datetime.max.time(), now.tzinfo)
+        day_of_week = start_day.strftime('%A')
+
+        scrobble_day_dict[day_of_week] = base_qs.filter(
+            media_filter,
+            timestamp__gte=start_day,
+            timestamp__lte=end,
+            played_to_completion=True,
+        ).count()

    return scrobble_day_dict

-def top_tracks(filter: str="today", limit: int=15) -> List["Track"]:
-    time_filter = Q(scrobble__timestamp__gte=START_OF_TODAY)
-    if filter == "week":
-        time_filter = Q(scrobble__timestamp__gte=STARTING_DAY_OF_CURRENT_WEEK)
-    if filter == "month":
-        time_filter = Q(scrobble__timestamp__gte=STARTING_DAY_OF_CURRENT_MONTH)
-    if filter == "year":
-        time_filter = Q(scrobble__timestamp__gte=STARTING_DAY_OF_CURRENT_YEAR)

-    return Track.objects.annotate(num_scrobbles=Count("scrobble", distinct=True)).filter(time_filter).order_by("-num_scrobbles")[:limit]
+def live_charts(
+    user: "User",
+    media_type: str = "Track",
+    chart_period: str = "all",
+    limit: int = 15,
+) -> QuerySet:
+    now = timezone.now()
+    tzinfo = now.tzinfo
+    now = now.date()
+    if user.is_authenticated:
+        now = now_user_timezone(user.profile)
+        tzinfo = now.tzinfo

-def top_artists(filter: str="today", limit: int=15) -> List["Artist"]:
-    time_filter = Q(track__scrobble__timestamp__gte=START_OF_TODAY)
-    if filter == "week":
-        time_filter = Q(track__scrobble__timestamp__gte=STARTING_DAY_OF_CURRENT_WEEK)
-    if filter == "month":
-        time_filter = Q(track__scrobble__timestamp__gte=STARTING_DAY_OF_CURRENT_MONTH)
-    if filter == "year":
-        time_filter = Q(track__scrobble__timestamp__gte=STARTING_DAY_OF_CURRENT_YEAR)
+    start_of_today = datetime.combine(now, datetime.min.time(), tzinfo)
+    start_day_of_week = now - timedelta(days=now.today().isoweekday() % 7)
+    start_day_of_month = now.replace(day=1)
+    start_day_of_year = now.replace(month=1, day=1)
+
+    media_model = apps.get_model(app_label='music', model_name=media_type)
+
+    period_queries = {
+        'today': {'scrobble__timestamp__gte': start_of_today},
+        'week': {'scrobble__timestamp__gte': start_day_of_week},
+        'month': {'scrobble__timestamp__gte': start_day_of_month},
+        'year': {'scrobble__timestamp__gte': start_day_of_year},
+        'all': {},
+    }
+
+    time_filter = Q()
+    completion_filter = Q(
+        scrobble__user=user, scrobble__played_to_completion=True
+    )
+    user_filter = Q(scrobble__user=user)
+    count_field = "scrobble"
+
+    if media_type == "Artist":
+        for period, query_dict in period_queries.items():
+            period_queries[period] = {
+                "track__" + k: v for k, v in query_dict.items()
+            }
+        completion_filter = Q(
+            track__scrobble__user=user,
+            track__scrobble__played_to_completion=True,
+        )
+        count_field = "track__scrobble"
+        user_filter = Q(track__scrobble__user=user)
+
+    time_filter = Q(**period_queries[chart_period])
+
+    return (
+        media_model.objects.filter(user_filter, time_filter)
+        .annotate(
+            num_scrobbles=Count(
+                count_field,
+                filter=completion_filter,
+                distinct=True,
+            )
+        )
+        .order_by("-num_scrobbles")[:limit]
+    )

-    return Artist.objects.annotate(num_scrobbles=Sum("track__scrobble", distinct=True)).filter(time_filter).order_by("-num_scrobbles")[:limit]

 def artist_scrobble_count(artist_id: int, filter: str = "today") -> int:
-    return (
-        Scrobble.objects.filter(track__artist=artist_id)
-        .count()
-    )
+    return Scrobble.objects.filter(track__artist=artist_id).count()
--- a/vrobbler/apps/music/api/init.py
+++ b/vrobbler/apps/music/api/init.py
--- a/vrobbler/apps/music/api/serializers.py
+++ b/vrobbler/apps/music/api/serializers.py
@ -0,0 +1,20 @@
+from music.models import Album, Artist, Track
+from rest_framework import serializers
+
+
+class ArtistSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Artist
+        fields = "__all__"
+
+
+class AlbumSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Album
+        fields = "__all__"
+
+
+class TrackSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Track
+        fields = "__all__"
--- a/vrobbler/apps/music/api/views.py
+++ b/vrobbler/apps/music/api/views.py
@ -0,0 +1,26 @@
+from rest_framework import permissions, viewsets
+
+from music.api.serializers import (
+    TrackSerializer,
+    ArtistSerializer,
+    AlbumSerializer,
+)
+from music.models import Artist, Album, Track
+
+
+class ArtistViewSet(viewsets.ModelViewSet):
+    queryset = Artist.objects.all().order_by('-created')
+    serializer_class = ArtistSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class AlbumViewSet(viewsets.ModelViewSet):
+    queryset = Album.objects.all().order_by('-created')
+    serializer_class = AlbumSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class TrackViewSet(viewsets.ModelViewSet):
+    queryset = Track.objects.all().order_by('-created')
+    serializer_class = TrackSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/music/migrations/0004_alter_artist_options_alter_album_musicbrainz_id_and_more.py
+++ b/vrobbler/apps/music/migrations/0004_alter_artist_options_alter_album_musicbrainz_id_and_more.py
@ -0,0 +1,35 @@
+# Generated by Django 4.1.5 on 2023-01-11 03:13
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0003_album_uuid_artist_uuid_track_uuid'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='artist',
+            options={},
+        ),
+        migrations.AlterField(
+            model_name='album',
+            name='musicbrainz_id',
+            field=models.CharField(
+                blank=True, max_length=255, null=True, unique=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name='track',
+            name='musicbrainz_id',
+            field=models.CharField(
+                blank=True, max_length=255, null=True, unique=True
+            ),
+        ),
+        migrations.AlterUniqueTogether(
+            name='artist',
+            unique_together={('name', 'musicbrainz_id')},
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0004_track_thumbs.py
+++ b/vrobbler/apps/music/migrations/0004_track_thumbs.py
@ -1,25 +0,0 @@
-# Generated by Django 4.1.5 on 2023-01-09 16:19
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('music', '0003_album_uuid_artist_uuid_track_uuid'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='track',
-            name='thumbs',
-            field=models.IntegerField(
-                choices=[
-                    (-1, 'Thumbs down'),
-                    (0, 'No opinion'),
-                    (1, 'Thumbs up'),
-                ],
-                default=0,
-            ),
-        ),
-    ]
--- a/vrobbler/apps/music/migrations/0005_album_cover_image.py
+++ b/vrobbler/apps/music/migrations/0005_album_cover_image.py
@ -0,0 +1,23 @@
+# Generated by Django 4.1.5 on 2023-01-12 04:22
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        (
+            'music',
+            '0004_alter_artist_options_alter_album_musicbrainz_id_and_more',
+        ),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='album',
+            name='cover_image',
+            field=models.ImageField(
+                blank=True, null=True, upload_to='albums/'
+            ),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0006_album_artists.py
+++ b/vrobbler/apps/music/migrations/0006_album_artists.py
@ -0,0 +1,20 @@
+# Generated by Django 4.1.5 on 2023-01-12 05:04
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0005_album_cover_image'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='album',
+            name='artists',
+            field=models.ManyToManyField(
+                blank=True, null=True, to='music.artist'
+            ),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0007_alter_album_artists.py
+++ b/vrobbler/apps/music/migrations/0007_alter_album_artists.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-01-12 17:17
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0006_album_artists'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='album',
+            name='artists',
+            field=models.ManyToManyField(to='music.artist'),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0008_alter_track_options.py
+++ b/vrobbler/apps/music/migrations/0008_alter_track_options.py
@ -0,0 +1,17 @@
+# Generated by Django 4.1.5 on 2023-01-13 01:47
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0007_alter_album_artists'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='track',
+            options={},
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0009_alter_track_musicbrainz_id_and_more.py
+++ b/vrobbler/apps/music/migrations/0009_alter_track_musicbrainz_id_and_more.py
@ -0,0 +1,22 @@
+# Generated by Django 4.1.5 on 2023-01-19 20:03
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0008_alter_track_options'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='track',
+            name='musicbrainz_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AlterUniqueTogether(
+            name='track',
+            unique_together={('album', 'musicbrainz_id')},
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0010_artist_biography_artist_theaudiodb_genre_and_more.py
+++ b/vrobbler/apps/music/migrations/0010_artist_biography_artist_theaudiodb_genre_and_more.py
@ -0,0 +1,28 @@
+# Generated by Django 4.1.5 on 2023-02-27 03:57
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0009_alter_track_musicbrainz_id_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='artist',
+            name='biography',
+            field=models.TextField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='artist',
+            name='theaudiodb_genre',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='artist',
+            name='theaudiodb_mood',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0011_artist_thumbnail.py
+++ b/vrobbler/apps/music/migrations/0011_artist_thumbnail.py
@ -0,0 +1,20 @@
+# Generated by Django 4.1.5 on 2023-02-27 04:04
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0010_artist_biography_artist_theaudiodb_genre_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='artist',
+            name='thumbnail',
+            field=models.ImageField(
+                blank=True, null=True, upload_to='artist/'
+            ),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0012_album_allmusic_id_album_discogs_id_and_more.py
+++ b/vrobbler/apps/music/migrations/0012_album_allmusic_id_album_discogs_id_and_more.py
@ -0,0 +1,85 @@
+# Generated by Django 4.1.5 on 2023-03-02 19:00
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0011_artist_thumbnail'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='album',
+            name='allmusic_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='discogs_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='rateyourmusic_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='theaudiodb_description',
+            field=models.TextField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='theaudiodb_genre',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='theaudiodb_id',
+            field=models.CharField(
+                blank=True, max_length=255, null=True, unique=True
+            ),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='theaudiodb_mood',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='theaudiodb_score',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='theaudiodb_score_votes',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='theaudiodb_speed',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='theaudiodb_style',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='theaudiodb_theme',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='wikidata_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='wikipedia_slug',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0013_alter_album_theaudiodb_score.py
+++ b/vrobbler/apps/music/migrations/0013_alter_album_theaudiodb_score.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-03-02 19:23
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0012_album_allmusic_id_album_discogs_id_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='album',
+            name='theaudiodb_score',
+            field=models.FloatField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0014_album_theaudiodb_year_released.py
+++ b/vrobbler/apps/music/migrations/0014_album_theaudiodb_year_released.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-03-02 19:27
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0013_alter_album_theaudiodb_score'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='album',
+            name='theaudiodb_year_released',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/music/models.py
+++ b/vrobbler/apps/music/models.py
@ -1,37 +1,35 @@
 import logging
+from tempfile import NamedTemporaryFile
 from typing import Dict, Optional
+from urllib.request import urlopen
 from uuid import uuid4

-from django.apps.config import cached_property
-
+import musicbrainzngs
+from django.conf import settings
+from django.core.files.base import ContentFile, File
 from django.db import models
+from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 from django_extensions.db.models import TimeStampedModel
+from scrobbles.mixins import ScrobblableMixin
+from scrobbles.theaudiodb import lookup_artist_from_tadb
+from vrobbler.apps.scrobbles.theaudiodb import lookup_album_from_tadb

 logger = logging.getLogger(__name__)
 BNULL = {"blank": True, "null": True}


-class Album(TimeStampedModel):
-    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
-    name = models.CharField(max_length=255)
-    year = models.IntegerField(**BNULL)
-    musicbrainz_id = models.CharField(max_length=255, **BNULL)
-    musicbrainz_releasegroup_id = models.CharField(max_length=255, **BNULL)
-    musicbrainz_albumartist_id = models.CharField(max_length=255, **BNULL)
-
-    def __str__(self):
-        return self.name
-
-    @property
-    def mb_link(self):
-        return f"https://musicbrainz.org/release/{self.musicbrainz_id}"
-
-
 class Artist(TimeStampedModel):
    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
    name = models.CharField(max_length=255)
+    biography = models.TextField(**BNULL)
+    theaudiodb_genre = models.CharField(max_length=255, **BNULL)
+    theaudiodb_mood = models.CharField(max_length=255, **BNULL)
    musicbrainz_id = models.CharField(max_length=255, **BNULL)
+    thumbnail = models.ImageField(upload_to="artist/", **BNULL)
+
+    class Meta:
+        unique_together = [['name', 'musicbrainz_id']]

    def __str__(self):
        return self.name
@ -40,32 +38,247 @@ class Artist(TimeStampedModel):
    def mb_link(self):
        return f"https://musicbrainz.org/artist/{self.musicbrainz_id}"

+    def get_absolute_url(self):
+        return reverse('music:artist_detail', kwargs={'slug': self.uuid})
+
+    def scrobbles(self):
+        from scrobbles.models import Scrobble
+
+        return Scrobble.objects.filter(
+            track__in=self.track_set.all()
+        ).order_by('-timestamp')
+
+    @property
+    def tracks(self):
+        return (
+            self.track_set.all()
+            .annotate(scrobble_count=models.Count('scrobble'))
+            .order_by('-scrobble_count')
+        )
+
+    def charts(self):
+        from scrobbles.models import ChartRecord
+
+        return ChartRecord.objects.filter(track__artist=self).order_by('-year')
+
+    def fix_metadata(self):
+        tadb_info = lookup_artist_from_tadb(self.name)
+        if not tadb_info:
+            logger.warn(f"No response from TADB for artist {self.name}")
+            return
+
+        self.biography = tadb_info['biography']
+        self.theaudiodb_genre = tadb_info['genre']
+        self.theaudiodb_mood = tadb_info['mood']
+
+        img_temp = NamedTemporaryFile(delete=True)
+        img_temp.write(urlopen(tadb_info['thumb_url']).read())
+        img_temp.flush()
+        img_filename = f"{self.name}_{self.uuid}.jpg"
+        self.thumbnail.save(img_filename, File(img_temp))
+
+
+class Album(TimeStampedModel):
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+    name = models.CharField(max_length=255)
+    artists = models.ManyToManyField(Artist)
+    year = models.IntegerField(**BNULL)
+    musicbrainz_id = models.CharField(max_length=255, unique=True, **BNULL)
+    musicbrainz_releasegroup_id = models.CharField(max_length=255, **BNULL)
+    musicbrainz_albumartist_id = models.CharField(max_length=255, **BNULL)
+    cover_image = models.ImageField(upload_to="albums/", **BNULL)
+    theaudiodb_id = models.CharField(max_length=255, unique=True, **BNULL)
+    theaudiodb_description = models.TextField(**BNULL)
+    theaudiodb_year_released = models.IntegerField(**BNULL)
+    theaudiodb_score = models.FloatField(**BNULL)
+    theaudiodb_score_votes = models.IntegerField(**BNULL)
+    theaudiodb_genre = models.CharField(max_length=255, **BNULL)
+    theaudiodb_style = models.CharField(max_length=255, **BNULL)
+    theaudiodb_mood = models.CharField(max_length=255, **BNULL)
+    theaudiodb_speed = models.CharField(max_length=255, **BNULL)
+    theaudiodb_theme = models.CharField(max_length=255, **BNULL)
+    allmusic_id = models.CharField(max_length=255, **BNULL)
+    rateyourmusic_id = models.CharField(max_length=255, **BNULL)
+    wikipedia_slug = models.CharField(max_length=255, **BNULL)
+    discogs_id = models.CharField(max_length=255, **BNULL)
+    wikidata_id = models.CharField(max_length=255, **BNULL)
+
+    def __str__(self):
+        return self.name
+
+    def get_absolute_url(self):
+        return reverse("music:album_detail", kwargs={'slug': self.uuid})
+
+    def scrobbles(self):
+        from scrobbles.models import Scrobble
+
+        return Scrobble.objects.filter(
+            track__in=self.track_set.all()
+        ).order_by('-timestamp')
+
+    @property
+    def tracks(self):
+        return (
+            self.track_set.all()
+            .annotate(scrobble_count=models.Count('scrobble'))
+            .order_by('-scrobble_count')
+        )
+
+    @property
+    def primary_artist(self):
+        return self.artists.first()
+
+    def scrape_theaudiodb(self) -> None:
+        artist = "Various Artists"
+        if self.primary_artist:
+            artist = self.primary_artist.name
+        album_data = lookup_album_from_tadb(self.name, artist)
+        if not album_data.get('theaudiodb_id'):
+            logger.info(f"No data for {self} found in TheAudioDB")
+            return
+
+        Album.objects.filter(pk=self.pk).update(**album_data)
+
+    def fix_metadata(self):
+        if (
+            not self.musicbrainz_albumartist_id
+            or not self.year
+            or not self.musicbrainz_releasegroup_id
+        ):
+            musicbrainzngs.set_useragent('vrobbler', '0.3.0')
+            mb_data = musicbrainzngs.get_release_by_id(
+                self.musicbrainz_id, includes=['artists', 'release-groups']
+            )
+            if not self.musicbrainz_releasegroup_id:
+                self.musicbrainz_releasegroup_id = mb_data['release'][
+                    'release-group'
+                ]['id']
+            if not self.musicbrainz_albumartist_id:
+                self.musicbrainz_albumartist_id = mb_data['release'][
+                    'artist-credit'
+                ][0]['artist']['id']
+            if not self.year:
+                try:
+                    self.year = mb_data['release']['date'][0:4]
+                except KeyError:
+                    pass
+                except IndexError:
+                    pass
+
+            self.save(
+                update_fields=[
+                    'musicbrainz_albumartist_id',
+                    'musicbrainz_releasegroup_id',
+                    'year',
+                ]
+            )
+
+            new_artist = Artist.objects.filter(
+                musicbrainz_id=self.musicbrainz_albumartist_id
+            ).first()
+            if self.musicbrainz_albumartist_id and new_artist:
+                self.artists.add(new_artist)
+            if not new_artist:
+                for t in self.track_set.all():
+                    self.artists.add(t.artist)
+            if (
+                not self.cover_image
+                or self.cover_image == 'default-image-replace-me'
+            ):
+                self.fetch_artwork()
+        self.scrape_theaudiodb()
+
+    def fetch_artwork(self, force=False):
+        if not self.cover_image and not force:
+            if self.musicbrainz_id:
+                try:
+                    img_data = musicbrainzngs.get_image_front(
+                        self.musicbrainz_id
+                    )
+                    name = f"{self.name}_{self.uuid}.jpg"
+                    self.cover_image = ContentFile(img_data, name=name)
+                    logger.info(f'Setting image to {name}')
+                except musicbrainzngs.ResponseError:
+                    logger.warning(
+                        f'No cover art found for {self.name} by release'
+                    )
+
+            if (
+                not self.cover_image
+                or self.cover_image == "default-image-replace-me"
+            ) and self.musicbrainz_releasegroup_id:
+                try:
+                    img_data = musicbrainzngs.get_release_group_image_front(
+                        self.musicbrainz_releasegroup_id
+                    )
+                    name = f"{self.name}_{self.uuid}.jpg"
+                    self.cover_image = ContentFile(img_data, name=name)
+                    logger.info(f'Setting image to {name}')
+                except musicbrainzngs.ResponseError:
+                    logger.warning(
+                        f'No cover art found for {self.name} by release group'
+                    )
+            if not self.cover_image:
+                logger.debug(
+                    f"No cover art found for release or release group for {self.name}, setting to default"
+                )
+            self.save()
+
+    @property
+    def mb_link(self) -> str:
+        return f"https://musicbrainz.org/release/{self.musicbrainz_id}"
+
+    @property
+    def allmusic_link(self) -> str:
+        if self.allmusic_id:
+            return f"https://www.allmusic.com/artist/{self.allmusic_id}"
+        return ""
+
+    @property
+    def wikipedia_link(self):
+        if self.wikipedia_slug:
+            return f"https://www.wikipedia.org/en/{self.wikipedia_slug}"
+        return ""
+
+    @property
+    def tadb_link(self):
+        if self.theaudiodb_id:
+            return f"https://www.theaudiodb.com/album/{self.theaudiodb_id}"
+        return ""
+
+
+class Track(ScrobblableMixin):
+    COMPLETION_PERCENT = getattr(settings, 'MUSIC_COMPLETION_PERCENT', 90)

-class Track(TimeStampedModel):
    class Opinion(models.IntegerChoices):
        DOWN = -1, 'Thumbs down'
        NEUTRAL = 0, 'No opinion'
        UP = 1, 'Thumbs up'

-    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
-    title = models.CharField(max_length=255, **BNULL)
    artist = models.ForeignKey(Artist, on_delete=models.DO_NOTHING)
    album = models.ForeignKey(Album, on_delete=models.DO_NOTHING, **BNULL)
    musicbrainz_id = models.CharField(max_length=255, **BNULL)
-    run_time = models.CharField(max_length=8, **BNULL)
-    run_time_ticks = models.PositiveBigIntegerField(**BNULL)
-    thumbs = models.IntegerField(default=Opinion.NEUTRAL, choices=Opinion.choices)
+
+    class Meta:
+        unique_together = [['album', 'musicbrainz_id']]

    def __str__(self):
        return f"{self.title} by {self.artist}"

+    def get_absolute_url(self):
+        return reverse('music:track_detail', kwargs={'slug': self.uuid})
+
+    @property
+    def subtitle(self):
+        return self.artist
+
    @property
    def mb_link(self):
        return f"https://musicbrainz.org/recording/{self.musicbrainz_id}"

-    @cached_property
-    def scrobble_count(self):
-        return self.scrobble_set.filter(in_progress=False).count()
+    @property
+    def info_link(self):
+        return self.mb_link

    @classmethod
    def find_or_create(
@ -80,28 +293,20 @@ class Track(TimeStampedModel):
            'musicbrainz_id'
        ):
            logger.warning(
-                f"No artist or artist musicbrainz ID found in message from Jellyfin, not scrobbling"
+                f"No artist or artist musicbrainz ID found in message from source, not scrobbling"
            )
            return
-        artist, artist_created = Artist.objects.get_or_create(**artist_dict)
-        if artist_created:
-            logger.debug(f"Created new album {artist}")
-        else:
-            logger.debug(f"Found album {artist}")

+        artist, artist_created = Artist.objects.get_or_create(**artist_dict)
        album, album_created = Album.objects.get_or_create(**album_dict)
-        if album_created:
-            logger.debug(f"Created new album {album}")
-        else:
-            logger.debug(f"Found album {album}")
+
+        album.fix_metadata()
+        if not album.cover_image:
+            album.fetch_artwork()

        track_dict['album_id'] = getattr(album, "id", None)
        track_dict['artist_id'] = artist.id

        track, created = cls.objects.get_or_create(**track_dict)
-        if created:
-            logger.debug(f"Created new track: {track}")
-        else:
-            logger.debug(f"Found track {track}")

        return track
--- a/vrobbler/apps/music/serializers.py
+++ b/vrobbler/apps/music/serializers.py
@ -0,0 +1 @@
+#!/usr/bin/env python3
--- a/vrobbler/apps/music/urls.py
+++ b/vrobbler/apps/music/urls.py
@ -0,0 +1,26 @@
+from django.urls import path
+from music import views
+
+app_name = 'music'
+
+
+urlpatterns = [
+    path('albums/', views.AlbumListView.as_view(), name='albums_list'),
+    path(
+        'album/<slug:slug>/',
+        views.AlbumDetailView.as_view(),
+        name='album_detail',
+    ),
+    path("tracks/", views.TrackListView.as_view(), name='tracks_list'),
+    path(
+        'tracks/<slug:slug>/',
+        views.TrackDetailView.as_view(),
+        name='track_detail',
+    ),
+    path('artists/', views.ArtistListView.as_view(), name='artist_list'),
+    path(
+        'artists/<slug:slug>/',
+        views.ArtistDetailView.as_view(),
+        name='artist_detail',
+    ),
+]
--- a/vrobbler/apps/music/utils.py
+++ b/vrobbler/apps/music/utils.py
@ -0,0 +1,109 @@
+import logging
+import re
+
+from musicbrainzngs.caa import musicbrainz
+
+from scrobbles.musicbrainz import (
+    lookup_album_dict_from_mb,
+    lookup_artist_from_mb,
+    lookup_track_from_mb,
+)
+
+logger = logging.getLogger(__name__)
+
+
+from music.models import Album, Artist, Track
+
+
+def get_or_create_artist(name: str, mbid: str = None) -> Artist:
+    artist = None
+    logger.debug(f'Got artist {name} and mbid: {mbid}')
+
+    if 'feat.' in name.lower():
+        name = re.split("feat.", name, flags=re.IGNORECASE)[0].strip()
+    if 'featuring' in name.lower():
+        name = re.split("featuring", name, flags=re.IGNORECASE)[0].strip()
+    if '&' in name.lower():
+        name = re.split("&", name, flags=re.IGNORECASE)[0].strip()
+
+    artist_dict = lookup_artist_from_mb(name)
+    mbid = mbid or artist_dict['id']
+
+    logger.debug(f'Looking up artist {name} and mbid: {mbid}')
+    artist = Artist.objects.filter(musicbrainz_id=mbid).first()
+    if not artist:
+        artist = Artist.objects.create(name=name, musicbrainz_id=mbid)
+        logger.debug(
+            f"Created artist {artist.name} ({artist.musicbrainz_id}) "
+        )
+        artist.fix_metadata()
+
+    return artist
+
+
+def get_or_create_album(name: str, artist: Artist, mbid: str = None) -> Album:
+    album = None
+    album_created = False
+    albums = Album.objects.filter(name__iexact=name)
+    if albums.count() == 1:
+        album = albums.first()
+    else:
+        for potential_album in albums:
+            if artist in album.artist_set.all():
+                album = potential_album
+    if not album:
+        album_created = True
+        album = Album.objects.create(name=name, musicbrainz_id=mbid)
+        album.save()
+        album.artists.add(artist)
+
+    if album_created or not mbid:
+        album_dict = lookup_album_dict_from_mb(
+            album.name, artist_name=artist.name
+        )
+        album.year = album_dict["year"]
+        album.musicbrainz_id = album_dict["mb_id"]
+        album.musicbrainz_releasegroup_id = album_dict["mb_group_id"]
+        album.musicbrainz_albumartist_id = artist.musicbrainz_id
+        album.save(
+            update_fields=[
+                "year",
+                "musicbrainz_id",
+                "musicbrainz_releasegroup_id",
+                "musicbrainz_albumartist_id",
+            ]
+        )
+        album.artists.add(artist)
+        album.fetch_artwork()
+    return album
+
+
+def get_or_create_track(
+    title: str,
+    artist: Artist,
+    album: Album,
+    mbid: str = None,
+    run_time=None,
+    run_time_ticks=None,
+) -> Track:
+    track = None
+    if not mbid:
+        mbid = lookup_track_from_mb(
+            title,
+            artist.musicbrainz_id,
+            album.musicbrainz_id,
+        )['id']
+
+    track = Track.objects.filter(musicbrainz_id=mbid).first()
+
+    if not track:
+        track = Track.objects.create(
+            title=title,
+            artist=artist,
+            album=album,
+            musicbrainz_id=mbid,
+            run_time=run_time,
+            run_time_ticks=run_time_ticks,
+        )
+
+    return track
--- a/vrobbler/apps/music/views.py
+++ b/vrobbler/apps/music/views.py
@ -0,0 +1,94 @@
+from django.db.models import Count
+from django.views import generic
+from music.models import Album, Artist, Track
+from scrobbles.models import ChartRecord
+from scrobbles.stats import get_scrobble_count_qs
+
+
+class TrackListView(generic.ListView):
+    model = Track
+    paginate_by = 200
+
+    def get_queryset(self):
+        return get_scrobble_count_qs(user=self.request.user).order_by(
+            "-scrobble_count"
+        )
+
+
+class TrackDetailView(generic.DetailView):
+    model = Track
+    slug_field = 'uuid'
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        context_data['charts'] = ChartRecord.objects.filter(
+            track=self.object, rank__in=[1, 2, 3]
+        )
+        return context_data
+
+
+class ArtistListView(generic.ListView):
+    model = Artist
+    paginate_by = 100
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(scrobble_count=Count('track__scrobble'))
+            .order_by("-scrobble_count")
+        )
+
+    def get_context_data(self, *, object_list=None, **kwargs):
+        context_data = super().get_context_data(
+            object_list=object_list, **kwargs
+        )
+        context_data['view'] = self.request.GET.get('view')
+        return context_data
+
+
+class ArtistDetailView(generic.DetailView):
+    model = Artist
+    slug_field = 'uuid'
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        artist = context_data['object']
+        rank = 1
+        tracks_ranked = []
+        scrobbles = artist.tracks.first().scrobble_count
+        for track in artist.tracks:
+            if scrobbles > track.scrobble_count:
+                rank += 1
+            tracks_ranked.append((rank, track))
+            scrobbles = track.scrobble_count
+
+        context_data['tracks_ranked'] = tracks_ranked
+        context_data['charts'] = ChartRecord.objects.filter(
+            artist=self.object, rank__in=[1, 2, 3]
+        )
+        return context_data
+
+
+class AlbumListView(generic.ListView):
+    model = Album
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(scrobble_count=Count('track__scrobble'))
+            .order_by("-scrobble_count")
+        )
+
+
+class AlbumDetailView(generic.DetailView):
+    model = Album
+    slug_field = 'uuid'
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        # context_data['charts'] = ChartRecord.objects.filter(
+        #    track__album=self.object, rank__in=[1, 2, 3]
+        # )
+        return context_data
--- a/vrobbler/apps/podcasts/init.py
+++ b/vrobbler/apps/podcasts/init.py
--- a/vrobbler/apps/podcasts/admin.py
+++ b/vrobbler/apps/podcasts/admin.py
@ -0,0 +1,36 @@
+from django.contrib import admin
+from podcasts.models import Episode, Podcast, Producer
+from scrobbles.admin import ScrobbleInline
+
+
+@admin.register(Producer)
+class ProducerAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("name",)
+    ordering = ("name",)
+
+
+@admin.register(Podcast)
+class PodcastAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = (
+        "name",
+        "producer",
+        "active",
+    )
+    ordering = ("name",)
+
+
+@admin.register(Episode)
+class EpisodeAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = (
+        "title",
+        "podcast",
+        "run_time",
+    )
+    list_filter = ("podcast",)
+    ordering = ("-created",)
+    inlines = [
+        ScrobbleInline,
+    ]
--- a/vrobbler/apps/podcasts/apps.py
+++ b/vrobbler/apps/podcasts/apps.py
@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class PodcastsConfig(AppConfig):
+    name = 'podcasts'
--- a/vrobbler/apps/podcasts/migrations/0001_initial.py
+++ b/vrobbler/apps/podcasts/migrations/0001_initial.py
@ -0,0 +1,158 @@
+# Generated by Django 4.1.5 on 2023-01-12 17:18
+
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name='Producer',
+            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'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Podcast',
+            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'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                ('active', models.BooleanField(default=True)),
+                ('url', models.URLField(blank=True, null=True)),
+                (
+                    'producer',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='podcasts.producer',
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Episode',
+            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'
+                    ),
+                ),
+                ('title', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                (
+                    'mopidy_uri',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'podcast',
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='podcasts.producer',
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/podcasts/migrations/0002_episode_run_time_episode_run_time_ticks_and_more.py
+++ b/vrobbler/apps/podcasts/migrations/0002_episode_run_time_episode_run_time_ticks_and_more.py
@ -0,0 +1,32 @@
+# Generated by Django 4.1.5 on 2023-01-12 17:48
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='episode',
+            name='run_time',
+            field=models.CharField(blank=True, max_length=8, null=True),
+        ),
+        migrations.AddField(
+            model_name='episode',
+            name='run_time_ticks',
+            field=models.PositiveBigIntegerField(blank=True, null=True),
+        ),
+        migrations.AlterField(
+            model_name='episode',
+            name='podcast',
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='podcasts.podcast',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/podcasts/migrations/0003_episode_pub_date.py
+++ b/vrobbler/apps/podcasts/migrations/0003_episode_pub_date.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-01-12 18:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0002_episode_run_time_episode_run_time_ticks_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='episode',
+            name='pub_date',
+            field=models.DateField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/podcasts/migrations/0004_episode_number.py
+++ b/vrobbler/apps/podcasts/migrations/0004_episode_number.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-01-12 18:32
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0003_episode_pub_date'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='episode',
+            name='number',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/podcasts/migrations/0005_alter_episode_options_alter_episode_title.py
+++ b/vrobbler/apps/podcasts/migrations/0005_alter_episode_options_alter_episode_title.py
@ -0,0 +1,22 @@
+# Generated by Django 4.1.5 on 2023-01-13 01:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0004_episode_number'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='episode',
+            options={},
+        ),
+        migrations.AlterField(
+            model_name='episode',
+            name='title',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]
--- a/vrobbler/apps/podcasts/migrations/init.py
+++ b/vrobbler/apps/podcasts/migrations/init.py
--- a/vrobbler/apps/podcasts/models.py
+++ b/vrobbler/apps/podcasts/models.py
@ -0,0 +1,96 @@
+import logging
+from typing import Dict, Optional
+from uuid import uuid4
+
+from django.conf import settings
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from django_extensions.db.models import TimeStampedModel
+
+from scrobbles.mixins import ScrobblableMixin
+
+logger = logging.getLogger(__name__)
+BNULL = {"blank": True, "null": True}
+
+
+class Producer(TimeStampedModel):
+    name = models.CharField(max_length=255)
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+
+    def __str__(self):
+        return f"{self.name}"
+
+
+class Podcast(TimeStampedModel):
+    name = models.CharField(max_length=255)
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+    producer = models.ForeignKey(
+        Producer, on_delete=models.DO_NOTHING, **BNULL
+    )
+    active = models.BooleanField(default=True)
+    url = models.URLField(**BNULL)
+
+    def __str__(self):
+        return f"{self.name}"
+
+
+class Episode(ScrobblableMixin):
+    COMPLETION_PERCENT = getattr(settings, 'PODCAST_COMPLETION_PERCENT', 90)
+
+    podcast = models.ForeignKey(Podcast, on_delete=models.DO_NOTHING)
+    number = models.IntegerField(**BNULL)
+    pub_date = models.DateField(**BNULL)
+    mopidy_uri = models.CharField(max_length=255, **BNULL)
+
+    def __str__(self):
+        return f"{self.title}"
+
+    @property
+    def subtitle(self):
+        return self.podcast
+
+    @property
+    def info_link(self):
+        return ""
+
+    @classmethod
+    def find_or_create(
+        cls, podcast_dict: Dict, producer_dict: Dict, episode_dict: Dict
+    ) -> Optional["Episode"]:
+        """Given a data dict from Mopidy, finds or creates a podcast and
+        producer before saving the epsiode so it can be scrobbled.
+
+        """
+        if not podcast_dict.get('name'):
+            logger.warning(f"No name from source for podcast, not scrobbling")
+            return
+
+        producer = None
+        if producer_dict.get('name'):
+            producer, producer_created = Producer.objects.get_or_create(
+                **producer_dict
+            )
+            if producer_created:
+                logger.debug(f"Created new producer {producer}")
+            else:
+                logger.debug(f"Found producer {producer}")
+
+        if producer:
+            podcast_dict["producer_id"] = producer.id
+        podcast, podcast_created = Podcast.objects.get_or_create(
+            **podcast_dict
+        )
+        if podcast_created:
+            logger.debug(f"Created new podcast {podcast}")
+        else:
+            logger.debug(f"Found podcast {podcast}")
+
+        episode_dict['podcast_id'] = podcast.id
+
+        episode, created = cls.objects.get_or_create(**episode_dict)
+        if created:
+            logger.debug(f"Created new episode: {episode}")
+        else:
+            logger.debug(f"Found episode {episode}")
+
+        return episode
--- a/vrobbler/apps/profiles/init.py
+++ b/vrobbler/apps/profiles/init.py
--- a/vrobbler/apps/profiles/admin.py
+++ b/vrobbler/apps/profiles/admin.py
@ -0,0 +1,9 @@
+from django.contrib import admin
+
+from profiles.models import UserProfile
+
+
+@admin.register(UserProfile)
+class UserProfileAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    ordering = ("-created",)
--- a/vrobbler/apps/profiles/api/init.py
+++ b/vrobbler/apps/profiles/api/init.py
@ -0,0 +1 @@
+#!/usr/bin/env python3
--- a/vrobbler/apps/profiles/api/serializers.py
+++ b/vrobbler/apps/profiles/api/serializers.py
@ -0,0 +1,18 @@
+from django.contrib.auth import get_user_model
+from rest_framework import serializers
+
+User = get_user_model()
+
+from profiles.models import UserProfile
+
+
+class UserSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = User
+        exclude = ('password',)
+
+
+class UserProfileSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = UserProfile
+        exclude = ('lastfm_password',)
--- a/vrobbler/apps/profiles/api/views.py
+++ b/vrobbler/apps/profiles/api/views.py
@ -0,0 +1,28 @@
+from django.contrib.auth import get_user_model
+
+from rest_framework import permissions, viewsets
+
+from profiles.api.serializers import UserSerializer, UserProfileSerializer
+from profiles.models import UserProfile
+
+User = get_user_model()
+
+
+class UserViewSet(viewsets.ModelViewSet):
+    """
+    API endpoint that allows users to be viewed or edited.
+    """
+
+    queryset = User.objects.all().order_by('-date_joined')
+    serializer_class = UserSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class UserProfileViewSet(viewsets.ModelViewSet):
+    """
+    API endpoint that allows users to be viewed or edited.
+    """
+
+    queryset = UserProfile.objects.all().order_by('-created')
+    serializer_class = UserProfileSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/profiles/constants.py
+++ b/vrobbler/apps/profiles/constants.py
@ -0,0 +1,17 @@
+from datetime import datetime
+
+import pytz
+
+ALL_TIMEZONE_CHOICES = tuple(zip(pytz.all_timezones, pytz.all_timezones))
+COMMON_TIMEZONE_CHOICES = tuple(
+    zip(pytz.common_timezones, pytz.common_timezones)
+)
+PRETTY_TIMEZONE_CHOICES = []
+
+for tz in pytz.common_timezones:
+    now = datetime.now(pytz.timezone(tz))
+    ofs = now.strftime("%z")
+    PRETTY_TIMEZONE_CHOICES.append((int(ofs), tz, "(GMT%s) %s" % (ofs, tz)))
+PRETTY_TIMEZONE_CHOICES.sort()
+for i in range(len(PRETTY_TIMEZONE_CHOICES)):
+    PRETTY_TIMEZONE_CHOICES[i] = PRETTY_TIMEZONE_CHOICES[i][1:]
--- a/vrobbler/apps/profiles/migrations/0001_initial.py
+++ b/vrobbler/apps/profiles/migrations/0001_initial.py
--- a/vrobbler/apps/profiles/migrations/0002_userprofile_lastfm_password_and_more.py
+++ b/vrobbler/apps/profiles/migrations/0002_userprofile_lastfm_password_and_more.py
@ -0,0 +1,24 @@
+# Generated by Django 4.1.5 on 2023-02-12 22:26
+
+from django.db import migrations, models
+import encrypted_field.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('profiles', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='lastfm_password',
+            field=encrypted_field.fields.EncryptedField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='userprofile',
+            name='lastfm_username',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]
--- a/vrobbler/apps/profiles/migrations/init.py
+++ b/vrobbler/apps/profiles/migrations/init.py
--- a/vrobbler/apps/profiles/models.py
+++ b/vrobbler/apps/profiles/models.py
@ -0,0 +1,29 @@
+import pytz
+
+from django.contrib.auth import get_user_model
+from django.db import models
+from django_extensions.db.models import TimeStampedModel
+from profiles.constants import PRETTY_TIMEZONE_CHOICES
+
+from encrypted_field import EncryptedField
+
+User = get_user_model()
+BNULL = {"blank": True, "null": True}
+
+
+class UserProfile(TimeStampedModel):
+    user = models.OneToOneField(
+        User, on_delete=models.CASCADE, related_name="profile"
+    )
+    timezone = models.CharField(
+        max_length=255, choices=PRETTY_TIMEZONE_CHOICES, default=pytz.UTC
+    )
+    lastfm_username = models.CharField(max_length=255, **BNULL)
+    lastfm_password = EncryptedField(**BNULL)
+
+    def __str__(self):
+        return f"User profile for {self.user}"
+
+    @property
+    def tzinfo(self):
+        return pytz.timezone(self.timezone)
--- a/vrobbler/apps/profiles/signals.py
+++ b/vrobbler/apps/profiles/signals.py
@ -0,0 +1,13 @@
+from django.contrib.auth import get_user_model
+from django.db.models.base import post_save
+from django.dispatch import receiver
+
+from profiles.models import UserProfile
+
+User = get_user_model()
+
+
+@receiver(post_save, sender=User)
+def create_profile(sender, instance, created, **kwargs):
+    if created:
+        UserProfile.objects.create(user=instance)
--- a/vrobbler/apps/profiles/utils.py
+++ b/vrobbler/apps/profiles/utils.py
@ -0,0 +1,58 @@
+import pytz
+from django.conf import settings
+from django.utils import timezone
+import calendar
+
+from datetime import datetime, timedelta
+
+# need to translate to a non-naive timezone, even if timezone == settings.TIME_ZONE, so we can compare two dates
+def to_user_timezone(date, profile):
+    timezone = profile.timezone if profile.timezone else settings.TIME_ZONE
+    return date.astimezone(pytz.timezone(timezone))
+
+
+def to_system_timezone(date):
+    return date.astimezone(pytz.timezone(settings.TIME_ZONE))
+
+
+def now_user_timezone(profile):
+    timezone.activate(pytz.timezone(profile.timezone))
+    return timezone.localtime(timezone.now())
+
+
+def start_of_day(dt, profile) -> datetime:
+    """Get the start of the day in the profile's timezone"""
+    timezone = profile.timezone if profile.timezone else settings.TIME_ZONE
+    tzinfo = pytz.timezone(timezone)
+    return datetime.combine(dt, datetime.min.time(), tzinfo)
+
+
+def end_of_day(dt, profile) -> datetime:
+    """Get the start of the day in the profile's timezone"""
+    timezone = profile.timezone if profile.timezone else settings.TIME_ZONE
+    tzinfo = pytz.timezone(timezone)
+    return datetime.combine(dt, datetime.max.time(), tzinfo)
+
+
+def start_of_week(dt, profile) -> datetime:
+    # TODO allow profile to set start of week
+    return start_of_day(dt, profile) - timedelta(dt.weekday())
+
+
+def end_of_week(dt, profile) -> datetime:
+    # TODO allow profile to set start of week
+    return start_of_week(dt, profile) + timedelta(days=6)
+
+
+def start_of_month(dt, profile) -> datetime:
+    return start_of_day(dt, profile).replace(day=1)
+
+
+def end_of_month(dt, profile) -> datetime:
+    next_month = end_of_day(dt, profile).replace(day=28) + timedelta(days=4)
+    # subtracting the number of the current day brings us back one month
+    return next_month - timedelta(days=next_month.day)
+
+
+def start_of_year(dt, profile) -> datetime:
+    return start_of_day(dt, profile).replace(month=1, day=1)
--- a/vrobbler/apps/scrobbles/admin.py
+++ b/vrobbler/apps/scrobbles/admin.py
@ -1,20 +1,108 @@
 from django.contrib import admin
-
-from scrobbles.models import Scrobble
+from scrobbles.models import (
+    AudioScrobblerTSVImport,
+    ChartRecord,
+    KoReaderImport,
+    LastFmImport,
+    Scrobble,
+)


+class ScrobbleInline(admin.TabularInline):
+    model = Scrobble
+    extra = 0
+    raw_id_fields = ('video', 'podcast_episode', 'track')
+    exclude = ('source_id', 'scrobble_log')
+
+
+class ImportBaseAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = (
+        "uuid",
+        "process_count",
+        "processed_finished",
+        "processing_started",
+    )
+    ordering = ("-created",)
+
+
+@admin.register(AudioScrobblerTSVImport)
+class AudioScrobblerTSVImportAdmin(ImportBaseAdmin):
+    """"""
+
+
+@admin.register(LastFmImport)
+class LastFmImportAdmin(ImportBaseAdmin):
+    """"""
+
+
+@admin.register(KoReaderImport)
+class KoReaderImportAdmin(ImportBaseAdmin):
+    """"""
+
+
+@admin.register(ChartRecord)
+class ChartRecordAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = (
+        "user",
+        "rank",
+        "count",
+        "year",
+        "week",
+        "month",
+        "day",
+        "media_name",
+    )
+    ordering = ("-created",)
+
+    def media_name(self, obj):
+        if obj.video:
+            return obj.video
+        if obj.track:
+            return obj.track
+        if obj.podcast_episode:
+            return obj.podcast_episode
+        if obj.sport_event:
+            return obj.sport_event
+
+
+@admin.register(Scrobble)
 class ScrobbleAdmin(admin.ModelAdmin):
    date_hierarchy = "timestamp"
    list_display = (
        "timestamp",
-        "video",
-        "track",
+        "media_name",
+        "media_type",
+        "playback_percent",
        "source",
-        "playback_position",
        "in_progress",
+        "is_paused",
+        "played_to_completion",
    )
-    list_filter = ("in_progress", "source")
+    raw_id_fields = (
+        'video',
+        'podcast_episode',
+        'track',
+        'sport_event',
+        'book',
+    )
+    list_filter = ("is_paused", "in_progress", "source", "track__artist")
    ordering = ("-timestamp",)

+    def media_name(self, obj):
+        return obj.media_obj

-admin.site.register(Scrobble, ScrobbleAdmin)
+    def media_type(self, obj):
+        return obj.media_obj.__class__.__name__
+        if obj.video:
+            return "Video"
+        if obj.track:
+            return "Track"
+        if obj.podcast_episode:
+            return "Podcast"
+        if obj.sport_event:
+            return "Sport Event"
+
+    def playback_percent(self, obj):
+        return obj.percent_played
--- a/vrobbler/apps/scrobbles/api/init.py
+++ b/vrobbler/apps/scrobbles/api/init.py
--- a/vrobbler/apps/scrobbles/api/serializers.py
+++ b/vrobbler/apps/scrobbles/api/serializers.py
@ -0,0 +1,33 @@
+from rest_framework import serializers
+from scrobbles.models import (
+    AudioScrobblerTSVImport,
+    KoReaderImport,
+    LastFmImport,
+    Scrobble,
+)
+
+
+class ScrobbleSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Scrobble
+        fields = "__all__"
+
+
+class KoReaderImportSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = KoReaderImport
+        fields = "__all__"
+
+
+class AudioScrobblerTSVImportSerializer(
+    serializers.HyperlinkedModelSerializer
+):
+    class Meta:
+        model = AudioScrobblerTSVImport
+        fields = "__all__"
+
+
+class LastFmImportSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = LastFmImport
+        fields = "__all__"
--- a/vrobbler/apps/scrobbles/api/views.py
+++ b/vrobbler/apps/scrobbles/api/views.py
@ -0,0 +1,49 @@
+from rest_framework import permissions, viewsets
+from scrobbles.api.serializers import (
+    AudioScrobblerTSVImportSerializer,
+    KoReaderImportSerializer,
+    LastFmImportSerializer,
+    ScrobbleSerializer,
+)
+from scrobbles.models import (
+    AudioScrobblerTSVImport,
+    KoReaderImport,
+    Scrobble,
+    LastFmImport,
+)
+
+
+class ScrobbleViewSet(viewsets.ModelViewSet):
+    queryset = Scrobble.objects.all().order_by('-timestamp')
+    serializer_class = ScrobbleSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get_queryset(self):
+        return super().get_queryset().filter(user=self.request.user)
+
+
+class KoReaderImportViewSet(viewsets.ModelViewSet):
+    queryset = KoReaderImport.objects.all().order_by('-created')
+    serializer_class = KoReaderImportSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get_queryset(self):
+        return super().get_queryset().filter(user=self.request.user)
+
+
+class AudioScrobblerTSVImportViewSet(viewsets.ModelViewSet):
+    queryset = AudioScrobblerTSVImport.objects.all().order_by('-created')
+    serializer_class = AudioScrobblerTSVImportSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get_queryset(self):
+        return super().get_queryset().filter(user=self.request.user)
+
+
+class LastFmImportViewSet(viewsets.ModelViewSet):
+    queryset = LastFmImport.objects.all().order_by('-created')
+    serializer_class = LastFmImportSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get_queryset(self):
+        return super().get_queryset().filter(user=self.request.user)
--- a/vrobbler/apps/scrobbles/constants.py
+++ b/vrobbler/apps/scrobbles/constants.py
@ -1,3 +1,2 @@
-#!/usr/bin/env python3
 JELLYFIN_VIDEO_ITEM_TYPES = ["Episode", "Movie"]
 JELLYFIN_AUDIO_ITEM_TYPES = ["Audio"]
--- a/vrobbler/apps/scrobbles/context_processors.py
+++ b/vrobbler/apps/scrobbles/context_processors.py
@ -0,0 +1,17 @@
+import pytz
+from django.utils import timezone
+from scrobbles.models import Scrobble
+
+
+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,
+        )
+    }
--- a/vrobbler/apps/scrobbles/export.py
+++ b/vrobbler/apps/scrobbles/export.py
@ -0,0 +1,67 @@
+import csv
+import tempfile
+from scrobbles.models import Scrobble
+
+from django.db.models import Q
+
+
+def export_scrobbles(start_date=None, end_date=None, format="AS"):
+    start_query = Q()
+    end_query = Q()
+    if start_date:
+        start_query = Q(timestamp__gte=start_date)
+    if start_date:
+        end_query = Q(timestamp__lte=end_date)
+
+    scrobble_qs = Scrobble.objects.filter(
+        start_query, end_query, track__isnull=False
+    )
+    headers = []
+    extension = 'tsv'
+    delimiter = '\t'
+
+    if format == "as":
+        headers = [
+            ['#AUDIOSCROBBLER/1.1'],
+            ['#TZ/UTC'],
+            ['#CLIENT/Vrobbler 1.0.0'],
+        ]
+
+    if format == "csv":
+        delimiter = ','
+        extension = 'csv'
+        headers = [
+            [
+                "artists",
+                "album",
+                "title",
+                "track_number",
+                "run_time",
+                "rating",
+                "timestamp",
+                "musicbrainz_id",
+            ]
+        ]
+
+    with tempfile.NamedTemporaryFile(mode='w', delete=False) as outfile:
+        writer = csv.writer(outfile, delimiter=delimiter)
+        for row in headers:
+            writer.writerow(row)
+
+        for scrobble in scrobble_qs:
+            track = scrobble.track
+            track_number = 0  # TODO Add track number
+            track_rating = "S"  # TODO implement ratings?
+            track_artist = track.artist or track.album.primary_artist
+            row = [
+                track_artist,
+                track.album.name,
+                track.title,
+                track_number,
+                track.run_time,
+                track_rating,
+                scrobble.timestamp.strftime('%s'),
+                track.musicbrainz_id,
+            ]
+            writer.writerow(row)
+        return outfile.name, extension
--- a/vrobbler/apps/scrobbles/forms.py
+++ b/vrobbler/apps/scrobbles/forms.py
@ -0,0 +1,25 @@
+from django import forms
+
+
+class ExportScrobbleForm(forms.Form):
+    """Provide options for downloading scrobbles"""
+
+    EXPORT_TYPES = (
+        ('as', 'Audioscrobbler'),
+        ('csv', 'CSV'),
+        ('html', 'HTML'),
+    )
+    export_type = forms.ChoiceField(choices=EXPORT_TYPES)
+
+
+class ScrobbleForm(forms.Form):
+    item_id = forms.CharField(
+        label="",
+        widget=forms.TextInput(
+            attrs={
+                'class': "form-control form-control-dark w-100",
+                'placeholder': "Scrobble something (IMDB ID, String, TVDB ID ...)",
+                'aria-label': "Scrobble something",
+            }
+        ),
+    )
--- a/vrobbler/apps/scrobbles/imdb.py
+++ b/vrobbler/apps/scrobbles/imdb.py
@ -0,0 +1,61 @@
+import logging
+from django.utils import timezone
+
+from imdb import Cinemagoer
+
+imdb_client = Cinemagoer()
+
+logger = logging.getLogger(__name__)
+
+
+def lookup_video_from_imdb(imdb_id: str) -> dict:
+
+    if 'tt' not in imdb_id:
+        logger.warning(f"IMDB ID should begin with 'tt' {imdb_id}")
+        return
+
+    lookup_id = imdb_id.strip('tt')
+    media = imdb_client.get_movie(lookup_id)
+
+    run_time_seconds = 60 * 60
+    runtimes = media.get("runtimes")
+    if runtimes:
+        run_time_seconds = int(runtimes[0]) * 60
+
+    # Ticks otherwise known as miliseconds
+    run_time_ticks = run_time_seconds * 1000 * 1000
+
+    item_type = "Movie"
+    if media.get('series title'):
+        item_type = "Episode"
+
+    try:
+        plot = media.get('plot')[0]
+    except TypeError:
+        plot = ""
+    except IndexError:
+        plot = ""
+
+    logger.debug(f"Received data from IMDB: {media.__dict__}")
+    # Build a rough approximation of a Jellyfin data response
+    data_dict = {
+        "ItemType": item_type,
+        "Name": media.get('title'),
+        "Overview": plot,
+        "Tagline": media.get('tagline'),
+        "Year": media.get('year'),
+        "Provider_imdb": imdb_id,
+        "RunTime": run_time_seconds,
+        "RunTimeTicks": run_time_ticks,
+        "SeriesName": media.get('series title'),
+        "EpisodeNumber": media.get('episode'),
+        "SeasonNumber": media.get('season'),
+        "PlaybackPositionTicks": 1,
+        "PlaybackPosition": 1,
+        "UtcTimestamp": timezone.now().strftime('%Y-%m-%d %H:%M:%S.%f%z'),
+        "IsPaused": False,
+        "PlayedToCompletion": False,
+    }
+    logger.debug(f"Parsed data from IMDB data: {data_dict}")
+
+    return data_dict
--- a/vrobbler/apps/scrobbles/koreader.py
+++ b/vrobbler/apps/scrobbles/koreader.py
@ -0,0 +1,124 @@
+import logging
+from datetime import datetime
+import sqlite3
+from enum import Enum
+
+import pytz
+
+from books.models import Author, Book
+from scrobbles.models import Scrobble
+from django.utils import timezone
+
+logger = logging.getLogger(__name__)
+
+
+class KoReaderBookColumn(Enum):
+    ID = 0
+    TITLE = 1
+    AUTHORS = 2
+    NOTES = 3
+    LAST_OPEN = 4
+    HIGHLIGHTS = 5
+    PAGES = 6
+    SERIES = 7
+    LANGUAGE = 8
+    MD5 = 9
+    TOTAL_READ_TIME = 10
+    TOTAL_READ_PAGES = 11
+
+
+class KoReaderPageStatColumn(Enum):
+    ID_BOOK = 0
+    PAGE = 1
+    START_TIME = 2
+    DURATION = 3
+    TOTAL_PAGES = 4
+
+
+def process_koreader_sqlite_file(sqlite_file_path, user_id):
+    """Given a sqlite file from KoReader, open the book table, iterate
+    over rows creating scrobbles from each book found"""
+    # Create a SQL connection to our SQLite database
+    con = sqlite3.connect(sqlite_file_path)
+    cur = con.cursor()
+
+    # Return all results of query
+    book_table = cur.execute("SELECT * FROM book")
+    new_scrobbles = []
+    for book_row in book_table:
+        authors = book_row[KoReaderBookColumn.AUTHORS.value].split('\n')
+        author_list = []
+        for author_str in authors:
+            logger.debug(f"Looking up author {author_str}")
+
+            if author_str == "N/A":
+                continue
+
+            author, created = Author.objects.get_or_create(name=author_str)
+            if created:
+                author.fix_metadata()
+            author_list.append(author)
+            logger.debug(f"Found author {author}, created: {created}")
+
+        book, created = Book.objects.get_or_create(
+            koreader_md5=book_row[KoReaderBookColumn.MD5.value]
+        )
+
+        if created:
+            book.title = book_row[KoReaderBookColumn.TITLE.value]
+            book.pages = book_row[KoReaderBookColumn.PAGES.value]
+            book.koreader_id = int(book_row[KoReaderBookColumn.ID.value])
+            book.koreader_authors = book_row[KoReaderBookColumn.AUTHORS.value]
+            book.run_time_ticks = int(book_row[KoReaderBookColumn.PAGES.value])
+            book.save(
+                update_fields=[
+                    "title",
+                    "pages",
+                    "koreader_id",
+                    "koreader_authors",
+                ]
+            )
+            book.fix_metadata()
+            if author_list:
+                book.authors.add(*[a.id for a in author_list])
+
+        playback_position = int(
+            book_row[KoReaderBookColumn.TOTAL_READ_TIME.value]
+        )
+        playback_position_ticks = playback_position * 1000
+        pages_read = int(book_row[KoReaderBookColumn.TOTAL_READ_PAGES.value])
+        timestamp = datetime.utcfromtimestamp(
+            book_row[KoReaderBookColumn.LAST_OPEN.value]
+        ).replace(tzinfo=pytz.utc)
+
+        new_scrobble = Scrobble(
+            book_id=book.id,
+            user_id=user_id,
+            source="KOReader",
+            timestamp=timestamp,
+            playback_position_ticks=playback_position_ticks,
+            playback_position=playback_position,
+            played_to_completion=True,
+            in_progress=False,
+            book_pages_read=pages_read,
+        )
+
+        existing = Scrobble.objects.filter(
+            timestamp=timestamp, book=book
+        ).first()
+        if existing:
+            logger.debug(f"Skipping existing scrobble {new_scrobble}")
+            continue
+
+        logger.debug(f"Queued scrobble {new_scrobble} for creation")
+        new_scrobbles.append(new_scrobble)
+
+    # Be sure to close the connection
+    con.close()
+
+    created = Scrobble.objects.bulk_create(new_scrobbles)
+    logger.info(
+        f"Created {len(created)} scrobbles",
+        extra={'created_scrobbles': created},
+    )
+    return created
--- a/vrobbler/apps/scrobbles/lastfm.py
+++ b/vrobbler/apps/scrobbles/lastfm.py
@ -0,0 +1,146 @@
+import logging
+import time
+from datetime import datetime, timedelta
+
+import pylast
+import pytz
+from django.conf import settings
+from django.utils import timezone
+from music.utils import (
+    get_or_create_album,
+    get_or_create_artist,
+    get_or_create_track,
+)
+
+logger = logging.getLogger(__name__)
+
+PYLAST_ERRORS = tuple(
+    getattr(pylast, exc_name)
+    for exc_name in (
+        "ScrobblingError",
+        "NetworkError",
+        "MalformedResponseError",
+        "WSError",
+    )
+    if hasattr(pylast, exc_name)
+)
+
+
+class LastFM:
+    def __init__(self, user):
+        try:
+            self.client = pylast.LastFMNetwork(
+                api_key=getattr(settings, "LASTFM_API_KEY"),
+                api_secret=getattr(settings, "LASTFM_SECRET_KEY"),
+                username=user.profile.lastfm_username,
+                password_hash=pylast.md5(user.profile.lastfm_password),
+            )
+            self.user = self.client.get_user(user.profile.lastfm_username)
+            self.vrobbler_user = user
+        except PYLAST_ERRORS as e:
+            logger.error(f"Error during Last.fm setup: {e}")
+
+    def import_from_lastfm(self, last_processed=None):
+        """Given a last processed time, import all scrobbles from LastFM since then"""
+        from scrobbles.models import Scrobble
+
+        new_scrobbles = []
+        source = "Last.fm"
+        source_id = ""
+        lastfm_scrobbles = self.get_last_scrobbles(time_from=last_processed)
+
+        for lfm_scrobble in lastfm_scrobbles:
+            timestamp = lfm_scrobble.pop('timestamp')
+
+            artist = get_or_create_artist(lfm_scrobble.pop('artist'))
+            album = get_or_create_album(lfm_scrobble.pop('album'), artist)
+
+            lfm_scrobble['artist'] = artist
+            lfm_scrobble['album'] = album
+            track = get_or_create_track(**lfm_scrobble)
+
+            new_scrobble = Scrobble(
+                user=self.vrobbler_user,
+                timestamp=timestamp,
+                source=source,
+                source_id=source_id,
+                track=track,
+                played_to_completion=True,
+                in_progress=False,
+            )
+            # Vrobbler scrobbles on finish, LastFM scrobbles on start
+            seconds_eariler = timestamp - timedelta(seconds=20)
+            seconds_later = timestamp + timedelta(seconds=20)
+            existing = Scrobble.objects.filter(
+                created__gte=seconds_eariler,
+                created__lte=seconds_later,
+                track=track,
+            ).first()
+            if existing:
+                logger.debug(f"Skipping existing scrobble {new_scrobble}")
+                continue
+            logger.debug(f"Queued scrobble {new_scrobble} for creation")
+            new_scrobbles.append(new_scrobble)
+
+        created = Scrobble.objects.bulk_create(new_scrobbles)
+        logger.info(
+            f"Created {len(created)} scrobbles",
+            extra={'created_scrobbles': created},
+        )
+        return created
+
+    def get_last_scrobbles(self, time_from=None, time_to=None):
+        """Given a user, Last.fm api key, and secret key, grab a list of scrobbled
+        tracks"""
+        lfm_params = {}
+        scrobbles = []
+        if time_from:
+            lfm_params["time_from"] = int(time_from.timestamp())
+        if time_to:
+            lfm_params["time_to"] = int(time_to.timestamp())
+
+        # if not time_from and not time_to:
+        lfm_params['limit'] = None
+
+        found_scrobbles = self.user.get_recent_tracks(**lfm_params)
+        # TOOD spin this out into a celery task over certain threshold of found scrobbles?
+
+        for scrobble in found_scrobbles:
+            run_time = None
+            run_time_ticks = None
+            mbid = None
+            artist = None
+
+            try:
+                run_time_ticks = scrobble.track.get_duration()
+                run_time = int(run_time_ticks / 1000)
+                mbid = scrobble.track.get_mbid()
+                artist = scrobble.track.get_artist().name
+            except pylast.MalformedResponseError as e:
+                logger.warn(e)
+            except pylast.WSError as e:
+                logger.warn(
+                    "LastFM barfed trying to get the track for {scrobble.track}"
+                )
+
+            if not artist:
+                logger.warn(f"Silly LastFM, no artist found for {scrobble}")
+                continue
+
+            timestamp = datetime.utcfromtimestamp(
+                int(scrobble.timestamp)
+            ).replace(tzinfo=pytz.utc)
+
+            logger.info(f"{artist},{scrobble.track.title},{timestamp}")
+            scrobbles.append(
+                {
+                    "artist": artist,
+                    "album": scrobble.album,
+                    "title": scrobble.track.title,
+                    "mbid": mbid,
+                    "run_time": run_time,
+                    "run_time_ticks": run_time_ticks,
+                    "timestamp": timestamp,
+                }
+            )
+        return scrobbles
--- a/vrobbler/apps/scrobbles/migrations/0007_scrobble_podcast_episode.py
+++ b/vrobbler/apps/scrobbles/migrations/0007_scrobble_podcast_episode.py
@ -0,0 +1,25 @@
+# Generated by Django 4.1.5 on 2023-01-12 17:48
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0002_episode_run_time_episode_run_time_ticks_and_more'),
+        ('scrobbles', '0006_scrobble_track_alter_scrobble_video'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='scrobble',
+            name='podcast_episode',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='podcasts.episode',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0008_scrobble_sport_event.py
+++ b/vrobbler/apps/scrobbles/migrations/0008_scrobble_sport_event.py
@ -0,0 +1,25 @@
+# Generated by Django 4.1.5 on 2023-01-14 21:23
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sports', '0002_rename_start_utc_sportevent_start'),
+        ('scrobbles', '0007_scrobble_podcast_episode'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='scrobble',
+            name='sport_event',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='sports.sportevent',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0009_scrobble_uuid.py
+++ b/vrobbler/apps/scrobbles/migrations/0009_scrobble_uuid.py
@ -0,0 +1,35 @@
+# Generated by Django 4.1.5 on 2023-01-20 18:40
+
+from uuid import uuid4
+from django.db import migrations, models
+
+
+def generate_uuids(apps, schema_editor):
+    """Force uuid generation for old scrobbles"""
+    Scrobble = apps.get_model('scrobbles', 'Scrobble')
+    for scrobble in Scrobble.objects.all():
+        if not scrobble.uuid:
+            scrobble.uuid = uuid4()
+            scrobble.save(update_fields=['uuid'])
+
+
+def reverse_generate_uuids(apps, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0008_scrobble_sport_event'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='scrobble',
+            name='uuid',
+            field=models.UUIDField(blank=True, editable=False, null=True),
+        ),
+        migrations.RunPython(
+            code=generate_uuids, reverse_code=reverse_generate_uuids
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0010_chartrecord.py
+++ b/vrobbler/apps/scrobbles/migrations/0010_chartrecord.py
@ -0,0 +1,88 @@
+# Generated by Django 4.1.5 on 2023-01-30 17:01
+
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0009_alter_track_musicbrainz_id_and_more'),
+        ('videos', '0006_alter_video_year'),
+        ('scrobbles', '0009_scrobble_uuid'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ChartRecord',
+            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'
+                    ),
+                ),
+                ('rank', models.IntegerField()),
+                ('year', models.IntegerField(default=2023)),
+                ('month', models.IntegerField(blank=True, null=True)),
+                ('week', models.IntegerField(blank=True, null=True)),
+                ('day', models.IntegerField(blank=True, null=True)),
+                (
+                    'artist',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='music.artist',
+                    ),
+                ),
+                (
+                    'series',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='videos.series',
+                    ),
+                ),
+                (
+                    'track',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='music.track',
+                    ),
+                ),
+                (
+                    'video',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='videos.video',
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0011_chartrecord_user.py
+++ b/vrobbler/apps/scrobbles/migrations/0011_chartrecord_user.py
@ -0,0 +1,26 @@
+# Generated by Django 4.1.5 on 2023-01-30 17:44
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('scrobbles', '0010_chartrecord'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='chartrecord',
+            name='user',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0012_audioscrobblertsvimport.py
+++ b/vrobbler/apps/scrobbles/migrations/0012_audioscrobblertsvimport.py
@ -0,0 +1,52 @@
+# Generated by Django 4.1.5 on 2023-02-03 19:50
+
+from django.db import migrations, models
+import django_extensions.db.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0011_chartrecord_user'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AudioScrobblerTSVImport',
+            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'
+                    ),
+                ),
+                (
+                    'tsv_file',
+                    models.FileField(
+                        blank=True,
+                        null=True,
+                        upload_to='audioscrobbler-uploads/%Y/%m-%d/',
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0013_audioscrobblertsvimport_processed_on.py
+++ b/vrobbler/apps/scrobbles/migrations/0013_audioscrobblertsvimport_processed_on.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-02-03 20:20
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0012_audioscrobblertsvimport'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='processed_on',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0014_audioscrobblertsvimport_process_log.py
+++ b/vrobbler/apps/scrobbles/migrations/0014_audioscrobblertsvimport_process_log.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-02-03 22:53
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0013_audioscrobblertsvimport_processed_on'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='process_log',
+            field=models.TextField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0015_audioscrobblertsvimport_uuid_and_more.py
+++ b/vrobbler/apps/scrobbles/migrations/0015_audioscrobblertsvimport_uuid_and_more.py
@ -0,0 +1,29 @@
+# Generated by Django 4.1.5 on 2023-02-03 23:36
+
+from django.db import migrations, models
+import scrobbles.models
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0014_audioscrobblertsvimport_process_log'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='uuid',
+            field=models.UUIDField(default=uuid.uuid4, editable=False),
+        ),
+        migrations.AlterField(
+            model_name='audioscrobblertsvimport',
+            name='tsv_file',
+            field=models.FileField(
+                blank=True,
+                null=True,
+                upload_to=scrobbles.models.AudioScrobblerTSVImport.get_path,
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0016_audioscrobblertsvimport_process_count.py
+++ b/vrobbler/apps/scrobbles/migrations/0016_audioscrobblertsvimport_process_count.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-02-03 23:44
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0015_audioscrobblertsvimport_uuid_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='process_count',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0017_audioscrobblertsvimport_user.py
+++ b/vrobbler/apps/scrobbles/migrations/0017_audioscrobblertsvimport_user.py
@ -0,0 +1,26 @@
+# Generated by Django 4.1.5 on 2023-02-07 00:07
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('scrobbles', '0016_audioscrobblertsvimport_process_count'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='user',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0018_lastfmimport.py
+++ b/vrobbler/apps/scrobbles/migrations/0018_lastfmimport.py
@ -0,0 +1,61 @@
+# Generated by Django 4.1.5 on 2023-02-13 06:43
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('scrobbles', '0017_audioscrobblertsvimport_user'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='LastFmImport',
+            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)),
+                ('processed_on', models.DateTimeField(blank=True, null=True)),
+                ('process_log', models.TextField(blank=True, null=True)),
+                ('process_count', models.IntegerField(blank=True, null=True)),
+                (
+                    'user',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0019_rename_processed_on_lastfmimport_processed_finished_and_more.py
+++ b/vrobbler/apps/scrobbles/migrations/0019_rename_processed_on_lastfmimport_processed_finished_and_more.py
@ -0,0 +1,23 @@
+# Generated by Django 4.1.5 on 2023-02-16 17:13
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0018_lastfmimport'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='lastfmimport',
+            old_name='processed_on',
+            new_name='processed_finished',
+        ),
+        migrations.AddField(
+            model_name='lastfmimport',
+            name='processing_started',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0020_alter_audioscrobblertsvimport_options_and_more.py
+++ b/vrobbler/apps/scrobbles/migrations/0020_alter_audioscrobblertsvimport_options_and_more.py
@ -0,0 +1,97 @@
+# Generated by Django 4.1.5 on 2023-02-19 03:53
+
+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 = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        (
+            'scrobbles',
+            '0019_rename_processed_on_lastfmimport_processed_finished_and_more',
+        ),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='audioscrobblertsvimport',
+            options={},
+        ),
+        migrations.AlterModelOptions(
+            name='lastfmimport',
+            options={},
+        ),
+        migrations.RenameField(
+            model_name='audioscrobblertsvimport',
+            old_name='processed_on',
+            new_name='processed_finished',
+        ),
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='processing_started',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+        migrations.CreateModel(
+            name='KoReaderImport',
+            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)),
+                (
+                    'sqlite_file',
+                    models.FileField(
+                        blank=True,
+                        null=True,
+                        upload_to=scrobbles.models.KoReaderImport.get_path,
+                    ),
+                ),
+                (
+                    'user',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0021_scrobble_book.py
+++ b/vrobbler/apps/scrobbles/migrations/0021_scrobble_book.py
@ -0,0 +1,25 @@
+# Generated by Django 4.1.5 on 2023-02-19 20:20
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('books', '0001_initial'),
+        ('scrobbles', '0020_alter_audioscrobblertsvimport_options_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='scrobble',
+            name='book',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='books.book',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0022_scrobble_book_pages_read.py
+++ b/vrobbler/apps/scrobbles/migrations/0022_scrobble_book_pages_read.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-02-20 00:38
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0021_scrobble_book'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='scrobble',
+            name='book_pages_read',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0023_alter_audioscrobblertsvimport_options_and_more.py
+++ b/vrobbler/apps/scrobbles/migrations/0023_alter_audioscrobblertsvimport_options_and_more.py
@ -0,0 +1,30 @@
+# Generated by Django 4.1.5 on 2023-02-25 00:19
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0022_scrobble_book_pages_read'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='audioscrobblertsvimport',
+            options={'verbose_name': 'AudioScrobbler TSV Import'},
+        ),
+        migrations.AlterModelOptions(
+            name='koreaderimport',
+            options={'verbose_name': 'KOReader Import'},
+        ),
+        migrations.AlterModelOptions(
+            name='lastfmimport',
+            options={'verbose_name': 'Last.FM Import'},
+        ),
+        migrations.AddField(
+            model_name='chartrecord',
+            name='count',
+            field=models.IntegerField(default=0),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0024_chartrecord_period_end_chartrecord_period_start.py
+++ b/vrobbler/apps/scrobbles/migrations/0024_chartrecord_period_end_chartrecord_period_start.py
@ -0,0 +1,23 @@
+# Generated by Django 4.1.5 on 2023-03-03 00:43
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0023_alter_audioscrobblertsvimport_options_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='chartrecord',
+            name='period_end',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='chartrecord',
+            name='period_start',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/mixins.py
+++ b/vrobbler/apps/scrobbles/mixins.py
@ -0,0 +1,19 @@
+from uuid import uuid4
+
+from django.db import models
+from django_extensions.db.models import TimeStampedModel
+
+BNULL = {"blank": True, "null": True}
+
+
+class ScrobblableMixin(TimeStampedModel):
+    SECONDS_TO_STALE = 1600
+
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+    title = models.CharField(max_length=255, **BNULL)
+    run_time = models.CharField(max_length=8, **BNULL)
+    run_time_ticks = models.PositiveBigIntegerField(**BNULL)
+    # thumbs = models.IntegerField(default=Opinion.NEUTRAL, choices=Opinion.choices)
+
+    class Meta:
+        abstract = True
--- a/vrobbler/apps/scrobbles/models.py
+++ b/vrobbler/apps/scrobbles/models.py
@ -1,200 +1,611 @@
+import calendar
+import datetime
 import logging
-from datetime import timedelta
-from typing import Optional
+from uuid import uuid4

-from django.conf import settings
+from books.models import Book
 from django.contrib.auth import get_user_model
 from django.db import models
+from django.urls import reverse
 from django.utils import timezone
 from django_extensions.db.models import TimeStampedModel
-from music.models import Track
-from videos.models import Video
+from music.models import Artist, Track
+from podcasts.models import Episode
+from scrobbles.lastfm import LastFM
+from scrobbles.utils import check_scrobble_for_finish
+from sports.models import SportEvent
+from videos.models import Series, Video
+
+from vrobbler.apps.profiles.utils import (
+    end_of_day,
+    end_of_month,
+    end_of_week,
+    start_of_day,
+    start_of_month,
+    start_of_week,
+)
+from vrobbler.apps.scrobbles.stats import build_charts

 logger = logging.getLogger(__name__)
 User = get_user_model()
 BNULL = {"blank": True, "null": True}
-VIDEO_BACKOFF = getattr(settings, 'VIDEO_BACKOFF_MINUTES')
-TRACK_BACKOFF = getattr(settings, 'MUSIC_BACKOFF_SECONDS')
-VIDEO_WAIT_PERIOD = getattr(settings, 'VIDEO_WAIT_PERIOD_DAYS')
-TRACK_WAIT_PERIOD = getattr(settings, 'MUSIC_WAIT_PERIOD_MINUTES')
+
+
+class BaseFileImportMixin(TimeStampedModel):
+    user = models.ForeignKey(User, on_delete=models.DO_NOTHING, **BNULL)
+    uuid = models.UUIDField(editable=False, default=uuid4)
+    processing_started = models.DateTimeField(**BNULL)
+    processed_finished = models.DateTimeField(**BNULL)
+    process_log = models.TextField(**BNULL)
+    process_count = models.IntegerField(**BNULL)
+
+    class Meta:
+        abstract = True
+
+    def __str__(self):
+        return f"Scrobble import {self.id}"
+
+    @property
+    def human_start(self):
+        start = "Unknown"
+        if self.processing_started:
+            start = self.processing_started.strftime('%B %d, %Y at %H:%M')
+        return start
+
+    @property
+    def import_type(self) -> str:
+        class_name = self.__class__.__name__
+        if class_name == 'AudioscrobblerTSVImport':
+            return "Audioscrobbler"
+        if class_name == 'KoReaderImport':
+            return "KoReader"
+        if self.__class__.__name__ == 'LastFMImport':
+            return "LastFM"
+        return "Generic"
+
+    def process(self, force=False):
+        logger.warning("Process not implemented")
+
+    def undo(self, dryrun=False):
+        """Accepts the log from a scrobble import and removes the scrobbles"""
+        from scrobbles.models import Scrobble
+
+        if not self.process_log:
+
+            logger.warning("No lines in process log found to undo")
+            return
+
+        for line in self.process_log.split('\n'):
+            scrobble_id = line.split("\t")[0]
+            scrobble = Scrobble.objects.filter(id=scrobble_id).first()
+            if not scrobble:
+                logger.warning(
+                    f"Could not find scrobble {scrobble_id} to undo"
+                )
+                continue
+            logger.info(f"Removing scrobble {scrobble_id}")
+            if not dryrun:
+                scrobble.delete()
+        self.processed_finished = None
+        self.processing_started = None
+        self.process_count = None
+        self.process_log = ""
+        self.save(
+            update_fields=[
+                "processed_finished",
+                "processing_started",
+                "process_log",
+                "process_count",
+            ]
+        )
+
+    def mark_started(self):
+        self.processing_started = timezone.now()
+        self.save(update_fields=["processing_started"])
+
+    def mark_finished(self):
+        self.processed_finished = timezone.now()
+        self.save(update_fields=['processed_finished'])
+
+    def record_log(self, scrobbles):
+        self.process_log = ""
+        if not scrobbles:
+            self.process_count = 0
+            self.save(update_fields=["process_log", "process_count"])
+            return
+
+        for count, scrobble in enumerate(scrobbles):
+            scrobble_str = f"{scrobble.id}\t{scrobble.timestamp}\t{scrobble.media_obj.title}"
+            log_line = f"{scrobble_str}"
+            if count > 0:
+                log_line = "\n" + log_line
+            self.process_log += log_line
+        self.process_count = len(scrobbles)
+        self.save(update_fields=["process_log", "process_count"])
+
+
+class KoReaderImport(BaseFileImportMixin):
+    class Meta:
+        verbose_name = "KOReader Import"
+
+    def __str__(self):
+        return f"KoReader import on {self.human_start}"
+
+    def get_absolute_url(self):
+        return reverse(
+            'scrobbles:koreader-import-detail', kwargs={'slug': self.uuid}
+        )
+
+    def get_path(instance, filename):
+        extension = filename.split('.')[-1]
+        uuid = instance.uuid
+        return f'koreader-uploads/{uuid}.{extension}'
+
+    sqlite_file = models.FileField(upload_to=get_path, **BNULL)
+
+    def process(self, force=False):
+        from scrobbles.koreader import process_koreader_sqlite_file
+
+        if self.processed_finished and not force:
+            logger.info(
+                f"{self} already processed on {self.processed_finished}"
+            )
+            return
+
+        self.mark_started()
+        scrobbles = process_koreader_sqlite_file(
+            self.sqlite_file.path, self.user.id
+        )
+        self.record_log(scrobbles)
+        self.mark_finished()
+
+
+class AudioScrobblerTSVImport(BaseFileImportMixin):
+    class Meta:
+        verbose_name = "AudioScrobbler TSV Import"
+
+    def __str__(self):
+        return f"Audioscrobbler import on {self.human_start}"
+
+    def get_absolute_url(self):
+        return reverse(
+            'scrobbles:tsv-import-detail', kwargs={'slug': self.uuid}
+        )
+
+    def get_path(instance, filename):
+        extension = filename.split('.')[-1]
+        uuid = instance.uuid
+        return f'audioscrobbler-uploads/{uuid}.{extension}'
+
+    tsv_file = models.FileField(upload_to=get_path, **BNULL)
+
+    def process(self, force=False):
+        from scrobbles.tsv import process_audioscrobbler_tsv_file
+
+        if self.processed_finished and not force:
+            logger.info(
+                f"{self} already processed on {self.processed_finished}"
+            )
+            return
+
+        self.mark_started()
+
+        tz = None
+        if self.user:
+            tz = self.user.profile.tzinfo
+        scrobbles = process_audioscrobbler_tsv_file(
+            self.tsv_file.path, self.user.id, user_tz=tz
+        )
+        self.record_log(scrobbles)
+        self.mark_finished()
+
+
+class LastFmImport(BaseFileImportMixin):
+    class Meta:
+        verbose_name = "Last.FM Import"
+
+    def __str__(self):
+        return f"LastFM import on {self.human_start}"
+
+    def get_absolute_url(self):
+        return reverse(
+            'scrobbles:lastfm-import-detail', kwargs={'slug': self.uuid}
+        )
+
+    def process(self, import_all=False):
+        """Import scrobbles found on LastFM"""
+        if self.processed_finished:
+            logger.info(
+                f"{self} already processed on {self.processed_finished}"
+            )
+            return
+
+        last_import = None
+        if not import_all:
+            try:
+                last_import = LastFmImport.objects.exclude(id=self.id).last()
+            except:
+                pass
+
+        if not import_all and not last_import:
+            logger.warn(
+                "No previous import, to import all Last.fm scrobbles, pass import_all=True"
+            )
+            return
+
+        lastfm = LastFM(self.user)
+        last_processed = None
+        if last_import:
+            last_processed = last_import.processed_finished
+
+        self.mark_started()
+
+        scrobbles = lastfm.import_from_lastfm(last_processed)
+
+        self.record_log(scrobbles)
+        self.mark_finished()
+
+
+class ChartRecord(TimeStampedModel):
+    """Sort of like a materialized view for what we could dynamically generate,
+    but would kill the DB as it gets larger. Collects time-based records
+    generated by a cron-like archival job
+
+    1972 by Josh Rouse - #3 in 2023, January
+
+    """
+
+    user = models.ForeignKey(User, on_delete=models.DO_NOTHING, **BNULL)
+    rank = models.IntegerField()
+    count = models.IntegerField(default=0)
+    year = models.IntegerField(default=timezone.now().year)
+    month = models.IntegerField(**BNULL)
+    week = models.IntegerField(**BNULL)
+    day = models.IntegerField(**BNULL)
+    video = models.ForeignKey(Video, on_delete=models.DO_NOTHING, **BNULL)
+    series = models.ForeignKey(Series, on_delete=models.DO_NOTHING, **BNULL)
+    artist = models.ForeignKey(Artist, on_delete=models.DO_NOTHING, **BNULL)
+    track = models.ForeignKey(Track, on_delete=models.DO_NOTHING, **BNULL)
+    period_start = models.DateTimeField(**BNULL)
+    period_end = models.DateTimeField(**BNULL)
+
+    def save(self, *args, **kwargs):
+        profile = self.user.profile
+
+        if self.week:
+            # set start and end to start and end of week
+            period = datetime.date.fromisocalendar(self.year, self.week, 1)
+            self.period_start = start_of_week(period, profile)
+            self.period_start = end_of_week(period, profile)
+        if self.day:
+            period = datetime.datetime(self.year, self.month, self.day)
+            self.period_start = start_of_day(period, profile)
+            self.period_end = end_of_day(period, profile)
+        if self.month and not self.day:
+            period = datetime.datetime(self.year, self.month, 1)
+            self.period_start = start_of_month(period, profile)
+            self.period_end = end_of_month(period, profile)
+        super(ChartRecord, self).save(*args, **kwargs)
+
+    @property
+    def media_obj(self):
+        media_obj = None
+        if self.video:
+            media_obj = self.video
+        if self.track:
+            media_obj = self.track
+        if self.artist:
+            media_obj = self.artist
+        return media_obj
+
+    @property
+    def month_str(self) -> str:
+        month_str = ""
+        if self.month:
+            month_str = calendar.month_name[self.month]
+        return month_str
+
+    @property
+    def day_str(self) -> str:
+        day_str = ""
+        if self.day:
+            day_str = str(self.day)
+        return day_str
+
+    @property
+    def week_str(self) -> str:
+        week_str = ""
+        if self.week:
+            week_str = str(self.week)
+        return "Week " + week_str
+
+    @property
+    def period(self) -> str:
+        period = str(self.year)
+        if self.month:
+            period = " ".join([self.month_str, period])
+        if self.week:
+            period = " ".join([self.week_str, period])
+        if self.day:
+            period = " ".join([self.day_str, period])
+        return period
+
+    @property
+    def period_type(self) -> str:
+        period = 'year'
+        if self.month:
+            period = 'month'
+        if self.week:
+            period = 'week'
+        if self.day:
+            period = 'day'
+        return period
+
+    def __str__(self):
+        title = f"#{self.rank} in {self.period}"
+        if self.day or self.week:
+            title = f"#{self.rank} on {self.period}"
+        return title
+
+    def link(self):
+        get_params = f"?date={self.year}"
+        if self.week:
+            get_params = get_params = get_params + f"-W{self.week}"
+        if self.month:
+            get_params = get_params = get_params + f"-{self.month}"
+        if self.day:
+            get_params = get_params = get_params + f"-{self.day}"
+        if self.artist:
+            get_params = get_params + "&media=Artist"
+        return reverse('scrobbles:charts-home') + get_params
+
+    @classmethod
+    def build(cls, user, **kwargs):
+        build_charts(user=user, **kwargs)
+
+    @classmethod
+    def for_year(cls, user, year):
+        return cls.objects.filter(year=year, user=user)
+
+    @classmethod
+    def for_month(cls, user, year, month):
+        return cls.objects.filter(year=year, month=month, user=user)
+
+    @classmethod
+    def for_day(cls, user, year, day, month):
+        return cls.objects.filter(year=year, month=month, day=day, user=user)
+
+    @classmethod
+    def for_week(cls, user, year, week):
+        return cls.objects.filter(year=year, week=week, user=user)


 class Scrobble(TimeStampedModel):
+    """A scrobble tracks played media items by a user."""
+
+    uuid = models.UUIDField(editable=False, **BNULL)
    video = models.ForeignKey(Video, on_delete=models.DO_NOTHING, **BNULL)
    track = models.ForeignKey(Track, on_delete=models.DO_NOTHING, **BNULL)
+    podcast_episode = models.ForeignKey(
+        Episode, on_delete=models.DO_NOTHING, **BNULL
+    )
+    sport_event = models.ForeignKey(
+        SportEvent, on_delete=models.DO_NOTHING, **BNULL
+    )
+    book = models.ForeignKey(Book, on_delete=models.DO_NOTHING, **BNULL)
    user = models.ForeignKey(
        User, blank=True, null=True, on_delete=models.DO_NOTHING
    )
+
+    # Time keeping
    timestamp = models.DateTimeField(**BNULL)
    playback_position_ticks = models.PositiveBigIntegerField(**BNULL)
    playback_position = models.CharField(max_length=8, **BNULL)
+
+    # Status indicators
    is_paused = models.BooleanField(default=False)
    played_to_completion = models.BooleanField(default=False)
+    in_progress = models.BooleanField(default=True)
+
+    # Metadata
    source = models.CharField(max_length=255, **BNULL)
    source_id = models.TextField(**BNULL)
-    in_progress = models.BooleanField(default=True)
    scrobble_log = models.TextField(**BNULL)

+    # Fields for keeping track of reads between scrobbles
+    book_pages_read = models.IntegerField(**BNULL)
+
+    def save(self, *args, **kwargs):
+        if not self.uuid:
+            self.uuid = uuid4()
+
+        return super(Scrobble, self).save(*args, **kwargs)
+
+    @property
+    def status(self) -> str:
+        if self.is_paused:
+            return 'paused'
+        if self.played_to_completion:
+            return 'finished'
+        if self.in_progress:
+            return 'in-progress'
+        return 'zombie'
+
+    @property
+    def is_stale(self) -> bool:
+        """Mark scrobble as stale if it's been more than an hour since it was updated"""
+        is_stale = False
+        now = timezone.now()
+        seconds_since_last_update = (now - self.modified).seconds
+        if seconds_since_last_update >= self.media_obj.SECONDS_TO_STALE:
+            is_stale = True
+        return is_stale
+
    @property
    def percent_played(self) -> int:
-        if self.playback_position_ticks and self.media_run_time_ticks:
-            return int(
-                (self.playback_position_ticks / self.media_run_time_ticks)
-                * 100
-            )
-        # If we don't have media_run_time_ticks, let's guess from created time
-        now = timezone.now()
-        playback_duration = (now - self.created).seconds
-        if playback_duration and self.track.run_time:
-            return int((playback_duration / int(self.track.run_time)) * 100)
+        if not self.media_obj:
+            return 0

-        return 0
+        if self.media_obj and not self.media_obj.run_time_ticks:
+            return 100
+
+        if not self.playback_position_ticks and self.played_to_completion:
+            return 100
+
+        playback_ticks = self.playback_position_ticks
+        if not playback_ticks:
+            playback_ticks = (timezone.now() - self.timestamp).seconds * 1000
+
+        percent = int((playback_ticks / self.media_obj.run_time_ticks) * 100)
+        if percent > 100:
+            percent = 100
+        return percent

    @property
-    def media_run_time_ticks(self) -> int:
+    def can_be_updated(self) -> bool:
+        updatable = True
+        if self.percent_played > 100:
+            logger.info(f"No - 100% played - {self.id} - {self.source}")
+            updatable = False
+        if self.is_stale:
+            logger.info(f"No - stale - {self.id} - {self.source}")
+            updatable = False
+        return updatable
+
+    @property
+    def media_obj(self):
+        media_obj = None
        if self.video:
-            return self.video.run_time_ticks
+            media_obj = self.video
        if self.track:
-            return self.track.run_time_ticks
-        # this is hacky, but want to avoid divide by zero
-        return 1
-
-    def is_stale(self, backoff, wait_period) -> bool:
-        scrobble_is_stale = self.in_progress and self.modified > wait_period
-
-        # Check if found in progress scrobble is more than a day old
-        if scrobble_is_stale:
-            logger.info(
-                'Found a in-progress scrobble for this item more than a day old, creating a new scrobble'
-            )
-            delete_stale_scrobbles = getattr(
-                settings, "DELETE_STALE_SCROBBLES", True
-            )
-
-            if delete_stale_scrobbles:
-                logger.info(
-                    'Deleting {scrobble} that has been in-progress too long'
-                )
-                self.delete()
-
-        return scrobble_is_stale
+            media_obj = self.track
+        if self.podcast_episode:
+            media_obj = self.podcast_episode
+        if self.sport_event:
+            media_obj = self.sport_event
+        if self.book:
+            media_obj = self.book
+        return media_obj

    def __str__(self):
-        media = None
-        if self.video:
-            media = self.video
-        if self.track:
-            media = self.track
-
-        return (
-            f"Scrobble of {media} {self.timestamp.year}-{self.timestamp.month}"
-        )
+        timestamp = self.timestamp.strftime('%Y-%m-%d')
+        return f"Scrobble of {self.media_obj} ({timestamp})"

    @classmethod
-    def create_or_update_for_video(
-        cls, video: "Video", user_id: int, jellyfin_data: dict
+    def create_or_update(
+        cls, media, user_id: int, scrobble_data: dict
    ) -> "Scrobble":
-        jellyfin_data['video_id'] = video.id
-        logger.debug(
-            f"Creating or updating scrobble for video {video} with data {jellyfin_data}"
-        )
+
+        if media.__class__.__name__ == 'Track':
+            media_query = models.Q(track=media)
+            scrobble_data['track_id'] = media.id
+        if media.__class__.__name__ == 'Video':
+            media_query = models.Q(video=media)
+            scrobble_data['video_id'] = media.id
+        if media.__class__.__name__ == 'Episode':
+            media_query = models.Q(podcast_episode=media)
+            scrobble_data['podcast_episode_id'] = media.id
+        if media.__class__.__name__ == 'SportEvent':
+            media_query = models.Q(sport_event=media)
+            scrobble_data['sport_event_id'] = media.id
+        if media.__class__.__name__ == 'Book':
+            media_query = models.Q(book=media)
+            scrobble_data['book_id'] = media.id
+
        scrobble = (
-            cls.objects.filter(video=video, user_id=user_id)
+            cls.objects.filter(
+                media_query,
+                user_id=user_id,
+            )
            .order_by('-modified')
            .first()
        )
+        if scrobble and scrobble.can_be_updated:
+            logger.info(
+                f"Updating {scrobble.id}",
+                {"scrobble_data": scrobble_data, "media": media},
+            )
+            return scrobble.update(scrobble_data)

-        # Backoff is how long until we consider this a new scrobble
-        backoff = timezone.now() + timedelta(minutes=VIDEO_BACKOFF)
-        wait_period = timezone.now() + timedelta(days=VIDEO_WAIT_PERIOD)
-
-        return cls.update_or_create(
-            scrobble, backoff, wait_period, jellyfin_data
+        source = scrobble_data['source']
+        logger.info(
+            f"Creating for {media.id} - {source}",
+            {"scrobble_data": scrobble_data, "media": media},
        )
+        # If creating a new scrobble, we don't need status
+        scrobble_data.pop('mopidy_status', None)
+        scrobble_data.pop('jellyfin_status', None)
+        return cls.create(scrobble_data)

-    @classmethod
-    def create_or_update_for_track(
-        cls, track: "Track", user_id: int, scrobble_data: dict
-    ) -> "Scrobble":
-        scrobble_data['track_id'] = track.id
-        scrobble = (
-            cls.objects.filter(track=track, user_id=user_id)
-            .order_by('-modified')
-            .first()
-        )
-        logger.debug(
-            f"Found existing scrobble for track {track}, updating",
-            {"scrobble_data": scrobble_data},
-        )
-
-        backoff = timezone.now() + timedelta(seconds=TRACK_BACKOFF)
-        wait_period = timezone.now() + timedelta(minutes=TRACK_WAIT_PERIOD)
-
-        return cls.update_or_create(
-            scrobble, backoff, wait_period, scrobble_data
-        )
-
-    @classmethod
-    def update_or_create(
-        cls,
-        scrobble: Optional["Scrobble"],
-        backoff,
-        wait_period,
-        scrobble_data: dict,
-    ) -> Optional["Scrobble"]:
-
+    def update(self, scrobble_data: dict) -> "Scrobble":
        # Status is a field we get from Mopidy, which refuses to poll us
-        mopidy_status = scrobble_data.pop('status', None)
-        scrobble_is_stale = False
+        scrobble_status = scrobble_data.pop('mopidy_status', None)
+        if not scrobble_status:
+            scrobble_status = scrobble_data.pop('jellyfin_status', None)

-        if mopidy_status == "stopped":
-            logger.info(f"Mopidy sent a message to stop {scrobble}")
-            if not scrobble:
-                logger.warning(
-                    'Mopidy sent us a stopped message, without ever starting'
-                )
-                return
+        if self.percent_played < 100:
+            # Only worry about ticks if we haven't gotten to the end
+            self.update_ticks(scrobble_data)

-            # Mopidy finished a play, scrobble away
-            scrobble.in_progress = False
-            scrobble.save(update_fields=['in_progress'])
-            return scrobble
+        # On stop, stop progress and send it to the check for completion
+        if scrobble_status == "stopped":
+            self.stop()
+        # On pause, set is_paused and stop scrobbling
+        if scrobble_status == "paused":
+            self.pause()
+        if scrobble_status == "resumed":
+            self.resume()

-        if scrobble and not mopidy_status:
-            scrobble_is_finished = (
-                not scrobble.in_progress and scrobble.modified < backoff
-            )
-            if scrobble_is_finished:
-                logger.info(
-                    'Found a very recent scrobble for this item, holding off scrobbling again'
-                )
-                return
-
-            scrobble_is_stale = scrobble.is_stale(backoff, wait_period)
-
-        if (not scrobble or scrobble_is_stale) or mopidy_status:
-            # If we default this to "" we can probably remove this
-            scrobble_data['scrobble_log'] = ""
-            scrobble = cls.objects.create(
-                **scrobble_data,
-            )
-        else:
-            for key, value in scrobble_data.items():
-                setattr(scrobble, key, value)
-            scrobble.save()
-
-        # If we hit our completion threshold, save it and get ready
-        # to scrobble again if we re-watch this.
-        if scrobble.percent_played >= getattr(
-            settings, "PERCENT_FOR_COMPLETION", 95
-        ):
-            scrobble.in_progress = False
-            scrobble.playback_position_ticks = scrobble.media_run_time_ticks
-            scrobble.save()
-
-        if scrobble.percent_played % 5 == 0:
-            if getattr(settings, "KEEP_DETAILED_SCROBBLE_LOGS", False):
-                scrobble.scrobble_log += f"\n{str(scrobble.timestamp)} - {scrobble.playback_position} - {str(scrobble.playback_position_ticks)} - {str(scrobble.percent_played)}%"
-                scrobble.save(update_fields=['scrobble_log'])
+        for key, value in scrobble_data.items():
+            setattr(self, key, value)
+        self.save()
+        return self

+    @classmethod
+    def create(
+        cls,
+        scrobble_data: dict,
+    ) -> "Scrobble":
+        scrobble_data['scrobble_log'] = ""
+        scrobble = cls.objects.create(
+            **scrobble_data,
+        )
        return scrobble
+
+    def stop(self, force_finish=False) -> None:
+        if not self.in_progress:
+            return
+        self.in_progress = False
+        self.save(update_fields=['in_progress'])
+        logger.info(f"{self.id} - {self.source}")
+        check_scrobble_for_finish(self, force_finish)
+
+    def pause(self) -> None:
+        if self.is_paused:
+            logger.warning(f"{self.id} - already paused - {self.source}")
+            return
+        self.is_paused = True
+        self.save(update_fields=["is_paused"])
+        logger.info(f"{self.id} - pausing - {self.source}")
+        check_scrobble_for_finish(self)
+
+    def resume(self) -> None:
+        if self.is_paused or not self.in_progress:
+            self.is_paused = False
+            self.in_progress = True
+            logger.info(f"{self.id} - resuming - {self.source}")
+            return self.save(update_fields=["is_paused", "in_progress"])
+
+    def cancel(self) -> None:
+        check_scrobble_for_finish(self, force_finish=True)
+        self.delete()
+
+    def update_ticks(self, data) -> None:
+        self.playback_position_ticks = data.get("playback_position_ticks")
+        self.playback_position = data.get("playback_position")
+        logger.info(
+            f"{self.id} - {self.playback_position_ticks} - {self.source}"
+        )
+        self.save(
+            update_fields=['playback_position_ticks', 'playback_position']
+        )
--- a/Show More
+++ b/Show More