Fix bounds for embedded lists in QP (#5202)

* remove ne matching and extra sorting

* use exists

* add to embedded list bounds tests

* skip nonfinites sort for lists

* handle NaN formatting

* debugging

* nonfinites tweaks

* selector fixes

* always use distinct for embedded lists

* fix selector

app/packages/core/src/components/Common/utils.tsx

@@ -68,13 +68,14 @@ export const getFormatter = (fieldType: string, timeZone: string, bounds) => {
         );
       }
 
-      return numeral(v).format(
+      const str = numeral(v).format(
         [INT_FIELD, FRAME_NUMBER_FIELD, FRAME_SUPPORT_FIELD].includes(fieldType)
           ? "0a"
           : bounds[1] - bounds[0] < 0.1
           ? "0.0000a"
           : "0.00a"
       );
+      return str === "NaN" ? v.toString() : str;
     },
   };
 };

app/packages/core/src/components/Filters/NumericFieldFilter/RangeSlider.tsx

@@ -35,9 +35,12 @@ const RangeSlider = ({
   const one = useRecoilValue(state.oneBound({ path, modal }));
   const timeZone = useRecoilValue(fos.timeZone);
   const hasBounds = useRecoilValue(state.hasBounds({ path, modal }));
+  const nonfinitesText = useRecoilValue(state.nonfinitesText({ path, modal }));
 
   if (!hasBounds) {
-    return <Box text="No results" />;
+    return (
+      <Box text={nonfinitesText ? `${nonfinitesText} present` : "No results"} />
+    );
   }
 
   const showSlider = hasBounds && !(excluded && defaultRange);

app/packages/core/src/components/Filters/NumericFieldFilter/state.ts

@@ -1,5 +1,5 @@
 import type { Nonfinite } from "@fiftyone/state";
-import { boundsAtom, nonfiniteAtom, rangeAtom } from "@fiftyone/state";
+import { boundsAtom, nonfiniteData, rangeAtom } from "@fiftyone/state";
 import { selectorFamily } from "recoil";
 
 export const FLOAT_NONFINITES: Nonfinite[] = ["inf", "ninf", "nan"];
@@ -25,14 +25,17 @@ export const hasDefaultRange = selectorFamily({
     },
 });
 
-export const hasNonfinites = selectorFamily({
-  key: "hasNonfinites",
+export const nonfinitesText = selectorFamily({
+  key: "nonfinitesText",
   get:
     (params: { path: string; modal: boolean }) =>
     ({ get }) => {
-      return FLOAT_NONFINITES.every((key) =>
-        get(nonfiniteAtom({ key, ...params }))
+      const data = get(nonfiniteData({ ...params, extended: false }));
+      const result = Object.entries(data).filter(
+        ([k, v]) => k !== "none" && Boolean(v)
       );
+
+      return result.length ? result.map(([key]) => key).join(", ") : null;
     },
 });
 

fiftyone/server/lightning.py

@@ -9,6 +9,7 @@
 from bson import ObjectId
 from dataclasses import asdict, dataclass
 from datetime import date, datetime
+import math
 import typing as t
 
 import asyncio
@@ -139,11 +140,11 @@ async def lightning_resolver(
         for item in sublist
     ]
 
-    filter = (
-        {f"{dataset.group_field}.name": input.slice}
-        if dataset.group_field and input.slice
-        else None
-    )
+    if dataset.group_field and input.slice:
+        filter = {f"{dataset.group_field}.name": input.slice}
+        dataset.group_slice = input.slice
+    else:
+        filter = {}
     result = await _do_async_pooled_queries(dataset, flattened, filter)
 
     results = []
@@ -316,13 +317,15 @@ async def _do_async_query(
     filter: t.Optional[t.Mapping[str, str]],
 ):
     if isinstance(query, DistinctQuery):
-        if query.has_list and not query.filters:
+        if query.has_list:
             return await _do_distinct_query(collection, query, filter)
 
         return await _do_distinct_pipeline(dataset, collection, query, filter)
 
     if filter:
-        query.insert(0, {"$match": filter})
+        for k, v in filter.items():
+            query.insert(0, {"$match": {k: v}})
+            query.insert(0, {"$sort": {k: 1}})
 
     return [i async for i in collection.aggregate(query)]
 
@@ -420,29 +423,19 @@ def _first(
 ):
     pipeline = [{"$sort": {path: sort}}]
 
-    if floats:
-        pipeline.extend(_handle_nonfinites(path, sort))
-
-    if sort:
-        pipeline.append({"$match": {path: {"$ne": None}}})
-
     matched_arrays = _match_arrays(dataset, path, is_frame_field)
     if matched_arrays:
         pipeline += matched_arrays
+    elif floats:
+        pipeline.extend(_handle_nonfinites(path, sort))
 
-    pipeline.append({"$limit": 1})
-
+    pipeline.extend([{"$match": {path: {"$exists": True}}}, {"$limit": 1}])
     unwound = _unwind(dataset, path, is_frame_field)
     if unwound:
         pipeline += unwound
         if floats:
             pipeline.extend(_handle_nonfinites(path, sort))
 
-        if sort:
-            pipeline.append({"$match": {path: {"$ne": None}}})
-
-        pipeline.append({"$sort": {path: sort}})
-
     return pipeline + [
         {
             "$group": {
@@ -513,8 +506,13 @@ def _match_arrays(dataset: fo.Dataset, path: str, is_frame_field: bool):
 def _parse_result(data):
     if data and data[0]:
         value = data[0]
-        if value.get("value", None) is not None:
-            return value["value"]
+        if "value" in value:
+            value = value["value"]
+            return (
+                value
+                if not isinstance(value, float) or math.isfinite(value)
+                else None
+            )
 
         return value.get("_id", None)
 

fiftyone/server/view.py

@@ -614,8 +614,9 @@ def _make_range_query(path: str, field: fof.Field, args):
 def _make_scalar_expression(f, args, field, list_field=None, is_label=False):
     expr = None
     if _is_support(field):
-        mn, mx = args["range"]
-        expr = (f[0] >= mn) & (f[1] <= mx)
+        if "range" in args:
+            mn, mx = args["range"]
+            expr = (f[0] >= mn) & (f[1] <= mx)
     elif isinstance(field, fof.ListField):
         if isinstance(list_field, str):
             return f.filter(
@@ -640,12 +641,14 @@ def _make_scalar_expression(f, args, field, list_field=None, is_label=False):
         if not true and not false:
             expr = (f != True) & (f != False)
     elif _is_datetime(field):
-        mn, mx = args["range"]
-        p = fou.timestamp_to_datetime
-        expr = (f >= p(mn)) & (f <= p(mx))
+        if "range" in args:
+            mn, mx = args["range"]
+            p = fou.timestamp_to_datetime
+            expr = (f >= p(mn)) & (f <= p(mx))
     elif isinstance(field, (fof.FloatField, fof.IntField)):
-        mn, mx = args["range"]
-        expr = (f >= mn) & (f <= mx)
+        if "range" in args:
+            mn, mx = args["range"]
+            expr = (f >= mn) & (f <= mx)
     else:
         values = args["values"]
         if not values: