rapidata 2.28.2__py3-none-any.whl → 2.44.3__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,19 +1,49 @@
+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.retrieval_modes import RetrievalMode
+from rapidata.rapidata_client.selection.rapidata_retrieval_modes import (
+    RapidataRetrievalMode,
+)
+
 
+class EffortSelection(RapidataSelection):
+    """
+    With this selection you can define the effort budget you have for a task.
+    As an example, you have a task that takes 10 seconds to complete. The effort budget would be 10.
 
-class EffortEstimationSelection(RapidataSelection):
-    
+    Args:
+        effort_budget (int): The effort budget for the task.
+        retrieval_mode (RetrievalMode): The retrieval mode for the task.
+        max_iterations (int | None): The maximum number of iterations for the task.
+    """
 
-    def __init__(self, effort_budget: int, retrieval_mode: RetrievalMode = RetrievalMode.Shuffled, max_iterations: int | None = None):
+    def __init__(
+        self,
+        effort_budget: int,
+        retrieval_mode: RapidataRetrievalMode = RapidataRetrievalMode.Shuffled,
+        max_iterations: int | None = None,
+    ):
         self.effort_budget = effort_budget
         self.retrieval_mode = retrieval_mode
         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,28 +1,51 @@
-from typing import Any
+from __future__ import annotations
+
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
-from rapidata.rapidata_client.selection.retrieval_modes import RetrievalMode
-from rapidata.api_client.models.labeling_selection import (
-    LabelingSelection as LabelingSelectionModel,
+from rapidata.rapidata_client.selection.rapidata_retrieval_modes import (
+    RapidataRetrievalMode,
 )
 
 
 class LabelingSelection(RapidataSelection):
     """Labeling selection class.
-    
+
     Decides how many actual datapoints you want to show per session.
-    
+
     Args:
         amount (int): The amount of labeling rapids that will be shown per session.
         retrieval_mode (RetrievalMode): The retrieval mode to use. Defaults to "Shuffled".
-        max_iterations (int | None): An annotator can answer the same task only once if the retrieval_mode is "Shuffled" 
-            or "Sequential". max_iterations can increase the amount of responses an annotator can do 
+        max_iterations (int | None): An annotator can answer the same task only once if the retrieval_mode is "Shuffled"
+            or "Sequential". max_iterations can increase the amount of responses an annotator can do
             to the same task (datapoint).
     """
 
-    def __init__(self, amount: int, retrieval_mode: RetrievalMode = RetrievalMode.Shuffled, max_iterations: int | None = None):
+    def __init__(
+        self,
+        amount: int,
+        retrieval_mode: RapidataRetrievalMode = RapidataRetrievalMode.Shuffled,
+        max_iterations: int | None = None,
+    ):
         self.amount = amount
         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/{retrieval_modes.py → rapidata_retrieval_modes.py}

@@ -1,18 +1,21 @@
 from enum import Enum
+from rapidata.api_client.models.retrieval_mode import RetrievalMode
 
-class RetrievalMode(Enum):
+
+class RapidataRetrievalMode(Enum):
     """
     Enum for defining retrieval modes for datapoints.
     """
-    Shuffled = "Shuffled"
+
+    Shuffled = RetrievalMode.SHUFFLED
     """
     Will shuffle the datapoints randomly for each user. The user will then see the datapoints in that order. This will take into account the "max_iterations" parameter.
     """
-    Sequential = "Sequential"
+    Sequential = RetrievalMode.SEQUENTIAL
     """
     Will show the datapoints in the order they are in the dataset. This will take into account the "max_iterations" parameter.
     """
-    Random = "Random"
+    Random = RetrievalMode.RANDOM
     """
     Will just randomly feed the datapoints to the annotators. This will NOT take into account the "max_iterations" parameter.
     """

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
+
+    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,24 @@
+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_model import FeatureFlagModel
+
 
 class RapidataSetting(BaseModel):
     """Base class for all settings"""
+
     key: str
     value: Any
 
     def _to_feature_flag(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})"