chore: replacing-deprecated-methods (#143)

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: Zaimwa9

flagsmith/flagsmith.py

@@ -6,11 +6,11 @@
 import pydantic
 import requests
 from flag_engine import engine
+from flag_engine.context.mappers import map_environment_identity_to_context
 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.evaluator import get_identity_segments
 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:
@@ -321,8 +329,18 @@ def _get_environment_from_api(self) -> EnvironmentModel:
     def _get_environment_flags_from_document(self) -> Flags:
         if self._environment is None:
             raise TypeError("No environment present")
-        return Flags.from_feature_state_models(
-            feature_states=engine.get_environment_feature_states(self._environment),
+        identity = self._get_identity_model(identifier="", traits=None)
+
+        context = map_environment_identity_to_context(
+            environment=self._environment,
+            identity=identity,
+            override_traits=None,
+        )
+
+        evaluation_result = engine.get_evaluation_result(context=context)
+
+        return Flags.from_evaluation_result(
+            evaluation_result=evaluation_result,
             analytics_processor=self._analytics_processor,
             default_flag_handler=self.default_flag_handler,
         )
@@ -333,13 +351,20 @@ 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,
         )
 

flagsmith/models.py

@@ -3,7 +3,7 @@
 import typing
 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
@@ -27,16 +27,15 @@ class Flag(BaseFlag):
     is_default: bool = field(default=False)
 
     @classmethod
-    def from_feature_state_model(
+    def from_evaluation_result(
         cls,
-        feature_state_model: FeatureStateModel,
-        identity_id: typing.Optional[typing.Union[str, int]] = None,
+        flag: FlagResult,
     ) -> Flag:
         return Flag(
-            enabled=feature_state_model.enabled,
-            value=feature_state_model.get_value(identity_id=identity_id),
-            feature_name=feature_state_model.feature.name,
-            feature_id=feature_state_model.feature.id,
+            enabled=flag["enabled"],
+            value=flag["value"],
+            feature_name=flag["name"],
+            feature_id=int(flag["feature_key"]),
         )
 
     @classmethod
@@ -56,22 +55,22 @@ class Flags:
     _analytics_processor: typing.Optional[AnalyticsProcessor] = None
 
     @classmethod
-    def from_feature_state_models(
+    def from_evaluation_result(
         cls,
-        feature_states: typing.Sequence[FeatureStateModel],
+        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:
-        flags = {
-            feature_state.feature.name: Flag.from_feature_state_model(
-                feature_state, identity_id=identity_id
-            )
-            for feature_state in feature_states
-        }
-
         return cls(
-            flags=flags,
+            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,
         )