- updating banned list of contents

- changing selection logic, following the logic that we have in production

Config_files/message_system_config.json

@@ -28,7 +28,8 @@
   "ollama_models": ["deepseek-r1:1.5b", "gemma3:4b", "deepseek-r1:7b", "gemma3:4b"],
   "claude_models": ["claude-3-5-haiku-latest"],
   "inference_models": ["google/gemma-3-27b-instruct/bf-16", "meta-llama/llama-3.2-11b-instruct/fp-16"],
-  "google_models": ["gemini-2.5-flash-lite", "gemini-2.5-flash", "gemini-2.0-flash"]
+  "google_models": ["gemini-2.5-flash-lite", "gemini-2.5-flash", "gemini-2.0-flash"],
+    "banned_contents": [373883, 358813, 301039, 377366]
 }
 
 

Messaging_system/LLMR.py

@@ -401,59 +401,119 @@ You are a helpful educational music content recommender. Your goal is to choose
     # ==========================================================================
     # Randomly select recommendations from top options
     # ==========================================================================
-    # main random selector ---
     def _get_recommendation_random(self):
         """
-        Randomly pick ONE item from the top-5 of each requested section.
+        Randomly pick ONE valid item from the top-5 of each requested section.
+        If the first random pick is missing/invalid, keep trying other candidates.
         Also remove the picked item from every section in recsys_json.
-        Returns: (content_id, content_info, updated_recsys_json, zero_tokens_dict)
+        Returns: (recommendation_dict, content_info, updated_recsys_json, zero_tokens_dict)
         """
-        # 1) Get user's recsys_result or fall back
+        import json, random
+
+        # 1) Get user's recsys_result or fall back to {}
         recsys_json = self._get_user_recommendation()
         try:
             recsys_data = json.loads(recsys_json) if recsys_json else {}
         except Exception:
             recsys_data = {}
 
-        # 2) Build candidate pool (top 5 per section)
         sections = self.Core.recsys_contents
-        candidates = self._collect_top_k(recsys_data, sections, k=5)
+
+        # 2) Primary candidate set
+        unique_candidates = self.build_unique_candidates(recsys_data, sections)
 
         # 3) Cold start or empty? -> use popular contents
-        if not candidates:
+        used_popular_fallback = False
+        if not unique_candidates:
             recsys_data = self._get_popular_fallback_json(k=5)
-            candidates = self._collect_top_k(recsys_data, sections, k=5)
+            unique_candidates = self.build_unique_candidates(recsys_data, sections)
+            used_popular_fallback = True
 
         # Still nothing? bail out
-        if not candidates:
+        if not unique_candidates:
             return None, None, None, None
 
-        # 4) Deduplicate by content_id, then pick randomly
-        seen = set()
-        unique_candidates = []
-        for rec in candidates:
-            cid = rec.get("content_id")
-            if cid not in seen:
-                seen.add(cid)
-                unique_candidates.append(rec)
+        # 4) Try candidates in random order until a valid one is found
+        idxs = list(range(len(unique_candidates)))
+        random.shuffle(idxs)
 
-        picked_rec = random.choice(unique_candidates)
-        picked_id = picked_rec["content_id"]
-        recommendation_dict = self._get_recommendation_info(picked_id, recsys_data)
+        picked_id, recommendation_dict, content_info = self.try_pick_from_candidates(idxs, unique_candidates,
+                                                                                     recsys_data)
 
-        # 5) Remove picked_id from ALL sections and store back
-        recsys_data = self._remove_selected_from_all(recsys_data, picked_id)
+        # 5) If nothing valid from primary set, and we haven't tried popular fallback yet, try it now
+        if picked_id is None and not used_popular_fallback:
+            recsys_data = self._get_popular_fallback_json(k=5)
+            unique_candidates = self.build_unique_candidates(recsys_data, sections)
+            if unique_candidates:
+                idxs = list(range(len(unique_candidates)))
+                random.shuffle(idxs)
+                picked_id, recommendation_dict, content_info = self.try_pick_from_candidates(idxs, unique_candidates,
+                                                                                             recsys_data)
+
+        # 6) If still nothing, bail out
+        if picked_id is None:
+            return None, None, None, None
 
+        # 7) Remove picked_id from ALL sections and store back
+        recsys_data = self._remove_selected_from_all(recsys_data, picked_id)
 
-        # 6) Track available ids if you still need it elsewhere
-        self.selected_content_ids = [r["content_id"] for r in unique_candidates]
+        # 8) Track available ids if you still need it elsewhere
+        self.selected_content_ids = [r["content_id"] for r in unique_candidates if r.get("content_id")]
 
-        # 7) Prepare return values
-        content_info = self._get_content_info(picked_id)
+        # 9) Prepare return values
         updated_json = json.dumps(recsys_data)
         zero_tokens = {"prompt_tokens": 0, "completion_tokens": 0}
 
         return recommendation_dict, content_info, updated_json, zero_tokens
+
+    # ====================================================================
+    def build_unique_candidates(self, src_data, sections):
+        # Build candidate pool (top 5 per section) and dedupe by content_id
+        cands = self._collect_top_k(src_data, sections, k=5)
+        seen, uniq = set(), []
+        for rec in cands or []:
+            cid = rec.get("content_id")
+            if cid and cid not in seen:
+                seen.add(cid)
+                uniq.append(rec)
+        return uniq
+
+    # ======================================================================
+    def try_pick_from_candidates(self, idxs, candidates, source_data):
+        """
+        Iterate candidates in random order, returning the first valid pick:
+        (picked_id, recommendation_dict, content_info) or (None, None, None)
+        """
+        banned_contents = set(self.Core.config_file.get("banned_contents", []))  # use set for faster lookup
+
+        for i in idxs:
+            rec = candidates[i]
+            picked_id = rec.get("content_id")
+            if not picked_id:
+                continue
+            # Skip if content is banned
+            if picked_id in banned_contents:
+                continue
+            try:
+                # Validate we can fetch both info payloads
+                content_info = self._get_content_info(picked_id)
+                if not content_info:
+                    # Treat falsy/empty as invalid and keep searching
+                    continue
+
+                recommendation_dict = self._get_recommendation_info(picked_id, source_data)
+                # If both succeed, we have a winner
+                return picked_id, recommendation_dict, content_info
+
+            except IndexError:
+                # Your reported failure mode; skip this candidate
+                continue
+            except KeyError:
+                continue
+            except Exception:
+                # Any unexpected data issue: skip and try the next
+                continue
+        return None, None, None
     #======================================================================
     # helpers used by the random path
     #======================================================================