flagsmith 3.5.0__tar.gz → 3.7.0__tar.gz

{flagsmith-3.5.0 → flagsmith-3.7.0}/PKG-INFO

@@ -1,23 +1,22 @@
 Metadata-Version: 2.1
 Name: flagsmith
-Version: 3.5.0
+Version: 3.7.0
 Summary: Flagsmith Python SDK
 License: BSD3
 Keywords: feature,flag,flagsmith,remote,config
 Author: Flagsmith
 Author-email: support@flagsmith.com
-Requires-Python: >=3.7.0,<4
+Requires-Python: >=3.8.1,<4
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: flagsmith-flag-engine (>=5.0.0,<6.0.0)
+Requires-Dist: flagsmith-flag-engine (>=5.1.0,<6.0.0)
 Requires-Dist: requests (>=2.27.1,<3.0.0)
 Requires-Dist: requests-futures (>=1.0.0,<2.0.0)
+Requires-Dist: sseclient-py (>=1.8.0,<2.0.0)
 Project-URL: Documentation, https://docs.flagsmith.com
 Description-Content-Type: text/markdown
 
@@ -33,11 +32,11 @@ The SDK for Python applications for [https://www.flagsmith.com/](https://www.fla
 ## Adding to your project
 
 For full documentation visit
-[https://docs.flagsmith.com/clients/server-side](https://docs.flagsmith.com/clients/server-side).
+[https://docs.flagsmith.com/clients/server-side?language=python](https://docs.flagsmith.com/clients/server-side?language=python).
 
 ## Contributing
 
-Please read [CONTRIBUTING.md](https://gist.github.com/kyle-ssg/c36a03aebe492e45cbd3eefb21cb0486) for details on our code
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code
 of conduct, and the process for submitting pull requests
 
 ## Getting Help

flagsmith-3.5.0/Readme.md → flagsmith-3.7.0/README.md

@@ -10,11 +10,11 @@ The SDK for Python applications for [https://www.flagsmith.com/](https://www.fla
 ## Adding to your project
 
 For full documentation visit
-[https://docs.flagsmith.com/clients/server-side](https://docs.flagsmith.com/clients/server-side).
+[https://docs.flagsmith.com/clients/server-side?language=python](https://docs.flagsmith.com/clients/server-side?language=python).
 
 ## Contributing
 
-Please read [CONTRIBUTING.md](https://gist.github.com/kyle-ssg/c36a03aebe492e45cbd3eefb21cb0486) for details on our code
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code
 of conduct, and the process for submitting pull requests
 
 ## Getting Help

flagsmith-3.7.0/flagsmith/__init__.py

@@ -0,0 +1,3 @@
+from .flagsmith import Flagsmith
+
+__all__ = ("Flagsmith",)

{flagsmith-3.5.0 → flagsmith-3.7.0}/flagsmith/analytics.py

@@ -1,12 +1,13 @@
 import json
+import typing
 from datetime import datetime
 
-from requests_futures.sessions import FuturesSession
+from requests_futures.sessions import FuturesSession  # type: ignore
 
-ANALYTICS_ENDPOINT = "analytics/flags/"
+ANALYTICS_ENDPOINT: typing.Final[str] = "analytics/flags/"
 
 # Used to control how often we send data(in seconds)
-ANALYTICS_TIMER = 10
+ANALYTICS_TIMER: typing.Final[int] = 10
 
 session = FuturesSession(max_workers=4)
 
@@ -17,7 +18,9 @@ class AnalyticsProcessor:
     the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.
     """
 
-    def __init__(self, environment_key: str, base_api_url: str, timeout: int = 3):
+    def __init__(
+        self, environment_key: str, base_api_url: str, timeout: typing.Optional[int] = 3
+    ):
         """
         Initialise the AnalyticsProcessor to handle sending analytics on flag usage to
         the Flagsmith API.
@@ -30,10 +33,10 @@ class AnalyticsProcessor:
         self.analytics_endpoint = base_api_url + ANALYTICS_ENDPOINT
         self.environment_key = environment_key
         self._last_flushed = datetime.now()
-        self.analytics_data = {}
-        self.timeout = timeout
+        self.analytics_data: typing.MutableMapping[str, typing.Any] = {}
+        self.timeout = timeout or 3
 
-    def flush(self):
+    def flush(self) -> None:
         """
         Sends all the collected data to the api asynchronously and resets the timer
         """
@@ -53,7 +56,7 @@ class AnalyticsProcessor:
         self.analytics_data.clear()
         self._last_flushed = datetime.now()
 
-    def track_feature(self, feature_name: str):
+    def track_feature(self, feature_name: str) -> None:
         self.analytics_data[feature_name] = self.analytics_data.get(feature_name, 0) + 1
         if (datetime.now() - self._last_flushed).seconds > ANALYTICS_TIMER:
             self.flush()

{flagsmith-3.5.0 → flagsmith-3.7.0}/flagsmith/exceptions.py

@@ -4,3 +4,7 @@ class FlagsmithClientError(Exception):
 
 class FlagsmithAPIError(FlagsmithClientError):
     pass
+
+
+class FlagsmithFeatureDoesNotExistError(FlagsmithClientError):
+    pass

{flagsmith-3.5.0 → flagsmith-3.7.0}/flagsmith/flagsmith.py

@@ -1,11 +1,14 @@
+import json
 import logging
 import typing
-from json import JSONDecodeError
+from datetime import datetime, timezone
 
 import requests
 from flag_engine import engine
 from flag_engine.environments.models import EnvironmentModel
-from flag_engine.identities.models import IdentityModel, TraitModel
+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 urllib3 import Retry
@@ -15,11 +18,23 @@ from flagsmith.exceptions import FlagsmithAPIError, FlagsmithClientError
 from flagsmith.models import DefaultFlag, Flags, Segment
 from flagsmith.offline_handlers import BaseOfflineHandler
 from flagsmith.polling_manager import EnvironmentDataPollingManager
-from flagsmith.utils.identities import generate_identities_data
+from flagsmith.streaming_manager import EventStreamManager, StreamEvent
+from flagsmith.utils.identities import Identity, generate_identities_data
 
 logger = logging.getLogger(__name__)
 
 DEFAULT_API_URL = "https://edge.api.flagsmith.com/api/v1/"
+DEFAULT_REALTIME_API_URL = "https://realtime.flagsmith.com/"
+
+JsonType = typing.Union[
+    None,
+    int,
+    str,
+    bool,
+    typing.List["JsonType"],
+    typing.List[typing.Mapping[str, "JsonType"]],
+    typing.Dict[str, "JsonType"],
+]
 
 
 class Flagsmith:
@@ -39,23 +54,28 @@ class Flagsmith:
 
     def __init__(
         self,
-        environment_key: str = None,
-        api_url: str = None,
-        custom_headers: typing.Dict[str, typing.Any] = None,
-        request_timeout_seconds: int = None,
+        environment_key: typing.Optional[str] = None,
+        api_url: typing.Optional[str] = None,
+        realtime_api_url: typing.Optional[str] = None,
+        custom_headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        request_timeout_seconds: typing.Optional[int] = None,
         enable_local_evaluation: bool = False,
         environment_refresh_interval_seconds: typing.Union[int, float] = 60,
-        retries: Retry = None,
+        retries: typing.Optional[Retry] = None,
         enable_analytics: bool = False,
-        default_flag_handler: typing.Callable[[str], DefaultFlag] = None,
-        proxies: typing.Dict[str, str] = None,
+        default_flag_handler: typing.Optional[
+            typing.Callable[[str], DefaultFlag]
+        ] = None,
+        proxies: typing.Optional[typing.Dict[str, str]] = None,
         offline_mode: bool = False,
-        offline_handler: BaseOfflineHandler = None,
+        offline_handler: typing.Optional[BaseOfflineHandler] = None,
+        enable_realtime_updates: bool = False,
     ):
         """
         :param environment_key: The environment key obtained from Flagsmith interface.
             Required unless offline_mode is True.
         :param api_url: Override the URL of the Flagsmith API to communicate with
+        :param realtime_api_url: Override the URL of the Flagsmith real-time API
         :param custom_headers: Additional headers to add to requests made to the
             Flagsmith API
         :param request_timeout_seconds: Number of seconds to wait for a request to
@@ -76,14 +96,18 @@ class Flagsmith:
         :param offline_handler: provide a handler for offline logic. Used to get environment
             document from another source when in offline_mode. Works in place of
             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
         """
 
         self.offline_mode = offline_mode
         self.enable_local_evaluation = enable_local_evaluation
+        self.environment_refresh_interval_seconds = environment_refresh_interval_seconds
         self.offline_handler = offline_handler
         self.default_flag_handler = default_flag_handler
-        self._analytics_processor = None
-        self._environment = None
+        self.enable_realtime_updates = enable_realtime_updates
+        self._analytics_processor: typing.Optional[AnalyticsProcessor] = None
+        self._environment: typing.Optional[EnvironmentModel] = None
+        self._identity_overrides_by_identifier: typing.Dict[str, IdentityModel] = {}
 
         # argument validation
         if offline_mode and not offline_handler:
@@ -93,6 +117,11 @@ class Flagsmith:
                 "Cannot use both default_flag_handler and offline_handler."
             )
 
+        if enable_realtime_updates and not enable_local_evaluation:
+            raise ValueError(
+                "Can only use realtime updates when running in local evaluation mode."
+            )
+
         if self.offline_handler:
             self._environment = self.offline_handler.get_environment()
 
@@ -110,6 +139,13 @@ class Flagsmith:
             api_url = api_url or DEFAULT_API_URL
             self.api_url = api_url if api_url.endswith("/") else f"{api_url}/"
 
+            realtime_api_url = realtime_api_url or DEFAULT_REALTIME_API_URL
+            self.realtime_api_url = (
+                realtime_api_url
+                if realtime_api_url.endswith("/")
+                else f"{realtime_api_url}/"
+            )
+
             self.request_timeout_seconds = request_timeout_seconds
             self.session.mount(self.api_url, HTTPAdapter(max_retries=retries))
 
@@ -124,20 +160,70 @@ class Flagsmith:
                         "in the environment settings page."
                     )
 
-                self.environment_data_polling_manager_thread = (
-                    EnvironmentDataPollingManager(
-                        main=self,
-                        refresh_interval_seconds=environment_refresh_interval_seconds,
-                        daemon=True,  # noqa
-                    )
-                )
-                self.environment_data_polling_manager_thread.start()
+                self._initialise_local_evaluation()
 
             if enable_analytics:
                 self._analytics_processor = AnalyticsProcessor(
                     environment_key, self.api_url, timeout=self.request_timeout_seconds
                 )
 
+    def _initialise_local_evaluation(self) -> None:
+        if self.enable_realtime_updates:
+            self.update_environment()
+            if not self._environment:
+                raise ValueError("Unable to get environment from API key")
+
+            stream_url = f"{self.realtime_api_url}sse/environments/{self._environment.api_key}/stream"
+
+            self.event_stream_thread = EventStreamManager(
+                stream_url=stream_url,
+                on_event=self.handle_stream_event,
+                daemon=True,
+            )
+
+            self.event_stream_thread.start()
+
+        else:
+            # To ensure that the environment is set before allowing subsequent
+            # method calls, update the environment manually.
+            self.update_environment()
+            self.environment_data_polling_manager_thread = (
+                EnvironmentDataPollingManager(
+                    main=self,
+                    refresh_interval_seconds=self.environment_refresh_interval_seconds,
+                    daemon=True,
+                )
+            )
+
+            self.environment_data_polling_manager_thread.start()
+
+    def handle_stream_event(self, event: StreamEvent) -> None:
+        try:
+            event_data = json.loads(event.data)
+        except json.JSONDecodeError as e:
+            raise FlagsmithAPIError("Unable to get valid json from event data.") from e
+
+        try:
+            stream_updated_at = datetime.fromtimestamp(event_data.get("updated_at"))
+        except TypeError as e:
+            raise FlagsmithAPIError(
+                "Unable to get valid timestamp from event data."
+            ) from e
+
+        if stream_updated_at.tzinfo is None:
+            stream_updated_at = stream_updated_at.astimezone(timezone.utc)
+
+        if not self._environment:
+            raise ValueError(
+                "Unable to access environment. Environment should not be null"
+            )
+        environment_updated_at = self._environment.updated_at
+        if environment_updated_at.tzinfo is None:
+            environment_updated_at = environment_updated_at.astimezone(timezone.utc)
+
+        if stream_updated_at > environment_updated_at:
+            self.update_environment()
+
     def get_environment_flags(self) -> Flags:
         """
         Get all the default for flags for the current environment.
@@ -149,7 +235,9 @@ class Flagsmith:
         return self._get_environment_flags_from_api()
 
     def get_identity_flags(
-        self, identifier: str, traits: typing.Dict[str, typing.Any] = None
+        self,
+        identifier: str,
+        traits: typing.Optional[typing.Mapping[str, TraitValue]] = None,
     ) -> Flags:
         """
         Get all the flags for the current environment for a given identity. Will also
@@ -168,7 +256,9 @@ class Flagsmith:
         return self._get_identity_flags_from_api(identifier, traits)
 
     def get_identity_segments(
-        self, identifier: str, traits: typing.Dict[str, typing.Any] = None
+        self,
+        identifier: str,
+        traits: typing.Optional[typing.Mapping[str, TraitValue]] = None,
     ) -> typing.List[Segment]:
         """
         Get a list of segments that the given identity is in.
@@ -186,18 +276,29 @@ class Flagsmith:
             )
 
         traits = traits or {}
-        identity_model = self._build_identity_model(identifier, **traits)
+        identity_model = self._get_identity_model(identifier, **traits)
         segment_models = get_identity_segments(self._environment, identity_model)
         return [Segment(id=sm.id, name=sm.name) for sm in segment_models]
 
-    def update_environment(self):
+    def update_environment(self) -> None:
         self._environment = self._get_environment_from_api()
+        self._update_overrides()
+
+    def _update_overrides(self) -> None:
+        if not self._environment:
+            return
+        if overrides := self._environment.identity_overrides:
+            self._identity_overrides_by_identifier = {
+                identity.identifier: identity for identity in overrides
+            }
 
     def _get_environment_from_api(self) -> EnvironmentModel:
         environment_data = self._get_json_response(self.environment_url, method="GET")
         return EnvironmentModel.model_validate(environment_data)
 
     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),
             analytics_processor=self._analytics_processor,
@@ -205,9 +306,11 @@ class Flagsmith:
         )
 
     def _get_identity_flags_from_document(
-        self, identifier: str, traits: typing.Dict[str, typing.Any]
+        self, identifier: str, traits: typing.Mapping[str, TraitValue]
     ) -> Flags:
-        identity_model = self._build_identity_model(identifier, **traits)
+        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
         )
@@ -220,11 +323,11 @@ class Flagsmith:
 
     def _get_environment_flags_from_api(self) -> Flags:
         try:
-            api_flags = self._get_json_response(
-                url=self.environment_flags_url, method="GET"
+            json_response: typing.List[typing.Mapping[str, JsonType]] = (
+                self._get_json_response(url=self.environment_flags_url, method="GET")
             )
             return Flags.from_api_flags(
-                api_flags=api_flags,
+                api_flags=json_response,
                 analytics_processor=self._analytics_processor,
                 default_flag_handler=self.default_flag_handler,
             )
@@ -236,12 +339,14 @@ class Flagsmith:
             raise
 
     def _get_identity_flags_from_api(
-        self, identifier: str, traits: typing.Dict[str, typing.Any]
+        self, identifier: str, traits: typing.Mapping[str, typing.Any]
     ) -> Flags:
         try:
             data = generate_identities_data(identifier, traits)
-            json_response = self._get_json_response(
-                url=self.identities_url, method="POST", body=data
+            json_response: typing.Dict[str, typing.List[typing.Dict[str, JsonType]]] = (
+                self._get_json_response(
+                    url=self.identities_url, method="POST", body=data
+                )
             )
             return Flags.from_api_flags(
                 api_flags=json_response["flags"],
@@ -255,7 +360,14 @@ class Flagsmith:
                 return Flags(default_flag_handler=self.default_flag_handler)
             raise
 
-    def _get_json_response(self, url: str, method: str, body: dict = None):
+    def _get_json_response(
+        self,
+        url: str,
+        method: str,
+        body: typing.Optional[
+            typing.Union[Identity, typing.Dict[str, JsonType]]
+        ] = None,
+    ) -> typing.Any:
         try:
             request_method = getattr(self.session, method.lower())
             response = request_method(
@@ -267,12 +379,16 @@ class Flagsmith:
                     response.status_code,
                 )
             return response.json()
-        except (requests.ConnectionError, JSONDecodeError) as e:
+        except (requests.ConnectionError, json.JSONDecodeError) as e:
             raise FlagsmithAPIError(
                 "Unable to get valid response from Flagsmith API."
             ) from e
 
-    def _build_identity_model(self, identifier: str, **traits):
+    def _get_identity_model(
+        self,
+        identifier: str,
+        **traits: TraitValue,
+    ) -> IdentityModel:
         if not self._environment:
             raise FlagsmithClientError(
                 "Unable to build identity model when no local environment present."
@@ -282,12 +398,20 @@ class Flagsmith:
             TraitModel(trait_key=key, trait_value=value)
             for key, value in traits.items()
         ]
+
+        if identity := self._identity_overrides_by_identifier.get(identifier):
+            identity.update_traits(trait_models)
+            return identity
+
         return IdentityModel(
             identifier=identifier,
             environment_api_key=self._environment.api_key,
             identity_traits=trait_models,
         )
 
-    def __del__(self):
+    def __del__(self) -> None:
         if hasattr(self, "environment_data_polling_manager_thread"):
             self.environment_data_polling_manager_thread.stop()
+
+        if hasattr(self, "event_stream_thread"):
+            self.event_stream_thread.stop()

{flagsmith-3.5.0 → flagsmith-3.7.0}/flagsmith/models.py

@@ -1,36 +1,37 @@
+from __future__ import annotations
+
 import typing
 from dataclasses import dataclass, field
 
 from flag_engine.features.models import FeatureStateModel
 
 from flagsmith.analytics import AnalyticsProcessor
-from flagsmith.exceptions import FlagsmithClientError
+from flagsmith.exceptions import FlagsmithFeatureDoesNotExistError
 
 
 @dataclass
 class BaseFlag:
     enabled: bool
-    value: typing.Union[str, int, float, bool, type(None)]
-    is_default: bool
+    value: typing.Union[str, int, float, bool, None]
 
 
+@dataclass
 class DefaultFlag(BaseFlag):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, is_default=True, **kwargs)
+    is_default: bool = field(default=True)
 
 
+@dataclass
 class Flag(BaseFlag):
-    def __init__(self, *args, feature_id: int, feature_name: str, **kwargs):
-        super().__init__(*args, is_default=False, **kwargs)
-        self.feature_id = feature_id
-        self.feature_name = feature_name
+    feature_id: int
+    feature_name: str
+    is_default: bool = field(default=False)
 
     @classmethod
     def from_feature_state_model(
         cls,
         feature_state_model: FeatureStateModel,
-        identity_id: typing.Union[str, int] = None,
-    ) -> "Flag":
+        identity_id: typing.Optional[typing.Union[str, int]] = None,
+    ) -> Flag:
         return Flag(
             enabled=feature_state_model.enabled,
             value=feature_state_model.get_value(identity_id=identity_id),
@@ -39,7 +40,7 @@ class Flag(BaseFlag):
         )
 
     @classmethod
-    def from_api_flag(cls, flag_data: dict) -> "Flag":
+    def from_api_flag(cls, flag_data: typing.Mapping[str, typing.Any]) -> Flag:
         return Flag(
             enabled=flag_data["enabled"],
             value=flag_data["feature_state_value"],
@@ -51,17 +52,17 @@ class Flag(BaseFlag):
 @dataclass
 class Flags:
     flags: typing.Dict[str, Flag] = field(default_factory=dict)
-    default_flag_handler: typing.Callable[[str], DefaultFlag] = None
-    _analytics_processor: AnalyticsProcessor = None
+    default_flag_handler: typing.Optional[typing.Callable[[str], DefaultFlag]] = None
+    _analytics_processor: typing.Optional[AnalyticsProcessor] = None
 
     @classmethod
     def from_feature_state_models(
         cls,
-        feature_states: typing.List[FeatureStateModel],
-        analytics_processor: AnalyticsProcessor,
-        default_flag_handler: typing.Callable,
-        identity_id: typing.Union[str, int] = None,
-    ) -> "Flags":
+        feature_states: typing.Sequence[FeatureStateModel],
+        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
@@ -78,10 +79,10 @@ class Flags:
     @classmethod
     def from_api_flags(
         cls,
-        api_flags: typing.List[dict],
-        analytics_processor: AnalyticsProcessor,
-        default_flag_handler: typing.Callable,
-    ) -> "Flags":
+        api_flags: typing.Sequence[typing.Mapping[str, typing.Any]],
+        analytics_processor: typing.Optional[AnalyticsProcessor],
+        default_flag_handler: typing.Optional[typing.Callable[[str], DefaultFlag]],
+    ) -> Flags:
         flags = {
             flag_data["feature"]["name"]: Flag.from_api_flag(flag_data)
             for flag_data in api_flags
@@ -121,12 +122,12 @@ class Flags:
         """
         return self.get_flag(feature_name).value
 
-    def get_flag(self, feature_name: str) -> BaseFlag:
+    def get_flag(self, feature_name: str) -> typing.Union[DefaultFlag, Flag]:
         """
         Get a specific flag given the feature name.
 
         :param feature_name: the name of the feature to retrieve the flag for.
-        :return: BaseFlag object.
+        :return: DefaultFlag | Flag object.
         :raises FlagsmithClientError: if feature doesn't exist
         """
         try:
@@ -134,7 +135,9 @@ class Flags:
         except KeyError:
             if self.default_flag_handler:
                 return self.default_flag_handler(feature_name)
-            raise FlagsmithClientError("Feature does not exist: %s" % feature_name)
+            raise FlagsmithFeatureDoesNotExistError(
+                "Feature does not exist: %s" % feature_name
+            )
 
         if self._analytics_processor and hasattr(flag, "feature_name"):
             self._analytics_processor.track_feature(flag.feature_name)

{flagsmith-3.5.0 → flagsmith-3.7.0}/flagsmith/polling_manager.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import threading
 import time
@@ -16,10 +18,10 @@ logger = logging.getLogger(__name__)
 class EnvironmentDataPollingManager(threading.Thread):
     def __init__(
         self,
-        *args,
-        main: "Flagsmith",
+        *args: typing.Any,
+        main: Flagsmith,
         refresh_interval_seconds: typing.Union[int, float] = 10,
-        **kwargs
+        **kwargs: typing.Any,
     ):
         super(EnvironmentDataPollingManager, self).__init__(*args, **kwargs)
         self._stop_event = threading.Event()
@@ -37,5 +39,5 @@ class EnvironmentDataPollingManager(threading.Thread):
     def stop(self) -> None:
         self._stop_event.set()
 
-    def __del__(self):
+    def __del__(self) -> None:
         self._stop_event.set()

flagsmith-3.7.0/flagsmith/streaming_manager.py

@@ -0,0 +1,58 @@
+import logging
+import threading
+import typing
+from typing import Callable, Generator, Optional, Protocol, cast
+
+import requests
+import sseclient
+
+from flagsmith.exceptions import FlagsmithAPIError
+
+logger = logging.getLogger(__name__)
+
+
+class StreamEvent(Protocol):
+    data: str
+
+
+class EventStreamManager(threading.Thread):
+    def __init__(
+        self,
+        *args: typing.Any,
+        stream_url: str,
+        on_event: Callable[[StreamEvent], None],
+        request_timeout_seconds: Optional[int] = None,
+        **kwargs: typing.Any
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self._stop_event = threading.Event()
+        self.stream_url = stream_url
+        self.on_event = on_event
+        self.request_timeout_seconds = request_timeout_seconds
+
+    def run(self) -> None:
+        while not self._stop_event.is_set():
+            try:
+                with requests.get(
+                    self.stream_url,
+                    stream=True,
+                    headers={"Accept": "application/json, text/event-stream"},
+                    timeout=self.request_timeout_seconds,
+                ) as response:
+                    sse_client = sseclient.SSEClient(
+                        cast(Generator[bytes, None, None], response)
+                    )
+                    for event in sse_client.events():
+                        self.on_event(event)
+
+            except requests.exceptions.ReadTimeout:
+                pass
+
+            except (FlagsmithAPIError, requests.RequestException):
+                logger.exception("Error handling event stream")
+
+    def stop(self) -> None:
+        self._stop_event.set()
+
+    def __del__(self) -> None:
+        self._stop_event.set()

flagsmith-3.7.0/flagsmith/utils/identities.py

@@ -0,0 +1,21 @@
+import typing
+
+from flag_engine.identities.traits.types import TraitValue
+
+Identity = typing.TypedDict(
+    "Identity",
+    {"identifier": str, "traits": typing.List[typing.Mapping[str, TraitValue]]},
+)
+
+
+def generate_identities_data(
+    identifier: str, traits: typing.Optional[typing.Mapping[str, TraitValue]] = None
+) -> Identity:
+    return {
+        "identifier": identifier,
+        "traits": (
+            [{"trait_key": k, "trait_value": v} for k, v in traits.items()]
+            if traits
+            else []
+        ),
+    }

{flagsmith-3.5.0 → flagsmith-3.7.0}/pyproject.toml

@@ -1,31 +1,40 @@
 [tool.poetry]
 name = "flagsmith"
-version = "3.5.0"
+version = "3.7.0"
 description = "Flagsmith Python SDK"
 authors = ["Flagsmith <support@flagsmith.com>"]
 license = "BSD3"
-readme = "Readme.md"
+readme = "README.md"
 keywords = ["feature", "flag", "flagsmith", "remote", "config"]
 documentation = "https://docs.flagsmith.com"
 packages = [{ include = "flagsmith" }]
 
 [tool.poetry.dependencies]
-python = ">=3.7.0,<4"
+python = ">=3.8.1,<4"
 requests = "^2.27.1"
 requests-futures = "^1.0.0"
-flagsmith-flag-engine = "^5.0.0"
+flagsmith-flag-engine = "^5.1.0"
+sseclient-py = "^1.8.0"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev]
+optional = true
+
+[tool.poetry.group.dev.dependencies]
 pytest = "^7.4.0"
 pytest-mock = "^3.6.1"
-black = "^23.3.0"
+black = ">=23.3,<25.0"
 pre-commit = "^2.17.0"
-responses = "^0.17.0"
-flake8 = "^4.0.1"
-isort = "^5.10.1"
+responses = "^0.24.1"
+flake8 = "^6.1.0"
+isort = "^5.12.0"
+mypy = "^1.7.1"
+types-requests = "^2.31.0.10"
+pytest-cov = "^4.1.0"
+
+[tool.mypy]
+plugins = ["pydantic.mypy"]
+exclude = ["example/*"]
 
-[tool.poetry.group.dev.dependencies]
-pytest = "^7.4.0"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

flagsmith-3.5.0/flagsmith/__init__.py

@@ -1 +0,0 @@
-from .flagsmith import Flagsmith  # noqa

flagsmith-3.5.0/flagsmith/utils/identities.py

@@ -1,5 +0,0 @@
-def generate_identities_data(identifier: str, traits: dict = None):
-    return {
-        "identifier": identifier,
-        "traits": [{"trait_key": k, "trait_value": v} for k, v in traits.items()],
-    }