Merge pull request #174 from luigi311/remove_season

Remove seasons from watch list

src/jellyfin_emby.py

@@ -184,7 +184,7 @@ class JellyfinEmby:
             response = self.query(query_string, "get")
 
             if response:
-                return f"{response['ServerName']}: {response['Version']}"
+                return f"{self.server_type} {response['ServerName']}: {response['Version']}"
             else:
                 return None
 
@@ -229,19 +229,23 @@ class JellyfinEmby:
                     f"/Users/{user_id}/Items"
                     + f"?ParentId={library_id}&Filters=IsPlayed&IncludeItemTypes=Movie&Recursive=True&Fields=ItemCounts,ProviderIds,MediaSources",
                     "get",
-                )
+                ).get("Items", [])
 
                 in_progress = self.query(
                     f"/Users/{user_id}/Items"
                     + f"?ParentId={library_id}&Filters=IsResumable&IncludeItemTypes=Movie&Recursive=True&Fields=ItemCounts,ProviderIds,MediaSources",
                     "get",
-                )
+                ).get("Items", [])
 
-                for movie in watched["Items"] + in_progress["Items"]:
+                for movie in watched + in_progress:
-                    if "MediaSources" in movie and movie["MediaSources"] != {}:
+                    # Skip if theres no user data which means the movie has not been watched
                     if "UserData" not in movie:
                         continue
 
+                    # Skip if theres no media tied to the movie
+                    if "MediaSources" not in movie or movie["MediaSources"] == {}:
+                        continue
+
                     # Skip if not watched or watched less than a minute
                     if (
                         movie["UserData"]["Played"] == True
@@ -272,20 +276,19 @@ class JellyfinEmby:
                     f"/Users/{user_id}/Items"
                     + f"?ParentId={library_id}&isPlaceHolder=false&IncludeItemTypes=Series&Recursive=True&Fields=ProviderIds,Path,RecursiveItemCount",
                     "get",
-                )
+                ).get("Items", [])
 
                 # Filter the list of shows to only include those that have been partially or fully watched
                 watched_shows_filtered = []
-                for show in watched_shows["Items"]:
+                for show in watched_shows:
-                    if not "UserData" in show:
+                    if "UserData" not in show:
                         continue
 
                     if "PlayedPercentage" in show["UserData"]:
                         if show["UserData"]["PlayedPercentage"] > 0:
                             watched_shows_filtered.append(show)
 
-                # Retrieve the seasons of each watched show
+                # Retrieve the watched/partially watched list of episodes of each watched show
-                seasons_watched = []
                 for show in watched_shows_filtered:
                     logger(
                         f"{self.server_type}: Adding {show.get('Name')} to {user_name} watched list",
@@ -298,116 +301,52 @@ class JellyfinEmby:
                         if "Path" in show
                         else tuple()
                     )
+                    show_display_name = (
+                        show_guids["title"]
+                        if show_guids["title"]
+                        else show_guids["locations"]
+                    )
+
                     show_guids = frozenset(show_guids.items())
-                    show_identifiers = {
-                        "show_guids": show_guids,
-                        "show_id": show["Id"],
-                    }
 
-                    seasons_watched.append(
+                    show_episodes = self.query(
-                        self.query(
+                        f"/Shows/{show['Id']}/Episodes"
-                            f"/Shows/{show['Id']}/Seasons"
+                        + f"?userId={user_id}&isPlaceHolder=false&Fields=ProviderIds,MediaSources",
-                            + f"?userId={user_id}&isPlaceHolder=false&Fields=ProviderIds,RecursiveItemCount",
                         "get",
-                            identifiers=frozenset(show_identifiers.items()),
+                    ).get("Items", [])
-                        )
-                    )
-
-                # Filter the list of seasons to only include those that have been partially or fully watched
-                seasons_watched_filtered = []
-                for seasons in seasons_watched:
-                    seasons_watched_filtered_dict = {}
-                    seasons_watched_filtered_dict["Identifiers"] = seasons[
-                        "Identifiers"
-                    ]
-                    seasons_watched_filtered_dict["Items"] = []
-                    for season in seasons["Items"]:
-                        if "PlayedPercentage" in season["UserData"]:
-                            if season["UserData"]["PlayedPercentage"] > 0:
-                                seasons_watched_filtered_dict["Items"].append(season)
-
-                    if seasons_watched_filtered_dict["Items"]:
-                        seasons_watched_filtered.append(seasons_watched_filtered_dict)
-
-                # Create a list of tasks to retrieve the episodes of each watched season
-                watched_episodes = []
-                for seasons in seasons_watched_filtered:
-                    if len(seasons["Items"]) > 0:
-                        for season in seasons["Items"]:
-                            if "IndexNumber" not in season:
-                                logger(
-                                    f"Jellyfin: Skipping show {season.get('SeriesName')} season {season.get('Name')} as it has no index number",
-                                    3,
-                                )
 
+                    # Iterate through the episodes
+                    # Create a list to store the episodes
+                    mark_episodes_list = []
+                    for episode in show_episodes:
+                        if "UserData" not in episode:
                             continue
-                            season_identifiers = dict(seasons["Identifiers"])
-                            season_identifiers["season_index"] = season["IndexNumber"]
-                            watched_task = self.query(
-                                f"/Shows/{season_identifiers['show_id']}/Episodes"
-                                + f"?seasonId={season['Id']}&userId={user_id}&isPlaceHolder=false&Filters=IsPlayed&Fields=ProviderIds,MediaSources",
-                                "get",
-                                identifiers=frozenset(season_identifiers.items()),
-                            )
 
-                            in_progress_task = self.query(
-                                f"/Shows/{season_identifiers['show_id']}/Episodes"
-                                + f"?seasonId={season['Id']}&userId={user_id}&isPlaceHolder=false&Filters=IsResumable&Fields=ProviderIds,MediaSources",
-                                "get",
-                                identifiers=frozenset(season_identifiers.items()),
-                            )
-                            watched_episodes.append(watched_task)
-                            watched_episodes.append(in_progress_task)
-
-                # Iterate through the watched episodes
-                for episodes in watched_episodes:
-                    # If the season has any watched episodes
-                    if len(episodes["Items"]) > 0:
-                        # Create a dictionary for the season with its identifier and episodes
-                        season_dict = {}
-                        season_dict["Identifiers"] = dict(episodes["Identifiers"])
-                        season_dict["Episodes"] = []
-                        for episode in episodes["Items"]:
                         if (
-                                "MediaSources" in episode
+                            "MediaSources" not in episode
-                                and episode["MediaSources"] != {}
+                            or episode["MediaSources"] == {}
                         ):
+                            continue
+
                         # If watched or watched more than a minute
                         if (
                             episode["UserData"]["Played"] == True
-                                    or episode["UserData"]["PlaybackPositionTicks"]
+                            or episode["UserData"]["PlaybackPositionTicks"] > 600000000
-                                    > 600000000
                         ):
-                                    episode_dict = get_guids(self.server_type, episode)
+                            episode_guids = get_guids(self.server_type, episode)
-                                    # Add the episode dictionary to the season's list of episodes
+                            mark_episodes_list.append(episode_guids)
-                                    season_dict["Episodes"].append(episode_dict)
 
-                        # Add the season dictionary to the show's list of seasons
+                    if mark_episodes_list:
-                        if (
+                        # Add the show dictionary to the user's watched list
-                            season_dict["Identifiers"]["show_guids"]
+                        if show_guids not in user_watched[user_name][library_title]:
-                            not in user_watched[user_name][library_title]
+                            user_watched[user_name][library_title][show_guids] = []
-                        ):
-                            user_watched[user_name][library_title][
-                                season_dict["Identifiers"]["show_guids"]
-                            ] = {}
-
-                        if (
-                            season_dict["Identifiers"]["season_index"]
-                            not in user_watched[user_name][library_title][
-                                season_dict["Identifiers"]["show_guids"]
-                            ]
-                        ):
-                            user_watched[user_name][library_title][
-                                season_dict["Identifiers"]["show_guids"]
-                            ][season_dict["Identifiers"]["season_index"]] = []
 
                         user_watched[user_name][library_title][
-                            season_dict["Identifiers"]["show_guids"]
+                            show_guids
-                        ][season_dict["Identifiers"]["season_index"]] = season_dict[
+                        ] = mark_episodes_list
-                            "Episodes"
+                        for episode in mark_episodes_list:
-                        ]
                             logger(
-                            f"{self.server_type}: Added {season_dict['Episodes']} to {user_name} {season_dict['Identifiers']['show_guids']} watched list",
+                                f"{self.server_type}: Added {episode} to {user_name} {show_display_name} watched list",
                                 1,
                             )
 
@@ -674,7 +613,7 @@ class JellyfinEmby:
                                 is not None
                             ):
                                 show_found = True
-                                for shows, seasons in videos.items():
+                                for shows, episodes in videos.items():
                                     show = {k: v for k, v in shows}
                                     if (
                                         contains_nested(
@@ -683,8 +622,7 @@ class JellyfinEmby:
                                         )
                                         is not None
                                     ):
-                                        for season in seasons.values():
+                                        for episode in episodes:
-                                            for episode in season:
                                             episode_videos.append(episode)
 
                                         break
@@ -702,13 +640,12 @@ class JellyfinEmby:
                                         ]
                                     ):
                                         show_found = True
-                                        for show, seasons in videos.items():
+                                        for show, episodes in videos.items():
                                             show = {k: v for k, v in show}
                                             if show_provider_id.lower() in show.get(
                                                 show_provider_source.lower(), []
                                             ):
-                                                for season in seasons.values():
+                                                for episode in episodes:
-                                                    for episode in season:
                                                     episode_videos.append(episode)
 
                                                 break

src/library.py

@@ -169,27 +169,19 @@ def episode_title_dict(user_list: dict):
         episode_output_dict["time"] = []
         episode_output_dict["locations"] = []
         episode_output_dict["show"] = []
-        episode_output_dict["season"] = []
         episode_counter = 0  # Initialize a counter for the current episode position
 
-        # Iterate through the shows, seasons, and episodes in user_list
+        # Iterate through the shows and episodes in user_list
         for show in user_list:
-            for season in user_list[show]:
+
-                for episode in user_list[show][season]:
+            for episode in user_list[show]:
                 # Add the show title to the episode_output_dict if it doesn't exist
                 if "show" not in episode_output_dict:
                     episode_output_dict["show"] = [None] * episode_counter
 
-                    # Add the season number to the episode_output_dict if it doesn't exist
-                    if "season" not in episode_output_dict:
-                        episode_output_dict["season"] = [None] * episode_counter
-
                 # Add the show title to the episode_output_dict
                 episode_output_dict["show"].append(dict(show))
 
-                    # Add the season number to the episode_output_dict
-                    episode_output_dict["season"].append(season)
-
                 # Iterate through the keys and values in each episode
                 for episode_key, episode_value in episode.items():
                     # If the key is not "status", add the key to episode_output_dict if it doesn't exist
@@ -202,9 +194,7 @@ def episode_title_dict(user_list: dict):
 
                     # If the key is "locations", append each location to the list
                     if episode_key == "locations":
-                            episode_output_dict[episode_key.lower()].append(
+                        episode_output_dict[episode_key.lower()].append(episode_value)
-                                episode_value
-                            )
 
                     # If the key is "status", append the "completed" and "time" values
                     elif episode_key == "status":

src/plex.py

@@ -117,11 +117,9 @@ def get_user_library_watched_show(show, process_episodes, threads=None):
             episode_guids_args, threads=threads
         )
 
-        episode_guids = {}
+        episode_guids = []
         for index, episode in enumerate(process_episodes):
-            if episode.parentIndex not in episode_guids:
+            episode_guids.append(episode_guids_results[index])
-                episode_guids[episode.parentIndex] = []
-            episode_guids[episode.parentIndex].append(episode_guids_results[index])
 
         return show_guids, episode_guids
     except Exception:
@@ -220,7 +218,7 @@ def find_video(plex_search, video_ids, videos=None):
                 ):
                     episode_videos = []
                     if videos:
-                        for show, seasons in videos.items():
+                        for show, episodes in videos.items():
                             show = {k: v for k, v in show}
                             if (
                                 contains_nested(
@@ -228,8 +226,7 @@ def find_video(plex_search, video_ids, videos=None):
                                 )
                                 is not None
                             ):
-                                for season in seasons.values():
+                                for episode in episodes:
-                                    for episode in season:
                                     episode_videos.append(episode)
 
                     return True, episode_videos
@@ -243,12 +240,11 @@ def find_video(plex_search, video_ids, videos=None):
                     if guid_id in video_ids[guid_source]:
                         episode_videos = []
                         if videos:
-                            for show, seasons in videos.items():
+                            for show, episodes in videos.items():
                                 show = {k: v for k, v in show}
                                 if guid_source in show.keys():
                                     if guid_id == show[guid_source]:
-                                        for season in seasons.values():
+                                        for episode in episodes:
-                                            for episode in season:
                                             episode_videos.append(episode)
 
                         return True, episode_videos
@@ -456,7 +452,7 @@ class Plex:
             raise Exception(e)
 
     def info(self) -> str:
-        return f"{self.plex.friendlyName}: {self.plex.version}"
+        return f"Plex {self.plex.friendlyName}: {self.plex.version}"
 
     def get_users(self):
         try:

src/watched.py

@@ -122,17 +122,14 @@ def cleanup_watched(
                 for show_key_1 in watched_list_1[user_1][library_1].keys():
                     show_key_dict = dict(show_key_1)
 
-                    for season in watched_list_1[user_1][library_1][show_key_1]:
                     # Filter the episode_watched_list_2_keys_dict dictionary to handle cases
                     # where episode location names are not unique such as S01E01.mkv
                     filtered_episode_watched_list_2_keys_dict = (
                         filter_episode_watched_list_2_keys_dict(
-                                episode_watched_list_2_keys_dict, show_key_dict, season
+                            episode_watched_list_2_keys_dict, show_key_dict
                         )
                     )
-                        for episode in watched_list_1[user_1][library_1][show_key_1][
+                    for episode in watched_list_1[user_1][library_1][show_key_1]:
-                            season
-                        ]:
                         episode_index = get_episode_index_in_dict(
                             episode, filtered_episode_watched_list_2_keys_dict
                         )
@@ -145,30 +142,7 @@ def cleanup_watched(
                             ):
                                 modified_watched_list_1[user_1][library_1][
                                     show_key_1
-                                    ][season].remove(episode)
+                                ].remove(episode)
-
-                        # Remove empty seasons
-                        if (
-                            len(
-                                modified_watched_list_1[user_1][library_1][show_key_1][
-                                    season
-                                ]
-                            )
-                            == 0
-                        ):
-                            if (
-                                season
-                                in modified_watched_list_1[user_1][library_1][
-                                    show_key_1
-                                ]
-                            ):
-                                logger(
-                                    f"Removing {season} from {show_key_dict['title']} because it is empty",
-                                    3,
-                                )
-                                del modified_watched_list_1[user_1][library_1][
-                                    show_key_1
-                                ][season]
 
                     # Remove empty shows
                     if len(modified_watched_list_1[user_1][library_1][show_key_1]) == 0:
@@ -231,27 +205,18 @@ def get_movie_index_in_dict(movie, movies_watched_list_2_keys_dict):
 
 
 def filter_episode_watched_list_2_keys_dict(
-    episode_watched_list_2_keys_dict, show_key_dict, season
+    episode_watched_list_2_keys_dict, show_key_dict
 ):
-    # If the episode_watched_list_2_keys_dict dictionary is empty, missing season or show then return an empty dictionary
+    # If the episode_watched_list_2_keys_dict dictionary is empty, missing show then return an empty dictionary
     if (
         len(episode_watched_list_2_keys_dict) == 0
-        or "season" not in episode_watched_list_2_keys_dict.keys()
         or "show" not in episode_watched_list_2_keys_dict.keys()
     ):
         return {}
 
-    # Filter the episode_watched_list_2_keys_dict dictionary to only include values for the correct show and season
+    # Filter the episode_watched_list_2_keys_dict dictionary to only include values for the correct show
     filtered_episode_watched_list_2_keys_dict = {}
     show_indecies = []
-    season_indecies = []
-
-    # Iterate through episode_watched_list_2_keys_dict["season"] and find the indecies that match season
-    for season_index, season_value in enumerate(
-        episode_watched_list_2_keys_dict.get("season")
-    ):
-        if season_value == season:
-            season_indecies.append(season_index)
 
     # Iterate through episode_watched_list_2_keys_dict["show"] and find the indecies that match show_key_dict
     for show_index, show_value in enumerate(episode_watched_list_2_keys_dict["show"]):
@@ -273,14 +238,14 @@ def filter_episode_watched_list_2_keys_dict(
                         show_indecies.append(show_index)
                         break
 
-    # Find the intersection of the show_indecies and season_indecies lists
+    # lists
-    indecies = list(set(show_indecies) & set(season_indecies))
+    indecies = list(set(show_indecies))
 
-    # If there are no indecies that match the show and season, return an empty dictionary
+    # If there are no indecies that match the show, return an empty dictionary
     if len(indecies) == 0:
         return {}
 
-    # Create a copy of the dictionary with indecies that match the show and season and none that don't
+    # Create a copy of the dictionary with indecies that match the show and none that don't
     for key, value in episode_watched_list_2_keys_dict.items():
         if key not in filtered_episode_watched_list_2_keys_dict:
             filtered_episode_watched_list_2_keys_dict[key] = []

test/test_library.py

@@ -42,8 +42,7 @@ show_list = {
             ("tvdb", "392256"),
             ("title", "The Last of Us"),
         }
-    ): {
+    ): [
-        "Season 1": [
         {
             "imdb": "tt11957006",
             "tmdb": "2181581",
@@ -57,7 +56,6 @@ show_list = {
         }
     ]
 }
-}
 movie_list = [
     {
         "title": "Coco",
@@ -83,7 +81,6 @@ episode_titles = {
     "tvdb": ["8444132"],
     "completed": [True],
     "time": [0],
-    "season": ["Season 1"],
     "show": [
         {
             "imdb": "tt3581920",

test/test_watched.py

@@ -24,8 +24,7 @@ tv_shows_watched_list_1 = {
             ("tvdb", "78804"),
             ("title", "Doctor Who (2005)"),
         }
-    ): {
+    ): [
-        1: [
         {
             "imdb": "tt0563001",
             "tmdb": "968589",
@@ -50,8 +49,7 @@ tv_shows_watched_list_1 = {
             "locations": ("S01E05.mkv",),
             "status": {"completed": True, "time": 0},
         },
-        ]
+    ],
-    },
     frozenset(
         {
             ("title", "Monarch: Legacy of Monsters"),
@@ -63,8 +61,7 @@ tv_shows_watched_list_1 = {
                 ("Monarch - Legacy of Monsters {tvdb-422598} {imdb-tt17220216}",),
             ),
         }
-    ): {
+    ): [
-        1: [
         {
             "imdb": "tt21255044",
             "tmdb": "4661246",
@@ -89,8 +86,7 @@ tv_shows_watched_list_1 = {
             "locations": ("S01E05.mkv",),
             "status": {"completed": True, "time": 0},
         },
-        ]
+    ],
-    },
     frozenset(
         {
             ("tmdb", "125928"),
@@ -102,8 +98,7 @@ tv_shows_watched_list_1 = {
             ),
             ("title", "My Adventures with Superman"),
         }
-    ): {
+    ): [
-        1: [
         {
             "imdb": "tt15699926",
             "tmdb": "3070048",
@@ -128,8 +123,7 @@ tv_shows_watched_list_1 = {
             "locations": ("S01E03.mkv",),
             "status": {"completed": True, "time": 0},
         },
-        ]
+    ],
-    },
 }
 
 
@@ -143,8 +137,7 @@ tv_shows_watched_list_2 = {
             ("tvdb", "78804"),
             ("tvrage", "3332"),
         }
-    ): {
+    ): [
-        1: [
         {
             "tvdb": "295294",
             "imdb": "tt0562992",
@@ -166,8 +159,7 @@ tv_shows_watched_list_2 = {
             "locations": ("S01E05.mkv",),
             "status": {"completed": True, "time": 0},
         },
-        ]
+    ],
-    },
     frozenset(
         {
             ("title", "Monarch: Legacy of Monsters"),
@@ -179,8 +171,7 @@ tv_shows_watched_list_2 = {
                 ("Monarch - Legacy of Monsters {tvdb-422598} {imdb-tt17220216}",),
             ),
         }
-    ): {
+    ): [
-        1: [
         {
             "tvdb": "9959300",
             "imdb": "tt20412166",
@@ -202,8 +193,7 @@ tv_shows_watched_list_2 = {
             "locations": ("S01E05.mkv",),
             "status": {"completed": True, "time": 0},
         },
-        ]
+    ],
-    },
     frozenset(
         {
             ("tmdb", "125928"),
@@ -215,8 +205,7 @@ tv_shows_watched_list_2 = {
             ),
             ("title", "My Adventures with Superman"),
         }
-    ): {
+    ): [
-        1: [
         {
             "tvdb": "8438181",
             "imdb": "tt15699926",
@@ -238,8 +227,7 @@ tv_shows_watched_list_2 = {
             "locations": ("S01E03.mkv",),
             "status": {"completed": True, "time": 0},
         },
-        ]
+    ],
-    },
 }
 
 expected_tv_show_watched_list_1 = {
@@ -251,8 +239,7 @@ expected_tv_show_watched_list_1 = {
             ("tvdb", "78804"),
             ("title", "Doctor Who (2005)"),
         }
-    ): {
+    ): [
-        1: [
         {
             "imdb": "tt0563001",
             "tmdb": "968589",
@@ -269,8 +256,7 @@ expected_tv_show_watched_list_1 = {
             "locations": ("S01E04.mkv",),
             "status": {"completed": False, "time": 240000},
         },
-        ]
+    ],
-    },
     frozenset(
         {
             ("title", "Monarch: Legacy of Monsters"),
@@ -282,8 +268,7 @@ expected_tv_show_watched_list_1 = {
                 ("Monarch - Legacy of Monsters {tvdb-422598} {imdb-tt17220216}",),
             ),
         }
-    ): {
+    ): [
-        1: [
         {
             "imdb": "tt21255044",
             "tmdb": "4661246",
@@ -300,8 +285,7 @@ expected_tv_show_watched_list_1 = {
             "locations": ("S01E04.mkv",),
             "status": {"completed": False, "time": 240000},
         },
-        ]
+    ],
-    },
 }
 
 expected_tv_show_watched_list_2 = {
@@ -314,8 +298,7 @@ expected_tv_show_watched_list_2 = {
             ("tvdb", "78804"),
             ("tvrage", "3332"),
         }
-    ): {
+    ): [
-        1: [
         {
             "tvdb": "295294",
             "imdb": "tt0562992",
@@ -330,8 +313,7 @@ expected_tv_show_watched_list_2 = {
             "locations": ("S01E02.mkv",),
             "status": {"completed": False, "time": 300670},
         },
-        ]
+    ],
-    },
     frozenset(
         {
             ("title", "Monarch: Legacy of Monsters"),
@@ -343,8 +325,7 @@ expected_tv_show_watched_list_2 = {
                 ("Monarch - Legacy of Monsters {tvdb-422598} {imdb-tt17220216}",),
             ),
         }
-    ): {
+    ): [
-        1: [
         {
             "tvdb": "9959300",
             "imdb": "tt20412166",
@@ -359,8 +340,7 @@ expected_tv_show_watched_list_2 = {
             "locations": ("S01E02.mkv",),
             "status": {"completed": False, "time": 300741},
         },
-        ]
+    ],
-    },
 }
 
 movies_watched_list_1 = [
@@ -463,21 +443,17 @@ tv_shows_2_watched_list_1 = {
             ("locations", ("Criminal Minds",)),
             ("tmdb", "4057"),
         }
-    ): {
+    ): [
-        "Season 1": [
         {
             "imdb": "tt0550489",
             "tmdb": "282843",
             "tvdb": "176357",
             "title": "Extreme Aggressor",
-                "locations": (
+            "locations": ("Criminal Minds S01E01 Extreme Aggressor WEBDL-720p.mkv",),
-                    "Criminal Minds S01E01 Extreme Aggressor WEBDL-720p.mkv",
-                ),
             "status": {"completed": True, "time": 0},
         },
     ]
 }
-}
 
 
 def test_simple_cleanup_watched():
@@ -610,8 +586,7 @@ def test_combine_watched_dicts():
                             ("locations", ("11.22.63",)),
                             ("imdb", "tt2879552"),
                         }
-                    ): {
+                    ): [
-                        "Season 1": [
                         {
                             "imdb": "tt4460418",
                             "title": "The Rabbit Hole",
@@ -623,7 +598,6 @@ def test_combine_watched_dicts():
                     ]
                 }
             }
-            }
         },
         {"test3": {"Subbed Anime": {}}},
     ]
@@ -664,8 +638,7 @@ def test_combine_watched_dicts():
                         ("locations", ("11.22.63",)),
                         ("imdb", "tt2879552"),
                     }
-                ): {
+                ): [
-                    "Season 1": [
                     {
                         "imdb": "tt4460418",
                         "title": "The Rabbit Hole",
@@ -675,7 +648,6 @@ def test_combine_watched_dicts():
                         "status": {"completed": True, "time": 0},
                     }
                 ]
-                }
             },
             "Subbed Anime": {},
         }

test/validate_ci_marklog.py

@@ -73,38 +73,47 @@ def check_marklog(lines, expected_values):
 
 def main():
     args = parse_args()
-    expected = {
+    expected_jellyfin = [
-        "dry": [
-            # Jellyfin -> Plex
         "jellyplex_watched/Movies/Five Nights at Freddy's",
         "jellyplex_watched/Movies/The Hunger Games: The Ballad of Songbirds & Snakes/301215",
         "jellyplex_watched/TV Shows/Doctor Who (2005)/Rose",
         "jellyplex_watched/TV Shows/Doctor Who (2005)/The End of the World/300670",
         "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Aftermath",
         "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Departure/300741",
-            # Plex -> Jellyfin
+        "jellyplex_watched/Movies/The Family Plan",
+        "jellyplex_watched/Movies/Five Nights at Freddy's",
+        "jellyplex_watched/Movies/The Hunger Games: The Ballad of Songbirds & Snakes/5",
+        "jellyplex_watched/TV Shows/Doctor Who (2005)/Rose",
+        "jellyplex_watched/TV Shows/Doctor Who (2005)/The End of the World/5",
+        "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Departure/5",
+        "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/The Way Out",
+    ]
+    expected_emby = [
+        "jellyplex_watched/Movies/Tears of Steel",
+            "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Aftermath",
+            "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Parallels and Interiors/240429",
+            "JellyUser/Movies/Tears of Steel",
+            "JellyUser/Shows/Monarch: Legacy of Monsters/Parallels and Interiors/4",
+    ]
+    expected_plex = [
         "JellyUser/Movies/Big Buck Bunny",
             "JellyUser/Movies/Killers of the Flower Moon/4",
             "JellyUser/Shows/Doctor Who/The Unquiet Dead",
             "JellyUser/Shows/Doctor Who/Aliens of London (1)/4",
             "JellyUser/Shows/Monarch: Legacy of Monsters/Secrets and Lies",
             "JellyUser/Shows/Monarch: Legacy of Monsters/Parallels and Interiors/4",
-            # Emby -> Plex
-            "jellyplex_watched/Movies/Tears of Steel",
-            "jellyplex_watched/TV shows/Doctor Who (2005)/World War Three (2)",
-            "jellyplex_watched/TV shows/Monarch: Legacy of Monsters/Parallels and Interiors/240429",
-            # Plex -> Emby
             "jellyplex_watched/Movies/Big Buck Bunny",
             "jellyplex_watched/Movies/The Family Plan",
             "jellyplex_watched/Movies/Killers of the Flower Moon/4",
-            # Emby -> Jellyfin
+            "jellyplex_watched/TV Shows/Doctor Who (2005)/The Unquiet Dead",
-            "JellyUser/Movies/Tears of Steel",
+            "jellyplex_watched/TV Shows/Doctor Who (2005)/Aliens of London (1)/4",
-            # Jellyfin -> Emby
+            "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Secrets and Lies",
-            "jellyplex_watched/Movies/The Family Plan",
+            "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/The Way Out",
-            "jellyplex_watched/Movies/Five Nights at Freddy's",
+    ]
-            "jellyplex_watched/Movies/The Hunger Games: The Ballad of Songbirds & Snakes/5",
+
-        ],
+    expected_dry = expected_emby + expected_plex + expected_jellyfin
-        "write": [
+
+    expected_write = [
         "jellyplex_watched/Movies/Five Nights at Freddy's",
         "jellyplex_watched/Movies/The Hunger Games: The Ballad of Songbirds & Snakes/301215",
         "jellyplex_watched/TV Shows/Doctor Who (2005)/Rose",
@@ -118,61 +127,36 @@ def main():
         "JellyUser/Shows/Monarch: Legacy of Monsters/Secrets and Lies",
         "JellyUser/Shows/Monarch: Legacy of Monsters/Parallels and Interiors/4",
         "jellyplex_watched/Movies/Tears of Steel",
-            "jellyplex_watched/TV shows/Doctor Who (2005)/World War Three (2)",
+        "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Parallels and Interiors/240429",
-            "jellyplex_watched/TV shows/Monarch: Legacy of Monsters/Parallels and Interiors/240429",
         "jellyplex_watched/Movies/Big Buck Bunny",
         "jellyplex_watched/Movies/The Family Plan",
         "jellyplex_watched/Movies/Five Nights at Freddy's",
         "jellyplex_watched/Movies/The Hunger Games: The Ballad of Songbirds & Snakes/5",
         "jellyplex_watched/Movies/Killers of the Flower Moon/4",
-            "JellyUser/Movies/Tears of Steel",
-            "JellyUser/Shows/Monarch: Legacy of Monsters/Parallels and Interiors/4",
-            "jellyplex_watched/TV shows/Doctor Who (2005)/World War Three (2)",
-            "jellyplex_watched/TV shows/Monarch: Legacy of Monsters/Parallels and Interiors/240429",
-        ],
-        "plex": [
-            "JellyUser/Movies/Big Buck Bunny",
-            "JellyUser/Movies/Killers of the Flower Moon/4",
-            "JellyUser/Shows/Doctor Who/The Unquiet Dead",
-            "JellyUser/Shows/Doctor Who/Aliens of London (1)/4",
-            "JellyUser/Shows/Monarch: Legacy of Monsters/Secrets and Lies",
-            "JellyUser/Shows/Monarch: Legacy of Monsters/Parallels and Interiors/4",
-            "jellyplex_watched/Movies/Big Buck Bunny",
-            "jellyplex_watched/Movies/The Family Plan",
-            "jellyplex_watched/Movies/Killers of the Flower Moon/4",
-        ],
-        "jellyfin": [
-            "jellyplex_watched/Movies/Five Nights at Freddy's",
-            "jellyplex_watched/Movies/The Hunger Games: The Ballad of Songbirds & Snakes/301215",
         "jellyplex_watched/TV Shows/Doctor Who (2005)/Rose",
-            "jellyplex_watched/TV Shows/Doctor Who (2005)/The End of the World/300670",
+        "jellyplex_watched/TV Shows/Doctor Who (2005)/The End of the World/5",
-            "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Aftermath",
+        "jellyplex_watched/TV Shows/Doctor Who (2005)/The Unquiet Dead",
-            "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Departure/300741",
+        "jellyplex_watched/TV Shows/Doctor Who (2005)/Aliens of London (1)/4",
-            "jellyplex_watched/Movies/The Family Plan",
+        "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Departure/5",
-            "jellyplex_watched/Movies/Five Nights at Freddy's",
+        "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/Secrets and Lies",
-            "jellyplex_watched/Movies/The Hunger Games: The Ballad of Songbirds & Snakes/5",
+        "jellyplex_watched/TV Shows/Monarch: Legacy of Monsters/The Way Out",
-        ],
-        "emby": [
-            "jellyplex_watched/Movies/Tears of Steel",
-            "jellyplex_watched/TV shows/Doctor Who (2005)/World War Three (2)",
-            "jellyplex_watched/TV shows/Monarch: Legacy of Monsters/Parallels and Interiors/240429",
         "JellyUser/Movies/Tears of Steel",
-        ],
+        "JellyUser/Shows/Monarch: Legacy of Monsters/Parallels and Interiors/4",
-    }
+    ]
 
     # Expected values for the mark.log file, dry-run is slightly different than write-run
     # due to some of the items being copied over from one server to another and now being there
     # for the next server run.
     if args.dry:
-        expected_values = expected["dry"]
+        expected_values = expected_dry
     elif args.write:
-        expected_values = expected["write"]
+        expected_values = expected_write
     elif args.plex:
-        expected_values = expected["plex"]
+        expected_values = expected_plex
     elif args.jellyfin:
-        expected_values = expected["jellyfin"]
+        expected_values = expected_jellyfin
     elif args.emby:
-        expected_values = expected["emby"]
+        expected_values = expected_emby
     else:
         print("No server specified")
         exit(1)