Merge remote-tracking branch 'origin/latest' into latest

Author: dannyvfilms

src/app/management/commands/populate_runtime_data.py

@@ -55,6 +55,7 @@ def handle(self, *args, **options):
             ],
             source__in=[
                 "tmdb",
+                "tvdb",
                 "mal",
                 "simkl",
             ],  # Only process items from providers that have runtime data

src/app/season_details_views.py

@@ -342,6 +342,34 @@ def _scoped_season_item_qs():
             if episode_number is None:
                 continue
 
+            # Parse the episode's air date once — reused below both for the
+            # "aired but runtime unknown" heuristic and to persist
+            # release_datetime. Without this, release_datetime is never set
+            # for any episode the user hasn't individually tracked/watched
+            # (that's the only other code path that extracts it), so an
+            # episode created here from a page view stays permanently NULL
+            # even once the provider does have its air date.
+            air_date_dt = None
+            raw_air_date = episode.get("air_date")
+            if raw_air_date:
+                try:
+                    if isinstance(raw_air_date, str):
+                        date_obj = datetime.strptime(raw_air_date, "%Y-%m-%d")  # noqa: DTZ007  # date-only value; no timezone applies
+                        air_date_dt = timezone.make_aware(
+                            date_obj,
+                            timezone.get_current_timezone(),
+                        )
+                    elif hasattr(raw_air_date, "year"):
+                        air_date_dt = (
+                            raw_air_date
+                            if timezone.is_aware(raw_air_date)
+                            else timezone.make_aware(raw_air_date)
+                        )
+                except (ValueError, TypeError):
+                    air_date_dt = None
+                if air_date_dt and air_date_dt.year <= MIN_PLAUSIBLE_YEAR:
+                    air_date_dt = None
+
             # Get or create episode item — retry on race condition
             lookup = {
                 "media_id": media_id,
@@ -360,6 +388,7 @@ def _scoped_season_item_qs():
                         defaults={
                             "title": season_metadata.get("title", ""),
                             "image": settings.IMG_NONE,
+                            "release_datetime": air_date_dt,
                         },
                     )
             except IntegrityError:
@@ -371,27 +400,9 @@ def _scoped_season_item_qs():
                 runtime_minutes = (
                     int(episode["runtime"]) if episode["runtime"] > 0 else None
                 )
-            elif episode.get("air_date"):
-                # Check if episode has aired
-                try:
-                    if isinstance(episode["air_date"], str):
-                        date_obj = datetime.strptime(episode["air_date"], "%Y-%m-%d")  # noqa: DTZ007  # date-only value; no timezone applies
-                        air_date_dt = timezone.make_aware(
-                            date_obj,
-                            timezone.get_current_timezone(),
-                        )
-                    else:
-                        air_date_dt = episode["air_date"]
-
-                    if (
-                        air_date_dt
-                        and air_date_dt.year > MIN_PLAUSIBLE_YEAR
-                        and air_date_dt <= current_datetime
-                    ):
-                        # Episode has aired but no runtime - mark as unknown (use 999998)
-                        runtime_minutes = 999998
-                except (ValueError, TypeError):
-                    pass
+            elif air_date_dt and air_date_dt <= current_datetime:
+                # Episode has aired but no runtime - mark as unknown (use 999998)
+                runtime_minutes = 999998
 
             # Extract provider rating from raw episode data (already in memory, no extra API call)
             score = None
@@ -412,20 +423,34 @@ def _scoped_season_item_qs():
                 episode_item.provider_rating != score
                 or episode_item.provider_rating_count != score_count
             )
+            # Only fill in a missing date, never overwrite one that's already
+            # set — this lets an episode created before its air date was
+            # known self-heal the next time anyone views the season page,
+            # without a dedicated backfill task.
+            release_datetime_changed = (
+                air_date_dt is not None and episode_item.release_datetime is None
+            )
 
             if runtime_changed:
                 episode_item.runtime_minutes = runtime_minutes
             if rating_changed:
                 episode_item.provider_rating = score
                 episode_item.provider_rating_count = score_count
+            if release_datetime_changed:
+                episode_item.release_datetime = air_date_dt
 
-            if runtime_changed or rating_changed:
+            if runtime_changed or rating_changed or release_datetime_changed:
                 episodes_to_update.append(episode_item)
 
         if episodes_to_update:
             Item.objects.bulk_update(
                 episodes_to_update,
-                ["runtime_minutes", "provider_rating", "provider_rating_count"],
+                [
+                    "runtime_minutes",
+                    "provider_rating",
+                    "provider_rating_count",
+                    "release_datetime",
+                ],
                 batch_size=100,
             )
             # Invalidate time_left + media_list cache for all users

src/app/signals.py

@@ -52,8 +52,8 @@
 
 RUNTIME_UNKNOWN_FAILED = 999999  # runtime completely unknown / failed lookup
 
-RUNTIME_BACKFILL_SOURCES = ("tmdb", "mal", "simkl")
-GENRE_BACKFILL_SOURCES = ("tmdb", "mal", "simkl", "igdb", "bgg")
+RUNTIME_BACKFILL_SOURCES = ("tmdb", "tvdb", "mal", "simkl")
+GENRE_BACKFILL_SOURCES = ("tmdb", "tvdb", "mal", "simkl", "igdb", "bgg")
 DISCOVER_PRIORITY_HISTORY_DEBOUNCE_SECONDS = 15
 DISCOVER_PRIORITY_HISTORY_COUNTDOWN = 15
 DISCOVER_PRIORITY_STATISTICS_DEBOUNCE_SECONDS = 20

src/app/tasks.py

@@ -168,6 +168,7 @@
 
 RELEASE_BACKFILL_SOURCES = (
     Sources.TMDB.value,
+    Sources.TVDB.value,
     Sources.MAL.value,
     Sources.MANGAUPDATES.value,
     Sources.IGDB.value,

src/app/tasks_genre.py

@@ -32,6 +32,7 @@
 
 GENRE_BACKFILL_SOURCES = (
     Sources.TMDB.value,
+    Sources.TVDB.value,
     Sources.MAL.value,
     "simkl",
     Sources.IGDB.value,

src/app/tasks_runtime.py

@@ -30,7 +30,7 @@
 
 BACKGROUND_TASK_PRIORITY = getattr(settings, "CELERY_TASK_PRIORITY_BACKGROUND", 9)
 
-RUNTIME_BACKFILL_SOURCES = ("tmdb", "mal", "simkl")
+RUNTIME_BACKFILL_SOURCES = ("tmdb", "tvdb", "mal", "simkl")
 RUNTIME_BACKFILL_QUEUE_TTL = 60 * 60  # 1 hour
 
 SEASON_KEY_TUPLE_LENGTH = 3  # (media_id, source, season_number)

src/app/templatetags/app_tags.py

@@ -1137,28 +1137,35 @@ def media_view_url(view_name, media):
     if not is_dict and not hasattr(media, "source"):
         return ""
 
+    media_type = media["media_type"] if is_dict else media.media_type
+
     # Build kwargs using either dict access or object attribute
     kwargs = {
         "source": media["source"] if is_dict else media.source,
         "media_type": (
-            media.get("route_media_type") or media["media_type"]
+            media.get("route_media_type") or media_type
             if is_dict
-            else getattr(media, "route_media_type", None) or media.media_type
+            else getattr(media, "route_media_type", None) or media_type
         ),
         "media_id": str(media["media_id"] if is_dict else media.media_id),
     }
 
-    # Handle season/episode numbers if they exist
-    if is_dict:
-        if "season_number" in media:
-            kwargs["season_number"] = media["season_number"]
-        if "episode_number" in media:
-            kwargs["episode_number"] = media["episode_number"]
-    else:
-        season_number = getattr(media, "season_number", None)
-        episode_number = getattr(media, "episode_number", None)
+    # Providers may include season_number=0 on top-level TV/anime metadata.
+    # Only season and episode objects use those values as URL path segments.
+    if media_type in (MediaTypes.SEASON.value, MediaTypes.EPISODE.value):
+        season_number = (
+            media.get("season_number")
+            if is_dict
+            else getattr(media, "season_number", None)
+        )
         if season_number is not None:
             kwargs["season_number"] = season_number
+    if media_type == MediaTypes.EPISODE.value:
+        episode_number = (
+            media.get("episode_number")
+            if is_dict
+            else getattr(media, "episode_number", None)
+        )
         if episode_number is not None:
             kwargs["episode_number"] = episode_number
 

src/app/tests/test_templatetags.py

@@ -880,6 +880,26 @@ def test_media_view_url(self):
             expected_tv_modal,
         )
 
+        # TMDB includes season_number=0 on top-level anime metadata. It is not
+        # a season route and must not become /lists_modal/.../<id>/0.
+        anime_dict = {
+            "source": Sources.TMDB.value,
+            "media_type": MediaTypes.ANIME.value,
+            "media_id": "83611",
+            "season_number": 0,
+        }
+        self.assertEqual(
+            app_tags.media_view_url("lists_modal", anime_dict),
+            reverse(
+                "lists_modal",
+                kwargs={
+                    "source": Sources.TMDB.value,
+                    "media_type": MediaTypes.ANIME.value,
+                    "media_id": "83611",
+                },
+            ),
+        )
+
     def test_unicode_icon(self):
         """Test the unicode_icon tag for all media types."""
         # Test all media types from MediaTypes

src/app/tests/views/test_media_details.py

@@ -5421,6 +5421,154 @@ def test_season_details_secondary_fragment_renders_episodes(
         )
         mock_process_episodes.assert_called_once()
 
+    @patch("app.providers.services.get_media_metadata")
+    @patch("app.providers.tmdb.process_episodes")
+    def test_season_details_persists_and_self_heals_episode_release_datetime(
+        self,
+        mock_process_episodes,
+        mock_get_metadata,
+    ):
+        """Viewing a season page must persist release_datetime for every episode.
+
+        Regression test: episode Items created while browsing a season page
+        (as opposed to individually tracking/watching one) previously only
+        picked up runtime/rating from the live provider payload and silently
+        dropped release_datetime, leaving it NULL forever unless that exact
+        episode was later tracked or a manual metadata sync ran. This left
+        "not caught up" categorization permanently wrong for any unwatched
+        episode created this way.
+        """
+        tv_item = Item.objects.create(
+            media_id="1668",
+            source=Sources.TMDB.value,
+            media_type=MediaTypes.TV.value,
+            title="Test TV Show",
+            image="http://example.com/show.jpg",
+        )
+        related_tv = TV.objects.create(
+            item=tv_item,
+            user=self.user,
+            status=Status.IN_PROGRESS.value,
+        )
+        season_item = Item.objects.create(
+            media_id="1668",
+            source=Sources.TMDB.value,
+            media_type=MediaTypes.SEASON.value,
+            title="Test TV Show",
+            image="http://example.com/show.jpg",
+            season_number=1,
+        )
+        Season.objects.create(
+            item=season_item,
+            user=self.user,
+            status=Status.IN_PROGRESS.value,
+            related_tv=related_tv,
+        )
+
+        # Episode 1 already has a trusted release_datetime — must not be
+        # clobbered by a differing value from the live payload.
+        already_dated_episode = Item.objects.create(
+            media_id="1668",
+            source=Sources.TMDB.value,
+            media_type=MediaTypes.EPISODE.value,
+            title="No Shortcuts",
+            image=settings.IMG_NONE,
+            season_number=1,
+            episode_number=1,
+            release_datetime=timezone.make_aware(datetime(2023, 1, 1)),
+        )
+        # Episode 2 exists (e.g. created by an earlier page view before its
+        # air date was known) but was never given a release_datetime.
+        stale_episode = Item.objects.create(
+            media_id="1668",
+            source=Sources.TMDB.value,
+            media_type=MediaTypes.EPISODE.value,
+            title="Test TV Show",
+            image=settings.IMG_NONE,
+            season_number=1,
+            episode_number=2,
+            release_datetime=None,
+        )
+
+        mock_get_metadata.side_effect = lambda *_args, **_kwargs: {
+            "title": "Test TV Show",
+            "media_id": "1668",
+            "source": Sources.TMDB.value,
+            "media_type": MediaTypes.TV.value,
+            "image": "http://example.com/image.jpg",
+            "season/1": {
+                "title": "Test TV Show",
+                "season_title": "Season 1",
+                "media_id": "1668",
+                "media_type": MediaTypes.SEASON.value,
+                "source": Sources.TMDB.value,
+                "image": "http://example.com/season.jpg",
+                "episodes": [
+                    {
+                        "episode_number": 1,
+                        "name": "No Shortcuts",
+                        "air_date": "2023-06-01",  # differs from the stored date
+                        "runtime": 48,
+                    },
+                    {
+                        "episode_number": 2,
+                        "name": "Episode 2",
+                        "air_date": "2023-01-08",
+                        "runtime": 42,
+                    },
+                    {
+                        "episode_number": 3,
+                        "name": "Episode 3",
+                        "air_date": "2023-01-15",
+                        "runtime": 44,
+                    },
+                ],
+            },
+        }
+        mock_process_episodes.return_value = []
+
+        response = self.client.get(
+            reverse(
+                "season_details",
+                kwargs={
+                    "source": Sources.TMDB.value,
+                    "media_id": "1668",
+                    "title": "test-tv-show",
+                    "season_number": 1,
+                },
+            ),
+            {"fragment": "secondary"},
+        )
+
+        self.assertEqual(response.status_code, 200)
+
+        already_dated_episode.refresh_from_db()
+        self.assertEqual(
+            already_dated_episode.release_datetime,
+            timezone.make_aware(datetime(2023, 1, 1)),
+            "an already-set release_datetime must not be overwritten",
+        )
+
+        stale_episode.refresh_from_db()
+        self.assertEqual(
+            stale_episode.release_datetime,
+            timezone.make_aware(datetime(2023, 1, 8)),
+            "a NULL release_datetime must self-heal from the live payload",
+        )
+
+        new_episode = Item.objects.get(
+            media_id="1668",
+            source=Sources.TMDB.value,
+            media_type=MediaTypes.EPISODE.value,
+            season_number=1,
+            episode_number=3,
+        )
+        self.assertEqual(
+            new_episode.release_datetime,
+            timezone.make_aware(datetime(2023, 1, 15)),
+            "a newly created episode must get release_datetime from the same payload",
+        )
+
     @patch("app.views.trakt_popularity_service.refresh_trakt_popularity")
     @patch("app.providers.tmdb.get_tvdb_episode_image_map")
     @patch("app.helpers.get_tmdb_backdrop_image")