rapidata 2.37.0__py3-none-any.whl → 3.0.0a8__py3-none-any.whl

rapidata/rapidata_client/selection/ab_test_selection.py

@@ -1,38 +1,46 @@
-from rapidata.api_client.models.ab_test_selection import (
-    AbTestSelection as AbTestSelectionModel,
-)
-from rapidata.api_client.models.ab_test_selection_a_inner import (
-    AbTestSelectionAInner,
-)
-from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+from __future__ import annotations
+
 from typing import Sequence
 
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+
 
 class AbTestSelection(RapidataSelection):
     """AbTestSelection Class
-    
+
     Splits the userbase into two segments and serves them a different collection of rapids.
 
     Useful for A/B Test.
-    
+
     Args:
         a_selections (Sequence[RapidataSelection]): List of selections for group A.
         b_selections (Sequence[RapidataSelection]): List of selections for group B.
     """
 
-    def __init__(self, a_selections: Sequence[RapidataSelection], b_selections: Sequence[RapidataSelection]):
+    def __init__(
+        self,
+        a_selections: Sequence[RapidataSelection],
+        b_selections: Sequence[RapidataSelection],
+    ):
         self.a_selections = a_selections
         self.b_selections = b_selections
 
     def _to_model(self):
-        return AbTestSelectionModel(
-            _t="AbTestSelection",
-            a=[
-                AbTestSelectionAInner(selection._to_model())
-                for selection in self.a_selections
-            ],
-            b=[
-                AbTestSelectionAInner(selection._to_model())
-                for selection in self.b_selections
-            ],
+        from rapidata.api_client.models.i_selection import ISelection
+        from rapidata.api_client.models.i_selection_ab_test_selection import (
+            ISelectionAbTestSelection,
+        )
+
+        return ISelection(
+            actual_instance=ISelectionAbTestSelection(
+                _t="AbTestSelection",
+                a=[selection._to_model() for selection in self.a_selections],
+                b=[selection._to_model() for selection in self.b_selections],
+            )
         )
+
+    def __str__(self) -> str:
+        return f"AbTestSelection(a_selections={self.a_selections}, b_selections={self.b_selections})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/selection/capped_selection.py

@@ -1,20 +1,17 @@
-from rapidata.api_client.models.capped_selection import (
-    CappedSelection as CappedSelectionModel,
-)
-from rapidata.api_client.models.ab_test_selection_a_inner import (
-    AbTestSelectionAInner,
-)
-from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+from __future__ import annotations
+
 from typing import Sequence
 
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+
 
 class CappedSelection(RapidataSelection):
     """CappedSelection Class
 
     Takes in different selections and caps the amount of rapids that can be shown.
-    
+
     Useful for demographic and conditional validation selections.
-    
+
     Args:
         selections (Sequence[RapidataSelection]): List of selections to cap.
         max_rapids (int): The maximum amount of rapids that can be shown for this selection.
@@ -25,11 +22,21 @@ class CappedSelection(RapidataSelection):
         self.max_rapids = max_rapids
 
     def _to_model(self):
-        return CappedSelectionModel(
-            _t="CappedSelection",
-            selections=[
-                AbTestSelectionAInner(selection._to_model())
-                for selection in self.selections
-            ],
-            maxRapids=self.max_rapids,
+        from rapidata.api_client.models.i_selection import ISelection
+        from rapidata.api_client.models.i_selection_capped_selection import (
+            ISelectionCappedSelection,
+        )
+
+        return ISelection(
+            actual_instance=ISelectionCappedSelection(
+                _t="CappedSelection",
+                selections=[selection._to_model() for selection in self.selections],
+                maxRapids=self.max_rapids,
+            )
         )
+
+    def __str__(self) -> str:
+        return f"CappedSelection(selections={self.selections}, max_rapids={self.max_rapids})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/selection/conditional_validation_selection.py

@@ -1,24 +1,22 @@
-from rapidata.rapidata_client.selection._base_selection import RapidataSelection
-from rapidata.api_client.models.conditional_validation_rapid_selection_config import (
-    ValidationChance,
-)
-from rapidata.api_client.models.conditional_validation_selection import (
-    ConditionalValidationSelection as ConditionalValidationSelectionModel,
-)
+from __future__ import annotations
+
 from typing import Optional
 
+from rapidata.rapidata_client.config.logger import logger
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+
 
 class ConditionalValidationSelection(RapidataSelection):
     """Conditional validation selection class.
 
     Probabilistically decides how many validation rapids you want to show per session based on the user score.
-    
+
     Args:
         validation_set_id (str): The id of the validation set to be used.
         thresholds (list[float]): The thresholds to use for the user score.
         chances (list[float]): The chances of showing a validation rapid for each threshold.
         rapid_counts (list[int]): The amount of validation rapids that will be shown per session of this validation set for each threshold if selected by probability. (all or nothing)
-        dimension (Optional[str], optional): The dimension of the userScore that will be used in the thresholds. Defaults to None.
+        dimensions (Optional[list[str]], optional): The dimensions of the userScore that will be used in the thresholds. Defaults to None.
 
     Example:
         ```python
@@ -29,7 +27,7 @@ class ConditionalValidationSelection(RapidataSelection):
             rapid_counts=[1, 1]
         )
         ```
-        This means that there's a 100% chance of showing a validation rapid if the user score is between 0 and 0.7, 
+        This means that there's a 100% chance of showing a validation rapid if the user score is between 0 and 0.7,
         and a 20% chance of showing a validation rapid if the user score is between 0.7 and 1.
     """
 
@@ -40,29 +38,50 @@ class ConditionalValidationSelection(RapidataSelection):
         chances: list[float],
         rapid_counts: list[int],
         dimension: Optional[str] = None,
+        dimensions: Optional[list[str]] = None,
     ):
         if len(thresholds) != len(chances) or len(thresholds) != len(rapid_counts):
             raise ValueError(
                 "The lengths of thresholds, chances and rapid_counts must be equal."
             )
-        
+
+        if dimension:
+            logger.warning("dimension is deprecated, use dimensions instead")
+            dimensions = (dimensions or []) + [dimension]
+
         self.validation_set_id = validation_set_id
         self.thresholds = thresholds
         self.chances = chances
         self.rapid_counts = rapid_counts
-        self.dimension = dimension
+        self.dimensions = dimensions
 
     def _to_model(self):
-        return ConditionalValidationSelectionModel(
-            _t="ConditionalValidationSelection",
-            validationSetId=self.validation_set_id,
-            validationChances=[
-                ValidationChance(
-                    userScoreThreshold=threshold, chance=chance, rapidCount=rapid_count
-                )
-                for threshold, chance, rapid_count in zip(
-                    self.thresholds, self.chances, self.rapid_counts
-                )
-            ],
-            dimension=self.dimension,
+        from rapidata.api_client.models.i_selection import ISelection
+        from rapidata.api_client.models.i_selection_conditional_validation_selection import (
+            ISelectionConditionalValidationSelection,
         )
+        from rapidata.api_client.models.conditional_validation_selection_validation_chance import (
+            ConditionalValidationSelectionValidationChance,
+        )
+
+        return ISelection(
+            actual_instance=ISelectionConditionalValidationSelection(
+                _t="ConditionalValidationSelection",
+                validationSetId=self.validation_set_id,
+                validationChances=[
+                    ConditionalValidationSelectionValidationChance(
+                        userScoreThreshold=threshold, chance=chance, rapidCount=rapid_count
+                    )
+                    for threshold, chance, rapid_count in zip(
+                        self.thresholds, self.chances, self.rapid_counts
+                    )
+                ],
+                dimensions=self.dimensions,
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"ConditionalValidationSelection(validation_set_id={self.validation_set_id}, thresholds={self.thresholds}, chances={self.chances}, rapid_counts={self.rapid_counts}, dimensions={self.dimensions})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/selection/demographic_selection.py

@@ -1,11 +1,12 @@
+from __future__ import annotations
+
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
-from rapidata.api_client.models.demographic_selection import DemographicSelection as DemographicSelectionModel
 
 
 class DemographicSelection(RapidataSelection):
     """Demographic selection class.
-    
-    This is used to ask demographic questions in an order.    
+
+    This is used to ask demographic questions in an order.
 
     The keys will select the rapids based on the confidence we already saved for each user.
 
@@ -15,7 +16,7 @@ class DemographicSelection(RapidataSelection):
         keys (list[str]): List of keys for the demographic rapids to be shown. As an example: "age"
         max_rapids (int): The maximum number of rapids to run.\n
             Allows to provide more keys, in case some of the earlier ones are not selected because of high confidence.
-                 
+
     Example:
         ```python
         DemographicSelection(["age", "gender"], 1)
@@ -23,11 +24,25 @@ class DemographicSelection(RapidataSelection):
         This will try to ask the user about their age, if that is not selected due to an already high confidence, it will try asking about their gender.
         The gender question may also be skipped if the confidence is high enough.
     """
-    
 
     def __init__(self, keys: list[str], max_rapids: int):
         self.keys = keys
         self.max_rapids = max_rapids
 
     def _to_model(self):
-        return DemographicSelectionModel(_t="DemographicSelection", keys=self.keys, maxRapids=self.max_rapids)
+        from rapidata.api_client.models.i_selection import ISelection
+        from rapidata.api_client.models.i_selection_demographic_selection import (
+            ISelectionDemographicSelection,
+        )
+
+        return ISelection(
+            actual_instance=ISelectionDemographicSelection(
+                _t="DemographicSelection", keys=self.keys, maxRapids=self.max_rapids
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"DemographicSelection(keys={self.keys}, max_rapids={self.max_rapids})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/selection/effort_selection.py

@@ -1,7 +1,6 @@
+from __future__ import annotations
+
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
-from rapidata.api_client.models.effort_capped_selection import (
-    EffortCappedSelection as EffortCappedSelectionModel,
-)
 from rapidata.rapidata_client.selection.rapidata_retrieval_modes import (
     RapidataRetrievalMode,
 )
@@ -29,9 +28,22 @@ class EffortSelection(RapidataSelection):
         self.max_iterations = max_iterations
 
     def _to_model(self):
-        return EffortCappedSelectionModel(
-            _t="EffortCappedSelection",
-            effortBudget=self.effort_budget,
-            retrievalMode=self.retrieval_mode.value,
-            maxIterations=self.max_iterations,
+        from rapidata.api_client.models.i_selection import ISelection
+        from rapidata.api_client.models.i_selection_effort_capped_selection import (
+            ISelectionEffortCappedSelection,
+        )
+
+        return ISelection(
+            actual_instance=ISelectionEffortCappedSelection(
+                _t="EffortCappedSelection",
+                effortBudget=self.effort_budget,
+                retrievalMode=self.retrieval_mode.value,
+                maxIterations=self.max_iterations,
+            )
         )
+
+    def __str__(self) -> str:
+        return f"EffortSelection(effort_budget={self.effort_budget}, retrieval_mode={self.retrieval_mode}, max_iterations={self.max_iterations})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/selection/labeling_selection.py

@@ -1,11 +1,9 @@
-from typing import Any
+from __future__ import annotations
+
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 from rapidata.rapidata_client.selection.rapidata_retrieval_modes import (
     RapidataRetrievalMode,
 )
-from rapidata.api_client.models.labeling_selection import (
-    LabelingSelection as LabelingSelectionModel,
-)
 
 
 class LabelingSelection(RapidataSelection):
@@ -31,10 +29,23 @@ class LabelingSelection(RapidataSelection):
         self.retrieval_mode = retrieval_mode
         self.max_iterations = max_iterations
 
-    def _to_model(self) -> Any:
-        return LabelingSelectionModel(
-            _t="LabelingSelection",
-            amount=self.amount,
-            retrievalMode=self.retrieval_mode.value,
-            maxIterations=self.max_iterations,
+    def _to_model(self):
+        from rapidata.api_client.models.i_selection import ISelection
+        from rapidata.api_client.models.i_selection_labeling_selection import (
+            ISelectionLabelingSelection,
+        )
+
+        return ISelection(
+            actual_instance=ISelectionLabelingSelection(
+                _t="LabelingSelection",
+                amount=self.amount,
+                retrievalMode=self.retrieval_mode.value,
+                maxIterations=self.max_iterations,
+            )
         )
+
+    def __str__(self) -> str:
+        return f"LabelingSelection(amount={self.amount}, retrieval_mode={self.retrieval_mode}, max_iterations={self.max_iterations})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/selection/rapidata_selections.py

@@ -1,15 +1,17 @@
 from rapidata.rapidata_client.selection import (
-    DemographicSelection, 
-    LabelingSelection, 
-    ValidationSelection, 
-    ConditionalValidationSelection, 
+    DemographicSelection,
+    LabelingSelection,
+    ValidationSelection,
+    ConditionalValidationSelection,
     CappedSelection,
-    ShufflingSelection)
+    ShufflingSelection,
+)
+
 
 class RapidataSelections:
     """RapidataSelections Classes
 
-    Selections are used to define what type of tasks and in what order they are shown to the user. 
+    Selections are used to define what type of tasks and in what order they are shown to the user.
     All selections combined are called a "Session". A session can contain multiple tasks of different types of tasks.
     As an example, a session might be 1 validation task, 2 labeling tasks.
 
@@ -20,19 +22,26 @@ class RapidataSelections:
         demographic (DemographicSelection): Decides if and how many demographic questions you want to show per session.
         capped (CappedSelection): Takes in different selections and caps the amount of rapids that can be shown.
         shuffling (ShufflingSelection): Shuffles the selections provided in the list.
-    
+
     Example:
         ```python
         from rapidata import LabelingSelection, ValidationSelection
-        selections=[ValidationSelection("your-validation-set-id", 1), 
+        selections=[ValidationSelection("your-validation-set-id", 1),
                     LabelingSelection(2)]
         ```
 
         This will require annotators to complete one validation task followed by two labeling tasks.
     """
-    labeling = LabelingSelection
-    validation = ValidationSelection
-    conditional_validation = ConditionalValidationSelection
-    demographic = DemographicSelection
-    capped = CappedSelection
-    shuffling = ShufflingSelection
+
+    Labeling = LabelingSelection
+    Validation = ValidationSelection
+    Conditional_validation = ConditionalValidationSelection
+    Demographic = DemographicSelection
+    Capped = CappedSelection
+    Shuffling = ShufflingSelection
+
+    def __str__(self) -> str:
+        return f"RapidataSelections(Labeling={self.Labeling}, Validation={self.Validation}, Conditional_validation={self.Conditional_validation}, Demographic={self.Demographic}, Capped={self.Capped}, Shuffling={self.Shuffling})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/selection/shuffling_selection.py

@@ -1,16 +1,15 @@
-
-from rapidata.api_client.models.ab_test_selection_a_inner import AbTestSelectionAInner
-from rapidata.api_client.models.shuffling_selection import ShufflingSelection as ShufflingSelectionModel
-from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+from __future__ import annotations
 
 from typing import Sequence
 
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+
 
 class ShufflingSelection(RapidataSelection):
     """ShufflingSelection Class
 
     Shuffles the selections provided in the list.
-    
+
     Args:
         selections (Sequence[RapidataSelection]): List of selections to shuffle.
 
@@ -25,12 +24,21 @@ class ShufflingSelection(RapidataSelection):
     def __init__(self, selections: Sequence[RapidataSelection]):
         self.selections = selections
 
-    def _to_model(self) -> ShufflingSelectionModel:
-        return ShufflingSelectionModel(
-            _t="ShufflingSelection",
-            selections=[
-                AbTestSelectionAInner(selection._to_model())
-                for selection in self.selections
-            ]
+    def _to_model(self):
+        from rapidata.api_client.models.i_selection import ISelection
+        from rapidata.api_client.models.i_selection_shuffling_selection import (
+            ISelectionShufflingSelection,
         )
-    
+
+        return ISelection(
+            actual_instance=ISelectionShufflingSelection(
+                _t="ShufflingSelection",
+                selections=[selection._to_model() for selection in self.selections],
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"ShufflingSelection(selections={self.selections})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/selection/static_selection.py

@@ -1,12 +1,11 @@
-
-from rapidata.api_client.models.static_selection import StaticSelection as StaticSelectionModel
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 
+
 class StaticSelection(RapidataSelection):
     """StaticSelection Class
 
     Given a list of RapidIds, theses specific rapids will be shown in order for every session.
-    
+
     Args:
         rapid_ids (list[str]): List of rapid ids to show.
     """
@@ -14,9 +13,21 @@ class StaticSelection(RapidataSelection):
     def __init__(self, rapid_ids: list[str]):
         self.rapid_ids = rapid_ids
 
-    def _to_model(self) -> StaticSelectionModel:
-        return StaticSelectionModel(
-            _t="StaticSelection",
-            rapidIds=self.rapid_ids
+    def _to_model(self):
+        from rapidata.api_client.models.i_selection import ISelection
+        from rapidata.api_client.models.i_selection_static_selection import (
+            ISelectionStaticSelection,
         )
-    
+
+        return ISelection(
+            actual_instance=ISelectionStaticSelection(
+                _t="StaticSelection",
+                rapidIds=self.rapid_ids,
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"StaticSelection(rapid_ids={self.rapid_ids})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/selection/validation_selection.py

@@ -1,5 +1,5 @@
+from __future__ import annotations
 
-from rapidata.api_client.models.validation_selection import ValidationSelection as ValidationSelectionModel
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 
 
@@ -7,7 +7,7 @@ class ValidationSelection(RapidataSelection):
     """Validation selection class.
 
     Decides how many validation rapids you want to show per session.
-    
+
     Args:
         validation_set_id (str): The id of the validation set to be used.
         amount (int): The amount of validation rapids that will be shown per session of this validation set.
@@ -18,5 +18,21 @@ class ValidationSelection(RapidataSelection):
         self.amount = amount
 
     def _to_model(self):
-        return ValidationSelectionModel(_t="ValidationSelection", validationSetId=self.validation_set_id, amount=self.amount)
-    
+        from rapidata.api_client.models.i_selection import ISelection
+        from rapidata.api_client.models.i_selection_validation_selection import (
+            ISelectionValidationSelection,
+        )
+
+        return ISelection(
+            actual_instance=ISelectionValidationSelection(
+                _t="ValidationSelection",
+                validationSetId=self.validation_set_id,
+                amount=self.amount,
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"ValidationSelection(validation_set_id={self.validation_set_id}, amount={self.amount})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/settings/__init__.py

@@ -7,4 +7,6 @@ from .play_video_until_the_end import PlayVideoUntilTheEnd
 from .custom_setting import CustomSetting
 from ._rapidata_setting import RapidataSetting
 from .allow_neither_both import AllowNeitherBoth
+from .swap_context_instruction import SwapContextInstruction
+from .mute_video import MuteVideo
 from .rapidata_settings import RapidataSettings

rapidata/rapidata_client/settings/_rapidata_setting.py

@@ -1,11 +1,30 @@
+from __future__ import annotations
 from pydantic import BaseModel
-from typing import Any
-from rapidata.api_client.models.feature_flag_model import FeatureFlagModel
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from rapidata.api_client.models.feature_flag import FeatureFlag
+    from rapidata.api_client.models.feature_flag_model import FeatureFlagModel
+
 
 class RapidataSetting(BaseModel):
     """Base class for all settings"""
+
     key: str
     value: Any
 
-    def _to_feature_flag(self) -> FeatureFlagModel:
+    def _to_feature_flag(self) -> FeatureFlag:
+        from rapidata.api_client.models.feature_flag import FeatureFlag
+
+        return FeatureFlag(key=self.key, value=str(self.value))
+
+    def _to_feature_flag_model(self) -> FeatureFlagModel:
+        from rapidata.api_client.models.feature_flag_model import FeatureFlagModel
+
         return FeatureFlagModel(key=self.key, value=str(self.value))
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}(key='{self.key}', value={self.value})"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(key={self.key!r}, value={self.value!r})"

rapidata/rapidata_client/settings/alert_on_fast_response.py

@@ -1,22 +1,25 @@
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
-from rapidata.rapidata_client.logging import managed_print
+from rapidata.rapidata_client.config import managed_print
+
 
 class AlertOnFastResponse(RapidataSetting):
     """
     Gives an alert as a pop up on the UI when the response time is less than the milliseconds.
-    
+
     Args:
         threshold (int): if the user responds in less than this time, an alert will be shown.
     """
-    
+
     def __init__(self, threshold: int):
         if not isinstance(threshold, int):
             raise ValueError("The alert must be an integer.")
         if threshold < 10:
-            managed_print(f"Warning: Are you sure you want to set the threshold so low ({threshold} milliseconds)?")
+            managed_print(
+                f"Warning: Are you sure you want to set the threshold so low ({threshold} milliseconds)?"
+            )
         if threshold > 25000:
             raise ValueError("The alert must be less than 25000 milliseconds.")
         if threshold < 0:
             raise ValueError("The alert must be greater than or equal to 0.")
-    
+
         super().__init__(key="alert_on_fast_response", value=threshold)

rapidata/rapidata_client/settings/allow_neither_both.py

@@ -1,5 +1,6 @@
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
 
+
 class AllowNeitherBoth(RapidataSetting):
     """
     Set whether to allow neither or both options.
@@ -11,4 +12,6 @@ class AllowNeitherBoth(RapidataSetting):
     """
 
     def __init__(self, value: bool = True):
+        if not isinstance(value, bool):
+            raise ValueError("The value must be a boolean.")
         super().__init__(key="compare_unsure", value=value)

rapidata/rapidata_client/settings/custom_setting.py

@@ -1,9 +1,10 @@
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
 
+
 class CustomSetting(RapidataSetting):
     """
     Set a custom setting with the given key and value. Use this to enable features that do not have a dedicated method (yet)
-    
+
     Args:
         key (str): The key for the custom setting.
         value (str): The value for the custom setting.
@@ -12,5 +13,5 @@ class CustomSetting(RapidataSetting):
     def __init__(self, key: str, value: str):
         if not isinstance(key, str):
             raise ValueError("The key must be a string.")
-        
+
         super().__init__(key=key, value=value)