kameleoon-client-python 3.17.0__tar.gz → 3.18.0__tar.gz

{kameleoon_client_python-3.17.0 → kameleoon_client_python-3.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kameleoon-client-python
-Version: 3.17.0
+Version: 3.18.0
 Summary: Kameleoon Client Python Software Development Kit.
 Home-page: https://developers.kameleoon.com/python-sdk.html
 Author: Kameleoon
@@ -20,27 +20,27 @@ Requires-Dist: requests<3.0.0,>=2.25
 Requires-Dist: sseclient-py<1.9.0,>=1.7.0
 Requires-Dist: aiohttp<4.0.0,>=3.8.0
 Provides-Extra: test
-Requires-Dist: pytest-asyncio==0.21.*; extra == "test"
-Requires-Dist: aiohttp<4.0.0,>=3.8.0; extra == "test"
-Requires-Dist: freezegun==1.1.0; extra == "test"
-Requires-Dist: twine==3.4.1; extra == "test"
-Requires-Dist: wheel==0.36.2; extra == "test"
-Requires-Dist: Werkzeug==2.0.1; extra == "test"
 Requires-Dist: mypy==0.991; extra == "test"
-Requires-Dist: pytest-ordering==0.6; extra == "test"
-Requires-Dist: pytest-cov==2.12.1; extra == "test"
-Requires-Dist: sseclient-py<1.9.0,>=1.7.0; extra == "test"
+Requires-Dist: flake8==4.0.1; extra == "test"
+Requires-Dist: types-requests==2.25.0; extra == "test"
+Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
 Requires-Dist: aioresponses==0.7.*; extra == "test"
+Requires-Dist: twine==3.4.1; extra == "test"
 Requires-Dist: pytest-django==4.4.0; extra == "test"
 Requires-Dist: Django==3.2.4; extra == "test"
-Requires-Dist: requests<3.0.0,>=2.25; extra == "test"
-Requires-Dist: flake8==4.0.1; extra == "test"
-Requires-Dist: pyyaml<6.1.0,>=5.4.0; extra == "test"
+Requires-Dist: pytest-cov==2.12.1; extra == "test"
+Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
 Requires-Dist: pylint==2.12.*; extra == "test"
+Requires-Dist: aiohttp<4.0.0,>=3.8.0; extra == "test"
+Requires-Dist: Werkzeug==2.0.1; extra == "test"
+Requires-Dist: pytest-asyncio==0.21.*; extra == "test"
+Requires-Dist: sseclient-py<1.9.0,>=1.7.0; extra == "test"
+Requires-Dist: wheel==0.36.2; extra == "test"
 Requires-Dist: types-PyYAML==5.4.3; extra == "test"
-Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
-Requires-Dist: types-requests==2.25.0; extra == "test"
-Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
+Requires-Dist: pyyaml<6.1.0,>=5.4.0; extra == "test"
+Requires-Dist: pytest-ordering==0.6; extra == "test"
+Requires-Dist: freezegun==1.1.0; extra == "test"
+Requires-Dist: requests<3.0.0,>=2.25; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{kameleoon_client_python-3.17.0 → kameleoon_client_python-3.18.0}/kameleoon/data/__init__.py

@@ -1,5 +1,6 @@
 """ Imports all kameleoon data objects """
 
+from .application_version import ApplicationVersion
 from .browser import Browser, BrowserType
 from .conversion import Conversion
 from .cookie import Cookie
@@ -13,6 +14,7 @@ from .user_agent import UserAgent
 from .unique_identifier import UniqueIdentifier
 
 __all__ = [
+    "ApplicationVersion",
     "Browser",
     "BrowserType",
     "Conversion",

kameleoon_client_python-3.18.0/kameleoon/data/application_version.py

@@ -0,0 +1,39 @@
+"""Application version data"""
+
+from kameleoon.data.data import Data, DataType
+
+
+class ApplicationVersion(Data):
+    """Application version data for targeting by application version.
+
+    The ApplicationVersion class represents the version of a user's application
+    and is used for targeting users based on semantic versioning (major, major.minor,
+    or major.minor.patch).
+    """
+
+    def __init__(self, version: str) -> None:
+        """
+        Creates a new ApplicationVersion.
+
+        :param version: The application version string (semantic versioning: major, major.minor, or
+            major.minor.patch). Examples: "1", "1.2", "1.2.3"
+
+        Example:
+
+        .. code-block:: python3
+
+                kameleoon_client.add_data(visitor_code, ApplicationVersion("1.2.3"))
+        """
+        self.__version = version
+
+    @property
+    def version(self) -> str:
+        """Returns the application version string."""
+        return self.__version
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.APPLICATION_VERSION
+
+    def __str__(self):
+        return f"ApplicationVersion{{version:{self.__version}}}"

{kameleoon_client_python-3.17.0 → kameleoon_client_python-3.18.0}/kameleoon/data/data.py

@@ -25,6 +25,7 @@ class DataType(IntEnum):
     CBS = 16
     PERSONALIZATION = 17
     TARGETED_SEGMENT = 18
+    APPLICATION_VERSION = 19
 
 
 class BaseData:

{kameleoon_client_python-3.17.0 → kameleoon_client_python-3.18.0}/kameleoon/data/manager/visitor.py

@@ -6,6 +6,7 @@ from typing import Any, Callable, Optional, Dict, List, Iterator, Iterable, cast
 
 from kameleoon.data.visitor_visits import VisitorVisits
 from kameleoon.data.data import Data
+from kameleoon.data.application_version import ApplicationVersion
 from kameleoon.data.browser import Browser
 from kameleoon.data.cbscores import CBScores
 from kameleoon.data.conversion import Conversion
@@ -102,6 +103,14 @@ class Visitor:  # pylint: disable=R0904
         KameleoonLogger.debug('CALL/RETURN: Visitor.operating_system -> (operating_system: %s)', operating_system)
         return operating_system
 
+    @property
+    def application_version(self) -> Optional[ApplicationVersion]:
+        """Returns the application version information associated with this Visitor."""
+        application_version = self._data.application_version
+        KameleoonLogger.debug('CALL/RETURN: Visitor.application_version -> (application_version: %s)',
+                              application_version)
+        return application_version
+
     @property
     def cookie(self) -> Optional[Cookie]:
         """Returns the cookie information associated with this Visitor."""
@@ -223,20 +232,22 @@ class Visitor:  # pylint: disable=R0904
         self._data.variations[variation.experiment_id] = variation
         KameleoonLogger.debug('RETURN: Visitor.assign_variation(variation: %s)', variation)
 
-    def add_data(self, *args, overwrite: bool = True) -> None:
+    def add_data(self, *args, overwrite: bool = True, track: bool = True) -> None:
         """Adds data to the Visitor."""
-        KameleoonLogger.debug('CALL: Visitor.add_data(args: %s, overwrite: %s)', args, overwrite)
+        KameleoonLogger.debug('CALL: Visitor.add_data(args: %s, overwrite: %s, track: %s)', args, overwrite, track)
         with self._data.lock:
             for data in args:
                 if data is None:
                     continue
+                if not track and isinstance(data, Sendable):
+                    data.mark_as_sent()
                 data_type = type(data)
                 data_adder = self.DATA_ADDERS.get(data_type)
                 if data_adder:
                     data_adder(self, self.DataAddingContext(data, overwrite))
                 else:
                     KameleoonLogger.warning("Data has unsupported type %s", data_type)
-        KameleoonLogger.debug('RETURN: Visitor.add_data(args: %s, overwrite: %s)', args, overwrite)
+        KameleoonLogger.debug('RETURN: Visitor.add_data(args: %s, overwrite: %s, track: %s)', args, overwrite, track)
 
     @property
     def mapping_identifier(self) -> Optional[str]:
@@ -302,6 +313,7 @@ class Visitor:  # pylint: disable=R0904
             self.visitor_visits: Optional[VisitorVisits] = None
             self.mapping_identifier: Optional[str] = None
             self.legal_consent = LegalConsent.UNKNOWN
+            self.application_version: Optional[ApplicationVersion] = None
 
         def enumerate_sendable_data(self) -> Iterator[Sendable]:
             """Iterates over all sendable data associated with the visitor."""
@@ -420,6 +432,10 @@ class Visitor:  # pylint: disable=R0904
         if context.overwrite or self._data.operating_system is None:
             self._data.operating_system = cast(OperatingSystem, context.data)
 
+    def _set_application_version(self, context: DataAddingContext) -> None:
+        if context.overwrite or self._data.application_version is None:
+            self._data.application_version = cast(ApplicationVersion, context.data)
+
     def _set_cookie(self, context: DataAddingContext) -> None:
         self._data.cookie = cast(Cookie, context.data)
 
@@ -482,6 +498,7 @@ class Visitor:  # pylint: disable=R0904
         Browser: _set_browser,
         Geolocation: _set_geolocation,
         OperatingSystem: _set_operating_system,
+        ApplicationVersion: _set_application_version,
         Cookie: _set_cookie,
         CustomData: _add_custom_data,
         MappingIdentifier: _add_custom_data,

{kameleoon_client_python-3.17.0 → kameleoon_client_python-3.18.0}/kameleoon/data/manager/visitor_manager.py

@@ -1,4 +1,5 @@
 """Visitor Manager"""
+
 import collections
 import time
 from typing import Any, Dict, Iterator, List, Optional
@@ -14,17 +15,16 @@ from kameleoon.managers.data.data_manager import DataManager
 
 class VisitorManager:
     """Visitor manager"""
-    def __init__(
-        self, data_manager: DataManager, expiration_period: float, scheduler: Scheduler
-    ) -> None:
-        KameleoonLogger.debug("CALL: VisitorManager(data_manager, expiration_period: %s, scheduler)",
-                              expiration_period)
+
+    def __init__(self, data_manager: DataManager, expiration_period: float, scheduler: Scheduler) -> None:
+        KameleoonLogger.debug("CALL: VisitorManager(data_manager, expiration_period: %s, scheduler)", expiration_period)
         self._data_manager = data_manager
         self.__expiration_period = expiration_period
         self._slots: Dict[str, VisitorSlot] = collections.defaultdict(VisitorSlot)
         scheduler.schedule_job("VisitorManager.purge", expiration_period, self.__purge)
-        KameleoonLogger.debug("RETURN: VisitorManager(data_manager, expiration_period: %s, scheduler)",
-                              expiration_period)
+        KameleoonLogger.debug(
+            "RETURN: VisitorManager(data_manager, expiration_period: %s, scheduler)", expiration_period
+        )
 
     def __iter__(self) -> Iterator[str]:
         yield from list(self._slots)
@@ -44,8 +44,9 @@ class VisitorManager:
                 visitor = slot.visitor
             finally:
                 slot.lock.release()
-        KameleoonLogger.debug("RETURN: VisitorManager.get_visitor(visitor_code: %s) -> (visitor: %s)",
-                              visitor_code, visitor)
+        KameleoonLogger.debug(
+            "RETURN: VisitorManager.get_visitor(visitor_code: %s) -> (visitor: %s)", visitor_code, visitor
+        )
         return visitor
 
     def get_or_create_visitor(self, visitor_code: str) -> Visitor:
@@ -62,7 +63,7 @@ class VisitorManager:
             slot.lock.release()
             KameleoonLogger.debug("RETURN: VisitorManager.get_or_create_visitor(visitor_code: %s)", visitor_code)
 
-    def add_data(self, visitor_code: str, *args) -> Visitor:
+    def add_data(self, visitor_code: str, *args, track: bool = True) -> Visitor:
         """
         Adds data to a visitor.
 
@@ -70,8 +71,13 @@ class VisitorManager:
         * marks custom data of the local scope as unsent
         * converts custom data with the mapping identifier index to the mapping identifier
         * maps a visitor by its mapping identifier
+
+        :param track: A boolean indicating whether the data should be tracked (sent to server).
+        If False, sendable data will be marked as sent immediately. Default is True.
         """
-        KameleoonLogger.debug("CALL: VisitorManager.add_data(visitor_code: %s, args: %s)", visitor_code, args)
+        KameleoonLogger.debug(
+            "CALL: VisitorManager.add_data(visitor_code: %s, args: %s, track: %s)", visitor_code, args, track
+        )
         visitor = self.get_or_create_visitor(visitor_code)
         custom_data_info = self._data_manager.data_file.custom_data_info
         data_to_add: List[Any] = [None] * len(args)
@@ -81,9 +87,13 @@ class VisitorManager:
             elif isinstance(data, Conversion):
                 data = self.__process_conversion(data, custom_data_info)
             data_to_add[i] = data
-        visitor.add_data(*data_to_add)
-        KameleoonLogger.debug("RETURN: VisitorManager.add_data(visitor_code: %s, args: %s) -> (visitor)",
-                              visitor_code, args)
+        visitor.add_data(*data_to_add, track=track)
+        KameleoonLogger.debug(
+            "RETURN: VisitorManager.add_data(visitor_code: %s, args: %s, track: %s) -> (visitor)",
+            visitor_code,
+            args,
+            track,
+        )
         return visitor
 
     def __process_custom_data(

kameleoon_client_python-3.18.0/kameleoon/helpers/sem_version.py

@@ -0,0 +1,60 @@
+"""Version utility for parsing and comparing semantic versions"""
+
+from typing import Optional
+
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
+
+
+class SemVersion:
+    """SemVersion (Semantic versions) is a utility class for parsing and comparing semantic versions.
+
+    Supports semantic versioning with major, minor, and patch components.
+    """
+
+    @staticmethod
+    def from_string(version_string: str) -> Optional["SemVersion"]:
+        """
+        Parses a version string into a Version object.
+
+        :param version_string: The version string to parse (e.g., "1", "1.2", "1.2.3")
+        :return: Version object or None if parsing failed
+        """
+        versions = [0, 0, 0]
+        version_parts = version_string.split(".")
+
+        for i in range(min(len(versions), len(version_parts))):
+            try:
+                versions[i] = int(version_parts[i])
+            except ValueError:
+                KameleoonLogger.error("Invalid version component, index: %s, value: %s", i, version_parts[i])
+                return None
+
+        return SemVersion(versions[0], versions[1], versions[2])
+
+    def __init__(self, major: int = 0, minor: int = 0, patch: int = 0) -> None:
+        """
+        Creates a new Version.
+
+        :param major: Major version number
+        :param minor: Minor version number
+        :param patch: Patch version number
+        """
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+
+    def compare_to(self, other: "SemVersion") -> int:
+        """
+        Compares SemVersion instances
+        """
+        a = (self.major, self.minor, self.patch)
+        b = (other.major, other.minor, other.patch)
+        return (a > b) - (a < b)
+
+    def to_float(self) -> float:
+        """
+        Converts the version to a float (only major and minor are considered).
+
+        :return: Float representation of the version (e.g., 1.2)
+        """
+        return float(f"{self.major}.{self.minor}")

{kameleoon_client_python-3.17.0 → kameleoon_client_python-3.18.0}/kameleoon/kameleoon_client.py

@@ -324,7 +324,7 @@ class KameleoonClient:
             cookies,
         )
 
-    def add_data(self, visitor_code: str, *args) -> None:
+    def add_data(self, visitor_code: str, *args, track: bool = True) -> None:
         """
         To associate various data with the current user, we can use the add_data() method.
         This method requires the visitor_code as a first parameter, and then accepts several additional parameters.
@@ -337,7 +337,9 @@ class KameleoonClient:
 
         :param visitor_code: Unique identifier of the user. This field is mandatory.
         :type visitor_code: str
-        :param args:
+        :param args: One or more Kameleoon Data objects to associate with the visitor.
+        :param track: A boolean indicating whether the data should be tracked (sent to server). Default is True.
+        :type track: bool
         :return: None
 
         Examples:
@@ -349,13 +351,17 @@ class KameleoonClient:
                 visitor_code = kameleoon_client.get_visitor_code(request.COOKIES)
                 kameleoon_client.add_data(visitor_code, CustomData("test-id", "test-value"))
                 kameleoon_client.add_data(visitor_code, Browser(BrowserType.CHROME))
-                kameleoon_client.add_data(visitor_code, PageView("www.test.com", "test-title"))
-                kameleoon_client.add_data(visitor_code, Conversion(1, 100.0))
+                kameleoon_client.add_data(visitor_code, PageView("www.test.com", "test-title"), track=True)
+                kameleoon_client.add_data(visitor_code, Conversion(1, 100.0), track=False)
         """
-        KameleoonLogger.info("CALL: KameleoonClient.add_data(visitor_code: %s, args: %s)", visitor_code, args)
+        KameleoonLogger.info(
+            "CALL: KameleoonClient.add_data(visitor_code: %s, args: %s, track: %s)", visitor_code, args, track
+        )
         validate_visitor_code(visitor_code)
-        self._visitor_manager.add_data(visitor_code, *args)
-        KameleoonLogger.info("RETURN: KameleoonClient.add_data(visitor_code: %s, args: %s)", visitor_code, args)
+        self._visitor_manager.add_data(visitor_code, *args, track=track)
+        KameleoonLogger.info(
+            "RETURN: KameleoonClient.add_data(visitor_code: %s, args: %s, track: %s)", visitor_code, args, track
+        )
 
     def track_conversion(
         self,
@@ -481,7 +487,7 @@ class KameleoonClient:
         )
 
     def is_feature_active(
-        self, visitor_code: str, feature_key: str, is_unique_identifier: Optional[bool] = None, track=True
+        self, visitor_code: str, feature_key: str, is_unique_identifier: Optional[bool] = None, track: bool = True
     ) -> bool:
         """
         Check if feature is active for a given visitor code
@@ -561,7 +567,7 @@ class KameleoonClient:
         )
         return feature_active
 
-    def get_variation(self, visitor_code: str, feature_key: str, track=True) -> Variation:
+    def get_variation(self, visitor_code: str, feature_key: str, track: bool = True) -> Variation:
         """
         Retrieves the variation assigned to the given visitor for a specific feature flag.
 
@@ -605,7 +611,7 @@ class KameleoonClient:
         )
         return external_variation
 
-    def get_variations(self, visitor_code: str, only_active=False, track=True) -> Dict[str, Variation]:
+    def get_variations(self, visitor_code: str, only_active=False, track: bool = True) -> Dict[str, Variation]:
         """
         Forms a dictionary of variations assigned to a given visitor across all feature flags.
         This method iterates over all available feature flags and returns the assigned variation for each flag
@@ -757,6 +763,11 @@ class KameleoonClient:
             save,
             bucketing_cd_index,
         )
+        consent, blocking_behaviour = self.__get_consent_and_blocking_behaviour(visitor)
+        if consent == LegalConsent.NOT_GIVEN and blocking_behaviour == ConsentBlockingBehaviour.COMPLETELY_BLOCKED:
+            raise FeatureEnvironmentDisabled(
+                "Evaluation for a holdout is blocked because visitor's consent was not provided."
+            )
         is_not_in_holdout = True
         code_for_hash = self.__get_code_for_hash(visitor, visitor_code, bucketing_cd_index)
         variation_hash = Hasher.obtain(code_for_hash, holdout.id_)
@@ -1610,7 +1621,7 @@ class KameleoonClient:
         )
         return (feature_flag, variation_key)
 
-    def __save_variation(self, visitor_code: str, eval_exp: Optional[EvaluatedExperiment], track=True) -> None:
+    def __save_variation(self, visitor_code: str, eval_exp: Optional[EvaluatedExperiment], track: bool = True) -> None:
         if (eval_exp is None) or (eval_exp.experiment.id_ is None) or (eval_exp.var_by_exp.variation_id is None):
             return
         KameleoonLogger.debug(
@@ -1695,11 +1706,7 @@ class KameleoonClient:
             feature_flag,
         )
         visitor = self._visitor_manager.get_visitor(visitor_code)
-        datafile = self._data_manager.data_file
-        if datafile.settings.is_consent_required:
-            consent = visitor.legal_consent if visitor else LegalConsent.UNKNOWN
-        else:
-            consent = LegalConsent.GIVEN
+        consent, blocking_behaviour = self.__get_consent_and_blocking_behaviour(visitor)
         code_for_hash = self.__get_code_for_hash(visitor, visitor_code, feature_flag.bucketing_custom_data_index)
         eval_exp = None
         for rule in feature_flag.rules:
@@ -1722,7 +1729,6 @@ class KameleoonClient:
             if hash_rule <= rule.exposition:
                 # Checking if the evaluation is blocked due to the consent policy
                 if (consent == LegalConsent.NOT_GIVEN) and rule.is_experimentation:
-                    blocking_behaviour = datafile.settings.blocking_behaviour_if_consent_not_given
                     if blocking_behaviour == ConsentBlockingBehaviour.PARTIALLY_BLOCKED:
                         break
                     raise FeatureEnvironmentDisabled(
@@ -1757,6 +1763,19 @@ class KameleoonClient:
         )
         return eval_exp
 
+    def __get_consent_and_blocking_behaviour(
+        self,
+        visitor: Optional[Visitor],
+    ) -> Tuple[LegalConsent, ConsentBlockingBehaviour]:
+        datafile = self._data_manager.data_file
+        if datafile.settings.is_consent_required:
+            consent = visitor.legal_consent if visitor else LegalConsent.UNKNOWN
+        else:
+            consent = LegalConsent.GIVEN
+        behaviour = datafile.settings.blocking_behaviour_if_consent_not_given
+
+        return consent, behaviour
+
     @staticmethod
     def __calculate_variation_key(eval_exp: Optional[EvaluatedExperiment], default_value: str) -> str:
         KameleoonLogger.debug(

{kameleoon_client_python-3.17.0 → kameleoon_client_python-3.18.0}/kameleoon/kameleoon_client_config.py

@@ -15,8 +15,8 @@ DEFAULT_REFRESH_INTERVAL_MINUTES = 60
 DEFAULT_SESSION_DURATION_MINUTES = 30
 DEFAULT_DEFAULT_TIMEOUT_MILLISECONDS = 10_000
 DEFAULT_TRACKING_INTERVAL_MILLISECONDS = 1000
-MIN_TRACKING_INTERVAL_MILLISECONDS = 100
-MAX_TRACKING_INTERVAL_MILLISECONDS = 1000
+MIN_TRACKING_INTERVAL_MILLISECONDS = 1_000
+MAX_TRACKING_INTERVAL_MILLISECONDS = 5_000
 DEFAULT_CONFIGURATION_PATH = "/etc/kameleoon/client-python.yaml"
 
 

{kameleoon_client_python-3.17.0 → kameleoon_client_python-3.18.0}/kameleoon/managers/remote_data/remote_visitor_data.py

@@ -50,15 +50,15 @@ class RemoteVisitorData:
         self.__visitor_code: Optional[str] = None
         current_visit = json.get("currentVisit")
         if current_visit is not None:
-            self.__parse_visit(current_visit, False)
+            self.__parse_visit(current_visit, 0)
         previous_visits = json.get("previousVisits")
         if previous_visits:
             prev_visits = []
-            for visit in previous_visits:
+            for i, visit in enumerate(previous_visits):
                 time_started = visit.get("timeStarted", 0)
                 time_last_event = visit.get("timeLastEvent", time_started)
                 prev_visits.append(VisitorVisits.Visit(time_started, time_last_event))
-                self.__parse_visit(visit, True)
+                self.__parse_visit(visit, i + 1)
             if len(prev_visits) > 0:
                 self.__visitor_visits = VisitorVisits(prev_visits, self.__visit_number)
         self.__kcs_heat = self.__parse_kcs_heat(json.get("kcs"))
@@ -123,7 +123,7 @@ class RemoteVisitorData:
         """Returns the `visitorCode` from the most recent visit"""
         return self.__visitor_code
 
-    def __parse_visit(self, json_visit: Dict[str, Any], is_prev_visit: bool) -> None:
+    def __parse_visit(self, json_visit: Dict[str, Any], visit_offset: int) -> None:
         if (self.__visitor_code is None) and isinstance(visitor_code := json_visit.get("visitorCode"), str):
             self.__visitor_code = visitor_code
         custom_data_events = json_visit.get("customDataEvents")
@@ -143,7 +143,7 @@ class RemoteVisitorData:
             self.__parse_geolocation(geolocation_events[-1])
         static_data_event = json_visit.get("staticDataEvent")
         if static_data_event:
-            self.__parse_static_data(static_data_event, is_prev_visit)
+            self.__parse_static_data(static_data_event, visit_offset)
         personalization_events = json_visit.get("personalizationEvents")
         if personalization_events:
             self.__parse_personalizations(personalization_events)
@@ -209,15 +209,13 @@ class RemoteVisitorData:
             if country is not None:
                 self.__geolocation = Geolocation(country, data.get("region"), data.get("city"))
 
-    def __parse_static_data(self, static_data_event: Dict[str, Any], is_prev_visit: bool) -> None:
+    def __parse_static_data(self, static_data_event: Dict[str, Any], visit_offset: int) -> None:
         if self.__device and self.__browser and self.__operating_system:
             return
         data = static_data_event.get("data")
         if data is not None:
-            if self.__visit_number == 0:
-                self.__visit_number = data.get("visitNumber", 0)
-                if is_prev_visit and (self.__visit_number > 0):
-                    self.__visit_number += 1
+            if (self.__visit_number == 0) and (remote_visit_number := data.get("visitNumber")):
+                self.__visit_number = remote_visit_number + visit_offset
             if self.__filter.device and (self.__device is None):
                 device_type = enum_from_name_literal(data.get("deviceType"), DeviceType, None)
                 if device_type is not None:

kameleoon_client_python-3.18.0/kameleoon/sdk_version.py

@@ -0,0 +1,12 @@
+"""Kameleoon SDK version"""
+
+version_info = (3, 18, 0)
+__version__ = ".".join(str(v) for v in version_info)  # uses in scripts
+
+
+# pylint: disable=R0903
+class SdkVersion:
+    """SdkVersion is a helper class for get name and version of sdk"""
+
+    NAME = "PYTHON"
+    VERSION = __version__

{kameleoon_client_python-3.17.0 → kameleoon_client_python-3.18.0}/kameleoon/targeting/conditions/browser_condition.py

@@ -1,8 +1,9 @@
 """Browser condition"""
+
 from typing import Any, Dict, Union
 from kameleoon.data import Browser, BrowserType
+from kameleoon.helpers.sem_version import SemVersion
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
-from kameleoon.sdk_version import SdkVersion
 from kameleoon.targeting.conditions.constants import TargetingOperator
 from kameleoon.targeting.conditions.targeting_condition import TargetingCondition
 
@@ -40,7 +41,8 @@ class BrowserCondition(TargetingCondition):
             return True
 
         # If browser types are equal and browser version is defined in condition, then need to compare versions
-        version_number = SdkVersion.get_float_version(str(self.__version))
+        version = SemVersion.from_string(str(self.__version))
+        version_number = version.to_float() if version else None
         if version_number is None:
             return False
 

kameleoon_client_python-3.18.0/kameleoon/targeting/conditions/sdk_language_condition.py

@@ -0,0 +1,38 @@
+"""Sdk language condition"""
+from typing import Any, Dict, Union
+
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
+from kameleoon.targeting.conditions.version_condition import VersionCondition
+
+
+class SdkLanguageCondition(VersionCondition):
+    """SdkLanguage uses in case if you need to target by sdk type and version"""
+
+    class SdkInfo:
+        """SdkInfo is a helper class to pass sdk name and version as parameters"""
+
+        def __init__(self, sdk_language: str, version: str) -> None:
+            self.__sdk_language = sdk_language
+            self.__version = version
+
+        @property
+        def sdk_language(self):
+            """Return sdk language (type)"""
+            return self.__sdk_language
+
+        @property
+        def version(self):
+            """Return sdk version"""
+            return self.__version
+
+    def __init__(self, json_condition: Dict[str, Union[str, int, Any]]):
+        super().__init__(json_condition)
+        try:
+            self.__sdk_language = json_condition.get("sdkLanguage", "")
+        except KeyError as ex:
+            KameleoonLogger.error("%s has wrong JSON structure: %s", self.__class__, ex)
+
+    def check(self, data: Any) -> bool:
+        return isinstance(data, SdkLanguageCondition.SdkInfo) and \
+            self.__sdk_language == data.sdk_language and \
+            (self._condition_version is None or self.check_targeting(data.version))

{kameleoon_client_python-3.17.0 → kameleoon_client_python-3.18.0}/kameleoon/targeting/conditions/targeting_condition.py

@@ -37,6 +37,7 @@ class TargetingConditionType(Enum):
     SAME_DAY_VISITS = "SAME_DAY_VISITS"
     NEW_VISITORS = "NEW_VISITORS"
     HEAT_SLICE = "HEAT_SLICE"
+    APPLICATION_VERSION = "APPLICATION_VERSION"
     UNKNOWN = "UNKNOWN"