kameleoon-client-python 3.10.0__tar.gz → 3.11.0__tar.gz

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/PKG-INFO

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

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon/data/conversion.py

@@ -1,6 +1,11 @@
 # pylint: disable=duplicate-code
 """Conversion data"""
+
+import json
+from typing import Optional, Iterable
+from kameleoon.data.custom_data import CustomData
 from kameleoon.data.data import Data, DataType
+from kameleoon.helpers.string_utils import StringUtils
 from kameleoon.network.sendable import DuplicationSafeSendableBase
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
 
@@ -11,7 +16,13 @@ class Conversion(Data, DuplicationSafeSendableBase):
 
     EVENT_TYPE = "conversion"
 
-    def __init__(self, goal_id: int, revenue: float = 0.0, negative: bool = False) -> None:
+    def __init__(
+        self,
+        goal_id: int,
+        revenue: float = 0.0,
+        negative: bool = False,
+        metadata: Optional[Iterable[CustomData]] = None,
+    ) -> None:
         """
         :param goal_id: Id of the goal associated to the conversion
         :type goal_id: int
@@ -19,6 +30,8 @@ class Conversion(Data, DuplicationSafeSendableBase):
         :type revenue: float
         :param negative: Optional field - If the revenue is negative. By default it's positive, defaults to False
         :type negative: bool
+        :param metadata: Optional field - Metadata of the conversion. `None` by default.
+        :type metadata: Optional[Iterable[CustomData]]
 
         Example:
 
@@ -31,6 +44,7 @@ class Conversion(Data, DuplicationSafeSendableBase):
         self.__goal_id = goal_id
         self.__revenue = revenue
         self.__negative = negative
+        self.__metadata = metadata
 
     @property
     def goal_id(self) -> int:
@@ -47,6 +61,11 @@ class Conversion(Data, DuplicationSafeSendableBase):
         """Returns negative flag state"""
         return self.__negative
 
+    @property
+    def metadata(self) -> Optional[Iterable[CustomData]]:
+        """Returns metadata"""
+        return self.__metadata
+
     @property
     def data_type(self) -> DataType:
         return DataType.CONVERSION
@@ -60,10 +79,23 @@ class Conversion(Data, DuplicationSafeSendableBase):
             QueryParam(QueryParams.REVENUE, str(self.revenue)),
             QueryParam(QueryParams.NEGATIVE, "true" if self.negative else "false"),
         )
+        if self.metadata:
+            query_builder.append(QueryParam(QueryParams.METADATA, self.__encode_metadata()))
+
+    def __encode_metadata(self) -> str:
+        metadata = {}
+        if self.metadata is not None:
+            added_indices = set()
+            for mcd in self.metadata:
+                if isinstance(mcd, CustomData) and (mcd.id not in added_indices):
+                    metadata[mcd.id] = mcd.values
+                    added_indices.add(mcd.id)
+        return json.dumps(metadata, separators=(",", ":"))
 
     def __str__(self):
         return (
             f"Conversion{{goal_id:{self.__goal_id},"
             f"revenue:{self.__revenue},"
-            f"negative:{self.__negative}}}"
+            f"negative:{self.__negative},"
+            f"metadata:{StringUtils.object_to_string(self.__metadata)}}}"
         )

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon/data/custom_data.py

@@ -45,9 +45,6 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.CUSTOM_DATA
 
-    def encode_query(self) -> str:
-        return super().encode_query() if len(self.__values) > 0 else ""
-
     def _add_query_params(self, query_builder: QueryBuilder) -> None:
         str_values = json.dumps({v: 1 for v in self.__values}, separators=(",", ":"))
         query_builder.extend(
@@ -58,7 +55,4 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
         )
 
     def __str__(self):
-        return (
-            f"CustomData{{id:{self.__id},"
-            f"values:{self.__values}}}"
-        )
+        return f"CustomData{{id:{self.__id},values:{self.__values}}}"

kameleoon-client-python-3.11.0/kameleoon/helpers/domain.py

@@ -0,0 +1,83 @@
+"""Helper for domain"""
+import re
+from typing import Optional
+
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
+
+HTTP = "http://"
+HTTPS = "https://"
+REGEX_DOMAIN = (
+    r"^(\.?(([a-zA-Z\d][a-zA-Z\d-]*[a-zA-Z\d])|[a-zA-Z\d]))"
+    r"(\.(([a-zA-Z\d][a-zA-Z\d-]*[a-zA-Z\d])|[a-zA-Z\d])){1,126}$"
+)
+LOCALHOST = "localhost"
+
+
+def validate_top_level_domain(top_level_domain: str) -> str:
+    """
+    Validate the given top-level domain.
+
+    Args:
+        top_level_domain (str): The top-level domain to validate.
+
+    Returns:
+        str: The validated top-level domain.
+    """
+    if top_level_domain == "":
+        return top_level_domain
+
+    top_level_domain = check_and_trim_protocol(top_level_domain.lower())
+
+    if not re.match(REGEX_DOMAIN, top_level_domain) and top_level_domain != LOCALHOST:
+        KameleoonLogger.error(
+            f"The top-level domain '{top_level_domain}' is invalid. The value has been set as provided, but it does "
+            f"not meet the required format for proper SDK functionality. Please check the domain for correctness.")
+        return top_level_domain
+
+    return top_level_domain
+
+
+def validate_network_domain(network_domain: Optional[str]) -> Optional[str]:
+    """
+    Validate the given network domain.
+
+    Args:
+        network_domain: The network domain to validate.
+
+    Returns:
+        str or None: The validated network domain, or None if invalid.
+    """
+    if not network_domain:
+        return None
+
+    network_domain = check_and_trim_protocol(network_domain.lower())
+
+    # Replace first and last dot
+    network_domain = re.sub(r"^\.+|\.+$", "", network_domain)
+
+    if not re.match(REGEX_DOMAIN, network_domain) and network_domain != LOCALHOST:
+        KameleoonLogger.error(f"The network domain '{network_domain}' is invalid.")
+        return None
+
+    return network_domain
+
+
+def check_and_trim_protocol(domain: str) -> str:
+    """
+    Check if the domain contains a protocol and trim it if it does.
+
+    Args:
+        domain: The domain to check and trim.
+
+    Returns:
+        str: The domain after trimming the protocol.
+    """
+    protocols = [HTTP, HTTPS]
+    for protocol in protocols:
+        if domain.startswith(protocol):
+            domain = domain[len(protocol):]
+            KameleoonLogger.warning(
+                f"The domain contains '{protocol}'. Domain after protocol trimming: '{domain}'"
+            )
+            return domain
+    return domain

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon/helpers/string_utils.py

@@ -1,5 +1,6 @@
 """Helper class for work with string values"""
 
+import collections.abc
 from typing import Any, Optional
 
 
@@ -31,6 +32,8 @@ class StringUtils:
     @staticmethod
     def object_to_string(data: Any) -> str:
         """Convert various data types into their string representation."""
+        if data is None:
+            return "None"
         if isinstance(data, str):
             return f"'{data}'"
         result = StringUtils._collection_to_string(data)
@@ -38,19 +41,17 @@ class StringUtils:
             return result
         if isinstance(data, bool):
             return StringUtils.bool_to_string_lower_case(data)
-        if data is None:
-            return "None"
         if hasattr(data, '__str__'):
             return str(data)
         return repr(data)
 
     @staticmethod
     def _collection_to_string(data: Any) -> Optional[str]:
-        if isinstance(data, (list, tuple)):
-            return "[" + ",".join(StringUtils.object_to_string(item) for item in data) + "]"
         if isinstance(data, dict):
             return "{" + ",".join(
                 f"{StringUtils.object_to_string(key)}: {StringUtils.object_to_string(value)}"
                 for key, value in data.items()
             ) + "}"
+        if isinstance(data, collections.abc.Iterable):
+            return "[" + ",".join(StringUtils.object_to_string(item) for item in data) + "]"
         return None

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon/kameleoon_client.py

@@ -142,6 +142,7 @@ class KameleoonClient:
             config.default_timeout_second,
             NetProviderImpl(),
             atsf,
+            config.network_domain,
         )
         self._targeting_manager = TargetingManager(self._data_manager, self._visitor_manager)
         self._warehouse_manager = WarehouseManager(self._network_manager, self._visitor_manager)
@@ -354,7 +355,8 @@ class KameleoonClient:
         KameleoonLogger.info("RETURN: KameleoonClient.add_data(visitor_code: %s, args: %s)", visitor_code, args)
 
     def track_conversion(
-        self, visitor_code: str, goal_id: int, revenue: float = 0.0, is_unique_identifier: Optional[bool] = None
+        self, visitor_code: str, goal_id: int, revenue: float = 0.0, is_unique_identifier: Optional[bool] = None,
+        negative=False, metadata: Optional[Iterable[CustomData]] = None,
     ) -> None:
         """
         To track conversion, use the track_conversion() method. This method requires visitor_code and goal_id to track
@@ -372,28 +374,25 @@ class KameleoonClient:
         :param is_unique_identifier: (Deprecated) Parameter that specifies whether the visitorCode is
         a unique identifier.
         :type is_unique_identifier: Optional[bool]
-        :return: None
+        :param negative: Defines if the revenue is positive or negative. This field is optional (`False` by default).
+        :type negative: bool
+        :param metadata: Metadata of the conversion. This field is optional (`None` by default).
+        :type metadata: Optional[Iterable[CustomData]]
         """
         KameleoonLogger.info(
             "CALL: KameleoonClient.track_conversion(visitor_code: %s, goal_id: %s, revenue: %s, "
-            "is_unique_identifier: %s)",
-            visitor_code,
-            goal_id,
-            revenue,
-            is_unique_identifier,
+            "is_unique_identifier: %s, negative: %s, metadata: %s)",
+            visitor_code, goal_id, revenue, is_unique_identifier, negative, metadata
         )
         validate_visitor_code(visitor_code)
         if is_unique_identifier is not None:
             self.__set_unique_identifier(visitor_code, is_unique_identifier)
-        self.add_data(visitor_code, Conversion(goal_id, revenue))
+        self.add_data(visitor_code, Conversion(goal_id, revenue, negative, metadata))
         self._tracking_manager.add_visitor_code(visitor_code)
         KameleoonLogger.info(
             "RETURN: KameleoonClient.track_conversion(visitor_code: %s, goal_id: %s, revenue: %s, "
-            "is_unique_identifier: %s)",
-            visitor_code,
-            goal_id,
-            revenue,
-            is_unique_identifier,
+            "is_unique_identifier: %s, negative: %s, metadata: %s)",
+            visitor_code, goal_id, revenue, is_unique_identifier, negative, metadata
         )
 
     def flush(

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon/kameleoon_client_config.py

@@ -1,11 +1,12 @@
 """Kameleoon Client Configuration"""
+
 import logging
 import os
 from typing import Any, Dict, Optional
 import yaml
 
 from kameleoon.exceptions import ConfigCredentialsInvalid, ConfigFileNotFound
-from kameleoon.helpers.domain import validate_top_level_domain
+from kameleoon.helpers.domain import validate_top_level_domain, validate_network_domain
 from kameleoon.helpers.logger import Logger
 from kameleoon.helpers.string_utils import StringUtils
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
@@ -22,7 +23,7 @@ DEFAULT_CONFIGURATION_PATH = "/etc/kameleoon/client-python.yaml"
 class KameleoonClientConfig:
     """Client configuration which can be used instead of external configuration file"""
 
-    # pylint: disable=R0913
+    # pylint: disable=R0913, R0904
     def __init__(
         self,
         client_id: str,
@@ -35,6 +36,7 @@ class KameleoonClientConfig:
         logger: Optional[logging.Logger] = None,
         multi_threading: Optional[bool] = None,
         tracking_interval_millisecond=DEFAULT_TRACKING_INTERVAL_MILLISECONDS,
+        network_domain: Optional[str] = None,
     ) -> None:
         """
         :param logger: (Deprecated)
@@ -67,6 +69,7 @@ class KameleoonClientConfig:
         self.__multi_threading = False
         if multi_threading is not None:
             self.set_multi_threading(multi_threading)
+        self.set_network_domain(network_domain)
 
     @staticmethod
     def read_from_yaml(config_path=DEFAULT_CONFIGURATION_PATH) -> "KameleoonClientConfig":
@@ -104,6 +107,8 @@ class KameleoonClientConfig:
             kwargs["top_level_domain"] = top_level_domain
         if isinstance(multi_threading := config_dict.get("multi_threading"), bool):
             kwargs["multi_threading"] = multi_threading
+        if isinstance(network_domain := config_dict.get("network_domain"), str):
+            kwargs["network_domain"] = network_domain
         return KameleoonClientConfig(client_id, client_secret, **kwargs)
 
     @property
@@ -137,9 +142,11 @@ class KameleoonClientConfig:
     def set_refresh_interval_minute(self, value: float) -> None:
         """Sets the refresh interval in minutes"""
         if value <= 0:
-            KameleoonLogger.warning("Configuration refresh interval must have positive value. "
-                                    "Default refresh interval (%s minutes) was applied.",
-                                    DEFAULT_REFRESH_INTERVAL_MINUTES)
+            KameleoonLogger.warning(
+                "Configuration refresh interval must have positive value. "
+                "Default refresh interval (%s minutes) was applied.",
+                DEFAULT_REFRESH_INTERVAL_MINUTES,
+            )
             value = DEFAULT_REFRESH_INTERVAL_MINUTES
         self.__refresh_interval_second = value * 60.0
 
@@ -151,8 +158,10 @@ class KameleoonClientConfig:
     def set_session_duration_minute(self, value: float) -> None:
         """Sets the session duration in minutes"""
         if value <= 0:
-            KameleoonLogger.warning("Session duration must have positive value. Default session duration "
-                                    "(%s minutes) was applied.", DEFAULT_SESSION_DURATION_MINUTES)
+            KameleoonLogger.warning(
+                "Session duration must have positive value. Default session duration " "(%s minutes) was applied.",
+                DEFAULT_SESSION_DURATION_MINUTES,
+            )
             value = DEFAULT_SESSION_DURATION_MINUTES
         self.__session_duration_second = value * 60.0
 
@@ -164,8 +173,10 @@ class KameleoonClientConfig:
     def set_default_timeout_millisecond(self, value: int) -> None:
         """Sets the default timeout in milliseconds"""
         if value <= 0:
-            KameleoonLogger.warning("Default timeout must have positive value. Default value (%s ms) was applied.",
-                                    DEFAULT_DEFAULT_TIMEOUT_MILLISECONDS)
+            KameleoonLogger.warning(
+                "Default timeout must have positive value. Default value (%s ms) was applied.",
+                DEFAULT_DEFAULT_TIMEOUT_MILLISECONDS,
+            )
             value = DEFAULT_DEFAULT_TIMEOUT_MILLISECONDS
         self.__default_timeout_second = value / 1000.0
 
@@ -179,12 +190,14 @@ class KameleoonClientConfig:
         if value < MIN_TRACKING_INTERVAL_MILLISECONDS:
             KameleoonLogger.warning(
                 "Tracking interval must not be shorter than (%s ms). Minimum possible interval was applied.",
-                MIN_TRACKING_INTERVAL_MILLISECONDS)
+                MIN_TRACKING_INTERVAL_MILLISECONDS,
+            )
             value = MIN_TRACKING_INTERVAL_MILLISECONDS
         elif value > MAX_TRACKING_INTERVAL_MILLISECONDS:
             KameleoonLogger.warning(
                 "Tracking interval must not be longer than (%s ms). Maximum possible interval was applied.",
-                MAX_TRACKING_INTERVAL_MILLISECONDS)
+                MAX_TRACKING_INTERVAL_MILLISECONDS,
+            )
             value = MAX_TRACKING_INTERVAL_MILLISECONDS
         self.__tracking_interval_second = value / 1000.0
 
@@ -205,8 +218,10 @@ class KameleoonClientConfig:
     def set_top_level_domain(self, value: str) -> None:
         """Sets the top level domain"""
         if not value:
-            KameleoonLogger.warning("Setting top level domain is strictly recommended, "
-                                    "otherwise you may have problems when using subdomains.")
+            KameleoonLogger.warning(
+                "Setting top level domain is strictly recommended, "
+                "otherwise you may have problems when using subdomains."
+            )
         self.__top_level_domain = validate_top_level_domain(value)
 
     @property
@@ -219,6 +234,15 @@ class KameleoonClientConfig:
         self.__multi_threading = value
         KameleoonLogger.warning("Configuration parameter 'multi_threading' is deprecated.")
 
+    @property
+    def network_domain(self) -> Optional[str]:
+        """Returns the network domain"""
+        return self.__network_domain
+
+    def set_network_domain(self, value: Optional[str]) -> None:
+        """Sets the network domain"""
+        self.__network_domain = validate_network_domain(value)
+
     def __str__(self):
         return (
             f"KameleoonClientConfig{{"
@@ -228,4 +252,6 @@ class KameleoonClientConfig:
             f"session_duration_second:{self.__session_duration_second},"
             f"environment:'{self.__environment}',"
             f"default_timeout_millisecond:{self.__default_timeout_second},"
-            f"top_level_domain:'{self.__top_level_domain}'}}")
+            f"top_level_domain:{self.__top_level_domain},"
+            f"network_domain:'{self.__network_domain}'}}"
+        )

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon/network/network_manager_factory.py

@@ -15,6 +15,7 @@ class NetworkManagerFactory:
         call_timeout: float,
         net_provider: NetProvider,
         access_token_source_factory: AccessTokenSourceFactory,
+        network_domain: Optional[str],
     ) -> NetworkManager:
         """Creates and returns an instance of `NetworkManager` with the specified parameters."""
         raise NotImplementedError()

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon/network/network_manager_factory_impl.py

@@ -1,4 +1,5 @@
 """Network"""
+
 from typing import Optional
 from kameleoon.network.access_token_source_factory import AccessTokenSourceFactory
 from kameleoon.network.url_provider import UrlProvider
@@ -16,18 +17,20 @@ from kameleoon.network.services.data_service_impl import DataServiceImpl
 
 class NetworkManagerFactoryImpl(NetworkManagerFactory):
     """Network manager factory implementation"""
+
     # fmt is disabled due issue in pylint, disabling R0801 doesn’t work
     # fmt: off
     # pylint: disable=R0913
     def create(
         self,
         site_code: str,
-        environment: Optional[str], call_timeout: float,
+        environment: Optional[str], call_timeout: float,  # don`t change this line
         net_provider: NetProvider,
         access_token_source_factory: AccessTokenSourceFactory,
+        network_domain: Optional[str],
     ) -> NetworkManager:
         # fmt: on
-        url_provider = UrlProvider(site_code, UrlProvider.DEFAULT_DATA_API_DOMAIN)
+        url_provider = UrlProvider(site_code, network_domain)
         network_manager = NetworkManagerImpl(
             url_provider, environment, call_timeout, net_provider, access_token_source_factory,
         )

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon/network/query_builder.py

@@ -25,6 +25,7 @@ class QueryParams(str, Enum):
     KCS = "kcs"
     KEY = "key"
     MAX_NUMBER_PREVIOUS_VISITS = "maxNumberPreviousVisits"
+    METADATA = "metadata"
     NEGATIVE = "negative"
     NONCE = "nonce"
     OVERWRITE = "overwrite"

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon/network/url_provider.py

@@ -1,4 +1,5 @@
 """Network"""
+
 from typing import Any, Optional
 from kameleoon.sdk_version import SdkVersion
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
@@ -7,29 +8,32 @@ from kameleoon.types.remote_visitor_data_filter import RemoteVisitorDataFilter
 
 class UrlProvider:
     """URL provider"""
+
     _TRACKING_PATH = "/visit/events"
     _VISITOR_DATA_PATH = "/visit/visitor"
     _EXPERIMENTS_CONFIGURATIONS_PATH = "/visit/experimentsConfigurations"
     _GET_DATA_PATH = "/map/map"
     _POST_DATA_PATH = "/map/maps"
-    _ACCESS_TOKEN_PATH = "/oauth/token"
-    _CONFIGURATION_API_URL_F = "https://sdk-config.kameleoon.eu/{0}"
-    _RT_CONFIGURATION_URL = "https://events.kameleoon.com:8110/sse"
+    _CONFIGURATION_API_URL_FORMAT = "https://{0}/{1}"
+    _RT_CONFIGURATION_URL_FORMAT = "https://{0}:8110/sse?{1}"
+    _ACCESS_TOKEN_URL_FORMAT = "https://{0}/oauth/token"
+    _DATA_API_URL_FORMAT = "https://{0}{1}?{2}"
 
-    DEFAULT_DATA_API_DOMAIN = "data.kameleoon.io"
     TEST_DATA_API_DOMAIN = "data.kameleoon.net"
-    DEFAULT_AUTOMATION_API_DOMAIN = "api.kameleoon.com"
     TEST_AUTOMATION_API_DOMAIN = "api.kameleoon.net"
+    DEFAULT_DATA_API_DOMAIN = "data.kameleoon.io"
+    DEFAULT_EVENTS_DOMAIN = "events.kameleoon.eu"
+    DEFAULT_CONFIGURATION_DOMAIN = "sdk-config.kameleoon.eu"
+    DEFAULT_ACCESS_TOKEN_DOMAIN = "api.kameleoon.com"
 
     def __init__(
         self,
         site_code: str,
-        data_api_domain=DEFAULT_DATA_API_DOMAIN,
-        automation_api_domain=DEFAULT_AUTOMATION_API_DOMAIN,
+        network_domain: Optional[str] = None,
     ) -> None:
         self.site_code = site_code
-        self._data_api_domain = data_api_domain
-        self._automation_api_domain = automation_api_domain
+        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()
 
     def __make_post_query_base(self) -> str:
@@ -43,14 +47,33 @@ class UrlProvider:
         # fmt: on
         return str(query_builder)
 
-    def apply_data_api_domain(self, domain: Any) -> None:
+    def __setup_domains(self, network_domain: Optional[str]) -> None:
+        """Updates the domains based on the provided network domain."""
+        if not network_domain:
+            self._data_api_domain = self.DEFAULT_DATA_API_DOMAIN
+            self._events_domain = self.DEFAULT_EVENTS_DOMAIN
+            self._configuration_domain = self.DEFAULT_CONFIGURATION_DOMAIN
+            self._access_token_domain = self.DEFAULT_ACCESS_TOKEN_DOMAIN
+            self.__is_custom_domain = False
+        else:
+            self._events_domain = f"events.{network_domain}"
+            self._configuration_domain = f"sdk-config.{network_domain}"
+            self._data_api_domain = f"data.{network_domain}"
+            self._access_token_domain = f"api.{network_domain}"
+            self.__is_custom_domain = True
+
+    def apply_data_api_domain(self, data_api_domain: Any) -> None:
         """Sets the domain for the data API."""
-        if isinstance(domain, str):
-            self._data_api_domain = domain
+        if data_api_domain:
+            if self.__is_custom_domain:
+                sub_domain = data_api_domain.split(".")[0]
+                self._data_api_domain = self._data_api_domain.replace(self._data_api_domain.split(".")[0], sub_domain)
+            else:
+                self._data_api_domain = data_api_domain
 
     def make_tracking_url(self) -> str:
         """Constructs the URL for tracking events."""
-        return f"https://{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.__post_query_base)
 
     def make_visitor_data_get_url(
         self, visitor_code: str, data_filter: RemoteVisitorDataFilter, is_unique_identifier: bool = False
@@ -72,11 +95,12 @@ class UrlProvider:
         self.__add_flag_param_if_required(query_builder, QueryParams.EXPERIMENT, data_filter.experiments)
         self.__add_flag_param_if_required(query_builder, QueryParams.PAGE, data_filter.page_views)
         self.__add_flag_param_if_required(
-            query_builder, QueryParams.STATIC_DATA,
-            data_filter.device or data_filter.browser or data_filter.operating_system
+            query_builder,
+            QueryParams.STATIC_DATA,
+            data_filter.device or data_filter.browser or data_filter.operating_system,
         )
         self.__add_flag_param_if_required(query_builder, QueryParams.CBS, data_filter.cbs)
-        return f"https://{self._data_api_domain}{self._VISITOR_DATA_PATH}?{query_builder}"
+        return self._DATA_API_URL_FORMAT.format(self._data_api_domain, self._VISITOR_DATA_PATH, str(query_builder))
 
     @staticmethod
     def __add_flag_param_if_required(query_builder: QueryBuilder, param_name: QueryParams, state: bool) -> None:
@@ -91,7 +115,7 @@ class UrlProvider:
             QueryParam(QueryParams.KEY, key),
         )
         # fmt: on
-        return f"https://{self._data_api_domain}{self._GET_DATA_PATH}?{query_builder}"
+        return self._DATA_API_URL_FORMAT.format(self._data_api_domain, self._GET_DATA_PATH, str(query_builder))
 
     def make_configuration_url(self, environment: Optional[str] = None, time_stamp: Optional[int] = None) -> str:
         """Constructs the URL for fetching configuration data with optional query parameters."""
@@ -100,7 +124,7 @@ class UrlProvider:
             query_builder.append(QueryParam(QueryParams.ENVIRONMENT, environment))
         if time_stamp is not None:
             query_builder.append(QueryParam(QueryParams.TS, str(time_stamp)))
-        url = self._CONFIGURATION_API_URL_F.format(self.site_code)
+        url = self._CONFIGURATION_API_URL_FORMAT.format(self._configuration_domain, self.site_code)
         query = str(query_builder)
         if len(query) > 0:
             url = f"{url}?{query}"
@@ -109,8 +133,8 @@ class UrlProvider:
     def make_real_time_url(self) -> str:
         """Constructs the URL for real-time configuration data."""
         query_builder = QueryParam(QueryParams.SITE_CODE, self.site_code)
-        return f"{self._RT_CONFIGURATION_URL}?{query_builder}"
+        return self._RT_CONFIGURATION_URL_FORMAT.format(self._events_domain, query_builder)
 
     def make_access_token_url(self) -> str:
         """Constructs the URL for fetching access tokens."""
-        return f"https://{self._automation_api_domain}{self._ACCESS_TOKEN_PATH}"
+        return self._ACCESS_TOKEN_URL_FORMAT.format(self._access_token_domain)

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon/sdk_version.py

@@ -1,10 +1,10 @@
-""" Kameleoon SDK version """
+"""Kameleoon SDK version"""
 
 from typing import Optional, Tuple
 
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 
-version_info = (3, 10, 0)
+version_info = (3, 11, 0)
 __version__ = ".".join(str(v) for v in version_info)  # uses in scripts
 
 

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.11.0}/kameleoon_client_python.egg-info/PKG-INFO

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