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

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

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

kameleoon_client_python-3.22.0/kameleoon/client_readiness/async_readiness.py

@@ -0,0 +1,43 @@
+"Async Client Readiness"
+
+import asyncio
+from typing import Optional
+
+from kameleoon.exceptions import Initialization
+from kameleoon.client_readiness.threading_readiness import ThreadingClientReadiness
+
+
+class AsyncClientReadiness:
+    """
+    A class that provides an asynchronous interface for checking client readiness.
+
+    This class wraps around a `ThreadingClientReadiness` object to provide asynchronous
+    methods for waiting for the client to be ready. Blocking waits are run in the
+    event loop's default executor so the loop is never blocked.
+    """
+
+    def __init__(self, inner: ThreadingClientReadiness) -> None:
+        """
+        Initializes an AsyncClientReadiness instance.
+        """
+        super().__init__()
+        self._inner = inner
+
+    @property
+    def inner(self) -> ThreadingClientReadiness:
+        """
+        Returns the inner ThreadingClientReadiness instance.
+        """
+        return self._inner
+
+    async def wait_with_timeout(self, timeout_second: float) -> Optional[Initialization]:
+        """
+        Asynchronously waits until the readiness state is settled, but no longer than
+        `timeout_second`. See `ThreadingClientReadiness.wait_with_timeout` for the
+        detailed contract.
+        """
+        # Non-blocking paths (already settled or expired timeout) are served inline.
+        if timeout_second <= 0:
+            return self._inner.wait_with_timeout(timeout_second)
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self._inner.wait_with_timeout, timeout_second)

kameleoon_client_python-3.22.0/kameleoon/client_readiness/threading_readiness.py

@@ -0,0 +1,134 @@
+"""ThreadingClientReadiness"""
+from threading import Event, Lock
+from typing import Optional
+
+from kameleoon.exceptions import Initialization
+
+
+class _State:
+    """
+    A single settlement of the readiness state: `error` is written at most once,
+    before the event is set, and never changes afterwards, so a waiter which
+    obtained the state observes exactly the outcome it was registered for.
+    """
+
+    def __init__(self) -> None:
+        self._event = Event()
+        self.error: Optional[Initialization] = None
+
+    def settle(self) -> None:
+        """Settles the state, releasing all its waiters."""
+        self._event.set()
+
+    @property
+    def settled(self) -> bool:
+        """Returns whether the state is settled."""
+        return self._event.is_set()
+
+    def wait(self, timeout_second: float) -> bool:
+        """Returns whether the state was settled before the timeout elapsed."""
+        return self._event.wait(timeout_second)
+
+
+class ThreadingClientReadiness:
+    """
+    ThreadingClientReadiness tracks whether the SDK has successfully loaded its
+    configuration and exposes that state to `KameleoonClient.wait_init` and
+    `KameleoonClient.is_ready`:
+    - a successful fetch settles the state successfully;
+    - a failed fetch settles it with an `Initialization` error.
+
+    Readiness is monotonic: once the SDK is ready it stays ready, and a later failed
+    fetch can never revert it. A failure reported before the first success does not
+    prevent a subsequent successful retry from marking the SDK ready.
+
+    It is created on the thread that builds the client but settled from the
+    background thread(s) performing configuration fetches.
+    """
+
+    def __init__(self, site_code: str, environment: Optional[str]) -> None:
+        self._lock = Lock()
+        self._state = _State()
+        self._ready = False
+        self._site_code = site_code
+        self._environment = environment
+
+    @property
+    def ready(self) -> bool:
+        """
+        Returns `True` if the SDK has been successfully initialized, `False` otherwise
+        (including while the initialization is still pending or has failed).
+        It never blocks.
+
+        This is the per-request hot path, so it is lock-free: `_ready` is only ever
+        flipped False -> True (readiness is monotonic), making a plain attribute read
+        safe. At worst a reader briefly observes `False` while `mark_ready` is
+        completing, which is indistinguishable from calling a moment earlier.
+        """
+        return self._ready
+
+    def mark_ready(self) -> None:
+        """Marks the SDK ready and releases all waiters."""
+        with self._lock:
+            self._ready = True
+            if self._state.settled:
+                if self._state.error is not None:
+                    # Recovery after a failure: the failed state is left settled for its
+                    # waiters, and a fresh, ready state is published for the new ones.
+                    state = _State()
+                    state.settle()
+                    self._state = state
+            else:
+                self._state.settle()
+
+    def mark_not_ready(self, cause: Exception) -> None:
+        """
+        Reports a failed fetch with an `Initialization` error, but only while the SDK
+        is not yet ready. A failure never reverts an already-ready client and is
+        reported at most once, so the first reported cause is the one waiters observe.
+
+        :param cause: the failure which prevented the SDK from loading its configuration.
+        :type cause: Exception
+        """
+        with self._lock:
+            if not self._state.settled:
+                self._state.error = Initialization(self._site_code, self._environment, cause)
+                self._state.settle()
+            # else: already ready, or the failure was already reported
+
+    def wait_with_timeout(self, timeout_second: float) -> Optional[Initialization]:
+        """
+        Blocks until the readiness state is settled, but no longer than `timeout_second`.
+        Returns the result of the configuration fetch: `None` once the SDK is ready, or
+        the `Initialization` error the fetch failure was reported with (fail-fast - it
+        does not wait for background retries). If no fetch result is available within
+        the timeout, returns an `Initialization` error caused by the expired timeout.
+        A non-positive timeout expires immediately unless a result is already available.
+        An expired timeout does not settle the readiness state: once the SDK becomes
+        ready, a subsequent call returns `None`.
+
+        :param timeout_second: maximum number of seconds to wait.
+        :type timeout_second: float
+        :return: `None` if the SDK is ready, otherwise an `Initialization` error.
+        :rtype: Optional[Initialization]
+        """
+        state = self._current_state()
+        if state.settled:
+            return state.error
+        if timeout_second <= 0:
+            return self._timeout_failure(timeout_second)
+        if state.wait(timeout_second):
+            return state.error
+        return self._timeout_failure(timeout_second)
+
+    def _timeout_failure(self, timeout_second: float) -> Initialization:
+        # The timeout failure wraps a `TimeoutError` cause (the counterpart of the
+        # timeout error types the other SDKs report), so a caller can distinguish an
+        # expired timeout from a failed fetch.
+        cause = TimeoutError(f"initialization did not complete within {round(timeout_second * 1000)} ms")
+        return Initialization(self._site_code, self._environment, cause)
+
+    def _current_state(self) -> _State:
+        # Synchronized for safe publication of the state swapped in by a recovery.
+        with self._lock:
+            return self._state

{kameleoon_client_python-3.19.0 → kameleoon_client_python-3.22.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.22.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.22.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.22.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