fix: update flagd-core to match upstream fractional v2 and Python 3.10

- Implement fractional v2 bucketing algorithm (unsigned hash, integer
  arithmetic with bit-shift instead of percentage-based float)
- Add MAX_WEIGHT_SUM overflow guard
- Add negative weight clamping (max(0, weight))
- Add explicit bool-as-weight rejection
- Support non-string variant types (str|float|int|bool|None)
- Extract _resolve_bucket_by helper
- Bump mmh3 dependency to >=5.0.0,<6.0.0
- Drop Python 3.9: update requires-python to >=3.10 for all tools packages

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: aepfli

tools/openfeature-flagd-api-testkit/pyproject.toml

@@ -21,7 +21,7 @@ dependencies = [
     "pytest>=8.4.0",
     "pytest-bdd>=8.1.0",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 
 [project.urls]
 Homepage = "https://github.com/open-feature/python-sdk-contrib"
@@ -46,7 +46,7 @@ data-dir = "src"
 [tool.mypy]
 mypy_path = "src"
 files = "src"
-python_version = "3.9"
+python_version = "3.10"
 namespace_packages = true
 explicit_package_bases = true
 local_partial_types = true

tools/openfeature-flagd-api/pyproject.toml

@@ -18,7 +18,7 @@ keywords = []
 dependencies = [
     "openfeature-sdk>=0.8.2",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 
 [project.urls]
 Homepage = "https://github.com/open-feature/python-sdk-contrib"
@@ -38,7 +38,7 @@ namespace = true
 [tool.mypy]
 mypy_path = "src"
 files = "src"
-python_version = "3.9"
+python_version = "3.10"
 namespace_packages = true
 explicit_package_bases = true
 local_partial_types = true

tools/openfeature-flagd-core/pyproject.toml

@@ -18,11 +18,11 @@ keywords = []
 dependencies = [
     "openfeature-flagd-api",
     "openfeature-sdk>=0.8.2",
-    "mmh3>=4.1.0",
+    "mmh3>=5.0.0,<6.0.0",
     "panzi-json-logic>=1.0.1",
     "semver>=3,<4",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 
 [project.urls]
 Homepage = "https://github.com/open-feature/python-sdk-contrib"
@@ -48,7 +48,7 @@ namespace = true
 [tool.mypy]
 mypy_path = "src"
 files = "src"
-python_version = "3.9"
+python_version = "3.10"
 namespace_packages = true
 explicit_package_bases = true
 local_partial_types = true

tools/openfeature-flagd-core/src/openfeature/contrib/tools/flagd/core/targeting/custom_ops.py

@@ -1,62 +1,71 @@
 import logging
 import typing
+from collections.abc import Sequence
 from dataclasses import dataclass
 
 import mmh3
 import semver
 
-JsonPrimitive = typing.Union[str, bool, float, int]
-JsonLogicArg = typing.Union[JsonPrimitive, typing.Sequence[JsonPrimitive]]
+MAX_WEIGHT_SUM = 2_147_483_647  # MaxInt32
+
+JsonPrimitive: typing.TypeAlias = str | bool | float | int
+JsonLogicArg: typing.TypeAlias = JsonPrimitive | Sequence[JsonPrimitive]
 
 logger = logging.getLogger("openfeature.contrib")
 
 
 @dataclass
 class Fraction:
-    variant: str
+    variant: str | float | int | bool | None
     weight: int = 1
 
 
-def fractional(data: dict, *args: JsonLogicArg) -> typing.Optional[str]:
+def _resolve_bucket_by(data: dict, args: tuple) -> tuple[str | None, tuple]:
+    if isinstance(args[0], str):
+        return args[0], args[1:]
+
+    seed = data.get("$flagd", {}).get("flagKey", "")
+    targeting_key = data.get("targetingKey")
+    if not targeting_key:
+        logger.error("No targetingKey provided for fractional shorthand syntax.")
+        return None, args
+    return seed + targeting_key, args
+
+
+def fractional(data: dict, *args: JsonLogicArg) -> str | float | int | bool | None:
     if not args:
         logger.error("No arguments provided to fractional operator.")
         return None
 
-    bucket_by = None
-    if isinstance(args[0], str):
-        bucket_by = args[0]
-        args = args[1:]
-    else:
-        seed = data.get("$flagd", {}).get("flagKey", "")
-        targeting_key = data.get("targetingKey")
-        if not targeting_key:
-            logger.error("No targetingKey provided for fractional shorthand syntax.")
-            return None
-        bucket_by = seed + targeting_key
+    bucket_by, args = _resolve_bucket_by(data, args)
 
     if not bucket_by:
         logger.error("No hashKey value resolved")
         return None
 
-    hash_ratio = abs(mmh3.hash(bucket_by)) / (2**31 - 1)
-    bucket = hash_ratio * 100
+    hash_value = mmh3.hash(bucket_by, signed=False)
 
     total_weight = 0
     fractions = []
     try:
         for arg in args:
             fraction = _parse_fraction(arg)
-            if fraction:
-                fractions.append(fraction)
-                total_weight += fraction.weight
+            fractions.append(fraction)
+            total_weight += fraction.weight
 
     except ValueError:
         logger.debug(f"Invalid {args} configuration")
         return None
 
-    range_end: float = 0
+    if total_weight > MAX_WEIGHT_SUM:
+        logger.error(f"Total fractional weight exceeds MaxInt32 ({MAX_WEIGHT_SUM:,}).")
+        return None
+
+    bucket = (hash_value * total_weight) >> 32
+
+    range_end = 0
     for fraction in fractions:
-        range_end += fraction.weight * 100 / total_weight
+        range_end += fraction.weight
         if bucket < range_end:
             return fraction.variant
     return None
@@ -68,31 +77,34 @@ def _parse_fraction(arg: JsonLogicArg) -> Fraction:
             "Fractional variant weights must be (str, int) tuple or [str] list"
         )
 
-    if not isinstance(arg[0], str):
-        raise ValueError(
-            "Fractional variant identifier (first element) isn't of type 'str'"
-        )
+    variant = arg[0]
 
-    if len(arg) >= 2 and not isinstance(arg[1], int):
-        raise ValueError(
-            "Fractional variant weight value (second element) isn't of type 'int'"
-        )
+    weight = None
+    if len(arg) == 2:
+        w = arg[1]
+        if isinstance(w, bool):
+            raise ValueError("Fractional weight value isn't of type 'int'")
+        elif isinstance(w, int):
+            weight = w
+        else:
+            raise ValueError("Fractional weight value isn't of type 'int'")
 
-    fraction = Fraction(variant=arg[0])
-    if len(arg) >= 2:
-        fraction.weight = arg[1]
+    fraction = Fraction(variant=variant)
+    if weight is not None:
+        # negative weights can be the result of rollout calculations, so we clamp to 0 rather than raising an error
+        fraction.weight = max(0, weight)
 
     return fraction
 
 
-def starts_with(data: dict, *args: JsonLogicArg) -> typing.Optional[bool]:
+def starts_with(data: dict, *args: JsonLogicArg) -> bool | None:
     def f(s1: str, s2: str) -> bool:
         return s1.startswith(s2)
 
     return string_comp(f, data, *args)
 
 
-def ends_with(data: dict, *args: JsonLogicArg) -> typing.Optional[bool]:
+def ends_with(data: dict, *args: JsonLogicArg) -> bool | None:
     def f(s1: str, s2: str) -> bool:
         return s1.endswith(s2)
 
@@ -101,7 +113,7 @@ def f(s1: str, s2: str) -> bool:
 
 def string_comp(
     comparator: typing.Callable[[str, str], bool], data: dict, *args: JsonLogicArg
-) -> typing.Optional[bool]:
+) -> bool | None:
     if not args:
         logger.error("No arguments provided to string_comp operator.")
         return None
@@ -119,7 +131,7 @@ def string_comp(
     return comparator(arg1, arg2)
 
 
-def sem_ver(data: dict, *args: JsonLogicArg) -> typing.Optional[bool]:  # noqa: C901
+def sem_ver(data: dict, *args: JsonLogicArg) -> bool | None:  # noqa: C901
     if not args:
         logger.error("No arguments provided to sem_ver operator.")
         return None