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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kameleoon-client-python
-Version: 3.3.2
+Version: 3.4.0
 Summary: Kameleoon Client Python Software Development Kit.
 Home-page: https://developers.kameleoon.com/python-sdk.html
 Author: Kameleoon
@@ -70,7 +70,7 @@ kameleoon_client = KameleoonClientFactory.create(SITE_CODE, config_path='/etc/ka
 
 # Option 2
 configuration_object = KameleoonClientConfig.read_from_yaml('/etc/kameleoon/client-python.yaml')
-configuration_object.set_logger(my_logger)
+configuration_object.set_logger(my_logger) # (is deprecated) use `KameleoonLogger.set_logger` method instead.
 kameleoon_client = KameleoonClientFactory.create(SITE_CODE, configuration_object)
 
 # Option 3
@@ -83,7 +83,7 @@ configuration_object = KameleoonClientConfig(
     environment="production",  # optional, possible values: "production" / "staging" / "development" / "staging", default: None
     top_level_domain="example.com",
     multi_threading=False,  # optional, default: False
-    logger=my_logger,  # optional, default: standard kameleoon logger
+    logger=my_logger,  # optional, default: standard kameleoon logger (is deprecated) use `KameleoonLogger.set_logger` method instead.
 )
 kameleoon_client = KameleoonClientFactory.create(SITE_CODE, configuration_object)
 ```

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/README.md

@@ -49,7 +49,7 @@ kameleoon_client = KameleoonClientFactory.create(SITE_CODE, config_path='/etc/ka
 
 # Option 2
 configuration_object = KameleoonClientConfig.read_from_yaml('/etc/kameleoon/client-python.yaml')
-configuration_object.set_logger(my_logger)
+configuration_object.set_logger(my_logger) # (is deprecated) use `KameleoonLogger.set_logger` method instead.
 kameleoon_client = KameleoonClientFactory.create(SITE_CODE, configuration_object)
 
 # Option 3
@@ -62,7 +62,7 @@ configuration_object = KameleoonClientConfig(
     environment="production",  # optional, possible values: "production" / "staging" / "development" / "staging", default: None
     top_level_domain="example.com",
     multi_threading=False,  # optional, default: False
-    logger=my_logger,  # optional, default: standard kameleoon logger
+    logger=my_logger,  # optional, default: standard kameleoon logger (is deprecated) use `KameleoonLogger.set_logger` method instead.
 )
 kameleoon_client = KameleoonClientFactory.create(SITE_CODE, configuration_object)
 ```

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

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

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

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

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

@@ -0,0 +1,44 @@
+"""ThreadingClientReadiness"""
+from threading import Lock
+
+
+class ThreadingClientReadiness:
+    """A class to manage and track the readiness of a component using threading."""
+
+    def __init__(self) -> None:
+        """Initializes the ThreadingClientReadiness object."""
+        self._is_initializing = False
+        self._success = False
+        self._condition = Lock()
+        self.reset()
+
+    @property
+    def is_initializing(self) -> bool:
+        """Returns whether the component is currently initializing."""
+        return self._is_initializing
+
+    @property
+    def success(self) -> bool:
+        """Returns whether the initialization was successful."""
+        return self._success
+
+    def reset(self) -> None:
+        """Resets the readiness state to initializing."""
+        self._success = False
+        if not self._is_initializing:
+            self._is_initializing = True
+            self._condition.acquire()  # pylint: disable=R1732
+
+    def set(self, success: bool) -> None:
+        """Sets the readiness state to initialized with a success status."""
+        self._success = success
+        if self._is_initializing:
+            self._condition.release()
+            self._is_initializing = False
+
+    def wait(self) -> bool:
+        """Waits for the initialization to complete and returns the success status."""
+        if self._is_initializing:
+            with self._condition:
+                pass
+        return self._success

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/configuration/custom_data_info.py

@@ -1,8 +1,9 @@
 """Custom data info"""
 
-from logging import Logger
 from typing import Optional, Dict, Union, Any, List
 
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
+
 
 class CustomDataInfo:
     """Custom data info"""
@@ -10,7 +11,7 @@ class CustomDataInfo:
     SCOPE_VISITOR = "VISITOR"
 
     def __init__(
-        self, custom_data: Optional[List[Dict[str, Union[str, int, Any]]]], logger: Optional[Logger] = None
+        self, custom_data: Optional[List[Dict[str, Union[str, int, Any]]]]
     ) -> None:
         super().__init__()
         self.__mapping_identifier_index = None
@@ -26,8 +27,8 @@ class CustomDataInfo:
                     if data.get("scope") == self.SCOPE_VISITOR:
                         self.__visitor_scope.add(index)
                     if data.get("isMappingIdentifier"):
-                        if bool(self.__mapping_identifier_index is not None) and logger is not None:
-                            logger.info(
+                        if bool(self.__mapping_identifier_index is not None):
+                            KameleoonLogger.warning(
                                 "More than one mapping identifier is set. Undefined behavior may occur" +
                                 " on cross-device reconciliation."
                             )

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/configuration/data_file.py

@@ -1,5 +1,5 @@
 """Kameleoon Configuration"""
-from logging import Logger
+
 from typing import Any, Dict, Optional
 from kameleoon.configuration.custom_data_info import CustomDataInfo
 from kameleoon.configuration.variation_by_exposition import VariationByExposition
@@ -7,6 +7,7 @@ from kameleoon.configuration.feature_flag import FeatureFlag
 from kameleoon.configuration.rule import Rule
 from kameleoon.configuration.settings import Settings
 from kameleoon.exceptions import FeatureNotFound, FeatureEnvironmentDisabled
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
 
 
 class DataFile:
@@ -15,11 +16,12 @@ class DataFile:
     @staticmethod
     def default(environment: Optional[str]) -> "DataFile":
         """Creates new instance of `DataFile` initialized with default values"""
-        return DataFile(environment, Settings(), {}, CustomDataInfo(None))
+        data_file = DataFile(environment, Settings(), {}, CustomDataInfo(None))
+        return data_file
 
     @staticmethod
     def from_json(
-        environment: Optional[str], configuration: Dict[str, Any], logger: Optional[Logger] = None
+        environment: Optional[str], configuration: Dict[str, Any]
     ) -> "DataFile":
         """Creates new instance of `DataFile` initialized from the specified configuration JSON"""
         settings = Settings(configuration.get("configuration"))
@@ -27,8 +29,9 @@ class DataFile:
             (feature_flag := FeatureFlag(jobj)).feature_key: feature_flag
             for jobj in configuration.get("featureFlags") or []
         }
-        custom_data_info = CustomDataInfo(configuration.get("customData"), logger=logger)
-        return DataFile(environment, settings, feature_flags, custom_data_info)
+        custom_data_info = CustomDataInfo(configuration.get("customData"))
+        data_file = DataFile(environment, settings, feature_flags, custom_data_info)
+        return data_file
 
     # pylint: disable=R0913
     def __init__(
@@ -38,6 +41,9 @@ class DataFile:
         feature_flags: Dict[str, FeatureFlag],
         custom_data_info: CustomDataInfo,
     ) -> None:
+        KameleoonLogger.debug(
+            'CALL: DataFile(environment: %s, settings: %s, feature_flags: %s, custom_data_info: %s)',
+            environment, settings, feature_flags, custom_data_info)
         self.__environment = environment  # pylint: disable=W0238
         self.__settings = settings
         self.__feature_flags: Dict[str, FeatureFlag] = feature_flags
@@ -52,6 +58,9 @@ class DataFile:
         self.__feature_flag_by_id: Dict[int, FeatureFlag] = {}
         self.__collect_indices()
         self.__custom_data_info = custom_data_info
+        KameleoonLogger.debug(
+            'RETURN: DataFile.new(environment: %s, settings: %s, feature_flags: %s, custom_data_info: %s)',
+            environment, settings, feature_flags, custom_data_info)
 
     @property
     def settings(self) -> Settings:
@@ -109,3 +118,12 @@ class DataFile:
                     for variation in rule.variation_by_exposition:
                         if variation.variation_id is not None:
                             self.__variation_by_id[variation.variation_id] = variation
+
+    def __str__(self):
+        return (
+            f"DataFile{{"
+            f"environment:'{self.__environment}',"
+            f"feature_flags:{len(self.__feature_flags)},"
+            f"settings:{self.__settings}"
+            f"}}"
+        )

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/configuration/feature_flag.py

@@ -4,6 +4,7 @@ from typing import Any, List, Dict, Optional
 
 from kameleoon.configuration.rule import Rule
 from kameleoon.configuration.variation import Variation
+from kameleoon.helpers.string_utils import StringUtils
 
 
 class FeatureFlag:
@@ -29,3 +30,15 @@ class FeatureFlag:
     def get_variation(self, key: str) -> Optional[Variation]:
         """Retrun a variation for the given key"""
         return next((v for v in self.variations if v.key == key), None)
+
+    def __str__(self):
+        return (
+            f"FeatureFlag{{"
+            f"id:{self.id_},"
+            f"feature_key:'{self.feature_key}',"
+            f"environment_enabled:{self.environment_enabled},"
+            f"variations:{StringUtils.object_to_string(self.variations)},"
+            f"default_variation_key:'{self.default_variation_key}',"
+            f"rules:{len(self.rules)}"
+            f"}}"
+        )

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/configuration/rule.py

@@ -54,3 +54,6 @@ class Rule:
         """Return `true` if rule is `targeted delivery` type"""
 
         return self.type == RuleType.TARGETED_DELIVERY
+
+    def __str__(self):
+        return f"Rule{{id:{self.id_}}}"

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/configuration/settings.py

@@ -33,3 +33,10 @@ class Settings:
     def data_api_domain(self) -> Any:
         """Returns Data API domain to be switched to"""
         return self.__data_api_domain
+
+    def __str__(self):
+        return (
+            f"Settings{{real_time_update:{self.__real_time_update},"
+            f"is_consent_required:{self.__is_consent_required},"
+            f"data_api_domain:'{self.__data_api_domain}'}}"
+        )

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/configuration/variable.py

@@ -4,6 +4,8 @@ from enum import Enum
 import json
 from typing import Any, List, Dict, Union
 
+from kameleoon.helpers.string_utils import StringUtils
+
 
 class Variable:
     """
@@ -43,3 +45,8 @@ class Variable:
     def get_type(self) -> str:
         """Returns type value of variable"""
         return self.__type
+
+    def __str__(self):
+        return (f"Variable{{key:'{self.key},"
+                f"type:'{self.__type}',"
+                f"value:{StringUtils.object_to_string(self.__value)}}}")

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/configuration/variation.py

@@ -4,6 +4,7 @@ from enum import Enum
 from typing import Any, List, Dict, Optional
 
 from kameleoon.configuration.variable import Variable
+from kameleoon.helpers.string_utils import StringUtils
 
 
 class Variation:
@@ -29,3 +30,7 @@ class Variation:
     def get_variable_by_key(self, key: str) -> Optional[Variable]:
         """Retrun a variable for the given key"""
         return next((v for v in self.variables if v.key == key), None)
+
+    def __str__(self):
+        return (f"Variation{{key:'{self.key}',"
+                f"variables:{StringUtils.object_to_string(self.variables)}}}")

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/configuration/variation_by_exposition.py

@@ -17,3 +17,10 @@ class VariationByExposition:
         self.variation_key: str = dict_json.get("variationKey", "")
         self.variation_id: Optional[int] = dict_json.get("variationId")
         self.exposition: float = dict_json.get("exposition", 0.0)
+
+    def __str__(self):
+        return (
+            f"VariationByExposition{{exposition:{self.exposition},"
+            f"variation_key:'{self.variation_key}',"
+            f"variation_id:{self.variation_id}}}"
+        )

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

@@ -1,29 +1,31 @@
 """ Imports all kameleoon data objects """
 
-from .custom_data import CustomData
 from .browser import Browser, BrowserType
 from .conversion import Conversion
-from .device import Device, DeviceType
-from .page_view import PageView
-from .user_agent import UserAgent
-from .data import Data, DataType
 from .cookie import Cookie
+from .custom_data import CustomData
+from .data import Data, DataType
+from .device import Device, DeviceType
 from .geolocation import Geolocation
 from .operating_system import OperatingSystem, OperatingSystemType
+from .page_view import PageView
+from .user_agent import UserAgent
+from .unique_identifier import UniqueIdentifier
 
 __all__ = [
-    "CustomData",
     "Browser",
     "BrowserType",
     "Conversion",
-    "Device",
-    "DeviceType",
-    "PageView",
-    "UserAgent",
+    "Cookie",
+    "CustomData",
     "Data",
     "DataType",
-    "Cookie",
+    "Device",
+    "DeviceType",
     "Geolocation",
-    "OperatingSystemType",
     "OperatingSystem",
+    "OperatingSystemType",
+    "PageView",
+    "UserAgent",
+    "UniqueIdentifier",
 ]

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/data/browser.py

@@ -51,10 +51,16 @@ class Browser(Data, DuplicationUnsafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.BROWSER
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
-        qb.extend(
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        query_builder.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
             QueryParam(QueryParams.BROWSER_INDEX, str(self.browser_type.value)),
         )
         if self.version:
-            qb.append(QueryParam(QueryParams.BROWSER_VERSION, str(self.version)))
+            query_builder.append(QueryParam(QueryParams.BROWSER_VERSION, str(self.version)))
+
+    def __str__(self):
+        return (
+            f"Browser{{browser_type:{self.__browser_type},"
+            f"version:{self.__version}}}"
+        )

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/data/conversion.py

@@ -51,12 +51,19 @@ class Conversion(Data, DuplicationSafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.CONVERSION
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
         # remove query_builder, it's done due due pylint issue with R0801 - duplicate_code,
         # need to update pylint and return str(QueryBuilder) straightaway
-        qb.extend(
+        query_builder.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
             QueryParam(QueryParams.GOAL_ID, str(self.goal_id)),
             QueryParam(QueryParams.REVENUE, str(self.revenue)),
             QueryParam(QueryParams.NEGATIVE, "true" if self.negative else "false"),
         )
+
+    def __str__(self):
+        return (
+            f"Conversion{{goal_id:{self.__goal_id},"
+            f"revenue:{self.__revenue},"
+            f"negative:{self.__negative}}}"
+        )

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/data/cookie.py

@@ -30,3 +30,6 @@ class Cookie(Data):
     @property
     def data_type(self) -> DataType:
         return DataType.COOKIE
+
+    def __str__(self):
+        return f"Cookie{{cookies:{self.__cookies}}}"

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/data/custom_data.py

@@ -30,7 +30,6 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
         # pylint: disable=W0511
         self.__id = id
         self.__values = args
-        self.is_mapping_identifier: bool = False
 
     @property
     def id(self) -> int:  # pylint: disable=C0103
@@ -49,13 +48,17 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
     def encode_query(self) -> str:
         return super().encode_query() if len(self.__values) > 0 else ""
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
         str_values = json.dumps({v: 1 for v in self.__values}, separators=(",", ":"))
-        qb.extend(
-            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
-            QueryParam(QueryParams.INDEX, str(self.id)),
+        query_builder.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE, False),
+            QueryParam(QueryParams.INDEX, str(self.id), False),
             QueryParam(QueryParams.VALUES_COUNT_MAP, str_values),
-            QueryParam(QueryParams.OVERWRITE, "true"),
+            QueryParam(QueryParams.OVERWRITE, "true", False),
+        )
+
+    def __str__(self):
+        return (
+            f"CustomData{{id:{self.__id},"
+            f"values:{self.__values}}}"
         )
-        if self.is_mapping_identifier:
-            qb.append(QueryParam(QueryParams.MAPPING_IDENTIFIER, "true"))

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/data/data.py

@@ -19,6 +19,7 @@ class DataType(IntEnum):
     PAGE_VIEW_VISIT = 10
     VISITOR_VISITS = 11
     KCS_HEAT = 12
+    UNIQUE_IDENTIFIER = 13
 
 
 class BaseData:
@@ -31,7 +32,7 @@ class BaseData:
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert class instance to dict"""
-        return self.__dict__
+        return {k: str(v) for k, v in self.__dict__.items()}
 
 
 class Data(BaseData):  # pylint: disable=W0223

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/data/device.py

@@ -40,8 +40,11 @@ class Device(Data, DuplicationUnsafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.DEVICE
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
-        qb.extend(
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        query_builder.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
             QueryParam(QueryParams.DEVICE_TYPE, self.device_type.value),
         )
+
+    def __str__(self):
+        return f"Device{{device_type:{self.__device_type}}}"

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/data/geolocation.py

@@ -82,19 +82,29 @@ class Geolocation(Data, DuplicationUnsafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.GEOLOCATION
 
-    def _add_query_params(self, qb: QueryBuilder) -> None:
-        qb.extend(
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        query_builder.extend(
             QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
         )
         if self.country:
-            qb.append(QueryParam(QueryParams.COUNTRY, self.country))
+            query_builder.append(QueryParam(QueryParams.COUNTRY, self.country))
         if self.region:
-            qb.append(QueryParam(QueryParams.REGION, self.region))
+            query_builder.append(QueryParam(QueryParams.REGION, self.region))
         if self.city:
-            qb.append(QueryParam(QueryParams.CITY, self.city))
+            query_builder.append(QueryParam(QueryParams.CITY, self.city))
         if self.postal_code:
-            qb.append(QueryParam(QueryParams.POSTAL_CODE, self.postal_code))
+            query_builder.append(QueryParam(QueryParams.POSTAL_CODE, self.postal_code))
         if self.latitude is not None:
-            qb.append(QueryParam(QueryParams.LATITUDE, str(self.latitude)))
+            query_builder.append(QueryParam(QueryParams.LATITUDE, str(self.latitude)))
         if self.longitude is not None:
-            qb.append(QueryParam(QueryParams.LONGITUDE, str(self.longitude)))
+            query_builder.append(QueryParam(QueryParams.LONGITUDE, str(self.longitude)))
+
+    def __str__(self):
+        return (
+            f"Geolocation{{country:'{self.country}',"
+            f"region:'{self.region}',"
+            f"city:'{self.city}',"
+            f"postal_code:'{self.postal_code}',"
+            f"latitude:{self.latitude},"
+            f"longitude:{self.longitude}}}"
+        )

{kameleoon-client-python-3.3.2 → kameleoon-client-python-3.4.0}/kameleoon/data/kcs_heat.py

@@ -20,3 +20,6 @@ class KcsHeat(BaseData):
     @property
     def data_type(self) -> DataType:
         return DataType.KCS_HEAT
+
+    def __str__(self):
+        return f"KcsHeat{{values:{self.__values}}}"

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

@@ -0,0 +1,71 @@
+"""Assigned Variation"""
+import time
+from typing import Optional
+from kameleoon.configuration.rule_type import RuleType
+from kameleoon.data.data import BaseData, DataType
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
+from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
+
+
+class AssignedVariation(BaseData, DuplicationUnsafeSendableBase):
+    """Assigned variation"""
+    EVENT_TYPE = "experiment"
+
+    def __init__(
+        self,
+        experiment_id: int,
+        variation_id: int,
+        rule_type: RuleType = RuleType.UNKNOWN,
+        assignment_time: Optional[float] = None,
+    ) -> None:
+        super().__init__()
+        self.__experiment_id = experiment_id
+        self.__variation_id = variation_id
+        self.__rule_type = rule_type
+        self.__assignment_time = assignment_time or time.time()
+
+    @property
+    def experiment_id(self) -> int:
+        """Returns the experiment ID."""
+        return self.__experiment_id
+
+    @property
+    def variation_id(self) -> int:
+        """Returns the variation ID."""
+        return self.__variation_id
+
+    @property
+    def rule_type(self) -> RuleType:
+        """Returns the rule type associated with the variation."""
+        return self.__rule_type
+
+    @property
+    def assignment_time(self) -> float:
+        """Returns the time when the assignment occurred."""
+        return self.__assignment_time
+
+    @property
+    def data_type(self) -> DataType:
+        """Returns the data type for the assigned variation."""
+        return DataType.ASSIGNED_VARIATION
+
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        # fmt: off
+        query_builder.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
+            QueryParam(QueryParams.EXPERIMENT_ID, str(self.__experiment_id)),
+            QueryParam(QueryParams.VARIATION_ID, str(self.__variation_id)),
+        )
+        # fmt: on
+
+    def is_valid(self, respool_time: Optional[int]) -> bool:
+        """Checks if the assigned variation is valid based on the respool time."""
+        return (respool_time is None) or (self.assignment_time >= respool_time)
+
+    def __str__(self):
+        return (
+            f"AssignedVariation{{experiment_id:{self.__experiment_id},"
+            f"variation_id:{self.__variation_id},"
+            f"assignment_time:{self.__assignment_time},"
+            f"rule_type:{self.__rule_type}}}"
+        )