Fix indexing

src/library.py

@@ -132,6 +132,8 @@ def check_whitelist_logic(
 def show_title_dict(user_list: dict):
     try:
         show_output_dict = {}
+        show_output_dict["locations"] = []
+        show_counter = 0  # Initialize a counter for the current show position
 
         show_output_keys = user_list.keys()
         show_output_keys = [dict(x) for x in list(show_output_keys)]
@@ -141,15 +143,19 @@ def show_title_dict(user_list: dict):
                 if provider_key.lower() == "title":
                     continue
                 if provider_key.lower() not in show_output_dict:
-                    show_output_dict[provider_key.lower()] = []
+                    show_output_dict[provider_key.lower()] = [None] * show_counter
                 if provider_key.lower() == "locations":
-                    for show_location in provider_value:
-                        show_output_dict[provider_key.lower()].append(show_location)
+                    show_output_dict[provider_key.lower()].append(provider_value)
                 else:
                     show_output_dict[provider_key.lower()].append(
                         provider_value.lower()
                     )
 
+            show_counter += 1
+            for key in show_output_dict:
+                if len(show_output_dict[key]) < show_counter:
+                    show_output_dict[key].append(None)
+
         return show_output_dict
     except Exception:
         logger("Generating show_output_dict failed, skipping", 1)
@@ -159,34 +165,54 @@ def show_title_dict(user_list: dict):
 def episode_title_dict(user_list: dict):
     try:
         episode_output_dict = {}
+        episode_output_dict["completed"] = []
+        episode_output_dict["time"] = []
+        episode_output_dict["locations"] = []
+        episode_counter = 0  # Initialize a counter for the current episode position
+
+        # Iterate through the shows, seasons, and episodes in user_list
         for show in user_list:
             for season in user_list[show]:
                 for episode in user_list[show][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
                         if episode_key != "status":
                             if episode_key.lower() not in episode_output_dict:
-                                episode_output_dict[episode_key.lower()] = []
-
-                        if "completed" not in episode_output_dict:
-                            episode_output_dict["completed"] = []
-                        if "time" not in episode_output_dict:
-                            episode_output_dict["time"] = []
+                                # Initialize the list with None values up to the current episode position
+                                episode_output_dict[episode_key.lower()] = [
+                                    None
+                                ] * episode_counter
 
+                        # If the key is "locations", append each location to the list
                         if episode_key == "locations":
-                            for episode_location in episode_value:
-                                episode_output_dict[episode_key.lower()].append(
-                                    episode_location
-                                )
+                            episode_output_dict[episode_key.lower()].append(
+                                episode_value
+                            )
+
+                        # If the key is "status", append the "completed" and "time" values
                         elif episode_key == "status":
                             episode_output_dict["completed"].append(
                                 episode_value["completed"]
                             )
                             episode_output_dict["time"].append(episode_value["time"])
+
+                        # For other keys, append the value to the list
                         else:
                             episode_output_dict[episode_key.lower()].append(
                                 episode_value.lower()
                             )
 
+                    # Increment the episode_counter
+                    episode_counter += 1
+
+                    # Extend the lists in episode_output_dict with None values to match the current episode_counter
+                    for key in episode_output_dict:
+                        if len(episode_output_dict[key]) < episode_counter:
+                            episode_output_dict[key].append(None)
+
         return episode_output_dict
     except Exception:
         logger("Generating episode_output_dict failed, skipping", 1)
@@ -196,26 +222,30 @@ def episode_title_dict(user_list: dict):
 def movies_title_dict(user_list: dict):
     try:
         movies_output_dict = {}
+        movies_output_dict["completed"] = []
+        movies_output_dict["time"] = []
+        movies_output_dict["locations"] = []
+        movie_counter = 0  # Initialize a counter for the current movie position
+
         for movie in user_list:
             for movie_key, movie_value in movie.items():
                 if movie_key != "status":
                     if movie_key.lower() not in movies_output_dict:
                         movies_output_dict[movie_key.lower()] = []
 
-                if "completed" not in movies_output_dict:
-                    movies_output_dict["completed"] = []
-                if "time" not in movies_output_dict:
-                    movies_output_dict["time"] = []
-
                 if movie_key == "locations":
-                    for movie_location in movie_value:
-                        movies_output_dict[movie_key.lower()].append(movie_location)
+                    movies_output_dict[movie_key.lower()].append(movie_value)
                 elif movie_key == "status":
                     movies_output_dict["completed"].append(movie_value["completed"])
                     movies_output_dict["time"].append(movie_value["time"])
                 else:
                     movies_output_dict[movie_key.lower()].append(movie_value.lower())
 
+            movie_counter += 1
+            for key in movies_output_dict:
+                if len(movies_output_dict[key]) < movie_counter:
+                    movies_output_dict[key].append(None)
+
         return movies_output_dict
     except Exception:
         logger("Generating movies_output_dict failed, skipping", 1)