Update grpc, separate Time and Numeric decay

Author: trengrj

weaviate/collections/classes/grpc.py

@@ -245,7 +245,7 @@ class Rerank(_WeaviateInput):
 
 
 @dataclass
-class _DecayFunction:
+class _TimeDecayFunction:
     property: str
     origin: str
     scale: str
@@ -254,6 +254,16 @@ class _DecayFunction:
     decay_value: Optional[float] = None
 
 
+@dataclass
+class _NumericDecayFunction:
+    property: str
+    origin: float
+    scale: float
+    offset: Optional[float] = None
+    curve: Optional[str] = None
+    decay_value: Optional[float] = None
+
+
 @dataclass
 class _PropertyValueFunction:
     property: str
@@ -263,7 +273,8 @@ class _PropertyValueFunction:
 @dataclass
 class _BoostCondition:
     filter: Optional[Any] = None  # FilterReturn
-    decay: Optional[_DecayFunction] = None
+    time_decay: Optional[_TimeDecayFunction] = None
+    numeric_decay: Optional[_NumericDecayFunction] = None
     property_value: Optional[_PropertyValueFunction] = None
     weight: Optional[float] = None
 
@@ -338,37 +349,36 @@ def filter(
         return _Boost(conditions=[_BoostCondition(filter=filter)], weight=weight, depth=depth)
 
     @staticmethod
-    def decay(
+    def time_decay(
         property: str,
         *,
-        origin: Optional[Union[str, int, float, datetime]] = None,
-        scale: Union[str, int, float, timedelta],
-        offset: Optional[Union[str, int, float, timedelta]] = None,
+        origin: Optional[Union[str, datetime]] = None,
+        scale: Union[str, timedelta],
+        offset: Optional[Union[str, timedelta]] = None,
         curve: Optional[Union[_BoostCurve, str]] = None,
         decay_value: Optional[float] = None,
         weight: Optional[float] = None,
         depth: Optional[int] = None,
     ) -> _Boost:
-        """Apply distance-based decay scoring from an origin value.
+        """Apply time-based decay scoring from an origin date.
 
         Args:
-            property: The property name to compute distance from.
-            origin: The origin point. Use "now" for current time, a datetime for a specific time,
-                or a numeric value for number properties. Defaults to "now" for date properties.
-            scale: Distance from origin where score equals decay_value. Use timedelta for date
-                properties (e.g. timedelta(days=7)) or a number for numeric properties. String
-                shorthands like "7d", "24h" are also accepted.
+            property: The date property name to compute distance from.
+            origin: The origin point. Use "now" for current time or a datetime for a specific time.
+                Defaults to "now".
+            scale: Distance from origin where score equals decay_value. Use timedelta
+                (e.g. timedelta(days=7)) or a string shorthand like "7d", "24h".
             offset: Documents within this distance from origin get full score (default "0").
                 Accepts the same types as scale.
             curve: Decay curve type: `Boost.Curve.EXPONENTIAL` (default), `Boost.Curve.GAUSSIAN`, or `Boost.Curve.LINEAR`.
             decay_value: Score at scale distance from origin (default 0.5).
             weight: Blending weight [0,1] controlling how much the rank affects final scores.
-            depth: Number of results to rescore (default 100, max 10000). Higher values improve accuracy at the cost of performance.
+            depth: Number of results to rescore (default 100, max 10000).
         """
         return _Boost(
             conditions=[
                 _BoostCondition(
-                    decay=_DecayFunction(
+                    time_decay=_TimeDecayFunction(
                         property=property,
                         origin=_decay_value_to_str(origin) if origin is not None else "",
                         scale=_decay_value_to_str(scale),
@@ -382,6 +392,47 @@ def decay(
             depth=depth,
         )
 
+    @staticmethod
+    def numeric_decay(
+        property: str,
+        *,
+        origin: float,
+        scale: float,
+        offset: Optional[float] = None,
+        curve: Optional[Union[_BoostCurve, str]] = None,
+        decay_value: Optional[float] = None,
+        weight: Optional[float] = None,
+        depth: Optional[int] = None,
+    ) -> _Boost:
+        """Apply numeric distance-based decay scoring from an origin value.
+
+        Args:
+            property: The numeric property name to compute distance from.
+            origin: The origin point (numeric value).
+            scale: Distance from origin where score equals decay_value.
+            offset: Documents within this distance from origin get full score (default 0).
+            curve: Decay curve type: `Boost.Curve.EXPONENTIAL` (default), `Boost.Curve.GAUSSIAN`, or `Boost.Curve.LINEAR`.
+            decay_value: Score at scale distance from origin (default 0.5).
+            weight: Blending weight [0,1] controlling how much the rank affects final scores.
+            depth: Number of results to rescore (default 100, max 10000).
+        """
+        return _Boost(
+            conditions=[
+                _BoostCondition(
+                    numeric_decay=_NumericDecayFunction(
+                        property=property,
+                        origin=float(origin),
+                        scale=float(scale),
+                        offset=float(offset) if offset is not None else None,
+                        curve=curve.value if isinstance(curve, _BoostCurve) else curve,
+                        decay_value=decay_value,
+                    )
+                )
+            ],
+            weight=weight,
+            depth=depth,
+        )
+
     @staticmethod
     def property(
         name: str,
@@ -423,15 +474,15 @@ def blend(
         and the `weight` parameter here controls the overall blending strength.
 
         Args:
-            *ranks: Rank objects created via `Boost.filter()`, `Boost.decay()`, or `Boost.property()`.
+            *ranks: Rank objects created via `Boost.filter()`, `Boost.time_decay()`, `Boost.numeric_decay()`, or `Boost.property()`.
             weight: Overall blending weight [0,1] for combining primary search and rank scores.
             depth: Number of results to rescore (default 100, max 10000). Higher values improve accuracy at the cost of performance.
         """
         conditions: List[_BoostCondition] = []
         for r in ranks:
             for cond in r.conditions:
                 if cond.weight is None and r.weight is not None:
-                    cond = _BoostCondition(filter=cond.filter, decay=cond.decay, property_value=cond.property_value, weight=r.weight)
+                    cond = _BoostCondition(filter=cond.filter, time_decay=cond.time_decay, numeric_decay=cond.numeric_decay, property_value=cond.property_value, weight=r.weight)
                 conditions.append(cond)
         return _Boost(conditions=conditions, weight=weight, depth=depth)
 

weaviate/collections/grpc/query.py

@@ -552,6 +552,11 @@ def _metadata_to_grpc(self, metadata: _MetadataQuery) -> search_get_pb2.Metadata
         "sqrt": search_get_pb2.PROPERTY_VALUE_MODIFIER_SQRT,
     }
 
+    def __resolve_curve(self, curve: Optional[str]) -> int:
+        if curve is None:
+            return search_get_pb2.DECAY_CURVE_EXPONENTIAL
+        return self._CURVE_TO_PROTO.get(curve, search_get_pb2.DECAY_CURVE_EXPONENTIAL)
+
     def __boost_to_grpc(
         self, boost: Optional[_Boost]
     ) -> Optional[search_get_pb2.Boost]:
@@ -562,17 +567,26 @@ def __boost_to_grpc(
             grpc_cond = search_get_pb2.BoostCondition(weight=cond.weight)
             if cond.filter is not None:
                 grpc_cond.filter.CopyFrom(_FilterToGRPC.convert(cond.filter))
-            elif cond.decay is not None:
-                grpc_cond.decay.CopyFrom(
-                    search_get_pb2.DecayFunction(
-                        property=cond.decay.property,
-                        origin=cond.decay.origin,
-                        scale=cond.decay.scale,
-                        offset=cond.decay.offset,
-                        curve=self._CURVE_TO_PROTO.get(
-                            cond.decay.curve, search_get_pb2.DECAY_CURVE_EXPONENTIAL
-                        ) if cond.decay.curve is not None else search_get_pb2.DECAY_CURVE_EXPONENTIAL,
-                        decay_value=cond.decay.decay_value,
+            elif cond.time_decay is not None:
+                grpc_cond.time_decay.CopyFrom(
+                    search_get_pb2.TimeDecayFunction(
+                        property=cond.time_decay.property,
+                        origin=cond.time_decay.origin,
+                        scale=cond.time_decay.scale,
+                        offset=cond.time_decay.offset,
+                        curve=self.__resolve_curve(cond.time_decay.curve),
+                        decay_value=cond.time_decay.decay_value,
+                    )
+                )
+            elif cond.numeric_decay is not None:
+                grpc_cond.numeric_decay.CopyFrom(
+                    search_get_pb2.NumericDecayFunction(
+                        property=cond.numeric_decay.property,
+                        origin=cond.numeric_decay.origin,
+                        scale=cond.numeric_decay.scale,
+                        offset=cond.numeric_decay.offset,
+                        curve=self.__resolve_curve(cond.numeric_decay.curve),
+                        decay_value=cond.numeric_decay.decay_value,
                     )
                 )
             elif cond.property_value is not None:

weaviate/proto/v1/v4216/v1/search_get_pb2.py

@@ -347,16 +347,18 @@ class Boost(_message.Message):
     def __init__(self, conditions: _Optional[_Iterable[_Union[BoostCondition, _Mapping]]] = ..., weight: _Optional[float] = ..., depth: _Optional[int] = ...) -> None: ...
 
 class BoostCondition(_message.Message):
-    __slots__ = ("filter", "decay", "property_value", "weight")
+    __slots__ = ("filter", "time_decay", "property_value", "numeric_decay", "weight")
     FILTER_FIELD_NUMBER: _ClassVar[int]
-    DECAY_FIELD_NUMBER: _ClassVar[int]
+    TIME_DECAY_FIELD_NUMBER: _ClassVar[int]
     PROPERTY_VALUE_FIELD_NUMBER: _ClassVar[int]
+    NUMERIC_DECAY_FIELD_NUMBER: _ClassVar[int]
     WEIGHT_FIELD_NUMBER: _ClassVar[int]
     filter: _base_pb2.Filters
-    decay: DecayFunction
+    time_decay: TimeDecayFunction
     property_value: PropertyValueFunction
+    numeric_decay: NumericDecayFunction
     weight: float
-    def __init__(self, filter: _Optional[_Union[_base_pb2.Filters, _Mapping]] = ..., decay: _Optional[_Union[DecayFunction, _Mapping]] = ..., property_value: _Optional[_Union[PropertyValueFunction, _Mapping]] = ..., weight: _Optional[float] = ...) -> None: ...
+    def __init__(self, filter: _Optional[_Union[_base_pb2.Filters, _Mapping]] = ..., time_decay: _Optional[_Union[TimeDecayFunction, _Mapping]] = ..., property_value: _Optional[_Union[PropertyValueFunction, _Mapping]] = ..., numeric_decay: _Optional[_Union[NumericDecayFunction, _Mapping]] = ..., weight: _Optional[float] = ...) -> None: ...
 
 class PropertyValueFunction(_message.Message):
     __slots__ = ("property", "modifier")
@@ -366,7 +368,7 @@ class PropertyValueFunction(_message.Message):
     modifier: PropertyValueModifier
     def __init__(self, property: _Optional[str] = ..., modifier: _Optional[_Union[PropertyValueModifier, str]] = ...) -> None: ...
 
-class DecayFunction(_message.Message):
+class TimeDecayFunction(_message.Message):
     __slots__ = ("property", "origin", "scale", "offset", "curve", "decay_value")
     PROPERTY_FIELD_NUMBER: _ClassVar[int]
     ORIGIN_FIELD_NUMBER: _ClassVar[int]
@@ -381,3 +383,19 @@ class DecayFunction(_message.Message):
     curve: DecayCurve
     decay_value: float
     def __init__(self, property: _Optional[str] = ..., origin: _Optional[str] = ..., scale: _Optional[str] = ..., offset: _Optional[str] = ..., curve: _Optional[_Union[DecayCurve, str]] = ..., decay_value: _Optional[float] = ...) -> None: ...
+
+class NumericDecayFunction(_message.Message):
+    __slots__ = ("property", "origin", "scale", "offset", "curve", "decay_value")
+    PROPERTY_FIELD_NUMBER: _ClassVar[int]
+    ORIGIN_FIELD_NUMBER: _ClassVar[int]
+    SCALE_FIELD_NUMBER: _ClassVar[int]
+    OFFSET_FIELD_NUMBER: _ClassVar[int]
+    CURVE_FIELD_NUMBER: _ClassVar[int]
+    DECAY_VALUE_FIELD_NUMBER: _ClassVar[int]
+    property: str
+    origin: float
+    scale: float
+    offset: float
+    curve: DecayCurve
+    decay_value: float
+    def __init__(self, property: _Optional[str] = ..., origin: _Optional[float] = ..., scale: _Optional[float] = ..., offset: _Optional[float] = ..., curve: _Optional[_Union[DecayCurve, str]] = ..., decay_value: _Optional[float] = ...) -> None: ...