kameleoon-client-python 3.1.0__tar.gz → 3.2.0__tar.gz

{kameleoon-client-python-3.1.0 → kameleoon-client-python-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kameleoon-client-python
-Version: 3.1.0
+Version: 3.2.0
 Summary: Kameleoon Client Python Software Development Kit.
 Home-page: https://developers.kameleoon.com/python-sdk.html
 Author: Kameleoon
@@ -9,14 +9,12 @@ License: GPLv3
 Platform: UNKNOWN
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.6.0
+Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
 Provides-Extra: test
 

kameleoon-client-python-3.2.0/kameleoon/configuration/__init__.py

@@ -0,0 +1,9 @@
+""" Imports kameleoon configurations objects """
+
+from .variable import Variable
+from .variation import Variation
+
+__all__ = [
+    "Variable",
+    "Variation",
+]

kameleoon-client-python-3.2.0/kameleoon/configuration/custom_data_info.py

@@ -0,0 +1,51 @@
+"""Custom data info"""
+
+from logging import Logger
+from typing import Optional, Dict, Union, Any, List
+
+
+class CustomDataInfo:
+    """Custom data info"""
+
+    SCOPE_VISITOR = "VISITOR"
+
+    def __init__(
+        self, custom_data: Optional[List[Dict[str, Union[str, int, Any]]]], logger: Optional[Logger] = None
+    ) -> None:
+        super().__init__()
+        self.__mapping_identifier_index = None
+        self.__local_only = set()
+        self.__visitor_scope = set()
+        if custom_data is not None:
+            for data in custom_data:
+                index = data.get("index")
+                if index is not None:
+                    index = int(index)
+                    if data.get("localOnly"):
+                        self.__local_only.add(index)
+                    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(
+                                "More than one mapping identifier is set. Undefined behavior may occur" +
+                                " on cross-device reconciliation."
+                            )
+                        self.__mapping_identifier_index = index
+
+    def is_local_only(self, index: int) -> bool:
+        """Check for local only"""
+        return index in self.__local_only
+
+    def is_mapping_identifier(self, index: int) -> bool:
+        """Check for mapping identifier"""
+        return self.__mapping_identifier_index == index
+
+    def is_visitor_scope(self, index: int) -> bool:
+        """Check for visitor scope"""
+        return index in self.__visitor_scope
+
+    @property
+    def mapping_identifier_index(self) -> Optional[int]:
+        """Take mapping identifier index"""
+        return self.__mapping_identifier_index

kameleoon-client-python-3.2.0/kameleoon/configuration/data_file.py

@@ -0,0 +1,111 @@
+"""Kameleoon Configuration"""
+from logging import Logger
+from typing import Any, Dict, Optional
+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
+
+
+class DataFile:
+    """`DataFile` is a container for an actual client-configuration data"""
+
+    @staticmethod
+    def default(environment: Optional[str]) -> "DataFile":
+        """Creates new instance of `DataFile` initialized with default values"""
+        return DataFile(environment, Settings(), {}, CustomDataInfo(None))
+
+    @staticmethod
+    def from_json(
+        environment: Optional[str], configuration: Dict[str, Any], logger: Optional[Logger] = None
+    ) -> "DataFile":
+        """Creates new instance of `DataFile` initialized from the specified configuration JSON"""
+        settings = Settings(configuration.get("configuration"))
+        feature_flags = {
+            (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)
+
+    # pylint: disable=R0913
+    def __init__(
+        self,
+        environment: Optional[str],
+        settings: Settings,
+        feature_flags: Dict[str, FeatureFlag],
+        custom_data_info: CustomDataInfo,
+    ) -> None:
+        self.__environment = environment  # pylint: disable=W0238
+        self.__settings = settings
+        self.__feature_flags: Dict[str, FeatureFlag] = feature_flags
+        self.__has_any_targeted_delivery_rule = any(
+            rule.is_targeted_delivery
+            for ff in self.__feature_flags.values()
+            if ff.environment_enabled
+            for rule in ff.rules
+        )
+        self.__variation_by_id: Dict[int, VariationByExposition] = {}
+        self.__rule_by_segment_id: Dict[int, Rule] = {}
+        self.__feature_flag_by_id: Dict[int, FeatureFlag] = {}
+        self.__collect_indices()
+        self.__custom_data_info = custom_data_info
+
+    @property
+    def settings(self) -> Settings:
+        """Returns settings"""
+        return self.__settings
+
+    @property
+    def feature_flags(self) -> Dict[str, FeatureFlag]:
+        """Returns dictionary of all feature flags stored by feature keys"""
+        return self.__feature_flags
+
+    @property
+    def feature_flag_by_id(self) -> Dict[int, FeatureFlag]:
+        """Returns dictionary of all feature flags stored by id"""
+        return self.__feature_flag_by_id
+
+    @property
+    def rule_by_segment_id(self) -> Dict[int, Rule]:
+        """Returns dictionary of all rule stored by segment id"""
+        return self.__rule_by_segment_id
+
+    @property
+    def variation_by_id(self) -> Dict[int, VariationByExposition]:
+        """Returns dictionary of all variations stored by id"""
+        return self.__variation_by_id
+
+    @property
+    def has_any_targeted_delivery_rule(self) -> bool:
+        """Returns `True` if has a feature flag with a rule of the targeted delivery type, otherwise returns `False`"""
+        return self.__has_any_targeted_delivery_rule
+
+    def get_feature_flag(self, feature_key: str) -> FeatureFlag:
+        """
+        Returns feature flag with the specified feature key if it exists,
+        otherwise raises `FeatureNotFound` exception.
+        """
+        feature_flag = self.__feature_flags.get(feature_key)
+        if feature_flag is None:
+            raise FeatureNotFound(feature_key)
+        if not feature_flag.environment_enabled:
+            raise FeatureEnvironmentDisabled(feature_key, self.__environment)
+        return feature_flag
+
+    @property
+    def custom_data_info(self) -> CustomDataInfo:
+        """Returns custom data info for mapping device`"""
+        return self.__custom_data_info
+
+    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:
+                for rule in feature_flag.rules:
+                    self.__rule_by_segment_id[rule.segment_id] = rule
+                    for variation in rule.variation_by_exposition:
+                        if variation.variation_id is not None:
+                            self.__variation_by_id[variation.variation_id] = variation

{kameleoon-client-python-3.1.0 → kameleoon-client-python-3.2.0}/kameleoon/configuration/rule.py

@@ -28,8 +28,10 @@ class Rule:
         self.variation_by_exposition: List[VariationByExposition] = VariationByExposition.from_array(
             dict_json.get("variationByExposition", [])
         )
+        self.first_variation = self.variation_by_exposition[0] if len(self.variation_by_exposition) > 0 else None
         segment = dict_json.get("segment")
         self.targeting_segment: Optional[Segment] = Segment(segment) if segment else None
+        self.segment_id: int = self.targeting_segment.id_ if self.targeting_segment else -1
 
     def get_variation(self, hash_double: float) -> Optional[VariationByExposition]:
         """Calculates the variation key for the given hash of visitor"""

{kameleoon-client-python-3.1.0 → kameleoon-client-python-3.2.0}/kameleoon/configuration/variable.py

@@ -39,3 +39,7 @@ class Variable:
         if self.__type == Variable.Type.JSON.value and isinstance(self.__value, str):
             return json.loads(self.__value)
         return None
+
+    def get_type(self) -> str:
+        """Returns type value of variable"""
+        return self.__type

{kameleoon-client-python-3.1.0 → kameleoon-client-python-3.2.0}/kameleoon/data/__init__.py

@@ -7,6 +7,9 @@ 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 .geolocation import Geolocation
+from .operating_system import OperatingSystem, OperatingSystemType
 
 __all__ = [
     "CustomData",
@@ -19,4 +22,8 @@ __all__ = [
     "UserAgent",
     "Data",
     "DataType",
+    "Cookie",
+    "Geolocation",
+    "OperatingSystemType",
+    "OperatingSystem",
 ]

kameleoon-client-python-3.2.0/kameleoon/data/cookie.py

@@ -0,0 +1,32 @@
+"""Cookie data"""
+
+from typing import Dict
+from kameleoon.data.data import Data, DataType
+
+
+class Cookie(Data):
+    """Cookie data"""
+
+    def __init__(self, cookies: Dict[str, str]) -> None:
+        """
+        :param cookies: values cookie from visitor
+        :type cookies: Dict[str, str]
+
+        Example:
+        .. code-block:: python3
+                kameleoon_client.add_data(visitor_code, Cookie({'key1' : 'value1'}))
+        """
+        super().__init__()
+        self.__cookies = cookies
+
+    @property
+    def cookies(self) -> Dict[str, str]:
+        """
+        :return: cookie values
+        :rtype: Dict[str, str]
+        """
+        return self.__cookies
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.COOKIE

{kameleoon-client-python-3.1.0 → kameleoon-client-python-3.2.0}/kameleoon/data/custom_data.py

@@ -30,6 +30,7 @@ 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
@@ -56,3 +57,5 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
             QueryParam(QueryParams.VALUES_COUNT_MAP, str_values),
             QueryParam(QueryParams.OVERWRITE, "true"),
         )
+        if self.is_mapping_identifier:
+            qb.append(QueryParam(QueryParams.MAPPING_IDENTIFIER, "true"))

{kameleoon-client-python-3.1.0 → kameleoon-client-python-3.2.0}/kameleoon/data/data.py

@@ -13,6 +13,11 @@ class DataType(IntEnum):
     PAGE_VIEW = 4
     USER_AGENT = 5
     ASSIGNED_VARIATION = 6
+    COOKIE = 7
+    OPERATING_SYSTEM = 8
+    GEOLOCATION = 9
+    PAGE_VIEW_VISIT = 10
+    VISITOR_VISITS = 11
 
 
 class BaseData:

kameleoon-client-python-3.2.0/kameleoon/data/geolocation.py

@@ -0,0 +1,100 @@
+# pylint: disable=duplicate-code
+"""Geolocation data"""
+
+from typing import Optional
+from kameleoon.data.data import Data, DataType
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
+from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
+
+
+class Geolocation(Data, DuplicationUnsafeSendableBase):
+    """Geolocation data"""
+
+    EVENT_TYPE = "staticData"
+
+    # pylint: disable=R0913
+    def __init__(
+        self,
+        country: str,
+        region: Optional[str] = None,
+        city: Optional[str] = None,
+        postal_code: Optional[str] = None,
+        latitude: Optional[float] = None,
+        longitude: Optional[float] = None,
+    ) -> None:
+        """
+        :param country: required
+        :type country: str
+        :param region:
+        :type region: Optional[str]
+        :param city:
+        :type city: Optional[str]
+        :param postal_code:
+        :type postal_code: Optional[str]
+        :param latitude:
+        :type latitude: Optional[float]
+        :param longitude:
+        :type longitude: Optional[float]
+
+        Example:
+        .. code-block:: python3
+                kameleoon_client.add_data(visitor_code, Geolocation("France"))
+        """
+        super().__init__()
+        self.__country = country
+        self.__region = region
+        self.__city = city
+        self.__postal_code = postal_code
+        self.__latitude = latitude
+        self.__longitude = longitude
+
+    @property
+    def country(self) -> Optional[str]:
+        """Returns country"""
+        return self.__country
+
+    @property
+    def region(self) -> Optional[str]:
+        """Returns region"""
+        return self.__region
+
+    @property
+    def city(self) -> Optional[str]:
+        """Returns city"""
+        return self.__city
+
+    @property
+    def postal_code(self) -> Optional[str]:
+        """Returns postal_code"""
+        return self.__postal_code
+
+    @property
+    def latitude(self) -> Optional[float]:
+        """Returns latitude"""
+        return self.__latitude
+
+    @property
+    def longitude(self) -> Optional[float]:
+        """Returns longitude"""
+        return self.__longitude
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.GEOLOCATION
+
+    def _add_query_params(self, qb: QueryBuilder) -> None:
+        qb.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
+        )
+        if self.country:
+            qb.append(QueryParam(QueryParams.COUNTRY, self.country))
+        if self.region:
+            qb.append(QueryParam(QueryParams.REGION, self.region))
+        if self.city:
+            qb.append(QueryParam(QueryParams.CITY, self.city))
+        if self.postal_code:
+            qb.append(QueryParam(QueryParams.POSTAL_CODE, self.postal_code))
+        if self.latitude is not None:
+            qb.append(QueryParam(QueryParams.LATITUDE, str(self.latitude)))
+        if self.longitude is not None:
+            qb.append(QueryParam(QueryParams.LONGITUDE, str(self.longitude)))

kameleoon-client-python-3.2.0/kameleoon/data/operating_system.py

@@ -0,0 +1,52 @@
+# pylint: disable=duplicate-code
+"""Operating system data"""
+
+from enum import IntEnum
+from kameleoon.data.data import Data, DataType
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
+from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
+
+
+class OperatingSystemType(IntEnum):
+    """Operating system types"""
+
+    WINDOWS: int = 0
+    MAC: int = 1
+    IOS: int = 2
+    LINUX: int = 3
+    ANDROID: int = 4
+    WINDOWS_PHONE: int = 5
+
+
+class OperatingSystem(Data, DuplicationUnsafeSendableBase):
+    """Operating system data"""
+
+    EVENT_TYPE = "staticData"
+
+    def __init__(self, os_type: OperatingSystemType) -> None:
+        """
+        :param os_type: OperatingSystemType, can be: WINDOWS, MAC, IOS, LINUX, ANDROID, WINDOWS_PHONE
+        :type os_type: OperatingSystemType
+
+        Example:
+        .. code-block:: python3
+                kameleoon_client.add_data(visitor_code, OperatingSystem(OperatingSystemType.ANDROID))
+        """
+        super().__init__()
+        self.__os_type = os_type
+
+    @property
+    def os_type(self) -> OperatingSystemType:
+        """Returns operating system type"""
+        return self.__os_type
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.OPERATING_SYSTEM
+
+    def _add_query_params(self, qb: QueryBuilder) -> None:
+        qb.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
+            QueryParam(QueryParams.OPERATING_SYSTEM, self.os_type.name),
+            QueryParam(QueryParams.OPERATING_SYSTEM_INDEX, str(self.os_type.value)),
+        )

{kameleoon-client-python-3.1.0 → kameleoon-client-python-3.2.0}/kameleoon/data/page_view.py

@@ -12,12 +12,12 @@ class PageView(Data, DuplicationSafeSendableBase):
 
     EVENT_TYPE = "page"
 
-    def __init__(self, url: str, title: str, referrers: Optional[List[int]] = None) -> None:
+    def __init__(self, url: str, title: Optional[str], referrers: Optional[List[int]] = None) -> None:
         """
         :param url: Url of the page
         :type url: str
-        :param title: Title of the page
-        :type title: str
+        :param title: Optional field - Title of the page
+        :type title: Optional[str]
         :param referrers: Optional field - Referrer ids
         :type referrers: Optional[List[int]]
 
@@ -38,7 +38,7 @@ class PageView(Data, DuplicationSafeSendableBase):
         return self.__url
 
     @property
-    def title(self) -> str:
+    def title(self) -> Optional[str]:
         """Returns title"""
         return self.__title
 
@@ -58,8 +58,9 @@ class PageView(Data, DuplicationSafeSendableBase):
         qb.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
             QueryParam(QueryParams.HREF, self.url),
-            QueryParam(QueryParams.TITLE, self.title),
         )
+        if self.title:
+            qb.append(QueryParam(QueryParams.TITLE, self.title))
         if self.referrers:
             str_referrers = json.dumps(self.referrers, separators=(",", ":"))
             qb.append(QueryParam(QueryParams.REFERRERS_INDICES, str_referrers))

kameleoon-client-python-3.2.0/kameleoon/data/visitor_visits.py

@@ -0,0 +1,29 @@
+"""Visitor visits"""
+
+from typing import List, Optional
+
+from kameleoon.data import DataType
+
+from kameleoon.data.data import BaseData
+
+
+class VisitorVisits(BaseData):
+    """Visitor visits"""
+
+    def __init__(self, previous_visit_timestamps: List[int]) -> None:
+        super().__init__()
+        self.__previous_visit_timestamps = previous_visit_timestamps
+
+    @property
+    def previous_visit_timestamps(self) -> List[int]:
+        """Return timestamps for visit"""
+        return self.__previous_visit_timestamps
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.VISITOR_VISITS
+
+    @staticmethod
+    def get_previous_visit_timestamps(visitor_visits: Optional["VisitorVisits"]) -> List[int]:
+        """Return timestamps for visit"""
+        return visitor_visits.previous_visit_timestamps if visitor_visits is not None else []

{kameleoon-client-python-3.1.0 → kameleoon-client-python-3.2.0}/kameleoon/helpers/functions.py

@@ -66,3 +66,20 @@ def enum_from_literal(literal: str, enum_type: Type[E], default_value: E) -> E:
         return enum_type(literal)
     except ValueError:
         return default_value
+
+
+def enum_from_name_literal(literal: str, enum_type: Type[E], default_value: Optional[E]) -> Optional[E]:
+    """
+    Converts enum name literal to enum value.
+    Returns default enum value if literal does not correspond any enum name.
+    """
+    try:
+        return enum_type[literal]
+    except ValueError:
+        return default_value
+
+
+def compare_str_ignore_case(value_1: Optional[str], value_2: Optional[str]) -> bool:
+    """Comparing two strings ignoring case."""
+    return (value_1 == value_2 or
+            ((value_1 is not None and value_2 is not None) and value_1.lower() == value_2.lower()))