refactor trending models fetching to improve parameter filtering and logging

main.py

@@ -624,10 +624,15 @@ async def get_trending_models_with_summaries(
             and model.get("downloads", 0) >= min_downloads
         ]
 
-        # Sort by trending score and limit
+        # Sort by trending score
         trending_models = sorted(
             trending_models, key=lambda x: x.get("trendingScore", 0), reverse=True
-        )[:limit]
+        )
+
+        # Fetch up to 3x the limit (buffer for filtering) or all available if fewer
+        # This ensures we have enough models to filter from
+        fetch_limit = min(len(trending_models), limit * 3)
+        trending_models = trending_models[:fetch_limit]
 
         # Get model IDs
         model_ids = [model["modelId"] for model in trending_models]
@@ -640,27 +645,20 @@ async def get_trending_models_with_summaries(
         id_to_summary = dict(zip(summaries["ids"], summaries["documents"]))
         id_to_metadata = dict(zip(summaries["ids"], summaries["metadatas"]))
 
-        # Combine data
-        results = []
+        # Log parameters for debugging
+        print(
+            f"Filter params - min_param_count: {min_param_count}, max_param_count: {max_param_count}"
+        )
+
+        # Combine data - collect all results first
+        all_results = []
         for model in trending_models:
             if model["modelId"] in id_to_summary:
                 metadata = id_to_metadata.get(model["modelId"], {})
                 param_count = metadata.get("param_count", 0)
 
-                # Apply parameter count filters
-                using_param_filters = min_param_count > 0 or max_param_count is not None
-
-                # Skip if param_count is 0 and we're using param filters
-                if using_param_filters and param_count == 0:
-                    continue
-
-                # Skip if param_count is less than min_param_count
-                if min_param_count > 0 and param_count < min_param_count:
-                    continue
-
-                # Skip if param_count is greater than max_param_count
-                if max_param_count is not None and param_count > max_param_count:
-                    continue
+                # Log model parameter counts
+                print(f"Model: {model['modelId']}, param_count: {param_count}")
 
                 result = ModelQueryResult(
                     model_id=model["modelId"],
@@ -670,9 +668,50 @@ async def get_trending_models_with_summaries(
                     downloads=model.get("downloads", 0),
                     param_count=param_count,
                 )
-                results.append(result)
+                all_results.append(result)
 
-        return results
+        # Apply parameter filtering after collecting all results
+        filtered_results = all_results
+
+        # Check if any parameter filtering is being applied
+        using_param_filters = min_param_count > 0 or max_param_count is not None
+
+        # Only filter by params if we have specific parameter constraints
+        if using_param_filters:
+            filtered_results = []
+            for result in all_results:
+                should_include = True
+
+                # Always exclude models with param_count=0 when any parameter filtering is active
+                if result.param_count == 0:
+                    print(
+                        f"Filtering out {result.model_id} - has param_count=0 but parameter filtering is active"
+                    )
+                    should_include = False
+
+                # Apply min param filter if specified
+                elif min_param_count > 0 and result.param_count < min_param_count:
+                    print(
+                        f"Filtering out {result.model_id} - param_count {result.param_count} < min_param_count {min_param_count}"
+                    )
+                    should_include = False
+
+                # Apply max param filter if specified
+                elif (
+                    max_param_count is not None and result.param_count > max_param_count
+                ):
+                    print(
+                        f"Filtering out {result.model_id} - param_count {result.param_count} > max_param_count {max_param_count}"
+                    )
+                    should_include = False
+
+                if should_include:
+                    filtered_results.append(result)
+
+            print(f"After filtering: {len(filtered_results)} models remain")
+
+        # Finally limit to the requested number
+        return filtered_results[:limit]
 
     except Exception as e:
         logger.error(f"Error fetching trending models: {str(e)}")
@@ -689,7 +728,7 @@ async def get_trending_models(
     min_param_count: int = Query(
         default=0,
         ge=0,
-        description="Minimum parameter count (models with param_count=0 will be excluded if any param filter is used)",
+        description="Minimum parameter count (models with param_count=0 will be excluded if any parameter filter is used)",
     ),
     max_param_count: Optional[int] = Query(
         default=None,
@@ -703,6 +742,10 @@ async def get_trending_models(
     - When min_param_count > 0 or max_param_count is specified, models with param_count=0 are excluded
     - param_count=0 indicates missing/unknown parameter count in the dataset
     """
+    print(
+        f"Request for trending models with params: limit={limit}, min_likes={min_likes}, min_downloads={min_downloads}, min_param_count={min_param_count}, max_param_count={max_param_count}"
+    )
+
     results = await get_trending_models_with_summaries(
         limit=limit,
         min_likes=min_likes,
@@ -710,6 +753,8 @@ async def get_trending_models(
         min_param_count=min_param_count,
         max_param_count=max_param_count,
     )
+
+    print(f"Returning {len(results)} trending model results")
     return ModelQueryResponse(results=results)