flagsmith-flag-engine 10.0.2__tar.gz → 10.0.4__tar.gz

{flagsmith_flag_engine-10.0.2/flagsmith_flag_engine.egg-info → flagsmith_flag_engine-10.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flagsmith-flag-engine
-Version: 10.0.2
+Version: 10.0.4
 Summary: Flag engine for the Flagsmith API.
 Home-page: https://github.com/Flagsmith/flagsmith-engine
 Author: Flagsmith

{flagsmith_flag_engine-10.0.2 → flagsmith_flag_engine-10.0.4}/flag_engine/segments/evaluator.py

@@ -264,53 +264,45 @@ def context_matches_condition(
     condition: SegmentCondition,
     segment_key: SupportsStr,
 ) -> bool:
-    context_value = (
-        get_context_value(context, condition_property)
-        if (condition_property := condition.get("property"))
-        else None
-    )
+    context_value: ContextValue
+    condition_property = condition["property"]
+    condition_operator = condition["operator"]
+
+    if condition_operator == constants.PERCENTAGE_SPLIT and (not condition_property):
+        # Currently, the only supported condition with a blank property
+        # is percentage split.
+        # In this case, we use the identity key as context value.
+        # This is mainly to support legacy segments created before
+        # we introduced JSONPath support.
+        context_value = _get_identity_key(context)
+    else:
+        context_value = get_context_value(context, condition_property)
 
-    if condition["operator"] == constants.IN:
-        if isinstance(segment_value := condition["value"], list):
-            in_values = segment_value
-        else:
-            try:
-                in_values = json.loads(segment_value)
-                # Only accept JSON lists.
-                # Ideally, we should use something like pydantic.TypeAdapter[list[str]],
-                # but we aim to ditch the pydantic dependency in the future.
-                if not isinstance(in_values, list):
-                    raise ValueError
-            except ValueError:
-                in_values = segment_value.split(",")
-        in_values = [str(value) for value in in_values]
+    if condition_operator == constants.IN:
+        in_values = _get_in_values(condition["value"])
         # Guard against comparing boolean values to numeric strings.
-        if isinstance(context_value, int) and not (
-            context_value is True or context_value is False
-        ):
+        if type(context_value) is int:
             context_value = str(context_value)
         return context_value in in_values
 
     condition = typing.cast(StrValueSegmentCondition, condition)
 
-    if condition["operator"] == constants.PERCENTAGE_SPLIT:
-        if context_value is not None:
-            object_ids = [segment_key, context_value]
-        elif identity_key := _get_identity_key(context):
-            object_ids = [segment_key, identity_key]
-        else:
+    if condition_operator == constants.PERCENTAGE_SPLIT:
+        if context_value is None:
             return False
 
+        object_ids = [segment_key, context_value]
+
         try:
             float_value = float(condition["value"])
         except ValueError:
             return False
         return get_hashed_percentage_for_object_ids(object_ids) <= float_value
 
-    if condition["operator"] == constants.IS_NOT_SET:
+    if condition_operator == constants.IS_NOT_SET:
         return context_value is None
 
-    if condition["operator"] == constants.IS_SET:
+    if condition_operator == constants.IS_SET:
         return context_value is not None
 
     return (
@@ -342,6 +334,30 @@ def _matches_context_value(
     return False
 
 
+@lru_cache(maxsize=1024)
+def _parse_in_values_str(segment_value: str) -> frozenset[str]:
+    """
+    Parse a string-form IN condition value into a frozenset of strings.
+    A bracketed value is tried as JSON first (with CSV fallback on parse
+    error); anything else is split on commas directly.
+    """
+    if segment_value.startswith("["):
+        try:
+            parsed: list[typing.Any] = json.loads(segment_value)
+        except ValueError:
+            return frozenset(segment_value.split(","))
+        return frozenset(v if type(v) is str else str(v) for v in parsed)
+    return frozenset(segment_value.split(","))
+
+
+def _get_in_values(
+    segment_value: typing.Union[str, list[typing.Any]],
+) -> frozenset[str]:
+    if isinstance(segment_value, list):
+        return frozenset(v if type(v) is str else str(v) for v in segment_value)
+    return _parse_in_values_str(segment_value)
+
+
 def _evaluate_not_contains(
     segment_value: typing.Optional[str],
     context_value: ContextValue,
@@ -417,7 +433,7 @@ MATCHERS_BY_OPERATOR: dict[
 
 def _get_identity_key(
     context: _EvaluationContextAnyMeta,
-) -> typing.Optional[SupportsStr]:
+) -> typing.Optional[str]:
     if identity_context := context.get("identity"):
         return identity_context.get("key")
     return None

{flagsmith_flag_engine-10.0.2 → flagsmith_flag_engine-10.0.4/flagsmith_flag_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flagsmith-flag-engine
-Version: 10.0.2
+Version: 10.0.4
 Summary: Flag engine for the Flagsmith API.
 Home-page: https://github.com/Flagsmith/flagsmith-engine
 Author: Flagsmith

{flagsmith_flag_engine-10.0.2 → flagsmith_flag_engine-10.0.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import find_packages, setup
 
 setup(
     name="flagsmith-flag-engine",
-    version="10.0.2",
+    version="10.0.4",
     author="Flagsmith",
     author_email="support@flagsmith.com",
     packages=find_packages(include=["flag_engine", "flag_engine.*"]),