Fix duplicate calendar events and notifications for anime tracked in both buckets

- EventManager gains a cross-bucket dedup that resolves an Anime item's MAL
  id to a verified TMDB/TVDB id via the pinned Kometa Anime-IDs mapping and
  hides the Anime-bucket event when the user also actively tracks that show
  in the TV bucket.
- notifications.get_user_releases now applies the same hidden-duplicate-id
  filter, which also fixes the pre-existing gap where the TMDB/TVDB
  cross-provider dedup (#639) wasn't applied to release notifications.

Fixes #968

Author: dannyvfilms

src/events/models.py

@@ -17,6 +17,7 @@
 from app import config
 from app.models import TV, Item, MediaTypes, Season, Sources, Status
 from app.services.item_merge import dedupe_cross_provider_items
+from integrations.anime_mapping import resolve_provider_series_id
 
 # Statuses that represent inactive tracking
 # will be ignored when creating events
@@ -76,15 +77,27 @@ def get_user_events(self, user, first_day, last_day):
             datetime__lte=end_datetime,
         ).select_related("item")
 
-        hidden_item_ids = self._cross_provider_hidden_season_item_ids(
-            user,
-            enabled_types,
-        )
+        hidden_item_ids = self.hidden_duplicate_item_ids(user, enabled_types)
         if hidden_item_ids:
             queryset = queryset.exclude(item_id__in=hidden_item_ids)
 
         return self.sort_with_sentinel_last(queryset)
 
+    def hidden_duplicate_item_ids(self, user, enabled_types):
+        """Return `Item` ids to exclude because a preferred duplicate exists.
+
+        Combines the TMDB/TVDB cross-provider dedup (#639) with the
+        Anime/TV cross-bucket dedup (#968), so both the calendar and
+        release notifications hide the same duplicates.
+        """
+        return self._cross_provider_hidden_season_item_ids(
+            user,
+            enabled_types,
+        ) | self._cross_bucket_hidden_anime_item_ids(
+            user,
+            enabled_types,
+        )
+
     def _active_tv_show_media_ids(self, user):
         """Return media_ids of the user's actively-tracked TV shows."""
         return (
@@ -140,6 +153,58 @@ def _cross_provider_hidden_season_item_ids(self, user, enabled_types):
         kept_ids = {item.id for item in deduped}
         return {item.id for item in season_items if item.id not in kept_ids}
 
+    def _cross_bucket_hidden_anime_item_ids(self, user, enabled_types):
+        """Return Anime `Item` ids to hide because a tracked TV counterpart exists.
+
+        A user can track the same real show both in the Anime bucket (MAL)
+        and the TV bucket (TMDB/TVDB) - each gets its own independent `Item`
+        and `Event`s, so without this the calendar and release notifications
+        fire twice for the same episode (#968). Uses the pinned Kometa
+        Anime-IDs mapping (`integrations.anime_mapping`) to resolve a MAL id
+        to its verified TMDB/TVDB series id - never a title guess. The TV
+        bucket is always kept since it carries season/episode structure; the
+        Anime bucket duplicate is hidden.
+        """
+        if MediaTypes.ANIME.value not in enabled_types:
+            return set()
+        if not (
+            MediaTypes.TV.value in enabled_types
+            or MediaTypes.SEASON.value in enabled_types
+        ):
+            return set()
+
+        active_anime_items = list(
+            Item.objects.filter(
+                media_type=MediaTypes.ANIME.value,
+                source=Sources.MAL.value,
+                anime__user=user,
+            ).exclude(anime__status__in=INACTIVE_TRACKING_STATUSES),
+        )
+        if not active_anime_items:
+            return set()
+
+        active_tv_shows = set(
+            TV.objects.filter(
+                user=user,
+                item__media_type=MediaTypes.TV.value,
+            )
+            .exclude(status__in=INACTIVE_TRACKING_STATUSES)
+            .values_list("item__source", "item__media_id"),
+        )
+        if not active_tv_shows:
+            return set()
+
+        hidden_ids = set()
+        for anime_item in active_anime_items:
+            tmdb_id = resolve_provider_series_id(anime_item.media_id, "tmdb")
+            tvdb_id = resolve_provider_series_id(anime_item.media_id, "tvdb")
+            if (tmdb_id and (Sources.TMDB.value, tmdb_id) in active_tv_shows) or (
+                tvdb_id and (Sources.TVDB.value, tvdb_id) in active_tv_shows
+            ):
+                hidden_ids.add(anime_item.id)
+
+        return hidden_ids
+
     def _build_tv_query(self, user, enabled_types):
         """Build query for TV shows based on TV status and season statuses."""
         if not (

src/events/notifications.py

@@ -230,8 +230,16 @@ def get_user_releases(users, target_events):
         user_events = []
         enabled_types = user_enabled_types[user.id]
         excluded_items = user_exclusions.get(user.id, set())
+        hidden_item_ids = Event.objects.hidden_duplicate_item_ids(
+            user,
+            enabled_types,
+        )
 
         for event in target_events.values():
+            # Check if a preferred cross-provider/cross-bucket duplicate exists
+            if event.item.id in hidden_item_ids:
+                continue
+
             # Check if user has excluded this item
             if event.item.media_type != Season and event.item.id in excluded_items:
                 continue

src/events/tests/test_models.py

@@ -1,4 +1,5 @@
 import datetime
+from unittest import mock
 
 from django.contrib.auth import get_user_model
 from django.test import TestCase
@@ -466,3 +467,141 @@ def test_get_user_events_stays_a_queryset_for_media_type_filtering(self):
         filtered = events.filter(item__media_type__in=[MediaTypes.SEASON.value])
 
         self.assertEqual(filtered.count(), 1)
+
+
+class EventManagerCrossBucketAnimeDedupTests(TestCase):
+    """The calendar must not show the same real episode twice across buckets (#968)."""
+
+    def setUp(self):
+        self.credentials = {"username": "dedup-anime-user", "password": "testpass123"}
+        self.user = get_user_model().objects.create_user(**self.credentials)
+
+    def _anime_item(self, mal_id="52991"):
+        anime_item = Item.objects.create(
+            title="Test Anime",
+            media_id=mal_id,
+            media_type=MediaTypes.ANIME.value,
+            source=Sources.MAL.value,
+            image="",
+        )
+        Anime.objects.create(
+            item=anime_item,
+            user=self.user,
+            status=Status.IN_PROGRESS.value,
+        )
+        return anime_item
+
+    def _tv_show(self, media_id="1396", source=Sources.TMDB.value):
+        tv_item = Item.objects.create(
+            title="Test TV Show",
+            media_id=media_id,
+            media_type=MediaTypes.TV.value,
+            source=source,
+            image="",
+        )
+        season_item = Item.objects.create(
+            title="Test TV Show - Season 1",
+            media_id=media_id,
+            media_type=MediaTypes.SEASON.value,
+            source=source,
+            image="",
+            season_number=1,
+        )
+        TV.objects.create(
+            item=tv_item,
+            user=self.user,
+            status=Status.IN_PROGRESS.value,
+        )
+        return season_item
+
+    def test_hides_anime_duplicate_with_matching_tmdb_show(self):
+        anime_item = self._anime_item()
+        season_item = self._tv_show(media_id="1396", source=Sources.TMDB.value)
+        when = timezone.now() + datetime.timedelta(days=1)
+        anime_event = Event.objects.create(
+            item=anime_item,
+            content_number=1,
+            datetime=when,
+        )
+        season_event = Event.objects.create(
+            item=season_item,
+            content_number=1,
+            datetime=when,
+        )
+
+        with mock.patch(
+            "events.models.resolve_provider_series_id",
+            side_effect=lambda mal_id, provider: (
+                "1396" if provider == "tmdb" else None
+            ),
+        ):
+            events = Event.objects.get_user_events(self.user, when.date(), when.date())
+
+        self.assertEqual(list(events), [season_event])
+        self.assertNotIn(anime_event, events)
+
+    def test_hides_anime_duplicate_with_matching_tvdb_show(self):
+        anime_item = self._anime_item()
+        season_item = self._tv_show(media_id="81189", source=Sources.TVDB.value)
+        when = timezone.now() + datetime.timedelta(days=1)
+        anime_event = Event.objects.create(
+            item=anime_item,
+            content_number=1,
+            datetime=when,
+        )
+        season_event = Event.objects.create(
+            item=season_item,
+            content_number=1,
+            datetime=when,
+        )
+
+        with mock.patch(
+            "events.models.resolve_provider_series_id",
+            side_effect=lambda mal_id, provider: (
+                "81189" if provider == "tvdb" else None
+            ),
+        ):
+            events = Event.objects.get_user_events(self.user, when.date(), when.date())
+
+        self.assertEqual(list(events), [season_event])
+        self.assertNotIn(anime_event, events)
+
+    def test_keeps_anime_event_without_tv_counterpart(self):
+        anime_item = self._anime_item()
+        when = timezone.now() + datetime.timedelta(days=1)
+        anime_event = Event.objects.create(
+            item=anime_item,
+            content_number=1,
+            datetime=when,
+        )
+
+        with mock.patch(
+            "events.models.resolve_provider_series_id",
+            return_value=None,
+        ):
+            events = Event.objects.get_user_events(self.user, when.date(), when.date())
+
+        self.assertEqual(list(events), [anime_event])
+
+    def test_keeps_both_when_mapping_does_not_match_tracked_show(self):
+        anime_item = self._anime_item()
+        season_item = self._tv_show(media_id="1396", source=Sources.TMDB.value)
+        when = timezone.now() + datetime.timedelta(days=1)
+        anime_event = Event.objects.create(
+            item=anime_item,
+            content_number=1,
+            datetime=when,
+        )
+        season_event = Event.objects.create(
+            item=season_item,
+            content_number=1,
+            datetime=when,
+        )
+
+        with mock.patch(
+            "events.models.resolve_provider_series_id",
+            return_value=None,
+        ):
+            events = Event.objects.get_user_events(self.user, when.date(), when.date())
+
+        self.assertCountEqual(list(events), [anime_event, season_event])

src/events/tests/test_notification.py

@@ -1321,3 +1321,97 @@ def test_daily_digest_with_notification_urls(self, mock_send_notifications):
 
         # Verify the result message
         self.assertEqual(result, "Daily digest sent for 5 releases")
+
+
+class CrossBucketAnimeNotificationTests(TestCase):
+    """Release notifications must not duplicate a show across Anime and TV (#968)."""
+
+    def setUp(self):
+        self.credentials = {
+            "username": "notify-dedup-user",
+            "password": "12345",
+            "notification_urls": "https://example.com/notify",
+        }
+        self.user = get_user_model().objects.create_user(**self.credentials)
+
+        self.anime_item = Item.objects.create(
+            media_id="52991",
+            source=Sources.MAL.value,
+            media_type=MediaTypes.ANIME.value,
+            title="Test Anime",
+            image="http://example.com/anime.jpg",
+        )
+        self.tv_show_item = Item.objects.create(
+            media_id="1396",
+            source=Sources.TMDB.value,
+            media_type=MediaTypes.TV.value,
+            title="Test TV Show",
+            image="http://example.com/tv.jpg",
+        )
+        self.season1_item = Item.objects.create(
+            media_id="1396",
+            source=Sources.TMDB.value,
+            media_type=MediaTypes.SEASON.value,
+            title="Test TV Show - Season 1",
+            season_number=1,
+            image="http://example.com/tv.jpg",
+        )
+
+        Anime.objects.create(
+            item=self.anime_item,
+            user=self.user,
+            status=Status.IN_PROGRESS.value,
+        )
+        TV.objects.create(
+            item=self.tv_show_item,
+            user=self.user,
+            status=Status.IN_PROGRESS.value,
+        )
+
+        now = timezone.now()
+        ten_mins_ago = now - timedelta(minutes=10)
+        self.anime_event = Event.objects.create(
+            item=self.anime_item,
+            content_number=1,
+            datetime=ten_mins_ago,
+            notification_sent=False,
+        )
+        self.season1_event = Event.objects.create(
+            item=self.season1_item,
+            content_number=1,
+            datetime=ten_mins_ago,
+            notification_sent=False,
+        )
+
+    def test_get_user_releases_hides_anime_duplicate_of_tracked_tv_show(self):
+        users_with_notifications = (
+            get_user_model()
+            .objects.filter(~models.Q(notification_urls=""))
+            .prefetch_related("notification_excluded_items")
+        )
+        target_events = {
+            (
+                self.anime_event.item.id,
+                self.anime_event.content_number,
+            ): self.anime_event,
+            (
+                self.season1_event.item.id,
+                self.season1_event.content_number,
+            ): self.season1_event,
+        }
+
+        with patch(
+            "events.models.resolve_provider_series_id",
+            side_effect=lambda mal_id, provider: (
+                "1396" if provider == "tmdb" else None
+            ),
+        ):
+            user_releases = get_user_releases(users_with_notifications, target_events)
+
+        user_events = user_releases[self.user.id]
+        self.assertTrue(
+            any(event.id == self.season1_event.id for event in user_events),
+        )
+        self.assertFalse(
+            any(event.id == self.anime_event.id for event in user_events),
+        )