kameleoon-client-python 2.3.0__tar.gz → 3.0.0__tar.gz

{kameleoon-client-python-2.3.0 → kameleoon-client-python-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kameleoon-client-python
-Version: 2.3.0
+Version: 3.0.0
 Summary: Kameleoon Client Python Software Development Kit.
 Home-page: https://developers.kameleoon.com/python-sdk.html
 Author: Kameleoon
@@ -92,7 +92,7 @@ variation (most likely a returning visitor that has already been exposed to the
 then it will return the previous variation assigned for the given experiment.
 
 ```python
-visitor_code = kameleoon_client.get_visitor_code(request.COOKIES)
+visitor_code = kameleoon_client.get_visitor_code(cookies_readonly=request.COOKIES)
 variation_id = 0
 try:
     variation_id = kameleoon_client.trigger_experiment(visitor_code, 135471)
@@ -168,9 +168,11 @@ The following example shows a sample django application wrapped by the Kameleoon
 import uuid
 
 from django.core.wsgi import get_wsgi_application
+from django.apps import apps
+kameleoon_app = apps.get_app_config("kameleoon_app")
 
 from kameleoon import KameleoonWSGIMiddleware
-application = KameleoonWSGIMiddleware(get_wsgi_application(), 'example.com', uuid.uuid4().hex)
+application = KameleoonWSGIMiddleware(get_wsgi_application(), kameleoon_app.kameleoon_client, uuid.uuid4().hex)
 ```
 
 You can then access the Kameleoon client in your views:
@@ -196,7 +198,7 @@ kameleoon_app = apps.get_app_config('your_app')
 client = kameleoon_app.kameleoon_client
 
 def view(request):
-    visitor_code = client.get_visitor_code(request.COOKIES)
+    visitor_code = client.get_visitor_code(cookies_readonly=request.COOKIES)
     variation_id = 0
     try:
         variation_id = client.trigger_experiment(visitor_code, 135471)
@@ -248,7 +250,7 @@ You need to pass the visitor_code and goal_id parameters so we can correctly
 track conversions for this particular visitor.
 
 ```python
-visitor_code = client.get_visitor_code(request.COOKIES)
+visitor_code = client.get_visitor_code(cookies_readonly=request.COOKIES)
 goal_id = 83023
 client.track_conversion(visitor_code, goal_id )
 ```

{kameleoon-client-python-2.3.0 → kameleoon-client-python-3.0.0}/README.md

@@ -69,7 +69,7 @@ variation (most likely a returning visitor that has already been exposed to the
 then it will return the previous variation assigned for the given experiment.
 
 ```python
-visitor_code = kameleoon_client.get_visitor_code(request.COOKIES)
+visitor_code = kameleoon_client.get_visitor_code(cookies_readonly=request.COOKIES)
 variation_id = 0
 try:
     variation_id = kameleoon_client.trigger_experiment(visitor_code, 135471)
@@ -145,9 +145,11 @@ The following example shows a sample django application wrapped by the Kameleoon
 import uuid
 
 from django.core.wsgi import get_wsgi_application
+from django.apps import apps
+kameleoon_app = apps.get_app_config("kameleoon_app")
 
 from kameleoon import KameleoonWSGIMiddleware
-application = KameleoonWSGIMiddleware(get_wsgi_application(), 'example.com', uuid.uuid4().hex)
+application = KameleoonWSGIMiddleware(get_wsgi_application(), kameleoon_app.kameleoon_client, uuid.uuid4().hex)
 ```
 
 You can then access the Kameleoon client in your views:
@@ -173,7 +175,7 @@ kameleoon_app = apps.get_app_config('your_app')
 client = kameleoon_app.kameleoon_client
 
 def view(request):
-    visitor_code = client.get_visitor_code(request.COOKIES)
+    visitor_code = client.get_visitor_code(cookies_readonly=request.COOKIES)
     variation_id = 0
     try:
         variation_id = client.trigger_experiment(visitor_code, 135471)
@@ -225,7 +227,7 @@ You need to pass the visitor_code and goal_id parameters so we can correctly
 track conversions for this particular visitor.
 
 ```python
-visitor_code = client.get_visitor_code(request.COOKIES)
+visitor_code = client.get_visitor_code(cookies_readonly=request.COOKIES)
 goal_id = 83023
 client.track_conversion(visitor_code, goal_id )
 ```

{kameleoon-client-python-2.3.0 → kameleoon-client-python-3.0.0}/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-client-python-3.0.0/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-client-python-2.3.0 → kameleoon-client-python-3.0.0}/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-client-python-2.3.0 → kameleoon-client-python-3.0.0}/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-client-python-3.0.0/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-client-python-3.0.0/kameleoon/configuration/settings.py

@@ -0,0 +1,28 @@
+"""Kameleoon Configuration"""
+
+from typing import Any, Dict, Optional
+
+
+class Settings:
+    """
+    KameleoonConfigurationSettings is used for saving setting's parameters, e.g
+    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.__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-client-python-2.3.0 → kameleoon-client-python-3.0.0}/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-client-python-2.3.0 → kameleoon-client-python-3.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-client-python-2.3.0 → kameleoon-client-python-3.0.0}/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-client-python-3.0.0/kameleoon/data/custom_data.py

@@ -0,0 +1,58 @@
+"""Custom data"""
+
+import json
+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, DuplicationUnsafeSendableBase):
+    """Custom data"""
+
+    EVENT_TYPE = "customData"
+
+    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`: str
+
+        Example:
+
+        .. code-block:: python3
+
+                kameleoon_client.add_data(visitor_code, CustomData(123, "some-value"))
+        """
+        # pylint: disable=invalid-name,redefined-builtin
+        super().__init__()
+        # 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=(",", ":"))
+        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-client-python-3.0.0/kameleoon/data/data.py

@@ -0,0 +1,32 @@
+""" Kameleoon data module"""
+from enum import IntEnum
+from typing import Any, Dict
+
+
+class DataType(IntEnum):
+    """Data types"""
+
+    CUSTOM_DATA = 0
+    BROWSER = 1
+    CONVERSION = 2
+    DEVICE = 3
+    PAGE_VIEW = 4
+    USER_AGENT = 5
+    ASSIGNED_VARIATION = 6
+
+
+class BaseData:
+    """Base data class"""
+
+    @property
+    def data_type(self) -> DataType:
+        """Returns data type of the instance"""
+        raise NotImplementedError
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert class instance to dict"""
+        return self.__dict__
+
+
+class Data(BaseData):  # pylint: disable=W0223
+    """Base external data class"""

{kameleoon-client-python-2.3.0 → kameleoon-client-python-3.0.0}/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-client-python-2.3.0 → kameleoon-client-python-3.0.0}/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-client-python-2.3.0 → kameleoon-client-python-3.0.0}/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-client-python-3.0.0/kameleoon/defaults.py

@@ -0,0 +1,9 @@
+"""Default constants"""
+
+import os
+
+BASE_DIR: str = os.path.dirname((os.path.dirname(__file__)))
+
+DEBUG: bool = True
+
+MILLISECONDS_IN_SECOND: int = 1000