flagsmith-flag-engine 5.3.0__tar.gz → 5.4.0__tar.gz

{flagsmith-flag-engine-5.3.0/flagsmith_flag_engine.egg-info → flagsmith-flag-engine-5.4.0}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.1
 Name: flagsmith-flag-engine
-Version: 5.3.0
+Version: 5.4.0
 Summary: Flag engine for the Flagsmith API.
 Home-page: https://github.com/Flagsmith/flagsmith-engine
 Author: Flagsmith
 Author-email: support@flagsmith.com
 License: BSD3
-Platform: UNKNOWN
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.7
@@ -36,5 +35,3 @@ python -m pip install -r requirements-dev.txt
 
 - Marshmallow Schemas
 - Plain Python
-
-

flagsmith-flag-engine-5.4.0/flag_engine/context/mappers.py

@@ -0,0 +1,39 @@
+import typing
+
+from flag_engine.context.types import EvaluationContext
+from flag_engine.environments.models import EnvironmentModel
+from flag_engine.identities.models import IdentityModel
+from flag_engine.identities.traits.models import TraitModel
+
+
+def map_environment_identity_to_context(
+    environment: EnvironmentModel,
+    identity: IdentityModel,
+    override_traits: typing.Optional[typing.List[TraitModel]],
+) -> EvaluationContext:
+    """
+    Maps an EnvironmentModel and IdentityModel to an EvaluationContext.
+
+    :param environment: The environment model object.
+    :param identity: The identity model object.
+    :param override_traits: A list of TraitModel objects, to be used in place of `identity.identity_traits` if provided.
+    :return: An EvaluationContext containing the environment and identity.
+    """
+    return {
+        "environment": {
+            "key": environment.api_key,
+            "name": environment.name or "",
+        },
+        "identity": {
+            "identifier": identity.identifier,
+            "key": str(identity.django_id or identity.composite_key),
+            "traits": {
+                trait.trait_key: trait.trait_value
+                for trait in (
+                    override_traits
+                    if override_traits is not None
+                    else identity.identity_traits
+                )
+            },
+        },
+    }

flagsmith-flag-engine-5.4.0/flag_engine/context/types.py

@@ -0,0 +1,28 @@
+# generated by datamodel-codegen:
+#   filename:  https://raw.githubusercontent.com/Flagsmith/flagsmith/chore/update-evaluation-context/sdk/evaluation-context.json  # noqa: E501
+#   timestamp: 2025-07-16T10:39:10+00:00
+
+from __future__ import annotations
+
+from typing import Dict, Optional, TypedDict
+
+from typing_extensions import NotRequired
+
+from flag_engine.identities.traits.types import ContextValue
+from flag_engine.utils.types import SupportsStr
+
+
+class EnvironmentContext(TypedDict):
+    key: str
+    name: str
+
+
+class IdentityContext(TypedDict):
+    identifier: str
+    key: SupportsStr
+    traits: NotRequired[Dict[str, ContextValue]]
+
+
+class EvaluationContext(TypedDict):
+    environment: EnvironmentContext
+    identity: NotRequired[Optional[IdentityContext]]

{flagsmith-flag-engine-5.3.0 → flagsmith-flag-engine-5.4.0}/flag_engine/engine.py

@@ -1,10 +1,12 @@
 import typing
 
+from flag_engine.context.mappers import map_environment_identity_to_context
+from flag_engine.context.types import EvaluationContext
 from flag_engine.environments.models import EnvironmentModel
 from flag_engine.features.models import FeatureModel, FeatureStateModel
 from flag_engine.identities.models import IdentityModel
 from flag_engine.identities.traits.models import TraitModel
-from flag_engine.segments.evaluator import get_identity_segments
+from flag_engine.segments.evaluator import get_context_segments
 from flag_engine.utils.exceptions import FeatureStateNotFound
 
 
@@ -53,9 +55,17 @@ def get_identity_feature_states(
     :return: list of feature state models based on the environment, any matching
         segments and any specific identity overrides
     """
+    context = map_environment_identity_to_context(
+        environment=environment,
+        identity=identity,
+        override_traits=override_traits,
+    )
+
     feature_states = list(
         _get_identity_feature_states_dict(
-            environment, identity, override_traits
+            environment=environment,
+            identity=identity,
+            context=context,
         ).values()
     )
     if environment.get_hide_disabled_flags():
@@ -79,8 +89,16 @@ def get_identity_feature_state(
     :return: feature state model based on the environment, any matching
         segments and any specific identity overrides
     """
+    context = map_environment_identity_to_context(
+        environment=environment,
+        identity=identity,
+        override_traits=override_traits,
+    )
+
     feature_states = _get_identity_feature_states_dict(
-        environment, identity, override_traits
+        environment=environment,
+        identity=identity,
+        context=context,
     )
     matching_feature = next(
         filter(lambda feature: feature.name == feature_name, feature_states.keys()),
@@ -96,29 +114,33 @@ def get_identity_feature_state(
 def _get_identity_feature_states_dict(
     environment: EnvironmentModel,
     identity: IdentityModel,
-    override_traits: typing.Optional[typing.List[TraitModel]],
+    context: EvaluationContext,
 ) -> typing.Dict[FeatureModel, FeatureStateModel]:
     # Get feature states from the environment
-    feature_states = {fs.feature: fs for fs in environment.feature_states}
+    feature_states_by_feature = {fs.feature: fs for fs in environment.feature_states}
 
     # Override with any feature states defined by matching segments
-    identity_segments = get_identity_segments(environment, identity, override_traits)
-    for matching_segment in identity_segments:
-        for feature_state in matching_segment.feature_states:
-            if feature_state.feature in feature_states:
-                if feature_states[feature_state.feature].is_higher_segment_priority(
-                    feature_state
-                ):
-                    continue
-            feature_states[feature_state.feature] = feature_state
+    for context_segment in get_context_segments(
+        context=context,
+        segments=environment.project.segments,
+    ):
+        for segment_feature_state in context_segment.feature_states:
+            if (
+                feature_state := feature_states_by_feature.get(
+                    segment_feature := segment_feature_state.feature
+                )
+            ) and feature_state.is_higher_segment_priority(segment_feature_state):
+                continue
+            feature_states_by_feature[segment_feature] = segment_feature_state
 
     # Override with any feature states defined directly the identity
-    feature_states.update(
+    feature_states_by_feature.update(
         {
-            fs.feature: fs
-            for fs in identity.identity_features
-            if fs.feature in feature_states
+            identity_feature: identity_feature_state
+            for identity_feature_state in identity.identity_features
+            if (identity_feature := identity_feature_state.feature)
+            in feature_states_by_feature
         }
     )
 
-    return feature_states
+    return feature_states_by_feature

flagsmith-flag-engine-5.4.0/flag_engine/identities/traits/models.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+
+from flag_engine.identities.traits.types import ContextValue
+
+
+class TraitModel(BaseModel):
+    trait_key: str
+    trait_value: ContextValue = Field(...)

{flagsmith-flag-engine-5.3.0 → flagsmith-flag-engine-5.4.0}/flag_engine/identities/traits/types.py

@@ -8,10 +8,10 @@ from typing_extensions import Annotated, TypeGuard
 
 from flag_engine.identities.traits.constants import TRAIT_STRING_VALUE_MAX_LENGTH
 
-_UnconstrainedTraitValue = Union[None, int, float, bool, str]
+_UnconstrainedContextValue = Union[None, int, float, bool, str]
 
 
-def map_any_value_to_trait_value(value: Any) -> _UnconstrainedTraitValue:
+def map_any_value_to_trait_value(value: Any) -> _UnconstrainedContextValue:
     """
     Try to coerce a value of arbitrary type to a trait value type.
     Union member-specific constraints, such as max string value length, are ignored here.
@@ -36,7 +36,7 @@ _int_pattern = re.compile(r"-?[0-9]+")
 _float_pattern = re.compile(r"-?[0-9]+\.[0-9]+")
 
 
-def _map_string_value_to_trait_value(value: str) -> _UnconstrainedTraitValue:
+def _map_string_value_to_trait_value(value: str) -> _UnconstrainedContextValue:
     if _int_pattern.fullmatch(value):
         return int(value)
     if _float_pattern.fullmatch(value):
@@ -44,11 +44,11 @@ def _map_string_value_to_trait_value(value: str) -> _UnconstrainedTraitValue:
     return value
 
 
-def _is_trait_value(value: Any) -> TypeGuard[_UnconstrainedTraitValue]:
-    return isinstance(value, get_args(_UnconstrainedTraitValue))
+def _is_trait_value(value: Any) -> TypeGuard[_UnconstrainedContextValue]:
+    return isinstance(value, get_args(_UnconstrainedContextValue))
 
 
-TraitValue = Annotated[
+ContextValue = Annotated[
     Union[
         None,
         StrictBool,

{flagsmith-flag-engine-5.3.0 → flagsmith-flag-engine-5.4.0}/flag_engine/organisations/models.py

@@ -4,9 +4,9 @@ from pydantic import BaseModel
 class OrganisationModel(BaseModel):
     id: int
     name: str
-    feature_analytics: bool
-    stop_serving_flags: bool
-    persist_trait_data: bool
+    feature_analytics: bool = False
+    stop_serving_flags: bool = False
+    persist_trait_data: bool = True
 
     @property
     def unique_slug(self) -> str:

{flagsmith-flag-engine-5.3.0 → flagsmith-flag-engine-5.4.0}/flag_engine/projects/models.py

@@ -10,7 +10,7 @@ class ProjectModel(BaseModel):
     id: int
     name: str
     organisation: OrganisationModel
-    hide_disabled_flags: bool
+    hide_disabled_flags: bool = False
     segments: typing.List[SegmentModel] = Field(default_factory=list)
     enable_realtime_updates: bool = False
     server_key_only_feature_ids: typing.List[int] = Field(default_factory=list)

flagsmith-flag-engine-5.4.0/flag_engine/segments/evaluator.py

@@ -0,0 +1,229 @@
+import operator
+import re
+import typing
+from contextlib import suppress
+from functools import partial, wraps
+
+import semver
+
+from flag_engine.context.types import EvaluationContext
+from flag_engine.identities.traits.types import ContextValue
+from flag_engine.segments import constants
+from flag_engine.segments.models import (
+    SegmentConditionModel,
+    SegmentModel,
+    SegmentRuleModel,
+)
+from flag_engine.segments.types import ConditionOperator
+from flag_engine.utils.hashing import get_hashed_percentage_for_object_ids
+from flag_engine.utils.semver import is_semver
+from flag_engine.utils.types import SupportsStr, get_casting_function
+
+
+def get_context_segments(
+    context: EvaluationContext,
+    segments: typing.List[SegmentModel],
+) -> typing.List[SegmentModel]:
+    return [
+        segment
+        for segment in segments
+        if is_context_in_segment(
+            context=context,
+            segment=segment,
+        )
+    ]
+
+
+def is_context_in_segment(
+    context: EvaluationContext,
+    segment: SegmentModel,
+) -> bool:
+    return bool(rules := segment.rules) and all(
+        context_matches_rule(context=context, rule=rule, segment_key=segment.id)
+        for rule in rules
+    )
+
+
+def context_matches_rule(
+    context: EvaluationContext,
+    rule: SegmentRuleModel,
+    segment_key: SupportsStr,
+) -> bool:
+    matches_conditions = (
+        rule.matching_function(
+            [
+                context_matches_condition(
+                    context=context,
+                    condition=condition,
+                    segment_key=segment_key,
+                )
+                for condition in conditions
+            ]
+        )
+        if (conditions := rule.conditions)
+        else True
+    )
+
+    return matches_conditions and all(
+        context_matches_rule(
+            context=context,
+            rule=rule,
+            segment_key=segment_key,
+        )
+        for rule in rule.rules
+    )
+
+
+def context_matches_condition(
+    context: EvaluationContext,
+    condition: SegmentConditionModel,
+    segment_key: SupportsStr,
+) -> bool:
+    context_value = (
+        get_context_value(context, condition.property_) if condition.property_ else None
+    )
+
+    if condition.operator == constants.PERCENTAGE_SPLIT:
+        assert condition.value
+
+        if context_value is not None:
+            object_ids = [segment_key, context_value]
+        else:
+            object_ids = [segment_key, get_context_value(context, "$.identity.key")]
+
+        float_value = float(condition.value)
+        return get_hashed_percentage_for_object_ids(object_ids) <= float_value
+
+    if condition.operator == constants.IS_NOT_SET:
+        return context_value is None
+
+    if condition.operator == constants.IS_SET:
+        return context_value is not None
+
+    return _matches_context_value(condition, context_value) if context_value else False
+
+
+def _get_trait(context: EvaluationContext, trait_key: str) -> ContextValue:
+    return (
+        identity_context["traits"][trait_key]
+        if (identity_context := context["identity"])
+        else None
+    )
+
+
+def get_context_value(
+    context: EvaluationContext,
+    property: str,
+) -> ContextValue:
+    getter = CONTEXT_VALUE_GETTERS_BY_PROPERTY.get(property) or partial(
+        _get_trait,
+        trait_key=property,
+    )
+    try:
+        return getter(context)
+    except KeyError:
+        return None
+
+
+def _matches_context_value(
+    condition: SegmentConditionModel,
+    context_value: ContextValue,
+) -> bool:
+    if matcher := MATCHERS_BY_OPERATOR.get(condition.operator):
+        return matcher(condition.value, context_value)
+
+    return False
+
+
+def _evaluate_not_contains(
+    segment_value: typing.Optional[str],
+    context_value: ContextValue,
+) -> bool:
+    return isinstance(context_value, str) and str(segment_value) not in context_value
+
+
+def _evaluate_regex(
+    segment_value: typing.Optional[str],
+    context_value: ContextValue,
+) -> bool:
+    return (
+        context_value is not None
+        and re.compile(str(segment_value)).match(str(context_value)) is not None
+    )
+
+
+def _evaluate_modulo(
+    segment_value: typing.Optional[str],
+    context_value: ContextValue,
+) -> bool:
+    if not isinstance(context_value, (int, float)):
+        return False
+
+    if segment_value is None:
+        return False
+
+    try:
+        divisor_part, remainder_part = segment_value.split("|")
+        divisor = float(divisor_part)
+        remainder = float(remainder_part)
+    except ValueError:
+        return False
+
+    return context_value % divisor == remainder
+
+
+def _evaluate_in(
+    segment_value: typing.Optional[str], context_value: ContextValue
+) -> bool:
+    if segment_value:
+        if isinstance(context_value, str):
+            return context_value in segment_value.split(",")
+        if isinstance(context_value, int) and not any(
+            context_value is x for x in (False, True)
+        ):
+            return str(context_value) in segment_value.split(",")
+    return False
+
+
+def _context_value_typed(
+    func: typing.Callable[..., bool],
+) -> typing.Callable[[typing.Optional[str], ContextValue], bool]:
+    @wraps(func)
+    def inner(
+        segment_value: typing.Optional[str],
+        context_value: typing.Union[ContextValue, semver.Version],
+    ) -> bool:
+        with suppress(TypeError, ValueError):
+            if isinstance(context_value, str) and is_semver(segment_value):
+                context_value = semver.Version.parse(
+                    context_value,
+                )
+            match_value = get_casting_function(context_value)(segment_value)
+            return func(context_value, match_value)
+        return False
+
+    return inner
+
+
+MATCHERS_BY_OPERATOR: typing.Dict[
+    ConditionOperator, typing.Callable[[typing.Optional[str], ContextValue], bool]
+] = {
+    constants.NOT_CONTAINS: _evaluate_not_contains,
+    constants.REGEX: _evaluate_regex,
+    constants.MODULO: _evaluate_modulo,
+    constants.IN: _evaluate_in,
+    constants.EQUAL: _context_value_typed(operator.eq),
+    constants.GREATER_THAN: _context_value_typed(operator.gt),
+    constants.GREATER_THAN_INCLUSIVE: _context_value_typed(operator.ge),
+    constants.LESS_THAN: _context_value_typed(operator.lt),
+    constants.LESS_THAN_INCLUSIVE: _context_value_typed(operator.le),
+    constants.NOT_EQUAL: _context_value_typed(operator.ne),
+    constants.CONTAINS: _context_value_typed(operator.contains),
+}
+
+
+CONTEXT_VALUE_GETTERS_BY_PROPERTY = {
+    "$.identity.identifier": lambda context: context["identity"]["identifier"],
+    "$.identity.key": lambda context: context["identity"]["key"],
+    "$.environment.name": lambda context: context["environment"]["name"],
+}

{flagsmith-flag-engine-5.3.0 → flagsmith-flag-engine-5.4.0}/flag_engine/utils/types.py

@@ -3,7 +3,7 @@ from functools import singledispatch
 
 import semver
 
-from flag_engine.identities.traits.types import TraitValue
+from flag_engine.identities.traits.types import ContextValue
 from flag_engine.utils.semver import remove_semver_suffix
 
 
@@ -15,7 +15,7 @@ class SupportsStr(typing.Protocol):
 @singledispatch
 def get_casting_function(
     input_: object,
-) -> typing.Callable[..., TraitValue]:
+) -> typing.Callable[..., ContextValue]:
     """
     This function returns a callable to cast a value to the same type as input_
     >>> assert get_casting_function("a string") == str

{flagsmith-flag-engine-5.3.0 → flagsmith-flag-engine-5.4.0/flagsmith_flag_engine.egg-info}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.1
 Name: flagsmith-flag-engine
-Version: 5.3.0
+Version: 5.4.0
 Summary: Flag engine for the Flagsmith API.
 Home-page: https://github.com/Flagsmith/flagsmith-engine
 Author: Flagsmith
 Author-email: support@flagsmith.com
 License: BSD3
-Platform: UNKNOWN
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.7
@@ -36,5 +35,3 @@ python -m pip install -r requirements-dev.txt
 
 - Marshmallow Schemas
 - Plain Python
-
-

{flagsmith-flag-engine-5.3.0 → flagsmith-flag-engine-5.4.0}/flagsmith_flag_engine.egg-info/SOURCES.txt

@@ -5,6 +5,9 @@ setup.py
 flag_engine/__init__.py
 flag_engine/engine.py
 flag_engine/py.typed
+flag_engine/context/__init__.py
+flag_engine/context/mappers.py
+flag_engine/context/types.py
 flag_engine/environments/__init__.py
 flag_engine/environments/models.py
 flag_engine/environments/integrations/__init__.py
@@ -27,6 +30,7 @@ flag_engine/segments/constants.py
 flag_engine/segments/evaluator.py
 flag_engine/segments/models.py
 flag_engine/segments/types.py
+flag_engine/types/__init__.py
 flag_engine/utils/__init__.py
 flag_engine/utils/datetime.py
 flag_engine/utils/exceptions.py

{flagsmith-flag-engine-5.3.0 → flagsmith-flag-engine-5.4.0}/setup.py

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

flagsmith-flag-engine-5.3.0/flag_engine/identities/traits/models.py

@@ -1,8 +0,0 @@
-from pydantic import BaseModel, Field
-
-from flag_engine.identities.traits.types import TraitValue
-
-
-class TraitModel(BaseModel):
-    trait_key: str
-    trait_value: TraitValue = Field(...)

flagsmith-flag-engine-5.3.0/flag_engine/segments/evaluator.py

@@ -1,207 +0,0 @@
-import operator
-import re
-import typing
-from contextlib import suppress
-from functools import wraps
-
-import semver
-
-from flag_engine.environments.models import EnvironmentModel
-from flag_engine.identities.models import IdentityModel
-from flag_engine.identities.traits.models import TraitModel
-from flag_engine.identities.traits.types import TraitValue
-from flag_engine.segments import constants
-from flag_engine.segments.models import (
-    SegmentConditionModel,
-    SegmentModel,
-    SegmentRuleModel,
-)
-from flag_engine.segments.types import ConditionOperator
-from flag_engine.utils.hashing import get_hashed_percentage_for_object_ids
-from flag_engine.utils.semver import is_semver
-from flag_engine.utils.types import get_casting_function
-
-
-def get_identity_segments(
-    environment: EnvironmentModel,
-    identity: IdentityModel,
-    override_traits: typing.Optional[typing.List[TraitModel]] = None,
-) -> typing.List[SegmentModel]:
-    return list(
-        filter(
-            lambda s: evaluate_identity_in_segment(identity, s, override_traits),
-            environment.project.segments,
-        )
-    )
-
-
-def evaluate_identity_in_segment(
-    identity: IdentityModel,
-    segment: SegmentModel,
-    override_traits: typing.Optional[typing.List[TraitModel]] = None,
-) -> bool:
-    """
-    Evaluates whether a given identity is in the provided segment.
-
-    :param identity: identity model object to evaluate
-    :param segment: segment model object to evaluate
-    :param override_traits: pass in a list of traits to use instead of those on the
-        identity model itself
-    :return: True if the identity is in the segment, False otherwise
-    """
-    return len(segment.rules) > 0 and all(
-        _traits_match_segment_rule(
-            override_traits or identity.identity_traits,
-            rule,
-            segment.id,
-            identity.django_id or identity.composite_key,
-        )
-        for rule in segment.rules
-    )
-
-
-def _traits_match_segment_rule(
-    identity_traits: typing.List[TraitModel],
-    rule: SegmentRuleModel,
-    segment_id: typing.Union[int, str],
-    identity_id: typing.Union[int, str],
-) -> bool:
-    matches_conditions = (
-        rule.matching_function(
-            [
-                _traits_match_segment_condition(
-                    identity_traits, condition, segment_id, identity_id
-                )
-                for condition in rule.conditions
-            ]
-        )
-        if len(rule.conditions) > 0
-        else True
-    )
-
-    return matches_conditions and all(
-        _traits_match_segment_rule(identity_traits, rule, segment_id, identity_id)
-        for rule in rule.rules
-    )
-
-
-def _traits_match_segment_condition(
-    identity_traits: typing.List[TraitModel],
-    condition: SegmentConditionModel,
-    segment_id: typing.Union[int, str],
-    identity_id: typing.Union[int, str],
-) -> bool:
-    if condition.operator == constants.PERCENTAGE_SPLIT:
-        assert condition.value
-        float_value = float(condition.value)
-        return (
-            get_hashed_percentage_for_object_ids([segment_id, identity_id])
-            <= float_value
-        )
-
-    trait = next(
-        filter(lambda t: t.trait_key == condition.property_, identity_traits), None
-    )
-
-    if condition.operator == constants.IS_NOT_SET:
-        return trait is None
-
-    if condition.operator == constants.IS_SET:
-        return trait is not None
-
-    return _matches_trait_value(condition, trait.trait_value) if trait else False
-
-
-def _matches_trait_value(
-    condition: SegmentConditionModel,
-    trait_value: TraitValue,
-) -> bool:
-    if match_func := MATCH_FUNCS_BY_OPERATOR.get(condition.operator):
-        return match_func(condition.value, trait_value)
-
-    return False
-
-
-def _evaluate_not_contains(
-    segment_value: typing.Optional[str],
-    trait_value: TraitValue,
-) -> bool:
-    return isinstance(trait_value, str) and str(segment_value) not in trait_value
-
-
-def _evaluate_regex(
-    segment_value: typing.Optional[str],
-    trait_value: TraitValue,
-) -> bool:
-    return (
-        trait_value is not None
-        and re.compile(str(segment_value)).match(str(trait_value)) is not None
-    )
-
-
-def _evaluate_modulo(
-    segment_value: typing.Optional[str],
-    trait_value: TraitValue,
-) -> bool:
-    if not isinstance(trait_value, (int, float)):
-        return False
-
-    if segment_value is None:
-        return False
-
-    try:
-        divisor_part, remainder_part = segment_value.split("|")
-        divisor = float(divisor_part)
-        remainder = float(remainder_part)
-    except ValueError:
-        return False
-
-    return trait_value % divisor == remainder
-
-
-def _evaluate_in(segment_value: typing.Optional[str], trait_value: TraitValue) -> bool:
-    if segment_value:
-        if isinstance(trait_value, str):
-            return trait_value in segment_value.split(",")
-        if isinstance(trait_value, int) and not any(
-            trait_value is x for x in (False, True)
-        ):
-            return str(trait_value) in segment_value.split(",")
-    return False
-
-
-def _trait_value_typed(
-    func: typing.Callable[..., bool],
-) -> typing.Callable[[typing.Optional[str], TraitValue], bool]:
-    @wraps(func)
-    def inner(
-        segment_value: typing.Optional[str],
-        trait_value: typing.Union[TraitValue, semver.Version],
-    ) -> bool:
-        with suppress(TypeError, ValueError):
-            if isinstance(trait_value, str) and is_semver(segment_value):
-                trait_value = semver.Version.parse(
-                    trait_value,
-                )
-            match_value = get_casting_function(trait_value)(segment_value)
-            return func(trait_value, match_value)
-        return False
-
-    return inner
-
-
-MATCH_FUNCS_BY_OPERATOR: typing.Dict[
-    ConditionOperator, typing.Callable[[typing.Optional[str], TraitValue], bool]
-] = {
-    constants.NOT_CONTAINS: _evaluate_not_contains,
-    constants.REGEX: _evaluate_regex,
-    constants.MODULO: _evaluate_modulo,
-    constants.IN: _evaluate_in,
-    constants.EQUAL: _trait_value_typed(operator.eq),
-    constants.GREATER_THAN: _trait_value_typed(operator.gt),
-    constants.GREATER_THAN_INCLUSIVE: _trait_value_typed(operator.ge),
-    constants.LESS_THAN: _trait_value_typed(operator.lt),
-    constants.LESS_THAN_INCLUSIVE: _trait_value_typed(operator.le),
-    constants.NOT_EQUAL: _trait_value_typed(operator.ne),
-    constants.CONTAINS: _trait_value_typed(operator.contains),
-}