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

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

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

{kameleoon_client_python-3.17.1 → kameleoon_client_python-3.19.0}/kameleoon/configuration/data_file.py

@@ -1,6 +1,7 @@
 """Kameleoon Configuration"""
 
 from typing import Any, Dict, Iterable, List, Optional, Set
+
 from kameleoon.configuration import Variable
 from kameleoon.configuration.custom_data_info import CustomDataInfo
 from kameleoon.configuration.experiment import Experiment
@@ -20,7 +21,7 @@ class DataFile:
     @staticmethod
     def default(environment: Optional[str]) -> "DataFile":
         """Creates new instance of `DataFile` initialized with default values"""
-        data_file = DataFile(environment, None, Settings(), {}, {}, CustomDataInfo(None))
+        data_file = DataFile(environment, None, Settings(), {}, {}, CustomDataInfo(None), None, 0)
         return data_file
 
     @staticmethod
@@ -33,23 +34,29 @@ class DataFile:
         custom_data_info = CustomDataInfo(configuration.get("customData"))
         feature_flags = DataFile.__parse_feature_flags(configuration, segments, custom_data_info)
         holdout = Experiment.from_json(configuration["holdout"]) if "holdout" in configuration else None
-        data_file = DataFile(environment, last_modified, settings, segments, feature_flags, custom_data_info, holdout)
+        date_modified = int(configuration.get("dateModified", 0))
+        data_file = DataFile(
+            environment,
+            last_modified,
+            settings,
+            segments,
+            feature_flags,
+            custom_data_info,
+            holdout,
+            date_modified,
+        )
         return data_file
 
     @staticmethod
     def __parse_segments(configuration: Dict[str, Any]) -> Dict[int, Segment]:
-        return {
-            (seg := Segment.from_json(jobj)).id_: seg
-            for jobj in configuration.get("segments") or []
-        }
+        return {(seg := Segment.from_json(jobj)).id_: seg for jobj in configuration.get("segments") or []}
 
     @staticmethod
     def __parse_feature_flags(
         configuration: Dict[str, Any], segments: Dict[int, Segment], cdi: CustomDataInfo
     ) -> Dict[str, FeatureFlag]:
         return {
-            (ff := FeatureFlag(jobj, segments, cdi)).feature_key: ff
-            for jobj in configuration.get("featureFlags") or []
+            (ff := FeatureFlag(jobj, segments, cdi)).feature_key: ff for jobj in configuration.get("featureFlags") or []
         }
 
     # pylint: disable=R0913
@@ -61,15 +68,22 @@ class DataFile:
         segments: Dict[int, Segment],
         feature_flags: Dict[str, FeatureFlag],
         custom_data_info: CustomDataInfo,
-        holdout: Optional[Experiment] = None,
+        holdout: Optional[Experiment],
+        date_modified: int,
     ) -> None:
         KameleoonLogger.debug(
             "CALL: DataFile(environment: %s, last_modified: %s, settings: %s, segments, feature_flags,"
-            " custom_data_info: %s, holdout: %s)",
-            environment, last_modified, settings, custom_data_info, holdout
+            " custom_data_info: %s, holdout: %s, date_modified: %s)",
+            environment,
+            last_modified,
+            settings,
+            custom_data_info,
+            holdout,
+            date_modified,
         )
         self.__environment = environment  # pylint: disable=W0238
         self.__last_modified = last_modified
+        self.__date_modified = date_modified
         self.__settings = settings
         self.__segments = segments
         self.__audience_tracking_segments = [seg for seg in segments.values() if seg.audience_tracking]
@@ -90,8 +104,13 @@ class DataFile:
         self.__holdout = holdout
         KameleoonLogger.debug(
             "RETURN: DataFile(environment: %s, last_modified: %s, settings: %s, segments, feature_flags,"
-            " custom_data_info: %s, holdout: %s)",
-            environment, last_modified, settings, custom_data_info, holdout
+            " custom_data_info: %s, holdout: %s, date_modified: %s)",
+            environment,
+            last_modified,
+            settings,
+            custom_data_info,
+            holdout,
+            date_modified,
         )
 
     @property
@@ -99,6 +118,11 @@ class DataFile:
         """Returns last modified string"""
         return self.__last_modified
 
+    @property
+    def date_modified(self) -> int:
+        """Returns the last data-file update timestamp from the configuration."""
+        return self.__date_modified
+
     @property
     def settings(self) -> Settings:
         """Returns settings"""
@@ -152,10 +176,12 @@ class DataFile:
         feature_flag = self.__feature_flags.get(feature_key)
         if feature_flag is None:
             raise FeatureNotFound(feature_key)
+        return feature_flag
+
+    def _ensure_environment_enabled(self, feature_flag: FeatureFlag):
         if not feature_flag.environment_enabled:
             env = "default" if self.__environment is None else f"'{self.__environment}'"
-            raise FeatureEnvironmentDisabled(f"Feature '{feature_key}' is disabled for {env} environment")
-        return feature_flag
+            raise FeatureEnvironmentDisabled(f"Feature '{feature_flag.feature_key}' is disabled for {env} environment")
 
     @property
     def custom_data_info(self) -> CustomDataInfo:
@@ -211,6 +237,7 @@ class DataFile:
             "DataFile{"
             f"environment:'{self.__environment}',"
             f"last_modified:'{self.__last_modified}',"
+            f"date_modified:{self.__date_modified},"
             f"feature_flags:{len(self.__feature_flags)},"
             f"settings:{self.__settings}"
             "}"

{kameleoon_client_python-3.17.1 → kameleoon_client_python-3.19.0}/kameleoon/configuration/variation.py

@@ -23,6 +23,7 @@ class Variation:
 
     def __init__(self, dict_json: Dict[str, Any]):
         self.key: str = dict_json.get("key", "")
+        self.name: str = dict_json.get("name", "")
         self.variables: List[Variable] = Variable.from_array(
             dict_json.get("variables", [])
         )
@@ -33,4 +34,5 @@ class Variation:
 
     def __str__(self):
         return (f"Variation{{key:'{self.key}',"
+                f"name:'{self.name}',"
                 f"variables:{StringUtils.object_to_string(self.variables)}}}")

{kameleoon_client_python-3.17.1 → kameleoon_client_python-3.19.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.19.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.19.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.19.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.19.0}/kameleoon/data/manager/visitor_manager.py

@@ -1,12 +1,14 @@
 """Visitor Manager"""
+
 import collections
 import time
 from typing import Any, Dict, Iterator, List, Optional
+
 from kameleoon.configuration.custom_data_info import CustomDataInfo
 from kameleoon.data import Conversion, CustomData
-from kameleoon.data.mapping_identifier import MappingIdentifier
 from kameleoon.data.manager.visitor import Visitor
 from kameleoon.data.manager.visitor_slot import VisitorSlot
+from kameleoon.data.mapping_identifier import MappingIdentifier
 from kameleoon.helpers.scheduler import Scheduler
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.managers.data.data_manager import DataManager
@@ -14,17 +16,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 +45,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 +64,21 @@ 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 peek_visitor(self, visitor_code: str) -> Optional[Visitor]:
+        """Retrieves a visitor by their code if it exists, otherwise returns `None`."""
+        KameleoonLogger.debug(f"CALL: VisitorManager.peekVisitor(visitor_code: {visitor_code})")
+        if (slot := self.__try_acquire_slot(visitor_code)) is None:
+            visitor = None
+        else:
+            try:
+                visitor = slot.visitor
+            finally:
+                slot.lock.release()
+        KameleoonLogger.debug(
+            f"RETURN: VisitorManager.peekVisitor(visitor_code: {visitor_code}) -> "f"(visitor: {visitor})")
+        return visitor
+
+    def add_data(self, visitor_code: str, *args, track: bool = True) -> Visitor:
         """
         Adds data to a visitor.
 
@@ -70,8 +86,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 +102,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.19.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}")