kameleoon-client-python 3.12.0__tar.gz → 3.13.0__tar.gz

{kameleoon-client-python-3.12.0/kameleoon_client_python.egg-info → kameleoon-client-python-3.13.0}/PKG-INFO

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

{kameleoon-client-python-3.12.0 → kameleoon-client-python-3.13.0}/kameleoon/configuration/data_file.py

@@ -19,12 +19,12 @@ class DataFile:
     @staticmethod
     def default(environment: Optional[str]) -> "DataFile":
         """Creates new instance of `DataFile` initialized with default values"""
-        data_file = DataFile(environment, Settings(), {}, CustomDataInfo(None))
+        data_file = DataFile(environment, None, Settings(), {}, CustomDataInfo(None))
         return data_file
 
     @staticmethod
     def from_json(
-        environment: Optional[str], configuration: Dict[str, Any]
+        environment: Optional[str], last_modified: Optional[str], configuration: Dict[str, Any]
     ) -> "DataFile":
         """Creates new instance of `DataFile` initialized from the specified configuration JSON"""
         settings = Settings(configuration.get("configuration"))
@@ -34,23 +34,26 @@ class DataFile:
         }
         custom_data_info = CustomDataInfo(configuration.get("customData"))
         holdout = Experiment.from_json(configuration["holdout"]) if "holdout" in configuration else None
-        data_file = DataFile(environment, settings, feature_flags, custom_data_info, holdout)
+        data_file = DataFile(environment, last_modified, settings, feature_flags, custom_data_info, holdout)
         return data_file
 
     # pylint: disable=R0913
     def __init__(
         self,
         environment: Optional[str],
+        last_modified: Optional[str],
         settings: Settings,
         feature_flags: Dict[str, FeatureFlag],
         custom_data_info: CustomDataInfo,
         holdout: Optional[Experiment] = None,
     ) -> None:
         KameleoonLogger.debug(
-            'CALL: DataFile(environment: %s, settings: %s, feature_flags: %s, custom_data_info: %s, holdout: %s)',
-            environment, settings, feature_flags, custom_data_info, holdout
+            "CALL: DataFile(environment: %s, last_modified: %s, settings: %s, feature_flags: %s,"
+            " custom_data_info: %s, holdout: %s)",
+            environment, last_modified, settings, feature_flags, custom_data_info, holdout
         )
         self.__environment = environment  # pylint: disable=W0238
+        self.__last_modified = last_modified
         self.__settings = settings
         self.__feature_flags: Dict[str, FeatureFlag] = feature_flags
         self.__me_groups = self.__make_me_groups(feature_flags.values())
@@ -69,10 +72,16 @@ class DataFile:
         self.__custom_data_info = custom_data_info
         self.__holdout = holdout
         KameleoonLogger.debug(
-            'RETURN: DataFile.new(environment: %s, settings: %s, feature_flags: %s, custom_data_info: %s, holdout: %s)',
-            environment, settings, feature_flags, custom_data_info
+            "RETURN: DataFile(environment: %s, last_modified: %s, settings: %s, feature_flags: %s,"
+            " custom_data_info: %s, holdout: %s)",
+            environment, last_modified, settings, feature_flags, custom_data_info, holdout
         )
 
+    @property
+    def last_modified(self) -> Optional[str]:
+        """Returns last modified string"""
+        return self.__last_modified
+
     @property
     def settings(self) -> Settings:
         """Returns settings"""
@@ -177,11 +186,12 @@ class DataFile:
 
     def __str__(self):
         return (
-            f"DataFile{{"
+            "DataFile{"
             f"environment:'{self.__environment}',"
+            f"last_modified:'{self.__last_modified}',"
             f"feature_flags:{len(self.__feature_flags)},"
             f"settings:{self.__settings}"
-            f"}}"
+            "}"
         )
 
     class RuleInfo:

{kameleoon-client-python-3.12.0 → kameleoon-client-python-3.13.0}/kameleoon/data/manager/visitor.py

@@ -1,4 +1,6 @@
 """Visitor"""
+import time
+
 from threading import Lock
 from typing import Any, Callable, Optional, Dict, List, Iterator, Iterable, cast
 
@@ -44,6 +46,11 @@ class Visitor:  # pylint: disable=R0904
         """Creates and returns a clone of the current Visitor instance which shares all the visitor data."""
         return Visitor(self)
 
+    @property
+    def time_started(self) -> int:
+        """Returns the current visit's start time"""
+        return self._data.time_started
+
     def enumerate_sendable_data(self) -> Iterator[Sendable]:
         """Enumerates all sendable data associated with this Visitor."""
         KameleoonLogger.debug('CALL: Visitor.enumerate_sendable_data()')
@@ -263,6 +270,7 @@ class Visitor:  # pylint: disable=R0904
     class VisitorData:
         """Visitor Data"""
         def __init__(self) -> None:
+            self.time_started = int(time.time() * 1000)
             self.lock = Lock()
             self.user_agent: Optional[str] = None
             self.device: Optional[Device] = None
@@ -289,18 +297,20 @@ class Visitor:  # pylint: disable=R0904
                 yield self.device
             if self.browser:
                 yield self.browser
-            if self.geolocation:
-                yield self.geolocation
             if self.operating_system:
                 yield self.operating_system
+            if self.geolocation:
+                yield self.geolocation
+            if self.visitor_visits:
+                yield self.visitor_visits
             if self.custom_data_dict is not None:
                 yield from list(self.custom_data_dict.values())
             if self.page_view_visits is not None:
                 yield from (visit.page_view for visit in list(self.page_view_visits.values()))
-            if self.conversions is not None:
-                yield from list(self.conversions)
             if self.variations is not None:
                 yield from list(self.variations.values())
+            if self.conversions is not None:
+                yield from list(self.conversions)
 
         def count_sendable_data(self) -> int:
             """Counts the total number of sendable data items associated with the visitor."""
@@ -309,18 +319,20 @@ class Visitor:  # pylint: disable=R0904
                 count += 1
             if self.browser is not None:
                 count += 1
+            if self.operating_system is not None:
+                count += 1
             if self.geolocation is not None:
                 count += 1
-            if self.operating_system is not None:
+            if self.visitor_visits:
                 count += 1
             if self.custom_data_dict is not None:
                 count += len(self.custom_data_dict)
             if self.page_view_visits is not None:
                 count += len(self.page_view_visits)
-            if self.conversions is not None:
-                count += len(self.conversions)
             if self.variations is not None:
                 count += len(self.variations)
+            if self.conversions is not None:
+                count += len(self.conversions)
             return count
 
     class DataAddingContext:
@@ -433,7 +445,8 @@ class Visitor:  # pylint: disable=R0904
             self._data.cbscores = cast(CBScores, context.data)
 
     def _set_visitor_visits(self, context: DataAddingContext) -> None:
-        self._data.visitor_visits = cast(VisitorVisits, context.data)
+        if context.overwrite or (self._data.visitor_visits is None):
+            self._data.visitor_visits = cast(VisitorVisits, context.data).localize(self._data.time_started)
 
     def _set_is_unique_identifier(self, context: DataAddingContext) -> None:
         self._is_unique_identifier = cast(UniqueIdentifier, context.data).value

kameleoon-client-python-3.13.0/kameleoon/data/visitor_visits.py

@@ -0,0 +1,117 @@
+"""Visitor visits"""
+
+from typing import Any, List, Optional, Tuple
+
+from kameleoon.data import DataType
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
+from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
+
+from kameleoon.data.data import BaseData
+
+
+class VisitorVisits(BaseData, DuplicationUnsafeSendableBase):
+    """Visitor visits"""
+
+    EVENT_TYPE = "staticData"
+
+    def __init__(
+        self, prev_visits: List["Visit"], visit_number=0, *, time_started=0, time_since_previous_visit=0
+    ) -> None:
+        super().__init__()
+        self.__visit_number = max(visit_number, len(prev_visits))
+        self.__prev_visits = prev_visits
+        self.__time_started = time_started
+        self.__time_since_previous_visit = time_since_previous_visit
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.VISITOR_VISITS
+
+    @property
+    def visit_number(self) -> int:
+        """Returns the visit number"""
+        return self.__visit_number
+
+    @property
+    def prev_visits(self) -> List["Visit"]:
+        """Returns the previous visit list"""
+        return self.__prev_visits
+
+    @property
+    def time_started(self) -> int:
+        """Returns the current visit's start time"""
+        return self.__time_started
+
+    @property
+    def time_since_previous_visit(self) -> int:
+        """Returns the time since the previous visit"""
+        return self.__time_since_previous_visit
+
+    def localize(self, time_started: int) -> "VisitorVisits":
+        """
+        Localizes a remote instance of `VisitorVisits` creating a new instance
+        with a specific current visit's start time.
+        """
+        time_since_previous_visit = 0
+        for visit in self.__prev_visits:
+            time_delta = time_started - visit.time_last_activity
+            if time_delta >= 0:
+                time_since_previous_visit = time_delta
+                break
+        return VisitorVisits(
+            self.__prev_visits, self.__visit_number,
+            time_started=time_started, time_since_previous_visit=time_since_previous_visit,
+        )
+
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        query_builder.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
+            QueryParam(QueryParams.VISIT_NUMBER, str(self.__visit_number)),
+            QueryParam(QueryParams.TIME_SINCE_PREVIOUS_VISIT, str(self.__time_since_previous_visit)),
+        )
+
+    def __eq__(self, value: Any) -> bool:
+        return isinstance(value, VisitorVisits) and (self.__visit_number == value.visit_number) and \
+            (self.__prev_visits == value.prev_visits) and (self.__time_started == value.time_started) and \
+            (self.__time_since_previous_visit == value.time_since_previous_visit)
+
+    def __str__(self) -> str:
+        return (
+            "VisitorVisits{"
+            f"visit_number:{self.__visit_number},"
+            f"prev_visits:{[str(v) for v in self.__prev_visits]},"
+            f"time_started:{self.__time_started},"
+            f"time_since_previous_visit:{self.__time_since_previous_visit}"
+            "}"
+        )
+
+    @staticmethod
+    def get_visitor_visits(obj: Any) -> Tuple["VisitorVisits", bool]:
+        """Determines if an object is `VisitorVisits` or `None` and returns a valid instance of `VisitorVisits`."""
+        if isinstance(obj, VisitorVisits):
+            return obj, True
+        return VisitorVisits([]), obj is None
+
+    class Visit:
+        """Visit"""
+
+        def __init__(self, time_started: int, time_last_activity: Optional[int] = None) -> None:
+            self.__time_started = time_started
+            self.__time_last_activity = time_last_activity or time_started
+
+        @property
+        def time_started(self) -> int:
+            """Returns the start time"""
+            return self.__time_started
+
+        @property
+        def time_last_activity(self) -> int:
+            """Returns the last activity time"""
+            return self.__time_last_activity
+
+        def __eq__(self, value: Any) -> bool:
+            return isinstance(value, VisitorVisits.Visit) and (self.__time_started == value.time_started) and \
+                (self.__time_last_activity == value.time_last_activity)
+
+        def __str__(self) -> str:
+            return f"Visit{{time_started:{self.__time_started},time_last_activity:{self.__time_last_activity}}}"

{kameleoon-client-python-3.12.0 → kameleoon-client-python-3.13.0}/kameleoon/kameleoon_client.py

@@ -47,7 +47,7 @@ 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
+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
@@ -1435,13 +1435,18 @@ class KameleoonClient:
         KameleoonLogger.debug("CALL: KameleoonClient._fetch_configuration(time_stamp: %s)", time_stamp)
         success = False
         try:
-            configuration_json = await self._obtain_configuration(time_stamp)
-            if configuration_json:
-                data_file = DataFile.from_json(self._config.environment, configuration_json)
-                self._data_manager.data_file = data_file
-                self._network_manager.url_provider.apply_data_api_domain(data_file.settings.data_api_domain)
-                self._call_update_handler_if_needed(time_stamp is not None)
-            success = True
+            fetched_configuration = await self._obtain_configuration(time_stamp)
+            if fetched_configuration:
+                if fetched_configuration.configuration:
+                    data_file = DataFile.from_json(
+                        self._config.environment,
+                        fetched_configuration.last_modified,
+                        fetched_configuration.configuration
+                    )
+                    self._data_manager.data_file = data_file
+                    self._network_manager.url_provider.apply_data_api_domain(data_file.settings.data_api_domain)
+                    self._call_update_handler_if_needed(time_stamp is not None)
+                success = True
         except Exception as ex:
             KameleoonLogger.error("Error occurred during configuration fetching: %s", ex)
         self._manage_configuration_update(self._data_manager.data_file.settings.real_time_update)
@@ -1532,7 +1537,7 @@ class KameleoonClient:
         if not self._data_manager.data_file.settings.real_time_update:
             await self._fetch_configuration()
 
-    async def _obtain_configuration(self, time_stamp: Optional[int]) -> Optional[Dict[str, Any]]:
+    async def _obtain_configuration(self, time_stamp: Optional[int]) -> Optional[FetchedConfiguration]:
         """
         Obtaining configuration from CDN service.
         Should be run in a separate thead.
@@ -1541,15 +1546,14 @@ class KameleoonClient:
         :return: None
         """
         KameleoonLogger.debug("CALL: KameleoonClient._obtain_configuration(time_stamp: %s)", time_stamp)
+        last_modified = self._data_manager.data_file.last_modified
         service: ConfigurationService = self._network_manager.get_service(ConfigurationService)
-        response = await service.fetch_configuration(self._config.environment, time_stamp)
-        content = None
-        if response.code and (response.code // 100 == 2):
-            content = response.content
+        fetched_configuration = await service.fetch_configuration(self._config.environment, time_stamp, last_modified)
         KameleoonLogger.debug(
-            "RETURN: KameleoonClient._obtain_configuration(time_stamp: %s) -> (content: %s)", time_stamp, content
+            "RETURN: KameleoonClient._obtain_configuration(time_stamp: %s) -> (fetched_configuration: %s)",
+            time_stamp, fetched_configuration
         )
-        return content
+        return fetched_configuration
 
     def __get_feature_variation_key(self, visitor_code: str, feature_key: str) -> Tuple[FeatureFlag, str]:
         """

{kameleoon-client-python-3.12.0 → kameleoon-client-python-3.13.0}/kameleoon/managers/remote_data/remote_data_manager.py

@@ -63,7 +63,7 @@ class RemoteDataManager:
         if response.content is None:
             return []
         custom_data_info = self._data_manager.data_file.custom_data_info
-        remote_visitor_data = RemoteDataManager.__parse_remote_visitor_data(response.content)
+        remote_visitor_data = RemoteDataManager.__parse_remote_visitor_data(response.content, data_filter)
         remote_visitor_data.mark_data_as_sent(custom_data_info)
         data_to_add = remote_visitor_data.collect_data_to_add()
         if add_data and data_to_add:
@@ -77,9 +77,9 @@ class RemoteDataManager:
         return remote_visitor_data.collect_data_to_return()
 
     @staticmethod
-    def __parse_remote_visitor_data(raw: Any) -> RemoteVisitorData:
+    def __parse_remote_visitor_data(raw: Any, data_filter: RemoteVisitorDataFilter) -> RemoteVisitorData:
         try:
-            return RemoteVisitorData(raw)
+            return RemoteVisitorData(raw, data_filter)
         except Exception as ex:  # pylint: disable=W0703
             KameleoonLogger.error("Parsing of remote visitor data failed: %s", ex)
-            return RemoteVisitorData({})
+            return RemoteVisitorData({}, data_filter)

{kameleoon-client-python-3.12.0 → kameleoon-client-python-3.13.0}/kameleoon/managers/remote_data/remote_visitor_data.py

@@ -28,12 +28,14 @@ from kameleoon.data import (
     OperatingSystemType,
     Data,
 )
+from kameleoon.types.remote_visitor_data_filter import RemoteVisitorDataFilter
 
 
 class RemoteVisitorData:
     """Remote visitor data"""
 
-    def __init__(self, json: Dict[str, Any]) -> None:
+    def __init__(self, json: Dict[str, Any], data_filter: RemoteVisitorDataFilter) -> None:
+        self.__filter = data_filter
         self.__geolocation: Optional[Geolocation] = None
         self.__device: Optional[Device] = None
         self.__browser: Optional[Browser] = None
@@ -43,18 +45,22 @@ class RemoteVisitorData:
         self.__experiments: Optional[Dict[int, AssignedVariation]] = None
         self.__personalizations: Optional[Dict[int, Personalization]] = None
         self.__conversions: Optional[List[Conversion]] = None
-        self.__previous_visitor_visits: Optional[VisitorVisits] = None
+        self.__visit_number = 0
+        self.__visitor_visits: Optional[VisitorVisits] = None
         self.__visitor_code: Optional[str] = None
         current_visit = json.get("currentVisit")
         if current_visit is not None:
-            self.__parse_visit(current_visit)
+            self.__parse_visit(current_visit, False)
         previous_visits = json.get("previousVisits")
         if previous_visits:
-            times_started = []
+            prev_visits = []
             for visit in previous_visits:
-                times_started.append(visit.get("timeStarted", 0))
-                self.__parse_visit(visit)
-            self.__previous_visitor_visits = VisitorVisits(times_started)
+                time_started = visit.get("timeStarted", 0)
+                time_last_event = visit.get("timeLastEvent", time_started)
+                prev_visits.append(VisitorVisits.Visit(time_started, time_last_event))
+                self.__parse_visit(visit, True)
+            if len(prev_visits) > 0:
+                self.__visitor_visits = VisitorVisits(prev_visits, self.__visit_number)
         self.__kcs_heat = self.__parse_kcs_heat(json.get("kcs"))
         self.__cbs = self.__parse_cbscores(json.get("cbs"))
 
@@ -63,8 +69,8 @@ class RemoteVisitorData:
         data_to_add: List[BaseData] = []
         if self.__custom_data_dict:
             data_to_add += self.__custom_data_dict.values()
-        if self.__previous_visitor_visits:
-            data_to_add.append(self.__previous_visitor_visits)
+        if self.__visitor_visits:
+            data_to_add.append(self.__visitor_visits)
         if self.__kcs_heat:
             data_to_add.append(self.__kcs_heat)
         if self.__cbs:
@@ -117,7 +123,7 @@ class RemoteVisitorData:
         """Returns the `visitorCode` from the most recent visit"""
         return self.__visitor_code
 
-    def __parse_visit(self, json_visit: Dict[str, Any]) -> None:
+    def __parse_visit(self, json_visit: Dict[str, Any], is_prev_visit: bool) -> None:
         if (self.__visitor_code is None) and isinstance(visitor_code := json_visit.get("visitorCode"), str):
             self.__visitor_code = visitor_code
         custom_data_events = json_visit.get("customDataEvents")
@@ -137,7 +143,7 @@ class RemoteVisitorData:
             self.__parse_geolocation(geolocation_events[-1])
         static_data_event = json_visit.get("staticDataEvent")
         if static_data_event:
-            self.__parse_static_data(static_data_event)
+            self.__parse_static_data(static_data_event, is_prev_visit)
         personalization_events = json_visit.get("personalizationEvents")
         if personalization_events:
             self.__parse_personalizations(personalization_events)
@@ -203,20 +209,24 @@ class RemoteVisitorData:
             if country is not None:
                 self.__geolocation = Geolocation(country, data.get("region"), data.get("city"))
 
-    def __parse_static_data(self, static_data_event: Dict[str, Any]) -> None:
+    def __parse_static_data(self, static_data_event: Dict[str, Any], is_prev_visit: bool) -> None:
         if self.__device and self.__browser and self.__operating_system:
             return
         data = static_data_event.get("data")
         if data is not None:
-            if self.__device is None:
+            if self.__visit_number == 0:
+                self.__visit_number = data.get("visitNumber", 0)
+                if is_prev_visit and (self.__visit_number > 0):
+                    self.__visit_number += 1
+            if self.__filter.device and (self.__device is None):
                 device_type = enum_from_name_literal(data.get("deviceType"), DeviceType, None)
                 if device_type is not None:
                     self.__device = Device(device_type)
-            if self.__browser is None:
+            if self.__filter.browser and (self.__browser is None):
                 browser_type = enum_from_name_literal(data.get("browser"), BrowserType, None)
                 if browser_type is not None:
                     self.__browser = Browser(browser_type, data.get("browserVersion"))
-            if self.__operating_system is None:
+            if self.__filter.operating_system and (self.__operating_system is None):
                 operating_system_type = enum_from_name_literal(data.get("os"), OperatingSystemType, None)
                 if operating_system_type is not None:
                     self.__operating_system = OperatingSystem(operating_system_type)

{kameleoon-client-python-3.12.0 → kameleoon-client-python-3.13.0}/kameleoon/network/net_provider.py

@@ -18,10 +18,14 @@ class HttpMethod(Enum):
 
 class Response:
     """Response"""
-    def __init__(self, error: Optional[Exception], code: Optional[int], content: Optional[Any]):
+    def __init__(
+        self, error: Optional[Exception], code: Optional[int], content: Optional[Any],
+        headers: Optional[Dict[str, str]] = None
+    ) -> None:
         self.error = error
         self.code = code
         self.content = content
+        self.headers = headers or {}
 
     @property
     def success(self) -> bool:
@@ -31,7 +35,7 @@ class Response:
     @property
     def is_expected_status_code(self) -> bool:
         """Checks if the status code is one of the expected codes."""
-        return (self.code is not None) and ((self.code // 100 == 2) or (self.code == 403))
+        return (self.code is not None) and ((self.code // 100 == 2) or (self.code == 403) or (self.code == 304))
 
     def __str__(self):
         return f"HttpResponse{{Code:{self.code},Error:{self.error},Body:'{self.content}'}}"

{kameleoon-client-python-3.12.0 → kameleoon-client-python-3.13.0}/kameleoon/network/net_provider_impl.py

@@ -66,7 +66,7 @@ class NetProviderImpl(NetProvider):
         return headers
 
     @staticmethod
-    async def __form_response(resp, response_content_type: ResponseContentType) -> Response:
+    async def __form_response(resp: aiohttp.ClientResponse, response_content_type: ResponseContentType) -> Response:
         try:
             if response_content_type == ResponseContentType.TEXT:
                 content = await resp.text()
@@ -76,4 +76,5 @@ class NetProviderImpl(NetProvider):
                 content = None
         except aiohttp.ContentTypeError:
             content = None
-        return Response(None, resp.status, content)
+        headers = dict(resp.headers)
+        return Response(None, resp.status, content, headers)

{kameleoon-client-python-3.12.0 → kameleoon-client-python-3.13.0}/kameleoon/network/query_builder.py

@@ -10,53 +10,55 @@ class QueryParams(str, Enum):
     BROWSER_INDEX = "browserIndex"
     BROWSER_VERSION = "browserVersion"
     CBS = "cbs"
+    CITY = "city"
     CLIENT_ID = "client_id"
     CLIENT_SECRET = "client_secret"
+    CONVERSION = "conversion"
+    COUNTRY = "country"
     CURRENT_VISIT = "currentVisit"
     CUSTOM_DATA = "customData"
     DEVICE_TYPE = "deviceType"
     ENVIRONMENT = "environment"
     EVENT_TYPE = "eventType"
+    EXPERIMENT = "experiment"
     EXPERIMENT_ID = "id"
+    GEOLOCATION = "geolocation"
     GOAL_ID = "goalId"
     GRANT_TYPE = "grant_type"
     HREF = "href"
     INDEX = "index"
     KCS = "kcs"
     KEY = "key"
+    LATITUDE = "latitude"
+    LONGITUDE = "longitude"
+    MAPPING_IDENTIFIER = "mappingIdentifier"
+    MAPPING_VALUE = "mappingValue"
     MAX_NUMBER_PREVIOUS_VISITS = "maxNumberPreviousVisits"
     METADATA = "metadata"
     NEGATIVE = "negative"
     NONCE = "nonce"
+    OPERATING_SYSTEM = "os"
+    OPERATING_SYSTEM_INDEX = "osIndex"
     OVERWRITE = "overwrite"
+    PAGE = "page"
     PERSONALIZATION = "personalization"
+    POSTAL_CODE = "postalCode"
     REFERRERS_INDICES = "referrersIndices"
+    REGION = "region"
     REVENUE = "revenue"
     SDK_NAME = "sdkName"
     SDK_VERSION = "sdkVersion"
     SITE_CODE = "siteCode"
+    STATIC_DATA = "staticData"
+    TIME_SINCE_PREVIOUS_VISIT = "timeSincePreviousVisit"
     TITLE = "title"
     TS = "ts"
     USER_AGENT = "userAgent"
     VALUES_COUNT_MAP = "valuesCountMap"
     VARIATION_ID = "variationId"
     VERSION = "version"
+    VISIT_NUMBER = "visitNumber"
     VISITOR_CODE = "visitorCode"
-    COUNTRY = "country"
-    REGION = "region"
-    CITY = "city"
-    POSTAL_CODE = "postalCode"
-    LATITUDE = "latitude"
-    LONGITUDE = "longitude"
-    OPERATING_SYSTEM = "os"
-    GEOLOCATION = "geolocation"
-    OPERATING_SYSTEM_INDEX = "osIndex"
-    MAPPING_IDENTIFIER = "mappingIdentifier"
-    MAPPING_VALUE = "mappingValue"
-    CONVERSION = "conversion"
-    EXPERIMENT = "experiment"
-    PAGE = "page"
-    STATIC_DATA = "staticData"
 
     def __str__(self) -> str:
         return self.value

kameleoon-client-python-3.13.0/kameleoon/network/services/configuration_service.py

@@ -0,0 +1,24 @@
+"""Services"""
+from typing import Any, Dict, Optional
+from kameleoon.network.services.service import Service
+
+
+class FetchedConfiguration:
+    """Represents fetched configuration in json format and its last modification date"""
+
+    def __init__(self, configuration: Optional[Dict[str, Any]], last_modified: Optional[str]) -> None:
+        self.configuration = configuration
+        self.last_modified = last_modified
+
+    def __str__(self) -> str:
+        return f"FetchedConfiguration{{configuration:{self.configuration},last_modified:'{self.last_modified}'}}"
+
+
+class ConfigurationService(Service):
+    """Abstract configuration service"""
+    async def fetch_configuration(
+        self, environment: Optional[str] = None, time_stamp: Optional[int] = None,
+        if_modified_since: Optional[str] = None, timeout: Optional[float] = None
+    ) -> Optional[FetchedConfiguration]:
+        """Asynchronously fetches configuration data from a remote service."""
+        raise NotImplementedError()