kameleoon-client-python 3.3.3__tar.gz → 3.5.0__tar.gz

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kameleoon-client-python
-Version: 3.3.3
+Version: 3.5.0
 Summary: Kameleoon Client Python Software Development Kit.
 Home-page: https://developers.kameleoon.com/python-sdk.html
 Author: Kameleoon
@@ -70,7 +70,7 @@ kameleoon_client = KameleoonClientFactory.create(SITE_CODE, config_path='/etc/ka
 
 # Option 2
 configuration_object = KameleoonClientConfig.read_from_yaml('/etc/kameleoon/client-python.yaml')
-configuration_object.set_logger(my_logger)
+configuration_object.set_logger(my_logger) # (is deprecated) use `KameleoonLogger.set_logger` method instead.
 kameleoon_client = KameleoonClientFactory.create(SITE_CODE, configuration_object)
 
 # Option 3
@@ -83,7 +83,7 @@ configuration_object = KameleoonClientConfig(
     environment="production",  # optional, possible values: "production" / "staging" / "development" / "staging", default: None
     top_level_domain="example.com",
     multi_threading=False,  # optional, default: False
-    logger=my_logger,  # optional, default: standard kameleoon logger
+    logger=my_logger,  # optional, default: standard kameleoon logger (is deprecated) use `KameleoonLogger.set_logger` method instead.
 )
 kameleoon_client = KameleoonClientFactory.create(SITE_CODE, configuration_object)
 ```

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/README.md

@@ -49,7 +49,7 @@ kameleoon_client = KameleoonClientFactory.create(SITE_CODE, config_path='/etc/ka
 
 # Option 2
 configuration_object = KameleoonClientConfig.read_from_yaml('/etc/kameleoon/client-python.yaml')
-configuration_object.set_logger(my_logger)
+configuration_object.set_logger(my_logger) # (is deprecated) use `KameleoonLogger.set_logger` method instead.
 kameleoon_client = KameleoonClientFactory.create(SITE_CODE, configuration_object)
 
 # Option 3
@@ -62,7 +62,7 @@ configuration_object = KameleoonClientConfig(
     environment="production",  # optional, possible values: "production" / "staging" / "development" / "staging", default: None
     top_level_domain="example.com",
     multi_threading=False,  # optional, default: False
-    logger=my_logger,  # optional, default: standard kameleoon logger
+    logger=my_logger,  # optional, default: standard kameleoon logger (is deprecated) use `KameleoonLogger.set_logger` method instead.
 )
 kameleoon_client = KameleoonClientFactory.create(SITE_CODE, configuration_object)
 ```

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/client_readiness/threading_readiness.py

@@ -1,9 +1,12 @@
-"ThreadingClientReadiness"
+"""ThreadingClientReadiness"""
 from threading import Lock
 
 
 class ThreadingClientReadiness:
+    """A class to manage and track the readiness of a component using threading."""
+
     def __init__(self) -> None:
+        """Initializes the ThreadingClientReadiness object."""
         self._is_initializing = False
         self._success = False
         self._condition = Lock()
@@ -11,25 +14,30 @@ class ThreadingClientReadiness:
 
     @property
     def is_initializing(self) -> bool:
+        """Returns whether the component is currently initializing."""
         return self._is_initializing
 
     @property
     def success(self) -> bool:
+        """Returns whether the initialization was successful."""
         return self._success
 
     def reset(self) -> None:
+        """Resets the readiness state to initializing."""
         self._success = False
         if not self._is_initializing:
             self._is_initializing = True
-            self._condition.acquire()
+            self._condition.acquire()  # pylint: disable=R1732
 
     def set(self, success: bool) -> None:
+        """Sets the readiness state to initialized with a success status."""
         self._success = success
         if self._is_initializing:
             self._condition.release()
             self._is_initializing = False
 
     def wait(self) -> bool:
+        """Waits for the initialization to complete and returns the success status."""
         if self._is_initializing:
             with self._condition:
                 pass

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/configuration/custom_data_info.py

@@ -1,8 +1,9 @@
 """Custom data info"""
 
-from logging import Logger
 from typing import Optional, Dict, Union, Any, List
 
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
+
 
 class CustomDataInfo:
     """Custom data info"""
@@ -10,7 +11,7 @@ class CustomDataInfo:
     SCOPE_VISITOR = "VISITOR"
 
     def __init__(
-        self, custom_data: Optional[List[Dict[str, Union[str, int, Any]]]], logger: Optional[Logger] = None
+        self, custom_data: Optional[List[Dict[str, Union[str, int, Any]]]]
     ) -> None:
         super().__init__()
         self.__mapping_identifier_index = None
@@ -26,8 +27,8 @@ class CustomDataInfo:
                     if data.get("scope") == self.SCOPE_VISITOR:
                         self.__visitor_scope.add(index)
                     if data.get("isMappingIdentifier"):
-                        if bool(self.__mapping_identifier_index is not None) and logger is not None:
-                            logger.info(
+                        if bool(self.__mapping_identifier_index is not None):
+                            KameleoonLogger.warning(
                                 "More than one mapping identifier is set. Undefined behavior may occur" +
                                 " on cross-device reconciliation."
                             )

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/configuration/data_file.py

@@ -1,12 +1,14 @@
 """Kameleoon Configuration"""
-from logging import Logger
-from typing import Any, Dict, Optional
+
+from typing import Any, Dict, Optional, Set
+from kameleoon.configuration import Variable
 from kameleoon.configuration.custom_data_info import CustomDataInfo
 from kameleoon.configuration.variation_by_exposition import VariationByExposition
 from kameleoon.configuration.feature_flag import FeatureFlag
 from kameleoon.configuration.rule import Rule
 from kameleoon.configuration.settings import Settings
 from kameleoon.exceptions import FeatureNotFound, FeatureEnvironmentDisabled
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
 
 
 class DataFile:
@@ -15,11 +17,12 @@ class DataFile:
     @staticmethod
     def default(environment: Optional[str]) -> "DataFile":
         """Creates new instance of `DataFile` initialized with default values"""
-        return DataFile(environment, Settings(), {}, CustomDataInfo(None))
+        data_file = DataFile(environment, Settings(), {}, CustomDataInfo(None))
+        return data_file
 
     @staticmethod
     def from_json(
-        environment: Optional[str], configuration: Dict[str, Any], logger: Optional[Logger] = None
+        environment: Optional[str], configuration: Dict[str, Any]
     ) -> "DataFile":
         """Creates new instance of `DataFile` initialized from the specified configuration JSON"""
         settings = Settings(configuration.get("configuration"))
@@ -27,8 +30,9 @@ class DataFile:
             (feature_flag := FeatureFlag(jobj)).feature_key: feature_flag
             for jobj in configuration.get("featureFlags") or []
         }
-        custom_data_info = CustomDataInfo(configuration.get("customData"), logger=logger)
-        return DataFile(environment, settings, feature_flags, custom_data_info)
+        custom_data_info = CustomDataInfo(configuration.get("customData"))
+        data_file = DataFile(environment, settings, feature_flags, custom_data_info)
+        return data_file
 
     # pylint: disable=R0913
     def __init__(
@@ -38,6 +42,9 @@ class DataFile:
         feature_flags: Dict[str, FeatureFlag],
         custom_data_info: CustomDataInfo,
     ) -> None:
+        KameleoonLogger.debug(
+            'CALL: DataFile(environment: %s, settings: %s, feature_flags: %s, custom_data_info: %s)',
+            environment, settings, feature_flags, custom_data_info)
         self.__environment = environment  # pylint: disable=W0238
         self.__settings = settings
         self.__feature_flags: Dict[str, FeatureFlag] = feature_flags
@@ -50,8 +57,12 @@ class DataFile:
         self.__variation_by_id: Dict[int, VariationByExposition] = {}
         self.__rule_by_segment_id: Dict[int, Rule] = {}
         self.__feature_flag_by_id: Dict[int, FeatureFlag] = {}
+        self.__experiment_ids_with_js_css_variable: Set[int] = set()
         self.__collect_indices()
         self.__custom_data_info = custom_data_info
+        KameleoonLogger.debug(
+            'RETURN: DataFile.new(environment: %s, settings: %s, feature_flags: %s, custom_data_info: %s)',
+            environment, settings, feature_flags, custom_data_info)
 
     @property
     def settings(self) -> Settings:
@@ -100,12 +111,38 @@ class DataFile:
         """Returns custom data info for mapping device`"""
         return self.__custom_data_info
 
+    def has_experiment_js_css_variable(self, experiment_id: int) -> bool:
+        """Returns `True` if the experiment has a JS or CSS variable, otherwise returns `False`"""
+        return experiment_id in self.__experiment_ids_with_js_css_variable
+
     def __collect_indices(self) -> None:
         for _, feature_flag in self.__feature_flags.items():
             self.__feature_flag_by_id[feature_flag.id_] = feature_flag
             if feature_flag.rules is not None:
+                has_feature_flag_variable_js_css = self.__has_feature_flag_variable_js_css(feature_flag)
                 for rule in feature_flag.rules:
                     self.__rule_by_segment_id[rule.segment_id] = rule
+                    if has_feature_flag_variable_js_css:
+                        self.__experiment_ids_with_js_css_variable.add(rule.experiment_id)
                     for variation in rule.variation_by_exposition:
                         if variation.variation_id is not None:
                             self.__variation_by_id[variation.variation_id] = variation
+
+    @staticmethod
+    def __has_feature_flag_variable_js_css(feature_flag: FeatureFlag) -> bool:
+        variations = feature_flag.variations
+        first_variation = next(iter(variations), None)
+        if first_variation:
+            for variable in first_variation.variables:
+                if variable.get_type() in {Variable.Type.CSS.value, Variable.Type.JS.value}:
+                    return True
+        return False
+
+    def __str__(self):
+        return (
+            f"DataFile{{"
+            f"environment:'{self.__environment}',"
+            f"feature_flags:{len(self.__feature_flags)},"
+            f"settings:{self.__settings}"
+            f"}}"
+        )

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/configuration/feature_flag.py

@@ -4,6 +4,7 @@ from typing import Any, List, Dict, Optional
 
 from kameleoon.configuration.rule import Rule
 from kameleoon.configuration.variation import Variation
+from kameleoon.helpers.string_utils import StringUtils
 
 
 class FeatureFlag:
@@ -29,3 +30,15 @@ class FeatureFlag:
     def get_variation(self, key: str) -> Optional[Variation]:
         """Retrun a variation for the given key"""
         return next((v for v in self.variations if v.key == key), None)
+
+    def __str__(self):
+        return (
+            f"FeatureFlag{{"
+            f"id:{self.id_},"
+            f"feature_key:'{self.feature_key}',"
+            f"environment_enabled:{self.environment_enabled},"
+            f"variations:{StringUtils.object_to_string(self.variations)},"
+            f"default_variation_key:'{self.default_variation_key}',"
+            f"rules:{len(self.rules)}"
+            f"}}"
+        )

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/configuration/rule.py

@@ -54,3 +54,6 @@ class Rule:
         """Return `true` if rule is `targeted delivery` type"""
 
         return self.type == RuleType.TARGETED_DELIVERY
+
+    def __str__(self):
+        return f"Rule{{id:{self.id_}}}"

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/configuration/settings.py

@@ -33,3 +33,10 @@ class Settings:
     def data_api_domain(self) -> Any:
         """Returns Data API domain to be switched to"""
         return self.__data_api_domain
+
+    def __str__(self):
+        return (
+            f"Settings{{real_time_update:{self.__real_time_update},"
+            f"is_consent_required:{self.__is_consent_required},"
+            f"data_api_domain:'{self.__data_api_domain}'}}"
+        )

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/configuration/variable.py

@@ -4,6 +4,8 @@ from enum import Enum
 import json
 from typing import Any, List, Dict, Union
 
+from kameleoon.helpers.string_utils import StringUtils
+
 
 class Variable:
     """
@@ -17,6 +19,8 @@ class Variable:
         JSON = "JSON"
         NUMBER = "NUMBER"
         STRING = "STRING"
+        CSS = "CSS"
+        JS = "JS"
 
     @staticmethod
     def from_array(array: List[Dict[str, Any]]) -> List["Variable"]:
@@ -34,6 +38,8 @@ class Variable:
             Variable.Type.BOOLEAN.value,
             Variable.Type.NUMBER.value,
             Variable.Type.STRING.value,
+            Variable.Type.CSS.value,
+            Variable.Type.JS.value,
         ):
             return self.__value
         if self.__type == Variable.Type.JSON.value and isinstance(self.__value, str):
@@ -43,3 +49,8 @@ class Variable:
     def get_type(self) -> str:
         """Returns type value of variable"""
         return self.__type
+
+    def __str__(self):
+        return (f"Variable{{key:'{self.key},"
+                f"type:'{self.__type}',"
+                f"value:{StringUtils.object_to_string(self.__value)}}}")

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/configuration/variation.py

@@ -4,6 +4,7 @@ from enum import Enum
 from typing import Any, List, Dict, Optional
 
 from kameleoon.configuration.variable import Variable
+from kameleoon.helpers.string_utils import StringUtils
 
 
 class Variation:
@@ -29,3 +30,7 @@ class Variation:
     def get_variable_by_key(self, key: str) -> Optional[Variable]:
         """Retrun a variable for the given key"""
         return next((v for v in self.variables if v.key == key), None)
+
+    def __str__(self):
+        return (f"Variation{{key:'{self.key}',"
+                f"variables:{StringUtils.object_to_string(self.variables)}}}")

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/configuration/variation_by_exposition.py

@@ -17,3 +17,10 @@ class VariationByExposition:
         self.variation_key: str = dict_json.get("variationKey", "")
         self.variation_id: Optional[int] = dict_json.get("variationId")
         self.exposition: float = dict_json.get("exposition", 0.0)
+
+    def __str__(self):
+        return (
+            f"VariationByExposition{{exposition:{self.exposition},"
+            f"variation_key:'{self.variation_key}',"
+            f"variation_id:{self.variation_id}}}"
+        )

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/__init__.py

@@ -1,29 +1,31 @@
 """ Imports all kameleoon data objects """
 
-from .custom_data import CustomData
 from .browser import Browser, BrowserType
 from .conversion import Conversion
-from .device import Device, DeviceType
-from .page_view import PageView
-from .user_agent import UserAgent
-from .data import Data, DataType
 from .cookie import Cookie
+from .custom_data import CustomData
+from .data import Data, DataType
+from .device import Device, DeviceType
 from .geolocation import Geolocation
 from .operating_system import OperatingSystem, OperatingSystemType
+from .page_view import PageView
+from .user_agent import UserAgent
+from .unique_identifier import UniqueIdentifier
 
 __all__ = [
-    "CustomData",
     "Browser",
     "BrowserType",
     "Conversion",
-    "Device",
-    "DeviceType",
-    "PageView",
-    "UserAgent",
+    "Cookie",
+    "CustomData",
     "Data",
     "DataType",
-    "Cookie",
+    "Device",
+    "DeviceType",
     "Geolocation",
-    "OperatingSystemType",
     "OperatingSystem",
+    "OperatingSystemType",
+    "PageView",
+    "UserAgent",
+    "UniqueIdentifier",
 ]

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/browser.py

@@ -51,10 +51,16 @@ class Browser(Data, DuplicationUnsafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.BROWSER
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
-        qb.extend(
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        query_builder.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
             QueryParam(QueryParams.BROWSER_INDEX, str(self.browser_type.value)),
         )
         if self.version:
-            qb.append(QueryParam(QueryParams.BROWSER_VERSION, str(self.version)))
+            query_builder.append(QueryParam(QueryParams.BROWSER_VERSION, str(self.version)))
+
+    def __str__(self):
+        return (
+            f"Browser{{browser_type:{self.__browser_type},"
+            f"version:{self.__version}}}"
+        )

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/conversion.py

@@ -51,12 +51,19 @@ class Conversion(Data, DuplicationSafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.CONVERSION
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
         # remove query_builder, it's done due due pylint issue with R0801 - duplicate_code,
         # need to update pylint and return str(QueryBuilder) straightaway
-        qb.extend(
+        query_builder.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
             QueryParam(QueryParams.GOAL_ID, str(self.goal_id)),
             QueryParam(QueryParams.REVENUE, str(self.revenue)),
             QueryParam(QueryParams.NEGATIVE, "true" if self.negative else "false"),
         )
+
+    def __str__(self):
+        return (
+            f"Conversion{{goal_id:{self.__goal_id},"
+            f"revenue:{self.__revenue},"
+            f"negative:{self.__negative}}}"
+        )

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/cookie.py

@@ -30,3 +30,6 @@ class Cookie(Data):
     @property
     def data_type(self) -> DataType:
         return DataType.COOKIE
+
+    def __str__(self):
+        return f"Cookie{{cookies:{self.__cookies}}}"

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/custom_data.py

@@ -30,7 +30,6 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
         # pylint: disable=W0511
         self.__id = id
         self.__values = args
-        self.is_mapping_identifier: bool = False
 
     @property
     def id(self) -> int:  # pylint: disable=C0103
@@ -49,13 +48,17 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
     def encode_query(self) -> str:
         return super().encode_query() if len(self.__values) > 0 else ""
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
         str_values = json.dumps({v: 1 for v in self.__values}, separators=(",", ":"))
-        qb.extend(
-            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
-            QueryParam(QueryParams.INDEX, str(self.id)),
+        query_builder.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE, False),
+            QueryParam(QueryParams.INDEX, str(self.id), False),
             QueryParam(QueryParams.VALUES_COUNT_MAP, str_values),
-            QueryParam(QueryParams.OVERWRITE, "true"),
+            QueryParam(QueryParams.OVERWRITE, "true", False),
+        )
+
+    def __str__(self):
+        return (
+            f"CustomData{{id:{self.__id},"
+            f"values:{self.__values}}}"
         )
-        if self.is_mapping_identifier:
-            qb.append(QueryParam(QueryParams.MAPPING_IDENTIFIER, "true"))

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/data.py

@@ -19,6 +19,7 @@ class DataType(IntEnum):
     PAGE_VIEW_VISIT = 10
     VISITOR_VISITS = 11
     KCS_HEAT = 12
+    UNIQUE_IDENTIFIER = 13
 
 
 class BaseData:
@@ -31,7 +32,7 @@ class BaseData:
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert class instance to dict"""
-        return self.__dict__
+        return {k: str(v) for k, v in self.__dict__.items()}
 
 
 class Data(BaseData):  # pylint: disable=W0223

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/device.py

@@ -40,8 +40,11 @@ class Device(Data, DuplicationUnsafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.DEVICE
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
-        qb.extend(
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        query_builder.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
             QueryParam(QueryParams.DEVICE_TYPE, self.device_type.value),
         )
+
+    def __str__(self):
+        return f"Device{{device_type:{self.__device_type}}}"

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/geolocation.py

@@ -82,19 +82,29 @@ class Geolocation(Data, DuplicationUnsafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.GEOLOCATION
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
-        qb.extend(
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        query_builder.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
         )
         if self.country:
-            qb.append(QueryParam(QueryParams.COUNTRY, self.country))
+            query_builder.append(QueryParam(QueryParams.COUNTRY, self.country))
         if self.region:
-            qb.append(QueryParam(QueryParams.REGION, self.region))
+            query_builder.append(QueryParam(QueryParams.REGION, self.region))
         if self.city:
-            qb.append(QueryParam(QueryParams.CITY, self.city))
+            query_builder.append(QueryParam(QueryParams.CITY, self.city))
         if self.postal_code:
-            qb.append(QueryParam(QueryParams.POSTAL_CODE, self.postal_code))
+            query_builder.append(QueryParam(QueryParams.POSTAL_CODE, self.postal_code))
         if self.latitude is not None:
-            qb.append(QueryParam(QueryParams.LATITUDE, str(self.latitude)))
+            query_builder.append(QueryParam(QueryParams.LATITUDE, str(self.latitude)))
         if self.longitude is not None:
-            qb.append(QueryParam(QueryParams.LONGITUDE, str(self.longitude)))
+            query_builder.append(QueryParam(QueryParams.LONGITUDE, str(self.longitude)))
+
+    def __str__(self):
+        return (
+            f"Geolocation{{country:'{self.country}',"
+            f"region:'{self.region}',"
+            f"city:'{self.city}',"
+            f"postal_code:'{self.postal_code}',"
+            f"latitude:{self.latitude},"
+            f"longitude:{self.longitude}}}"
+        )

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/kcs_heat.py

@@ -20,3 +20,6 @@ class KcsHeat(BaseData):
     @property
     def data_type(self) -> DataType:
         return DataType.KCS_HEAT
+
+    def __str__(self):
+        return f"KcsHeat{{values:{self.__values}}}"

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/manager/assigned_variation.py

@@ -1,3 +1,4 @@
+"""Assigned Variation"""
 import time
 from typing import Optional
 from kameleoon.configuration.rule_type import RuleType
@@ -7,6 +8,7 @@ from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParam
 
 
 class AssignedVariation(BaseData, DuplicationUnsafeSendableBase):
+    """Assigned variation"""
     EVENT_TYPE = "experiment"
 
     def __init__(
@@ -24,27 +26,32 @@ class AssignedVariation(BaseData, DuplicationUnsafeSendableBase):
 
     @property
     def experiment_id(self) -> int:
+        """Returns the experiment ID."""
         return self.__experiment_id
 
     @property
     def variation_id(self) -> int:
+        """Returns the variation ID."""
         return self.__variation_id
 
     @property
     def rule_type(self) -> RuleType:
+        """Returns the rule type associated with the variation."""
         return self.__rule_type
 
     @property
     def assignment_time(self) -> float:
+        """Returns the time when the assignment occurred."""
         return self.__assignment_time
 
     @property
     def data_type(self) -> DataType:
+        """Returns the data type for the assigned variation."""
         return DataType.ASSIGNED_VARIATION
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
         # fmt: off
-        qb.extend(
+        query_builder.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
             QueryParam(QueryParams.EXPERIMENT_ID, str(self.__experiment_id)),
             QueryParam(QueryParams.VARIATION_ID, str(self.__variation_id)),
@@ -52,4 +59,13 @@ class AssignedVariation(BaseData, DuplicationUnsafeSendableBase):
         # fmt: on
 
     def is_valid(self, respool_time: Optional[int]) -> bool:
+        """Checks if the assigned variation is valid based on the respool time."""
         return (respool_time is None) or (self.assignment_time >= respool_time)
+
+    def __str__(self):
+        return (
+            f"AssignedVariation{{experiment_id:{self.__experiment_id},"
+            f"variation_id:{self.__variation_id},"
+            f"assignment_time:{self.__assignment_time},"
+            f"rule_type:{self.__rule_type}}}"
+        )

{kameleoon-client-python-3.3.3 → kameleoon-client-python-3.5.0}/kameleoon/data/manager/page_view_visit.py

@@ -15,14 +15,17 @@ class PageViewVisit(BaseData):
         self.last_timestamp = last_timestamp or int(time.time() * 1000)
 
     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
 
     def merge(self, page_view_visit) -> None:
+        """Merges the visit data from another PageViewVisit instance into this one."""
         self.count += page_view_visit.count
         self.last_timestamp = max(self.last_timestamp, page_view_visit.last_timestamp)
 
     def increase_page_visits(self) -> None:
+        """Increases the visit count by 1."""
         self.count += 1
 
     @property
@@ -32,3 +35,10 @@ class PageViewVisit(BaseData):
     def __eq__(self, other: object) -> bool:
         return isinstance(other, PageViewVisit) and (other.page_view == self.page_view) and (
             other.count == self.count) and (other.last_timestamp == self.last_timestamp)
+
+    def __str__(self):
+        return (
+            f"PageViewVisit{{last_timestamp:{self.last_timestamp},"
+            f"count:{self.count},"
+            f"page_view:{self.page_view}}}"
+        )