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

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

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

{kameleoon_client_python-3.19.0 → kameleoon_client_python-3.20.0}/kameleoon/data/conversion.py

@@ -6,6 +6,7 @@ from typing import Optional, Iterable
 from kameleoon.data.custom_data import CustomData
 from kameleoon.data.data import Data, DataType
 from kameleoon.helpers.string_utils import StringUtils
+from kameleoon.helpers.time import time_ms
 from kameleoon.network.sendable import DuplicationSafeSendableBase
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
 
@@ -45,6 +46,23 @@ class Conversion(Data, DuplicationSafeSendableBase):
         self.__revenue = revenue
         self.__negative = negative
         self._metadata = metadata
+        self._assignment_time_ms = time_ms()
+
+    # pylint: disable=too-many-arguments
+    @classmethod
+    def _build_internal(
+        cls,
+        goal_id: int,
+        revenue: float = 0.0,
+        negative: bool = False,
+        metadata: Optional[Iterable[CustomData]] = None,
+        assignment_time: Optional[int] = None,
+    ) -> "Conversion":
+        """Create a conversion with SDK-managed internal state."""
+        conversion = cls(goal_id, revenue, negative, metadata)
+        if assignment_time:
+            conversion._assignment_time_ms = assignment_time
+        return conversion
 
     @property
     def goal_id(self) -> int:
@@ -66,6 +84,11 @@ class Conversion(Data, DuplicationSafeSendableBase):
         """Returns metadata"""
         return self._metadata
 
+    @property
+    def _assignment_time(self) -> float:
+        """Returns the internal time when the conversion was added."""
+        return self._assignment_time_ms
+
     @property
     def data_type(self) -> DataType:
         return DataType.CONVERSION
@@ -97,5 +120,6 @@ class Conversion(Data, DuplicationSafeSendableBase):
             f"Conversion{{goal_id:{self.__goal_id},"
             f"revenue:{self.__revenue},"
             f"negative:{self.__negative},"
-            f"metadata:{StringUtils.object_to_string(self._metadata)}}}"
+            f"metadata:{StringUtils.object_to_string(self._metadata)},"
+            f"assignment_time:{self._assignment_time_ms}}}"
         )

{kameleoon_client_python-3.19.0 → kameleoon_client_python-3.20.0}/kameleoon/data/manager/assigned_variation.py

@@ -1,14 +1,17 @@
+# pylint: disable=duplicate-code
 """Assigned Variation"""
-import time
+
 from typing import Optional
 from kameleoon.configuration.rule_type import RuleType
 from kameleoon.data.data import BaseData, DataType
+from kameleoon.helpers.time import time_ms
 from kameleoon.network.sendable import DuplicationUnsafeSendableBase
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
 
 
 class AssignedVariation(BaseData, DuplicationUnsafeSendableBase):
     """Assigned variation"""
+
     EVENT_TYPE = "experiment"
 
     def __init__(
@@ -22,7 +25,7 @@ class AssignedVariation(BaseData, DuplicationUnsafeSendableBase):
         self.__experiment_id = experiment_id
         self.__variation_id = variation_id
         self.__rule_type = rule_type
-        self.__assignment_time = assignment_time or time.time()
+        self.__assignment_time_ms = assignment_time or time_ms()
 
     @property
     def experiment_id(self) -> int:
@@ -42,7 +45,7 @@ class AssignedVariation(BaseData, DuplicationUnsafeSendableBase):
     @property
     def assignment_time(self) -> float:
         """Returns the time when the assignment occurred."""
-        return self.__assignment_time
+        return self.__assignment_time_ms
 
     @property
     def data_type(self) -> DataType:
@@ -66,6 +69,6 @@ class AssignedVariation(BaseData, DuplicationUnsafeSendableBase):
         return (
             f"AssignedVariation{{experiment_id:{self.__experiment_id},"
             f"variation_id:{self.__variation_id},"
-            f"assignment_time:{self.__assignment_time},"
+            f"assignment_time:{self.__assignment_time_ms},"
             f"rule_type:{self.__rule_type}}}"
         )

{kameleoon_client_python-3.19.0 → kameleoon_client_python-3.20.0}/kameleoon/data/manager/page_view_visit.py

@@ -1,10 +1,10 @@
 """Page view visit"""
 
-import time
 from typing import Optional
 from kameleoon.data import DataType
 from kameleoon.data.data import BaseData
 from kameleoon.data.page_view import PageView
+from kameleoon.helpers.time import time_ms
 
 
 class PageViewVisit(BaseData):
@@ -14,13 +14,13 @@ class PageViewVisit(BaseData):
         super().__init__()
         self.page_view = page_view
         self.count = count
-        self.last_timestamp = last_timestamp or int(time.time() * 1000)
+        self.last_timestamp = last_timestamp or time_ms()
 
     def overwrite(self, new_page_view: PageView) -> None:
         """Overwrites the current PageView with a new PageView and increments the visit count."""
         self.page_view = new_page_view
         self.count += 1
-        self.last_timestamp = int(time.time() * 1000)
+        self.last_timestamp = time_ms()
 
     def merge(self, page_view_visit) -> None:
         """Merges the visit data from another PageViewVisit instance into this one."""

{kameleoon_client_python-3.19.0 → kameleoon_client_python-3.20.0}/kameleoon/data/manager/visitor.py

@@ -1,5 +1,4 @@
 """Visitor"""
-import time
 
 from threading import Lock
 from typing import Any, Callable, Optional, Dict, List, Iterator, Iterable, cast
@@ -27,6 +26,7 @@ from kameleoon.data.manager.forced_experiment_variation import ForcedExperimentV
 from kameleoon.data.manager.forced_feature_variation import ForcedFeatureVariation
 from kameleoon.data.manager.legal_consent import LegalConsent
 from kameleoon.data.manager.page_view_visit import PageViewVisit
+from kameleoon.helpers.time import time_ms
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.network.sendable import Sendable
 
@@ -37,6 +37,7 @@ EMPTY_LIST: List[Any] = []
 
 class Visitor:  # pylint: disable=R0904
     """Visitor"""
+
     def __init__(self, source: Optional["Visitor"] = None) -> None:
         if source is None:
             self._data = Visitor.VisitorData()
@@ -56,108 +57,109 @@ class Visitor:  # pylint: disable=R0904
 
     def enumerate_sendable_data(self) -> Iterator[Sendable]:
         """Enumerates all sendable data associated with this Visitor."""
-        KameleoonLogger.debug('CALL: Visitor.enumerate_sendable_data()')
+        KameleoonLogger.debug("CALL: Visitor.enumerate_sendable_data()")
         sendable_data = self._data.enumerate_sendable_data()
-        KameleoonLogger.debug('RETURN: Visitor.enumerate_sendable_data() -> (sendable_data)')
+        KameleoonLogger.debug("RETURN: Visitor.enumerate_sendable_data() -> (sendable_data)")
         return sendable_data
 
     def count_sendable_data(self) -> int:
         """Counts the number of sendable data items associated with this Visitor."""
-        KameleoonLogger.debug('CALL: Visitor.count_sendable_data()')
+        KameleoonLogger.debug("CALL: Visitor.count_sendable_data()")
         count_sendable_data = self._data.count_sendable_data()
-        KameleoonLogger.debug('RETURN: Visitor.count_sendable_data() -> (count: %s)', count_sendable_data)
+        KameleoonLogger.debug("RETURN: Visitor.count_sendable_data() -> (count: %s)", count_sendable_data)
         return count_sendable_data
 
     @property
     def user_agent(self) -> Optional[str]:
         """Returns the user agent string associated with this Visitor."""
         user_agent = self._data.user_agent
-        KameleoonLogger.debug('CALL/RETURN: Visitor.user_agent -> (user_agent: %s)', user_agent)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.user_agent -> (user_agent: %s)", user_agent)
         return user_agent
 
     @property
     def device(self) -> Optional[Device]:
         """Returns the device information associated with this Visitor."""
         device = self._data.device
-        KameleoonLogger.debug('CALL/RETURN: Visitor.device -> (device: %s)', device)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.device -> (device: %s)", device)
         return device
 
     @property
     def browser(self) -> Optional[Browser]:
         """Returns the browser information associated with this Visitor."""
         browser = self._data.browser
-        KameleoonLogger.debug('CALL/RETURN: Visitor.browser -> (browser: %s)', browser)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.browser -> (browser: %s)", browser)
         return browser
 
     @property
     def geolocation(self) -> Optional[Geolocation]:
         """Returns the geolocation information associated with this Visitor."""
         geolocation = self._data.geolocation
-        KameleoonLogger.debug('CALL/RETURN: Visitor.geolocation -> (geolocation: %s)', geolocation)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.geolocation -> (geolocation: %s)", geolocation)
         return geolocation
 
     @property
     def operating_system(self) -> Optional[OperatingSystem]:
         """Returns the operating system information associated with this Visitor."""
         operating_system = self._data.operating_system
-        KameleoonLogger.debug('CALL/RETURN: Visitor.operating_system -> (operating_system: %s)', operating_system)
+        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)
+        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."""
         cookie = self._data.cookie
-        KameleoonLogger.debug('CALL/RETURN: Visitor.cookie -> (cookie: %s)', cookie)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.cookie -> (cookie: %s)", cookie)
         return cookie
 
     @property
     def custom_data(self) -> Dict[int, CustomData]:
         """Returns the custom data associated with this Visitor."""
         custom_data = EMPTY_DICT if self._data.custom_data_dict is None else self._data.custom_data_dict.copy()
-        KameleoonLogger.debug('CALL/RETURN: Visitor.custom_data -> (custom_data: %s)', custom_data)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.custom_data -> (custom_data: %s)", custom_data)
         return custom_data
 
     @property
     def page_view_visits(self) -> Dict[str, PageViewVisit]:
         """Returns the page view visits associated with this Visitor."""
         page_view_visits = EMPTY_DICT if self._data.page_view_visits is None else self._data.page_view_visits.copy()
-        KameleoonLogger.debug('CALL/RETURN: Visitor.page_view_visits -> (page_view_visits: %s)', page_view_visits)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.page_view_visits -> (page_view_visits: %s)", page_view_visits)
         return page_view_visits
 
     @property
     def conversions(self) -> List[Conversion]:
         """Returns the conversions associated with this Visitor."""
         conversions = EMPTY_LIST if self._data.conversions is None else self._data.conversions.copy()
-        KameleoonLogger.debug('CALL/RETURN: Visitor.conversions -> (conversions: %s)', conversions)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.conversions -> (conversions: %s)", conversions)
         return conversions
 
     @property
     def variations(self) -> Dict[int, AssignedVariation]:
         """Returns the variations associated with this Visitor."""
         variations = EMPTY_DICT if self._data.variations is None else self._data.variations.copy()
-        KameleoonLogger.debug('CALL/RETURN: Visitor.variations -> (variations: %s)', variations)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.variations -> (variations: %s)", variations)
         return variations
 
     @property
     def personalizations(self) -> Dict[int, Personalization]:
         """Returns the personalizations associated with this Visitor."""
         personalizations = EMPTY_DICT if self._data.personalizations is None else self._data.personalizations.copy()
-        KameleoonLogger.debug('CALL/RETURN: Visitor.personalizations -> (personalizations: %s)', personalizations)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.personalizations -> (personalizations: %s)", personalizations)
         return personalizations
 
     @property
     def targeted_segments(self) -> Dict[int, TargetedSegment]:
         """Returns the personalizations associated with this Visitor."""
         targeted_segments = EMPTY_DICT if self._data.targeted_segments is None else self._data.targeted_segments.copy()
-        KameleoonLogger.debug('CALL/RETURN: Visitor.targeted_segments -> (targeted_segments: %s)', targeted_segments)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.targeted_segments -> (targeted_segments: %s)", targeted_segments)
         return targeted_segments
 
     def get_forced_feature_variation(self, feature_key: str) -> Optional[ForcedFeatureVariation]:
@@ -165,10 +167,10 @@ class Visitor:  # pylint: disable=R0904
         Returns an associated forced feature variation by its feature key if it is present.
         Otherwise returns `None`.
         """
-        KameleoonLogger.debug('CALL: Visitor.get_forced_feature_variation(feature_key: %s)', feature_key)
+        KameleoonLogger.debug("CALL: Visitor.get_forced_feature_variation(feature_key: %s)", feature_key)
         ffv = self._data.simulated_variations.get(feature_key) if self._data.simulated_variations else None
         KameleoonLogger.debug(
-            'RETURN: Visitor.get_forced_feature_variation(feature_key: %s) -> (variation: %s)', feature_key, ffv
+            "RETURN: Visitor.get_forced_feature_variation(feature_key: %s) -> (variation: %s)", feature_key, ffv
         )
         return ffv
 
@@ -177,64 +179,64 @@ class Visitor:  # pylint: disable=R0904
         Returns an associated forced experiment variation by its experiment id if it is present.
         Otherwise returns `None`.
         """
-        KameleoonLogger.debug('CALL: Visitor.get_forced_experiment_variation(experiment_id: %s)', experiment_id)
+        KameleoonLogger.debug("CALL: Visitor.get_forced_experiment_variation(experiment_id: %s)", experiment_id)
         fev = self._data.forced_variations.get(experiment_id) if self._data.forced_variations else None
         KameleoonLogger.debug(
-            'RETURN: Visitor.get_forced_experiment_variation(experiment_id: %s) -> (variation: %s)', experiment_id, fev
+            "RETURN: Visitor.get_forced_experiment_variation(experiment_id: %s) -> (variation: %s)", experiment_id, fev
         )
         return fev
 
     def reset_forced_experiment_variation(self, experiment_id: int) -> None:
         """Resets an associated forced experiment variation for some experiment id"""
-        KameleoonLogger.debug('CALL: Visitor.reset_forced_experiment_variation(experiment_id: %s)', experiment_id)
+        KameleoonLogger.debug("CALL: Visitor.reset_forced_experiment_variation(experiment_id: %s)", experiment_id)
         if self._data.forced_variations:
             self._data.forced_variations.pop(experiment_id, None)
-        KameleoonLogger.debug('RETURN: Visitor.reset_forced_experiment_variation(experiment_id: %s)', experiment_id)
+        KameleoonLogger.debug("RETURN: Visitor.reset_forced_experiment_variation(experiment_id: %s)", experiment_id)
 
     def update_simulated_variations(self, variations: Iterable[ForcedFeatureVariation]) -> None:
         """Updates the associated simulated variations"""
         if not (self._data.simulated_variations or variations):
             return
-        KameleoonLogger.debug('CALL: Visitor.update_simulated_variations(variations: %s)', variations)
+        KameleoonLogger.debug("CALL: Visitor.update_simulated_variations(variations: %s)", variations)
         self._data.simulated_variations = {sv.feature_key: sv for sv in variations}
-        KameleoonLogger.debug('RETURN: Visitor.update_simulated_variations(variations: %s)', variations)
+        KameleoonLogger.debug("RETURN: Visitor.update_simulated_variations(variations: %s)", variations)
 
     @property
     def kcs_heat(self) -> Optional[KcsHeat]:
         """Returns the KCS heat data associated with this Visitor."""
         kcs_heat = self._data.kcs_heat
-        KameleoonLogger.debug('CALL/RETURN: Visitor.kcs_heat -> (kcs_heat: %s)', kcs_heat)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.kcs_heat -> (kcs_heat: %s)", kcs_heat)
         return kcs_heat
 
     @property
     def cbscores(self) -> Optional[CBScores]:
         """Returns the CBS data associated with this Visitor."""
         cbs = self._data.cbscores
-        KameleoonLogger.debug('CALL/RETURN: Visitor.cbscores -> (cbs: %s)', cbs)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.cbscores -> (cbs: %s)", cbs)
         return cbs
 
     @property
     def visitor_visits(self) -> Optional[VisitorVisits]:
         """Returns the visitor visits data associated with this Visitor."""
         visitor_visits = self._data.visitor_visits
-        KameleoonLogger.debug('CALL/RETURN: Visitor.visitor_visits -> (visitor_visits: %s)', visitor_visits)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.visitor_visits -> (visitor_visits: %s)", visitor_visits)
         return visitor_visits
 
     def assign_variation(self, variation: AssignedVariation) -> None:
         """Assigns a variation to the Visitor."""
-        KameleoonLogger.debug('CALL: Visitor.assign_variation(variation: %s)', variation)
+        KameleoonLogger.debug("CALL: Visitor.assign_variation(variation: %s)", variation)
         if self._data.variations is None:
             with self._data.lock:
                 if self._data.variations is None:
                     self._data.variations = {variation.experiment_id: variation}
-                    KameleoonLogger.debug('RETURN: Visitor.assign_variation(variation: %s)', variation)
+                    KameleoonLogger.debug("RETURN: Visitor.assign_variation(variation: %s)", variation)
                     return
         self._data.variations[variation.experiment_id] = variation
-        KameleoonLogger.debug('RETURN: Visitor.assign_variation(variation: %s)', variation)
+        KameleoonLogger.debug("RETURN: Visitor.assign_variation(variation: %s)", variation)
 
     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, track: %s)', args, overwrite, track)
+        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:
@@ -247,14 +249,13 @@ class Visitor:  # pylint: disable=R0904
                     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, track: %s)', args, overwrite, track)
+        KameleoonLogger.debug("RETURN: Visitor.add_data(args: %s, overwrite: %s, track: %s)", args, overwrite, track)
 
     @property
     def mapping_identifier(self) -> Optional[str]:
         """Returns the mapping identifier associated with this Visitor."""
         mapping_identifier = self._data.mapping_identifier
-        KameleoonLogger.debug('CALL/RETURN: Visitor.mapping_identifier -> (mapping_identifier: %s)',
-                              mapping_identifier)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.mapping_identifier -> (mapping_identifier: %s)", mapping_identifier)
         return mapping_identifier
 
     @mapping_identifier.setter
@@ -272,7 +273,7 @@ class Visitor:  # pylint: disable=R0904
     def legal_consent(self) -> LegalConsent:
         """Returns the legal consent status for this Visitor."""
         legal_consent = self._data.legal_consent
-        KameleoonLogger.debug('CALL/RETURN: Visitor.legal_consent -> (legal_consent: %s)', legal_consent)
+        KameleoonLogger.debug("CALL/RETURN: Visitor.legal_consent -> (legal_consent: %s)", legal_consent)
         return legal_consent
 
     @legal_consent.setter
@@ -285,14 +286,16 @@ class Visitor:  # pylint: disable=R0904
     def is_unique_identifier(self) -> bool:
         """Returns the unique identifier status for this Visitor."""
         is_unique_identifier = self._is_unique_identifier
-        KameleoonLogger.debug('CALL/RETURN: Visitor.is_unique_identifier -> (is_unique_identifier: %s)',
-                              is_unique_identifier)
+        KameleoonLogger.debug(
+            "CALL/RETURN: Visitor.is_unique_identifier -> (is_unique_identifier: %s)", is_unique_identifier
+        )
         return is_unique_identifier
 
     class VisitorData:
         """Visitor Data"""
+
         def __init__(self) -> None:
-            self.time_started = int(time.time() * 1000)
+            self.time_started = time_ms()
             self.lock = Lock()
             self.user_agent: Optional[str] = None
             self.device: Optional[Device] = None
@@ -365,9 +368,8 @@ class Visitor:  # pylint: disable=R0904
 
     class DataAddingContext:
         """Data adding context"""
-        def __init__(
-            self, data: Data, overwrite: bool = True
-        ) -> None:
+
+        def __init__(self, data: Data, overwrite: bool = True) -> None:
             self._data = data
             self._overwrite = overwrite
 

{kameleoon_client_python-3.19.0 → kameleoon_client_python-3.20.0}/kameleoon/data/manager/visitor_manager.py

@@ -17,14 +17,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_sec: float, scheduler: Scheduler) -> None:
+        KameleoonLogger.debug(
+            "CALL: VisitorManager(data_manager, expiration_period: %s, scheduler)", expiration_period_sec
+        )
         self._data_manager = data_manager
-        self.__expiration_period = expiration_period
+        self.__expiration_period_sec = expiration_period_sec
         self._slots: Dict[str, VisitorSlot] = collections.defaultdict(VisitorSlot)
-        scheduler.schedule_job("VisitorManager.purge", expiration_period, self.__purge)
+        scheduler.schedule_job("VisitorManager.purge", expiration_period_sec, self.__purge)
         KameleoonLogger.debug(
-            "RETURN: VisitorManager(data_manager, expiration_period: %s, scheduler)", expiration_period
+            "RETURN: VisitorManager(data_manager, expiration_period: %s, scheduler)", expiration_period_sec
         )
 
     def __iter__(self) -> Iterator[str]:
@@ -75,7 +77,8 @@ class VisitorManager:
             finally:
                 slot.lock.release()
         KameleoonLogger.debug(
-            f"RETURN: VisitorManager.peekVisitor(visitor_code: {visitor_code}) -> "f"(visitor: {visitor})")
+            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:
@@ -163,7 +166,7 @@ class VisitorManager:
 
     def __purge(self) -> None:
         KameleoonLogger.debug("CALL: VisitorManager.__purge()")
-        expired_time = time.time() - self.__expiration_period
+        expired_time = time.time() - self.__expiration_period_sec
         for visitor_code in list(self._slots):
             if slot := self.__try_acquire_slot_once(visitor_code):
                 try:

kameleoon_client_python-3.20.0/kameleoon/data/personalization.py

@@ -0,0 +1,44 @@
+# pylint: disable=duplicate-code
+"""Personalization"""
+
+from typing import Optional
+
+from kameleoon.data import DataType
+from kameleoon.data.data import BaseData
+from kameleoon.helpers.time import time_ms
+
+
+class Personalization(BaseData):
+    """Personalization"""
+
+    def __init__(self, id_: int, variation_id: int, assignment_time: Optional[int] = None) -> None:
+        super().__init__()
+        self.__id = id_
+        self.__variation_id = variation_id
+        self.__assignment_time_ms = assignment_time or time_ms()
+
+    @property
+    def id(self) -> int:
+        """Returns personalization ID"""
+        return self.__id
+
+    @property
+    def variation_id(self) -> int:
+        """Returns variation ID"""
+        return self.__variation_id
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.PERSONALIZATION
+
+    @property
+    def assignment_time(self) -> float:
+        """Returns the time when the personalization was assigned."""
+        return self.__assignment_time_ms
+
+    def __str__(self):
+        return (
+            f"Personalization{{id:{self.__id},"
+            f"variation_id:{self.__variation_id},"
+            f"assignment_time:{self.__assignment_time_ms}}}"
+        )

kameleoon_client_python-3.20.0/kameleoon/helpers/time.py

@@ -0,0 +1,24 @@
+"""Time conversion helpers."""
+
+from __future__ import annotations
+import time
+
+
+def ns_to_ms(ns: int) -> int:
+    """Convert nanoseconds to milliseconds."""
+    return ns // 1_000_000
+
+
+def time_ms() -> int:
+    """Return current time in milliseconds."""
+    return time.time_ns() // 1_000_000
+
+
+def m_to_s(m: int) -> int:
+    """Convert minutes to seconds."""
+    return m * 60
+
+
+def s_to_ms(s: int | float) -> int:
+    """Convert seconds to milliseconds."""
+    return int(s * 1000)

{kameleoon_client_python-3.19.0 → kameleoon_client_python-3.20.0}/kameleoon/hybrid/hybrid_manager_impl.py

@@ -1,8 +1,10 @@
+# pylint: disable=duplicate-code
 """Hybrid"""
-import time
+
 from typing import Dict, Optional
 from kameleoon.data.manager.assigned_variation import AssignedVariation
 from kameleoon.helpers.string_utils import StringUtils
+from kameleoon.helpers.time import time_ms
 from kameleoon.hybrid.hybrid_manager import HybridManager
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.managers.data.data_manager import DataManager
@@ -10,34 +12,41 @@ from kameleoon.managers.data.data_manager import DataManager
 
 class HybridManagerImpl(HybridManager):
     """Implementation of HybridManager that generates tracking code for engine integration."""
+
     TC_INIT = "window.kameleoonQueue=window.kameleoonQueue||[];"
     TC_ASSIGN_VARIATION_F = "window.kameleoonQueue.push(['Experiments.assignVariation',{0},{1},true]);"
     TC_TRIGGER_F = "window.kameleoonQueue.push(['Experiments.trigger',{0},{2}]);"
     TC_ASSIGN_VARIATION_TRIGGER_F = TC_ASSIGN_VARIATION_F + TC_TRIGGER_F
 
-    def __init__(self, expiration_period: float, data_manager: DataManager) -> None:
-        KameleoonLogger.debug("CALL: HybridManagerImpl(expiration_period: %s)", expiration_period)
+    def __init__(self, expiration_period_ms: int, data_manager: DataManager) -> None:
+        KameleoonLogger.debug("CALL: HybridManagerImpl(expiration_period: %s)", expiration_period_ms)
         super().__init__()
-        self._expiration_period = expiration_period
+        self._expiration_period_ms = expiration_period_ms
         self._data_manager = data_manager
-        KameleoonLogger.debug("RETURN: HybridManagerImpl(expiration_period: %s)", expiration_period)
+        KameleoonLogger.debug("RETURN: HybridManagerImpl(expiration_period: %s)", expiration_period_ms)
 
     def get_engine_tracking_code(self, visitor_variations: Optional[Dict[int, AssignedVariation]]) -> str:
-        KameleoonLogger.debug("CALL: HybridManagerImpl.get_engine_tracking_code(visitor_variations: %s)",
-                              visitor_variations)
+        KameleoonLogger.debug(
+            "CALL: HybridManagerImpl.get_engine_tracking_code(visitor_variations: %s)", visitor_variations
+        )
         lines = [self.TC_INIT]
         if visitor_variations:
-            expiration_time = time.time() - self._expiration_period
+            expiration_time = time_ms() - self._expiration_period_ms
             for variation in visitor_variations.values():
                 if variation.assignment_time > expiration_time:
-                    tracking_only = not (self._data_manager.data_file.
-                                         has_experiment_js_css_variable(variation.experiment_id))
+                    tracking_only = not (
+                        self._data_manager.data_file.has_experiment_js_css_variable(variation.experiment_id)
+                    )
                     line = self.TC_ASSIGN_VARIATION_TRIGGER_F.format(
-                        variation.experiment_id, variation.variation_id,
-                        StringUtils.bool_to_string_lower_case(tracking_only))
+                        variation.experiment_id,
+                        variation.variation_id,
+                        StringUtils.bool_to_string_lower_case(tracking_only),
+                    )
                     lines.append(line)
         tracking_code = "".join(lines)
         KameleoonLogger.debug(
             "RETURN: HybridManagerImpl.get_engine_tracking_code(visitor_variations: %s) -> (tracking_code: %s)",
-            visitor_variations, tracking_code)
+            visitor_variations,
+            tracking_code,
+        )
         return tracking_code