kameleoon-client-python 3.18.0__tar.gz → 3.19.0__tar.gz

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kameleoon-client-python
-Version: 3.18.0
+Version: 3.19.0
 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: mypy==0.991; extra == "test"
-Requires-Dist: flake8==4.0.1; extra == "test"
-Requires-Dist: types-requests==2.25.0; extra == "test"
-Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
-Requires-Dist: aioresponses==0.7.*; extra == "test"
-Requires-Dist: twine==3.4.1; extra == "test"
-Requires-Dist: pytest-django==4.4.0; extra == "test"
-Requires-Dist: Django==3.2.4; extra == "test"
-Requires-Dist: pytest-cov==2.12.1; extra == "test"
-Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
-Requires-Dist: pylint==2.12.*; extra == "test"
-Requires-Dist: aiohttp<4.0.0,>=3.8.0; extra == "test"
+Requires-Dist: wheel==0.36.2; extra == "test"
 Requires-Dist: Werkzeug==2.0.1; extra == "test"
+Requires-Dist: aiohttp<4.0.0,>=3.8.0; extra == "test"
+Requires-Dist: pylint==2.12.*; extra == "test"
+Requires-Dist: types-requests==2.25.0; extra == "test"
 Requires-Dist: pytest-asyncio==0.21.*; extra == "test"
 Requires-Dist: sseclient-py<1.9.0,>=1.7.0; extra == "test"
-Requires-Dist: wheel==0.36.2; extra == "test"
-Requires-Dist: types-PyYAML==5.4.3; extra == "test"
+Requires-Dist: pytest-cov==2.12.1; extra == "test"
+Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
+Requires-Dist: freezegun==1.1.0; extra == "test"
 Requires-Dist: pyyaml<6.1.0,>=5.4.0; extra == "test"
+Requires-Dist: pytest-django==4.4.0; extra == "test"
 Requires-Dist: pytest-ordering==0.6; extra == "test"
-Requires-Dist: freezegun==1.1.0; extra == "test"
+Requires-Dist: Django==3.2.4; extra == "test"
+Requires-Dist: types-PyYAML==5.4.3; extra == "test"
+Requires-Dist: flake8==4.0.1; extra == "test"
+Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
+Requires-Dist: mypy==0.991; extra == "test"
 Requires-Dist: requests<3.0.0,>=2.25; extra == "test"
+Requires-Dist: twine==3.4.1; extra == "test"
+Requires-Dist: aioresponses==0.7.*; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/configuration/data_file.py

@@ -1,6 +1,7 @@
 """Kameleoon Configuration"""
 
 from typing import Any, Dict, Iterable, List, Optional, Set
+
 from kameleoon.configuration import Variable
 from kameleoon.configuration.custom_data_info import CustomDataInfo
 from kameleoon.configuration.experiment import Experiment
@@ -20,7 +21,7 @@ class DataFile:
     @staticmethod
     def default(environment: Optional[str]) -> "DataFile":
         """Creates new instance of `DataFile` initialized with default values"""
-        data_file = DataFile(environment, None, Settings(), {}, {}, CustomDataInfo(None))
+        data_file = DataFile(environment, None, Settings(), {}, {}, CustomDataInfo(None), None, 0)
         return data_file
 
     @staticmethod
@@ -33,23 +34,29 @@ class DataFile:
         custom_data_info = CustomDataInfo(configuration.get("customData"))
         feature_flags = DataFile.__parse_feature_flags(configuration, segments, custom_data_info)
         holdout = Experiment.from_json(configuration["holdout"]) if "holdout" in configuration else None
-        data_file = DataFile(environment, last_modified, settings, segments, feature_flags, custom_data_info, holdout)
+        date_modified = int(configuration.get("dateModified", 0))
+        data_file = DataFile(
+            environment,
+            last_modified,
+            settings,
+            segments,
+            feature_flags,
+            custom_data_info,
+            holdout,
+            date_modified,
+        )
         return data_file
 
     @staticmethod
     def __parse_segments(configuration: Dict[str, Any]) -> Dict[int, Segment]:
-        return {
-            (seg := Segment.from_json(jobj)).id_: seg
-            for jobj in configuration.get("segments") or []
-        }
+        return {(seg := Segment.from_json(jobj)).id_: seg for jobj in configuration.get("segments") or []}
 
     @staticmethod
     def __parse_feature_flags(
         configuration: Dict[str, Any], segments: Dict[int, Segment], cdi: CustomDataInfo
     ) -> Dict[str, FeatureFlag]:
         return {
-            (ff := FeatureFlag(jobj, segments, cdi)).feature_key: ff
-            for jobj in configuration.get("featureFlags") or []
+            (ff := FeatureFlag(jobj, segments, cdi)).feature_key: ff for jobj in configuration.get("featureFlags") or []
         }
 
     # pylint: disable=R0913
@@ -61,15 +68,22 @@ class DataFile:
         segments: Dict[int, Segment],
         feature_flags: Dict[str, FeatureFlag],
         custom_data_info: CustomDataInfo,
-        holdout: Optional[Experiment] = None,
+        holdout: Optional[Experiment],
+        date_modified: int,
     ) -> None:
         KameleoonLogger.debug(
             "CALL: DataFile(environment: %s, last_modified: %s, settings: %s, segments, feature_flags,"
-            " custom_data_info: %s, holdout: %s)",
-            environment, last_modified, settings, custom_data_info, holdout
+            " custom_data_info: %s, holdout: %s, date_modified: %s)",
+            environment,
+            last_modified,
+            settings,
+            custom_data_info,
+            holdout,
+            date_modified,
         )
         self.__environment = environment  # pylint: disable=W0238
         self.__last_modified = last_modified
+        self.__date_modified = date_modified
         self.__settings = settings
         self.__segments = segments
         self.__audience_tracking_segments = [seg for seg in segments.values() if seg.audience_tracking]
@@ -90,8 +104,13 @@ class DataFile:
         self.__holdout = holdout
         KameleoonLogger.debug(
             "RETURN: DataFile(environment: %s, last_modified: %s, settings: %s, segments, feature_flags,"
-            " custom_data_info: %s, holdout: %s)",
-            environment, last_modified, settings, custom_data_info, holdout
+            " custom_data_info: %s, holdout: %s, date_modified: %s)",
+            environment,
+            last_modified,
+            settings,
+            custom_data_info,
+            holdout,
+            date_modified,
         )
 
     @property
@@ -99,6 +118,11 @@ class DataFile:
         """Returns last modified string"""
         return self.__last_modified
 
+    @property
+    def date_modified(self) -> int:
+        """Returns the last data-file update timestamp from the configuration."""
+        return self.__date_modified
+
     @property
     def settings(self) -> Settings:
         """Returns settings"""
@@ -152,10 +176,12 @@ class DataFile:
         feature_flag = self.__feature_flags.get(feature_key)
         if feature_flag is None:
             raise FeatureNotFound(feature_key)
+        return feature_flag
+
+    def _ensure_environment_enabled(self, feature_flag: FeatureFlag):
         if not feature_flag.environment_enabled:
             env = "default" if self.__environment is None else f"'{self.__environment}'"
-            raise FeatureEnvironmentDisabled(f"Feature '{feature_key}' is disabled for {env} environment")
-        return feature_flag
+            raise FeatureEnvironmentDisabled(f"Feature '{feature_flag.feature_key}' is disabled for {env} environment")
 
     @property
     def custom_data_info(self) -> CustomDataInfo:
@@ -211,6 +237,7 @@ class DataFile:
             "DataFile{"
             f"environment:'{self.__environment}',"
             f"last_modified:'{self.__last_modified}',"
+            f"date_modified:{self.__date_modified},"
             f"feature_flags:{len(self.__feature_flags)},"
             f"settings:{self.__settings}"
             "}"

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/configuration/variation.py

@@ -23,6 +23,7 @@ class Variation:
 
     def __init__(self, dict_json: Dict[str, Any]):
         self.key: str = dict_json.get("key", "")
+        self.name: str = dict_json.get("name", "")
         self.variables: List[Variable] = Variable.from_array(
             dict_json.get("variables", [])
         )
@@ -33,4 +34,5 @@ class Variation:
 
     def __str__(self):
         return (f"Variation{{key:'{self.key}',"
+                f"name:'{self.name}',"
                 f"variables:{StringUtils.object_to_string(self.variables)}}}")

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/data/manager/visitor_manager.py

@@ -3,11 +3,12 @@
 import collections
 import time
 from typing import Any, Dict, Iterator, List, Optional
+
 from kameleoon.configuration.custom_data_info import CustomDataInfo
 from kameleoon.data import Conversion, CustomData
-from kameleoon.data.mapping_identifier import MappingIdentifier
 from kameleoon.data.manager.visitor import Visitor
 from kameleoon.data.manager.visitor_slot import VisitorSlot
+from kameleoon.data.mapping_identifier import MappingIdentifier
 from kameleoon.helpers.scheduler import Scheduler
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.managers.data.data_manager import DataManager
@@ -63,6 +64,20 @@ class VisitorManager:
             slot.lock.release()
             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()
+        KameleoonLogger.debug(
+            f"RETURN: VisitorManager.peekVisitor(visitor_code: {visitor_code}) -> "f"(visitor: {visitor})")
+        return visitor
+
     def add_data(self, visitor_code: str, *args, track: bool = True) -> Visitor:
         """
         Adds data to a visitor.

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/kameleoon_client.py

@@ -3,16 +3,14 @@
 from http.cookies import Morsel
 from typing import cast, Callable, Coroutine, Optional, Tuple, Union, Any, List, Dict, Iterable
 
+from kameleoon import configuration
 from kameleoon.client_readiness.async_readiness import AsyncClientReadiness
 from kameleoon.client_readiness.threading_readiness import ThreadingClientReadiness
-
-from kameleoon import configuration
 from kameleoon.configuration.consent_blocking_behaviour import ConsentBlockingBehaviour
 from kameleoon.configuration.data_file import DataFile
 from kameleoon.configuration.feature_flag import FeatureFlag
 from kameleoon.configuration.rule import Rule
 from kameleoon.configuration.rule_type import RuleType
-
 from kameleoon.data import Conversion, CustomData, Data, UniqueIdentifier
 from kameleoon.data.manager.assigned_variation import AssignedVariation
 from kameleoon.data.manager.forced_experiment_variation import ForcedExperimentVariation
@@ -20,7 +18,6 @@ from kameleoon.data.manager.legal_consent import LegalConsent
 from kameleoon.data.manager.visitor import Visitor
 from kameleoon.data.manager.visitor_manager import VisitorManager
 from kameleoon.data.targeted_segment import TargetedSegment
-
 from kameleoon.exceptions import (
     FeatureVariationNotFound,
     FeatureExperimentNotFound,
@@ -28,37 +25,28 @@ from kameleoon.exceptions import (
     FeatureEnvironmentDisabled,
     SiteCodeIsEmpty,
 )
-
 from kameleoon.helpers.hasher import Hasher
 from kameleoon.helpers.visitor_code import validate_visitor_code
-
 from kameleoon.hybrid.hybrid_manager_impl import HybridManagerImpl
-
 from kameleoon.kameleoon_client_config import KameleoonClientConfig
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.logging.logger import DefaultLogger
-
 from kameleoon.managers.asyncexec.async_executor import AsyncExecutor
 from kameleoon.managers.data.data_manager import DataManager
 from kameleoon.managers.evaluation.evaluated_experiment import EvaluatedExperiment
 from kameleoon.managers.remote_data.remote_data_manager import RemoteDataManager
 from kameleoon.managers.tracking.tracking_manager import TrackingManager
 from kameleoon.managers.warehouse.warehouse_manager import WarehouseManager
-
 from kameleoon.network.access_token_source_factory import AccessTokenSourceFactory
+from kameleoon.network.cookie.cookie_manager import CookieManager
 from kameleoon.network.net_provider_impl import NetProviderImpl
 from kameleoon.network.network_manager_factory import NetworkManagerFactory
 from kameleoon.network.network_manager_factory_impl import NetworkManagerFactoryImpl
 from kameleoon.network.sendable import Sendable
 from kameleoon.network.services.configuration_service import ConfigurationService, FetchedConfiguration
-from kameleoon.network.cookie.cookie_manager import CookieManager
-
 from kameleoon.real_time.real_time_configuration_service import RealTimeConfigurationService
-
 from kameleoon.targeting.targeting_manager import TargetingManager
-
 from kameleoon.types.remote_visitor_data_filter import RemoteVisitorDataFilter
-from kameleoon.types.variable import Variable
 from kameleoon.types.variation import Variation
 
 __all__ = [
@@ -596,9 +584,7 @@ class KameleoonClient:
         validate_visitor_code(visitor_code)
         feature_flag = self._data_manager.data_file.get_feature_flag(feature_key)
         variation_key, eval_exp = self.__get_variation_info(visitor_code, feature_flag, track)
-        external_variation = self.__create_external_variation(
-            variation_key, feature_flag.get_variation(variation_key), eval_exp
-        )
+        external_variation = self.__create_external_variation(feature_flag.get_variation(variation_key), eval_exp)
         if track:
             self._tracking_manager.add_visitor_code(visitor_code)
         KameleoonLogger.info(
@@ -611,6 +597,14 @@ class KameleoonClient:
         )
         return external_variation
 
+    def get_data_file(self):
+        """Retrieves the information about the data file"""
+
+        KameleoonLogger.info("CALL: KameleoonClient.get_data_file()")
+        data_file = self._data_manager.external_datafile
+        KameleoonLogger.info("RETURN: KameleoonClient.get_data_file() -> (data_file: %s)", data_file)
+        return data_file
+
     def get_variations(self, visitor_code: str, only_active=False, track: bool = True) -> Dict[str, Variation]:
         """
         Forms a dictionary of variations assigned to a given visitor across all feature flags.
@@ -640,8 +634,6 @@ class KameleoonClient:
         validate_visitor_code(visitor_code)
         variations: Dict[str, Variation] = {}
         for feature_flag in self._data_manager.data_file.feature_flags.values():
-            if not feature_flag.environment_enabled:
-                continue
             try:
                 variation_key, eval_exp = self.__get_variation_info(visitor_code, feature_flag, track)
             except FeatureEnvironmentDisabled:
@@ -649,7 +641,7 @@ class KameleoonClient:
             if only_active and (variation_key == configuration.Variation.Type.OFF.value):
                 continue
             variations[feature_flag.feature_key] = self.__create_external_variation(
-                variation_key, feature_flag.get_variation(variation_key), eval_exp
+                feature_flag.get_variation(variation_key), eval_exp
             )
         if track:
             self._tracking_manager.add_visitor_code(visitor_code)
@@ -698,6 +690,10 @@ class KameleoonClient:
         )
         eval_exp = None
         forced_variation = visitor.get_forced_feature_variation(feature_flag.feature_key) if visitor else None
+
+        if not (forced_variation and forced_variation.simulated):
+            self._data_manager.data_file._ensure_environment_enabled(feature_flag)
+
         if forced_variation:
             eval_exp = EvaluatedExperiment.from_forced_variation(forced_variation)
         elif self.__is_visitor_not_in_holdout(
@@ -791,31 +787,20 @@ class KameleoonClient:
 
     @staticmethod
     def __create_external_variation(
-        variation_key: str,
         variation: Optional[configuration.Variation],
         eval_exp: Optional[EvaluatedExperiment],
     ) -> Variation:
         KameleoonLogger.debug(
-            "CALL: KameleoonClient.__create_external_variation(variation_key: %s, internal_variation: %s, "
-            "eval_exp: %s)",
-            variation_key,
+            "CALL: KameleoonClient.__create_external_variation(variation: %s, eval_exp: %s)",
             variation,
             eval_exp,
         )
-        ext_variables: Dict[str, Variable] = {}
-        if variation:
-            for variable in variation.variables:
-                ext_variables[variable.key] = Variable(variable.key, variable.get_type(), variable.get_value())
-        variation_id = None
-        experiment_id = None
-        if eval_exp:
-            variation_id = eval_exp.var_by_exp.variation_id
-            experiment_id = eval_exp.experiment.id_
-        ext_variation = Variation(variation_key, variation_id, experiment_id, ext_variables)
+        variation_id, experiment_id = (
+            (eval_exp.var_by_exp.variation_id, eval_exp.experiment.id_) if eval_exp else (None, None)
+        )
+        ext_variation = Variation._build_from_internal(variation, variation_id, experiment_id)
         KameleoonLogger.debug(
-            "RETURN: KameleoonClient.__create_external_variation(variation_key: %s, internal_variation: %s, "
-            "eval_exp: %s) -> (ext_variation: %s)",
-            variation_key,
+            "RETURN: KameleoonClient.__create_external_variation(variation: %s, eval_exp: %s) -> (ext_variation: %s)",
             variation,
             eval_exp,
             ext_variation,
@@ -863,6 +848,9 @@ class KameleoonClient:
             variation_key,
         )
         feature_flag = self._data_manager.data_file.get_feature_flag(feature_key)
+
+        self._data_manager.data_file._ensure_environment_enabled(feature_flag)
+
         variation = feature_flag.get_variation(variation_key)
         if not variation:
             raise FeatureVariationNotFound(variation_key)
@@ -1164,14 +1152,18 @@ class KameleoonClient:
         )
         return custom_data
 
+    # Deprecated methods
     def get_feature_list(self) -> List[str]:
         """
+        Deprecated function. Please use `get_data_file` instead.
+
         The get_feature_list method uses for obtaining a list of feature flag IDs:
         - currently available for the SDK
 
         :return: List of all feature flag IDs
-        :rtype: List[int]
+        :rtype: List[str]
         """
+        KameleoonLogger.info("Call to deprecated function `get_feature_list`. Please use `get_data_file` instead.")
         KameleoonLogger.info("CALL: KameleoonClient.get_feature_list()")
         features = list(self._data_manager.data_file.feature_flags)
         KameleoonLogger.info("RETURN: KameleoonClient.get_feature_list() -> (features: %s)", features)
@@ -1200,8 +1192,6 @@ class KameleoonClient:
         visitor = self._visitor_manager.get_visitor(visitor_code)
 
         def filter_conditions(feature_flag: FeatureFlag) -> bool:
-            if not feature_flag.environment_enabled:
-                return False
             try:
                 eval_exp = self.__evaluate(visitor, visitor_code, feature_flag, False, False)
             except FeatureEnvironmentDisabled:
@@ -1251,8 +1241,6 @@ class KameleoonClient:
         visitor = self._visitor_manager.get_visitor(visitor_code)
         map_active_features: Dict[str, Variation] = {}
         for feature_flag in self._data_manager.data_file.feature_flags.values():
-            if not feature_flag.environment_enabled:
-                continue
             try:
                 eval_exp = self.__evaluate(visitor, visitor_code, feature_flag, False, False)
             except FeatureEnvironmentDisabled:
@@ -1261,7 +1249,7 @@ class KameleoonClient:
             if variation_key == configuration.Variation.Type.OFF.value:
                 continue
             map_active_features[feature_flag.feature_key] = self.__create_external_variation(
-                variation_key, feature_flag.get_variation(variation_key), eval_exp
+                feature_flag.get_variation(variation_key), eval_exp
             )
         KameleoonLogger.info(
             "RETURN: KameleoonClient.get_active_features(visitor_code: %s) -> (active_features: %s)",

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/managers/data/data_manager.py

@@ -2,6 +2,7 @@
 
 from kameleoon.configuration.data_file import DataFile
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
+from kameleoon.types.data_file import DataFile as TypesDataFile
 
 
 class DataManager:
@@ -22,6 +23,11 @@ class DataManager:
         """Sets a new `DataFile` for this instance by updating the container."""
         self.__container = DataManager.Container(value)
 
+    @property
+    def external_datafile(self) -> TypesDataFile:
+        """Returns the external `DataFile` associated with this instance."""
+        return self.__container.external_datafile
+
     @property
     def is_visitor_code_managed(self) -> bool:
         """Returns `True` if consent is required, otherwise returns `False`."""
@@ -34,6 +40,7 @@ class DataManager:
         def __init__(self, data_file: DataFile) -> None:
             KameleoonLogger.debug("CALL: DataManager.Container(data_file: %s)", data_file)
             self.data_file = data_file
+            self.external_datafile = TypesDataFile._build_from_internal(data_file)
             # Regarding GDPR policy we should set visitorCode if legal consent isn't required or we have at
             # least one Targeted Delivery rule in datafile
             self.is_visitor_code_managed = (

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/managers/tracking/tracking_builder.py

@@ -61,7 +61,7 @@ class TrackingBuilder:
             return
         for visitor_code in self.__visitor_codes:
             if self.__total_size <= self.__request_size_limit:
-                visitor = self.__visitor_manager.get_visitor(visitor_code)
+                visitor = self.__visitor_manager.peek_visitor(visitor_code)
                 is_consent_given = self.__is_consent_given(visitor)
                 data = self.__collect_tracking_data(visitor_code, visitor, is_consent_given)
                 if len(data) > 0:

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/network/access_token_source.py

@@ -1,5 +1,6 @@
 """Network"""
 import asyncio
+import base64
 import time
 from typing import Optional
 
@@ -25,11 +26,18 @@ class AccessTokenSource:
         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)
         KameleoonLogger.debug(
             lambda: f"RETURN: AccessTokenSource(network_manager, client_id: '{StringUtils.secret(client_id)}', "
                     f"client_secret: '{StringUtils.secret(client_secret)}')"
         )
 
+    @staticmethod
+    def construct_basic_token(client_id: str, client_secret: str) -> str:
+        """Returns the basic token"""
+        basic_token_content = f"{client_id}:{client_secret}"
+        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."""
         KameleoonLogger.debug("CALL: AccessTokenSource.get_token(timeout: %s)", timeout)
@@ -73,7 +81,7 @@ class AccessTokenSource:
         KameleoonLogger.debug("CALL: AccessTokenSource._fetch_token(timeout: %s)", timeout)
         try:
             service: AutomationService = self._network_manager.get_service(AutomationService)
-            response = await service.fetch_access_jwtoken(self._client_id, self._client_secret, timeout)
+            response = await service.fetch_access_jwtoken(self._basic_authorization_token, timeout)
             if not response.success:
                 KameleoonLogger.error("Failed to fetch access JWT")
                 return None

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/network/net_provider.py

@@ -64,8 +64,14 @@ class Request:
     def __str__(self):
         body = "None"
         if self.body is not None:
-            body = "'****'" if self.body.startswith('grant_type=client_credentials') else f"'{self.body}'"
-        return f"HttpRequest{{Method:'{self.method}',Url:'{self.url}',Headers:{self.headers},Body:{body}}}"
+            body = self.body
+
+        headers = [
+            f"{name}:{'***' if name == 'Authorization' else value}"
+            for name, value in (self.headers or {}).items()
+        ]
+
+        return f"HttpRequest{{Method:'{self.method}',Url:'{self.url}',Headers:{headers},Body:{body}}}"
 
 
 class NetProvider:

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/network/services/automation_service.py

@@ -7,7 +7,7 @@ from kameleoon.network.net_provider import Response
 class AutomationService(Service):
     """Abstract automation service"""
     def fetch_access_jwtoken(
-        self, client_id: str, client_secret: str, timeout: Optional[float] = None
+        self, basic_authorization_token: str, timeout: Optional[float] = None
     ) -> Coroutine[Any, Any, Response]:
         """Fetches an access JWT token asynchronously."""
         raise NotImplementedError()

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/network/services/automation_service_impl.py

@@ -13,6 +13,7 @@ class AutomationServiceImpl(AutomationService, ServiceImpl):
     """Automation service implementation"""
     _ACCESS_TOKEN_GRANT_TYPE = "client_credentials"
     _H_CONTENT_TYPE_NAME = "Content-Type"
+    _H_AUTHORIZATION = "Authorization"
     _H_CONTENT_TYPE_VALUE = "application/x-www-form-urlencoded"
 
     def __init__(self, network_manager) -> None:
@@ -22,27 +23,25 @@ class AutomationServiceImpl(AutomationService, ServiceImpl):
         KameleoonLogger.debug("RETURN: AutomationServiceImpl(network_manager)")
 
     def fetch_access_jwtoken(
-        self, client_id: str, client_secret: str, timeout: Optional[float] = None
+        self, basic_authorization_token: str, timeout: Optional[float] = None
     ) -> Coroutine[Any, Any, Response]:
         KameleoonLogger.debug(lambda: f"CALL: AutomationServiceImpl.fetch_access_jwtoken("
-                                      f"client_id: '{StringUtils.secret(client_id)}', "
-                                      f"client_secret: '{StringUtils.secret(client_secret)}', timeout: {timeout})")
+                                      f"basic_authorization_token: '{StringUtils.secret(basic_authorization_token)}', "
+                                      f"timeout: {timeout})")
         if timeout is None:
             timeout = self.network_manager.call_timeout
         url: str = self.network_manager.url_provider.make_access_token_url()
         body = QueryBuilder(
             QueryParam(QueryParams.GRANT_TYPE, self._ACCESS_TOKEN_GRANT_TYPE),
-            QueryParam(QueryParams.CLIENT_ID, client_id),
-            QueryParam(QueryParams.CLIENT_SECRET, client_secret),
         )
-        headers = {self._H_CONTENT_TYPE_NAME: self._H_CONTENT_TYPE_VALUE}
+        headers = {self._H_CONTENT_TYPE_NAME: self._H_CONTENT_TYPE_VALUE,
+                   self._H_AUTHORIZATION: basic_authorization_token}
         request = Request(
             HttpMethod.POST, url, timeout, headers=headers, body=str(body),
             response_content_type=ResponseContentType.JSON,
         )
         response = self._make_call(request, False)
         KameleoonLogger.debug(lambda: f"CALL: AutomationServiceImpl.fetch_access_jwtoken("
-                                      f"client_id: '{StringUtils.secret(client_id)}', "
-                                      f"client_secret: '{StringUtils.secret(client_secret)}', "
+                                      f"basic_authorization_token: '{StringUtils.secret(basic_authorization_token)}', "
                                       f"timeout: {timeout}) -> (response_coroutine)")
         return response

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/network/url_provider.py

@@ -34,18 +34,22 @@ class UrlProvider:
         self.site_code = site_code
         self._data_api_domain = self.DEFAULT_DATA_API_DOMAIN  # if remove W0201 error (pylint)
         self.__setup_domains(network_domain)
-        self.__post_query_base = self.__make_post_query_base()
+        query_builder = self.__make_sdk_sitecode_query_builder()
+        self.__sdk_sitecode_query_base = str(query_builder)
+        query_builder.append(
+            QueryParam(QueryParams.BODY_UA, "true"),
+        )
+        self.__tracking_query_base = str(query_builder)
 
-    def __make_post_query_base(self) -> str:
+    def __make_sdk_sitecode_query_builder(self) -> QueryBuilder:
         # fmt: off
         query_builder = QueryBuilder(
             QueryParam(QueryParams.SDK_NAME, SdkVersion.NAME),
             QueryParam(QueryParams.SDK_VERSION, SdkVersion.VERSION),
             QueryParam(QueryParams.SITE_CODE, self.site_code),
-            QueryParam(QueryParams.BODY_UA, "true"),
         )
         # fmt: on
-        return str(query_builder)
+        return query_builder
 
     def __setup_domains(self, network_domain: Optional[str]) -> None:
         """Updates the domains based on the provided network domain."""
@@ -73,7 +77,7 @@ class UrlProvider:
 
     def make_tracking_url(self) -> str:
         """Constructs the URL for tracking events."""
-        return self._DATA_API_URL_FORMAT.format(self._data_api_domain, self._TRACKING_PATH, self.__post_query_base)
+        return self._DATA_API_URL_FORMAT.format(self._data_api_domain, self._TRACKING_PATH, self.__tracking_query_base)
 
     def make_visitor_data_get_url(
         self, visitor_code: str, data_filter: RemoteVisitorDataFilter, is_unique_identifier: bool = False
@@ -134,4 +138,4 @@ class UrlProvider:
 
     def make_access_token_url(self) -> str:
         """Constructs the URL for fetching access tokens."""
-        return self._ACCESS_TOKEN_URL_FORMAT.format(self._access_token_domain)
+        return self._ACCESS_TOKEN_URL_FORMAT.format(self._access_token_domain) + "?" + self.__sdk_sitecode_query_base

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/sdk_version.py

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

{kameleoon_client_python-3.18.0 → kameleoon_client_python-3.19.0}/kameleoon/targeting/conditions/unknown_condition.py

@@ -1,5 +1,7 @@
 """Unknown condition"""
 from typing import Any
+
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.targeting.conditions.targeting_condition import TargetingCondition
 
 
@@ -11,4 +13,5 @@ class UnknownCondition(TargetingCondition):
     """
 
     def check(self, data: Any) -> bool:
+        KameleoonLogger.warning("Condition of unknown type '%s' evaluated as true", self.type)
         return True