refactor: Drop lazy_identity_evaluation rollback kwarg

Lazy is now the only path through ``_get_identity_flags_from_document``.
Per-flag resolution still goes via the engine's public
``get_evaluation_result`` (against a trimmed context), so callers get
the perf win without the eager fallback or the kwarg surface.

Tests pinned to the old eager path are reworked to mock
``flagsmith.models.engine.get_evaluation_result`` instead — that's
where the call lands now — and trigger evaluation via ``.all_flags()``
when they need the bulk-context call shape.

beep boop

Author: khvn26

flagsmith/flagsmith.py

@@ -83,7 +83,6 @@ def __init__(
         offline_handler: typing.Optional[OfflineHandler] = None,
         enable_realtime_updates: bool = False,
         application_metadata: typing.Optional[ApplicationMetadata] = None,
-        lazy_identity_evaluation: bool = True,
     ):
         """
         :param environment_key: The environment key obtained from Flagsmith interface.
@@ -112,11 +111,6 @@ def __init__(
             default_flag_handler if offline_mode is not set and using remote evaluation.
         :param enable_realtime_updates: Use real-time functionality via SSE as opposed to polling the API
         :param application_metadata: Optional metadata about the client application.
-        :param lazy_identity_evaluation: When True (default), ``get_identity_flags``
-            returns a lazy ``Flags`` that resolves flags on first access using a
-            precomputed segment-overrides index, rather than evaluating every
-            feature in the environment up-front. Set to False to opt back into
-            the legacy eager path if you hit a regression.
         """
 
         self.offline_mode = offline_mode
@@ -125,7 +119,6 @@ def __init__(
         self.offline_handler = offline_handler
         self.default_flag_handler = default_flag_handler
         self.enable_realtime_updates = enable_realtime_updates
-        self.lazy_identity_evaluation = lazy_identity_evaluation
         self._analytics_processor: typing.Optional[AnalyticsProcessor] = None
         self._pipeline_analytics_processor: typing.Optional[
             PipelineAnalyticsProcessor
@@ -441,25 +434,12 @@ def _get_identity_flags_from_document(
             identifier=identifier,
             traits=traits,
         )
-        if self.lazy_identity_evaluation:
-            # Lazy path: defer per-feature evaluation until the caller
-            # actually reads a flag. Hot for callers that only read one
-            # or a few flags out of a large environment.
-            return Flags.from_evaluation_context(
-                context=context,
-                overrides_index=self._segment_overrides_index,
-                analytics_processor=self._analytics_processor,
-                default_flag_handler=self.default_flag_handler,
-                pipeline_analytics_processor=self._pipeline_analytics_processor,
-                identity_identifier=identifier,
-                traits=resolve_trait_values(traits),
-            )
-        evaluation_result = engine.get_evaluation_result(
+        # Lazy: defer per-feature evaluation until the caller actually reads
+        # a flag. Hot for callers that only read one or a few flags out of a
+        # large environment.
+        return Flags.from_evaluation_context(
             context=context,
-        )
-
-        return Flags.from_evaluation_result(
-            evaluation_result=evaluation_result,
+            overrides_index=self._segment_overrides_index,
             analytics_processor=self._analytics_processor,
             default_flag_handler=self.default_flag_handler,
             pipeline_analytics_processor=self._pipeline_analytics_processor,

tests/test_flagsmith.py

@@ -191,12 +191,15 @@ def test_get_identity_flags_uses_local_environment_when_available(
     evaluation_context: SDKEvaluationContext,
     mocker: MockerFixture,
 ) -> None:
-    # Given: the eager rollback path; this test pins the engine call
-    # shape, so bypass the lazy default to exercise it.
+    # Given
     flagsmith._evaluation_context = evaluation_context
     flagsmith.enable_local_evaluation = True
-    flagsmith.lazy_identity_evaluation = False
-    mock_engine = mocker.patch("flagsmith.flagsmith.engine")
+    # ``Flags`` materialises identity flags via ``engine.get_evaluation_result``
+    # imported from ``flagsmith.models``, so patch it where it's actually used.
+    mock_get_evaluation_result = mocker.patch(
+        "flagsmith.models.engine.get_evaluation_result",
+        autospec=True,
+    )
 
     expected_evaluation_result = {
         "flags": {
@@ -213,15 +216,15 @@ def test_get_identity_flags_uses_local_environment_when_available(
     identifier = "identifier"
     traits = {"some_trait": "some_value"}
 
-    mock_engine.get_evaluation_result.return_value = expected_evaluation_result
+    mock_get_evaluation_result.return_value = expected_evaluation_result
 
     # When
     identity_flags = flagsmith.get_identity_flags(identifier, traits).all_flags()
 
     # Then
-    mock_engine.get_evaluation_result.assert_called_once()
-    call_args = mock_engine.get_evaluation_result.call_args
-    context = call_args[1]["context"]
+    mock_get_evaluation_result.assert_called_once()
+    call_args = mock_get_evaluation_result.call_args
+    context = call_args[0][0] if call_args.args else call_args[1]["context"]
     assert context["identity"]["identifier"] == identifier
     assert context["identity"]["traits"]["some_trait"] == "some_value"
     assert "some_trait" in context["identity"]["traits"]
@@ -234,11 +237,9 @@ def test_get_identity_flags_includes_segments_in_evaluation_context(
     mocker: MockerFixture,
     local_eval_flagsmith: Flagsmith,
 ) -> None:
-    # Given: eager rollback path — this test asserts what goes into the
-    # engine call directly.
-    local_eval_flagsmith.lazy_identity_evaluation = False
+    # Given
     mock_get_evaluation_result = mocker.patch(
-        "flagsmith.flagsmith.engine.get_evaluation_result",
+        "flagsmith.models.engine.get_evaluation_result",
         autospec=True,
     )
 
@@ -259,22 +260,22 @@ def test_get_identity_flags_includes_segments_in_evaluation_context(
 
     mock_get_evaluation_result.return_value = expected_evaluation_result
 
-    # When
-    local_eval_flagsmith.get_identity_flags(identifier, traits)
+    # When: ``all_flags`` triggers the bulk evaluation path on the lazy
+    # ``Flags`` object, which is where the full identity context — segments
+    # included — is passed to the engine.
+    local_eval_flagsmith.get_identity_flags(identifier, traits).all_flags()
 
-    # Then
-    # Verify segments are present in the context passed to the engine for identity flags
+    # Then: segments are present in the context passed to the engine for
+    # identity flags (in contrast to the env-flags path, which strips them).
     call_args = mock_get_evaluation_result.call_args
-    context = call_args[1]["context"]
+    context = call_args[0][0] if call_args.args else call_args[1]["context"]
     assert "segments" in context
 
 
-def test_get_identity_flags__lazy_by_default__resolves_one_flag_at_a_time(
+def test_get_identity_flags__resolves_one_flag_at_a_time(
     local_eval_flagsmith: Flagsmith,
     mocker: MockerFixture,
 ) -> None:
-    # Given: the lazy path is on by default.
-    assert local_eval_flagsmith.lazy_identity_evaluation is True
     spy = mocker.spy(engine, "get_evaluation_result")
 
     # When: we ask for identity flags but never touch a specific flag...
@@ -296,28 +297,6 @@ def test_get_identity_flags__lazy_by_default__resolves_one_flag_at_a_time(
     assert set(trimmed_context["features"]) == {"some_feature"}
 
 
-def test_get_identity_flags__lazy_disabled__falls_back_to_eager_path(
-    requests_session_response_ok: None,
-    server_api_key: str,
-    mocker: MockerFixture,
-) -> None:
-    # Given: lazy evaluation is explicitly turned off (rollback kwarg).
-    flagsmith = Flagsmith(
-        environment_key=server_api_key,
-        enable_local_evaluation=True,
-        environment_refresh_interval_seconds=0.1,
-        lazy_identity_evaluation=False,
-    )
-    spy = mocker.spy(engine, "get_evaluation_result")
-
-    # When
-    flags = flagsmith.get_identity_flags("someone")
-
-    # Then: the bulk evaluation ran up-front and every flag is resolved.
-    assert spy.call_count == 1
-    assert set(flags.flags.keys()) == {"some_feature"}
-
-
 @responses.activate()
 def test_get_identity_flags__transient_identity__calls_expected(
     flagsmith: Flagsmith,