chore: replacing-deprecated-methods

flagsmith/flagsmith.py

@@ -10,7 +10,7 @@
 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.evaluator import get_identity_segments
+from flag_engine.context.mappers import map_environment_identity_to_context
 from requests.adapters import HTTPAdapter
 from requests.utils import default_user_agent
 from urllib3 import Retry
@@ -280,10 +280,18 @@ def get_identity_segments(
 
         traits = traits or {}
         identity_model = self._get_identity_model(identifier, **traits)
-        segment_models = get_identity_segments(
-            environment=self._environment, identity=identity_model
+        context = map_environment_identity_to_context(
+            environment=self._environment,
+            identity=identity_model,
+            override_traits=None,
         )
-        return [Segment(id=sm.id, name=sm.name) for sm in segment_models]
+        evaluation_result = engine.get_evaluation_result(
+            context=context,
+        )
+        return [
+            Segment(id=int(sm["key"]), name=sm["name"])
+            for sm in evaluation_result.get("segments", [])
+        ]
 
     def update_environment(self) -> None:
         try:
@@ -322,6 +330,7 @@ def _get_environment_flags_from_document(self) -> Flags:
         if self._environment is None:
             raise TypeError("No environment present")
         return Flags.from_feature_state_models(
+            # TODO: Use from_evaluation_result
             feature_states=engine.get_environment_feature_states(self._environment),
             analytics_processor=self._analytics_processor,
             default_flag_handler=self.default_flag_handler,
@@ -333,14 +342,21 @@ def _get_identity_flags_from_document(
         identity_model = self._get_identity_model(identifier, **traits)
         if self._environment is None:
             raise TypeError("No environment present")
-        feature_states = engine.get_identity_feature_states(
-            self._environment, identity_model
+        context = map_environment_identity_to_context(
+            environment=self._environment,
+            identity=identity_model,
+            override_traits=None,
         )
-        return Flags.from_feature_state_models(
-            feature_states=feature_states,
+
+        evaluation_result = engine.get_evaluation_result(
+            context=context,
+        )
+
+        return Flags.from_evaluation_result(
+            evaluation_result=evaluation_result,
             analytics_processor=self._analytics_processor,
-            identity_id=identity_model.composite_key,
             default_flag_handler=self.default_flag_handler,
+            identity_id=identity_model.composite_key,
         )
 
     def _get_environment_flags_from_api(self) -> Flags:

flagsmith/models.py

@@ -4,7 +4,7 @@
 from dataclasses import dataclass, field
 
 from flag_engine.features.models import FeatureStateModel
-
+from flag_engine.result.types import EvaluationResult, FlagResult
 from flagsmith.analytics import AnalyticsProcessor
 from flagsmith.exceptions import FlagsmithFeatureDoesNotExistError
 
@@ -39,6 +39,19 @@ def from_feature_state_model(
             feature_id=feature_state_model.feature.id,
         )
 
+    @classmethod
+    def from_evaluation_result(
+        cls,
+        flag: FlagResult,
+        identity_id: typing.Optional[typing.Union[str, int]] = None,
+    ) -> Flag:
+        return Flag(
+            enabled=flag["enabled"],
+            value=flag["value"],
+            feature_name=flag["name"],
+            feature_id=int(flag["feature_key"]),
+        )
+
     @classmethod
     def from_api_flag(cls, flag_data: typing.Mapping[str, typing.Any]) -> Flag:
         return Flag(
@@ -76,6 +89,28 @@ def from_feature_state_models(
             _analytics_processor=analytics_processor,
         )
 
+    @classmethod
+    def from_evaluation_result(
+        cls,
+        evaluation_result: EvaluationResult,
+        analytics_processor: typing.Optional[AnalyticsProcessor],
+        default_flag_handler: typing.Optional[typing.Callable[[str], DefaultFlag]],
+        identity_id: typing.Optional[typing.Union[str, int]] = None,
+    ) -> Flags:
+        return cls(
+            flags={
+                flag["name"]: Flag(
+                    enabled=flag["enabled"],
+                    value=flag["value"],
+                    feature_name=flag["name"],
+                    feature_id=int(flag["feature_key"]),
+                )
+                for flag in evaluation_result["flags"]
+            },
+            default_flag_handler=default_flag_handler,
+            _analytics_processor=analytics_processor,
+        )
+
     @classmethod
     def from_api_flags(
         cls,