[release] Bump to version 54.4

- Remove all-time trends
- Add a trend around moods

PROJECT.org

@@ -88,7 +88,7 @@ fetching and simple saving.
 *** Metadata sources
 **** Scraper
 
-* Backlog [0/19] :vrobbler:project:personal:
+* Backlog [0/20] :vrobbler:project:personal:
 ** TODO [#C] Create small utility to clean up tracks scrobbled with wonky playback times :bug:music:scrobbles:
 :PROPERTIES:
 :ID:       702462cf-d54b-48c6-8a7c-78b8de751deb
@@ -579,6 +579,108 @@ named constants for maintainability.
   - ~vrobbler/apps/scrobbles/importers/tsv.py~ (line 55) -- ="S"= completion status
 
     
+** TODO [#C] Clean up naming of =bgsplay= parsing :importers:refactoring:
+:PROPERTIES:
+:ID:       c751dbbc-464a-4e63-9fe3-e034303f7b54
+:END:
+
+*** Description
+
+We should rename `email_scrobble_board_game` to reflect the fact that it's just
+a helper method to create board game scrobbles given a json blob. It's
+independent of the email flow it was originally creatdd for
+
+* Version 54.4 [2/2]
+** DONE [#A] Remove all-time trends :trends:
+:PROPERTIES:
+:ID:       53b231d1-7677-8cd3-1d88-dae110aba1e6
+:END:
+
+*** Description
+
+All time trends take forever to calculate and don't provide too much data
+
+** DONE [#B] Add a trend around moods :moods:trends:
+:PROPERTIES:
+:ID:       fba3f4ae-8f97-ee0b-e762-31630884518a
+:END:
+
+* Version 54.3 [1/1]
+** DONE [#B] Fix bug in series metadata cleanup script :videos:metadta:
+:PROPERTIES:
+:ID:       85448702-907c-5d63-f5af-7795661d7c46
+:END:
+
+* Version 54.2 [4/4]
+** DONE [#B] Add script to clean up TV series metadata :videos:metadata:
+:PROPERTIES:
+:ID:       a468b328-59d9-f84b-9ddb-087216783453
+:END:
+** DONE [#A] Update youtube video detail pages with links to channel :videos:templates:
+:PROPERTIES:
+:ID:       8b87cb42-09e5-a3f5-136f-182f967fa81f
+:END:
+** DONE [#A] Concurrent reading trend does not consolidate on single book :trends:reading:
+:PROPERTIES:
+:ID:       fe220f55-7e0d-2a17-2477-a5aa7c4a1f2c
+:END:
+** DONE [#B] Trends dont seem to look very far back :trends:
+:PROPERTIES:
+:ID:       ffcfba3f-5a93-9ee0-9680-666e6eccd684
+:END:
+
+*** Description
+
+Specificially, looking at reading-pace when run on prod, it claims that I've
+only had one reading session without music. Which may be true, but perhaps we
+need to indicate what the time frame we're looking at is (month, week, year)
+and provide a way to jump back and forward through time, same as charts.
+
+
+* Version 54.1 [1/1]
+** DONE [#A] Concurrent listening trend is inefficient and should be disabled :trends:scrobbles:
+:PROPERTIES:
+:ID:       4aa3b719-6b22-cae9-85f0-fac67b4fc753
+:END:
+
+* Version 54.0 [3/3]
+** DONE [#B] Add peak hour, weekly rhythm and activity dist trends :trends:scrobbles:
+:PROPERTIES:
+:ID:       5fa52fac-d5f0-4369-bcaa-589c886b07d3
+:END:
+
+** DONE [#A] Implement YouTube channel info scraping :videos:youtube:stub:
+:PROPERTIES:
+:ID:       1d3beafd-62cb-4735-a465-edb37bf885db
+:END:
+
+*** Description
+File: ~vrobbler/apps/videos/models.py~ (line 140)
+
+=Video.fix_metadata()= is a stub that logs "Not implemented yet" and returns.
+Needs actual implementation to scrape channel metadata from YouTube.
+
+** DONE [#A] Fix Amazon book scraper :amazon:scraper:broken:
+:PROPERTIES:
+:ID:       c38aba25-0171-49ab-a9f3-acf2003da429
+:END:
+
+*** Description
+
+File: ~vrobbler/apps/books/amazon.py~ (line 56)
+
+The =scrape_data_from_amazon()= function is likely broken due to Amazon blocking
+scrapers and changing HTML structure. Needs rewrite or replacement with a proper
+API.
+
+
+* Version 53.1 [1/1]
+** DONE [#A] Error with loading logdict :scrobbles:bug:logdata:
+:PROPERTIES:
+:ID:       92d4fa16-4b90-47e0-95ae-472bdca582ce
+:END:
+
+
 * Version 53.0 [5/5]
 ** DONE [#B] Add a /trends/ page that shows trends based on scrobble data :feature:trends:scrobbles:
 :PROPERTIES:

poetry.lock

@@ -4270,6 +4270,29 @@ six = "*"
 [package.extras]
 testing = ["filelock"]
 
+[[package]]
+name = "python-amazon-paapi"
+version = "6.3.0"
+description = "Amazon Product Advertising API 5.0 wrapper for Python"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "python_amazon_paapi-6.3.0-py3-none-any.whl", hash = "sha256:b7cd852084a49d53c3ba2195531fccbc8c7f4124b2e82e2fda02b53d3b8de521"},
+    {file = "python_amazon_paapi-6.3.0.tar.gz", hash = "sha256:e525d69efcbe4f9566ec2b9b43fa3183c484d166d3852edb38b4df9c0b19cf1f"},
+]
+
+[package.dependencies]
+certifi = ">=2023.0.0"
+pydantic = ">=2.0.0"
+python-dateutil = ">=2.8.0"
+requests = ">=2.28.0"
+six = ">=1.16.0"
+urllib3 = ">=1.26.0,<3"
+
+[package.extras]
+async = ["httpx (>=0.27.0)", "typing-extensions (>=4.15.0)"]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
@@ -6032,4 +6055,4 @@ cffi = ["cffi (>=1.17,<2.0) ; platform_python_implementation != \"PyPy\" and pyt
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.11,<3.15"
-content-hash = "cc5b3b44071d6b0ab4f05189580232cc129b4ed694ab3f0673c3d838c3af0f8a"
+content-hash = "aafab54d3c3d674b917782bf449b7d6324ca2259fb58bff13a08caabe110c342"

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vrobbler"
-version = "53.0"
+version = "54.4"
 description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]
 
@@ -64,6 +64,7 @@ fitparse = "^1.2.0"
 lxml = ">=5.5.0"
 vaderSentiment = "^3.3.2"
 sqids = "^0.5.2"
+python-amazon-paapi = "^6.3.0"
 
 [tool.poetry.group.test]
 optional = true

vrobbler/apps/books/amazon.py

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

vrobbler/apps/books/constants.py

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

vrobbler/apps/books/models.py

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

vrobbler/apps/books/sources/amazon.py

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

vrobbler/apps/music/models.py

@@ -600,8 +600,9 @@ class Track(ScrobblableMixin):
     def __str__(self):
         return f"{self.title} by {self.artist}"
 
+    @property
     def logdata_cls(self):
-        return TrackLogData()
+        return TrackLogData
 
     @property
     def primary_album(self):

vrobbler/apps/trends/admin.py

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

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

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

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

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

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

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

vrobbler/apps/trends/models.py

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

vrobbler/apps/trends/tasks.py

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

vrobbler/apps/trends/trends/__init__.py

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

vrobbler/apps/trends/trends/activity.py

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

vrobbler/apps/trends/trends/concurrent.py

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

vrobbler/apps/trends/trends/mood.py

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

vrobbler/apps/trends/trends/reading.py

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

vrobbler/apps/trends/trends/trending.py

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

vrobbler/apps/trends/urls.py

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

vrobbler/apps/trends/utils.py

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

vrobbler/apps/trends/views.py

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

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

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

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

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

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

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

vrobbler/apps/videos/models.py

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

vrobbler/apps/videos/sources/tmdb.py

@@ -1,4 +1,5 @@
 import logging
+import os
 
 import pendulum
 from django.conf import settings
@@ -8,6 +9,8 @@ from videos.metadata import VideoMetadata, VideoType
 
 TMDB_KEY = getattr(settings, "TMDB_API_KEY", "")
 
+os.environ.setdefault("TMDB_API_KEY", TMDB_KEY)
+
 tmdb = TMDb(key=TMDB_KEY, language="en-US", region="US")
 
 TMDB_IMAGE_URL = "https://image.tmdb.org/t/p/original"
@@ -43,6 +46,28 @@ def lookup_video_from_tmdb(name_or_id: str, kind: str = "movie") -> VideoMetadat
         )  # TODO: enrich this with TMDB url
         video_metadata.year = pendulum.parse(media.release_date).year
         video_metadata.genres = [g.get("name", "") for g in media.genres]
+        video_metadata.tmdb_id = media.id
+        video_metadata.base_run_time_seconds = media.runtime * 60
+        video_metadata.plot = media.overview
+        video_metadata.overview = media.overview
+        video_metadata.tmdb_rating = media.vote_average
+
+    if len(tmdb_result.tv_results) > 0:
+        media = TV().details(tmdb_result.tv_results[0].id)
+        video_metadata.video_type = VideoType.TV_EPISODE.value
+        video_metadata.title = media.name
+        video_metadata.cover_url = (
+            TMDB_IMAGE_URL + media.poster_path
+        )
+        video_metadata.year = pendulum.parse(media.first_air_date).year if media.first_air_date else None
+        video_metadata.genres = [g.get("name", "") for g in media.genres]
+        video_metadata.tmdb_id = media.id
+        video_metadata.base_run_time_seconds = (
+            media.episode_run_time[0] * 60 if media.episode_run_time else 1800
+        )
+        video_metadata.plot = media.overview
+        video_metadata.overview = media.overview
+        video_metadata.tmdb_rating = media.vote_average
 
     if len(tmdb_result.tv_episode_results) > 0:
         video_metadata.video_type = VideoType.TV_EPISODE.value
@@ -63,15 +88,12 @@ def lookup_video_from_tmdb(name_or_id: str, kind: str = "movie") -> VideoMetadat
             series.save()
         video_metadata.tv_series_id = series.id
 
+        video_metadata.tmdb_id = media.id
+        video_metadata.plot = media.overview
+        video_metadata.overview = media.overview
+
     if not media:
         logger.warning("Video not found on TMDB", extra={"imdb_id": imdb_id})
         return video_metadata
 
-    video_metadata.tmdb_id = media.id
-    video_metadata.base_run_time_seconds = media.runtime * 60
-    video_metadata.plot = media.overview
-    video_metadata.overview = media.overview
-    video_metadata.tmdb_rating = media.vote_average
-    # video_metadata.next_imdb_id = imdb_result.get("next episode", None)
-
     return video_metadata

vrobbler/apps/videos/sources/youtube.py

@@ -4,7 +4,6 @@ import logging
 import pendulum
 import requests
 from django.conf import settings
-
 from videos.metadata import VideoMetadata, VideoType
 
 logger = logging.getLogger(__name__)
@@ -13,7 +12,7 @@ YOUTUBE_VIDEO_URL = "https://www.youtube.com/watch?v="
 YOUTUBE_CHANNEL_URL = "https://www.youtube.com/channel/"
 
 API_KEY = settings.GOOGLE_API_KEY
-GOOGLE_VIDEOS_URL = "https://www.googleapis.com/youtube/v3/videos?part=snippet,contentDetails&id={youtube_id}&key={key}"
+GOOGLE_VIDEOS_URL = "https://www.googleapis.com/youtube/v3/videos?part=snippet,contentDetails,topicDetails&id={youtube_id}&key={key}"
 
 
 def lookup_video_from_youtube(youtube_id: str) -> VideoMetadata:
@@ -68,6 +67,15 @@ def lookup_video_from_youtube(youtube_id: str) -> VideoMetadata:
             yt_metadata.get("thumbnails", {}).get("high", {}).get("url", {})
         )
         video_metadata.genres = yt_metadata.get("tags", [])
+        topic_details = (
+            json.loads(response.content).get("items", [None])[0].get("topicDetails", {})
+        )
+        topic_categories = topic_details.get("topicCategories", [])
+        for category_url in topic_categories:
+            topic_name = category_url.rstrip("/").split("/")[-1]
+            topic_name = topic_name.replace("_", " ").replace("-", " ")
+            if topic_name not in video_metadata.genres:
+                video_metadata.genres.append(topic_name)
         video_metadata.overview = yt_metadata.get("description", "")
 
         date_str = yt_metadata.get("publishedAt")

vrobbler/apps/videos/views.py

@@ -1,5 +1,7 @@
 import datetime
+
 from django.contrib.auth.mixins import LoginRequiredMixin
+from django.core.paginator import EmptyPage, PageNotAnInteger, Paginator
 from django.utils import timezone
 from django.views import generic
 from scrobbles.models import Scrobble
@@ -44,15 +46,31 @@ class SeriesDetailView(LoginRequiredMixin, ChartContextMixin, generic.DetailView
         return context_data
 
 
-class ChannelDetailView(LoginRequiredMixin, generic.DetailView):
+class ChannelDetailView(LoginRequiredMixin, ChartContextMixin, generic.DetailView):
     model = Channel
     slug_field = "uuid"
     template_name = "videos/channel_detail.html"
+    paginate_by = 50
 
     def get_context_data(self, **kwargs):
         user_id = self.request.user.id
         context_data = super().get_context_data(**kwargs)
-        context_data["scrobbles"] = self.object.scrobbles_for_user(user_id)
+
+        scrobbles = self.object.scrobbles_for_user(user_id)
+        paginator = Paginator(scrobbles, self.paginate_by)
+        page_number = self.request.GET.get("page")
+
+        try:
+            page_obj = paginator.page(page_number)
+        except PageNotAnInteger:
+            page_obj = paginator.page(1)
+        except EmptyPage:
+            page_obj = paginator.page(paginator.num_pages)
+
+        context_data["page_obj"] = page_obj
+        context_data["scrobbles"] = page_obj.object_list
+        context_data["is_paginated"] = paginator.num_pages > 1
+
         return context_data
 
 

vrobbler/settings.py

@@ -82,6 +82,11 @@ TODOIST_CLIENT_SECRET = os.getenv("VROBBLER_TODOIST_CLIENT_SECRET", "")
 GOOGLE_API_KEY = os.getenv("VROBBLER_GOOGLE_API_KEY", "")
 LICHESS_API_KEY = os.getenv("VROBBLER_LICHESS_API_KEY", "")
 
+AMAZON_PAAPI_ACCESS_KEY = os.getenv("VROBBLER_AMAZON_PAAPI_ACCESS_KEY", "")
+AMAZON_PAAPI_SECRET_KEY = os.getenv("VROBBLER_AMAZON_PAAPI_SECRET_KEY", "")
+AMAZON_PAAPI_ASSOCIATE_TAG = os.getenv("VROBBLER_AMAZON_PAAPI_ASSOCIATE_TAG", "")
+AMAZON_PAAPI_COUNTRY = os.getenv("VROBBLER_AMAZON_PAAPI_COUNTRY", "US")
+
 DEFAULT_TASK_CONTEXT_TAGS = [
     "Dev",
     "Home",

vrobbler/templates/videos/channel_detail.html

@@ -19,6 +19,26 @@
      color:white;
      background:rgba(0,0,0,0.4);
 }
+dl {
+    display: flex;
+    flex-flow: row wrap;
+    padding-right:20px;
+    border:none;
+}
+dt {
+    flex-basis: 20%;
+    padding: 5px;
+    background: #3cf;
+    text-align: right;
+    color: #fff;
+}
+dd {
+    flex-basis: 70%;
+    flex-grow: 1;
+    margin: 0;
+    padding: 5px;
+    border:none;
+}
 </style>
 {% endblock %}
 
@@ -29,9 +49,30 @@
         <img src="{{ object.safe_cover_image_url }}" width="400px" />
     </div>
     <div class="summary">
-        {% if object.youtube_id %}<p><a href="{{object.youtube_url}}" target="_blank">View on YouTube</a></p>{% endif %}
+        {% if object.description %}<p><em>{{object.description}}</em></p>{% endif %}
+        {% if object.genre.all %}
+        <p>Genres: {% for tag in object.genre.all %}<span class="badge bg-secondary">{{tag.name}}</span> {% endfor %}</p>
+        {% endif %}
+        <hr />
+        {% if object.youtube_id %}
+        <p style="float:right;">
+            <a href="{{object.youtube_url}}" target="_blank"><img src="{% static "images/youtube_logo.png" %}" width=35></a>
+        </p>
+        {% endif %}
+        {% if object.twitch_id %}
+        <p style="float:right;">
+            <a href="{{object.twitch_url}}" target="_blank">View on Twitch</a>
+        </p>
+        {% endif %}
     </div>
 </div>
+{% if charts %}
+<div class="row">
+    <div class="col-md">
+        {% include "scrobbles/_chart_links.html" %}
+    </div>
+</div>
+{% endif %}
 <div class="row">
     <div class="col-md">
         <h3>Last scrobbles</h3>
@@ -41,6 +82,8 @@
                     <tr>
                         <th scope="col">Date</th>
                         <th scope="col">Title</th>
+                        <th scope="col">With</th>
+                        <th scope="col">Rated</th>
                     </tr>
                 </thead>
                 <tbody>
@@ -48,11 +91,26 @@
                     <tr>
                         <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
                         <td><a href="{{scrobble.media_obj.get_absolute_url}}">{{scrobble.media_obj.title}}</a></td>
+                        <td>{% firstof scrobble.logdata.with_people|join:", " "Solo" %}</td>
+                        <td>{% firstof scrobble.logdata.rating "Unrated" %}</td>
                     </tr>
                     {% endfor %}
                 </tbody>
             </table>
         </div>
+        {% if is_paginated %}
+        <nav>
+            <ul class="pagination">
+                {% if page_obj.has_previous %}
+                <li class="page-item"><a class="page-link" href="?page={{ page_obj.previous_page_number }}">Previous</a></li>
+                {% endif %}
+                <li class="page-item disabled"><span class="page-link">Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}</span></li>
+                {% if page_obj.has_next %}
+                <li class="page-item"><a class="page-link" href="?page={{ page_obj.next_page_number }}">Next</a></li>
+                {% endif %}
+            </ul>
+        </nav>
+        {% endif %}
     </div>
 </div>
 {% endblock %}

vrobbler/templates/videos/video_detail.html

@@ -63,6 +63,7 @@ dd {
     </div>
     <div class="summary">
     {% if object.tv_series %}<h4><a href="{{object.tv_series.get_absolute_url}}">{{object.tv_series}}</a> - S{{object.season_number}}E{{object.episode_number}}</h4>{% endif %}
+        {% if object.channel %}<h5><a href="{{object.channel.get_absolute_url}}">{{object.channel.name}}</a></h5>{% endif %}
         {% if object.overview %}<p><em>{{object.overview}}</em></p>{% endif %}
         {% if object.plot%}<p>{{object.plot|safe|linebreaks|truncatewords:160}}</p>{% endif %}
         <hr />