kameleoon-client-python 3.22.0__py2.py3-none-any.whl → 3.22.2__py2.py3-none-any.whl

kameleoon/data/manager/visitor_manager.py

@@ -67,17 +67,15 @@ class VisitorManager:
             KameleoonLogger.debug("RETURN: VisitorManager.get_or_create_visitor(visitor_code: %s)", visitor_code)
 
     def peek_visitor(self, visitor_code: str) -> Optional[Visitor]:
-        """Retrieves a visitor by their code if it exists, otherwise returns `None`."""
-        KameleoonLogger.debug(f"CALL: VisitorManager.peekVisitor(visitor_code: {visitor_code})")
-        if (slot := self.__try_acquire_slot(visitor_code)) is None:
-            visitor = None
-        else:
-            try:
-                visitor = slot.visitor
-            finally:
-                slot.lock.release()
+        """
+        Retrieves a visitor by their code if it exists, otherwise returns `None`. Unlike `get_visitor`, does not
+        count as visitor activity and takes no lock: a plain read needs no protection against the purge.
+        """
+        KameleoonLogger.debug("CALL: VisitorManager.peek_visitor(visitor_code: %s)", visitor_code)
+        slot = self._slots.get(visitor_code)
+        visitor = slot.visitor if slot is not None else None
         KameleoonLogger.debug(
-            f"RETURN: VisitorManager.peekVisitor(visitor_code: {visitor_code}) -> " f"(visitor: {visitor})"
+            "RETURN: VisitorManager.peek_visitor(visitor_code: %s) -> (visitor: %s)", visitor_code, visitor
         )
         return visitor
 
@@ -180,7 +178,7 @@ class VisitorManager:
         while True:
             slot = self._slots[visitor_code]
             slot.lock.acquire()
-            if slot == self._slots.get(visitor_code):
+            if slot is self._slots.get(visitor_code):
                 return slot
             slot.lock.release()
 
@@ -190,7 +188,7 @@ class VisitorManager:
             if slot is None:
                 return None
             slot.lock.acquire()
-            if slot == self._slots.get(visitor_code):
+            if slot is self._slots.get(visitor_code):
                 return slot
             slot.lock.release()
 
@@ -199,7 +197,7 @@ class VisitorManager:
         if slot is None:
             return None
         slot.lock.acquire()
-        if slot == self._slots.get(visitor_code):
+        if slot is self._slots.get(visitor_code):
             return slot
         slot.lock.release()
         return None

kameleoon/helpers/multi_threading.py

@@ -12,6 +12,10 @@ class ThreadEventLoop:
     ThreadEventLoop is helper object to handle asynchronous tasks execution in a separate thread.
     """
 
+    # Upper bound for `stop` to wait for the running tasks and for the thread to exit; a task that never
+    # completes (or a loop thread blocked by a synchronous call) must not hang the disposal forever.
+    STOP_TIMEOUT = 10.0
+
     def __init__(self) -> None:
         self.loop: Optional[asyncio.AbstractEventLoop] = None
         self.thread: Optional[threading.Thread] = None
@@ -40,17 +44,38 @@ class ThreadEventLoop:
         return self.loop
 
     def stop(self) -> None:
-        """Stops the thread and the event loop"""
+        """
+        Stops the thread and the event loop.
+
+        Waits (up to `STOP_TIMEOUT`) for the already scheduled tasks to complete before stopping the loop.
+        """
         if self.thread is None:
             return
         self.running_allowed = False
-        time.sleep(0.001)
-        while self.count_tasks() > 0:
-            time.sleep(0.01)
         loop = self.get_loop()
+        if threading.current_thread() is self.thread:
+            # Called from the loop's own thread (e.g. a GC-triggered `__del__`): it cannot wait for or join itself.
+            loop.call_soon(loop.stop)
+            return
+        # The draining runs on the loop itself, after everything already queued (e.g. tasks being created by
+        # `run_coroutine_threadsafe`), so it observes the tasks a cross-thread `all_tasks` poll could miss.
+        drained = asyncio.run_coroutine_threadsafe(self.__wait_for_tasks(), loop)
+        try:
+            drained.result(timeout=self.STOP_TIMEOUT)
+        except Exception:  # pylint: disable=W0703
+            drained.cancel()
         loop.call_soon_threadsafe(loop.stop)
-        self.thread.join()
-        loop.close()
+        self.thread.join(timeout=self.STOP_TIMEOUT)
+        if not self.thread.is_alive():
+            loop.close()
+
+    @staticmethod
+    async def __wait_for_tasks() -> None:
+        while True:
+            tasks = [task for task in asyncio.all_tasks() if task is not asyncio.current_task()]
+            if not tasks:
+                return
+            await asyncio.wait(tasks, timeout=ThreadEventLoop.STOP_TIMEOUT)
 
     def run_coro(self, coro: Coroutine[Any, Any, Any]) -> Optional[concurrent.futures.Future[Any]]:
         """
@@ -66,10 +91,6 @@ class ThreadEventLoop:
             self.start()
         return asyncio.run_coroutine_threadsafe(coro, self.get_loop())
 
-    def count_tasks(self) -> int:
-        """Returns the number of running tasks."""
-        return len(asyncio.all_tasks(self.get_loop()))
-
 
 def run_in_thread(
     func: Callable[[], Any], thread_name: Optional[str] = None, with_event_loop=False
@@ -86,16 +107,15 @@ def run_in_thread(
     :rtype: threading.Thread
     """
     if with_event_loop:
+
         def target():
             loop = asyncio.new_event_loop()
             func()
             loop.close()
+
     else:
         target = func
-    thread = threading.Thread(target=target)
-    thread.daemon = True
-    if thread_name:
-        thread.setName(thread_name)
+    thread = threading.Thread(target=target, name=thread_name or None, daemon=True)
     thread.start()
     return thread
 

kameleoon/helpers/scheduler.py

@@ -42,10 +42,14 @@ class Scheduler:
 
     def stop(self) -> None:
         """
-        Starts all scheduled jobs.
+        Stops all scheduled jobs.
 
         Should not be called more than once.
         """
+        if self._loop.is_closed():
+            # The jobs died with the loop; nothing left to stop (e.g. disposal after the host app closed its loop).
+            KameleoonLogger.debug("Scheduler is not stopped: event loop is already closed")
+            return
         try:
             self._loop.call_soon_threadsafe(self._stop)
         except Exception as err:  # pylint: disable=W0703
@@ -53,8 +57,7 @@ class Scheduler:
 
     def _stop(self) -> None:
         for job in self._jobs.values():
-            if job.stop_signal is not None:
-                job.stop_signal.set()
+            job.stop()
 
     class Job:
         """`Job` represents a scheduled job"""
@@ -65,13 +68,24 @@ class Scheduler:
             self.func = func
             self.stop_signal: Optional[asyncio.Event] = None
             self.future: Optional[concurrent.futures.Future[Any]] = None
+            self._stop_requested = False
 
         def run(self, loop: asyncio.AbstractEventLoop) -> None:
             """Starts the job execution in the given event loop."""
             if self.future is None:
                 self.future = asyncio.run_coroutine_threadsafe(self._cycle(), loop)
 
+        def stop(self) -> None:
+            """Requests the job to stop. Must be called on the job's event loop."""
+            # `stop_signal` only exists once `_cycle` has started; a stop posted with `call_soon_threadsafe` right
+            # after `run` is processed before the task's first step, so the request has to be remembered as well.
+            self._stop_requested = True
+            if self.stop_signal is not None:
+                self.stop_signal.set()
+
         async def _cycle(self) -> None:
+            if self._stop_requested:
+                return
             self.stop_signal = asyncio.Event()
             interval = self.interval
             stop_task = asyncio.create_task(self.stop_signal.wait())

kameleoon/helpers/string_utils.py

@@ -9,7 +9,7 @@ class StringUtils:
 
     @staticmethod
     def secret(secret: Optional[str]) -> str:
-        """Hide part of the string, keeping only a few initial characters visible."""
+        """Hides the string behind a fixed-width mask, keeping only a few trailing characters visible."""
         hid_ch = '*'
         vis_count = 4
 
@@ -21,8 +21,7 @@ class StringUtils:
         if length <= vis_count:
             return hid_ch * length
 
-        hidden_length = max(length - vis_count, vis_count)
-        return secret[:length - hidden_length] + hid_ch * hidden_length
+        return hid_ch * vis_count + secret[max(length - vis_count, vis_count):]
 
     @staticmethod
     def bool_to_string_lower_case(data: bool) -> str:

kameleoon/managers/tracking/tracking_manager.py

@@ -1,5 +1,6 @@
 """Tracking"""
-from typing import Iterable, List
+import asyncio
+from typing import Iterable, List, Optional
 from kameleoon.data.manager.visitor_manager import VisitorManager
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.managers.asyncexec.async_executor import AsyncExecutor
@@ -7,7 +8,7 @@ from kameleoon.managers.data.data_manager import DataManager
 from kameleoon.managers.tracking.tracking_builder import TrackingBuilder
 from kameleoon.managers.tracking.visitor_tracking_registry import (
     VisitorTrackingRegistry,
-    LockVisitorTrackingRegistry,
+    ConcurrentVisitorTrackingRegistry,
 )
 from kameleoon.network.net_provider import Response
 from kameleoon.network.network_manager import NetworkManager
@@ -19,6 +20,7 @@ class TrackingManager:
     """Tracking manager"""
     LINES_DELIMITER = "\n"
     REQUEST_SIZE_LIMIT = 2560 * 1024  # 2.5 * 1024^2 characters
+    PROBE_MAX_VISITORS = 1
 
     # pylint: disable=R0913
     def __init__(
@@ -30,7 +32,8 @@ class TrackingManager:
             "CALL: TrackingManager(data_manager, network_manager. visitor_manager, "
             "track_interval_seconds: %s, scheduler)", track_interval_seconds
         )
-        self._tracking_visitors: VisitorTrackingRegistry = LockVisitorTrackingRegistry(visitor_manager)
+        self._tracking_visitors: VisitorTrackingRegistry = ConcurrentVisitorTrackingRegistry(visitor_manager)
+        self._probe_mode = False
         self._data_manager = data_manager
         self._network_manager = network_manager
         self._visitor_manager = visitor_manager
@@ -41,6 +44,11 @@ class TrackingManager:
             "track_interval_seconds: %s, scheduler)", track_interval_seconds
         )
 
+    @property
+    def probe_mode(self) -> bool:
+        """Test purpose only"""
+        return self._probe_mode
+
     def add_visitor_code(self, visitor_code: str) -> None:
         """Adds a visitor code to the tracking registry."""
         KameleoonLogger.debug("CALL: TrackingManager.add_visitor_code(visitor_code: %s)", visitor_code)
@@ -54,7 +62,10 @@ class TrackingManager:
         `track_all` is triggered by the interval tracking timer.
         """
         KameleoonLogger.debug("CALL: TrackingManager.track_all()")
-        self.__track(self._tracking_visitors.extract())
+        if self._probe_mode:
+            self.__track_probe()
+        else:
+            self.__track(self._tracking_visitors.extract())
         KameleoonLogger.debug("RETURN: TrackingManager.track_all()")
 
     def track_visitor(self, visitor_code: str) -> None:
@@ -63,7 +74,14 @@ class TrackingManager:
         self.__track([visitor_code])
         KameleoonLogger.debug("RETURN: TrackingManager.track_visitor(visitor_code: %s)", visitor_code)
 
-    def __track(self, visitor_codes: Iterable[str]) -> None:
+    def __track_probe(self) -> None:
+        # Sends one visitor's data; visitors without data are dropped (as on the normal path) until one is found.
+        while visitor_codes := self._tracking_visitors.extract(self.PROBE_MAX_VISITORS):
+            if self.__track(visitor_codes):
+                return
+
+    def __track(self, visitor_codes: Iterable[str]) -> bool:
+        """Returns whether a request was sent."""
         builder = TrackingBuilder(
             visitor_codes, self._data_manager.data_file, self._visitor_manager, self.REQUEST_SIZE_LIMIT
         )
@@ -75,33 +93,58 @@ class TrackingManager:
                 "If it is not caused by the peak load, decreasing the tracking interval is recommended."
             )
             self._tracking_visitors.add_all(builder.visitor_codes_to_keep)
-        self.__perform_tracking_request(
+        return self.__perform_tracking_request(
             builder.visitor_codes_to_send, builder.unsent_visitor_data, builder.tracking_lines
         )
 
     def __perform_tracking_request(
         self, visitor_codes: List[str], visitors_data: List[Sendable], tracking_lines: List[str]
-    ) -> None:
+    ) -> bool:
+        """Returns whether a request was sent."""
         if not tracking_lines:
-            return
+            return False
         lines = self.LINES_DELIMITER.join(tracking_lines)
         # Mark unsent data as transmitted
         for sendable_data in visitors_data:
             sendable_data.mark_as_transmitting()
 
-        async def call() -> Response:
-            service = self._network_manager.get_service(DataService)
-            response = await service.send_tracking_data(lines)
-            if response.success:
+        async def call() -> Optional[Response]:
+            response: Optional[Response] = None
+            try:
+                service = self._network_manager.get_service(DataService)
+                response = await service.send_tracking_data(lines)
+            except asyncio.CancelledError:
+                # Not a Data API failure: roll the data back for the next request without entering probe mode.
+                self.__handle_failed_request(visitor_codes, visitors_data)
+                raise
+            except Exception as exception:  # pylint: disable=W0703
+                KameleoonLogger.error("Tracking request failed: %s", exception)
+            if (response is not None) and response.success:
                 KameleoonLogger.debug("Successful request for tracking visitors: %s, data: %s",
                                       visitor_codes, visitors_data)
                 for sendable_data in visitors_data:
                     sendable_data.mark_as_sent()
+                self.__leave_probe_mode()
             else:
-                KameleoonLogger.debug("Failed request for tracking visitors: %s, data: %s",
-                                      visitor_codes, visitors_data)
-                for sendable_data in visitors_data:
-                    sendable_data.mark_as_unsent()
-                self._tracking_visitors.add_all(visitor_codes)
+                self.__handle_failed_request(visitor_codes, visitors_data)
+                self.__enter_probe_mode()
             return response
         self._async_executor.run_coro(call(), "send_tracking_data")
+        return True
+
+    def __handle_failed_request(self, visitor_codes: List[str], visitors_data: List[Sendable]) -> None:
+        KameleoonLogger.debug("Failed request for tracking visitors: %s, data: %s", visitor_codes, visitors_data)
+        for sendable_data in visitors_data:
+            sendable_data.mark_as_unsent()
+        self._tracking_visitors.add_all(visitor_codes)
+
+    def __enter_probe_mode(self) -> None:
+        if not self._probe_mode:
+            self._probe_mode = True
+            KameleoonLogger.info("Tracking request failed: only one visitor's data per tracking request"
+                                 " will be sent until a request succeeds")
+
+    def __leave_probe_mode(self) -> None:
+        if self._probe_mode:
+            self._probe_mode = False
+            KameleoonLogger.info("Tracking request succeeded: full-size tracking requests are restored")

kameleoon/managers/tracking/visitor_tracking_registry.py

@@ -1,6 +1,8 @@
 """Tracking"""
+
+import sys
 from threading import Lock
-from typing import Iterable, List, Set
+from typing import Dict, Iterable, List, Set
 from kameleoon.data.manager.visitor_manager import VisitorManager
 
 
@@ -10,6 +12,28 @@ class VisitorTrackingRegistry:
 
     Must be thread-safe
     """
+
+    UNLIMITED = sys.maxsize
+    DEFAULT_STORAGE_LIMIT = 1_000_000
+    DEFAULT_EXTRACTION_LIMIT = 20_000
+    LIMITED_EXTRACTION_THRESHOLD_COEFFICIENT = 2
+    REMOVAL_FACTOR = 0.8
+
+    def __init__(
+        self,
+        visitor_manager: VisitorManager,
+        storage_limit=DEFAULT_STORAGE_LIMIT,
+        extraction_limit=DEFAULT_EXTRACTION_LIMIT,
+    ) -> None:
+        self._visitor_manager = visitor_manager
+        self._storage_limit = storage_limit
+        self._extraction_limit = extraction_limit
+
+    @property
+    def visitors(self) -> Set[str]:
+        """Test purpose only"""
+        raise NotImplementedError()
+
     def add(self, visitor_code: str) -> None:
         """Adds a single visitor code to the registry."""
         raise NotImplementedError()
@@ -18,72 +42,71 @@ class VisitorTrackingRegistry:
         """Adds multiple visitor codes to the registry."""
         raise NotImplementedError()
 
-    def extract(self) -> Iterable[str]:
-        """Extracts and returns stored visitor codes from the registry."""
+    def extract(self, limit: int = UNLIMITED) -> List[str]:
+        """
+        Removes and returns visitor codes. A backlog under the doubled `extraction_limit` is returned at once
+        (unless `limit` is smaller); otherwise at most `min(limit, extraction_limit)` codes are returned.
+        Codes are extracted in no particular order.
+        """
         raise NotImplementedError()
 
+    def _extraction_count(self, size: int, limit: int) -> int:
+        if (size <= limit) and (size < self._extraction_limit * self.LIMITED_EXTRACTION_THRESHOLD_COEFFICIENT):
+            return size
+        return min(limit, self._extraction_limit)
 
-class LockVisitorTrackingRegistry(VisitorTrackingRegistry):
-    """An implementation of the `VisitorTrackingRegistry` based on the `threading.Lock`"""
-    LIMITED_EXTRACTION_THRESHOLD_COEFFICIENT = 2
-    REMOVAL_FACTOR = 0.8
+    def _storage_limit_after_removal(self) -> int:
+        return int(self._storage_limit * self.REMOVAL_FACTOR)
 
-    def __init__(self, visitor_manager: VisitorManager, storage_limit=1000_000, extraction_limit=20_000) -> None:
-        self._visitor_manager = visitor_manager
-        self._storage_limit = storage_limit
-        self._extraction_limit = extraction_limit
-        self._visitors: Set[str] = set()
-        self._lock = Lock()
+
+class ConcurrentVisitorTrackingRegistry(VisitorTrackingRegistry):
+    """
+    Lock-free on the hot path: `add` is a single `dict` operation, atomic under the GIL (CPython, PyPy) and under the
+    free-threaded build's per-object locking, so request threads never block on the registry - with the GIL a lock
+    there causes a convoy on every interpreter switch (~5x lower throughput, p99 of hundreds of microseconds at
+    8 threads; see `tests/benchmarks/visitor_tracking_registry_benchmark.py`). The dict is never swapped out;
+    `extract` removes with `popitem()` (O(1)) under a lock that only serializes removers, so a concurrently added
+    code is either returned now or kept for the next extraction, never lost. Nothing here depends on the order in
+    which concurrent operations interleave, only on single operations not corrupting or losing entries.
+    """
+
+    def __init__(
+        self,
+        visitor_manager: VisitorManager,
+        storage_limit=VisitorTrackingRegistry.DEFAULT_STORAGE_LIMIT,
+        extraction_limit=VisitorTrackingRegistry.DEFAULT_EXTRACTION_LIMIT,
+    ) -> None:
+        super().__init__(visitor_manager, storage_limit, extraction_limit)
+        self._visitors: Dict[str, None] = {}
+        self._extract_lock = Lock()
+
+    @property
+    def visitors(self) -> Set[str]:
+        return set(self._visitors)
 
     def add(self, visitor_code: str) -> None:
-        """Adds a single visitor code to the registry."""
-        with self._lock:
-            self._visitors.add(visitor_code)
+        self._visitors[visitor_code] = None
 
     def add_all(self, visitor_codes: Iterable[str]) -> None:
-        """Adds multiple visitor codes to the registry."""
-        with self._lock:
-            self._visitors.update(visitor_codes)
-            if len(self._visitors) > self._storage_limit:
-                self.__erase_nonexistent_visitors()
-                self.__erase_to_storage_limit()
-
-    def __erase_nonexistent_visitors(self) -> None:
-        """Not thread-safe"""
-        visitors_to_remove = [vc for vc in self._visitors if self._visitor_manager.get_visitor(vc) is None]
-        self._visitors.difference_update(visitors_to_remove)
+        self._visitors.update(dict.fromkeys(visitor_codes))
+        if len(self._visitors) > self._storage_limit:
+            self.__erase_to_storage_limit()
 
     def __erase_to_storage_limit(self) -> None:
-        """Not thread-safe"""
-        visitors_to_remove_count = len(self._visitors) - int(self._storage_limit * self.REMOVAL_FACTOR)
-        for _ in range(visitors_to_remove_count):
-            self._visitors.pop()
-
-    def extract(self) -> Iterable[str]:
-        """
-        Extracts and returns visitor codes from the registry. The number of the extracted visitor codes
-        is limited to the doubled `extraction_limit`.
-        """
-        return self.__extract_all() if self.__should_extract_all_be_used() else self.__extract_limited()
-
-    def __should_extract_all_be_used(self) -> bool:
-        return len(self._visitors) < self._extraction_limit * self.LIMITED_EXTRACTION_THRESHOLD_COEFFICIENT
-
-    def __extract_all(self) -> Iterable[str]:
-        new_visitors: Set[str] = set()
-        with self._lock:
-            old_visitors = self._visitors
-            self._visitors = new_visitors
-        return old_visitors
-
-    def __extract_limited(self) -> Iterable[str]:
-        with self._lock:
-            if self.__should_extract_all_be_used():
-                return self.__extract_all()
-            extracted: List[str] = [""] * self._extraction_limit
-            for i, visitor_code in enumerate(self._visitors):
-                if i >= self._extraction_limit:
-                    break
-                extracted[i] = visitor_code
-            self._visitors.difference_update(extracted)
-            return extracted
+        with self._extract_lock:
+            # Drain with `popitem()` instead of a `for` loop over the live dict: request threads keep calling `add`
+            # meanwhile, and a loop over a dict that gets a new key fails with "dictionary changed size during
+            # iteration" - which would abort the eviction. Codes added while draining stay in the live dict.
+            drained = [self._visitors.popitem()[0] for _ in range(len(self._visitors))]
+            # `peek_visitor`: an eviction pass must not count as activity and extend the visitors' sessions.
+            self._visitors.update(
+                dict.fromkeys(vc for vc in drained if self._visitor_manager.peek_visitor(vc) is not None)
+            )
+            visitors_to_remove_count = len(self._visitors) - self._storage_limit_after_removal()
+            for _ in range(visitors_to_remove_count):
+                self._visitors.popitem()
+
+    def extract(self, limit: int = VisitorTrackingRegistry.UNLIMITED) -> List[str]:
+        with self._extract_lock:
+            count = self._extraction_count(len(self._visitors), limit)
+            return [self._visitors.popitem()[0] for _ in range(count)]

kameleoon/network/access_token_source.py

@@ -1,16 +1,25 @@
 """Network"""
+
+# Postponed evaluation: `concurrent.futures.Future[...]` is not subscriptable at runtime before Python 3.9.
+from __future__ import annotations
+
 import asyncio
 import base64
+import concurrent.futures
+import threading
 import time
-from typing import Optional
+from typing import Optional, Tuple
 
 from kameleoon.helpers.string_utils import StringUtils
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
+from kameleoon.network.net_provider import Response
 from kameleoon.network.services.automation_service import AutomationService
 
 
 class AccessTokenSource:
     """Access Token Source"""
+
+    _SILENCE_PERIOD = 300.0  # in seconds
     _TOKEN_EXPIRATION_GAP = 60.0  # in seconds
     _TOKEN_OBSOLESCENCE_GAP = 1800.0  # in seconds
     _JWT_ACCESS_TOKEN_FIELD = "access_token"
@@ -19,17 +28,22 @@ class AccessTokenSource:
     def __init__(self, network_manager, client_id: str, client_secret: str) -> None:
         KameleoonLogger.debug(
             lambda: f"CALL: AccessTokenSource(network_manager, client_id: '{StringUtils.secret(client_id)}', "
-                    f"client_secret: '{StringUtils.secret(client_secret)}')"
+            f"client_secret: '{StringUtils.secret(client_secret)}')"
         )
         self._network_manager = network_manager
         self._client_id = client_id
         self._client_secret = client_secret
-        self._cached_token: Optional[AccessTokenSource.ExpiringToken] = None
-        self._fetching = False
         self._basic_authorization_token = AccessTokenSource.construct_basic_token(client_id, client_secret)
+        # Written by the fetching coroutine, read by callers on any thread / event loop.
+        self._cached_token: Optional[AccessTokenSource.ExpiringToken] = None
+        self._silent_after_fetch_failure_until = 0.0  # 0 = never silenced
+        # In-flight fetch shared by all concurrent callers; `None` when idle. A `concurrent.futures.Future` (not an
+        # asyncio one) because callers may run on different event loops. Guarded by `_lock`.
+        self._fetching: Optional[concurrent.futures.Future[Optional[str]]] = None
+        self._lock = threading.Lock()
         KameleoonLogger.debug(
             lambda: f"RETURN: AccessTokenSource(network_manager, client_id: '{StringUtils.secret(client_id)}', "
-                    f"client_secret: '{StringUtils.secret(client_secret)}')"
+            f"client_secret: '{StringUtils.secret(client_secret)}')"
         )
 
     @staticmethod
@@ -39,73 +53,97 @@ class AccessTokenSource:
         return "Basic " + base64.b64encode(basic_token_content.encode("utf-8")).decode("utf-8")
 
     async def get_token(self, timeout: Optional[float] = None) -> Optional[str]:
-        """Returns the access token. Fetches a new token if the cached one is expired or obsolete."""
+        """
+        Returns the access token. Fetches a new token if the cached one is expired or obsolete.
+
+        Returns `None` without a request during the silence period which follows a fetch failure.
+        """
         KameleoonLogger.debug("CALL: AccessTokenSource.get_token(timeout: %s)", timeout)
         now = time.time()
         token = self._cached_token
-        if (token is None) or token.is_expired(now):
-            return await self._call_fetch_token(timeout)
-        if not self._fetching and token.is_obsolete(now):
-            self._run_fetch_token()
-        value = token.value
-        KameleoonLogger.debug("RETURN: AccessTokenSource.get_token(timeout: %s) -> (token: %s)",
-                              timeout, token)
-        return value
+        silent = now < self._silent_after_fetch_failure_until
+        if (token is not None) and not token.is_expired(now):
+            if token.is_obsolete(now) and not silent:
+                self._fetch_token(timeout)  # refresh in background, keep serving the current token
+            result = token.value
+        elif silent:
+            result = None
+        else:
+            result = await asyncio.wrap_future(self._fetch_token(timeout))
+        KameleoonLogger.debug(lambda: f"RETURN: AccessTokenSource.get_token(timeout: {timeout}) -> "
+                                      f"(token: '{StringUtils.secret(result)}')")
+        return result
 
     def discard_token(self, token: str) -> None:
         """Discards the specified token, if it matches the cached token."""
-        KameleoonLogger.debug("CALL: AccessTokenSource.discard_token(token: %s)", token)
+        KameleoonLogger.debug(lambda: f"CALL: AccessTokenSource.discard_token(token: '{StringUtils.secret(token)}')")
         cached_token = self._cached_token
         if cached_token and (cached_token.value == token):
             self._cached_token = None
-        KameleoonLogger.debug("RETURN: AccessTokenSource.discard_token(token: %s)", token)
+        KameleoonLogger.debug(lambda: f"RETURN: AccessTokenSource.discard_token(token: '{StringUtils.secret(token)}')")
 
-    async def _call_fetch_token(self, timeout: Optional[float]) -> Optional[str]:
+    def _fetch_token(self, timeout: Optional[float]) -> concurrent.futures.Future[Optional[str]]:
+        """Starts a fetch unless one is already in flight; returns the future shared by all waiters."""
+        with self._lock:
+            if self._fetching is not None:
+                return self._fetching
+            future: concurrent.futures.Future[Optional[str]] = concurrent.futures.Future()
+            # A waiter that is cancelled (`asyncio.wrap_future` forwards cancellation) must not cancel the shared
+            # fetch: a running future ignores `cancel()`, so the other waiters and `set_result()` are unaffected.
+            future.set_running_or_notify_cancel()
+            self._fetching = future
         try:
-            self._fetching = True
-            return await self._fetch_token(timeout)
+            asyncio.get_running_loop().create_task(self._perform_fetch(future, timeout))
         except Exception as exception:  # pylint: disable=W0703
-            KameleoonLogger.error("Failed to call access token fetching: %s", exception)
-            self._fetching = False
-            return None
+            self._on_fetch_done(future, None, exception)
+        return future
 
-    def _run_fetch_token(self) -> None:
-        try:
-            self._fetching = True
-            asyncio.create_task(self._fetch_token())
-        except Exception as exception:  # pylint: disable=W0703
-            KameleoonLogger.error("Failed to run access token fetching: %s", exception)
-            self._fetching = False
-
-    async def _fetch_token(self, timeout: Optional[float] = None) -> Optional[str]:
-        KameleoonLogger.debug("CALL: AccessTokenSource._fetch_token(timeout: %s)", timeout)
+    async def _perform_fetch(self, future: concurrent.futures.Future[Optional[str]], timeout: Optional[float]) -> None:
+        KameleoonLogger.debug("CALL: AccessTokenSource._perform_fetch(timeout: %s)", timeout)
+        token: Optional[str] = None
+        error: Optional[Exception] = None
         try:
             service: AutomationService = self._network_manager.get_service(AutomationService)
             response = await service.fetch_access_jwtoken(self._basic_authorization_token, timeout)
-            if not response.success:
-                KameleoonLogger.error("Failed to fetch access JWT")
-                return None
-            if not isinstance(response.content, dict):
-                KameleoonLogger.error("Failed to obtain proper access JWT")
-                return None
-            try:
-                jwt = response.content
-                token = jwt[self._JWT_ACCESS_TOKEN_FIELD]
-                expires_in = jwt[self._JWT_EXPIRES_IN_FIELD]
-            except Exception as exception:  # pylint: disable=W0703
-                KameleoonLogger.error("Failed to parse access JWT: %s", exception)
-                return None
-            if not (isinstance(token, str) and token and isinstance(expires_in, int) and expires_in):
-                KameleoonLogger.error("Failed to read access JWT")
-                return None
-            self._handle_fetched_token(token, expires_in)
-            KameleoonLogger.debug("RETURN: AccessTokenSource._fetch_token(timeout: %s) -> (token: %s)",
-                                  timeout, token)
-            return token
+            token, expires_in = self._parse_response(response)
+            self._cached_token = self._new_expiring_token(token, expires_in)
+            KameleoonLogger.info("Fetched access token")
+        except Exception as exception:  # pylint: disable=W0703
+            error = exception
         finally:
-            self._fetching = False
+            # Also runs on cancellation (e.g. the event loop shutting down), so waiters are never left pending.
+            self._on_fetch_done(future, token, error)
+        KameleoonLogger.debug(lambda: f"RETURN: AccessTokenSource._perform_fetch(timeout: {timeout}) -> "
+                                      f"(token: '{StringUtils.secret(token)}')")
+
+    def _on_fetch_done(
+        self, future: concurrent.futures.Future[Optional[str]], token: Optional[str], error: Optional[Exception]
+    ) -> None:
+        if error is not None:
+            self._silent_after_fetch_failure_until = time.time() + self._SILENCE_PERIOD
+            KameleoonLogger.warning(
+                "Failed to fetch access token (%s); it will not be requested for %ds", error, int(self._SILENCE_PERIOD)
+            )
+        # Clear before completing so waiters that re-enter get_token() can start a new fetch.
+        with self._lock:
+            self._fetching = None
+        future.set_result(token)
 
-    def _handle_fetched_token(self, token: str, expires_in: int) -> None:
+    def _parse_response(self, response: Response) -> Tuple[str, int]:
+        if not response.success:
+            raise ValueError(f"access token request failed: {response}")
+        jwt = response.content
+        if not isinstance(jwt, dict):
+            raise ValueError(f"access token response is not a JSON object: {response}")
+        expires_in = jwt.get(self._JWT_EXPIRES_IN_FIELD)
+        if not (isinstance(expires_in, int) and (expires_in > 0)):
+            raise ValueError(f"access token response has no valid '{self._JWT_EXPIRES_IN_FIELD}' field")
+        token = jwt.get(self._JWT_ACCESS_TOKEN_FIELD)
+        if not (isinstance(token, str) and token):
+            raise ValueError(f"access token response has no '{self._JWT_ACCESS_TOKEN_FIELD}' field")
+        return token, expires_in
+
+    def _new_expiring_token(self, token: str, expires_in: int) -> AccessTokenSource.ExpiringToken:
         now = time.time()
         exp_time = now + expires_in - self._TOKEN_EXPIRATION_GAP
         if expires_in > self._TOKEN_OBSOLESCENCE_GAP:
@@ -113,17 +151,16 @@ class AccessTokenSource:
         else:
             obs_time = exp_time
             if expires_in <= self._TOKEN_EXPIRATION_GAP:
-                KameleoonLogger.error(
-                    "Access token life time (%ss) is not long enough to cache the token", expires_in
-                )
+                KameleoonLogger.error("Access token life time (%ss) is not long enough to cache the token", expires_in)
             else:
                 KameleoonLogger.warning(
-                    'Access token life time (%ss) is not long enough to refresh cached token in background', expires_in
+                    "Access token life time (%ss) is not long enough to refresh cached token in background", expires_in
                 )
-        self._cached_token = self.ExpiringToken(token, exp_time, obs_time)
+        return self.ExpiringToken(token, exp_time, obs_time)
 
     class ExpiringToken:
         """Expiring Token"""
+
         def __init__(self, value: str, expiration_time: float, obsolescence_time: float) -> None:
             self.value = value
             self.expiration_time = expiration_time

kameleoon/network/net_provider.py

@@ -1,6 +1,7 @@
 """Network"""
 from enum import Enum
 from typing import Any, Dict, Optional
+from kameleoon.helpers.string_utils import StringUtils
 
 
 class ResponseContentType(Enum):
@@ -67,7 +68,7 @@ class Request:
             body = self.body
 
         headers = [
-            f"{name}:{'***' if name == 'Authorization' else value}"
+            f"{name}:{StringUtils.secret(value) if name == 'Authorization' else value}"
             for name, value in (self.headers or {}).items()
         ]
 

kameleoon/network/services/service_impl.py

@@ -6,6 +6,7 @@ from typing import Any, Coroutine
 
 from kameleoon.events.http_request_failure import HttpRequestFailure
 from kameleoon.events.request_type import RequestType
+from kameleoon.helpers.string_utils import StringUtils
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.logging.log_level import LogLevel
 from kameleoon.network.network_manager import NetworkManager
@@ -70,7 +71,8 @@ class ServiceImpl(Service):
                     response.content,
                 )
                 if request.access_token and (response.code == 401):
-                    KameleoonLogger.warning("Unexpected rejection of access token %s", request.access_token)
+                    KameleoonLogger.warning("Unexpected rejection of access token '%s'",
+                                            StringUtils.secret(request.access_token))
                     access_token_source.discard_token(request.access_token)
                     if attempt == retry_limit:
                         try_access_token_auth = False

kameleoon/sdk_version.py

@@ -1,6 +1,6 @@
 """Kameleoon SDK version"""
 
-version_info = (3, 22, 0)
+version_info = (3, 22, 2)
 __version__ = ".".join(str(v) for v in version_info)  # uses in scripts
 
 

kameleoon/targeting/conditions/browser_condition.py

@@ -23,7 +23,12 @@ class BrowserCondition(TargetingCondition):
                 else BrowserType.INTERNET_EXPLORER
             )
             self.__version = json_condition.get("version", None)
-            self.__operator = TargetingOperator[str(json_condition.get("versionMatchType", None))]
+            # Version is optional; the operator is only meaningful when it's set
+            self.__operator = (
+                TargetingOperator.from_string(json_condition.get("versionMatchType", None))
+                if self.__version is not None
+                else TargetingOperator.UNKNOWN
+            )
         except KeyError as exeception:
             KameleoonLogger.error("%s has wrong JSON structure: %s", self.__class__, exeception)
 

kameleoon/targeting/conditions/constants.py

@@ -1,6 +1,9 @@
 """ Constants """
 
 from enum import Enum
+from typing import Any
+
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
 
 
 class TargetingOperator(Enum):
@@ -17,3 +20,13 @@ class TargetingOperator(Enum):
     FALSE = "FALSE"
     AMONG_VALUES = "AMONG_VALUES"
     ANY = "ANY"
+    UNKNOWN = "UNKNOWN"
+
+    @classmethod
+    def from_string(cls, raw: Any) -> "TargetingOperator":
+        """Parse an operator name from the configuration; unparsable values map to UNKNOWN."""
+        try:
+            return cls[str(raw).upper()]
+        except KeyError:
+            KameleoonLogger.error("Unexpected TargetingOperator: %s", raw)
+            return cls.UNKNOWN

kameleoon/targeting/conditions/version_condition.py

@@ -19,11 +19,12 @@ class VersionCondition(TargetingCondition):
     def __init__(self, json_condition: Dict[str, Union[str, int, Any]]):
         super().__init__(json_condition)
         self._condition_version = json_condition.get("version", None)
-        try:
-            self.__operator = TargetingOperator[str(json_condition.get("versionMatchType", None))]
-        except KeyError as ex:
-            KameleoonLogger.error("%s has wrong JSON structure: %s", self.__class__, ex)
-            self.__operator = TargetingOperator.UNDEFINED
+        # Version may be optional (e.g. SDK_LANGUAGE); the operator is only meaningful when it's set
+        self.__operator = (
+            TargetingOperator.from_string(json_condition.get("versionMatchType", None))
+            if self._condition_version is not None
+            else TargetingOperator.UNKNOWN
+        )
         self.__cached_sem_version: Optional[SemVersion] = None
 
     def check(self, data: Any) -> bool:

{kameleoon_client_python-3.22.0.dist-info → kameleoon_client_python-3.22.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kameleoon-client-python
-Version: 3.22.0
+Version: 3.22.2
 Summary: Kameleoon Client Python Software Development Kit.
 Home-page: https://developers.kameleoon.com/python-sdk.html
 Author: Kameleoon
@@ -20,27 +20,27 @@ Requires-Dist: requests<3.0.0,>=2.25
 Requires-Dist: sseclient-py<1.9.0,>=1.7.0
 Requires-Dist: aiohttp<4.0.0,>=3.8.0
 Provides-Extra: test
-Requires-Dist: types-requests==2.25.0; extra == "test"
-Requires-Dist: Django==3.2.4; extra == "test"
 Requires-Dist: sseclient-py<1.9.0,>=1.7.0; extra == "test"
-Requires-Dist: pytest-django==4.4.0; extra == "test"
-Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
-Requires-Dist: pytest-ordering==0.6; extra == "test"
-Requires-Dist: aiohttp<4.0.0,>=3.8.0; extra == "test"
-Requires-Dist: flake8==4.0.1; extra == "test"
-Requires-Dist: pytest-asyncio==0.21.*; extra == "test"
 Requires-Dist: pytest-cov==2.12.1; extra == "test"
-Requires-Dist: mypy==0.991; extra == "test"
+Requires-Dist: pytest-django==4.5.2; extra == "test"
 Requires-Dist: pylint==2.12.*; extra == "test"
-Requires-Dist: Werkzeug==2.0.1; extra == "test"
-Requires-Dist: pyyaml<6.1.0,>=5.4.0; extra == "test"
-Requires-Dist: freezegun==1.1.0; extra == "test"
-Requires-Dist: twine==3.4.1; extra == "test"
-Requires-Dist: types-PyYAML==5.4.3; extra == "test"
-Requires-Dist: requests<3.0.0,>=2.25; extra == "test"
 Requires-Dist: wheel==0.36.2; extra == "test"
+Requires-Dist: types-PyYAML==5.4.3; extra == "test"
+Requires-Dist: types-requests==2.25.0; extra == "test"
 Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
+Requires-Dist: aiohttp<4.0.0,>=3.8.0; extra == "test"
+Requires-Dist: Django==4.2.*; extra == "test"
 Requires-Dist: aioresponses==0.7.*; extra == "test"
+Requires-Dist: freezegun==1.1.0; extra == "test"
+Requires-Dist: pytest-asyncio==0.21.*; extra == "test"
+Requires-Dist: Werkzeug==2.0.1; extra == "test"
+Requires-Dist: mypy==0.991; extra == "test"
+Requires-Dist: twine==3.4.1; extra == "test"
+Requires-Dist: pyyaml<6.1.0,>=5.4.0; extra == "test"
+Requires-Dist: flake8==4.0.1; extra == "test"
+Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
+Requires-Dist: requests<3.0.0,>=2.25; extra == "test"
+Requires-Dist: pytest-ordering==0.6; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{kameleoon_client_python-3.22.0.dist-info → kameleoon_client_python-3.22.2.dist-info}/RECORD

@@ -5,7 +5,7 @@ kameleoon/kameleoon_client.py,sha256=Gg1NTcI0JUmYKPFYDRhJSG_Z2fxKaO8ECZ7R0yRgffA
 kameleoon/kameleoon_client_config.py,sha256=DJm--TtaTPc_09q3uv8XjHrX_q7C-sh0tf65lL2TxCw,11181
 kameleoon/kameleoon_client_factory.py,sha256=9_VXYnfZ0A5GNY6Y3j9aCfUV2uc-_-SQhslU3uUoeSQ,3228
 kameleoon/middleware.py,sha256=gwbt2YK0D6Uvmm3M7WqkTdwUIZEA85Use39Tt3oVeus,1584
-kameleoon/sdk_version.py,sha256=ncxEjKQ9_WR9SvDwaE9MGrPqwCzrZaFdPEX__Vce448,289
+kameleoon/sdk_version.py,sha256=7ZsKymIDnKmWCSJ-FIVDMmzAxUjdAcZfrkndtWxSG08,289
 kameleoon/client_readiness/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kameleoon/client_readiness/async_readiness.py,sha256=NTzreGNJ9jOdpia0gAnkOwjn14Vu6m53l7QC_eJQ5ig,1569
 kameleoon/client_readiness/threading_readiness.py,sha256=bpld4cxl4H6ZIvJxomU_Qmhii2ru7fRK1yzYp2SQhTw,5794
@@ -49,7 +49,7 @@ kameleoon/data/manager/forced_variation.py,sha256=k4_86h5O4_S-bqzfKIS3iU4xRCMXTl
 kameleoon/data/manager/legal_consent.py,sha256=5ymyDPywLetYa8e7nrgYp6Ds8j9qrqRpuCSg995gPNc,160
 kameleoon/data/manager/page_view_visit.py,sha256=ghn7zPSFtDyGpkwT4zEFKiMsJpXhicgmJsTSOnzcank,1730
 kameleoon/data/manager/visitor.py,sha256=YBXbQ7kMYEj38fikOuxfiXFde6nDowUmJjnW2e4aE2Q,24786
-kameleoon/data/manager/visitor_manager.py,sha256=oqOLp1VBI51v38Jb4XM9NqJq01X1rIZ7jk-qRrv94Pw,9167
+kameleoon/data/manager/visitor_manager.py,sha256=dbXYE4mCJx0bU-ZErOXdL6UXdjGWGL_q6DJyIFH7Q70,9207
 kameleoon/data/manager/visitor_slot.py,sha256=zf3Ov38CQrR5lS6oJ4Ehbxma2heBGNtUvRohEj1k7sY,528
 kameleoon/events/__init__.py,sha256=LGBoX1JDZr6dPpsqlUmYE5jN4i9L_GdQif7bkQOL3Hs,751
 kameleoon/events/data_file_update_event.py,sha256=caM6BSpMhMU1itXAIsAnVLsUbH-IDcL5HJy0UtF2yWI,1141
@@ -65,12 +65,12 @@ kameleoon/helpers/domain.py,sha256=muSkEMF-jbIzrHvwJQNB9XHZGQ18tluc1kNRGgjC0bU,2
 kameleoon/helpers/functions.py,sha256=JEjReWV9u9muD6aGZwiwUjBMl8UPHn5CfiGmN8zxkfc,1401
 kameleoon/helpers/hasher.py,sha256=CR0qaaD1y_AXGyCxiJZuuNOT8VjoXsoQhoXJMaNdgAM,945
 kameleoon/helpers/logger.py,sha256=BHugg5UDUlKiPVMIU1x4X4oex1DK_9XUcaf8H7wSp2Y,1100
-kameleoon/helpers/multi_threading.py,sha256=QtNKJww0UwFi5xF1jvGFNl3O3palhigm6d3QUcPb5k0,4363
+kameleoon/helpers/multi_threading.py,sha256=Em1DeYRH5Vx7GUSv5m6sdAxc43za3WSijUahROS1iHY,5491
 kameleoon/helpers/nonce.py,sha256=QmdCkHvzcdwY2yC7XsHzVLjUKxKdSyvgG1fi8Xz8Xh8,254
 kameleoon/helpers/repeat_timer.py,sha256=S8nC4jbK5z6C8on-FJ_CN8kZynBN22PsPcgaO8gOMwc,412
-kameleoon/helpers/scheduler.py,sha256=mwV3jDSoKk7omcvMA4f1RGv2fgqMCdQqUApRVcrTk4E,3376
+kameleoon/helpers/scheduler.py,sha256=8VFnX8WpWItcuO1fDBZKV150wcR0jm5UM0nwqzcaKbw,4149
 kameleoon/helpers/sem_version.py,sha256=BGqUkPo5jx0nTgr7m_paIl0l8xCgi_zFsiS1D4gzNDo,1976
-kameleoon/helpers/string_utils.py,sha256=HAB0S9HlIT2v4fI3JZOqFfc1JewwDi-jZxIosiv0F4A,1886
+kameleoon/helpers/string_utils.py,sha256=g2ofE2oF_04JsbG43xDS3clrVuxZIPq1cMKqeSqRthM,1855
 kameleoon/helpers/time.py,sha256=E7279NV9pDuYqVesIIrEhixMviKEoNhDLO9XQXNaWdk,486
 kameleoon/helpers/visitor_code.py,sha256=boya6fmyixNaOwdvxDzt91C7-XN8T9T_0mm3C5JQGIA,745
 kameleoon/hybrid/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -92,15 +92,15 @@ kameleoon/managers/remote_data/remote_data_manager.py,sha256=UOAmAo8U9-H_RDm8czz
 kameleoon/managers/remote_data/remote_visitor_data.py,sha256=8uZnwRt2zvhHhTA54-Y8IUvAve7sx7TGAf4x9mYX7fQ,13884
 kameleoon/managers/tracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kameleoon/managers/tracking/tracking_builder.py,sha256=SjKDbDBpRrCdafFb1o-o8lyqaFd_URbwDTi8toHBKBU,7540
-kameleoon/managers/tracking/tracking_manager.py,sha256=EyO5VJo8RMB96zgbDrOt7Us7Q2PVz2UCVkIP9SivBh8,5214
-kameleoon/managers/tracking/visitor_tracking_registry.py,sha256=5-4JQysILdSK6ajHWdv9A60ov8vaPtp9sV8emS7w4tk,3523
+kameleoon/managers/tracking/tracking_manager.py,sha256=nOzqNHXpmEhTLOXRLIfwOSJHIdbTic0_-RLDXy1tEPY,7154
+kameleoon/managers/tracking/visitor_tracking_registry.py,sha256=zTyOQtj3mFk1GUl9aSoT2Hv1EPcGrvGcWprKBg3y7fg,4834
 kameleoon/managers/warehouse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kameleoon/managers/warehouse/warehouse_manager.py,sha256=9HFzc_B2EGWxipP7XIj9-1-P3cA-ksI7lBUB4PGP_wg,3351
 kameleoon/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kameleoon/network/access_token_source.py,sha256=Yx-f4Gi23IDSYo67bGkw-STWIUQq91UuZEm5r40Bc9M,6587
+kameleoon/network/access_token_source.py,sha256=8ZrGA9TTBolti-_sCVTpQTHch9sC0PMVdHt-rszYvwU,9040
 kameleoon/network/access_token_source_factory.py,sha256=7k07mpFjkeTUIsOmchsIHd6-o9hzo4yvl99hmHPoQuc,605
 kameleoon/network/activity_event.py,sha256=acutjP-03lOQlJF_olCrQwNLuR3JaIZnA0-MAt5EiVE,425
-kameleoon/network/net_provider.py,sha256=1DbPInqVjtm79MmHvk2qkDrfrep992q98uMX9bbeNc0,2498
+kameleoon/network/net_provider.py,sha256=skL7Q4_mNeRrBQ016zCSxtW5cHJaLvMrdrNm1pU80hU,2573
 kameleoon/network/net_provider_impl.py,sha256=nP1Lz3LgxPBqQuML9BtaY7ZzXwSdsQ1zm5tLwJHFaT0,3053
 kameleoon/network/network_manager.py,sha256=OoE0PaKIDmsJbZV0F9KKroPHOWJGIiKx2ejkrHB5z6Y,1888
 kameleoon/network/network_manager_factory.py,sha256=SAaiNF_Fw6xoyOCZ3y9Wu3BLZwW74JsBmkTSIJhtilw,850
@@ -123,23 +123,18 @@ kameleoon/network/services/configuration_service_impl.py,sha256=-xFKFtkhd0Hk_nOn
 kameleoon/network/services/data_service.py,sha256=wWrb98JmlNCILvmG3JZPqdc8Sp5aUsMrDWaABvA0iKk,1098
 kameleoon/network/services/data_service_impl.py,sha256=1BegpK7towoXCy5eqztFfG0XeNrtgjoSiQz219saLDA,3859
 kameleoon/network/services/service.py,sha256=G2paqnw_1XjCC_eCbuOq9MWe0RqScIQMbnJUJj3ehtk,192
-kameleoon/network/services/service_impl.py,sha256=X1SSP-RMuib-fi7hsUWk8_OXFxKKuUaGtjZSkZFSFco,5344
+kameleoon/network/services/service_impl.py,sha256=7DIpo9_BX_s6usZqVDlT_Ao3FBdzVQgmQ9Gk940Ue-U,5465
 kameleoon/real_time/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kameleoon/real_time/real_time_event.py,sha256=84d1wcd34ZbctjWFa1EIt8LdDSNt6c49xZA5NKQn-IA,548
 kameleoon/real_time/real_time_event_service.py,sha256=NOyQqs9704afYIIgLpsFcue1riFc6cbrTOOFIbOmbmQ,3060
-kameleoon/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kameleoon/storage/cache.py,sha256=a9p7DlmFPFVBM_RCYOEqomf5ieyd9wcPZcfiPFplJ5U,1902
-kameleoon/storage/cache_factory.py,sha256=joERiQmfKc0fSmgQsiTEH8SbJ20TekeG79UZnW45yW4,571
-kameleoon/storage/cache_factory_impl.py,sha256=HU-7Y8OeUD0078KasR3Qru2HeP4gkRtCHtwMVzgB_d8,356
-kameleoon/storage/cache_impl.py,sha256=8aGhq2Q2InKvY0UMpReVlt0tQZiwAA1HRxc6xmLGb9I,1058
 kameleoon/targeting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kameleoon/targeting/models.py,sha256=21QikRumqRRlimD_qGnr9xzuFyLcCii3b398F7wf10Q,1018
 kameleoon/targeting/targeting_manager.py,sha256=IH1LcAptfCB4KhcWrHWROzE1aXCG5eElcgt_UGf96qI,7722
 kameleoon/targeting/tree_builder.py,sha256=Np7b4aIUN_Sgt87hWTXRNkMImCLCbzxe36dCmk6tpTc,5622
 kameleoon/targeting/tree_condition_factory.py,sha256=FbAqnJ4Y1wQ-pxH4tBLbVOd2hbU-9LMplUvWM7vCX78,6366
 kameleoon/targeting/conditions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kameleoon/targeting/conditions/browser_condition.py,sha256=_Zq8SLvXDopRCDm0ucBIcP_ynI0991Q9xIeqkOGkVvU,2605
-kameleoon/targeting/conditions/constants.py,sha256=3ospn-l0fVyNrrpsGZFfjW9uLIvsKOT6yCFttxVWy-I,389
+kameleoon/targeting/conditions/browser_condition.py,sha256=_zgC6KrK5gFY4aQHcFkOdlNPK8TclNJwE-94_9hfISA,2818
+kameleoon/targeting/conditions/constants.py,sha256=_m6M_HjKHFna-LbH1M3dWFaRUzzRN6h73Whl-VQJk04,857
 kameleoon/targeting/conditions/conversion_condition.py,sha256=l4lju0HlkVD82neDZehGhCaBqr7uaNOzq3S51MiYoNI,1707
 kameleoon/targeting/conditions/cookie_condition.py,sha256=iZsQKC6L1RD9jnQMOmEfEohPR9Ek5s4ON0SJCmpb7Cg,2714
 kameleoon/targeting/conditions/custom_datum.py,sha256=H8SDA6sXAANFKmToasPzxibGRv8vB2Z8dRPjLCZCRWo,4020
@@ -162,7 +157,7 @@ kameleoon/targeting/conditions/target_personalization_condition.py,sha256=42fm_F
 kameleoon/targeting/conditions/targeting_condition.py,sha256=QaGrJAaoGLQKQagHOUmdjGV6cDySl9O7KI_IdjOyQnU,1986
 kameleoon/targeting/conditions/time_elapsed_since_visit_condition.py,sha256=xm2nnppMd5EEAD9-KqQLXGO838u1Srm6HROvgNaLErc,1161
 kameleoon/targeting/conditions/unknown_condition.py,sha256=Hw2-ncD6bSSqQutiz_2uSqJNQMgwzh82k-UiVnJN8ag,551
-kameleoon/targeting/conditions/version_condition.py,sha256=hmgAgxZNOccatjS5uvo9QkxjYn0-AEhLD_hPGqVIolk,2733
+kameleoon/targeting/conditions/version_condition.py,sha256=YUcP4ZDcNz2hYfdB-7uB0TgtwZ08LOYxe5X_eiNDuTE,2764
 kameleoon/targeting/conditions/visit_number_today_condition.py,sha256=Zgm4f_YUCBbbItanK0ZVDnYDOU-gOvkJGq-XB0wXDMQ,1769
 kameleoon/targeting/conditions/visit_number_total_condition.py,sha256=eKTBGNPsbwJh4_uayWbdSZxFFK5Cu5vzNjKV9Uilwcg,764
 kameleoon/targeting/conditions/visitor_code_condition.py,sha256=03q8MeXc4y1FhHyA_7rCOmDjN7iDka-sOUfhNDTDrCg,415
@@ -175,7 +170,7 @@ kameleoon/types/remote_visitor_data_filter.py,sha256=YqInU1WvVwdBC9cTLhVXK7JYLic
 kameleoon/types/rule.py,sha256=RrnZA_nkIbvzfUSUcuKCqxqs48aVVk6WhlGfg2WrPns,1307
 kameleoon/types/variable.py,sha256=txEU9O07WPQOz6NjRIibyJWQ_mFexyqRa8YaR6W6eSE,833
 kameleoon/types/variation.py,sha256=vrgQWDeDc1FvsG5_O7CfsB5Xl4QhiKgKsWQMyoF1BkQ,2771
-kameleoon_client_python-3.22.0.dist-info/METADATA,sha256=xXeuoFLIFNsR5D9subJbSLKmt_Jt0nyNodgl0MGebfM,13195
-kameleoon_client_python-3.22.0.dist-info/WHEEL,sha256=AeO2BvogYWm3eGaHCvhzmUYt8ia7KfURiHzO_1atlys,109
-kameleoon_client_python-3.22.0.dist-info/top_level.txt,sha256=i6mIQRivSZ-iWKzQ7WnfUr-c19Hkt0uJR_PKO53yZEc,10
-kameleoon_client_python-3.22.0.dist-info/RECORD,,
+kameleoon_client_python-3.22.2.dist-info/METADATA,sha256=5yUAN6CSAN7zbIPgZEcJxK9p-qPsCaxS03iKdDuM9VM,13195
+kameleoon_client_python-3.22.2.dist-info/WHEEL,sha256=AeO2BvogYWm3eGaHCvhzmUYt8ia7KfURiHzO_1atlys,109
+kameleoon_client_python-3.22.2.dist-info/top_level.txt,sha256=i6mIQRivSZ-iWKzQ7WnfUr-c19Hkt0uJR_PKO53yZEc,10
+kameleoon_client_python-3.22.2.dist-info/RECORD,,

kameleoon/storage/cache.py

@@ -1,67 +0,0 @@
-""" Kameleoon Visitor Variation """
-
-from typing import TypeVar, Generic, Optional
-
-
-K = TypeVar("K")
-V = TypeVar("V")
-
-
-class Cache(Generic[K, V]):
-    """
-    Interface `Cache` represents a container type that is supposed to store relevant values by distinct keys
-    and to manage relevance of the stored values and is not supposed to be thread safe.
-    """
-
-    def __init__(self, expiration_period: float):
-        if expiration_period <= 0.0:
-            raise ValueError("'expiration_period' arg must have positive value!")
-        self._expiration_period = expiration_period
-
-    @property
-    def expiration_period(self) -> float:
-        """
-        Period during which a stored value is considered as relevant.
-        :return: Expiration period
-        :rtype: float
-        """
-        return self._expiration_period
-
-    def __len__(self) -> int:
-        raise NotImplementedError()
-
-    def set(self, key: K, value: V) -> None:
-        """
-        If item stored by specified key exists, this method updates its value and its relevance,
-        otherwise this method creates new relevant item with specified key and value.
-        :param key: Key
-        :type key: K
-        :param value: New value
-        :type value: V
-        """
-        raise NotImplementedError()
-
-    def get(self, key: K) -> Optional[V]:
-        """
-        Makes an attempt to get value of item stored by specified key.
-        :param key: Key
-        :type key: K
-        :return: Stored value or None if operation fails
-        :rtype: Optional[V]
-        """
-        raise NotImplementedError()
-
-    def clear(self) -> None:
-        """
-        Removes all stored values.
-        """
-        raise NotImplementedError()
-
-    def purge(self) -> None:
-        """
-        Removes all expired items.
-        """
-        raise NotImplementedError()
-
-    def __iter__(self):
-        raise NotImplementedError()

kameleoon/storage/cache_factory.py

@@ -1,17 +0,0 @@
-""" Kameleoon Visitor Variation """
-
-from .cache import Cache, K, V
-
-
-class CacheFactory:
-    """`CacheFactory` is supposed to be used for creating instances of `Cache` type."""
-
-    def create(self, expiration_period: float) -> Cache[K, V]:
-        """
-        Creates an instance of `Cache` type with specified expiration period.
-        :param expiration_period: Expiration period of new instance of `Cache` type
-        :type expiration_period: float
-        :return: New instance of `Cache` type
-        :rtype: Cache
-        """
-        raise NotImplementedError()

kameleoon/storage/cache_factory_impl.py

@@ -1,12 +0,0 @@
-""" Kameleoon Visitor Variation """
-
-from .cache import Cache, K, V
-from .cache_impl import CacheImpl
-from .cache_factory import CacheFactory
-
-
-class CacheFactoryImpl(CacheFactory):
-    """`CacheFactoryImpl` implements `CacheFactory` interface."""
-
-    def create(self, expiration_period: float) -> Cache[K, V]:
-        return CacheImpl(expiration_period)

kameleoon/storage/cache_impl.py

@@ -1,36 +0,0 @@
-""" Kameleoon Visitor Variation """
-
-import time
-from typing import Dict, Tuple, Optional
-from .cache import Cache, K, V
-
-
-class CacheImpl(Cache[K, V]):
-    """`CacheImpl` implements `Cache` interface."""
-
-    def __init__(self, expiration_period: float):
-        super().__init__(expiration_period)
-        self.__items: Dict[K, Tuple[V, float]] = {}
-
-    def __len__(self) -> int:
-        return len(self.__items)
-
-    def set(self, key: K, value: V) -> None:
-        expiration_ts = time.time() + self._expiration_period
-        self.__items[key] = (value, expiration_ts)
-
-    def get(self, key: K) -> Optional[V]:
-        item = self.__items.get(key, None)
-        return item[0] if item is not None else None
-
-    def clear(self) -> None:
-        self.__items.clear()
-
-    def purge(self) -> None:
-        now = time.time()
-        to_be_removed = [k for k, v in self.__items.items() if v[1] <= now]
-        for key in to_be_removed:
-            del self.__items[key]
-
-    def __iter__(self):
-        return ((k, v[0]) for k, v in self.__items.items())