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

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

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

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

@@ -3,4 +3,5 @@
 from .sdk_version import __version__  # noqa: F401
 from .kameleoon_client import KameleoonClient  # noqa: F401
 from .kameleoon_client_config import KameleoonClientConfig  # noqa: F401
+from .kameleoon_client_factory import KameleoonClientFactory  # noqa: F401
 from .middleware import KameleoonWSGIMiddleware  # noqa: F401

kameleoon-client-python-3.3.3/kameleoon/client_readiness/async_readiness.py

@@ -0,0 +1,48 @@
+"Async Client Readiness"
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from collections import defaultdict
+from typing import Dict
+from kameleoon.client_readiness.threading_readiness import ThreadingClientReadiness
+
+
+class AsyncClientReadiness:
+    """
+    A class that provides an asynchronous interface for checking client readiness.
+
+    This class wraps around a `ThreadingClientReadiness` object to provide asynchronous
+    methods for waiting for the client to be ready. It uses a thread pool executor to
+    run blocking operations in a separate thread.
+    """
+
+    def __init__(self, inner: ThreadingClientReadiness) -> None:
+        """
+        Initializes an AsyncClientReadiness instance.
+        """
+        super().__init__()
+        self._inner = inner
+        self._executor: Dict[int, ThreadPoolExecutor] = defaultdict(ThreadPoolExecutor)
+
+    @property
+    def inner(self) -> ThreadingClientReadiness:
+        """
+        Returns the inner ThreadingClientReadiness instance.
+        """
+        return self._inner
+
+    def dispose_on_set(self) -> None:
+        """
+        Disposes of the executors by clearing the executor dictionary.
+        """
+        self._executor.clear()
+
+    async def wait(self) -> bool:
+        """
+        Asynchronously waits for the client readiness operation to complete.
+        """
+        if self._inner.is_initializing:
+            executor = self._executor[0]
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(executor, self._inner.wait)
+        return self._inner.success

kameleoon-client-python-3.3.3/kameleoon/client_readiness/threading_readiness.py

@@ -0,0 +1,36 @@
+"ThreadingClientReadiness"
+from threading import Lock
+
+
+class ThreadingClientReadiness:
+    def __init__(self) -> None:
+        self._is_initializing = False
+        self._success = False
+        self._condition = Lock()
+        self.reset()
+
+    @property
+    def is_initializing(self) -> bool:
+        return self._is_initializing
+
+    @property
+    def success(self) -> bool:
+        return self._success
+
+    def reset(self) -> None:
+        self._success = False
+        if not self._is_initializing:
+            self._is_initializing = True
+            self._condition.acquire()
+
+    def set(self, success: bool) -> None:
+        self._success = success
+        if self._is_initializing:
+            self._condition.release()
+            self._is_initializing = False
+
+    def wait(self) -> bool:
+        if self._is_initializing:
+            with self._condition:
+                pass
+        return self._success

kameleoon-client-python-3.3.3/kameleoon/data/manager/assigned_variation.py

@@ -0,0 +1,55 @@
+import time
+from typing import Optional
+from kameleoon.configuration.rule_type import RuleType
+from kameleoon.data.data import BaseData, DataType
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
+from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
+
+
+class AssignedVariation(BaseData, DuplicationUnsafeSendableBase):
+    EVENT_TYPE = "experiment"
+
+    def __init__(
+        self,
+        experiment_id: int,
+        variation_id: int,
+        rule_type: RuleType = RuleType.UNKNOWN,
+        assignment_time: Optional[float] = None,
+    ) -> None:
+        super().__init__()
+        self.__experiment_id = experiment_id
+        self.__variation_id = variation_id
+        self.__rule_type = rule_type
+        self.__assignment_time = assignment_time or time.time()
+
+    @property
+    def experiment_id(self) -> int:
+        return self.__experiment_id
+
+    @property
+    def variation_id(self) -> int:
+        return self.__variation_id
+
+    @property
+    def rule_type(self) -> RuleType:
+        return self.__rule_type
+
+    @property
+    def assignment_time(self) -> float:
+        return self.__assignment_time
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.ASSIGNED_VARIATION
+
+    def _add_query_params(self, qb: QueryBuilder) -> None:
+        # fmt: off
+        qb.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
+            QueryParam(QueryParams.EXPERIMENT_ID, str(self.__experiment_id)),
+            QueryParam(QueryParams.VARIATION_ID, str(self.__variation_id)),
+        )
+        # fmt: on
+
+    def is_valid(self, respool_time: Optional[int]) -> bool:
+        return (respool_time is None) or (self.assignment_time >= respool_time)

kameleoon-client-python-3.3.3/kameleoon/data/manager/page_view_visit.py

@@ -0,0 +1,34 @@
+"""Page view visit"""
+import time
+from typing import Optional
+from kameleoon.data import DataType
+from kameleoon.data.data import BaseData
+from kameleoon.data.page_view import PageView
+
+
+class PageViewVisit(BaseData):
+    """Page view visit"""
+    def __init__(self, page_view: PageView, count=1, last_timestamp: Optional[int] = None) -> None:
+        super().__init__()
+        self.page_view = page_view
+        self.count = count
+        self.last_timestamp = last_timestamp or int(time.time() * 1000)
+
+    def overwrite(self, new_page_view: PageView) -> None:
+        self.page_view = new_page_view
+        self.count += 1
+
+    def merge(self, page_view_visit) -> None:
+        self.count += page_view_visit.count
+        self.last_timestamp = max(self.last_timestamp, page_view_visit.last_timestamp)
+
+    def increase_page_visits(self) -> None:
+        self.count += 1
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.PAGE_VIEW_VISIT
+
+    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)

kameleoon-client-python-3.3.3/kameleoon/data/manager/visitor.py

@@ -0,0 +1,261 @@
+from threading import Lock
+from typing import Any, Callable, Optional, Dict, List, Iterator, cast
+
+from logging import Logger
+from kameleoon.data.visitor_visits import VisitorVisits
+from kameleoon.data.data import Data
+from kameleoon.data.browser import Browser
+from kameleoon.data.conversion import Conversion
+from kameleoon.data.cookie import Cookie
+from kameleoon.data.custom_data import CustomData
+from kameleoon.data.device import Device
+from kameleoon.data.geolocation import Geolocation
+from kameleoon.data.kcs_heat import KcsHeat
+from kameleoon.data.operating_system import OperatingSystem
+from kameleoon.data.page_view import PageView
+from kameleoon.data.user_agent import UserAgent
+from kameleoon.data.manager.assigned_variation import AssignedVariation
+from kameleoon.data.manager.page_view_visit import PageViewVisit
+from kameleoon.network.sendable import Sendable
+
+
+EMPTY_DICT: Dict[Any, Any] = {}
+EMPTY_LIST: List[Any] = []
+
+
+class Visitor:
+    def __init__(self) -> None:
+        self._lock = Lock()
+        self._user_agent: Optional[str] = None
+        self._device: Optional[Device] = None
+        self._browser: Optional[Browser] = None
+        self._geolocation: Optional[Geolocation] = None
+        self._operating_system: Optional[OperatingSystem] = None
+        self._cookie: Optional[Cookie] = None
+        self._custom_data_dict: Optional[Dict[int, CustomData]] = None
+        self._page_view_visits: Optional[Dict[str, PageViewVisit]] = None
+        self._conversions: Optional[List[Conversion]] = None
+        self._variations: Optional[Dict[int, AssignedVariation]] = None
+        self._kcs_heat: Optional[KcsHeat] = None
+        self._visitor_visits: Optional[VisitorVisits] = None
+        self._mapping_identifier: Optional[str] = None
+        self.legal_consent = False
+
+    def enumerate_sendable_data(self) -> Iterator[Sendable]:
+        if self._device:
+            yield self._device
+        if self._browser:
+            yield self._browser
+        if self._geolocation:
+            yield self._geolocation
+        if self._operating_system:
+            yield self._operating_system
+        if self._custom_data_dict is not None:
+            yield from list(self._custom_data_dict.values())
+        if self._page_view_visits is not None:
+            yield from (visit.page_view for visit in list(self._page_view_visits.values()))
+        if self._conversions is not None:
+            yield from list(self._conversions)
+        if self._variations is not None:
+            yield from list(self._variations.values())
+
+    def count_sendable_data(self) -> int:
+        count = 0
+        if self._device is not None:
+            count += 1
+        if self._browser is not None:
+            count += 1
+        if self._geolocation is not None:
+            count += 1
+        if self._operating_system is not None:
+            count += 1
+        if self._custom_data_dict is not None:
+            count += len(self._custom_data_dict)
+        if self._page_view_visits is not None:
+            count += len(self._page_view_visits)
+        if self._conversions is not None:
+            count += len(self._conversions)
+        if self._variations is not None:
+            count += len(self._variations)
+        return count
+
+    @property
+    def user_agent(self) -> Optional[str]:
+        return self._user_agent
+
+    @property
+    def device(self) -> Optional[Device]:
+        return self._device
+
+    @property
+    def browser(self) -> Optional[Browser]:
+        return self._browser
+
+    @property
+    def geolocation(self) -> Optional[Geolocation]:
+        return self._geolocation
+
+    @property
+    def operating_system(self) -> Optional[OperatingSystem]:
+        return self._operating_system
+
+    @property
+    def cookie(self) -> Optional[Cookie]:
+        return self._cookie
+
+    @property
+    def custom_data(self) -> Dict[int, CustomData]:
+        return EMPTY_DICT if self._custom_data_dict is None else self._custom_data_dict.copy()
+
+    @property
+    def page_view_visits(self) -> Dict[str, PageViewVisit]:
+        return EMPTY_DICT if self._page_view_visits is None else self._page_view_visits.copy()
+
+    @property
+    def conversions(self) -> List[Conversion]:
+        return EMPTY_LIST if self._conversions is None else self._conversions.copy()
+
+    @property
+    def variations(self) -> Dict[int, AssignedVariation]:
+        return EMPTY_DICT if self._variations is None else self._variations.copy()
+
+    @property
+    def kcs_heat(self) -> Optional[KcsHeat]:
+        return self._kcs_heat
+
+    @property
+    def visitor_visits(self) -> Optional[VisitorVisits]:
+        return self._visitor_visits
+
+    def assign_variation(self, variation: AssignedVariation) -> None:
+        if self._variations is None:
+            with self._lock:
+                if self._variations is None:
+                    self._variations = {variation.experiment_id: variation}
+                    return
+        self._variations[variation.experiment_id] = variation
+
+    def add_data(self, *args, overwrite: bool = True, logger: Optional[Logger] = None) -> None:
+        with self._lock:
+            for data in args:
+                data_type = type(data)
+                data_adder = DATA_ADDERS.get(data_type)
+                if data_adder:
+                    data_adder(self.DataAddingContext(self, data, overwrite, logger))
+                elif logger:
+                    logger.error(f"Data has unsupported type '{data_type}'")
+
+    @property
+    def mapping_identifier(self):
+        return self._mapping_identifier
+
+    class DataAddingContext:
+        def __init__(
+            self, visitor: "Visitor", data: Data, overwrite: bool = True, logger: Optional[Logger] = None
+        ) -> None:
+            self.visitor = visitor
+            self.data = data
+            self.overwrite = overwrite
+            self.logger = logger
+
+    @staticmethod
+    def _set_user_agent(c: DataAddingContext) -> None:
+        c.visitor._user_agent = cast(UserAgent, c.data).value
+
+    @staticmethod
+    def _set_device(c: DataAddingContext) -> None:
+        if c.overwrite or c.visitor._device is None:
+            c.visitor._device = cast(Device, c.data)
+
+    @staticmethod
+    def _add_variation(c: DataAddingContext) -> None:
+        variation = cast(AssignedVariation, c.data)
+        if c.visitor._variations is None:
+            c.visitor._variations = {}
+        if c.overwrite or variation.experiment_id not in c.visitor.variations:
+            c.visitor._variations[variation.experiment_id] = variation
+
+    @staticmethod
+    def _set_browser(c: DataAddingContext) -> None:
+        if c.overwrite or c.visitor._browser is None:
+            c.visitor._browser = cast(Browser, c.data)
+
+    @staticmethod
+    def _set_geolocation(c: DataAddingContext) -> None:
+        if c.overwrite or c.visitor._geolocation is None:
+            c.visitor._geolocation = cast(Geolocation, c.data)
+
+    @staticmethod
+    def _set_operating_system(c: DataAddingContext) -> None:
+        if c.overwrite or c.visitor._operating_system is None:
+            c.visitor._operating_system = cast(OperatingSystem, c.data)
+
+    @staticmethod
+    def _set_cookie(c: DataAddingContext) -> None:
+        c.visitor._cookie = cast(Cookie, c.data)
+
+    @staticmethod
+    def _add_custom_data(c: DataAddingContext) -> None:
+        custom_data = cast(CustomData, c.data)
+        if c.visitor._custom_data_dict is None:
+            c.visitor._custom_data_dict = {}
+        if c.overwrite or custom_data.id not in c.visitor._custom_data_dict:
+            c.visitor._custom_data_dict[custom_data.id] = custom_data
+
+    @staticmethod
+    def _add_page_view(c: DataAddingContext) -> None:
+        page_view = cast(PageView, c.data)
+        if len(page_view.url) == 0:
+            if c.logger:
+                c.logger.error("Passed PageView data is invalid because of empty 'url' field; the data was ignored.")
+            return
+        if c.visitor._page_view_visits is None:
+            c.visitor._page_view_visits = {page_view.url: PageViewVisit(page_view)}
+        else:
+            if visit := c.visitor._page_view_visits.get(page_view.url):
+                visit.overwrite(page_view)
+            else:
+                c.visitor._page_view_visits[page_view.url] = PageViewVisit(page_view)
+
+    @staticmethod
+    def _add_page_view_visit(c: DataAddingContext) -> None:
+        page_view_visit = cast(PageViewVisit, c.data)
+        if c.visitor._page_view_visits is None:
+            c.visitor._page_view_visits = {}
+        if visit := c.visitor._page_view_visits.get(page_view_visit.page_view.url):
+            visit.merge(page_view_visit)
+        else:
+            c.visitor._page_view_visits[page_view_visit.page_view.url] = page_view_visit
+
+    @staticmethod
+    def _add_conversion(c: DataAddingContext) -> None:
+        conversion = cast(Conversion, c.data)
+        if c.visitor._conversions is None:
+            c.visitor._conversions = [conversion]
+        else:
+            c.visitor._conversions.append(conversion)
+
+    @staticmethod
+    def _set_kcs_heat(c: DataAddingContext) -> None:
+        c.visitor._kcs_heat = cast(KcsHeat, c.data)
+
+    @staticmethod
+    def _set_visitor_visits(c: DataAddingContext) -> None:
+        c.visitor._visitor_visits = cast(VisitorVisits, c.data)
+
+
+DATA_ADDERS: Dict[type, Callable[[Visitor.DataAddingContext], None]] = {
+    UserAgent: Visitor._set_user_agent,
+    Device: Visitor._set_device,
+    Browser: Visitor._set_browser,
+    Geolocation: Visitor._set_geolocation,
+    OperatingSystem: Visitor._set_operating_system,
+    Cookie: Visitor._set_cookie,
+    CustomData: Visitor._add_custom_data,
+    PageView: Visitor._add_page_view,
+    PageViewVisit: Visitor._add_page_view_visit,
+    Conversion: Visitor._add_conversion,
+    KcsHeat: Visitor._set_kcs_heat,
+    VisitorVisits: Visitor._set_visitor_visits,
+    AssignedVariation: Visitor._add_variation,
+}

kameleoon-client-python-3.3.3/kameleoon/data/manager/visitor_manager.py

@@ -0,0 +1,112 @@
+import collections
+import time
+from typing import Dict, Iterator, Optional
+from logging import Logger
+from kameleoon.data import CustomData
+from kameleoon.configuration.custom_data_info import CustomDataInfo
+from kameleoon.data.manager.visitor import Visitor
+from kameleoon.data.manager.visitor_slot import VisitorSlot
+from kameleoon.helpers.scheduler import Scheduler
+
+
+class VisitorManager:
+
+    def __init__(self, expiration_period: float, scheduler: Scheduler) -> None:
+        self.__expiration_period = expiration_period
+        self._slots: Dict[str, VisitorSlot] = collections.defaultdict(VisitorSlot)
+        self.custom_data_info: Optional[CustomDataInfo] = None
+        scheduler.schedule_job("VisitorManager.purge", expiration_period, self.__purge)
+
+    def __iter__(self) -> Iterator[str]:
+        yield from list(self._slots)
+
+    def __len__(self) -> int:
+        return len(self._slots)
+
+    def get_visitor(self, visitor_code: str) -> Optional[Visitor]:
+        if (slot := self.__try_acquire_slot(visitor_code)) is None:
+            return None
+        try:
+            if slot.visitor is not None:
+                slot.update_last_activity_time()
+            return slot.visitor
+        finally:
+            slot.lock.release()
+
+    def get_or_create_visitor(self, visitor_code: str) -> Visitor:
+        slot = self.__acquire_slot(visitor_code)
+        try:
+            if slot.visitor is None:
+                slot.visitor = Visitor()
+            else:
+                slot.update_last_activity_time()
+            return slot.visitor
+        finally:
+            slot.lock.release()
+
+    def add_data(self, visitor_code: str, *args, logger: Optional[Logger] = None):
+        visitor = self.get_or_create_visitor(visitor_code)
+        for custom_data in args:
+            if not isinstance(custom_data, CustomData):
+                continue
+            # We shouldn't send custom data with local only type
+            if self.custom_data_info and self.custom_data_info.is_local_only(custom_data.id):
+                custom_data.mark_as_sent()
+            # If mappingIdentifier is passed, we should link anonymous visitor with real unique userId.
+            # After authorization, customer must be able to continue work with userId, but hash for variation
+            # should be calculated based on anonymous visitor code, that's why set MappingIdentifier to visitor.
+            if (
+                self.custom_data_info is not None
+                and self.custom_data_info.is_mapping_identifier(custom_data.id)
+                and len(custom_data.values) > 0
+                and len(custom_data.values[0]) > 0
+            ):
+                custom_data.is_mapping_identifier = True
+                visitor._mapping_identifier = visitor_code
+                target_visitor_code = custom_data.values[0]
+                if visitor_code != target_visitor_code:
+                    slot = self.__acquire_slot(target_visitor_code)
+                    try:
+                        slot.visitor = visitor
+                    finally:
+                        slot.lock.release()
+        visitor.add_data(*args, logger=logger)
+        return visitor
+
+    def __purge(self) -> None:
+        expired_time = time.time() - self.__expiration_period
+        for visitor_code in list(self._slots):
+            if slot := self.__try_acquire_slot_once(visitor_code):
+                try:
+                    if (slot.visitor is None) or (slot.last_activity_time < expired_time):
+                        self._slots.pop(visitor_code, None)
+                finally:
+                    slot.lock.release()
+
+    def __acquire_slot(self, visitor_code: str) -> VisitorSlot:
+        while True:
+            slot = self._slots[visitor_code]
+            slot.lock.acquire()
+            if slot == self._slots.get(visitor_code):
+                return slot
+            slot.lock.release()
+
+    def __try_acquire_slot(self, visitor_code: str) -> Optional[VisitorSlot]:
+        while True:
+            slot = self._slots.get(visitor_code)
+            if slot is None:
+                return None
+            slot.lock.acquire()
+            if slot == self._slots.get(visitor_code):
+                return slot
+            slot.lock.release()
+
+    def __try_acquire_slot_once(self, visitor_code: str) -> Optional[VisitorSlot]:
+        slot = self._slots.get(visitor_code)
+        if slot is None:
+            return None
+        slot.lock.acquire()
+        if slot == self._slots.get(visitor_code):
+            return slot
+        slot.lock.release()
+        return None

kameleoon-client-python-3.3.3/kameleoon/data/manager/visitor_slot.py

@@ -0,0 +1,15 @@
+import time
+from threading import Lock
+from typing import Optional
+from kameleoon.data.manager.visitor import Visitor
+
+
+class VisitorSlot:
+    def __init__(self) -> None:
+        self.lock = Lock()
+        self.visitor: Optional[Visitor] = None
+        self.last_activity_time = 0.0
+        self.update_last_activity_time()
+
+    def update_last_activity_time(self) -> None:
+        self.last_activity_time = time.time()

kameleoon-client-python-3.3.3/kameleoon/hybrid/hybrid_manager.py

@@ -0,0 +1,7 @@
+from typing import Dict, Optional
+from kameleoon.data.manager.assigned_variation import AssignedVariation
+
+
+class HybridManager:
+    def get_engine_tracking_code(self, visitor_variations: Optional[Dict[int, AssignedVariation]]) -> str:
+        raise NotImplementedError()

kameleoon-client-python-3.3.3/kameleoon/hybrid/hybrid_manager_impl.py

@@ -0,0 +1,25 @@
+import time
+from typing import Dict, Optional
+from kameleoon.data.manager.assigned_variation import AssignedVariation
+from kameleoon.hybrid.hybrid_manager import HybridManager
+
+
+class HybridManagerImpl(HybridManager):
+    TC_INIT = "window.kameleoonQueue=window.kameleoonQueue||[];"
+    TC_ASSIGN_VARIATION_F = "window.kameleoonQueue.push(['Experiments.assignVariation',{0},{1}]);"
+    TC_TRIGGER_F = "window.kameleoonQueue.push(['Experiments.trigger',{0},true]);"
+    TC_ASSIGN_VARIATION_TRIGGER_F = TC_ASSIGN_VARIATION_F + TC_TRIGGER_F
+
+    def __init__(self, expiration_period: float) -> None:
+        super().__init__()
+        self._expiration_period = expiration_period
+
+    def get_engine_tracking_code(self, visitor_variations: Optional[Dict[int, AssignedVariation]]) -> str:
+        lines = [self.TC_INIT]
+        if visitor_variations:
+            expiration_time = time.time() - self._expiration_period
+            for variation in visitor_variations.values():
+                if variation.assignment_time > expiration_time:
+                    line = self.TC_ASSIGN_VARIATION_TRIGGER_F.format(variation.experiment_id, variation.variation_id)
+                    lines.append(line)
+        return "".join(lines)

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.3.3}/kameleoon/kameleoon_client.py

@@ -1106,7 +1106,7 @@ class KameleoonClient:
         return (feature_flag, variation_key)
 
     def __assign_feature_variation(
-            self, visitor_code: str, rule: Optional[Rule], variation: Optional[VariationByExposition]
+        self, visitor_code: str, rule: Optional[Rule], variation: Optional[VariationByExposition]
     ) -> None:
         if rule is not None:
             visitor = self._visitor_manager.get_or_create_visitor(visitor_code)