style: Use single backticks in comments and docstrings

beep boop

Author: khvn26

flagsmith/models.py

@@ -88,11 +88,11 @@ class Flags:
     _pipeline_analytics_processor: typing.Optional[PipelineAnalyticsProcessor] = None
     _identity_identifier: typing.Optional[str] = None
     _traits: typing.Optional[typing.Dict[str, typing.Any]] = None
-    # Lazy-evaluation state. When ``_context`` is set, ``flags`` is a
+    # Lazy-evaluation state. When `_context` is set, `flags` is a
     # per-feature memo rather than a fully-materialised snapshot; unseen
     # features are resolved on demand via the engine primitives and
-    # cached back into ``flags``. Left as ``None`` by the eager code
-    # paths (``from_evaluation_result`` / ``from_api_flags``).
+    # cached back into `flags`. Left as `None` by the eager code
+    # paths (`from_evaluation_result` / `from_api_flags`).
     _context: typing.Optional[SDKEvaluationContext] = None
     _overrides_index: typing.Optional[SegmentOverridesIndex] = None
     _fully_materialised: bool = False
@@ -135,10 +135,10 @@ def from_evaluation_context(
         identity_identifier: typing.Optional[str] = None,
         traits: typing.Optional[typing.Dict[str, typing.Any]] = None,
     ) -> Flags:
-        """Build a lazy ``Flags`` backed by an evaluation context.
+        """Build a lazy `Flags` backed by an evaluation context.
 
         No engine work is done here — flags are resolved on first access
-        via :meth:`_resolve_flag`. Reusing the same ``overrides_index``
+        via :meth:`_resolve_flag`. Reusing the same `overrides_index`
         across calls amortises its construction cost (it's rebuilt only
         when the environment doc refreshes, not per identity).
         """
@@ -231,7 +231,7 @@ def get_flag(self, feature_name: str) -> typing.Union[DefaultFlag, Flag]:
         try:
             flag = self.flags[feature_name]
         except KeyError:
-            # Lazy path: if this ``Flags`` wraps an evaluation context and
+            # Lazy path: if this `Flags` wraps an evaluation context and
             # the feature exists in it, resolve and memoise now. Otherwise
             # fall through to the default_flag_handler / not-found error,
             # preserving the eager-mode behaviour byte-for-byte.
@@ -266,7 +266,7 @@ def get_flag(self, feature_name: str) -> typing.Union[DefaultFlag, Flag]:
     def _resolve_flag(self, feature_name: str) -> Flag:
         """Evaluate a single feature against the lazy context.
 
-        Goes through the engine's public ``get_evaluation_result`` so
+        Goes through the engine's public `get_evaluation_result` so
         identity-key enrichment, multivariate hashing, percentage-split
         rules and override-priority handling all stay where they
         belong (in the engine). The performance win comes from passing
@@ -277,7 +277,7 @@ def _resolve_flag(self, feature_name: str) -> Flag:
         """
         context = self._context
         overrides_index = self._overrides_index
-        # ``get_flag`` / ``all_flags`` gate this call behind the same
+        # `get_flag` / `all_flags` gate this call behind the same
         # non-None checks; assert here so type checkers can narrow.
         assert context is not None and overrides_index is not None
 

tests/test_flagsmith.py

@@ -194,8 +194,8 @@ def test_get_identity_flags_uses_local_environment_when_available(
     # Given
     flagsmith._evaluation_context = evaluation_context
     flagsmith.enable_local_evaluation = True
-    # ``Flags`` materialises identity flags via ``engine.get_evaluation_result``
-    # imported from ``flagsmith.models``, so patch it where it's actually used.
+    # `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,
@@ -260,8 +260,8 @@ def test_get_identity_flags_includes_segments_in_evaluation_context(
 
     mock_get_evaluation_result.return_value = expected_evaluation_result
 
-    # When: ``all_flags`` triggers the bulk evaluation path on the lazy
-    # ``Flags`` object, which is where the full identity context — segments
+    # 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()
 

tests/test_models.py

@@ -179,9 +179,9 @@ def test_get_flag_without_pipeline_processor() -> None:
 def lazy_context_factory() -> LazyContextFactory:
     """Factory for minimal evaluation contexts used by the lazy-Flags tests.
 
-    The returned context has a ``target`` feature with a single segment
-    override (matches when ``tier == segment_match_value``, priority 0)
-    plus ``extra_features`` no-override "noise" features whose values
+    The returned context has a `target` feature with a single segment
+    override (matches when `tier == segment_match_value`, priority 0)
+    plus `extra_features` no-override "noise" features whose values
     should come straight off the base feature context.
     """
 
@@ -259,7 +259,7 @@ def lazy_context(
 
 @pytest.fixture
 def lazy_flags(lazy_context: SDKEvaluationContext) -> Flags:
-    """Lazy ``Flags`` built from the default context, no analytics, no handler."""
+    """Lazy `Flags` built from the default context, no analytics, no handler."""
     return Flags.from_evaluation_context(
         context=lazy_context,
         overrides_index=build_segment_overrides_index(lazy_context),