Bump version to 0.12.0

Version 1.0 approaches!
2023-03-02 15:10:58 -05:00
958 changed files with 5954 additions and 81445 deletions
--- a/.drone.yml
+++ b/.drone.yml
@ -4,79 +4,25 @@
 ################

 kind: pipeline
-name: build & deploy
+name: run_tests

 steps:
  # Run tests against Python/Flask engine backend (with pytest)
  - name: pytest with coverage
-    image: python:3.11.1
+    image: python:3.10.4
    commands:
      # Install dependencies
      - cp vrobbler.conf.test vrobbler.conf
      - pip install poetry
-      - poetry install --with test
+      - poetry install
      # Start with a fresh database (which is already running as a service from Drone)
-      - poetry run pytest -n 5 --cov-report term:skip-covered --cov=vrobbler tests
+      - poetry run pytest --cov-report term:skip-covered --cov=vrobbler tests
    environment:
      VROBBLER_DATABASE_URL: sqlite:///test.db
    volumes:
      # Mount pip cache from host
      - name: pip_cache
        path: /root/.cache/pip
-  - name: deploy
-    image: appleboy/drone-ssh
-    settings:
-      host:
-        - vrobbler.service
-      username: root
-      ssh_key:
-        from_secret: jail_key
-      command_timeout: 2m
-      script:
-        - pip uninstall -y vrobbler
-        - pip install git+https://code.lab.unbl.ink/secstate/vrobbler.git@main
-        - vrobbler migrate
-        - vrobbler collectstatic --noinput
-        - immortalctl restart celery && immortalctl restart vrobbler
-    when:
-      ref:
-        - refs/tags/*
-  - name: build success notification
-    image: parrazam/drone-ntfy:0.3-linux-amd64
-    when:
-        status: [success]
-    settings:
-      url: https://ntfy.unbl.ink
-      topic: drone
-      priority: low
-      tags:
-        - success
-        - vrobbler
-      actions:
-        - action: view
-          label: Changes
-          url: "{{ .Commit.Link }}"
-        - action: view
-          label: Build
-          url: "{{ .Build.Link }}"
-  - name: build failure notification
-    image: parrazam/drone-ntfy:0.3-linux-amd64
-    when:
-        status: [failure]
-    settings:
-      url: https://ntfy.unbl.ink
-      topic: drone
-      priority: high
-      tags:
-        - failure
-        - vrobbler
-      actions:
-        - action: view
-          label: Changes
-          url: "{{ .Commit.Link }}"
-        - action: view
-          label: Build
-          url: "{{ .Build.Link }}"
 volumes:
  - name: docker
    host:
--- a/.gitea/workflows/ci.yml
+++ b/.gitea/workflows/ci.yml
@ -1,162 +0,0 @@
-name: ci
-
-on:
-  push:
-    branches: ["**"]
-    tags: ["*"]
-  pull_request:
-
-concurrency:
-  group: ${{ gitea.workflow }}
-  cancel-in-progress: false
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    env:
-      VROBBLER_DATABASE_URL: sqlite:///test.db
-      VROBBLER_USDA_API_KEY: ${{ vars.VROBBLER_USDA_API_KEY }}
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Cache pip/poetry
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cache/pip
-            ~/.cache/pypoetry
-          key: ${{ runner.os }}-py311-${{ hashFiles('**/poetry.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-py311-
-
-      - name: Install Poetry
-        run: |
-          python -m pip install --upgrade pip
-          pip install poetry
-
-      - name: Install deps
-        run: |
-          cp vrobbler.conf.test vrobbler.conf
-          poetry install --with test
-
-      - name: Pytest with coverage
-        run: |
-          poetry run pytest -n 5 --cov-report term:skip-covered --cov=vrobbler tests
-
-      - name: Notify success (ntfy)
-        if: success()
-        run: |
-          curl -fsS \
-            -H "Title: vrobbler CI success" \
-            -H "Priority: low" \
-            -H "Tags: success,vrobbler" \
-            -H "Actions: view, Changes, ${{ gitea.server_url }}/${{ gitea.repository }}/commit/${{ gitea.sha }}; view, Build, ${{ gitea.server_url }}/${{ gitea.repository }}/actions/runs/${{ gitea.run_id }}" \
-            -d "✅ Build succeeded: ${{ gitea.repository }} @ ${{ gitea.sha }}" \
-            https://ntfy.unbl.ink/drone
-
-      - name: Notify failure (ntfy)
-        if: failure()
-        run: |
-          curl -fsS \
-            -H "Title: vrobbler CI failure" \
-            -H "Priority: high" \
-            -H "Tags: failure,vrobbler" \
-            -H "Actions: view, Changes, ${{ gitea.server_url }}/${{ gitea.repository }}/commit/${{ gitea.sha }}; view, Build, ${{ gitea.server_url }}/${{ gitea.repository }}/actions/runs/${{ gitea.run_id }}" \
-            -d "❌ Build failed: ${{ gitea.repository }} @ ${{ gitea.sha }}" \
-            https://ntfy.unbl.ink/drone
-
-  build-and-deploy:
-    needs: [test]
-    if: startsWith(gitea.ref, 'refs/tags/')
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install Poetry
-        run: |
-          python -m pip install --upgrade pip
-          pip install poetry
-
-      - name: Write commit hash to build file
-        run: |
-          mkdir -p build_meta
-          echo "${{ gitea.sha }}" | cut -c1-8 > build_meta/commit.txt
-
-      - name: Build package with commit info
-        run: |
-          echo "commit = '$(echo ${{ gitea.sha }} | cut -c1-8)'" > vrobbler/_commit.py
-          poetry build
-          git checkout vrobbler/_commit.py
-
-      - name: Clean old wheels from server
-        uses: appleboy/ssh-action@v1.0.3
-        with:
-          host: vrobbler.service
-          username: root
-          key: ${{ secrets.JAIL_KEY }}
-          script: |
-            rm -f /var/lib/vrobbler/dist/*.whl
-
-      - name: Copy wheel to server and deploy
-        uses: appleboy/scp-action@v1.0.0
-        with:
-          host: vrobbler.service
-          username: root
-          key: ${{ secrets.JAIL_KEY }}
-          source: "dist/*.whl"
-          target: "/var/lib/vrobbler"
-
-      - name: Install wheel and restart services
-        uses: appleboy/ssh-action@v1.0.3
-        with:
-          host: vrobbler.service
-          username: root
-          key: ${{ secrets.JAIL_KEY }}
-          command_timeout: 2m
-          script: |
-            set -e
-            mkdir -p /var/lib/vrobbler
-            echo "${{ gitea.sha }}" | cut -c1-8 > /var/lib/vrobbler/commit.txt
-            pip uninstall -y vrobbler
-            pip install /var/lib/vrobbler/dist/*.whl
-            rm -f /var/lib/vrobbler/dist/*.whl
-            python3 -c "import vrobbler; print(f'vrobbler {vrobbler.__version__} installed OK')"
-            vrobbler migrate
-            vrobbler collectstatic --noinput
-            immortalctl restart vrobbler-celery && immortalctl restart vrobbler-celerybeat && immortalctl restart vrobbler
-
-      - name: Notify deploy success (ntfy)
-        if: success()
-        run: |
-          curl -fsS \
-            -H "Title: vrobbler deploy success" \
-            -H "Priority: low" \
-            -H "Tags: success,vrobbler,deploy" \
-            -H "Actions: view, View changes, ${{ gitea.server_url }}/${{ gitea.repository }}/commit/${{ gitea.sha }}; view, View build, ${{ gitea.server_url }}/${{ gitea.repository }}/actions/runs/${{ gitea.run_id }}" \
-            -d "🚀 Deploy succeeded: ${{ gitea.ref_name }} (${{ gitea.sha }})" \
-            https://ntfy.unbl.ink/drone
-
-      - name: Notify deploy failure (ntfy)
-        if: failure()
-        run: |
-          curl -fsS \
-            -H "Title: vrobbler deploy failure" \
-            -H "Priority: high" \
-            -H "Tags: failure,vrobbler,deploy" \
-            -H "Actions: view, View changes, ${{ gitea.server_url }}/${{ gitea.repository }}/commit/${{ gitea.sha }}; view, View build, ${{ gitea.server_url }}/${{ gitea.repository }}/actions/runs/${{ gitea.run_id }}" \
-            -d "💥 Deploy failed: ${{ gitea.ref_name }} (${{ gitea.sha }})" \
-            https://ntfy.unbl.ink/drone
--- a/.github/workflows/django.yml
+++ b/.github/workflows/django.yml
@ -1,31 +0,0 @@
-name: Django CI
-
-on:
-  push:
-    branches: [ "develop" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-    strategy:
-      max-parallel: 4
-      matrix:
-        python-version: [3.9, 3.11, 3.12]
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v3
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install Dependencies
-      run: |
-        python -m pip install --upgrade pip
-        python -m pip install poetry
-        poetry install
-    - name: Run Tests
-      run: |
-        pytest
--- a/.gitignore
+++ b/.gitignore
@ -1,7 +1,5 @@
-db.sqlite3*
+db.sqlite3
 vrobbler.conf
 media/
 dist/
 .coverage
-tmp/*
-vrobbler/static/*
--- a/AGENTS.md
+++ b/AGENTS.md
@ -1,26 +0,0 @@
-This is a Django-based web application that has an API, but primarily functions
-with traditional Django views with HTML templates to display data that mostly
-constitutes "scrobbled" items. The app started as a way to track a user's
-watched videos via a Jellyfin server, but has since grown to keep track of a
-number of media types: music tracks, tasks, videos, web pages, food, life
-events, sports events, podcasts, video games, board games, beers, brick (lego)
-sets, puzzles, books and geolocations.
-
-The project is written in Python and prefers to use "fat" models where logical
-methods are contained in either instance methods on instatiated data models, or
-classmethods on the Django model class itself. When logic grows too complex,
-helper functions should be pulled out into utils.py files and the model instance
-ro class method should call the utility function.
-
-Be sure to check pyproject.toml for project defaults. Specifically for black and
-isort expectations.
-
-Imports in python files should always be top level if possible.
-
-All tasks live in the PROJECT.org file and include an org ID that is a uuid to make them unique.
-
-In local development, environment variables for various sensitive values live in a .envrc file
-
-The .envrc file can be loaded into a shell environment to allow access to most third party services
-
-Care should be taken when using .envrc that we do not spam services we use in production with requests
--- a/6
+++ b/6
@ -1,6 +0,0 @@
-deploy:
-	ssh vrobbler.service "pip uninstall vrobbler && pip install git+https://code.lab.unbl.ink/secstate/vrobbler.git && immortalctl restart vrobbler && immortalctl restart vrobbler-celery && vrobbler migrate"
-logs:
-	ssh life.unbl.ink tail -n 100 -f /var/log/vrobbler.json
-test:
-	pytest vrobbler
--- a/PROJECT.org
+++ b/PROJECT.org
--- a/2
+++ b/2
@ -1,2 +1,2 @@
 web: python manage.py runserver 0.0.0.0:8014
-worker: celery -A vrobbler worker -Q default,charts -l DEBUG
+worker: celery -A vrobbler worker -l DEBUG
--- a/README.md
+++ b/README.md
@ -1,7 +1,7 @@
 Vrobbler
 ========

-[![Build Status](https://ci.lab.unbl.ink/api/badges/secstate/vrobbler/status.svg?ref=refs/heads/main)](https://ci.lab.unbl.ink/secstate/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.

@ -21,23 +21,3 @@ VROBBLER_KEEP_DETAILED_SCROBBLE_LOGS=True
 VROBBLER_DATABASE_URL="postgres://vrobbler:<pass>@db.service:5432/vrobbler"
 VROBBLER_REDIS_URL="redis://:<pass>@cache.service:6379/0"
 ```
-
-## Database Backup
-
-A backup command is available via `./manage.py backup_database` (also runs on a cron schedule via Celery). It dumps the database with `pg_dump`, compresses with gzip, and optionally copies the backup to a remote host via SCP.
-
-Configure these additional settings as needed:
-
-```
-VROBBLER_DB_BACKUP_SSH_KEY="/path/to/ssh/private/key"
-VROBBLER_DB_BACKUP_SSH_DEST="user@backup.example.com:/remote/path/"
-VROBBLER_DB_BACKUP_NTFY_URL="https://ntfy.sh/your-topic"
-```
-
- `VROBBLER_DB_BACKUP_SSH_KEY` — Path to the SSH private key used for remote copy.
- `VROBBLER_DB_BACKUP_SSH_DEST` — SCP destination (user@host:path). If set, the backup is copied to the remote host and old backups are pruned.
- `VROBBLER_DB_BACKUP_LOCAL_DIR` — Local directory for backup storage. Defaults to `/var/backups/`. Backups are stored in a `vrobbler/` subdirectory.
- `VROBBLER_DB_BACKUP_NTFY_URL` — ntfy.sh URL for success notifications. Defaults to `https://ntfy.unbl.ink/backups`.
-
-Retention is hardcoded: keeps daily backups for 7 days, plus one per month for 12 months.
-```
--- a/data/birding-example.csv
+++ b/data/birding-example.csv
@ -1,5 +0,0 @@
-Species,Count,Location,Observation Type,Observation Date,Start Time,Duration,Distance,Area,Party Size,Complete Checklist,# of species,Details
-Canada Goose,6,"120 Perkins Street, Castine, Maine, US (44.384, -68.805)",Stationary,"May 10, 2026",4:15 PM,9 minute(s),,,4,true,4 species,
-Common Loon,1,"120 Perkins Street, Castine, Maine, US (44.384, -68.805)",Stationary,"May 10, 2026",4:15 PM,9 minute(s),,,4,true,4 species,
-Double-crested Cormorant,1,"120 Perkins Street, Castine, Maine, US (44.384, -68.805)",Stationary,"May 10, 2026",4:15 PM,9 minute(s),,,4,true,4 species,
-Boat-tailed Grackle,2,"120 Perkins Street, Castine, Maine, US (44.384, -68.805)",Stationary,"May 10, 2026",4:15 PM,9 minute(s),,,4,true,4 species,Sitting together on roof line of a house on Water Street. 20 meters away. Both birds were mostly black with green accents on the breast with long tails which they were repeatedly fanning out to show the V shape.
--- a/data/moods.json
+++ b/data/moods.json
--- a/data/play-example.json
+++ b/data/play-example.json
@ -1,96 +0,0 @@
-{
-    "about": "This is a Play file that can be read by Board Game Stats. If you see this text, try to use a share, export or open-in function to open it with Board Game Stats.",
-    "players": [
-        {
-            "uuid": "31f8b92e-11d8-4162-88b1-fd9c79eea249",
-            "id": 2,
-            "name": "Colin Powell",
-            "isAnonymous": false,
-            "modificationDate": "2025-10-18 08:32:40",
-            "metaData": "{\"isNpc\":0,\"playerAvatar\":{\"image\":\"AnnikaHeller_Capybara.webp\",\"shape\":[1,1,1,1],\"color\":[0.6,0.20000000298023224,0.9803921580314636]}}"
-        },
-        {
-            "uuid": "dd2d1881-84ab-474c-a6b2-3045d034dc40",
-            "id": 3,
-            "name": "Silas Sewell",
-            "isAnonymous": false,
-            "modificationDate": "2026-01-18 12:27:12",
-            "metaData": "{\"isNpc\":0,\"playerAvatar\":{\"image\":\"RoryMuldoon_07.webp\",\"shape\":[1,1,1,1],\"color\":[0,0,0.1835034190722739]}}"
-        }
-    ],
-    "locations": [
-        {
-            "uuid": "14f7389c-767f-4725-9b35-906c407b293c",
-            "id": 3,
-            "name": "Timberwyck Farm",
-            "modificationDate": "2025-07-01 18:03:38"
-        }
-    ],
-    "games": [
-        {
-            "uuid": "9e431cdd-b325-4061-a875-d415d46342c0",
-            "id": 1046,
-            "name": "Sweet Takes",
-            "modificationDate": "2026-04-11 16:25:35",
-            "cooperative": false,
-            "highestWins": true,
-            "noPoints": false,
-            "usesTeams": false,
-            "urlThumb": "https://cf.geekdo-images.com/l4HILZn5iLbceQeDph4G5A__small/img/gmGqlmwe9fniqYpniGwhg5RUgVQ=/fit-in/200x150/filters:strip_icc()/pic8784202.jpg",
-            "urlImage": "https://cf.geekdo-images.com/l4HILZn5iLbceQeDph4G5A__original/img/b4IU8WIEWRpacbXp0FHG9HfFRpw=/0x0/filters:format(jpeg)/pic8784202.jpg",
-            "bggName": "Sweet Takes",
-            "bggYear": 2023,
-            "bggId": 407581,
-            "designers": "Hisashi Hayashi",
-            "isBaseGame": 1,
-            "isExpansion": 0,
-            "rating": 67,
-            "minPlayerCount": 2,
-            "maxPlayerCount": 5,
-            "minPlayTime": 15,
-            "maxPlayTime": 15,
-            "minAge": 8
-        }
-    ],
-    "plays": [
-        {
-            "uuid": "7b2fd583-e8f2-40fe-9565-90178390b87e",
-            "modificationDate": "2026-04-16 20:18:03",
-            "entryDate": "2026-04-16 20:13:33",
-            "playDate": "2026-04-16 20:13:33",
-            "usesTeams": false,
-            "durationMin": 4,
-            "ignored": false,
-            "manualWinner": false,
-            "rounds": 0,
-            "locationRefId": 3,
-            "gameRefId": 1046,
-            "board": "",
-            "scoringSetting": 1,
-            "metaData": "{\"playerRefId\":2,\"playGameBggVersion\":\"{\\\"versionId\\\":0,\\\"versionName\\\":\\\"\\\",\\\"imageUrl\\\":\\\"https:\\\\\\/\\\\\\/cf.geekdo-images.com\\\\\\/l4HILZn5iLbceQeDph4G5A__small\\\\\\/img\\\\\\/gmGqlmwe9fniqYpniGwhg5RUgVQ=\\\\\\/fit-in\\\\\\/200x150\\\\\\/filters:strip_icc()\\\\\\/pic8784202.jpg\\\",\\\"thumbUrl\\\":\\\"https:\\\\\\/\\\\\\/cf.geekdo-images.com\\\\\\/l4HILZn5iLbceQeDph4G5A__small\\\\\\/img\\\\\\/gmGqlmwe9fniqYpniGwhg5RUgVQ=\\\\\\/fit-in\\\\\\/200x150\\\\\\/filters:strip_icc()\\\\\\/pic8784202.jpg\\\",\\\"yearPublished\\\":0}\",\"playUsedGameCopy\":2}",
-            "playerScores": [
-                {
-                    "score": "27",
-                    "winner": false,
-                    "newPlayer": false,
-                    "startPlayer": false,
-                    "playerRefId": 2,
-                    "role": "",
-                    "rank": 0,
-                    "seatOrder": 0
-                },
-                {
-                    "score": "36",
-                    "winner": true,
-                    "newPlayer": true,
-                    "startPlayer": false,
-                    "playerRefId": 3,
-                    "rank": 0,
-                    "seatOrder": 0
-                }
-            ],
-            "expansionPlays": []
-        }
-    ],
-    "userInfo": { "meRefId": 2 }
-}
--- a/data/sample-trail.fit
+++ b/data/sample-trail.fit
--- a/data/sample_trail.gpx
+++ b/data/sample_trail.gpx
--- a/data/scale-example.csv
+++ b/data/scale-example.csv
@ -1,2 +0,0 @@
-DATE,TIME,BICEPS,BMI,BMR,BODY_FAT,BONE,CALIPER,CALIPER_1,CALIPER_2,CALIPER_3,CALORIES,CHEST,COMMENT,HEART_RATE,HIPS,LBM,MUSCLE,NECK,TDEE,THIGH,VISCERAL_FAT,WAIST,WATER,WEIGHT,WHR,WHTR
-2026-05-20,11:56:58.076,,31.09,1706.74,29.084072,3.438837,,,,,,,,,,,33.07067,,2645.46,,,,54.445187,192.68378,,
--- a/data/statistics.sqlite3
+++ b/data/statistics.sqlite3
--- a/envrc.sample
+++ b/envrc.sample
@ -1,4 +1,4 @@
 export ENV_PATH=$(poetry env info --path)
 source "${ENV_PATH}/bin/activate"

-#export PYPI_PASSWORD="$(pass personal/apikey/pypi)"
+export PYPI_PASSWORD="$(pass personal/apikey/pypi)"
--- a/25
+++ b/25
@ -1,25 +0,0 @@
-dj-port := "0.0.0.0:" + env_var_or_default("DJANGO_PORT", "8000")
-
-default:
-    @just --list
-
-django:
-    poetry run python manage.py runserver {{dj-port}}
-
-shell:
-    poetry run python manage.py shell
-
-celery:
-    poetry run celery -A vrobbler worker -l info --concurrency=2 --pool=threads
-
-celery-beat:
-    poetry run celery -A vrobbler beat -l info
-
-push:
-    git push && git push gitea
-    git push --tags && git push --tags gitea
-
-release kind="minor":
-    poetry run python scripts/release.py {{kind}}
-    just push
-    
--- a/manage.py
+++ b/manage.py
@ -6,7 +6,7 @@ import sys

 def main():
    """Run administrative tasks."""
-    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "vrobbler.settings")
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'vrobbler.settings')
    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
@ -18,5 +18,5 @@ def main():
    execute_from_command_line(sys.argv)


-if __name__ == "__main__":
+if __name__ == '__main__':
    main()
--- a/poetry.lock
+++ b/poetry.lock
--- a/pyproject.toml
+++ b/pyproject.toml
@ -1,24 +1,22 @@
 [tool.poetry]
 name = "vrobbler"
-version = "59.5"
+version = "0.11.5"
 description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]

 [tool.poetry.dependencies]
-python = ">=3.11,<3.15"
+python = "^3.8"
 Django = "^4.0.3"
 django-extensions = "^3.1.5"
 python-dateutil = "^2.8.2"
-python-dotenv = ">=0.20.0,<2"
+python-dotenv = "^0.20.0"
 python-json-logger = "^2.0.2"
-cloudscraper = "^1.2.71"
 colorlog = "^6.6.0"
-httpx = "<=0.27.2"
 djangorestframework = "^3.13.1"
 Markdown = "^3.3.6"
 django-filter = "^21.1"
-Pillow = "^10.0.0"
-psycopg2 = "2.9.10"
+Pillow = "^9.0.1"
+psycopg2 = "^2.9.3"
 dj-database-url = "^0.5.0"
 django-mathfilters = "^1.0.0"
 django-allauth = "^0.50.0"
@ -28,7 +26,9 @@ django-taggit = "^2.1.0"
 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"
@ -36,43 +36,8 @@ pylast = "^5.1.0"
 django-encrypted-field = "^1.0.5"
 celery = "^5.2.7"
 honcho = "^1.1.0"
-howlongtobeatpy = "^1.0.5"
-beautifulsoup4 = "^4.11.2"
-django-storages = "^1.13.2"
-stream-sqlite = "^0.0.41"
-ipython = "^8.14.0"
-pendulum = "^3"
-trafilatura = "^1.6.3"
-django-imagekit = "^5.0.0"
-django-mcp-server = "^0.5.7"
-thefuzz = "^0.22.1"
-dataclass-wizard = "^0.35.0"
-webdavclient3 = "^3.14.6"
-boto3 = "^1.35.37"
-urllib3 = "<2"
-django-oauth-toolkit = "^3.0.1"
-meta-yt = "^0.1.9"
-berserk = "^0.13.2"
-poetry-bumpversion = "^0.3.3"
-orgparse = "^0.4.20250520"
-tmdbv3api = "^1.9.0"
-themoviedb = "^1.0.2"
-feedparser = "^6.0.12"
-titlecase = "^2.4.1"
-bgg-api = "^1.1.13"
-recipe-scrapers = "^15.11.0"
-gpxpy = "^1.6.2"
-fitparse = "^1.2.0"
-lxml = ">=5.5.0"
-vaderSentiment = "^3.3.2"
-sqids = "^0.5.2"
-python-amazon-paapi = "^6.3.0"
-yake = "^0.7.3"

-[tool.poetry.group.test]
-optional = true
-
-[tool.poetry.group.test.dependencies]
+[tool.poetry.dev-dependencies]
 Werkzeug = "2.0.3"
 black = "^22.3"
 coverage = "^7.0.5"
@ -81,22 +46,24 @@ pytest = "^7.1"
 pytest-black = "^0.3.12"
 pytest-cov = "^3.0"
 pytest-django = "^4.5.2"
-pytest-xdist= "^1.0.0"
 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"
 bandit = "^1.7.4"

 [tool.pytest.ini_options]
-addopts = "-ra -q --reuse-db --no-migrations"
+minversion = "6.0"
+addopts = "-ra -q"
 testpaths = ["tests"]
-DJANGO_SETTINGS_MODULE='vrobbler.settings-testing'
+DJANGO_SETTINGS_MODULE='vrobbler.settings'

 [tool.black]
-line-length = 88
+line-length = 79
+skip-string-normalization = true
 target-version = ["py39", "py310"]
 include = ".py$"
 exclude = "migrations"
@ -113,8 +80,6 @@ exclude_dirs = ["*/tests/*", "*/migrations/*"]
 [tool.poetry.scripts]
 vrobbler = "vrobbler.cli:main"

-[tool.poetry_bumpversion.file."vrobbler/__init__.py"]
-
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
--- a/scripts/README.org
+++ b/scripts/README.org
@ -1,27 +0,0 @@
-#+title: Readme
-
-Scripts are a collection of helpful utility scripts, or simple gut-check tests for various functional pieces.
-
-* test_recipe_scraper.py
-Asserts various urls by making actual calls out to the internet, while our test suite mocks return values.
-
-#+begin_src shell
-python ../manage.py shell < ../scripts/test_recipe_scraper.py
-#+end_src
-
-#+RESULTS:
-| Eagerly   | running                                                                     | all               | tasks |
-| Connected | to                                                                          | sqlite@db.sqlite3 |       |
-| Checking: | https://cookingwithmike.com/quinoa-meatloaf/                                |                   |       |
-| Checking: | https://www.kingarthurbaking.com/recipes/overnight-sourdough-waffles-recipe |                   |       |
-| Checking: | https://dirt.fyi/article/2026/02/25-years-of-ipod-brain?src=longreads       |                   |       |
-
-* test_koreader_import.py
-Run through an actual koreader sqlite file and make sure imports work as expected
-
-#+begin_src shell
-rm db.sqlite3
-cp ../db.sqlite3 .
-python ../manage.py shell < ../scripts/test_koreader_import.py
-#+end_src
-
--- a/scripts/koreader-test.sqlite3
+++ b/scripts/koreader-test.sqlite3
--- a/scripts/release.py
+++ b/scripts/release.py
@ -1,217 +0,0 @@
-#!/usr/bin/env python3
-"""Cut a new release: collect DONE items from Backlog into a new Version section.
-
-Usage:
-    poetry run python scripts/release.py major
-    poetry run python scripts/release.py minor
-"""
-
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-PROJECT_FILE = Path("PROJECT.org")
-PYPROJECT_FILE = Path("pyproject.toml")
-
-BACKLOG_RE = re.compile(r"^\* Backlog\s+\[(\d+)/(\d+)\](.*)$")
-VERSION_RE = re.compile(r"^\* Version\s+(\d+\.\d+)\s+\[\d+/\d+\]")
-DONE_HEADER_RE = re.compile(r"^(\*\* DONE\s+)(.*)$")
-ITEM_HEADER_RE = re.compile(r"^\*\* ")
-
-
-def parse_done_line(line):
-    """Extract a clean title from a ** DONE line, stripping priority and tags."""
-    rest = line[8:].strip()  # remove "** DONE "
-    # strip priority marker like [#A]
-    rest = re.sub(r"^\[#[A-C]\]\s+", "", rest, count=1)
-    # strip org-mode tags at end (space-colon-tags)
-    rest = re.sub(r"\s+:\S.*:\s*$", "", rest)
-    return rest
-
-
-def bump_version(current_major, current_minor, kind):
-    if kind == "major":
-        return current_major + 1, 0
-    elif kind == "minor":
-        return current_major, current_minor + 1
-    else:
-        raise ValueError(f"Unknown bump kind: {kind}")
-
-
-def main():
-    if len(sys.argv) < 2 or sys.argv[1] not in ("major", "minor"):
-        print(f"Usage: {sys.argv[0]} <major|minor>", file=sys.stderr)
-        sys.exit(1)
-
-    kind = sys.argv[1]
-
-    lines = PROJECT_FILE.read_text().splitlines(keepends=True)
-
-    # ---------------------------------------------------------------
-    # 1. Identify top-level sections
-    # ---------------------------------------------------------------
-    section_starts = []
-    for i, line in enumerate(lines):
-        if line.startswith("* ") and not line.startswith("** "):
-            section_starts.append(i)
-    section_starts.append(len(lines))
-
-    backlog_idx = None
-    version_idx = None
-
-    for idx, start in enumerate(section_starts[:-1]):
-        header = lines[start].strip()
-        if header.startswith("* Backlog"):
-            backlog_idx = idx
-        if header.startswith("* Version"):
-            version_idx = idx  # last occurrence wins
-
-    if backlog_idx is None:
-        print("ERROR: no Backlog section found", file=sys.stderr)
-        sys.exit(1)
-    if version_idx is None:
-        print("ERROR: no Version section found", file=sys.stderr)
-        sys.exit(1)
-
-    backlog_start = section_starts[backlog_idx]
-    backlog_end = section_starts[backlog_idx + 1]
-
-    # Find the newest Version section (first after Backlog) that matches
-    # our expected format (e.g. "37.0" not "0.11.4").
-    version_start = None
-    for idx in range(backlog_idx + 1, version_idx + 1):
-        header = lines[section_starts[idx]].strip()
-        if VERSION_RE.match(header):
-            version_start = section_starts[idx]
-            break
-
-    if version_start is None:
-        print("ERROR: no parseable Version header found", file=sys.stderr)
-        sys.exit(1)
-
-    version_header = lines[version_start].strip()
-
-    # ---------------------------------------------------------------
-    # 2. Parse current version from the newest * Version header
-    # ---------------------------------------------------------------
-    vm = VERSION_RE.match(version_header)
-    current_version = vm.group(1)
-    major_str, minor_str = current_version.split(".")
-    current_major = int(major_str)
-    current_minor = int(minor_str)
-    new_major, new_minor = bump_version(current_major, current_minor, kind)
-    new_version = f"{new_major}.{new_minor}"
-
-    # ---------------------------------------------------------------
-    # 3. Collect ** DONE items from the Backlog section
-    # ---------------------------------------------------------------
-    backlog_lines = lines[backlog_start:backlog_end]
-
-    # Split Backlog into items at each ** line (skip the section header)
-    items = []  # list of (start_idx, end_idx, is_done)
-    item_start = None
-    for i in range(1, len(backlog_lines)):
-        if ITEM_HEADER_RE.match(backlog_lines[i]):
-            if item_start is not None:
-                items.append((item_start, i, backlog_lines[item_start].startswith("** DONE")))
-            item_start = i
-    if item_start is not None:
-        items.append((item_start, len(backlog_lines), backlog_lines[item_start].startswith("** DONE")))
-
-    done_items = [(s, e) for s, e, is_done in items if is_done]
-    kept_items = [(s, e) for s, e, is_done in items if not is_done]
-
-    if not done_items:
-        print("No DONE items found in Backlog — nothing to release.")
-        sys.exit(1)
-
-    # ---------------------------------------------------------------
-    # 4. Build the new Version section text
-    # ---------------------------------------------------------------
-    version_section_lines = [f"* Version {new_version} [{len(done_items)}/{len(done_items)}]\n"]
-    for s, e in done_items:
-        version_section_lines.extend(backlog_lines[s:e])
-
-    # ---------------------------------------------------------------
-    # 5. Build updated Backlog section
-    # ---------------------------------------------------------------
-    backlog_header_line = backlog_lines[0]
-    bm = BACKLOG_RE.match(backlog_header_line.strip())
-    if not bm:
-        print(f"ERROR: could not parse backlog header: {backlog_header_line!r}", file=sys.stderr)
-        sys.exit(1)
-    done_count = int(bm.group(1))
-    total_count = int(bm.group(2))
-    tags = bm.group(3)
-
-    new_done = done_count - len(done_items)
-    new_total = total_count - len(done_items)
-    new_backlog_header = f"* Backlog [{new_done}/{new_total}]{tags}\n"
-
-    backlog_body = []
-    for s, e in kept_items:
-        backlog_body.extend(backlog_lines[s:e])
-
-    # ---------------------------------------------------------------
-    # 6. Assemble the new file
-    # ---------------------------------------------------------------
-    before_backlog = lines[:backlog_start]
-    after_backlog = lines[backlog_end:version_start]
-
-    # Everything from the first Version section onwards
-    from_version = lines[version_start:]
-
-    output = (
-        before_backlog
-        + [new_backlog_header]
-        + backlog_body
-        + version_section_lines
-        + ["\n"]
-        + after_backlog
-        + from_version
-    )
-
-    # ---------------------------------------------------------------
-    # 7. Update pyproject.toml
-    # ---------------------------------------------------------------
-    pyproject = PYPROJECT_FILE.read_text()
-    pyproject = re.sub(
-        r'^version = "[\d.]+"',
-        f'version = "{new_version}"',
-        pyproject,
-        count=1,
-        flags=re.MULTILINE,
-    )
-
-    # ---------------------------------------------------------------
-    # 8. Write files
-    # ---------------------------------------------------------------
-    PROJECT_FILE.write_text("".join(output))
-    PYPROJECT_FILE.write_text(pyproject)
-
-    # ---------------------------------------------------------------
-    # 9. Build commit body from done item titles
-    # ---------------------------------------------------------------
-    commit_lines = []
-    for s, e in done_items:
-        title = parse_done_line(backlog_lines[s])
-        if title:
-            commit_lines.append(f"- {title}")
-
-    commit_body = "\n".join(commit_lines)
-    commit_message = f"[release] Bump to version {new_version}\n\n{commit_body}"
-
-    # ---------------------------------------------------------------
-    # 10. Git commit + tag
-    # ---------------------------------------------------------------
-    subprocess.run(["git", "add", str(PROJECT_FILE), str(PYPROJECT_FILE)], check=True)
-    subprocess.run(["git", "commit", "-m", commit_message], check=True)
-    subprocess.run(["git", "tag", new_version], check=True)
-
-    print(f"\nReleased v{new_version} — tag {new_version} created.")
-    print(f"Moved {len(done_items)} DONE item(s) from Backlog to Version section.")
-
-
-if __name__ == "__main__":
-    main()
--- a/scripts/test_koreader_import.py
+++ b/scripts/test_koreader_import.py
@ -1,6 +0,0 @@
-#!/usr/bin/env python3
-
-from books.koreader import process_koreader_sqlite_file
-
-
-process_koreader_sqlite_file("./koreader-test.sqlite3", 1)
--- a/scripts/test_recipe_scraper.py
+++ b/scripts/test_recipe_scraper.py
@ -1,21 +0,0 @@
-import requests
-from foods.sources.rscraper import (
-    RecipeScraperService,
-)
-
-
-test_urls = {
-    "https://cookingwithmike.com/quinoa-meatloaf/": True,
-    "https://www.kingarthurbaking.com/recipes/overnight-sourdough-waffles-recipe": True,
-    "https://dirt.fyi/article/2026/02/25-years-of-ipod-brain?src=longreads": False,
-    "https://tastesbetterfromscratch.com/belgian-waffles/": True,
-}
-
-for k, v in test_urls.items():
-
-    html = requests.get(k).text
-    print("Checking: ", k)
-    if v:
-        assert RecipeScraperService().is_recipe(html, k)
-    else:
-        assert not RecipeScraperService().is_recipe(html, k)
--- a/tests/birds_tests/init.py
+++ b/tests/birds_tests/init.py
--- a/tests/birds_tests/conftest.py
+++ b/tests/birds_tests/conftest.py
@ -1,70 +0,0 @@
-import tempfile
-
-import pytest
-from birds.models import (
-    Bird,
-    BirdSightingEntry,
-    BirdSightingLogData,
-    BirdingLocation,
-)
-from django.contrib.auth import get_user_model
-from scrobbles.models import Scrobble
-
-User = get_user_model()
-
-
-@pytest.fixture
-def user(db):
-    return User.objects.create(email="birder@example.com")
-
-
-@pytest.fixture
-def bird(db):
-    return Bird.objects.create(
-        common_name="Northern Cardinal",
-        scientific_name="Cardinalis cardinalis",
-    )
-
-
-@pytest.fixture
-def birding_location(db):
-    return BirdingLocation.objects.create(title="Test Park")
-
-
-@pytest.fixture
-def birding_csv_content():
-    return """Species,Count,Location,Observation Type,Observation Date,Start Time,Duration,Distance,Area,Party Size,Complete Checklist,# of species,Details
-Canada Goose,6,Test Park,Stationary,"May 10, 2026",4:15 PM,9 minute(s),,,4,true,4 species,
-Northern Cardinal,2,Test Park,Stationary,"May 10, 2026",4:15 PM,9 minute(s),,,4,true,4 species,At the feeder
-"""
-
-
-@pytest.fixture
-def birding_csv_file(birding_csv_content):
-    with tempfile.NamedTemporaryFile(
-        mode="w", suffix=".csv", delete=False, encoding="utf-8"
-    ) as f:
-        f.write(birding_csv_content)
-        return f.name
-
-
-@pytest.fixture
-def scrobble_with_sightings(user, birding_location, bird):
-    return Scrobble.objects.create(
-        user=user,
-        birding_location=birding_location,
-        media_type=Scrobble.MediaType.BIRDING_LOCATION,
-        timestamp="2026-05-10 16:15:00+00:00",
-        played_to_completion=True,
-        log={
-            "birds": [
-                BirdSightingEntry(
-                    bird_id=bird.id, quantity=2, sighting_notes="At the feeder"
-                ).asdict
-            ],
-            "duration_minutes": 9,
-            "observation_type": "Stationary",
-            "party_size": 4,
-            "complete_checklist": True,
-        },
-    )
--- a/tests/birds_tests/test_dataclasses.py
+++ b/tests/birds_tests/test_dataclasses.py
@ -1,96 +0,0 @@
-from birds.models import BirdSightingEntry, BirdSightingLogData
-
-
-class TestBirdSightingEntry:
-    def test_create_entry(self, db, bird):
-        entry = BirdSightingEntry(bird_id=bird.id, quantity=3)
-        assert entry.bird_id == bird.id
-        assert entry.quantity == 3
-        assert entry.sighting_notes is None
-
-    def test_entry_default_quantity(self, db, bird):
-        entry = BirdSightingEntry(bird_id=bird.id)
-        assert entry.quantity == 1
-
-    def test_entry_str(self, db, bird):
-        entry = BirdSightingEntry(
-            bird_id=bird.id, quantity=2, sighting_notes="in the tree"
-        )
-        expected = f"{bird.common_name} x2 (in the tree)"
-        assert str(entry) == expected
-
-    def test_entry_str_no_notes(self, db, bird):
-        entry = BirdSightingEntry(bird_id=bird.id, quantity=1)
-        expected = f"{bird.common_name} x1"
-        assert str(entry) == expected
-
-    def test_entry_bird_property(self, db, bird):
-        entry = BirdSightingEntry(bird_id=bird.id)
-        assert entry.bird == bird
-
-    def test_entry_bird_property_none(self, db):
-        entry = BirdSightingEntry(bird_id=None)
-        assert entry.bird is None
-
-    def test_entry_asdict(self, db, bird):
-        entry = BirdSightingEntry(
-            bird_id=bird.id, quantity=4, sighting_notes="flying south"
-        )
-        d = entry.asdict
-        assert d["bird_id"] == bird.id
-        assert d["quantity"] == 4
-        assert d["sighting_notes"] == "flying south"
-
-
-class TestBirdSightingLogData:
-    def test_empty_logdata(self):
-        logdata = BirdSightingLogData()
-        assert logdata.birds is None
-        assert logdata.duration_minutes is None
-        assert logdata.observation_type is None
-        assert logdata.party_size is None
-        assert logdata.complete_checklist is None
-
-    def test_with_birds(self, db, bird):
-        entry = BirdSightingEntry(bird_id=bird.id, quantity=2).asdict
-        logdata = BirdSightingLogData(
-            birds=[entry],
-            duration_minutes=15,
-            observation_type="Traveling",
-            party_size=3,
-            complete_checklist=True,
-        )
-        assert len(logdata.birds) == 1
-        assert logdata.duration_minutes == 15
-        assert logdata.observation_type == "Traveling"
-        assert logdata.party_size == 3
-        assert logdata.complete_checklist is True
-
-    def test_bird_list_property(self, db, bird):
-        entry = BirdSightingEntry(bird_id=bird.id, quantity=2).asdict
-        logdata = BirdSightingLogData(birds=[entry])
-        assert bird.common_name in logdata.bird_list
-
-    def test_bird_list_empty(self):
-        logdata = BirdSightingLogData()
-        assert logdata.bird_list == ""
-
-    def test_as_html_with_all_fields(self, db, bird):
-        entry = BirdSightingEntry(bird_id=bird.id, quantity=2).asdict
-        logdata = BirdSightingLogData(
-            birds=[entry],
-            observation_type="Stationary",
-            distance="2 km",
-            area="Woodland",
-            party_size=4,
-            complete_checklist=True,
-            weather="Sunny",
-        )
-        html = logdata.as_html()
-        assert "Stationary" in html
-        assert "2 km" in html
-        assert "Woodland" in html
-        assert "Party size: 4" in html
-        assert "Complete checklist: True" in html
-        assert "Sunny" in html
-        assert bird.common_name in html
--- a/tests/birds_tests/test_importer.py
+++ b/tests/birds_tests/test_importer.py
@ -1,189 +0,0 @@
-import tempfile
-from datetime import timedelta
-
-import pytest
-from birds.importer import (
-    import_birding_csv,
-    parse_bool,
-    parse_coords,
-    parse_duration,
-    parse_int,
-    parse_timestamp,
-)
-from birds.models import Bird, BirdingLocation, BirdingCSVImport
-from scrobbles.models import Scrobble
-
-
-class TestParserHelpers:
-    def test_parse_duration(self):
-        assert parse_duration("9 minute(s)") == 9
-        assert parse_duration("120 minute(s)") == 120
-        assert parse_duration("") is None
-        assert parse_duration(None) is None
-        assert parse_duration("not a duration") is None
-
-    def test_parse_coords(self):
-        loc = "Some Place, US (44.384, -68.805)"
-        lat, lon = parse_coords(loc)
-        assert lat == 44.384
-        assert lon == -68.805
-
-    def test_parse_coords_no_match(self):
-        loc = "Some Place, US"
-        lat, lon = parse_coords(loc)
-        assert lat is None
-        assert lon is None
-
-    def test_parse_timestamp(self):
-        dt = parse_timestamp("May 10, 2026", "4:15 PM")
-        assert dt is not None
-        assert dt.year == 2026
-        assert dt.month == 5
-        assert dt.day == 10
-        assert dt.hour == 16
-        assert dt.minute == 15
-
-    def test_parse_timestamp_no_time(self):
-        dt = parse_timestamp("May 10, 2026", "")
-        assert dt is not None
-        assert dt.year == 2026
-
-    def test_parse_timestamp_invalid(self):
-        assert parse_timestamp("not a date", "") is None
-
-    def test_parse_bool(self):
-        assert parse_bool("true") is True
-        assert parse_bool("True") is True
-        assert parse_bool("yes") is True
-        assert parse_bool("1") is True
-        assert parse_bool("false") is False
-        assert parse_bool("") is None
-        assert parse_bool(None) is None
-
-    def test_parse_int(self):
-        assert parse_int("42") == 42
-        assert parse_int("") is None
-        assert parse_int(None) is None
-        assert parse_int("not a number") is None
-
-
-class TestImportBirdingCSV:
-    def test_import_creates_birds(self, user, birding_csv_file):
-        import_birding_csv(birding_csv_file, user.id)
-        assert Bird.objects.filter(common_name="Canada Goose").exists()
-        assert Bird.objects.filter(common_name="Northern Cardinal").exists()
-
-    def test_import_creates_location(self, user, birding_csv_file):
-        import_birding_csv(birding_csv_file, user.id)
-        assert BirdingLocation.objects.filter(title="Test Park").exists()
-
-    def test_import_creates_scrobble(self, user, birding_csv_file):
-        import_birding_csv(birding_csv_file, user.id)
-        assert Scrobble.objects.filter(
-            source="Birding CSV Import"
-        ).count() == 1
-
-    def test_import_logdata_fields(self, user, birding_csv_file):
-        import_birding_csv(birding_csv_file, user.id)
-        scrobble = Scrobble.objects.filter(source="Birding CSV Import").first()
-        log = scrobble.log
-        assert log["duration_minutes"] == 9
-        assert log["observation_type"] == "Stationary"
-        assert log["party_size"] == 4
-        assert log["complete_checklist"] is True
-        assert len(log["birds"]) == 2
-
-    def test_import_sighting_details(self, user, birding_csv_file):
-        import_birding_csv(birding_csv_file, user.id)
-        scrobble = Scrobble.objects.filter(source="Birding CSV Import").first()
-        birds = scrobble.log["birds"]
-        cardinal = next(b for b in birds if b["quantity"] == 2)
-        assert cardinal["sighting_notes"] == "At the feeder"
-
-    def test_import_idempotent(self, user, birding_csv_file):
-        import_birding_csv(birding_csv_file, user.id)
-        import_birding_csv(birding_csv_file, user.id)
-        assert Scrobble.objects.filter(
-            source="Birding CSV Import"
-        ).count() == 1
-
-    def test_import_bird_quantities(self, user, birding_csv_file):
-        import_birding_csv(birding_csv_file, user.id)
-        scrobble = Scrobble.objects.filter(source="Birding CSV Import").first()
-        birds = scrobble.log["birds"]
-        goose = next(b for b in birds if b["quantity"] == 6)
-        assert goose is not None
-
-    def test_import_sets_stop_timestamp(self, user, birding_csv_file):
-        import_birding_csv(birding_csv_file, user.id)
-        scrobble = Scrobble.objects.filter(source="Birding CSV Import").first()
-        assert scrobble.stop_timestamp is not None
-        expected = scrobble.timestamp + timedelta(minutes=9)
-        assert scrobble.stop_timestamp == expected
-
-
-class TestBirdingCSVImportModel:
-    def test_create_import_model(self, db, user):
-        imp = BirdingCSVImport.objects.create(user=user)
-        assert imp.uuid is not None
-        assert imp.import_type == "Birding CSV"
-        assert "Birding" in str(imp)
-
-    def test_record_error(self, db, user):
-        imp = BirdingCSVImport.objects.create(user=user)
-        assert imp.error_log is None
-        imp.record_error("test error")
-        imp.refresh_from_db()
-        assert imp.error_log is not None
-        assert "test error" in imp.error_log
-
-    def test_record_error_appends(self, db, user):
-        imp = BirdingCSVImport.objects.create(user=user)
-        imp.record_error("first error")
-        imp.record_error("second error")
-        imp.refresh_from_db()
-        assert imp.error_log.count("\n") == 1
-        assert "first error" in imp.error_log
-        assert "second error" in imp.error_log
-
-    @pytest.mark.django_db(transaction=True)
-    def test_process_via_model(self, user, birding_csv_file):
-        imp = BirdingCSVImport.objects.create(user=user)
-        with open(birding_csv_file, "rb") as f:
-            imp.csv_file.save("test.csv", f, save=True)
-        imp.process()
-        imp.refresh_from_db()
-        assert imp.process_count == 1
-        assert imp.processed_finished is not None
-
-    def test_record_error_on_bad_csv(self, user, db):
-        content = """Species,Count,Location,Observation Type,Observation Date,Start Time,Duration,Distance,Area,Party Size,Complete Checklist,# of species,Details
-Canada Goose,6,Test Park,Stationary,"Bad Date",4:15 PM,9 minute(s),,,4,true,4 species,
-"""
-        with tempfile.NamedTemporaryFile(
-            mode="w", suffix=".csv", delete=False, encoding="utf-8"
-        ) as f:
-            f.write(content)
-            file_path = f.name
-
-        errors = []
-        scrobbles = import_birding_csv(file_path, user.id, record_error=errors.append)
-        assert len(scrobbles) == 0
-        assert len(errors) == 1
-        assert "Could not parse date/time" in errors[0]
-
-    def test_record_error_on_bad_location(self, user, db):
-        content = """Species,Count,Location,Observation Type,Observation Date,Start Time,Duration,Distance,Area,Party Size,Complete Checklist,# of species,Details
-Canada Goose,6,,Stationary,"May 10, 2026",4:15 PM,9 minute(s),,,4,true,4 species,
-"""
-        with tempfile.NamedTemporaryFile(
-            mode="w", suffix=".csv", delete=False, encoding="utf-8"
-        ) as f:
-            f.write(content)
-            file_path = f.name
-
-        errors = []
-        scrobbles = import_birding_csv(file_path, user.id, record_error=errors.append)
-        assert len(scrobbles) == 0
-        assert len(errors) == 1
-        assert "Skipping rows with no location" in errors[0]
--- a/tests/birds_tests/test_models.py
+++ b/tests/birds_tests/test_models.py
@ -1,30 +0,0 @@
-import pytest
-from birds.models import Bird
-
-
-class TestBirdModel:
-    def test_create_bird(self, db):
-        bird = Bird.objects.create(common_name="Blue Jay")
-        assert bird.common_name == "Blue Jay"
-        assert bird.uuid is not None
-        assert str(bird) == "Blue Jay"
-
-    def test_find_or_create_new(self, db):
-        bird = Bird.find_or_create("American Robin")
-        assert bird.common_name == "American Robin"
-
-    def test_find_or_create_existing(self, db, bird):
-        result = Bird.find_or_create("Northern Cardinal")
-        assert result.id == bird.id
-        assert result.common_name == "Northern Cardinal"
-
-    def test_find_or_create_case_insensitive(self, db, bird):
-        result = Bird.find_or_create("northern cardinal")
-        assert result.id == bird.id
-
-    def test_bird_str(self, db):
-        bird = Bird.objects.create(common_name="Mourning Dove")
-        assert str(bird) == "Mourning Dove"
-
-    def test_bird_scientific_name(self, db, bird):
-        assert bird.scientific_name == "Cardinalis cardinalis"
--- a/tests/birds_tests/test_views.py
+++ b/tests/birds_tests/test_views.py
@ -1,42 +0,0 @@
-from django.contrib.auth import get_user_model
-from django.test import Client
-from django.urls import reverse
-from scrobbles.models import EBirdCSVImport
-
-User = get_user_model()
-
-
-class TestBirdingLocationViews:
-    def test_birding_location_list_anonymous(self, db):
-        client = Client()
-        response = client.get(reverse("birds:birding_location_list"))
-        assert response.status_code == 200
-
-    def test_bird_list_anonymous(self, db):
-        client = Client()
-        response = client.get(reverse("birds:bird_list"))
-        assert response.status_code == 200
-
-
-class TestBirdingCSVImportViews:
-    def test_upload_view_requires_login(self, db):
-        client = Client()
-        response = client.get(reverse("birds:csv-upload"))
-        assert response.status_code == 302
-
-    def test_import_detail_view_requires_login(self, db):
-        client = Client()
-        response = client.get(
-            reverse("birds:csv_import_detail", kwargs={"slug": "00000000-0000-0000-0000-000000000001"})
-        )
-        assert response.status_code == 302
-
-    def test_import_detail_authenticated(self, db):
-        user = User.objects.create(email="birder@example.com")
-        client = Client()
-        client.force_login(user)
-        imp = EBirdCSVImport.objects.create(user=user)
-        response = client.get(
-            reverse("scrobbles:ebird-csv-import-detail", kwargs={"slug": imp.uuid})
-        )
-        assert response.status_code == 200
--- a/tests/boardgames_tests/test_bgg.py
+++ b/tests/boardgames_tests/test_bgg.py
@ -1,31 +0,0 @@
-import pytest
-from boardgames.bgg import (
-    take_first,
-    lookup_boardgame_id_from_bgg,
-    lookup_boardgame_from_bgg,
-)
-
-
-@pytest.mark.skip(reason="Deprecated library")
-def test_take_first():
-    assert take_first([]) == ""
-
-    assert take_first(["a", "b"]) == "a"
-
-
-@pytest.mark.skip(reason="Deprecated library")
-def test_lookup_boardgame_id_from_bgg():
-    bgg_id = lookup_boardgame_id_from_bgg("Cosmic Encounter")
-    assert bgg_id == "15"
-
-    bgg_id = lookup_boardgame_id_from_bgg("Comedy Encounter")
-    assert bgg_id == None
-
-
-@pytest.mark.skip(reason="Deprecated library")
-def test_lookup_boardgame_from_bgg():
-    bgg_result = lookup_boardgame_from_bgg(15)
-    assert bgg_result.get("bggeek_id") == 15
-
-    bgg_result = lookup_boardgame_from_bgg("Cosmic Encounter")
-    assert bgg_result.get("bggeek_id") == "15"
--- a/tests/discgolf_tests/init.py
+++ b/tests/discgolf_tests/init.py
--- a/tests/discgolf_tests/conftest.py
+++ b/tests/discgolf_tests/conftest.py
@ -1,63 +0,0 @@
-import tempfile
-
-import pytest
-from django.contrib.auth import get_user_model
-
-User = get_user_model()
-
-
-@pytest.fixture
-def user(db):
-    return User.objects.create(email="golfer@example.com")
-
-
-@pytest.fixture
-def udisc_singles_csv_content():
-    return """PlayerName,CourseName,LayoutName,StartDate,Hole1,Hole2,Hole3,Total
-Par,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",3,3,3,9
-Alice,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",4,2,3,9
-Bob,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",3,4,5,12
-"""
-
-
-@pytest.fixture
-def udisc_singles_csv_file(udisc_singles_csv_content):
-    with tempfile.NamedTemporaryFile(
-        mode="w", suffix=".csv", delete=False, encoding="utf-8-sig"
-    ) as f:
-        f.write(udisc_singles_csv_content)
-        return f.name
-
-
-@pytest.fixture
-def udisc_teams_csv_content():
-    return """PlayerName,CourseName,LayoutName,StartDate,Hole1,Hole2,Hole3,Total
-Par,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",3,3,3,9
-Alice+Bob,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",4,2,3,9
-Charlie+Diana,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",3,4,5,12
-"""
-
-
-@pytest.fixture
-def udisc_teams_csv_file(udisc_teams_csv_content):
-    with tempfile.NamedTemporaryFile(
-        mode="w", suffix=".csv", delete=False, encoding="utf-8-sig"
-    ) as f:
-        f.write(udisc_teams_csv_content)
-        return f.name
-
-
-@pytest.fixture
-def udisc_csv_no_par_content():
-    return """PlayerName,CourseName,LayoutName,StartDate,Hole1,Hole2,Hole3,Total
-Alice,Maple Hill,Mountains,"Jun 15, 2026 10:00 AM",4,2,3,9
-"""
-
-
-@pytest.fixture
-def udisc_csv_no_par_file(udisc_csv_no_par_content):
-    with tempfile.NamedTemporaryFile(
-        mode="w", suffix=".csv", delete=False, encoding="utf-8-sig"
-    ) as f:
-        f.write(udisc_csv_no_par_content)
-        return f.name
--- a/tests/discgolf_tests/test_models.py
+++ b/tests/discgolf_tests/test_models.py
@ -1,102 +0,0 @@
-from discgolf.models import DiscGolfCourse, DiscGolfLogData
-from scrobbles.dataclasses import BaseLogData
-
-
-class TestDiscGolfCourseModel:
-    def test_create_course(self, db):
-        course = DiscGolfCourse.objects.create(
-            title="Maple Hill",
-            layout_name="Mountains",
-            number_of_holes=18,
-            par_total=54,
-            par_per_hole={"hole_1": 3, "hole_2": 3},
-        )
-        assert course.uuid is not None
-        assert str(course) == "Maple Hill (Mountains)"
-        assert course.subtitle == "Mountains"
-
-    def test_subtitle_fallback(self, db):
-        course = DiscGolfCourse.objects.create(title="Maple Hill")
-        assert course.subtitle == ""
-
-    def test_logdata_cls(self, db):
-        course = DiscGolfCourse.objects.create(title="Maple Hill")
-        assert course.logdata_cls is DiscGolfLogData
-        assert issubclass(course.logdata_cls, BaseLogData)
-
-    def test_strings(self, db):
-        course = DiscGolfCourse.objects.create(title="Maple Hill")
-        assert course.strings.verb == "Playing"
-        assert course.strings.tags == "golf"
-
-    def test_primary_image_url(self, db):
-        course = DiscGolfCourse.objects.create(title="Maple Hill")
-        assert course.primary_image_url == ""
-
-    def test_get_absolute_url(self, db):
-        course = DiscGolfCourse.objects.create(title="Maple Hill")
-        url = course.get_absolute_url()
-        assert str(course.uuid) in url
-        assert url.startswith("/disc-golf/")
-
-    def test_find_or_create_new(self, db):
-        course = DiscGolfCourse.find_or_create(
-            "New Course", layout_name="Default"
-        )
-        assert course.title == "New Course"
-        assert course.layout_name == "Default"
-
-    def test_find_or_create_existing(self, db):
-        created = DiscGolfCourse.objects.create(
-            title="Existing", layout_name="Alpha"
-        )
-        found = DiscGolfCourse.find_or_create("Existing", layout_name="Beta")
-        assert found.id == created.id
-        assert found.layout_name == "Alpha"
-
-    def test_scrobbles_method(self, db, user):
-        from datetime import datetime
-
-        import pytz
-
-        from scrobbles.models import Scrobble
-
-        course = DiscGolfCourse.objects.create(title="Maple Hill")
-        dt1 = datetime(2026, 6, 15, 14, 0, 0, tzinfo=pytz.UTC)
-        dt2 = datetime(2026, 6, 14, 14, 0, 0, tzinfo=pytz.UTC)
-        s1 = Scrobble.objects.create(
-            user=user,
-            disc_golf_course=course,
-            media_type=Scrobble.MediaType.DISC_GOLF,
-            timestamp=dt1,
-        )
-        s2 = Scrobble.objects.create(
-            user=user,
-            disc_golf_course=course,
-            media_type=Scrobble.MediaType.DISC_GOLF,
-            timestamp=dt2,
-        )
-        qs = course.scrobbles(user.id)
-        assert list(qs) == [s1, s2]
-
-
-class TestDiscGolfLogData:
-    def test_basic_logdata(self):
-        data = DiscGolfLogData()
-        assert data.scores is None
-        assert data.weather is None
-        assert data.fun_factor is None
-        assert data.course_name is None
-
-    def test_logdata_with_scores(self):
-        data = DiscGolfLogData(
-            scores={"Alice": {"person_id": 1, "total": 9}},
-            weather="Sunny",
-            fun_factor="High",
-            course_name="Maple Hill",
-            par=9,
-            round_type="Singles",
-        )
-        assert data.scores["Alice"]["total"] == 9
-        assert data.weather == "Sunny"
-        assert data.round_type == "Singles"
--- a/tests/discgolf_tests/test_utils.py
+++ b/tests/discgolf_tests/test_utils.py
@ -1,150 +0,0 @@
-from unittest.mock import patch
-
-from discgolf.models import DiscGolfCourse
-from discgolf.utils import _parse_udisc_datetime, import_udisc_csv
-from people.models import Person
-from scrobbles.models import Scrobble
-
-
-class TestParserHelpers:
-    def test_parse_udisc_datetime(self):
-        dt = _parse_udisc_datetime("Jun 15, 2026 10:00 AM")
-        assert dt is not None
-        assert dt.year == 2026
-        assert dt.month == 6
-        assert dt.day == 15
-        assert dt.hour == 10
-        assert dt.minute == 0
-
-    def test_parse_udisc_datetime_date_only(self):
-        dt = _parse_udisc_datetime("Jun 15, 2026")
-        assert dt is not None
-        assert dt.year == 2026
-
-
-class TestImportUdiscCSV:
-    def test_import_singles_creates_course(self, user, udisc_singles_csv_file):
-        import_udisc_csv(udisc_singles_csv_file, user.id)
-        course = DiscGolfCourse.objects.filter(title="Maple Hill").first()
-        assert course is not None
-        assert course.layout_name == "Mountains"
-        assert course.number_of_holes == 3
-        assert course.par_total == 9
-        assert course.par_per_hole == {"hole_1": 3, "hole_2": 3, "hole_3": 3}
-
-    def test_import_singles_creates_scrobble(self, user, udisc_singles_csv_file):
-        import_udisc_csv(udisc_singles_csv_file, user.id)
-        assert Scrobble.objects.filter(source="uDisc").count() == 1
-
-    def test_import_singles_logdata(self, user, udisc_singles_csv_file):
-        import_udisc_csv(udisc_singles_csv_file, user.id)
-        scrobble = Scrobble.objects.filter(source="uDisc").first()
-        log = scrobble.log
-        assert log["course_name"] == "Maple Hill"
-        assert log["par"] == 9
-        assert log["round_type"] == "Singles"
-        assert "Alice" in log["scores"]
-        assert "Bob" in log["scores"]
-        assert log["scores"]["Alice"]["total"] == 9
-        assert log["scores"]["Bob"]["total"] == 12
-
-    def test_import_singles_creates_people(self, user, udisc_singles_csv_file):
-        import_udisc_csv(udisc_singles_csv_file, user.id)
-        assert Person.objects.filter(name="Alice").exists()
-        assert Person.objects.filter(name="Bob").exists()
-
-    def test_import_teams_creates_scrobble(self, user, udisc_teams_csv_file):
-        import_udisc_csv(udisc_teams_csv_file, user.id)
-        assert Scrobble.objects.filter(source="uDisc").count() == 1
-
-    def test_import_teams_logdata(self, user, udisc_teams_csv_file):
-        import_udisc_csv(udisc_teams_csv_file, user.id)
-        scrobble = Scrobble.objects.filter(source="uDisc").first()
-        assert scrobble.log["round_type"] == "Teams"
-        alice_bob = scrobble.log["scores"]["Alice+Bob"]
-        assert "person_ids" in alice_bob
-        assert len(alice_bob["person_ids"]) == 2
-
-    def test_import_creates_team_people(self, user, udisc_teams_csv_file):
-        import_udisc_csv(udisc_teams_csv_file, user.id)
-        assert Person.objects.filter(name="Alice").exists()
-        assert Person.objects.filter(name="Bob").exists()
-        assert Person.objects.filter(name="Charlie").exists()
-        assert Person.objects.filter(name="Diana").exists()
-
-    def test_import_teams_par_per_hole(self, user, udisc_teams_csv_file):
-        import_udisc_csv(udisc_teams_csv_file, user.id)
-        course = DiscGolfCourse.objects.get(title="Maple Hill")
-        assert course.par_per_hole == {"hole_1": 3, "hole_2": 3, "hole_3": 3}
-
-    def test_import_no_par_returns_empty(self, user, udisc_csv_no_par_file):
-        result = import_udisc_csv(udisc_csv_no_par_file, user.id)
-        assert result == []
-
-    def test_import_empty_csv(self, user, db):
-        import tempfile
-
-        with tempfile.NamedTemporaryFile(
-            mode="w", suffix=".csv", delete=False, encoding="utf-8-sig"
-        ) as f:
-            f.write("PlayerName,CourseName,LayoutName,StartDate,Hole1,Total\n")
-            path = f.name
-
-        result = import_udisc_csv(path, user.id)
-        assert result == []
-
-    def test_import_idempotent(self, user, udisc_singles_csv_file):
-        import_udisc_csv(udisc_singles_csv_file, user.id)
-        import_udisc_csv(udisc_singles_csv_file, user.id)
-        assert DiscGolfCourse.objects.filter(title="Maple Hill").count() == 1
-        assert Scrobble.objects.filter(source="uDisc").count() == 2
-
-    def test_import_course_defaults_only_on_create(
-        self, user, udisc_singles_csv_file
-    ):
-        import_udisc_csv(udisc_singles_csv_file, user.id)
-        course = DiscGolfCourse.objects.get(title="Maple Hill")
-        assert course.layout_name == "Mountains"
-
-        course.layout_name = "Updated"
-        course.save()
-
-        import_udisc_csv(udisc_singles_csv_file, user.id)
-        course.refresh_from_db()
-        assert course.layout_name == "Updated"
-
-    @patch("discgolf.utils.ScrobbleNtfyNotification")
-    def test_import_sends_notification(self, mock_notification_class, user, udisc_singles_csv_file):
-        import_udisc_csv(udisc_singles_csv_file, user.id)
-        mock_notification_class.assert_called_once()
-        mock_notification_class.return_value.send.assert_called_once()
-
-    def test_import_hole_scores_per_player(self, user, udisc_singles_csv_file):
-        import_udisc_csv(udisc_singles_csv_file, user.id)
-        scrobble = Scrobble.objects.filter(source="uDisc").first()
-        alice = scrobble.log["scores"]["Alice"]
-        assert alice["hole_1"] == 4
-        assert alice["hole_2"] == 2
-        assert alice["hole_3"] == 3
-        bob = scrobble.log["scores"]["Bob"]
-        assert bob["hole_1"] == 3
-        assert bob["hole_2"] == 4
-        assert bob["hole_3"] == 5
-
-    def test_import_record_error_on_bad_data(self, user, db):
-        import tempfile
-
-        content = """PlayerName,CourseName,LayoutName,StartDate,Hole1,Hole2,Hole3,Total
-Par,,Mountains,"Jun 15, 2026 10:00 AM",3,3,3,9
-"""
-        with tempfile.NamedTemporaryFile(
-            mode="w", suffix=".csv", delete=False, encoding="utf-8-sig"
-        ) as f:
-            f.write(content)
-            path = f.name
-
-        errors = []
-        result = import_udisc_csv(path, user.id, record_error=errors.append)
-        assert len(result) == 1
-        course = DiscGolfCourse.objects.first()
-        assert course.title == ""
--- a/tests/discgolf_tests/test_views.py
+++ b/tests/discgolf_tests/test_views.py
@ -1,58 +0,0 @@
-from datetime import datetime
-
-import pytz
-from django.contrib.auth import get_user_model
-from django.test import Client
-from django.urls import reverse
-
-from discgolf.models import DiscGolfCourse
-from scrobbles.models import Scrobble
-
-User = get_user_model()
-
-
-class TestDiscGolfCourseViews:
-    def _make_scrobble(self, user, course):
-        dt = datetime(2026, 6, 15, 14, 0, 0, tzinfo=pytz.UTC)
-        return Scrobble.objects.create(
-            user=user,
-            disc_golf_course=course,
-            media_type=Scrobble.MediaType.DISC_GOLF,
-            timestamp=dt,
-        )
-
-    def test_course_list_anonymous(self, db, user):
-        course = DiscGolfCourse.objects.create(title="Maple Hill")
-        self._make_scrobble(user, course)
-        client = Client()
-        response = client.get(reverse("discgolf:course_list"))
-        assert response.status_code == 200
-
-    def test_course_list_shows_course(self, db, user):
-        course = DiscGolfCourse.objects.create(title="Maple Hill")
-        self._make_scrobble(user, course)
-        client = Client()
-        response = client.get(reverse("discgolf:course_list"))
-        assert response.status_code == 200
-        assert "Maple Hill" in response.content.decode()
-
-    def test_course_detail_anonymous(self, db, user):
-        course = DiscGolfCourse.objects.create(title="Maple Hill")
-        self._make_scrobble(user, course)
-        client = Client()
-        response = client.get(
-            reverse("discgolf:course_detail", kwargs={"slug": course.uuid})
-        )
-        assert response.status_code == 200
-
-    def test_course_detail_shows_course(self, db, user):
-        course = DiscGolfCourse.objects.create(
-            title="Maple Hill", layout_name="Mountains"
-        )
-        self._make_scrobble(user, course)
-        client = Client()
-        response = client.get(
-            reverse("discgolf:course_detail", kwargs={"slug": course.uuid})
-        )
-        assert response.status_code == 200
-        assert "Maple Hill" in response.content.decode()
--- a/tests/foods_tests/init.py
+++ b/tests/foods_tests/init.py
--- a/tests/foods_tests/test_recipe_scraper.py
+++ b/tests/foods_tests/test_recipe_scraper.py
@ -1,186 +0,0 @@
-import pytest
-from foods.sources.rscraper import (
-    RecipeScraperService,
-)
-
-
-RECIPE_HTML_WITH_SCHEMA = """
-<!DOCTYPE html>
-<html>
-<head>
-    <script type="application/ld+json">
-    {
-        "@context": "https://schema.org/",
-        "@type": "Recipe",
-        "name": "Test Recipe",
-        "author": {
-            "@type": "Person",
-            "name": "Test Author"
-        },
-        "recipeIngredient": ["1 cup flour", "2 eggs", "1/2 cup sugar"],
-        "recipeInstructions": [
-            {
-                "@type": "HowToStep",
-                "text": "Mix ingredients together"
-            }
-        ],
-        "totalTime": "PT30M",
-        "recipeYield": "4 servings"
-    }
-    </script>
-</head>
-<body>
-    <h1>Test Recipe</h1>
-</body>
-</html>
-"""
-
-RECIPE_HTML_WITHOUT_SCHEMA = """
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Not a Recipe Page</title>
-</head>
-<body>
-    <h1>Welcome to My Blog</h1>
-    <p>This is just a regular blog post about cooking.</p>
-</body>
-</html>
-"""
-
-RECIPE_HTML_WITH_MICRODATA = """
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Test Recipe</title>
-</head>
-<body itemscope itemtype="http://schema.org/Recipe">
-    <h1 itemprop="name">Microdata Recipe</h1>
-    <div itemprop="author" itemscope itemtype="http://schema.org/Person">
-        <span itemprop="name">Test Author</span>
-    </div>
-    <div itemprop="recipeIngredient">1 cup flour</div>
-    <div itemprop="recipeIngredient">2 eggs</div>
-    <div itemprop="recipeInstructions">
-        <div itemprop="text">Mix all ingredients</div>
-    </div>
-</body>
-</html>
-"""
-
-
-class TestRecipeScraperService:
-    @pytest.fixture
-    def scraper(self):
-        return RecipeScraperService()
-
-    def test_is_recipe_with_valid_schema(self, scraper):
-        result = scraper.is_recipe(
-            RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe"
-        )
-        assert result is True
-
-    def test_is_recipe_without_schema(self, scraper):
-        result = scraper.is_recipe(
-            RECIPE_HTML_WITHOUT_SCHEMA, "https://example.com/blog"
-        )
-        assert result is False
-
-    def test_is_recipe_with_microdata(self, scraper):
-        result = scraper.is_recipe(
-            RECIPE_HTML_WITH_MICRODATA, "https://example.com/recipe"
-        )
-        assert result is True
-
-    def test_scrape_returns_title(self, scraper):
-        result = scraper.scrape(RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe")
-        assert result["title"] == "Test Recipe"
-
-    def test_scrape_returns_ingredients(self, scraper):
-        result = scraper.scrape(RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe")
-        assert len(result["ingredients"]) == 3
-        assert "1 cup flour" in result["ingredients"]
-
-    def test_scrape_returns_instructions(self, scraper):
-        result = scraper.scrape(RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe")
-        assert len(result["instructions"]) > 0
-        assert "Mix ingredients together" in result["instructions"]
-
-    def test_scrape_returns_yields(self, scraper):
-        result = scraper.scrape(RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe")
-        assert result["yields"] == "4 servings"
-
-    def test_scrape_returns_total_time(self, scraper):
-        result = scraper.scrape(RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe")
-        assert result["total_time"] == 30
-
-    def test_scrape_returns_url(self, scraper):
-        result = scraper.scrape(RECIPE_HTML_WITH_SCHEMA, "https://example.com/recipe")
-        assert result["url"] == "https://example.com/recipe"
-
-    def test_scrape_raises_on_invalid_html(self, scraper):
-        with pytest.raises(ValueError):
-            scraper.scrape("", "https://example.com/recipe")
-
-    def test_scrape_handles_missing_optional_fields(self, scraper):
-        minimal_html = """
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <script type="application/ld+json">
-            {
-                "@context": "https://schema.org/",
-                "@type": "Recipe",
-                "name": "Minimal Recipe"
-            }
-            </script>
-        </head>
-        <body></body>
-        </html>
-        """
-        result = scraper.scrape(minimal_html, "https://example.com/minimal")
-        assert result["title"] == "Minimal Recipe"
-        assert result["ingredients"] == []
-        assert result["instructions"] == []
-
-    def test_parse_servings(self, scraper):
-        assert scraper.parse_servings("4 servings") == 4
-        assert scraper.parse_servings("6 people") == 6
-        assert scraper.parse_servings("2") == 2
-        assert scraper.parse_servings("serves 8") == 8
-        assert scraper.parse_servings(None) is None
-        assert scraper.parse_servings("") is None
-
-    def test_extract_tags_from_cuisine(self, scraper):
-        recipe_data = {"cuisine": "Italian"}
-        tags = scraper.extract_tags(recipe_data)
-        assert "Italian" in tags
-
-    def test_extract_tags_from_cuisine_list(self, scraper):
-        recipe_data = {"cuisine": ["Italian", "Mexican"]}
-        tags = scraper.extract_tags(recipe_data)
-        assert "Italian" in tags
-        assert "Mexican" in tags
-
-    def test_extract_tags_from_dietary(self, scraper):
-        recipe_data = {"dietary": "Gluten-Free"}
-        tags = scraper.extract_tags(recipe_data)
-        assert "Gluten-Free" in tags
-
-    def test_extract_tags_from_course(self, scraper):
-        recipe_data = {"course": "Dessert"}
-        tags = scraper.extract_tags(recipe_data)
-        assert "Dessert" in tags
-
-    def test_extract_tags_from_keywords(self, scraper):
-        recipe_data = {"keywords": "easy, quick, healthy"}
-        tags = scraper.extract_tags(recipe_data)
-        assert "easy" in tags
-        assert "quick" in tags
-        assert "healthy" in tags
-
-    def test_extract_tags_from_keywords_list(self, scraper):
-        recipe_data = {"keywords": ["comfort food", "winter"]}
-        tags = scraper.extract_tags(recipe_data)
-        assert "comfort food" in tags
-        assert "winter" in tags
--- a/tests/foods_tests/test_usda.py
+++ b/tests/foods_tests/test_usda.py
@ -1,133 +0,0 @@
-import pytest
-from unittest.mock import patch
-from foods.sources.usda import (
-    USDAFoodAPI,
-    NutritionCalculator,
-)
-
-
-class TestUSDAFoodAPI:
-    @pytest.fixture
-    def usda_api(self):
-        with patch("vrobbler.apps.foods.sources.usda.settings") as mock_settings:
-            mock_settings.USDA_API_KEY = "test_api_key"
-            return USDAFoodAPI(api_key="test_api_key")
-
-    def test_extract_nutrients_with_nutrient_number(self, usda_api):
-        food_data = {
-            "description": "Test Food",
-            "foodNutrients": [
-                {
-                    "nutrientNumber": "203",
-                    "nutrientName": "Protein",
-                    "value": 10.0,
-                },
-                {
-                    "nutrientNumber": "204",
-                    "nutrientName": "Total lipid (fat)",
-                    "value": 5.0,
-                },
-                {
-                    "nutrientNumber": "205",
-                    "nutrientName": "Carbohydrate, by difference",
-                    "value": 20.0,
-                },
-                {
-                    "nutrientNumber": "208",
-                    "nutrientName": "Energy",
-                    "value": 150.0,
-                },
-                {
-                    "nutrientNumber": "269",
-                    "nutrientName": "Sugars, total",
-                    "value": 5.0,
-                },
-            ],
-        }
-        result = usda_api.extract_nutrients(food_data)
-        assert result["protein"] == 10.0
-        assert result["fat"] == 5.0
-        assert result["carbohydrates"] == 20.0
-        assert result["calories"] == 150.0
-        assert result["sugar"] == 5.0
-
-    def test_extract_nutrients_with_nested_nutrient(self, usda_api):
-        food_data = {
-            "description": "Test Food",
-            "foodNutrients": [
-                {
-                    "nutrient": {"id": 203, "name": "Protein"},
-                    "value": 10.0,
-                },
-            ],
-        }
-        result = usda_api.extract_nutrients(food_data)
-        assert result["protein"] == 10.0
-
-    def test_extract_nutrients_with_empty_nutrients(self, usda_api):
-        food_data = {"description": "Test Food", "foodNutrients": []}
-        result = usda_api.extract_nutrients(food_data)
-        assert result["protein"] == 0
-        assert result["calories"] == 0
-
-    def test_extract_nutrients_with_no_nutrients_key(self, usda_api):
-        food_data = {"description": "Test Food"}
-        result = usda_api.extract_nutrients(food_data)
-        assert result["protein"] == 0
-
-
-class TestNutritionCalculator:
-    @pytest.fixture
-    def calculator(self):
-        with patch("vrobbler.apps.foods.sources.usda.USDAFoodAPI"):
-            return NutritionCalculator()
-
-    def test_parse_ingredient_with_fraction(self, calculator):
-        result = calculator.parse_ingredient("1/2 cup flour")
-        assert result["quantity"] == 0.5
-        assert result["unit"] == "cup"
-        assert result["ingredient"] == "flour"
-
-    def test_parse_ingredient_with_mixed_number(self, calculator):
-        result = calculator.parse_ingredient("1 1/2 cups sugar")
-        assert result["quantity"] == 1.5
-        assert result["unit"] == "cups"
-        assert result["ingredient"] == "sugar"
-
-    def test_parse_ingredient_with_decimal(self, calculator):
-        result = calculator.parse_ingredient("0.5 tsp salt")
-        assert result["quantity"] == 0.5
-        assert result["unit"] == "tsp"
-        assert result["ingredient"] == "salt"
-
-    def test_parse_ingredient_with_whole_number(self, calculator):
-        result = calculator.parse_ingredient("3 eggs")
-        assert result["quantity"] == 3
-        assert result["unit"] is None
-        assert result["ingredient"] == "eggs"
-
-    def test_parse_ingredient_with_no_quantity(self, calculator):
-        result = calculator.parse_ingredient("salt to taste")
-        assert result["quantity"] == 1
-
-    def test_clean_ingredient_name_removes_modifiers(self, calculator):
-        result = calculator._clean_ingredient_name("fresh chopped onions")
-        assert "fresh" not in result.lower()
-        assert "chopped" not in result.lower()
-
-    def test_clean_ingredient_name_removes_parentheses(self, calculator):
-        result = calculator._clean_ingredient_name("flour (sifted)")
-        assert "(" not in result
-        assert ")" not in result
-
-    def test_convert_to_grams_cup(self, calculator):
-        result = calculator._convert_to_grams(2, "cups", "flour")
-        assert result == 480
-
-    def test_convert_to_grams_tablespoon(self, calculator):
-        result = calculator._convert_to_grams(3, "tbsp", "olive oil")
-        assert result == 45
-
-    def test_convert_to_grams_unknown_unit(self, calculator):
-        result = calculator._convert_to_grams(1, "unknown", "something")
-        assert result == 100
--- a/tests/podcasts_tests/test_scrapers.py
+++ b/tests/podcasts_tests/test_scrapers.py
@ -1,19 +0,0 @@
-import pytest
-from vrobbler.apps.podcasts.scrapers import scrape_data_from_google_podcasts
-
-expected_desc_snippet = "NPR's Up First is the news you need to start your day. "
-
-expected_img_url = "https://encrypted-tbn2.gstatic.com/images?q=tbn:ANd9GcR1F0CfR24RR6sme531yIkCrnK4zzmo97jeualO5drVPKG6oCk"
-expected_google_url = "https://podcasts.google.com/feed/aHR0cHM6Ly9mZWVkcy5ucHIub3JnLzUxMDMxOC9wb2RjYXN0LnhtbA"
-
-
-@pytest.mark.skip("Google Podcasts is gone")
-def test_get_not_allowed_from_mopidy():
-    query = "Up First"
-    result_dict = scrape_data_from_google_podcasts(query)
-
-    assert result_dict["title"] == query
-    assert expected_desc_snippet in result_dict["description"]
-    assert result_dict["image_url"] == expected_img_url
-    assert result_dict["producer"] == "NPR"
-    assert result_dict["google_url"] == expected_google_url
--- a/tests/scrobbles_tests/conftest.py
+++ b/tests/scrobbles_tests/conftest.py
@ -1,74 +1,36 @@
 import json
-
 import pytest
-from django.contrib.auth import get_user_model
-from rest_framework.authtoken.models import Token

-from boardgames.models import BoardGame
-from music.models import Track, Artist
 from scrobbles.models import Scrobble
-from people.models import Person
+from rest_framework.authtoken.models import Token
+from django.contrib.auth import get_user_model

 User = get_user_model()


-@pytest.fixture
-def boardgame_scrobble():
-    first = Person.objects.create(name="First Player")
-    second = Person.objects.create(name="Second Player")
-    return Scrobble.objects.create(
-        board_game=BoardGame.objects.create(title="Test Board Game"),
-        media_type="BoardGame",
-        played_to_completion=True,
-        log={
-            "players": [
-                {
-                    "person_id": first.id,
-                    "win": True,
-                    "score": 30,
-                    "color": "Blue",
-                },
-                {
-                    "person_id": second.id,
-                    "win": False,
-                    "score": 28,
-                    "color": "Red",
-                },
-            ],
-        },
-    )
-
-
-@pytest.fixture
-def test_track():
-    Track.objects.create(
-        title="Emotion",
-        artist=Artist.objects.create(name="Carly Rae Jepsen"),
-        base_run_time_seconds=60,
-    )
-
-
 class MopidyRequest:
    name = "Same in the End"
    artist = "Sublime"
    album = "Sublime"
    track_number = 4
    run_time_ticks = 156604
-    run_time = 60
+    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"  # noqa
+    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),
+            "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_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)
@ -99,89 +61,24 @@ class MopidyRequest:

@pytest.fixture
 def valid_auth_token():
-    user = User.objects.create(email="test@exmaple.com")
+    user = User.objects.create(email='test@exmaple.com')
    return Token.objects.create(user=user).key


@pytest.fixture
-def mopidy_track():
-    return MopidyRequest()
+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
+    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, artist="NPR", album="Up First"
-    ).request_json
-
-
-@pytest.fixture
-def mopidy_podcast_https_request_data():
-    mopidy_uri = "podcast+https://feeds.npr.org/510318/podcast.xml#85b9c4c4-ae09-43d9-8853-31ccf43f68e6"
-    return MopidyRequest(
-        mopidy_uri=mopidy_uri, artist="NPR", album="Up First"
-    ).request_json
-
-
-class JellyfinTrackRequest:
-    name = "Emotion"
-    artist = "Carly Rae Jepsen"
-    album = "Emotion"
-    track_number = 1
-    item_type = "Audio"
-    timestamp = "2024-01-14 12:00:19"
-    run_time_ticks = 156604
-    run_time = "00:00:60"
-    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"
-    status = "resumed"
-    client_name = "Jellyfin"
-
-    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),
-            "TrackNumber": int(kwargs.get("track_number", self.track_number)),
-            "RunTime": kwargs.get("run_time", self.run_time),
-            "ItemType": kwargs.get("item_type", self.item_type),
-            "UtcTimestamp": kwargs.get("timestamp", self.timestamp),
-            "PlaybackPositionTicks": int(
-                kwargs.get("playback_time_ticks", self.playback_time_ticks)
-            ),
-            "Provider_musicbrainztrack": kwargs.get(
-                "musicbrainz_track_id", self.musicbrainz_track_id
-            ),
-            "Provider_musicbrainzalbum": kwargs.get(
-                "musicbrainz_album_id", self.musicbrainz_album_id
-            ),
-            "Provider_musicbrainzartist": kwargs.get(
-                "musicbrainz_artist_id", self.musicbrainz_artist_id
-            ),
-            "Status": kwargs.get("status", self.status),
-            "ClientName": kwargs.get("client_name", self.client_name),
-        }
-
-    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 jellyfin_track():
-    return JellyfinTrackRequest()
+    return MopidyRequest(mopidy_uri=mopidy_uri).request_json
--- a/tests/scrobbles_tests/test_aggregators.py
+++ b/tests/scrobbles_tests/test_aggregators.py
@ -1,5 +1,4 @@
 from datetime import datetime, timedelta
-from unittest.mock import patch

 import pytest
 import time_machine
@ -7,110 +6,97 @@ 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_json, num=7, spacing=2, auth_token=None):
-    from rest_framework.authtoken.models import Token
-    import pytz
-
-    url = reverse("scrobbles:mopidy-webhook")
-    user = get_user_model().objects.create(username="Test User")
-    user.profile.timezone = "US/Eastern"
-    user.profile.save()
-    headers = {}
-    if auth_token:
-        headers = {"Authorization": f"Token {auth_token}"}
-        user = Token.objects.get(key=auth_token).user
-
-    client.post(url, request_json, content_type="application/json", headers=headers)
-    track = Scrobble.objects.last().track
-
-    est = pytz.timezone("US/Eastern")
+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):
-        naive_time = timezone.now().replace(tzinfo=None) - timedelta(days=i * spacing)
-        aware_time = est.localize(naive_time)
-        Scrobble.objects.create(
-            user=user,
-            track=track,
-            timestamp=aware_time,
-            played_to_completion=True,
-            source="Mopidy",
-        )
-    return user
+        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
-@patch("music.models.get_album_metadata_with_artist", return_value={})
-@patch("music.models.get_track_metadata_with_artist", return_value={})
-@patch("music.models.get_recording_mbid_exact", return_value=(None, None))
-@patch("music.models.lookup_artist_from_tadb", return_value={})
-@patch("music.models.lookup_album_from_tadb", return_value={})
@time_machine.travel(datetime(2022, 3, 4, 1, 24))
-def test_scrobble_counts_data(
-    mock_lookup_album_tadb,
-    mock_lookup_artist_tadb,
-    mock_get_recording,
-    mock_get_track,
-    mock_get_album,
-    client,
-    mopidy_track,
-    valid_auth_token,
-):
-    user = build_scrobbles(
-        client, mopidy_track.request_json, auth_token=valid_auth_token
-    )
+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,
+        'alltime': 7,
+        'month': 2,
+        'today': 1,
+        'week': 3,
+        'year': 7,
    }


@pytest.mark.django_db
-@patch("music.models.get_album_metadata_with_artist", return_value={})
-@patch("music.models.get_track_metadata_with_artist", return_value={})
-@patch("music.models.get_recording_mbid_exact", return_value=(None, None))
-@patch("music.models.lookup_artist_from_tadb", return_value={})
-@patch("music.models.lookup_album_from_tadb", return_value={})
-@time_machine.travel(datetime(2022, 3, 4, 1, 24))
-def test_live_charts(
-    mock_lookup_album_tadb,
-    mock_lookup_artist_tadb,
-    mock_get_recording,
-    mock_get_track,
-    mock_get_album,
-    client,
-    mopidy_track,
-    valid_auth_token,
-):
-    user = build_scrobbles(
-        client, mopidy_track.request_json, 7, 1, auth_token=valid_auth_token
-    )
-
+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"

-    tops = live_charts(user, chart_period="week")
+
+@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"

-    tops = live_charts(user, chart_period="month")
+
+@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"

-    tops = live_charts(user, chart_period="year")
+
+@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"

-    tops = live_charts(user, chart_period="week", media_type="Artist")
+
+@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"

-    tops = live_charts(user, chart_period="month", media_type="Artist")
+
+@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"

-    tops = live_charts(user, chart_period="year", media_type="Artist")
+
+@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_metadata.py
+++ b/tests/scrobbles_tests/test_metadata.py
@ -1,44 +0,0 @@
-import pytest
-
-# from scrobbles.dataclasses import BoardGameLogData, BoardGameScoreLogData
-
-
-@pytest.mark.skip("Need to get local tests running working again")
-@pytest.mark.django_db
-def test_boardgame_log_data(boardgame_scrobble):
-    assert boardgame_scrobble.logdata == BoardGameLogData(
-        players=[
-            BoardGameScoreLogData(
-                person_id=1,
-                bgg_username="",
-                color="Blue",
-                character=None,
-                team=None,
-                score=30,
-                win=True,
-                new=None,
-                rank=None,
-                seat_order=None,
-                role=None,
-            ),
-            BoardGameScoreLogData(
-                person_id=2,
-                bgg_username="",
-                color="Red",
-                character=None,
-                team=None,
-                score=28,
-                win=False,
-                new=None,
-                rank=None,
-                seat_order=None,
-                role=None,
-            ),
-        ],
-        difficulty=None,
-        solo=None,
-        two_handed=None,
-    )
-    assert len(boardgame_scrobble.logdata.players) == 1
-    assert boardgame_scrobble.logdata.players[0].user.id == 1
-    assert boardgame_scrobble.logdata.players[0].name == "Test"
--- a/tests/scrobbles_tests/test_scrobblers.py
+++ b/tests/scrobbles_tests/test_scrobblers.py
@ -1,59 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-from scrobbles.scrobblers import jellyfin_scrobble_media, mopidy_scrobble_media
-
-
-def test_jellyfin_scrobble_video_with_no_imdb_id():
-    with patch("scrobbles.scrobblers.Video") as mock_video_class:
-        mock_video_class.find_or_create.return_value = None
-
-        post_data = {
-            "ItemType": "Video",
-            "Name": "Test Video",
-            "Provider_imdb": "",
-            "PlaybackPosition": "00:05:00",
-            "NotificationType": "PlaybackProgress",
-            "UtcTimestamp": "2024-01-15T10:30:00Z",
-        }
-
-        result = jellyfin_scrobble_media(post_data, 1)
-
-        mock_video_class.find_or_create.assert_called_once_with(None)
-
-
-def test_jellyfin_scrobble_media_ignores_progress_with_zero_position():
-
-    post_data = {
-        "ItemType": "Audio",
-        "PlaybackPosition": "00:00:00",
-        "NotificationType": "PlaybackProgress",
-    }
-
-    result = jellyfin_scrobble_media(post_data, 1)
-
-    assert result is None
-
-
-def test_mopidy_scrobble_handles_missing_mopidy_uri():
-
-    with patch("scrobbles.scrobblers.Track") as mock_track_class:
-        with patch("scrobbles.scrobblers.parse_mopidy_uri", return_value=None):
-            mock_track = MagicMock()
-            mock_track.scrobble_for_user = MagicMock(return_value=MagicMock())
-            mock_track_class.find_or_create.return_value = mock_track
-
-            post_data = {
-                "name": "Test Song",
-                "artist": "Test Artist",
-                "album": "Test Album",
-                "run_time": 180000,
-            }
-
-            result = mopidy_scrobble_media(post_data, 1)
-
-            mock_track_class.find_or_create.assert_called_once_with(
-                title="Test Song",
-                artist_name="Test Artist",
-                album_name="Test Album",
-                run_time_seconds=180000,
-            )
--- a/tests/scrobbles_tests/test_utils.py
+++ b/tests/scrobbles_tests/test_utils.py
@ -1,10 +0,0 @@
-from datetime import datetime
-import pytz
-from django.contrib.auth import get_user_model
-
-from vrobbler.apps.scrobbles.utils import timestamp_user_tz_to_utc
-
-
-def test_timestamp_user_tz_to_utc():
-    timestamp = timestamp_user_tz_to_utc(1685561082, pytz.timezone("US/Eastern"))
-    assert timestamp == datetime(2023, 5, 31, 23, 24, 42, tzinfo=pytz.utc)
--- a/tests/scrobbles_tests/test_views.py
+++ b/tests/scrobbles_tests/test_views.py
--- a/tests/tasks_tests/test_todoist.py
+++ b/tests/tasks_tests/test_todoist.py
@ -1,127 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pytest
-from django.contrib.auth import get_user_model
-
-User = get_user_model()
-
-
-@pytest.fixture
-def user_profile(db):
-    user = User.objects.create_user(username="testuser", password="testpass")
-    return user.profile
-
-
-@pytest.mark.django_db
-class TestGenerateTodoistOauthUrl:
-    def test_generates_url_with_state(self, user_profile):
-        from tasks.todoist import generate_todoist_oauth_url
-
-        url = generate_todoist_oauth_url(user_profile.user_id)
-
-        user_profile.refresh_from_db()
-        assert user_profile.todoist_state is not None
-        assert len(user_profile.todoist_state) == 32
-        assert url.startswith("https://todoist.com/oauth/authorize")
-        assert user_profile.todoist_state in url
-
-    def test_updates_existing_state(self, user_profile):
-        from tasks.todoist import generate_todoist_oauth_url
-
-        old_state = "oldstate12345678901234567890123"
-        user_profile.todoist_state = old_state
-        user_profile.save()
-
-        url = generate_todoist_oauth_url(user_profile.user_id)
-
-        user_profile.refresh_from_db()
-        assert user_profile.todoist_state != old_state
-
-
-@pytest.mark.django_db
-class TestGetTodoistAccessToken:
-    def test_raises_when_profile_not_found(self):
-        from tasks.todoist import get_todoist_access_token
-
-        with pytest.raises(Exception, match="Could not find profile"):
-            get_todoist_access_token(user_id=999, state="anystate", code="anycode")
-
-    def test_raises_when_state_mismatch(self, user_profile):
-        from tasks.todoist import get_todoist_access_token
-
-        user_profile.todoist_state = "correctstate1234567890123"
-        user_profile.save()
-
-        with pytest.raises(Exception, match="state mismatch"):
-            get_todoist_access_token(
-                user_id=user_profile.user_id, state="wrongstate", code="anycode"
-            )
-
-    @patch("tasks.todoist.requests.post")
-    def test_exchanges_code_for_token(self, mock_post, user_profile):
-        from tasks.todoist import get_todoist_access_token
-
-        user_profile.todoist_state = "correctstate1234567890123"
-        user_profile.save()
-
-        mock_token_response = MagicMock()
-        mock_token_response.status_code = 200
-        mock_token_response.json.return_value = {"access_token": "test_access_token"}
-        mock_post.return_value = mock_token_response
-
-        get_todoist_access_token(
-            user_id=user_profile.user_id,
-            state="correctstate1234567890123",
-            code="testcode",
-        )
-
-        user_profile.refresh_from_db()
-        assert user_profile.todoist_auth_key == "test_access_token"
-        assert user_profile.todoist_state is None
-
-    @patch("tasks.todoist.requests.post")
-    def test_fetches_todoist_user_id(self, mock_post, user_profile):
-        from tasks.todoist import get_todoist_access_token
-
-        user_profile.todoist_state = "correctstate1234567890123"
-        user_profile.save()
-
-        mock_token_response = MagicMock()
-        mock_token_response.status_code = 200
-        mock_token_response.json.return_value = {"access_token": "test_access_token"}
-
-        mock_sync_response = MagicMock()
-        mock_sync_response.status_code = 200
-        mock_sync_response.json.return_value = {"user": {"id": "12345"}}
-
-        mock_post.side_effect = [mock_token_response, mock_sync_response]
-
-        get_todoist_access_token(
-            user_id=user_profile.user_id,
-            state="correctstate1234567890123",
-            code="testcode",
-        )
-
-        user_profile.refresh_from_db()
-        assert user_profile.todoist_user_id == "12345"
-
-    @patch("tasks.todoist.requests.post")
-    def test_handles_token_exchange_failure(self, mock_post, user_profile):
-        from tasks.todoist import get_todoist_access_token
-
-        user_profile.todoist_state = "correctstate1234567890123"
-        user_profile.save()
-
-        mock_response = MagicMock()
-        mock_response.status_code = 400
-        mock_post.return_value = mock_response
-
-        get_todoist_access_token(
-            user_id=user_profile.user_id,
-            state="correctstate1234567890123",
-            code="badcode",
-        )
-
-        user_profile.refresh_from_db()
-        assert user_profile.todoist_auth_key is None
-        assert user_profile.todoist_state == "correctstate1234567890123"
--- a/tests/test_context_processors.py
+++ b/tests/test_context_processors.py
@ -1,167 +0,0 @@
-import os
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from vrobbler import context_processors
-from vrobbler.context_processors import version_info
-
-
-@pytest.fixture(autouse=True)
-def reset_git_cache():
-    context_processors._GIT_COMMIT = None
-
-
-@pytest.fixture
-def mock_request():
-    return MagicMock()
-
-
-class TestVersionInfo:
-    def test_returns_version_and_commit(self, mock_request):
-        """Test that git commit is returned when _commit.py doesn't exist"""
-        with (
-            patch("vrobbler.context_processors.get_version") as mock_get_version,
-            patch(
-                "vrobbler.context_processors.subprocess.check_output"
-            ) as mock_check_output,
-        ):
-            mock_get_version.return_value = "1.0.0"
-            mock_check_output.return_value = b"abc1234"
-
-            # Mock the import to raise ImportError so git is used
-            import builtins
-
-            original_import = builtins.__import__
-
-            def mock_import(name, *args, **kwargs):
-                if name == "vrobbler._commit":
-                    raise ImportError("No module named 'vrobbler._commit'")
-                return original_import(name, *args, **kwargs)
-
-            with patch("builtins.__import__", side_effect=mock_import):
-                result = version_info(mock_request)
-
-            assert result["app_version"] == "1.0.0"
-            assert result["git_commit"] == "abc1234"
-
-    def test_uses_env_commit_if_set(self, mock_request):
-        with (
-            patch.dict(os.environ, {"VROBBLER_COMMIT": "env_commit_hash"}),
-            patch("vrobbler.context_processors.get_version") as mock_get_version,
-        ):
-            mock_get_version.return_value = "1.0.0"
-
-            result = version_info(mock_request)
-
-            assert result["git_commit"] == "env_commit_hash"
-
-    def test_uses_commit_from_module_when_available(self, mock_request):
-        """Test that commit from _commit.py module is used when available"""
-        with (patch("vrobbler.context_processors.get_version") as mock_get_version,):
-            mock_get_version.return_value = "1.0.0"
-
-            result = version_info(mock_request)
-
-            # Should use whatever value is in vrobbler/_commit.py
-            # Could be "unknown" or an actual commit hash
-            assert "git_commit" in result
-            assert result["git_commit"] != ""
-
-    def test_uses_commit_from_file_when_module_unavailable(self, mock_request):
-        """Test that commit from /var/lib/vrobbler/commit.txt is used"""
-        with (
-            patch("vrobbler.context_processors.get_version") as mock_get_version,
-            patch("pathlib.Path.exists", return_value=True),
-            patch("pathlib.Path.read_text", return_value="file_commit_hash"),
-        ):
-            mock_get_version.return_value = "1.0.0"
-
-            # Mock the import to raise ImportError
-            import builtins
-
-            original_import = builtins.__import__
-
-            def mock_import(name, *args, **kwargs):
-                if name == "vrobbler._commit":
-                    raise ImportError("No module named 'vrobbler._commit'")
-                return original_import(name, *args, **kwargs)
-
-            with patch("builtins.__import__", side_effect=mock_import):
-                result = version_info(mock_request)
-
-            assert result["git_commit"] == "file_commit_hash"
-
-    def test_falls_back_to_git_when_file_unavailable(self, mock_request):
-        """Test fallback to git when _commit.py and file don't exist"""
-        with (
-            patch("vrobbler.context_processors.get_version") as mock_get_version,
-            patch("pathlib.Path.exists", return_value=False),
-            patch(
-                "vrobbler.context_processors.subprocess.check_output"
-            ) as mock_check_output,
-        ):
-            mock_get_version.return_value = "1.0.0"
-            mock_check_output.return_value = b"git_commit_hash"
-
-            # Mock the import to raise ImportError
-            import builtins
-
-            original_import = builtins.__import__
-
-            def mock_import(name, *args, **kwargs):
-                if name == "vrobbler._commit":
-                    raise ImportError("No module named 'vrobbler._commit'")
-                return original_import(name, *args, **kwargs)
-
-            with patch("builtins.__import__", side_effect=mock_import):
-                result = version_info(mock_request)
-
-            assert result["git_commit"] == "git_commit_hash"
-
-    def test_returns_unknown_when_version_fails(self, mock_request):
-        with (
-            patch("vrobbler.context_processors.get_version") as mock_get_version,
-            patch(
-                "vrobbler.context_processors.subprocess.check_output"
-            ) as mock_check_output,
-        ):
-            mock_get_version.side_effect = Exception("not found")
-            mock_check_output.return_value = b"abc1234"
-
-            result = version_info(mock_request)
-
-            assert result["app_version"] == "unknown"
-
-    def test_returns_unknown_when_git_fails(self, mock_request):
-        import subprocess
-
-        with (
-            patch("vrobbler.context_processors.get_version") as mock_get_version,
-            patch(
-                "vrobbler.context_processors.subprocess.check_output"
-            ) as mock_check_output,
-        ):
-            mock_get_version.return_value = "1.0.0"
-            mock_check_output.side_effect = subprocess.SubprocessError()
-
-            result = version_info(mock_request)
-
-            assert result["git_commit"] == "unknown"
-
-    def test_returns_unknown_when_git_not_found(self, mock_request):
-        import subprocess
-
-        with (
-            patch("vrobbler.context_processors.get_version") as mock_get_version,
-            patch(
-                "vrobbler.context_processors.subprocess.check_output"
-            ) as mock_check_output,
-        ):
-            mock_get_version.return_value = "1.0.0"
-            mock_check_output.side_effect = FileNotFoundError()
-
-            result = version_info(mock_request)
-
-            assert result["git_commit"] == "unknown"
--- a/tests/trails_tests/init.py
+++ b/tests/trails_tests/init.py
--- a/tests/trails_tests/test_gpx_importer.py
+++ b/tests/trails_tests/test_gpx_importer.py
@ -1,281 +0,0 @@
-import os
-import tempfile
-from datetime import timedelta
-
-import pytest
-from django.contrib.auth import get_user_model
-from django.core.files import File
-
-from locations.models import GeoLocation
-from scrobbles.importers.trail_gpx import (
-    compute_trail_stats,
-    find_route_waypoint,
-    import_trail_gpx,
-    parse_trackpoints,
-)
-from scrobbles.models import Scrobble, TrailGPXImport
-from trails.models import Trail, TrailLogData
-
-User = get_user_model()
-
-SAMPLE_GPX = os.path.join(
-    os.path.dirname(__file__), "..", "..", "data", "sample_trail.gpx"
-)
-
-
-@pytest.fixture
-def user(db):
-    return User.objects.create(email="trailblazer@example.com")
-
-
-@pytest.fixture
-def sample_gpx_path():
-    return SAMPLE_GPX
-
-
-class TestParseTrackpoints:
-    def test_parses_gpx(self, sample_gpx_path):
-        result = parse_trackpoints(sample_gpx_path)
-        points = result["points"]
-        assert len(points) == 837
-        assert result["name"] == "Morning Run ⛅"
-        assert result["description"] == "Run"
-        lat, lon, ele, t = points[0]
-        assert round(lat, 6) == 34.190598
-        assert round(lon, 6) == -118.844015
-        assert ele == 305.3
-        assert t is not None
-
-    def test_first_and_last_times(self, sample_gpx_path):
-        result = parse_trackpoints(sample_gpx_path)
-        points = result["points"]
-        first_time = points[0][3]
-        last_time = points[-1][3]
-        duration = (last_time - first_time).total_seconds()
-        assert duration == pytest.approx(3770, abs=5)
-
-    def test_gpx_extra_metadata(self, sample_gpx_path):
-        result = parse_trackpoints(sample_gpx_path)
-        extra = result["extra"]
-        assert extra["avg_heartrate"] == 159
-        assert extra["max_heartrate"] == 183
-        assert extra["avg_speed_kmh"] == pytest.approx(9.82, abs=0.1)
-        assert extra["activity_type"] == "Run"
-        assert extra["moving_time_seconds"] == 3008
-        assert extra["total_elevation_gain_m"] == 246.4
-
-
-class TestImportTrailGPX:
-    def test_creates_trail(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        assert Trail.objects.filter(title="Morning Run ⛅").exists()
-
-    def test_creates_geolocation(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        assert GeoLocation.objects.filter(lat=34.190598, lon=-118.844015).exists()
-
-    def test_sets_trailhead(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        trail = Trail.objects.filter(title="Morning Run ⛅").first()
-        assert trail.trailhead_location is not None
-        assert round(trail.trailhead_location.lat, 6) == 34.190598
-
-    def test_creates_scrobble(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        assert Scrobble.objects.filter(source="GPX Import").count() == 1
-
-    def test_scrobble_timestamps(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        scrobble = Scrobble.objects.filter(source="GPX Import").first()
-        assert scrobble.timestamp.isoformat().startswith("2022-06-05T13:55:09")
-        assert scrobble.stop_timestamp.isoformat().startswith("2022-06-05T14:57:59")
-        assert scrobble.media_type == Scrobble.MediaType.TRAIL
-
-    def test_scrobble_has_trail_fk(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        scrobble = Scrobble.objects.filter(source="GPX Import").first()
-        assert scrobble.trail is not None
-        assert scrobble.trail.title == "Morning Run ⛅"
-
-    def test_scrobble_has_gpx_file(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        scrobble = Scrobble.objects.filter(source="GPX Import").first()
-        assert scrobble.gpx_file
-        assert scrobble.gpx_file.name.endswith(".gpx")
-
-    def test_lookup_existing_trail_by_trailhead(self, user, sample_gpx_path):
-        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
-        trail = Trail.objects.create(title="Existing Trail", trailhead_location=geo)
-        import_trail_gpx(sample_gpx_path, user.id)
-        scrobble = Scrobble.objects.filter(source="GPX Import").first()
-        assert scrobble.trail.id == trail.id
-
-    def test_dedup(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        import_trail_gpx(sample_gpx_path, user.id)
-        assert Scrobble.objects.filter(source="GPX Import").count() == 1
-
-    def test_scrobble_log_has_stats(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        scrobble = Scrobble.objects.filter(source="GPX Import").first()
-        log = scrobble.log
-        assert log["distance_km"] == pytest.approx(8.2, abs=0.2)
-        assert log["elevation_gain_m"] == pytest.approx(260, abs=20)
-        assert log["moving_time_seconds"] == pytest.approx(3770, abs=10)
-        assert log["avg_speed_kmh"] == pytest.approx(7.8, abs=0.5)
-        assert log["description"] == "Run"
-
-    def test_scrobble_playback_position(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        scrobble = Scrobble.objects.filter(source="GPX Import").first()
-        assert scrobble.playback_position_seconds == pytest.approx(3770, abs=5)
-
-    def test_scrobble_has_timezone(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        scrobble = Scrobble.objects.filter(source="GPX Import").first()
-        assert scrobble.timezone is not None
-        assert isinstance(scrobble.timezone, str)
-
-    def test_scrobble_log_extra_metadata(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        scrobble = Scrobble.objects.filter(source="GPX Import").first()
-        log = scrobble.log
-        assert log["avg_heartrate"] == 159
-        assert log["max_heartrate"] == 183
-        assert log["activity_type"] == "Run"
-
-    def test_scrobble_log_no_calories_in_gpx(self, user, sample_gpx_path):
-        import_trail_gpx(sample_gpx_path, user.id)
-        scrobble = Scrobble.objects.filter(source="GPX Import").first()
-        assert scrobble.log.get("calories") is None
-
-
-class TestComputeTrailStats:
-    def test_computes_distance_and_elevation(self, sample_gpx_path):
-        result = parse_trackpoints(sample_gpx_path)
-        stats = compute_trail_stats(result["points"])
-        assert stats["distance_km"] == pytest.approx(8.2, abs=0.2)
-        assert stats["elevation_gain_m"] == pytest.approx(260, abs=20)
-        assert stats["moving_time_seconds"] == pytest.approx(3770, abs=10)
-        assert stats["avg_speed_kmh"] == pytest.approx(7.8, abs=0.5)
-
-
-class TestTrailGPXImportModel:
-    def test_create_import_model(self, db, user, sample_gpx_path):
-        imp = TrailGPXImport.objects.create(
-            user=user,
-            original_filename="test_trail.gpx",
-        )
-        assert imp.uuid is not None
-        assert imp.import_type == "Trail GPX"
-
-    @pytest.mark.django_db(transaction=True)
-    def test_process_via_model(self, user, sample_gpx_path):
-        imp = TrailGPXImport.objects.create(
-            user=user,
-            original_filename="Morning Run.gpx",
-        )
-        with open(sample_gpx_path, "rb") as f:
-            imp.gpx_file.save("Morning Run.gpx", File(f), save=True)
-        imp.process()
-        imp.refresh_from_db()
-        assert imp.process_count == 1
-        assert imp.processed_finished is not None
-
-
-class TestFindRouteWaypoint:
-    def test_returns_halfway_point(self, sample_gpx_path):
-        result = parse_trackpoints(sample_gpx_path)
-        pt = find_route_waypoint(result["points"])
-        assert pt is not None
-        lat, lon = pt
-        assert lat == pytest.approx(34.177853, abs=0.001)
-        assert lon == pytest.approx(-118.829944, abs=0.001)
-
-    def test_returns_last_point_for_short_track(self):
-        points = [(34.0, -118.0, None, None), (34.001, -118.001, None, None)]
-        pt = find_route_waypoint(points)
-        assert pt == (34.001, -118.001)
-
-    def test_returns_none_for_empty_points(self):
-        assert find_route_waypoint([]) is None
-
-
-class TestFindByTrailhead:
-    def test_exact_match(self, db):
-        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
-        trail = Trail.objects.create(title="Test Trail", trailhead_location=geo)
-        found = Trail.find_by_trailhead(34.190598, -118.844015)
-        assert found == trail
-
-    def test_within_tolerance(self, db):
-        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
-        trail = Trail.objects.create(title="Nearby Trail", trailhead_location=geo)
-        found = Trail.find_by_trailhead(34.191000, -118.844000, tolerance_m=100)
-        assert found == trail
-
-    def test_beyond_tolerance(self, db):
-        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
-        Trail.objects.create(title="Far Trail", trailhead_location=geo)
-        found = Trail.find_by_trailhead(34.200000, -118.850000, tolerance_m=50)
-        assert found is None
-
-    def test_no_trailhead_returns_none(self, db):
-        Trail.objects.create(title="No Location")
-        found = Trail.find_by_trailhead(34.190598, -118.844015)
-        assert found is None
-
-    def test_same_trailhead_same_route_matches(self, db):
-        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
-        trail = Trail.objects.create(
-            title="Same Route Trail",
-            trailhead_location=geo,
-            route_lat=34.192167,
-            route_lon=-118.843143,
-        )
-        found = Trail.find_by_trailhead(
-            34.190598, -118.844015,
-            route_lat=34.192167, route_lon=-118.843143,
-            tolerance_m=100,
-        )
-        assert found == trail
-
-    def test_same_trailhead_different_route_does_not_match(self, db):
-        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
-        Trail.objects.create(
-            title="Different Route Trail",
-            trailhead_location=geo,
-            route_lat=34.200000,
-            route_lon=-118.850000,
-        )
-        found = Trail.find_by_trailhead(
-            34.190598, -118.844015,
-            route_lat=34.192167, route_lon=-118.843143,
-            tolerance_m=100,
-        )
-        assert found is None
-
-    def test_legacy_trail_without_route_still_matches(self, db):
-        geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
-        trail = Trail.objects.create(
-            title="Legacy Trail",
-            trailhead_location=geo,
-        )
-        found = Trail.find_by_trailhead(
-            34.190598, -118.844015,
-            route_lat=34.192167, route_lon=-118.843143,
-            tolerance_m=100,
-        )
-        assert found == trail
-
-
-class TestFindOrCreate:
-    def test_find_existing(self, db):
-        Trail.objects.create(title="Existing Trail")
-        trail = Trail.find_or_create("Existing Trail")
-        assert trail.title == "Existing Trail"
-
-    def test_create_new(self, db):
-        trail = Trail.find_or_create("New Trail")
-        assert trail.title == "New Trail"
-        assert Trail.objects.count() == 1
--- a/tests/videos_tests/init.py
+++ b/tests/videos_tests/init.py
--- a/tests/videos_tests/test_api.py
+++ b/tests/videos_tests/test_api.py
@ -1,98 +0,0 @@
-import pytest
-from django.contrib.auth import get_user_model
-from rest_framework.authtoken.models import Token
-
-from videos.models import Channel, Series, Video
-
-User = get_user_model()
-
-
-@pytest.fixture
-def auth_headers():
-    user = User.objects.create(email="api@test.com")
-    token = Token.objects.create(user=user)
-    return {"HTTP_AUTHORIZATION": f"Token {token.key}"}
-
-
-@pytest.fixture
-def channel():
-    return Channel.objects.create(name="Test Channel")
-
-
-@pytest.fixture
-def series():
-    return Series.objects.create(
-        name="Test Series",
-    )
-
-
-@pytest.fixture
-def video(channel):
-    return Video.objects.create(
-        title="Test Video",
-        imdb_id="tt1234567",
-        channel=channel,
-    )
-
-
-@pytest.mark.django_db
-class TestVideoAPI:
-    def test_list_videos(self, client, auth_headers, video):
-        response = client.get("/api/v1/videos/", **auth_headers)
-        assert response.status_code == 200
-        assert len(response.data["results"]) == 1
-        assert response.data["results"][0]["title"] == "Test Video"
-
-    def test_get_video(self, client, auth_headers, video):
-        response = client.get(f"/api/v1/videos/{video.id}/", **auth_headers)
-        assert response.status_code == 200
-        assert response.data["title"] == "Test Video"
-
-    def test_filter_videos_by_channel(self, client, auth_headers, channel, video):
-        response = client.get(f"/api/v1/videos/?channel={channel.id}", **auth_headers)
-        assert response.status_code == 200
-        assert len(response.data["results"]) == 1
-        assert response.data["results"][0]["channel"] == channel.id
-
-
-@pytest.mark.django_db
-class TestChannelAPI:
-    def test_list_channels(self, client, auth_headers, channel):
-        response = client.get("/api/v1/channels/", **auth_headers)
-        assert response.status_code == 200
-        assert len(response.data["results"]) == 1
-        assert response.data["results"][0]["name"] == "Test Channel"
-
-    def test_get_channel(self, client, auth_headers, channel):
-        response = client.get(f"/api/v1/channels/{channel.id}/", **auth_headers)
-        assert response.status_code == 200
-        assert response.data["name"] == "Test Channel"
-
-
-@pytest.mark.django_db
-class TestSeriesAPI:
-    def test_list_series(self, client, auth_headers, series):
-        response = client.get("/api/v1/series/", **auth_headers)
-        assert response.status_code == 200
-        assert len(response.data["results"]) == 1
-        assert response.data["results"][0]["name"] == "Test Series"
-
-    def test_get_series(self, client, auth_headers, series):
-        response = client.get(f"/api/v1/series/{series.id}/", **auth_headers)
-        assert response.status_code == 200
-        assert response.data["name"] == "Test Series"
-
-
-@pytest.mark.django_db
-class TestVideoAPIUnauthorized:
-    def test_list_videos_unauthenticated(self, client, video):
-        response = client.get("/api/v1/videos/")
-        assert response.status_code == 401
-
-    def test_list_channels_unauthenticated(self, client, channel):
-        response = client.get("/api/v1/channels/")
-        assert response.status_code == 401
-
-    def test_list_series_unauthenticated(self, client, series):
-        response = client.get("/api/v1/series/")
-        assert response.status_code == 401
--- a/tests/videos_tests/test_imdb.py
+++ b/tests/videos_tests/test_imdb.py
--- a/tests/videos_tests/test_video_find_or_create.py
+++ b/tests/videos_tests/test_video_find_or_create.py
@ -1,17 +0,0 @@
-import pytest
-from videos.models import Video
-
-
-@pytest.mark.django_db
-class TestVideoFindOrCreate:
-    def test_find_or_create_with_none_returns_none(self):
-        result = Video.find_or_create(None)
-        assert result is None
-
-    def test_find_or_create_with_empty_string_returns_none(self):
-        result = Video.find_or_create("")
-        assert result is None
-
-    def test_find_or_create_with_invalid_id_returns_none(self):
-        result = Video.find_or_create("invalid-id")
-        assert result is None
--- a/tests/videos_tests/test_youtube.py
+++ b/tests/videos_tests/test_youtube.py
@ -1,9 +0,0 @@
-import pytest
-from videos.sources.youtube import lookup_video_from_youtube
-
-
-@pytest.mark.skip(reason="Need to configure Youtube API stuffs in CI")
-@pytest.mark.django_db
-def test_lookup_youtube_id():
-    metadata = lookup_video_from_youtube("RZxs9pAv99Y")
-    assert metadata.title == "No Pun Included's Board Game of the Year 2024"
--- 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.example
+++ b/vrobbler.conf.example
@ -1,31 +1,11 @@
 # You can use this file to set environment variables for your local setup
 #
 VROBBLER_DEBUG=True
-VROBBLER_LOG_LEVEL="DEBUG"
 VROBBLER_JSON_LOGGING=True
+VROBBLER_LOG_LEVEL="DEBUG"
 VROBBLER_MEDIA_ROOT = "/media/"
-VROBBLER_KEEP_DETAILED_SCROBBLE_LOGS=False
+VROBBLER_TMDB_API_KEY = "KEY"
+VROBBLER_KEEP_DETAILED_SCROBBLE_LOGS=True

-VROBBLER_USE_S3=False
-# You may also need to set these in your environment
-AWS_S3_ACCESS_KEY_ID=""
-AWS_S3_SECRET_ACCESS_KEY=""
-AWS_S3_CUSTOM_DOMAIN="https://minio.dev/"
-
-# API keys
-VROBBLER_TMDB_API_KEY = "<key>"
-VROBBLER_LASTFM_API_KEY = "<key>"
-VROBBLER_LASTFM_SECRET_KEY = "<key>"
-VROBBLER_THESPORTSDB_API_KEY="<key>"
-VROBBLER_THEAUDIODB_API_KEY="<key>"
-VROBBLER_IGDB_CLIENT_ID="<id>"
-VROBBLER_IGDB_CLIENT_SECRET="<key>"
-VROBBLER_COMICVINE_API_KEY="<key>"
-VROBBLER_TODOIST_CLIENT_ID="<id>"
-VROBBLER_TODOIST_CLIENT_SECRET="<key>"
-VROBBLER_GOOGLE_API_KEY="<key>"
-VROBBLER_LICHESS_API_KEY = "<key>"
-
-# Storages
-# VROBBLER_DATABASE_URL="postgres://USER:PASSWORD@HOST:PORT/NAME"
-# VROBBLER_REDIS_URL="redis://:PASS@HOST:6379/0"
+VROBBLER_DATABASE_URL="postgres://USER:PASSWORD@HOST:PORT/NAME"
+VROBBLER_REDIS_URL="redis://:PASS@HOST:6379/0"
--- a/vrobbler.conf.test
+++ b/vrobbler.conf.test
@ -1,11 +1,8 @@
 # Local configuration for Emus

-VROBBLER_DUMP_REQUEST_DATA=False
-VROBBLER_LOG_TO_CONSOLE=False
-VROBBLER_DEBUG=False
+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=False
-
-VROBBLER_USE_S3="False"
-VROBBLER_DATABASE_URL="sqlite:///testdb.sqlite3"
+VROBBLER_KEEP_DETAILED_SCROBBLE_LOGS=True
--- a/vrobbler/init.py
+++ b/vrobbler/init.py
@ -2,5 +2,4 @@
 # Django starts so that shared_task will use this app.
 from .celery import app as celery_app

-__version__ = "42.0"
-__all__ = ("celery_app", "__version__")
+__all__ = ('celery_app',)
--- a/vrobbler/_commit.py
+++ b/vrobbler/_commit.py
@ -1 +0,0 @@
-commit = "unknown"
--- a/vrobbler/apps/beers/admin.py
+++ b/vrobbler/apps/beers/admin.py
@ -1,35 +0,0 @@
-from beers.models import Beer, BeerProducer, BeerStyle
-from django.contrib import admin
-from scrobbles.admin import ScrobbleInline
-
-
-class BeerInline(admin.TabularInline):
-    model = Beer
-    extra = 0
-
-
-@admin.register(BeerStyle)
-class BeerStyle(admin.ModelAdmin):
-    date_hierarchy = "created"
-    search_fields = ("name",)
-
-
-@admin.register(BeerProducer)
-class BeerProducer(admin.ModelAdmin):
-    date_hierarchy = "created"
-    search_fields = ("name",)
-
-
-@admin.register(Beer)
-class BeerAdmin(admin.ModelAdmin):
-    date_hierarchy = "created"
-    list_display = (
-        "uuid",
-        "title",
-    )
-    raw_id_fields = ("styles", "producer")
-    ordering = ("-created",)
-    search_fields = ("title",)
-    inlines = [
-        ScrobbleInline,
-    ]
--- a/vrobbler/apps/beers/api/init.py
+++ b/vrobbler/apps/beers/api/init.py
--- a/vrobbler/apps/beers/api/serializers.py
+++ b/vrobbler/apps/beers/api/serializers.py
@ -1,20 +0,0 @@
-from rest_framework import serializers
-from beers.models import Beer, BeerProducer, BeerStyle
-
-
-class BeerSerializer(serializers.HyperlinkedModelSerializer):
-    class Meta:
-        model = Beer
-        fields = "__all__"
-
-
-class BeerProducerSerializer(serializers.HyperlinkedModelSerializer):
-    class Meta:
-        model = BeerProducer
-        fields = "__all__"
-
-
-class BeerStyleSerializer(serializers.HyperlinkedModelSerializer):
-    class Meta:
-        model = BeerStyle
-        fields = "__all__"
--- a/vrobbler/apps/beers/api/views.py
+++ b/vrobbler/apps/beers/api/views.py
@ -1,21 +0,0 @@
-from rest_framework import permissions, viewsets
-from beers.api import serializers
-from beers import models
-
-
-class BeerViewSet(viewsets.ModelViewSet):
-    queryset = models.Beer.objects.all().order_by("-created")
-    serializer_class = serializers.BeerSerializer
-    permission_classes = [permissions.IsAuthenticated]
-
-
-class BeerProducerViewSet(viewsets.ModelViewSet):
-    queryset = models.BeerProducer.objects.all().order_by("-created")
-    serializer_class = serializers.BeerProducerSerializer
-    permission_classes = [permissions.IsAuthenticated]
-
-
-class BeerStyleViewSet(viewsets.ModelViewSet):
-    queryset = models.BeerStyle.objects.all().order_by("-created")
-    serializer_class = serializers.BeerStyleSerializer
-    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/beers/apps.py
+++ b/vrobbler/apps/beers/apps.py
@ -1,5 +0,0 @@
-from django.apps import AppConfig
-
-
-class BeersConfig(AppConfig):
-    name = "beers"
--- a/vrobbler/apps/beers/migrations/0001_initial.py
+++ b/vrobbler/apps/beers/migrations/0001_initial.py
@ -1,133 +0,0 @@
-# Generated by Django 4.2.16 on 2024-10-22 21:26
-
-from django.db import migrations, models
-import django_extensions.db.fields
-import taggit.managers
-import uuid
-
-
-class Migration(migrations.Migration):
-
-    initial = True
-
-    dependencies = [
-        ("scrobbles", "0065_alter_scrobble_log"),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="BeerProducer",
-            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"
-                    ),
-                ),
-                ("description", models.TextField(blank=True, null=True)),
-                (
-                    "location",
-                    models.CharField(blank=True, max_length=255, null=True),
-                ),
-            ],
-            options={
-                "get_latest_by": "modified",
-                "abstract": False,
-            },
-        ),
-        migrations.CreateModel(
-            name="Beer",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                (
-                    "created",
-                    django_extensions.db.fields.CreationDateTimeField(
-                        auto_now_add=True, verbose_name="created"
-                    ),
-                ),
-                (
-                    "modified",
-                    django_extensions.db.fields.ModificationDateTimeField(
-                        auto_now=True, verbose_name="modified"
-                    ),
-                ),
-                (
-                    "uuid",
-                    models.UUIDField(
-                        blank=True,
-                        default=uuid.uuid4,
-                        editable=False,
-                        null=True,
-                    ),
-                ),
-                (
-                    "title",
-                    models.CharField(blank=True, max_length=255, null=True),
-                ),
-                (
-                    "run_time_seconds",
-                    models.IntegerField(blank=True, null=True),
-                ),
-                (
-                    "run_time_ticks",
-                    models.PositiveBigIntegerField(blank=True, null=True),
-                ),
-                ("description", models.TextField(blank=True, null=True)),
-                ("ibu", models.SmallIntegerField(blank=True, null=True)),
-                ("abv", models.FloatField(blank=True, null=True)),
-                (
-                    "style",
-                    models.CharField(blank=True, max_length=100, null=True),
-                ),
-                ("non_alcoholic", models.BooleanField(default=False)),
-                (
-                    "beeradvocate_id",
-                    models.CharField(blank=True, max_length=255, null=True),
-                ),
-                (
-                    "beeradvocate_score",
-                    models.SmallIntegerField(blank=True, null=True),
-                ),
-                (
-                    "untappd_id",
-                    models.CharField(blank=True, max_length=255, null=True),
-                ),
-                (
-                    "genre",
-                    taggit.managers.TaggableManager(
-                        blank=True,
-                        help_text="A comma-separated list of tags.",
-                        through="scrobbles.ObjectWithGenres",
-                        to="scrobbles.Genre",
-                        verbose_name="Tags",
-                    ),
-                ),
-            ],
-            options={
-                "abstract": False,
-            },
-        ),
-    ]
--- a/vrobbler/apps/beers/migrations/0002_beer_beeradvocate_image_beer_producer_and_more.py
+++ b/vrobbler/apps/beers/migrations/0002_beer_beeradvocate_image_beer_producer_and_more.py
@ -1,36 +0,0 @@
-# Generated by Django 4.2.16 on 2024-10-22 21:34
-
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("beers", "0001_initial"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="beer",
-            name="beeradvocate_image",
-            field=models.ImageField(
-                blank=True, null=True, upload_to="beers/beeradvcoate/"
-            ),
-        ),
-        migrations.AddField(
-            model_name="beer",
-            name="producer",
-            field=models.ForeignKey(
-                blank=True,
-                null=True,
-                on_delete=django.db.models.deletion.DO_NOTHING,
-                to="beers.beerproducer",
-            ),
-        ),
-        migrations.AddField(
-            model_name="beerproducer",
-            name="beeradvocate_id",
-            field=models.CharField(blank=True, max_length=255, null=True),
-        ),
-    ]
--- a/vrobbler/apps/beers/migrations/0003_beerstyle_remove_beer_beeradvocate_image_and_more.py
+++ b/vrobbler/apps/beers/migrations/0003_beerstyle_remove_beer_beeradvocate_image_and_more.py
@ -1,75 +0,0 @@
-# Generated by Django 4.2.16 on 2024-10-22 21:47
-
-from django.db import migrations, models
-import django_extensions.db.fields
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("beers", "0002_beer_beeradvocate_image_beer_producer_and_more"),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="BeerStyle",
-            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"
-                    ),
-                ),
-                ("description", models.TextField(blank=True, null=True)),
-            ],
-            options={
-                "get_latest_by": "modified",
-                "abstract": False,
-            },
-        ),
-        migrations.RemoveField(
-            model_name="beer",
-            name="beeradvocate_image",
-        ),
-        migrations.RemoveField(
-            model_name="beer",
-            name="style",
-        ),
-        migrations.AddField(
-            model_name="beer",
-            name="untappd_image",
-            field=models.ImageField(
-                blank=True, null=True, upload_to="beers/untappd/"
-            ),
-        ),
-        migrations.AddField(
-            model_name="beer",
-            name="untappd_rating",
-            field=models.FloatField(blank=True, null=True),
-        ),
-        migrations.AddField(
-            model_name="beerproducer",
-            name="untappd_id",
-            field=models.CharField(blank=True, max_length=255, null=True),
-        ),
-        migrations.AddField(
-            model_name="beer",
-            name="styles",
-            field=models.ManyToManyField(to="beers.beerstyle"),
-        ),
-    ]
--- a/vrobbler/apps/beers/migrations/0004_beerproducer_name_beerproducer_uuid_beerstyle_name_and_more.py
+++ b/vrobbler/apps/beers/migrations/0004_beerproducer_name_beerproducer_uuid_beerstyle_name_and_more.py
@ -1,47 +0,0 @@
-# Generated by Django 4.2.16 on 2024-10-22 21:52
-
-from django.db import migrations, models
-import uuid
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("beers", "0003_beerstyle_remove_beer_beeradvocate_image_and_more"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="beerproducer",
-            name="name",
-            field=models.CharField(default="Untitled", max_length=255),
-            preserve_default=False,
-        ),
-        migrations.AddField(
-            model_name="beerproducer",
-            name="uuid",
-            field=models.UUIDField(
-                blank=True, default=uuid.uuid4, editable=False, null=True
-            ),
-        ),
-        migrations.AddField(
-            model_name="beerstyle",
-            name="name",
-            field=models.CharField(default="Untitled", max_length=255),
-            preserve_default=False,
-        ),
-        migrations.AddField(
-            model_name="beerstyle",
-            name="uuid",
-            field=models.UUIDField(
-                blank=True, default=uuid.uuid4, editable=False, null=True
-            ),
-        ),
-        migrations.AlterField(
-            model_name="beer",
-            name="styles",
-            field=models.ManyToManyField(
-                related_name="styles", to="beers.beerstyle"
-            ),
-        ),
-    ]
--- a/vrobbler/apps/beers/migrations/0005_alter_beer_run_time_seconds.py
+++ b/vrobbler/apps/beers/migrations/0005_alter_beer_run_time_seconds.py
@ -1,21 +0,0 @@
-# Generated by Django 4.2.16 on 2025-01-22 03:55
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        (
-            "beers",
-            "0004_beerproducer_name_beerproducer_uuid_beerstyle_name_and_more",
-        ),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="beer",
-            name="run_time_seconds",
-            field=models.IntegerField(default=900),
-        ),
-    ]
--- a/vrobbler/apps/beers/migrations/0006_remove_beer_run_time_seconds_and_more.py
+++ b/vrobbler/apps/beers/migrations/0006_remove_beer_run_time_seconds_and_more.py
@ -1,26 +0,0 @@
-# Generated by Django 4.2.19 on 2025-10-30 01:52
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('beers', '0005_alter_beer_run_time_seconds'),
-    ]
-
-    operations = [
-        migrations.RemoveField(
-            model_name='beer',
-            name='run_time_seconds',
-        ),
-        migrations.RemoveField(
-            model_name='beer',
-            name='run_time_ticks',
-        ),
-        migrations.AddField(
-            model_name='beer',
-            name='base_run_time_seconds',
-            field=models.IntegerField(blank=True, null=True),
-        ),
-    ]
--- a/vrobbler/apps/beers/migrations/0007_beer_tags.py
+++ b/vrobbler/apps/beers/migrations/0007_beer_tags.py
@ -1,26 +0,0 @@
-# Generated by Django 4.2.29 on 2026-03-26 21:25
-
-from django.db import migrations
-import taggit.managers
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("taggit", "0004_alter_taggeditem_content_type_alter_taggeditem_tag"),
-        ("beers", "0006_remove_beer_run_time_seconds_and_more"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="beer",
-            name="tags",
-            field=taggit.managers.TaggableManager(
-                blank=True,
-                help_text="A comma-separated list of tags.",
-                through="taggit.TaggedItem",
-                to="taggit.Tag",
-                verbose_name="Tags",
-            ),
-        ),
-    ]
--- a/vrobbler/apps/beers/migrations/0008_alter_beer_genre.py
+++ b/vrobbler/apps/beers/migrations/0008_alter_beer_genre.py
@ -1,26 +0,0 @@
-# Generated by Django 4.2.29 on 2026-05-01 15:49
-
-from django.db import migrations
-import taggit.managers
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("scrobbles", "0075_add_channel_scrobble"),
-        ("beers", "0007_beer_tags"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="beer",
-            name="genre",
-            field=taggit.managers.TaggableManager(
-                blank=True,
-                help_text="A comma-separated list of tags.",
-                through="scrobbles.ObjectWithGenres",
-                to="scrobbles.Genre",
-                verbose_name="Genre",
-            ),
-        ),
-    ]
--- a/vrobbler/apps/beers/migrations/init.py
+++ b/vrobbler/apps/beers/migrations/init.py
--- a/vrobbler/apps/beers/models.py
+++ b/vrobbler/apps/beers/models.py
@ -1,143 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-from uuid import uuid4
-
-from beers.untappd import get_beer_from_untappd_id
-from django.apps import apps
-from django.db import models
-from django.urls import reverse
-from django_extensions.db.models import TimeStampedModel
-from imagekit.models import ImageSpecField
-from imagekit.processors import ResizeToFit
-from scrobbles.dataclasses import BaseLogData
-from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
-
-BNULL = {"blank": True, "null": True}
-
-
-@dataclass
-class BeerLogData(BaseLogData):
-    rating: Optional[str] = None
-
-
-class BeerStyle(TimeStampedModel):
-    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
-    name = models.CharField(max_length=255)
-    description = models.TextField(**BNULL)
-
-    def __str__(self):
-        return self.name
-
-
-class BeerProducer(TimeStampedModel):
-    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
-    name = models.CharField(max_length=255)
-    description = models.TextField(**BNULL)
-    location = models.CharField(max_length=255, **BNULL)
-    beeradvocate_id = models.CharField(max_length=255, **BNULL)
-    untappd_id = models.CharField(max_length=255, **BNULL)
-
-    def find_or_create(cls, title: str) -> "BeerProducer":
-        return cls.objects.filter(title=title).first()
-
-    def __str__(self):
-        return self.name
-
-
-class Beer(ScrobblableMixin):
-    description = models.TextField(**BNULL)
-    ibu = models.SmallIntegerField(**BNULL)
-    abv = models.FloatField(**BNULL)
-    styles = models.ManyToManyField(BeerStyle, related_name="styles")
-    non_alcoholic = models.BooleanField(default=False)
-    beeradvocate_id = models.CharField(max_length=255, **BNULL)
-    beeradvocate_score = models.SmallIntegerField(**BNULL)
-    untappd_image = models.ImageField(upload_to="beers/untappd/", **BNULL)
-    untappd_image_small = ImageSpecField(
-        source="untappd_image",
-        processors=[ResizeToFit(100, 100)],
-        format="JPEG",
-        options={"quality": 60},
-    )
-    untappd_image_medium = ImageSpecField(
-        source="untappd_image",
-        processors=[ResizeToFit(300, 300)],
-        format="JPEG",
-        options={"quality": 75},
-    )
-    untappd_id = models.CharField(max_length=255, **BNULL)
-    untappd_rating = models.FloatField(**BNULL)
-    producer = models.ForeignKey(BeerProducer, on_delete=models.DO_NOTHING, **BNULL)
-
-    def get_absolute_url(self) -> str:
-        return reverse("beers:beer_detail", kwargs={"slug": self.uuid})
-
-    def __str__(self):
-        return f"{self.title} by {self.producer}"
-
-    @property
-    def subtitle(self):
-        return self.producer.name
-
-    @property
-    def strings(self) -> ScrobblableConstants:
-        return ScrobblableConstants(verb="Drinking", tags="beer")
-
-    @property
-    def beeradvocate_link(self) -> str:
-        link = ""
-        if self.producer and self.beeradvocate_id:
-            if self.beeradvocate_id:
-                link = f"https://www.beeradvocate.com/beer/profile/{self.producer.beeradvocate_id}/{self.beeradvocate_id}/"
-        return link
-
-    @property
-    def untappd_link(self) -> str:
-        link = ""
-        if self.untappd_id:
-            link = f"https://www.untappd.com/beer/{self.untappd_id}/"
-        return link
-
-    @property
-    def primary_image_url(self) -> str:
-        url = ""
-        if self.untappd_image:
-            url = self.untappd_image.url
-        return url
-
-    @property
-    def logdata_cls(self):
-        return BeerLogData
-
-    @classmethod
-    def find_or_create(cls, untappd_id: str) -> "Beer":
-        beer = cls.objects.filter(untappd_id=untappd_id).first()
-
-        if not beer:
-            beer_dict = get_beer_from_untappd_id(untappd_id)
-            producer_dict = {}
-            style_ids = []
-            for key in list(beer_dict.keys()):
-                if "producer__" in key:
-                    pkey = key.replace("producer__", "")
-                    producer_dict[pkey] = beer_dict.pop(key)
-                if "styles" in key:
-                    for style in beer_dict.pop("styles"):
-                        style_inst, created = BeerStyle.objects.get_or_create(
-                            name=style
-                        )
-                        style_ids.append(style_inst.id)
-
-            producer, _created = BeerProducer.objects.get_or_create(**producer_dict)
-            beer_dict["producer_id"] = producer.id
-            beer = Beer.objects.create(**beer_dict)
-            for style_id in style_ids:
-                beer.styles.add(style_id)
-
-        return beer
-
-    def scrobbles(self, user_id):
-        Scrobble = apps.get_model("scrobbles", "Scrobble")
-        return Scrobble.objects.filter(user_id=user_id, beer=self).order_by(
-            "-timestamp"
-        )
--- a/vrobbler/apps/beers/untappd.py
+++ b/vrobbler/apps/beers/untappd.py
@ -1,138 +0,0 @@
-import logging
-from typing import Optional
-
-import requests
-from bs4 import BeautifulSoup
-
-logger = logging.getLogger(__name__)
-
-UNTAPPD_URL = "https://untappd.com/beer/{id}"
-
-
-def get_first(key: str, result: dict) -> str:
-    obj = ""
-    if obj_list := result.get(key):
-        obj = obj_list[0]
-    return obj
-
-
-def get_title_from_soup(soup) -> str:
-    title = ""
-    try:
-        title = soup.find("h1").get_text()
-    except AttributeError:
-        pass
-    except ValueError:
-        pass
-    return title
-
-
-def get_description_from_soup(soup) -> str:
-    desc = ""
-    try:
-        desc = (
-            soup.find(class_="beer-descrption-read-less")
-            .get_text()
-            .replace("Show Less", "")
-            .strip()
-        )
-    except AttributeError:
-        pass
-    except ValueError:
-        pass
-    return desc
-
-
-def get_styles_from_soup(soup) -> list[str]:
-    styles = []
-    try:
-        styles = soup.find("p", class_="style").get_text().split(" - ")
-    except AttributeError:
-        pass
-    except ValueError:
-        pass
-    return styles
-
-
-def get_abv_from_soup(soup) -> Optional[float]:
-    abv = None
-    try:
-        abv = soup.find(class_="abv").get_text()
-        if abv:
-            abv = float(abv.strip("\n").strip("% ABV").strip())
-    except AttributeError:
-        pass
-    except ValueError:
-        pass
-    except TypeError:
-        pass
-    return abv
-
-
-def get_ibu_from_soup(soup) -> Optional[int]:
-    ibu = None
-    try:
-        ibu = soup.find(class_="ibu").get_text()
-        if ibu:
-            ibu = int(ibu.strip("\n").strip(" IBU").strip())
-    except AttributeError:
-        pass
-    except ValueError:
-        ibu = None
-    return ibu
-
-
-def get_rating_from_soup(soup) -> str:
-    rating = ""
-    try:
-        rating = float(soup.find(class_="num").get_text().strip("(").strip(")"))
-    except AttributeError:
-        rating = None
-    except ValueError:
-        rating = None
-    return rating
-
-
-def get_producer_id_from_soup(soup) -> str:
-    id = ""
-    try:
-        id = soup.find(class_="brewery").find("a")["href"].strip("/")
-    except ValueError:
-        pass
-    except IndexError:
-        pass
-    return id
-
-
-def get_producer_name_from_soup(soup) -> str:
-    name = ""
-    try:
-        name = soup.find(class_="brewery").find("a").get_text()
-    except AttributeError:
-        pass
-    except ValueError:
-        pass
-    return name
-
-
-def get_beer_from_untappd_id(untappd_id: str) -> dict:
-    beer_url = UNTAPPD_URL.format(id=untappd_id)
-    headers = {"User-Agent": "Vrobbler 0.11.12"}
-    response = requests.get(beer_url, headers=headers)
-    beer_dict = {"untappd_id": untappd_id}
-
-    if response.status_code != 200:
-        logger.warn("Bad response from untappd.com", extra={"response": response})
-        return beer_dict
-
-    soup = BeautifulSoup(response.text, "html.parser")
-    beer_dict["title"] = get_title_from_soup(soup)
-    beer_dict["description"] = get_description_from_soup(soup)
-    beer_dict["styles"] = get_styles_from_soup(soup)
-    beer_dict["abv"] = get_abv_from_soup(soup)
-    beer_dict["ibu"] = get_ibu_from_soup(soup)
-    beer_dict["untappd_rating"] = get_rating_from_soup(soup)
-    beer_dict["producer__untappd_id"] = get_producer_id_from_soup(soup)
-    beer_dict["producer__name"] = get_producer_name_from_soup(soup)
-
-    return beer_dict
--- a/vrobbler/apps/beers/urls.py
+++ b/vrobbler/apps/beers/urls.py
@ -1,14 +0,0 @@
-from django.urls import path
-from beers import views
-
-app_name = "beers"
-
-
-urlpatterns = [
-    path("beers/", views.BeerListView.as_view(), name="beer_list"),
-    path(
-        "beers/<slug:slug>/",
-        views.BeerDetailView.as_view(),
-        name="beer_detail",
-    ),
-]
--- a/vrobbler/apps/beers/views.py
+++ b/vrobbler/apps/beers/views.py
@ -1,11 +0,0 @@
-from beers.models import Beer
-
-from scrobbles.views import ScrobbleableListView, ScrobbleableDetailView
-
-
-class BeerListView(ScrobbleableListView):
-    model = Beer
-
-
-class BeerDetailView(ScrobbleableDetailView):
-    model = Beer
--- a/vrobbler/apps/birds/init.py
+++ b/vrobbler/apps/birds/init.py
--- a/vrobbler/apps/birds/admin.py
+++ b/vrobbler/apps/birds/admin.py
@ -1,31 +0,0 @@
-from birds.models import Bird, BirdingCSVImport, BirdingLocation
-from django.contrib import admin
-from scrobbles.admin import ScrobbleInline
-
-
-@admin.register(Bird)
-class BirdAdmin(admin.ModelAdmin):
-    date_hierarchy = "created"
-    list_display = ("uuid", "common_name", "scientific_name", "ebird_code")
-    ordering = ("-created",)
-    search_fields = ("common_name", "scientific_name")
-
-
-@admin.register(BirdingLocation)
-class BirdingLocationAdmin(admin.ModelAdmin):
-    date_hierarchy = "created"
-    list_display = ("uuid", "title")
-    ordering = ("-created",)
-    raw_id_fields = ("geo_location",)
-    search_fields = ("title",)
-    inlines = [
-        ScrobbleInline,
-    ]
-
-
-@admin.register(BirdingCSVImport)
-class BirdingCSVImportAdmin(admin.ModelAdmin):
-    date_hierarchy = "created"
-    list_display = ("uuid", "process_count", "processed_finished", "processing_started", "error_log")
-    raw_id_fields = ("user",)
-    ordering = ("-created",)
--- a/vrobbler/apps/birds/api/init.py
+++ b/vrobbler/apps/birds/api/init.py
--- a/vrobbler/apps/birds/api/serializers.py
+++ b/vrobbler/apps/birds/api/serializers.py
@ -1,14 +0,0 @@
-from rest_framework import serializers
-from birds.models import Bird, BirdingLocation
-
-
-class BirdSerializer(serializers.HyperlinkedModelSerializer):
-    class Meta:
-        model = Bird
-        fields = "__all__"
-
-
-class BirdingLocationSerializer(serializers.HyperlinkedModelSerializer):
-    class Meta:
-        model = BirdingLocation
-        fields = "__all__"
--- a/vrobbler/apps/birds/api/views.py
+++ b/vrobbler/apps/birds/api/views.py
@ -1,15 +0,0 @@
-from rest_framework import permissions, viewsets
-from birds.api import serializers
-from birds import models
-
-
-class BirdViewSet(viewsets.ModelViewSet):
-    queryset = models.Bird.objects.all().order_by("-created")
-    serializer_class = serializers.BirdSerializer
-    permission_classes = [permissions.IsAuthenticated]
-
-
-class BirdingLocationViewSet(viewsets.ModelViewSet):
-    queryset = models.BirdingLocation.objects.all().order_by("-created")
-    serializer_class = serializers.BirdingLocationSerializer
-    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/birds/apps.py
+++ b/vrobbler/apps/birds/apps.py
@ -1,5 +0,0 @@
-from django.apps import AppConfig
-
-
-class BirdsConfig(AppConfig):
-    name = "birds"
--- a/vrobbler/apps/birds/forms.py
+++ b/vrobbler/apps/birds/forms.py
@ -1,85 +0,0 @@
-import json
-
-from birds.models import Bird, BirdSightingEntry
-from django import forms
-
-
-class BirdSightingsWidget(forms.Widget):
-    template_name = "birds/bird_sightings_widget.html"
-
-    class Media:
-        js = ("birds/bird_sightings.js",)
-
-    def value_from_datadict(self, data, files, name):
-        bird_ids = data.getlist(f"{name}_bird_id")
-        quantities = data.getlist(f"{name}_quantity")
-        notes = data.getlist(f"{name}_sighting_notes")
-        return {
-            "bird_id": bird_ids,
-            "quantity": quantities,
-            "sighting_notes": notes,
-        }
-
-    def get_context(self, name, value, attrs):
-        context = super().get_context(name, value, attrs)
-        sightings = []
-        if value:
-            if isinstance(value, str):
-                try:
-                    value = json.loads(value)
-                except (json.JSONDecodeError, TypeError):
-                    value = []
-            for item in (value or []):
-                if isinstance(item, dict):
-                    sightings.append(item)
-                elif isinstance(item, BirdSightingEntry):
-                    sightings.append(item.asdict)
-        context["widget"]["sightings"] = sightings
-        context["widget"]["birds"] = Bird.objects.all().order_by("common_name")
-        return context
-
-
-class BirdSightingsField(forms.Field):
-    widget = BirdSightingsWidget
-
-    def clean(self, value):
-        if not value:
-            return None
-        result = []
-        bird_ids = value.get("bird_id", []) if isinstance(value, dict) else []
-        quantities = value.get("quantity", []) if isinstance(value, dict) else []
-        notes_list = (
-            value.get("sighting_notes", []) if isinstance(value, dict) else []
-        )
-
-        if isinstance(bird_ids, list):
-            for i, bird_id in enumerate(bird_ids):
-                if not bird_id:
-                    continue
-                try:
-                    bird_id = int(bird_id)
-                    quantity = int(quantities[i]) if i < len(quantities) else 1
-                except (ValueError, TypeError, IndexError):
-                    continue
-                note = notes_list[i] if i < len(notes_list) else ""
-                entry = BirdSightingEntry(
-                    bird_id=bird_id,
-                    quantity=quantity,
-                    sighting_notes=note or None,
-                )
-                result.append(entry.asdict)
-        elif bird_ids:
-            try:
-                bird_id = int(bird_ids)
-                quantity = int(quantities) if quantities else 1
-            except (ValueError, TypeError):
-                raise forms.ValidationError("Invalid bird sighting data")
-            note = notes_list if notes_list else ""
-            entry = BirdSightingEntry(
-                bird_id=bird_id,
-                quantity=quantity,
-                sighting_notes=note or None,
-            )
-            result.append(entry.asdict)
-
-        return result if result else None
--- a/vrobbler/apps/birds/importer.py
+++ b/vrobbler/apps/birds/importer.py
@ -1,198 +0,0 @@
-import csv
-import logging
-import re
-from collections import defaultdict
-from datetime import timedelta
-
-from dateutil import parser
-
-from django.contrib.auth import get_user_model
-
-from birds.models import Bird, BirdSightingEntry, BirdSightingLogData, BirdingLocation
-from scrobbles.models import Scrobble
-from scrobbles.notifications import ScrobbleNtfyNotification
-
-logger = logging.getLogger(__name__)
-User = get_user_model()
-
-LOCATION_COORDS_RE = re.compile(r"\(([\d\.\-]+),\s*([\d\.\-]+)\)")
-DURATION_RE = re.compile(r"(\d+)\s*minute")
-
-
-def parse_duration(duration_str):
-    if not duration_str:
-        return None
-    match = DURATION_RE.search(duration_str)
-    if match:
-        return int(match.group(1))
-    return None
-
-
-def parse_coords(location_str):
-    match = LOCATION_COORDS_RE.search(location_str)
-    if match:
-        return float(match.group(1)), float(match.group(2))
-    return None, None
-
-
-def parse_timestamp(date_str, time_str):
-    try:
-        dt_str = f"{date_str} {time_str}".strip()
-        dt = parser.parse(dt_str)
-        return dt
-    except (ValueError, TypeError):
-        try:
-            dt = parser.parse(date_str)
-            return dt
-        except (ValueError, TypeError):
-            logger.warning(f"Could not parse date/time: {date_str} {time_str}")
-            return None
-
-
-def parse_bool(value):
-    if not value:
-        return None
-    return value.strip().lower() in ("true", "yes", "1")
-
-
-def parse_int(value):
-    if not value:
-        return None
-    try:
-        return int(value.strip())
-    except (ValueError, TypeError):
-        return None
-
-
-def import_birding_csv(file_path, user_id, record_error=None):
-    user = User.objects.get(id=user_id)
-    new_scrobbles = []
-
-    with open(file_path, newline="", encoding="utf-8-sig") as f:
-        reader = csv.DictReader(f)
-        rows = list(reader)
-
-    groups = defaultdict(list)
-    for row in rows:
-        key = (
-            row.get("Location", "").strip(),
-            row.get("Observation Date", "").strip(),
-            row.get("Start Time", "").strip(),
-        )
-        groups[key].append(row)
-
-    for (location_str, date_str, time_str), sighting_rows in groups.items():
-        if not location_str:
-            msg = "Skipping rows with no location"
-            logger.warning(msg)
-            if record_error:
-                record_error(msg)
-            continue
-
-        timestamp = parse_timestamp(date_str, time_str)
-        if not timestamp:
-            msg = f"Could not parse date/time: {date_str} {time_str}"
-            if record_error:
-                record_error(msg)
-            continue
-
-        timestamp = user.profile.get_timestamp_with_tz(timestamp)
-
-        location_title = (
-            LOCATION_COORDS_RE.sub("", location_str).strip().rstrip(",").strip()
-        )
-        if not location_title:
-            location_title = location_str
-
-        location = BirdingLocation.find_or_create(location_title)
-        lat, lon = parse_coords(location_str)
-        if lat and lon and not location.geo_location:
-            from locations.models import GeoLocation
-
-            geo, _ = GeoLocation.objects.get_or_create(
-                lat=round(lat, 6),
-                lon=round(lon, 6),
-                defaults={"altitude": None},
-            )
-            location.geo_location = geo
-            location.save(update_fields=["geo_location"])
-
-        first_row = sighting_rows[0]
-
-        birds_data = []
-        for row in sighting_rows:
-            species = row.get("Species", "").strip()
-            if not species:
-                continue
-            count = parse_int(row.get("Count")) or 1
-            details = row.get("Details", "").strip()
-
-            bird = Bird.find_or_create(species)
-            entry = BirdSightingEntry(
-                bird_id=bird.id, quantity=count, sighting_notes=details or None
-            )
-            birds_data.append(entry.asdict)
-
-        duration_minutes = parse_duration(first_row.get("Duration", ""))
-        logdata = BirdSightingLogData(
-            birds=birds_data,
-            duration_minutes=duration_minutes,
-            observation_type=first_row.get("Observation Type", "").strip() or None,
-            distance=first_row.get("Distance", "").strip() or None,
-            area=first_row.get("Area", "").strip() or None,
-            party_size=parse_int(first_row.get("Party Size")),
-            complete_checklist=parse_bool(first_row.get("Complete Checklist")),
-        )
-
-        log_dict = logdata.asdict
-
-        weather_loc = location.geo_location
-        if not weather_loc:
-            last_loc = (
-                Scrobble.objects.filter(
-                    user=user,
-                    media_type=Scrobble.MediaType.GEO_LOCATION,
-                    geo_location__isnull=False,
-                )
-                .order_by("-timestamp")
-                .first()
-            )
-            if last_loc:
-                weather_loc = last_loc.geo_location
-        if weather_loc:
-            weather = weather_loc.current_weather
-            if weather:
-                log_dict["weather"] = weather["description"]
-                log_dict["temperature"] = weather["temp"]
-
-        stop_timestamp = timestamp + timedelta(minutes=duration_minutes) if duration_minutes else None
-
-        tz = getattr(timestamp.tzinfo, "name", None)
-
-        scrobble = Scrobble(
-            user=user,
-            timestamp=timestamp,
-            timezone=tz,
-            stop_timestamp=stop_timestamp,
-            source="Birding CSV Import",
-            birding_location=location,
-            log=log_dict,
-            played_to_completion=True,
-            in_progress=False,
-            media_type=Scrobble.MediaType.BIRDING_LOCATION,
-        )
-        existing = Scrobble.objects.filter(
-            timestamp=timestamp,
-            birding_location=location,
-            user=user,
-        ).first()
-        if existing:
-            logger.debug(f"Skipping existing scrobble for {location}")
-            continue
-        new_scrobbles.append(scrobble)
-
-    created = Scrobble.objects.bulk_create(new_scrobbles)
-    logger.info(f"Created {len(created)} birding scrobbles")
-    for scrobble in created:
-        ScrobbleNtfyNotification(scrobble).send()
-    return created
--- a/vrobbler/apps/birds/migrations/0001_initial.py
+++ b/vrobbler/apps/birds/migrations/0001_initial.py
@ -1,144 +0,0 @@
-# Generated by Django 4.2.29 on 2026-05-15 15:05
-
-from django.db import migrations, models
-import django.db.models.deletion
-import django_extensions.db.fields
-import taggit.managers
-import uuid
-
-
-class Migration(migrations.Migration):
-
-    initial = True
-
-    dependencies = [
-        ("taggit", "0004_alter_taggeditem_content_type_alter_taggeditem_tag"),
-        ("locations", "0010_clean_start"),
-        ("scrobbles", "0075_add_channel_scrobble"),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="Bird",
-            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
-                    ),
-                ),
-                ("common_name", models.CharField(max_length=255)),
-                (
-                    "scientific_name",
-                    models.CharField(blank=True, max_length=255, null=True),
-                ),
-                ("description", models.TextField(blank=True, null=True)),
-                (
-                    "ebird_code",
-                    models.CharField(
-                        blank=True, db_index=True, max_length=255, null=True
-                    ),
-                ),
-                (
-                    "photo",
-                    models.ImageField(blank=True, null=True, upload_to="birds/photos/"),
-                ),
-            ],
-            options={
-                "get_latest_by": "modified",
-                "abstract": False,
-            },
-        ),
-        migrations.CreateModel(
-            name="BirdingLocation",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                (
-                    "created",
-                    django_extensions.db.fields.CreationDateTimeField(
-                        auto_now_add=True, verbose_name="created"
-                    ),
-                ),
-                (
-                    "modified",
-                    django_extensions.db.fields.ModificationDateTimeField(
-                        auto_now=True, verbose_name="modified"
-                    ),
-                ),
-                (
-                    "uuid",
-                    models.UUIDField(
-                        blank=True, default=uuid.uuid4, editable=False, null=True
-                    ),
-                ),
-                ("title", models.CharField(blank=True, max_length=255, null=True)),
-                ("base_run_time_seconds", models.IntegerField(blank=True, null=True)),
-                ("description", models.TextField(blank=True, null=True)),
-                (
-                    "ebird_hotspot_id",
-                    models.CharField(blank=True, max_length=255, null=True),
-                ),
-                (
-                    "genre",
-                    taggit.managers.TaggableManager(
-                        blank=True,
-                        help_text="A comma-separated list of tags.",
-                        through="scrobbles.ObjectWithGenres",
-                        to="scrobbles.Genre",
-                        verbose_name="Genre",
-                    ),
-                ),
-                (
-                    "geo_location",
-                    models.ForeignKey(
-                        blank=True,
-                        null=True,
-                        on_delete=django.db.models.deletion.DO_NOTHING,
-                        to="locations.geolocation",
-                    ),
-                ),
-                (
-                    "tags",
-                    taggit.managers.TaggableManager(
-                        blank=True,
-                        help_text="A comma-separated list of tags.",
-                        through="taggit.TaggedItem",
-                        to="taggit.Tag",
-                        verbose_name="Tags",
-                    ),
-                ),
-            ],
-            options={
-                "abstract": False,
-            },
-        ),
-    ]
--- a/vrobbler/apps/birds/migrations/0002_birdingcsvimport.py
+++ b/vrobbler/apps/birds/migrations/0002_birdingcsvimport.py
@ -1,67 +0,0 @@
-# Generated by Django 4.2.29 on 2026-05-15 15:41
-
-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),
-        ("birds", "0001_initial"),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="BirdingCSVImport",
-            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)),
-                (
-                    "csv_file",
-                    models.FileField(
-                        blank=True, null=True, upload_to="birding-csv-uploads/"
-                    ),
-                ),
-                (
-                    "user",
-                    models.ForeignKey(
-                        blank=True,
-                        null=True,
-                        on_delete=django.db.models.deletion.DO_NOTHING,
-                        to=settings.AUTH_USER_MODEL,
-                    ),
-                ),
-            ],
-            options={
-                "verbose_name": "Birding CSV Import",
-            },
-        ),
-    ]
--- a/vrobbler/apps/birds/migrations/0003_birdingcsvimport_error_log.py
+++ b/vrobbler/apps/birds/migrations/0003_birdingcsvimport_error_log.py
@ -1,18 +0,0 @@
-# Generated by Django 4.2.29 on 2026-06-08 14:57
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("birds", "0002_birdingcsvimport"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="birdingcsvimport",
-            name="error_log",
-            field=models.TextField(blank=True, null=True),
-        ),
-    ]
--- a/vrobbler/apps/birds/migrations/init.py
+++ b/vrobbler/apps/birds/migrations/init.py
--- a/vrobbler/apps/birds/models.py
+++ b/vrobbler/apps/birds/models.py
@ -1,308 +0,0 @@
-import logging
-from dataclasses import dataclass
-from functools import cached_property
-from typing import Optional
-from uuid import uuid4
-
-from django.conf import settings
-from django.contrib.auth import get_user_model
-from django.core.files import File
-from django.db import models
-from django.urls import reverse
-from django.utils import timezone
-from django_extensions.db.models import TimeStampedModel
-from imagekit.models import ImageSpecField
-from imagekit.processors import ResizeToFit
-from locations.models import GeoLocation
-from scrobbles.dataclasses import BaseLogData, WithPeopleLogData
-from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
-
-User = get_user_model()
-
-logger = logging.getLogger(__name__)
-BNULL = {"blank": True, "null": True}
-
-
-@dataclass
-class BirdSightingEntry(BaseLogData):
-    bird_id: Optional[int] = None
-    quantity: int = 1
-    sighting_notes: Optional[str] = None
-
-    @property
-    def bird(self) -> Optional["Bird"]:
-        if not self.bird_id:
-            return None
-        return Bird.objects.filter(id=self.bird_id).first()
-
-    def __str__(self) -> str:
-        name = self.bird.common_name if self.bird else "Unknown"
-        out = f"{name} x{self.quantity}"
-        if self.sighting_notes:
-            out += f" ({self.sighting_notes})"
-        return out
-
-
-@dataclass
-class BirdSightingLogData(BaseLogData, WithPeopleLogData):
-    birds: Optional[list[BirdSightingEntry]] = None
-    duration_minutes: Optional[int] = None
-    observation_type: Optional[str] = None
-    distance: Optional[str] = None
-    area: Optional[str] = None
-    party_size: Optional[int] = None
-    complete_checklist: Optional[bool] = None
-    weather: Optional[str] = None
-    temperature: Optional[int] = None
-    guide: Optional[str] = None
-
-    _excluded_fields = {}
-
-    @cached_property
-    def bird_list(self) -> str:
-        if self.birds:
-            return ", ".join([BirdSightingEntry(**b).__str__() for b in self.birds])
-        return ""
-
-    def as_html(self) -> str:
-        html_parts = []
-
-        if self.observation_type:
-            html_parts.append(
-                f'<div class="birding-obs-type">Type: {self.observation_type}</div>'
-            )
-
-        if self.distance:
-            html_parts.append(
-                f'<div class="birding-distance">Distance: {self.distance}</div>'
-            )
-
-        if self.area:
-            html_parts.append(f'<div class="birding-area">Area: {self.area}</div>')
-
-        if self.party_size:
-            html_parts.append(
-                f'<div class="birding-party">Party size: {self.party_size}</div>'
-            )
-
-        if self.complete_checklist is not None:
-            html_parts.append(
-                f'<div class="birding-checklist">Complete checklist: {self.complete_checklist}</div>'
-            )
-
-        if self.weather:
-            html_parts.append(
-                f'<div class="birding-weather">Weather: {self.weather}</div>'
-            )
-
-        if self.temperature:
-            html_parts.append(
-                f'<div class="birding-temp">Temp: {self.temperature}°</div>'
-            )
-
-        if self.guide:
-            html_parts.append(f'<div class="birding-guide">Guide: {self.guide}</div>')
-
-        if self.duration_minutes:
-            html_parts.append(
-                f'<div class="birding-duration">Duration: {self.duration_minutes} min</div>'
-            )
-
-        if self.birds:
-            birds_html = []
-            for bird_data in self.birds:
-                sighting = BirdSightingEntry(**bird_data)
-                bird_info = sighting.bird.common_name if sighting.bird else "Unknown"
-                extra = f" x{sighting.quantity}"
-                if sighting.sighting_notes:
-                    extra += f" \u2014 {sighting.sighting_notes}"
-                birds_html.append(
-                    f'<div class="bird-sighting">{bird_info}{extra}</div>'
-                )
-            html_parts.append(
-                f'<div class="bird-sightings">{"".join(birds_html)}</div>'
-            )
-
-        return "".join(html_parts)
-
-    @classmethod
-    def override_fields(cls) -> dict:
-        from birds.forms import BirdSightingsField
-
-        fields = {}
-        for base in cls.mro()[1:]:
-            if hasattr(base, "override_fields"):
-                base_fields = base.override_fields()
-                fields.update(base_fields)
-        custom_fields = {
-            "birds": BirdSightingsField(required=False),
-        }
-        fields.update(custom_fields)
-        return fields
-
-
-class Bird(TimeStampedModel):
-    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
-    common_name = models.CharField(max_length=255)
-    scientific_name = models.CharField(max_length=255, **BNULL)
-    description = models.TextField(**BNULL)
-    ebird_code = models.CharField(max_length=255, **BNULL, db_index=True)
-    photo = models.ImageField(upload_to="birds/photos/", **BNULL)
-    photo_small = ImageSpecField(
-        source="photo",
-        processors=[ResizeToFit(100, 100)],
-        format="JPEG",
-        options={"quality": 60},
-    )
-    photo_medium = ImageSpecField(
-        source="photo",
-        processors=[ResizeToFit(300, 300)],
-        format="JPEG",
-        options={"quality": 75},
-    )
-
-    def __str__(self):
-        return self.common_name
-
-    def get_absolute_url(self):
-        return reverse("birds:bird_detail", kwargs={"slug": self.uuid})
-
-    @classmethod
-    def find_or_create(cls, common_name: str) -> "Bird":
-        bird = cls.objects.filter(common_name__iexact=common_name).first()
-        if not bird:
-            bird = cls.objects.create(common_name=common_name)
-        return bird
-
-
-class BirdingLocation(ScrobblableMixin):
-    description = models.TextField(**BNULL)
-    geo_location = models.ForeignKey(GeoLocation, **BNULL, on_delete=models.DO_NOTHING)
-    ebird_hotspot_id = models.CharField(max_length=255, **BNULL)
-
-    def get_absolute_url(self):
-        return reverse("birds:birding_location_detail", kwargs={"slug": self.uuid})
-
-    @property
-    def subtitle(self):
-        return self.geo_location
-
-    @property
-    def strings(self) -> ScrobblableConstants:
-        return ScrobblableConstants(verb="Birding at", tags="bird")
-
-    @property
-    def logdata_cls(self):
-        return BirdSightingLogData
-
-    def primary_image_url(self) -> str:
-        return ""
-
-    def fix_metadata(self) -> None:
-        pass
-
-    @classmethod
-    def find_or_create(cls, title: str) -> "BirdingLocation":
-        location = cls.objects.filter(title__iexact=title).first()
-        if not location:
-            location = cls.objects.create(title=title)
-        return location
-
-
-class BirdingCSVImport(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)
-    error_log = models.TextField(**BNULL)
-    csv_file = models.FileField(upload_to="birding-csv-uploads/", **BNULL)
-
-    class Meta:
-        verbose_name = "Birding CSV Import"
-
-    def __str__(self):
-        return f"Birding import on {self.human_start}"
-
-    @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):
-        return "Birding CSV"
-
-    def get_absolute_url(self):
-        return reverse("birds:csv_import_detail", kwargs={"slug": self.uuid})
-
-    @property
-    def upload_file_path(self):
-        if getattr(settings, "USE_S3_STORAGE"):
-            path = self.csv_file.url
-        else:
-            path = self.csv_file.path
-        return path
-
-    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}"
-            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"])
-
-    def record_error(self, error_message):
-        log_line = f"{timezone.now().isoformat()}: {error_message}"
-        if self.error_log:
-            self.error_log += "\n" + log_line
-        else:
-            self.error_log = log_line
-        self.save(update_fields=["error_log"])
-
-    def scrobbles(self):
-        from scrobbles.models import Scrobble
-
-        scrobble_ids = []
-        if self.process_log:
-            for line in self.process_log.split("\n"):
-                sid = line.split("\t")[0]
-                if sid:
-                    scrobble_ids.append(sid)
-        return Scrobble.objects.filter(id__in=scrobble_ids)
-
-    def process(self, force=False):
-        if self.processed_finished and not force:
-            logger.info(f"{self} already processed on {self.processed_finished}")
-            return
-        from birds.importer import import_birding_csv
-
-        self.mark_started()
-        try:
-            scrobbles = import_birding_csv(
-                self.upload_file_path, self.user_id, record_error=self.record_error
-            )
-            self.record_log(scrobbles)
-        except Exception as e:
-            self.record_error(f"Import failed: {e}")
-            logger.exception(f"Import failed for {self}")
-        finally:
-            self.mark_finished()
--- a/vrobbler/apps/birds/static/birds/bird_sightings.js
+++ b/vrobbler/apps/birds/static/birds/bird_sightings.js
@ -1,27 +0,0 @@
-document.addEventListener("DOMContentLoaded", function () {
-  var widget = document.querySelector(".bird-sightings-widget");
-  if (!widget) return;
-
-  var list = widget.querySelector(".bird-sightings-list");
-
-  widget.addEventListener("click", function (e) {
-    if (e.target.classList.contains("add-sighting-row")) {
-      var rows = list.querySelectorAll(".bird-sighting-row");
-      var template = rows[rows.length - 1];
-      if (!template) return;
-      var clone = template.cloneNode(true);
-      clone.querySelectorAll("select, input").forEach(function (el) {
-        el.value = "";
-      });
-      clone.querySelector('input[name$="_quantity"]').value = "1";
-      list.appendChild(clone);
-    }
-
-    if (e.target.classList.contains("remove-sighting")) {
-      var rows = list.querySelectorAll(".bird-sighting-row");
-      if (rows.length > 1) {
-        e.target.closest(".bird-sighting-row").remove();
-      }
-    }
-  });
-});
--- a/vrobbler/apps/birds/templates/birds/bird_sightings_widget.html
+++ b/vrobbler/apps/birds/templates/birds/bird_sightings_widget.html
@ -1,46 +0,0 @@
-<div class="bird-sightings-widget">
-  <div class="bird-sightings-list">
-    {% for sighting in widget.sightings %}
-    <div class="bird-sighting-row row mb-2">
-      <div class="col-md-6">
-        <select name="{{widget.name}}_bird_id" class="form-control">
-          <option value="">Select bird...</option>
-          {% for bird in widget.birds %}
-          <option value="{{bird.id}}" {% if sighting.bird_id == bird.id %}selected{% endif %}>{{bird.common_name}}</option>
-          {% endfor %}
-        </select>
-      </div>
-      <div class="col-md-2">
-        <input type="number" name="{{widget.name}}_quantity" class="form-control" value="{{sighting.quantity|default:1}}" min="1" placeholder="Qty">
-      </div>
-      <div class="col-md-3">
-        <input type="text" name="{{widget.name}}_sighting_notes" class="form-control" value="{{sighting.sighting_notes|default:''}}" placeholder="Notes">
-      </div>
-      <div class="col-md-1">
-        <button type="button" class="btn btn-sm btn-outline-danger remove-sighting">&times;</button>
-      </div>
-    </div>
-    {% empty %}
-    <div class="bird-sighting-row row mb-2">
-      <div class="col-md-6">
-        <select name="{{widget.name}}_bird_id" class="form-control">
-          <option value="">Select bird...</option>
-          {% for bird in widget.birds %}
-          <option value="{{bird.id}}">{{bird.common_name}}</option>
-          {% endfor %}
-        </select>
-      </div>
-      <div class="col-md-2">
-        <input type="number" name="{{widget.name}}_quantity" class="form-control" value="1" min="1" placeholder="Qty">
-      </div>
-      <div class="col-md-3">
-        <input type="text" name="{{widget.name}}_sighting_notes" class="form-control" value="" placeholder="Notes">
-      </div>
-      <div class="col-md-1">
-        <button type="button" class="btn btn-sm btn-outline-danger remove-sighting">&times;</button>
-      </div>
-    </div>
-    {% endfor %}
-  </div>
-  <button type="button" class="btn btn-sm btn-outline-primary add-sighting-row mt-2">Add bird</button>
-</div>
--- a/vrobbler/apps/birds/urls.py
+++ b/vrobbler/apps/birds/urls.py
@ -1,37 +0,0 @@
-from birds import views
-from django.urls import path
-
-app_name = "birds"
-
-urlpatterns = [
-    path(
-        "birding-locations/",
-        views.BirdingLocationListView.as_view(),
-        name="birding_location_list",
-    ),
-    path(
-        "birding-locations/<slug:slug>/",
-        views.BirdingLocationDetailView.as_view(),
-        name="birding_location_detail",
-    ),
-    path(
-        "birds/",
-        views.BirdListView.as_view(),
-        name="bird_list",
-    ),
-    path(
-        "birds/<slug:slug>/",
-        views.BirdDetailView.as_view(),
-        name="bird_detail",
-    ),
-    path(
-        "upload/birding-csv/",
-        views.BirdingCSVImportCreateView.as_view(),
-        name="csv-upload",
-    ),
-    path(
-        "imports/birding-csv/<slug:slug>/",
-        views.BirdingCSVImportDetailView.as_view(),
-        name="csv_import_detail",
-    ),
-]
--- a/vrobbler/apps/birds/views.py
+++ b/vrobbler/apps/birds/views.py
@ -1,63 +0,0 @@
-from birds.models import Bird, BirdingLocation
-from django.contrib.auth.mixins import LoginRequiredMixin
-from django.http import HttpResponseRedirect
-from django.urls import reverse_lazy
-from django.views import generic
-from scrobbles.models import EBirdCSVImport as BirdingCSVImport
-from scrobbles.views import (
-    ScrobbleableDetailView,
-    ScrobbleableListView,
-    JsonableResponseMixin,
-)
-
-
-class BirdingLocationListView(ScrobbleableListView):
-    model = BirdingLocation
-
-
-class BirdingLocationDetailView(ScrobbleableDetailView):
-    model = BirdingLocation
-
-
-class BirdListView(generic.ListView):
-    model = Bird
-    paginate_by = 200
-    ordering = "common_name"
-
-
-class BirdDetailView(generic.DetailView):
-    model = Bird
-    slug_field = "uuid"
-
-
-class BirdingCSVImportCreateView(
-    LoginRequiredMixin, JsonableResponseMixin, generic.CreateView
-):
-    model = BirdingCSVImport
-    fields = ["csv_file"]
-    template_name = "scrobbles/upload_form.html"
-    success_url = reverse_lazy("vrobbler-home")
-
-    def form_valid(self, form):
-        self.object = form.save(commit=False)
-        self.object.user = self.request.user
-        self.object.original_filename = (
-            form.cleaned_data["csv_file"].name
-        )
-        self.object.save()
-        self.object.process()
-        return HttpResponseRedirect(self.request.META.get("HTTP_REFERER"))
-
-
-class BirdingCSVImportDetailView(LoginRequiredMixin, generic.DetailView):
-    model = BirdingCSVImport
-    slug_field = "uuid"
-    template_name = "scrobbles/import_detail.html"
-
-    def get_queryset(self):
-        return super().get_queryset().filter(user=self.request.user)
-
-    def get_context_data(self, **kwargs):
-        context_data = super().get_context_data(**kwargs)
-        context_data["title"] = "eBird CSV Import"
-        return context_data
--- a/vrobbler/apps/boardgames/admin.py
+++ b/vrobbler/apps/boardgames/admin.py
@ -1,72 +0,0 @@
-from django.contrib import admin
-
-from boardgames.models import (
-    BoardGame,
-    BoardGameLocation,
-    BoardGamePublisher,
-    BoardGameDesigner,
-    BoardGameVariant,
-)
-
-from scrobbles.admin import ScrobbleInline
-
-
-@admin.register(BoardGamePublisher)
-class BoardGamePublisherAdmin(admin.ModelAdmin):
-    date_hierarchy = "created"
-    list_display = (
-        "name",
-        "uuid",
-    )
-    ordering = ("-created",)
-
-
-@admin.register(BoardGameDesigner)
-class BoardGameDesignerAdmin(admin.ModelAdmin):
-    date_hierarchy = "created"
-    list_display = (
-        "name",
-        "uuid",
-    )
-    ordering = ("-created",)
-
-
-@admin.register(BoardGameLocation)
-class BoardGameLocationAdmin(admin.ModelAdmin):
-    date_hierarchy = "created"
-    list_display = (
-        "name",
-        "uuid",
-        "geo_location",
-    )
-    raw_id_fields = ("geo_location",)
-    ordering = ("-created",)
-
-
-@admin.register(BoardGameVariant)
-class BoardGameVariantAdmin(admin.ModelAdmin):
-    date_hierarchy = "created"
-    list_display = (
-        "name",
-        "board_game",
-        "uuid",
-    )
-    raw_id_fields = ("board_game",)
-    search_fields = ("name", "board_game__title")
-    ordering = ("-created",)
-
-
-@admin.register(BoardGame)
-class BoardGameAdmin(admin.ModelAdmin):
-    date_hierarchy = "created"
-    list_display = (
-        "bggeek_id",
-        "title",
-        "published_year",
-    )
-    raw_id_fields = ("publisher", "publishers", "designers", "expansion_for_boardgame")
-    search_fields = ("title",)
-    ordering = ("-created",)
-    inlines = [
-        ScrobbleInline,
-    ]
--- a/vrobbler/apps/boardgames/api/serializers.py
+++ b/vrobbler/apps/boardgames/api/serializers.py
@ -1,32 +0,0 @@
-from boardgames import models
-from rest_framework import serializers
-
-
-class BoardGameDesignerSerializer(serializers.HyperlinkedModelSerializer):
-    class Meta:
-        model = models.BoardGameDesigner
-        fields = "__all__"
-
-
-class BoardGamePublisherSerializer(serializers.HyperlinkedModelSerializer):
-    class Meta:
-        model = models.BoardGamePublisher
-        fields = "__all__"
-
-
-class BoardGameLocationSerializer(serializers.HyperlinkedModelSerializer):
-    class Meta:
-        model = models.BoardGameLocation
-        fields = "__all__"
-
-
-class BoardGameVariantSerializer(serializers.HyperlinkedModelSerializer):
-    class Meta:
-        model = models.BoardGameVariant
-        fields = "__all__"
-
-
-class BoardGameSerializer(serializers.HyperlinkedModelSerializer):
-    class Meta:
-        model = models.BoardGame
-        fields = "__all__"
--- a/Show More
+++ b/Show More