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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kameleoon-client-python
-Version: 3.18.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: mypy==0.991; extra == "test"
-Requires-Dist: flake8==4.0.1; extra == "test"
-Requires-Dist: types-requests==2.25.0; extra == "test"
-Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
-Requires-Dist: aioresponses==0.7.*; extra == "test"
 Requires-Dist: twine==3.4.1; extra == "test"
 Requires-Dist: pytest-django==4.4.0; extra == "test"
+Requires-Dist: 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: pytest-asyncio==0.21.*; 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: 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: types-python-dateutil==2.8.2; extra == "test"
 Requires-Dist: pylint==2.12.*; extra == "test"
-Requires-Dist: aiohttp<4.0.0,>=3.8.0; extra == "test"
-Requires-Dist: Werkzeug==2.0.1; extra == "test"
-Requires-Dist: pytest-asyncio==0.21.*; extra == "test"
-Requires-Dist: sseclient-py<1.9.0,>=1.7.0; extra == "test"
-Requires-Dist: wheel==0.36.2; extra == "test"
 Requires-Dist: types-PyYAML==5.4.3; extra == "test"
-Requires-Dist: 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"
+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.18.0 → kameleoon_client_python-3.20.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.18.0 → kameleoon_client_python-3.20.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.18.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.18.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.18.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.18.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