kameleoon-client-python 2.3.0__py2.py3-none-any.whl → 3.0.0__py2.py3-none-any.whl

kameleoon/__init__.py

@@ -1,5 +1,6 @@
 """Kameleoon PYTHON SDK"""
 
 from .sdk_version import __version__  # noqa: F401
-from .client import KameleoonClient  # noqa: F401
+from .kameleoon_client import KameleoonClient  # noqa: F401
+from .kameleoon_client_config import KameleoonClientConfig  # noqa: F401
 from .middleware import KameleoonWSGIMiddleware  # noqa: F401

kameleoon/configuration/data_file.py

@@ -0,0 +1,63 @@
+"""Kameleoon Configuration"""
+
+from typing import Any, Dict, Optional
+from kameleoon.configuration.feature_flag import FeatureFlag
+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(), {})
+
+    @staticmethod
+    def from_json(environment: Optional[str], configuration: Dict[str, Any]) -> "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 []
+        }
+        return DataFile(environment, settings, feature_flags)
+
+    def __init__(self, environment: Optional[str], settings: Settings, feature_flags: Dict[str, FeatureFlag]) -> 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
+        )
+
+    @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 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

kameleoon/configuration/feature_flag.py

@@ -23,6 +23,7 @@ class FeatureFlag:
         self.variations: List[Variation] = Variation.from_array(
             dict_json.get("variations", [])
         )
+        self.environment_enabled = dict_json.get("environmentEnabled", False)
         self.rules: List[Rule] = Rule.from_array(dict_json.get("rules", []))
 
     def get_variation(self, key: str) -> Optional[Variation]:

kameleoon/configuration/rule.py

@@ -1,7 +1,7 @@
 """Kameleoon Configuration"""
 
-from enum import Enum
 from typing import Any, List, Dict, Optional
+from kameleoon.configuration.rule_type import RuleType, rule_type_from_literal
 from kameleoon.configuration.variation_by_exposition import VariationByExposition
 from kameleoon.targeting.models import Segment
 
@@ -11,12 +11,6 @@ class Rule:
     Rule is used for saving rule of feature flags (v2) with rules
     """
 
-    class Type(Enum):
-        """Possible types of rules"""
-
-        EXPERIMENTATION = "EXPERIMENTATION"
-        TARGETED_DELIVERY = "TARGETED_DELIVERY"
-
     @staticmethod
     def from_array(array: List[Dict[str, Any]]) -> List["Rule"]:
         """Create a list of Rules from the json array"""
@@ -26,7 +20,8 @@ class Rule:
     def __init__(self, dict_json: Dict[str, Any]):
         self.id_: int = dict_json["id"]
         self.order: int = dict_json.get("order", 0)
-        self.type: str = dict_json.get("type", "")
+        type_literal: str = dict_json.get("type", "")
+        self.type = rule_type_from_literal(type_literal)
         self.exposition: float = dict_json.get("exposition", 0.0)
         self.experiment_id: int = dict_json.get("experimentId", 0)
         self.respool_time: Optional[int] = dict_json.get("respoolTime", None)
@@ -50,10 +45,10 @@ class Rule:
     def is_experimentation(self) -> bool:
         """Return `true` if rule is `experimentation` type"""
 
-        return self.type == Rule.Type.EXPERIMENTATION.value
+        return self.type == RuleType.EXPERIMENTATION
 
     @property
     def is_targeted_delivery(self) -> bool:
         """Return `true` if rule is `targeted delivery` type"""
 
-        return self.type == Rule.Type.TARGETED_DELIVERY.value
+        return self.type == RuleType.TARGETED_DELIVERY

kameleoon/configuration/rule_type.py

@@ -0,0 +1,17 @@
+"""Kameleoon Configuration"""
+
+from enum import Enum
+from kameleoon.helpers.functions import enum_from_literal
+
+
+class RuleType(Enum):
+    """Possible types of rules"""
+
+    UNKNOWN: None = None
+    EXPERIMENTATION = "EXPERIMENTATION"
+    TARGETED_DELIVERY = "TARGETED_DELIVERY"
+
+
+def rule_type_from_literal(literal: str) -> RuleType:
+    """Converts rule type literal to RuleType value"""
+    return enum_from_literal(literal, RuleType, RuleType.UNKNOWN)

kameleoon/configuration/settings.py

@@ -9,8 +9,20 @@ class Settings:
     state of real time update for site code and etc
     """
 
+    _CONSENT_TYPE_REQUIRED = "REQUIRED"
+
     # pylint: disable=R0903
     def __init__(self, configuration: Optional[Dict[str, Any]] = None):
-        self.real_time_update: bool = bool(
-            configuration and configuration.get("realTimeUpdate")
-        )
+        self.__real_time_update: bool = bool(configuration and configuration.get("realTimeUpdate"))
+        self.__is_consent_required = (configuration is not None) and \
+            (configuration.get("consentType") == self._CONSENT_TYPE_REQUIRED)
+
+    @property
+    def real_time_update(self) -> bool:
+        """Returns streaming mode flag state"""
+        return self.__real_time_update
+
+    @property
+    def is_consent_required(self) -> bool:
+        """Returns consent required flag state"""
+        return self.__is_consent_required

kameleoon/configuration/variation_by_exposition.py

@@ -15,5 +15,5 @@ class VariationByExposition:
 
     def __init__(self, dict_json: Dict[str, Any]):
         self.variation_key: str = dict_json.get("variationKey", "")
-        self.variation_id: Optional[int] = dict_json.get("variationId", "")
-        self.exposition: int = dict_json.get("exposition", "")
+        self.variation_id: Optional[int] = dict_json.get("variationId")
+        self.exposition: float = dict_json.get("exposition", 0.0)

kameleoon/data/browser.py

@@ -3,7 +3,7 @@
 from enum import IntEnum
 from typing import Optional
 from kameleoon.data.data import Data, DataType
-from kameleoon.exceptions import KameleoonException
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
 
 
@@ -18,7 +18,7 @@ class BrowserType(IntEnum):
     OTHER: int = 5
 
 
-class Browser(Data):
+class Browser(Data, DuplicationUnsafeSendableBase):
     """Browser data"""
 
     EVENT_TYPE = "staticData"
@@ -34,18 +34,27 @@ class Browser(Data):
                 kameleoon_client.add_data(visitor_code, Browser(BrowserType.CHROME))
         """
         super().__init__()
-        self.browser_type = browser_type
-        self.version = version
-        self._instance: DataType = DataType.BROWSER
-
-    def obtain_full_post_text_line(self) -> str:
-        if self.browser_type < 0:
-            raise KameleoonException("Browser not recognized")
-        query_builder = QueryBuilder(
+        self.__browser_type = browser_type
+        self.__version = version
+
+    @property
+    def browser_type(self) -> BrowserType:
+        """Returns browser type"""
+        return self.__browser_type
+
+    @property
+    def version(self) -> Optional[float]:
+        """Returns version"""
+        return self.__version
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.BROWSER
+
+    def _add_query_params(self, qb: QueryBuilder) -> None:
+        qb.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
             QueryParam(QueryParams.BROWSER_INDEX, str(self.browser_type.value)),
-            QueryParam(QueryParams.NONCE, self._nonce),
         )
         if self.version:
-            query_builder.append(QueryParam(QueryParams.BROWSER_VERSION, str(self.version)))
-        return str(query_builder)
+            qb.append(QueryParam(QueryParams.BROWSER_VERSION, str(self.version)))

kameleoon/data/conversion.py

@@ -1,11 +1,12 @@
 # pylint: disable=duplicate-code
 """Conversion data"""
 from kameleoon.data.data import Data, DataType
+from kameleoon.network.sendable import DuplicationSafeSendableBase
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
 
 
 # pylint: disable=R0801
-class Conversion(Data):
+class Conversion(Data, DuplicationSafeSendableBase):
     """Conversion is used for tracking visitors conversions"""
 
     EVENT_TYPE = "conversion"
@@ -27,19 +28,35 @@ class Conversion(Data):
 
         """
         super().__init__()
-        self.goal_id = goal_id
-        self.revenue = revenue
-        self.negative = negative
-        self._instance: DataType = DataType.CONVERSION
-
-    def obtain_full_post_text_line(self) -> str:
+        self.__goal_id = goal_id
+        self.__revenue = revenue
+        self.__negative = negative
+
+    @property
+    def goal_id(self) -> int:
+        """Returns goal ID"""
+        return self.__goal_id
+
+    @property
+    def revenue(self) -> float:
+        """Returns revenue"""
+        return self.__revenue
+
+    @property
+    def negative(self) -> bool:
+        """Returns negative flag state"""
+        return self.__negative
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.CONVERSION
+
+    def _add_query_params(self, qb: 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
-        query_builder = QueryBuilder(
+        qb.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"),
-            QueryParam(QueryParams.NONCE, self._nonce),
         )
-        return str(query_builder)

kameleoon/data/custom_data.py

@@ -1,30 +1,23 @@
 """Custom data"""
 
 import json
-from typing import Optional, Tuple
-import warnings
+from typing import Tuple
 from kameleoon.data.data import Data, DataType
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
 
 
-class CustomData(Data):
+class CustomData(Data, DuplicationUnsafeSendableBase):
     """Custom data"""
 
     EVENT_TYPE = "customData"
 
-    @property
-    def values(self) -> Tuple[str, ...]:
-        """Stored values."""
-        return self.__values
-
-    def __init__(self, id: int, *args: str, value: Optional[str] = None) -> None:
+    def __init__(self, id: int, *args: str) -> None:
         """
         :param id: Index / ID of the custom data to be stored. This field is mandatory.
         :type id: int
         :param `*args`: Values of the custom data to be stored. This field is optional.
-        :type `*args`: Tuple[str, ...]
-        :param value: Single value of the custom data to be stored. This field is optional.
-        :type value: Optional[str]
+        :type `*args`: str
 
         Example:
 
@@ -34,27 +27,32 @@ class CustomData(Data):
         """
         # pylint: disable=invalid-name,redefined-builtin
         super().__init__()
-        self.id = str(id)
-        if value is None:
-            self.__values = args
-        else:
-            self.__values = (*args, value)
-            warnings.warn(
-                "Passing deprecated parameter `value`. Please pass variadic parameter list instead.",
-                category=DeprecationWarning,
-            )
-        self._instance: DataType = DataType.CUSTOM_DATA
-
-    def obtain_full_post_text_line(self) -> str:
-        if len(self.__values) == 0:
-            return ""
+        # pylint: disable=W0511
+        self.__id = id
+        self.__values = args
+
+    @property
+    def id(self) -> int:  # pylint: disable=C0103
+        """Returns ID"""
+        return self.__id
+
+    @property
+    def values(self) -> Tuple[str, ...]:
+        """Stored values."""
+        return self.__values
+
+    @property
+    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, qb: QueryBuilder) -> None:
         str_values = json.dumps({v: 1 for v in self.__values}, separators=(",", ":"))
-        return str(
-            QueryBuilder(
-                QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
-                QueryParam(QueryParams.INDEX, self.id),
-                QueryParam(QueryParams.VALUES_COUNT_MAP, str_values),
-                QueryParam(QueryParams.OVERWRITE, "true"),
-                QueryParam(QueryParams.NONCE, self._nonce),
-            )
+        qb.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
+            QueryParam(QueryParams.INDEX, str(self.id)),
+            QueryParam(QueryParams.VALUES_COUNT_MAP, str_values),
+            QueryParam(QueryParams.OVERWRITE, "true"),
         )

kameleoon/data/data.py

@@ -1,8 +1,6 @@
 """ Kameleoon data module"""
 from enum import IntEnum
-from typing import Any
-
-from kameleoon.network.post_body_line import PostBodyLine, get_nonce
+from typing import Any, Dict
 
 
 class DataType(IntEnum):
@@ -13,23 +11,22 @@ class DataType(IntEnum):
     CONVERSION = 2
     DEVICE = 3
     PAGE_VIEW = 4
+    USER_AGENT = 5
+    ASSIGNED_VARIATION = 6
 
 
-class Data(PostBodyLine):
+class BaseData:
     """Base data class"""
 
-    def __init__(self) -> None:
-        super().__init__()
-        self._nonce: str = get_nonce()
-        self.sent: bool = False
+    @property
+    def data_type(self) -> DataType:
+        """Returns data type of the instance"""
+        raise NotImplementedError
 
-    def to_dict(self) -> dict[str, Any]:
+    def to_dict(self) -> Dict[str, Any]:
         """Convert class instance to dict"""
         return self.__dict__
 
-    def obtain_full_post_text_line(self) -> str:
-        """
-        obtain full post text line
-        :return:
-        """
-        raise NotImplementedError
+
+class Data(BaseData):  # pylint: disable=W0223
+    """Base external data class"""

kameleoon/data/device.py

@@ -3,6 +3,7 @@
 
 from enum import Enum
 from kameleoon.data.data import Data, DataType
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
 
 
@@ -14,7 +15,7 @@ class DeviceType(Enum):
     DESKTOP: str = "DESKTOP"
 
 
-class Device(Data):
+class Device(Data, DuplicationUnsafeSendableBase):
     """Device data"""
 
     EVENT_TYPE = "staticData"
@@ -28,14 +29,19 @@ class Device(Data):
                 kameleoon_client.add_data(visitor_code, Device(DeviceType.PHONE))
         """
         super().__init__()
-        self.device_type = device_type
-        self._instance: DataType = DataType.DEVICE
-
-    def obtain_full_post_text_line(self) -> str:
-        return str(
-            QueryBuilder(
-                QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
-                QueryParam(QueryParams.DEVICE_TYPE, self.device_type.value),
-                QueryParam(QueryParams.NONCE, self._nonce),
-            )
+        self.__device_type = device_type
+
+    @property
+    def device_type(self) -> DeviceType:
+        """Returns device type"""
+        return self.__device_type
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.DEVICE
+
+    def _add_query_params(self, qb: QueryBuilder) -> None:
+        qb.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
+            QueryParam(QueryParams.DEVICE_TYPE, self.device_type.value),
         )

kameleoon/data/page_view.py

@@ -3,10 +3,11 @@
 import json
 from typing import List, Optional
 from kameleoon.data.data import Data, DataType
+from kameleoon.network.sendable import DuplicationSafeSendableBase
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
 
 
-class PageView(Data):
+class PageView(Data, DuplicationSafeSendableBase):
     """Page view"""
 
     EVENT_TYPE = "page"
@@ -27,19 +28,38 @@ class PageView(Data):
                 kameleoon_client.add_data(visitor_code, PageView("www.test.com", "test-title"))
         """
         super().__init__()
-        self.url = url
-        self.title = title
-        self.referrers = referrers
-        self._instance: DataType = DataType.PAGE_VIEW
+        self.__url = url
+        self.__title = title
+        self.__referrers = referrers
 
-    def obtain_full_post_text_line(self) -> str:
-        qb = QueryBuilder(  # pylint: disable=C0103
+    @property
+    def url(self) -> str:
+        """Returns URL"""
+        return self.__url
+
+    @property
+    def title(self) -> str:
+        """Returns title"""
+        return self.__title
+
+    @property
+    def referrers(self) -> Optional[List[int]]:
+        """Returns referrer list"""
+        return self.__referrers
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.PAGE_VIEW
+
+    def encode_query(self) -> str:
+        return super().encode_query() if len(self.__url) > 0 else ""
+
+    def _add_query_params(self, qb: QueryBuilder) -> None:
+        qb.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
             QueryParam(QueryParams.HREF, self.url),
             QueryParam(QueryParams.TITLE, self.title),
-            QueryParam(QueryParams.NONCE, self._nonce),
         )
         if self.referrers:
             str_referrers = json.dumps(self.referrers, separators=(",", ":"))
             qb.append(QueryParam(QueryParams.REFERRERS_INDICES, str_referrers))
-        return str(qb)

kameleoon/data/user_agent.py

@@ -1,6 +1,6 @@
 """User Agent data"""
 
-from kameleoon.data.data import Data
+from kameleoon.data.data import Data, DataType
 
 
 # pylint: disable=W0223,W0231
@@ -15,11 +15,17 @@ class UserAgent(Data):
         .. code-block:: python3
                 kameleoon_client.add_data(visitor_code, UserAgent('TestUserAgent'))
         """
-        self.value = value
+        super().__init__()
+        self.__value = value
 
-    def get_value(self) -> str:
+    @property
+    def value(self) -> str:
         """
         return user agent value
         :return:
         """
-        return self.value
+        return self.__value
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.USER_AGENT

kameleoon/defaults.py

@@ -4,38 +4,6 @@ import os
 
 BASE_DIR: str = os.path.dirname((os.path.dirname(__file__)))
 
-DEFAULT_CONFIGURATION_PATH: str = os.path.join(
-    "/etc", "kameleoon", "client-python.yaml"
-)
-
 DEBUG: bool = True
 
-DEFAULT_TIMEOUT_MILLISECONDS: int = 5000  # milli-seconds
 MILLISECONDS_IN_SECOND: int = 1000
-DEFAULT_TIMEOUT_SECONDS: float = (
-    DEFAULT_TIMEOUT_MILLISECONDS / MILLISECONDS_IN_SECOND
-)  # seconds
-
-DEFAULT_MILLISECONDS_BETWEEN_TARGETING_DATA_UPDATE: int = 1800000
-
-MINUTES_SESSION_DURATION: int = 30
-
-TARGETING_DATA_MAXIMUM_SIZE_BYTES = 500
-
-DEFAULT_VISITOR_DATA_MAXIMUM_SIZE = 500  # Mb
-
-KAMELEOON_COOKIE_NAME = "kameleoonVisitorCode"
-
-EXPIRE_DAYS = 380
-
-MAX_AGE = 32832000
-
-USER_AGENT_MAX_COUNT = 100_000
-
-KAMELEOON_COOKIE_VALUE_LENGTH = 16
-
-KAMELEOON_VISITOR_CODE_LENGTH = 255
-
-DEFAULT_CONFIGURATION_UPDATE_INTERVAL = 60 * 60  # sec
-
-KAMELEOON_KEY_JS_COOKIE = "_js_"