kameleoon-client-python 3.9.0__tar.gz → 3.11.0__tar.gz

{kameleoon-client-python-3.9.0 → kameleoon-client-python-3.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kameleoon-client-python
-Version: 3.9.0
+Version: 3.11.0
 Summary: Kameleoon Client Python Software Development Kit.
 Home-page: https://developers.kameleoon.com/python-sdk.html
 Author: Kameleoon

kameleoon-client-python-3.11.0/kameleoon/data/cbscores.py

@@ -0,0 +1,66 @@
+"""CBScores"""
+
+from typing import Dict, Iterable, List
+from kameleoon.helpers.string_utils import StringUtils
+from kameleoon.data import DataType
+from kameleoon.data.data import BaseData
+
+
+# pylint: disable=R0903
+class ScoredVarId:
+    """ScoredVarId"""
+    def __init__(self, variation_id: int, score: float) -> None:
+        self.variation_id = variation_id
+        self.score = score
+
+
+class VarGroup:
+    """VarGroup"""
+    def __init__(self, ids: List[int]) -> None:
+        ids.sort()
+        self.__ids = ids
+
+    @property
+    def ids(self) -> List[int]:
+        """Returns the IDs"""
+        return self.__ids
+
+    def __str__(self) -> str:
+        return f"VarGroup{{ids:{self.__ids}}}"
+
+
+class CBScores(BaseData):
+    """CBScores"""
+
+    def __init__(self, cbs_map: Dict[int, Iterable[ScoredVarId]]) -> None:
+        super().__init__()
+        self.__values = {cbs_key: self.__extract_var_ids(cbs_value) for cbs_key, cbs_value in cbs_map.items()}
+
+    @property
+    def values(self) -> Dict[int, List[VarGroup]]:
+        """
+        Returns the CB variation groups stored by experiment.
+
+        keys = experiment IDs / values = list of variation IDs ordered descending
+        by score (there may be several variation ids with same score)
+        """
+        return self.__values
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.CBS
+
+    @staticmethod
+    def __extract_var_ids(scores: Iterable[ScoredVarId]) -> List[VarGroup]:
+        grouped: Dict[float, List[int]] = {}
+        for score in scores:
+            glist = grouped.get(score.score)
+            if glist:
+                glist.append(score.variation_id)
+            else:
+                grouped[score.score] = [score.variation_id]
+        return [VarGroup(grouped[score]) for score in sorted(grouped, reverse=True)]
+
+    def __str__(self) -> str:
+        values = StringUtils.object_to_string(self.__values)
+        return f"CBScores{{values:{values}}}"

{kameleoon-client-python-3.9.0 → kameleoon-client-python-3.11.0}/kameleoon/data/conversion.py

@@ -1,6 +1,11 @@
 # pylint: disable=duplicate-code
 """Conversion data"""
+
+import json
+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.network.sendable import DuplicationSafeSendableBase
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
 
@@ -11,7 +16,13 @@ class Conversion(Data, DuplicationSafeSendableBase):
 
     EVENT_TYPE = "conversion"
 
-    def __init__(self, goal_id: int, revenue: float = 0.0, negative: bool = False) -> None:
+    def __init__(
+        self,
+        goal_id: int,
+        revenue: float = 0.0,
+        negative: bool = False,
+        metadata: Optional[Iterable[CustomData]] = None,
+    ) -> None:
         """
         :param goal_id: Id of the goal associated to the conversion
         :type goal_id: int
@@ -19,6 +30,8 @@ class Conversion(Data, DuplicationSafeSendableBase):
         :type revenue: float
         :param negative: Optional field - If the revenue is negative. By default it's positive, defaults to False
         :type negative: bool
+        :param metadata: Optional field - Metadata of the conversion. `None` by default.
+        :type metadata: Optional[Iterable[CustomData]]
 
         Example:
 
@@ -31,6 +44,7 @@ class Conversion(Data, DuplicationSafeSendableBase):
         self.__goal_id = goal_id
         self.__revenue = revenue
         self.__negative = negative
+        self.__metadata = metadata
 
     @property
     def goal_id(self) -> int:
@@ -47,6 +61,11 @@ class Conversion(Data, DuplicationSafeSendableBase):
         """Returns negative flag state"""
         return self.__negative
 
+    @property
+    def metadata(self) -> Optional[Iterable[CustomData]]:
+        """Returns metadata"""
+        return self.__metadata
+
     @property
     def data_type(self) -> DataType:
         return DataType.CONVERSION
@@ -60,10 +79,23 @@ class Conversion(Data, DuplicationSafeSendableBase):
             QueryParam(QueryParams.REVENUE, str(self.revenue)),
             QueryParam(QueryParams.NEGATIVE, "true" if self.negative else "false"),
         )
+        if self.metadata:
+            query_builder.append(QueryParam(QueryParams.METADATA, self.__encode_metadata()))
+
+    def __encode_metadata(self) -> str:
+        metadata = {}
+        if self.metadata is not None:
+            added_indices = set()
+            for mcd in self.metadata:
+                if isinstance(mcd, CustomData) and (mcd.id not in added_indices):
+                    metadata[mcd.id] = mcd.values
+                    added_indices.add(mcd.id)
+        return json.dumps(metadata, separators=(",", ":"))
 
     def __str__(self):
         return (
             f"Conversion{{goal_id:{self.__goal_id},"
             f"revenue:{self.__revenue},"
-            f"negative:{self.__negative}}}"
+            f"negative:{self.__negative},"
+            f"metadata:{StringUtils.object_to_string(self.__metadata)}}}"
         )

{kameleoon-client-python-3.9.0 → kameleoon-client-python-3.11.0}/kameleoon/data/custom_data.py

@@ -45,9 +45,6 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.CUSTOM_DATA
 
-    def encode_query(self) -> str:
-        return super().encode_query() if len(self.__values) > 0 else ""
-
     def _add_query_params(self, query_builder: QueryBuilder) -> None:
         str_values = json.dumps({v: 1 for v in self.__values}, separators=(",", ":"))
         query_builder.extend(
@@ -58,7 +55,4 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
         )
 
     def __str__(self):
-        return (
-            f"CustomData{{id:{self.__id},"
-            f"values:{self.__values}}}"
-        )
+        return f"CustomData{{id:{self.__id},values:{self.__values}}}"

{kameleoon-client-python-3.9.0 → kameleoon-client-python-3.11.0}/kameleoon/data/data.py

@@ -22,6 +22,7 @@ class DataType(IntEnum):
     UNIQUE_IDENTIFIER = 13
     FORCED_EXPERIMENT_VARIATION = 14
     FORCED_FEATURE_VARIATION = 15
+    CBS = 16
 
 
 class BaseData:

{kameleoon-client-python-3.9.0 → kameleoon-client-python-3.11.0}/kameleoon/data/manager/visitor.py

@@ -5,6 +5,7 @@ from typing import Any, Callable, Optional, Dict, List, Iterator, Iterable, cast
 from kameleoon.data.visitor_visits import VisitorVisits
 from kameleoon.data.data import Data
 from kameleoon.data.browser import Browser
+from kameleoon.data.cbscores import CBScores
 from kameleoon.data.conversion import Conversion
 from kameleoon.data.cookie import Cookie
 from kameleoon.data.custom_data import CustomData
@@ -172,6 +173,13 @@ class Visitor:  # pylint: disable=R0904
         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)
+        return cbs
+
     @property
     def visitor_visits(self) -> Optional[VisitorVisits]:
         """Returns the visitor visits data associated with this Visitor."""
@@ -261,6 +269,7 @@ class Visitor:  # pylint: disable=R0904
             self.forced_variations: Optional[Dict[int, ForcedExperimentVariation]] = None
             self.simulated_variations: Optional[Dict[str, ForcedFeatureVariation]] = None
             self.kcs_heat: Optional[KcsHeat] = None
+            self.cbscores: Optional[CBScores] = None
             self.visitor_visits: Optional[VisitorVisits] = None
             self.mapping_identifier: Optional[str] = None
             self.legal_consent = False
@@ -403,6 +412,10 @@ class Visitor:  # pylint: disable=R0904
     def _set_kcs_heat(self, context: DataAddingContext) -> None:
         self._data.kcs_heat = cast(KcsHeat, context.data)
 
+    def _set_cbscores(self, context: DataAddingContext) -> None:
+        if context.overwrite or self._data.cbscores is None:
+            self._data.cbscores = cast(CBScores, context.data)
+
     def _set_visitor_visits(self, context: DataAddingContext) -> None:
         self._data.visitor_visits = cast(VisitorVisits, context.data)
 
@@ -425,6 +438,7 @@ class Visitor:  # pylint: disable=R0904
         PageViewVisit: _add_page_view_visit,
         Conversion: _add_conversion,
         KcsHeat: _set_kcs_heat,
+        CBScores: _set_cbscores,
         VisitorVisits: _set_visitor_visits,
         AssignedVariation: _add_variation,
         ForcedFeatureVariation: _add_forced_feature_variation,

kameleoon-client-python-3.11.0/kameleoon/helpers/domain.py

@@ -0,0 +1,83 @@
+"""Helper for domain"""
+import re
+from typing import Optional
+
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
+
+HTTP = "http://"
+HTTPS = "https://"
+REGEX_DOMAIN = (
+    r"^(\.?(([a-zA-Z\d][a-zA-Z\d-]*[a-zA-Z\d])|[a-zA-Z\d]))"
+    r"(\.(([a-zA-Z\d][a-zA-Z\d-]*[a-zA-Z\d])|[a-zA-Z\d])){1,126}$"
+)
+LOCALHOST = "localhost"
+
+
+def validate_top_level_domain(top_level_domain: str) -> str:
+    """
+    Validate the given top-level domain.
+
+    Args:
+        top_level_domain (str): The top-level domain to validate.
+
+    Returns:
+        str: The validated top-level domain.
+    """
+    if top_level_domain == "":
+        return top_level_domain
+
+    top_level_domain = check_and_trim_protocol(top_level_domain.lower())
+
+    if not re.match(REGEX_DOMAIN, top_level_domain) and top_level_domain != LOCALHOST:
+        KameleoonLogger.error(
+            f"The top-level domain '{top_level_domain}' is invalid. The value has been set as provided, but it does "
+            f"not meet the required format for proper SDK functionality. Please check the domain for correctness.")
+        return top_level_domain
+
+    return top_level_domain
+
+
+def validate_network_domain(network_domain: Optional[str]) -> Optional[str]:
+    """
+    Validate the given network domain.
+
+    Args:
+        network_domain: The network domain to validate.
+
+    Returns:
+        str or None: The validated network domain, or None if invalid.
+    """
+    if not network_domain:
+        return None
+
+    network_domain = check_and_trim_protocol(network_domain.lower())
+
+    # Replace first and last dot
+    network_domain = re.sub(r"^\.+|\.+$", "", network_domain)
+
+    if not re.match(REGEX_DOMAIN, network_domain) and network_domain != LOCALHOST:
+        KameleoonLogger.error(f"The network domain '{network_domain}' is invalid.")
+        return None
+
+    return network_domain
+
+
+def check_and_trim_protocol(domain: str) -> str:
+    """
+    Check if the domain contains a protocol and trim it if it does.
+
+    Args:
+        domain: The domain to check and trim.
+
+    Returns:
+        str: The domain after trimming the protocol.
+    """
+    protocols = [HTTP, HTTPS]
+    for protocol in protocols:
+        if domain.startswith(protocol):
+            domain = domain[len(protocol):]
+            KameleoonLogger.warning(
+                f"The domain contains '{protocol}'. Domain after protocol trimming: '{domain}'"
+            )
+            return domain
+    return domain

{kameleoon-client-python-3.9.0 → kameleoon-client-python-3.11.0}/kameleoon/helpers/string_utils.py

@@ -1,5 +1,6 @@
 """Helper class for work with string values"""
 
+import collections.abc
 from typing import Any, Optional
 
 
@@ -31,6 +32,8 @@ class StringUtils:
     @staticmethod
     def object_to_string(data: Any) -> str:
         """Convert various data types into their string representation."""
+        if data is None:
+            return "None"
         if isinstance(data, str):
             return f"'{data}'"
         result = StringUtils._collection_to_string(data)
@@ -38,19 +41,17 @@ class StringUtils:
             return result
         if isinstance(data, bool):
             return StringUtils.bool_to_string_lower_case(data)
-        if data is None:
-            return "None"
         if hasattr(data, '__str__'):
             return str(data)
         return repr(data)
 
     @staticmethod
     def _collection_to_string(data: Any) -> Optional[str]:
-        if isinstance(data, (list, tuple)):
-            return "[" + ",".join(StringUtils.object_to_string(item) for item in data) + "]"
         if isinstance(data, dict):
             return "{" + ",".join(
                 f"{StringUtils.object_to_string(key)}: {StringUtils.object_to_string(value)}"
                 for key, value in data.items()
             ) + "}"
+        if isinstance(data, collections.abc.Iterable):
+            return "[" + ",".join(StringUtils.object_to_string(item) for item in data) + "]"
         return None