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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kameleoon-client-python
-Version: 3.17.1
+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: mypy==0.991; extra == "test"
 Requires-Dist: flake8==4.0.1; extra == "test"
-Requires-Dist: freezegun==1.1.0; extra == "test"
 Requires-Dist: types-requests==2.25.0; extra == "test"
-Requires-Dist: pytest-asyncio==0.21.*; extra == "test"
-Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
 Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
 Requires-Dist: aioresponses==0.7.*; extra == "test"
-Requires-Dist: wheel==0.36.2; extra == "test"
-Requires-Dist: requests<3.0.0,>=2.25; extra == "test"
 Requires-Dist: twine==3.4.1; extra == "test"
 Requires-Dist: pytest-django==4.4.0; extra == "test"
-Requires-Dist: types-PyYAML==5.4.3; extra == "test"
-Requires-Dist: pyyaml<6.1.0,>=5.4.0; extra == "test"
+Requires-Dist: Django==3.2.4; extra == "test"
 Requires-Dist: pytest-cov==2.12.1; extra == "test"
-Requires-Dist: pytest-ordering==0.6; extra == "test"
-Requires-Dist: sseclient-py<1.9.0,>=1.7.0; extra == "test"
-Requires-Dist: Werkzeug==2.0.1; extra == "test"
+Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
 Requires-Dist: pylint==2.12.*; extra == "test"
-Requires-Dist: Django==3.2.4; extra == "test"
-Requires-Dist: mypy==0.991; 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: 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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
@@ -1615,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(

{kameleoon_client_python-3.17.1 → 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.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.1 → 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.1 → 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"
 
 

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

@@ -0,0 +1,61 @@
+"""Version condition for targeting by application version"""
+
+from typing import Any, Dict, Optional, Union
+
+from kameleoon.data.application_version import ApplicationVersion
+from kameleoon.helpers.sem_version import SemVersion
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
+from kameleoon.targeting.conditions.constants import TargetingOperator
+from kameleoon.targeting.conditions.targeting_condition import TargetingCondition
+
+
+class VersionCondition(TargetingCondition):
+    """VersionCondition is used for targeting by application version.
+
+    Compares the visitor's application version against a configured version
+    using semantic versioning comparison (EQUAL, GREATER, LOWER).
+    """
+
+    def __init__(self, json_condition: Dict[str, Union[str, int, Any]]):
+        super().__init__(json_condition)
+        self._condition_version = json_condition.get("version", None)
+        try:
+            self.__operator = TargetingOperator[str(json_condition.get("versionMatchType", None))]
+        except KeyError as ex:
+            KameleoonLogger.error("%s has wrong JSON structure: %s", self.__class__, ex)
+            self.__operator = TargetingOperator.UNDEFINED
+        self.__cached_sem_version: Optional[SemVersion] = None
+
+    def check(self, data: Any) -> bool:
+        return self.check_targeting(data.version) if isinstance(data, ApplicationVersion) else False
+
+    def check_targeting(self, version: str) -> bool:
+        """Compare the provided version with the condition version.
+
+        :param version: The version string to compare
+        :return: True if the comparison matches, False otherwise
+        """
+        if self.__cached_sem_version is None and self._condition_version:
+            self.__cached_sem_version = SemVersion.from_string(str(self._condition_version))
+
+        version_compare = SemVersion.from_string(version)
+
+        if self.__cached_sem_version is None or version_compare is None:
+            KameleoonLogger.error(
+                "VersionCondition has unexpected values to compare, condition version: '%s', provided version: '%s'",
+                self._condition_version,
+                version,
+            )
+            return False
+
+        if self.__operator == TargetingOperator.EQUAL:
+            return self.__cached_sem_version.compare_to(version_compare) == 0
+
+        if self.__operator == TargetingOperator.GREATER:
+            return self.__cached_sem_version.compare_to(version_compare) < 0
+
+        if self.__operator == TargetingOperator.LOWER:
+            return self.__cached_sem_version.compare_to(version_compare) > 0
+
+        KameleoonLogger.error("Unexpected comparing operation for VersionCondition: %s", self.__operator)
+        return False

{kameleoon_client_python-3.17.1 → kameleoon_client_python-3.18.0}/kameleoon/targeting/targeting_manager.py

@@ -96,6 +96,7 @@ class TargetingManager:
         )
         return condition_data
 
+    # pylint: disable=R0912
     def __get_condition_data_by_type(self, visitor: Visitor, condition_type: TargetingConditionType):  # noqa: C901
         if condition_type == TargetingConditionType.BROWSER:
             return visitor.browser
@@ -107,6 +108,8 @@ class TargetingManager:
             return visitor.geolocation
         if condition_type == TargetingConditionType.OPERATING_SYSTEM:
             return visitor.operating_system
+        if condition_type == TargetingConditionType.APPLICATION_VERSION:
+            return visitor.application_version
         if condition_type == TargetingConditionType.CUSTOM_DATUM:
             return visitor.custom_data
         if condition_type == TargetingConditionType.CONVERSIONS:

{kameleoon_client_python-3.17.1 → kameleoon_client_python-3.18.0}/kameleoon/targeting/tree_condition_factory.py

@@ -25,6 +25,7 @@ from kameleoon.targeting.conditions.visit_number_today_condition import VisitNum
 from kameleoon.targeting.conditions.visit_number_total_condition import VisitNumberTotalCondition
 from kameleoon.targeting.conditions.visitor_new_return_condition import VisitorNewReturnCondition
 from kameleoon.targeting.conditions.time_elapsed_since_visit_condition import TimeElapsedSinceVisitCondition
+from kameleoon.targeting.conditions.version_condition import VersionCondition
 
 
 class TreeConditionFactory:
@@ -87,6 +88,9 @@ class TreeConditionFactory:
             if condition_type == TargetingConditionType.OPERATING_SYSTEM:
                 return OperatingSystemCondition(condition_json)
 
+            if condition_type == TargetingConditionType.APPLICATION_VERSION:
+                return VersionCondition(condition_json)
+
             if condition_type == TargetingConditionType.SEGMENT:
                 return SegmentCondition(condition_json)
 

{kameleoon_client_python-3.17.1 → kameleoon_client_python-3.18.0}/kameleoon_client_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kameleoon-client-python
-Version: 3.17.1
+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: mypy==0.991; extra == "test"
 Requires-Dist: flake8==4.0.1; extra == "test"
-Requires-Dist: freezegun==1.1.0; extra == "test"
 Requires-Dist: types-requests==2.25.0; extra == "test"
-Requires-Dist: pytest-asyncio==0.21.*; extra == "test"
-Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
 Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
 Requires-Dist: aioresponses==0.7.*; extra == "test"
-Requires-Dist: wheel==0.36.2; extra == "test"
-Requires-Dist: requests<3.0.0,>=2.25; extra == "test"
 Requires-Dist: twine==3.4.1; extra == "test"
 Requires-Dist: pytest-django==4.4.0; extra == "test"
-Requires-Dist: types-PyYAML==5.4.3; extra == "test"
-Requires-Dist: pyyaml<6.1.0,>=5.4.0; extra == "test"
+Requires-Dist: Django==3.2.4; extra == "test"
 Requires-Dist: pytest-cov==2.12.1; extra == "test"
-Requires-Dist: pytest-ordering==0.6; extra == "test"
-Requires-Dist: sseclient-py<1.9.0,>=1.7.0; extra == "test"
-Requires-Dist: Werkzeug==2.0.1; extra == "test"
+Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
 Requires-Dist: pylint==2.12.*; extra == "test"
-Requires-Dist: Django==3.2.4; extra == "test"
-Requires-Dist: mypy==0.991; 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: 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