rapidata 2.27.0__py3-none-any.whl → 2.44.4__py3-none-any.whl

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

@@ -0,0 +1,17 @@
+from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+
+
+class AllowNeitherBoth(RapidataSetting):
+    """
+    Set whether to allow neither or both options.
+    This setting only works for compare orders.
+
+    Args:
+        value (bool): Whether to allow neither or both options. Defaults to True.
+            If this setting is not added to an order, the users won't be able to select neither or both.
+    """
+
+    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)

rapidata/rapidata_client/settings/free_text_minimum_characters.py

@@ -1,17 +1,22 @@
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
-from rapidata.rapidata_client.logging import managed_print, logger
+from rapidata.rapidata_client.config import managed_print
+
 
 class FreeTextMinimumCharacters(RapidataSetting):
     """
     Set the minimum number of characters a user has to type.
-    
+
     Args:
         value (int): The minimum number of characters for free text.
     """
 
     def __init__(self, value: int):
         if value < 1:
-            raise ValueError("The minimum number of characters must be greater than or equal to 1.")
+            raise ValueError(
+                "The minimum number of characters must be greater than or equal to 1."
+            )
         if value > 40:
-            managed_print(f"Warning: Are you sure you want to set the minimum number of characters at {value}?")
+            managed_print(
+                f"Warning: Are you sure you want to set the minimum number of characters at {value}?"
+            )
         super().__init__(key="free_text_minimum_characters", value=value)

rapidata/rapidata_client/settings/models/translation_behaviour_options.py

@@ -1,14 +1,15 @@
 from enum import Enum
 
+
 class TranslationBehaviourOptions(Enum):
     """The options for the translation behaviour setting.
-    
+
     Attributes:
         BOTH: Show both the original and the translated text.
             May clutter the screen if the options are too long.
         ONLY_ORIGINAL: Show only the original text.
         ONLY_TRANSLATED: Show only the translated text."""
-    
+
     BOTH = "both"
     ONLY_ORIGINAL = "only original"
     ONLY_TRANSLATED = "only translated"

rapidata/rapidata_client/settings/mute_video.py

@@ -0,0 +1,15 @@
+from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+
+
+class MuteVideo(RapidataSetting):
+    """
+    Mute the video. If this setting is not supplied, the video will not be muted.
+
+    Args:
+        value (bool): Whether to mute the video. Defaults to True.
+    """
+
+    def __init__(self, value: bool = True):
+        if not isinstance(value, bool):
+            raise ValueError("The value must be a boolean.")
+        super().__init__(key="mute_video_asset", value=value)

rapidata/rapidata_client/settings/no_shuffle.py

@@ -1,16 +1,18 @@
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
 
+
 class NoShuffle(RapidataSetting):
     """
     Only for classification and compare tasks. If true, the order of the categories / images will not be shuffled and presented in the same order as specified.
 
     If this is not added to the order, the shuffling will be active.
-    
+
     Args:
         value (bool, optional): Whether to disable shuffling. Defaults to True for function call.
     """
+
     def __init__(self, value: bool = True):
         if not isinstance(value, bool):
             raise ValueError("The value must be a boolean.")
-        
+
         super().__init__(key="no_shuffle", value=value)

rapidata/rapidata_client/settings/play_video_until_the_end.py

@@ -1,16 +1,19 @@
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
 
+
 class PlayVideoUntilTheEnd(RapidataSetting):
     """
     Allows users to only answer once the video has finished playing.
     The additional time gets added on top of the video duration. Can be negative to allow answers before the video ends.
-    
+
     Args:
         additional_time (int, optional): Additional time in milliseconds. Defaults to 0.
     """
-    
+
     def __init__(self, additional_time: int = 0):
         if additional_time < -25000 or additional_time > 25000:
             raise ValueError("The additional time must be between -25000 and 25000.")
-        
-        super().__init__(key="alert_on_fast_response_add_media_duration", value=additional_time)
+
+        super().__init__(
+            key="alert_on_fast_response_add_media_duration", value=additional_time
+        )

rapidata/rapidata_client/settings/rapidata_settings.py

@@ -4,22 +4,27 @@ from rapidata.rapidata_client.settings import (
     FreeTextMinimumCharacters,
     NoShuffle,
     PlayVideoUntilTheEnd,
-    CustomSetting,
-    )
+    AllowNeitherBoth,
+    SwapContextInstruction,
+    MuteVideo,
+)
+
 
 class RapidataSettings:
     """
     Container class for all setting factory functions
 
     Settings can be added to an order to determine the behaviour of the task.
-    
+
     Attributes:
-        alert_on_fast_response (AlertOnFastResponse): The AlertOnFastResponse instance.
-        translation_behaviour (TranslationBehaviour): The TranslationBehaviour instance.
-        free_text_minimum_characters (FreeTextMinimumCharacters): The FreeTextMinimumCharacters instance.
-        no_shuffle (NoShuffle): The NoShuffle instance.
-        play_video_until_the_end (PlayVideoUntilTheEnd): The PlayVideoUntilTheEnd instance.
-        custom_setting (CustomSetting): The CustomSetting instance.
+        alert_on_fast_response (AlertOnFastResponse): Gives an alert as a pop up on the UI when the response time is less than the milliseconds.
+        translation_behaviour (TranslationBehaviour): Defines what's the behaviour of the translation in the UI.
+        free_text_minimum_characters (FreeTextMinimumCharacters): Only for free text tasks. Set the minimum number of characters a user has to type.
+        no_shuffle (NoShuffle): Only for classification and compare tasks. If true, the order of the categories / images will not be shuffled and presented in the same order as specified.
+        play_video_until_the_end (PlayVideoUntilTheEnd): Allows users to only answer once the video has finished playing.
+        allow_neither_both (AllowNeitherBoth): Only for compare tasks. If true, the users will be able to select neither or both instead of exclusively one of the options.
+        swap_context_instruction (SwapContextInstruction): Swap the place of the context and instruction.
+        mute_video (MuteVideo): Mute the video.
 
     Example:
         ```python
@@ -27,7 +32,7 @@ class RapidataSettings:
         settings=[FreeTextMinimumCharacters(10)]
         ```
 
-        This can be used in a free text order to set the minimum number of characters required to submit the task. 
+        This can be used in a free text order to set the minimum number of characters required to submit the task.
     """
 
     alert_on_fast_response = AlertOnFastResponse
@@ -35,5 +40,12 @@ class RapidataSettings:
     free_text_minimum_characters = FreeTextMinimumCharacters
     no_shuffle = NoShuffle
     play_video_until_the_end = PlayVideoUntilTheEnd
-    custom_setting = CustomSetting
+    allow_neither_both = AllowNeitherBoth
+    swap_context_instruction = SwapContextInstruction
+    mute_video = MuteVideo
+
+    def __str__(self) -> str:
+        return f"RapidataSettings(alert_on_fast_response={self.alert_on_fast_response}, translation_behaviour={self.translation_behaviour}, free_text_minimum_characters={self.free_text_minimum_characters}, no_shuffle={self.no_shuffle}, play_video_until_the_end={self.play_video_until_the_end}, allow_neither_both={self.allow_neither_both}, swap_context_instruction={self.swap_context_instruction}, mute_video={self.mute_video})"
 
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/settings/swap_context_instruction.py

@@ -0,0 +1,20 @@
+from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+
+
+class SwapContextInstruction(RapidataSetting):
+    """
+    Swap the place of the context and instruction.
+
+    If set to true, the instruction will be shown on top and the context below. if collapsed, only the instruction will be shown.
+
+    By default, the context will be shown on top and the instruction below.
+
+    Args:
+        value (bool): Whether to swap the place of the context and instruction.
+    """
+
+    def __init__(self, value: bool = True):
+        if not isinstance(value, bool):
+            raise ValueError("The value must be a boolean.")
+
+        super().__init__(key="swap_question_and_prompt", value=value)

rapidata/rapidata_client/settings/translation_behaviour.py

@@ -1,18 +1,20 @@
-from rapidata.rapidata_client.settings.models.translation_behaviour_options import TranslationBehaviourOptions
+from rapidata.rapidata_client.settings.models.translation_behaviour_options import (
+    TranslationBehaviourOptions,
+)
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
 
+
 class TranslationBehaviour(RapidataSetting):
     """
     Defines what's the behaviour of the translation in the UI.
     Will not translate text datapoints or sentences.
-    
+
     Args:
         value (TranslationBehaviourOptions): The translation behaviour.
     """
-    
+
     def __init__(self, value: TranslationBehaviourOptions):
         if not isinstance(value, TranslationBehaviourOptions):
             raise ValueError("The value must be a TranslationBehaviourOptions.")
-        
-        super().__init__(key="translation_behaviour", value=value)
 
+        super().__init__(key="translation_behaviour", value=value.value)

rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -1,8 +1,17 @@
+import webbrowser
+import urllib.parse
+from colorama import Fore
 from rapidata.rapidata_client.validation.rapids.rapids import Rapid
 from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.logging import logger
-from rapidata.api_client.models.update_dimensions_model import UpdateDimensionsModel
-from rapidata.rapidata_client.assets._sessions import SessionManager
+from rapidata.rapidata_client.config import logger, managed_print, tracer
+from rapidata.api_client.models.update_validation_set_model import (
+    UpdateValidationSetModel,
+)
+from rapidata.api_client.models.update_should_alert_model import UpdateShouldAlertModel
+from rapidata.rapidata_client.validation.rapids._validation_rapid_uploader import (
+    ValidationRapidUploader,
+)
+
 
 class RapidataValidationSet:
     """A class for interacting with a Rapidata validation set.
@@ -16,18 +25,31 @@ class RapidataValidationSet:
         name (str): The name of the validation set.
     """
 
-    def __init__(self, validation_set_id, name: str, openapi_service: OpenAPIService):
+    def __init__(
+        self,
+        validation_set_id,
+        name: str,
+        dimensions: list[str],
+        openapi_service: OpenAPIService,
+    ):
         self.id = validation_set_id
         self.name = name
-        self.__openapi_service = openapi_service
-    
+        self.dimensions = dimensions
+        self.validation_set_details_page = (
+            f"https://app.{openapi_service.environment}/validation-set/detail/{self.id}"
+        )
+        self._openapi_service = openapi_service
+        self.validation_rapid_uploader = ValidationRapidUploader(openapi_service)
+
     def add_rapid(self, rapid: Rapid):
         """Add a Rapid to the validation set.
 
         Args:
             rapid (Rapid): The Rapid to add to the validation set.
         """
-        rapid._add_to_validation_set(self.id, self.__openapi_service)
+        with tracer.start_as_current_span("RapidataValidationSet.add_rapid"):
+            logger.debug("Adding rapid %s to validation set %s", rapid, self.id)
+            self.validation_rapid_uploader.upload_rapid(rapid, self.id)
         return self
 
     def update_dimensions(self, dimensions: list[str]):
@@ -36,12 +58,84 @@ class RapidataValidationSet:
         Args:
             dimensions (list[str]): The new dimensions of the validation set.
         """
-        logger.debug(f"Updating dimensions for validation set {self.id} to {dimensions}")
-        self.__openapi_service.validation_api.validation_validation_set_id_dimensions_patch(self.id, UpdateDimensionsModel(dimensions=dimensions))
-        return self
+        with tracer.start_as_current_span("RapidataValidationSet.update_dimensions"):
+            logger.debug(
+                "Updating dimensions for validation set %s to %s", self.id, dimensions
+            )
+            self._openapi_service.validation_api.validation_set_validation_set_id_patch(
+                self.id, UpdateValidationSetModel(dimensions=dimensions)
+            )
+            self.dimensions = dimensions
+            return self
+
+    def update_should_alert(self, should_alert: bool):
+        """Determines whether users should be alerted if they answer incorrectly.
+
+        Args:
+            should_alert (bool): Specifies whether users should be alerted for incorrect answers. Defaults to True if not specifically overridden by this method.
+
+        Note:
+            The userScore dimensions which are updated when a user answers a validation task are updated regardless of the value of `should_alert`.
+        """
+        with tracer.start_as_current_span("RapidataValidationSet.update_should_alert"):
+            logger.debug(
+                "Setting shouldAlert for validation set %s to %s", self.id, should_alert
+            )
+            self._openapi_service.validation_api.validation_set_validation_set_id_patch(
+                self.id, UpdateValidationSetModel(shouldAlert=should_alert)
+            )
+            return self
+
+    def update_can_be_flagged(self, can_be_flagged: bool):
+        """Update if tasks in the validation set can be flagged for bad accuracy.
+
+        Args:
+            can_be_flagged (bool): Specifies whether tasks in the validation set can be flagged for bad accuracy. Defaults to True if not specifically overridden by this method.
+        """
+        with tracer.start_as_current_span(
+            "RapidataValidationSet.update_can_be_flagged"
+        ):
+            logger.debug(
+                "Setting canBeFlagged for validation set %s to %s",
+                self.id,
+                can_be_flagged,
+            )
+            self._openapi_service.validation_api.validation_set_validation_set_id_patch(
+                self.id, UpdateValidationSetModel(isFlagOverruled=(not can_be_flagged))
+            )
+            return self
+
+    def view(self) -> None:
+        """
+        Opens the validation set details page in the browser.
+
+        Raises:
+            Exception: If the order is not in processing state.
+        """
+        logger.info("Opening validation set details page in browser...")
+        could_open_browser = webbrowser.open(self.validation_set_details_page)
+        if not could_open_browser:
+            encoded_url = urllib.parse.quote(
+                self.validation_set_details_page, safe="%/:=&?~#+!$,;'@()*[]"
+            )
+            managed_print(
+                Fore.RED
+                + f"Please open this URL in your browser: '{encoded_url}'"
+                + Fore.RESET
+            )
+
+    def delete(self) -> None:
+        """Deletes the validation set"""
+        with tracer.start_as_current_span("RapidataValidationSet.delete"):
+            logger.info("Deleting ValidationSet '%s'", self)
+            self._openapi_service.validation_api.validation_set_validation_set_id_delete(
+                self.id
+            )
+            logger.debug("ValidationSet '%s' has been deleted.", self)
+            managed_print(f"ValidationSet '{self}' has been deleted.")
 
     def __str__(self):
-        return f"name: '{self.name}' id: {self.id}"
+        return f"name: '{self.name}' id: {self.id} dimensions: {self.dimensions}"
 
     def __repr__(self):
-        return f"name: '{self.name}' id: {self.id}"
+        return f"name: '{self.name}' id: {self.id} dimensions: {self.dimensions}"

rapidata/rapidata_client/validation/rapids/_validation_rapid_uploader.py

@@ -0,0 +1,62 @@
+from rapidata.rapidata_client.validation.rapids.rapids import Rapid
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.api_client.models.add_validation_rapid_model import (
+    AddValidationRapidModel,
+)
+from rapidata.api_client.models.add_validation_rapid_model_truth import (
+    AddValidationRapidModelTruth,
+)
+from rapidata.rapidata_client.datapoints._asset_uploader import AssetUploader
+from rapidata.api_client.models.add_validation_rapid_model_asset import (
+    AddValidationRapidModelAsset,
+)
+from rapidata.api_client.models.add_validation_rapid_model_context_asset import (
+    AddValidationRapidModelContextAsset,
+)
+from rapidata.api_client.models.i_asset_input import IAssetInput
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
+from rapidata.api_client.models.i_validation_truth import IValidationTruth
+
+
+class ValidationRapidUploader:
+    def __init__(self, openapi_service: OpenAPIService):
+        self.openapi_service = openapi_service
+        self.asset_uploader = AssetUploader(openapi_service)
+
+    def upload_rapid(self, rapid: Rapid, validation_set_id: str) -> None:
+        uploaded_asset: IAssetInput = (
+            self.asset_uploader.get_uploaded_asset_input(rapid.asset)
+            if rapid.data_type == "media"
+            else self.asset_uploader.get_uploaded_text_input(rapid.asset)
+        )
+
+        self.openapi_service.validation_api.validation_set_validation_set_id_rapid_post(
+            validation_set_id=validation_set_id,
+            add_validation_rapid_model=AddValidationRapidModel(
+                asset=uploaded_asset,
+                payload=self._get_payload(rapid),
+                context=rapid.context,
+                contextAsset=(
+                    self.asset_uploader.get_uploaded_asset_input(rapid.media_context)
+                    if rapid.media_context
+                    else None
+                ),
+                truth=(
+                    IValidationTruth(actual_instance=rapid.truth)
+                    if rapid.truth
+                    else None
+                ),
+                randomCorrectProbability=rapid.random_correct_probability,
+                explanation=rapid.explanation,
+                featureFlags=(
+                    [setting._to_feature_flag() for setting in rapid.settings]
+                    if rapid.settings
+                    else None
+                ),
+            ),
+        )
+
+    def _get_payload(self, rapid: Rapid) -> IRapidPayload:
+        if isinstance(rapid.payload, dict):
+            return IRapidPayload(actual_instance=rapid.payload)
+        return IRapidPayload(actual_instance=rapid.payload.to_dict())

rapidata/rapidata_client/validation/rapids/box.py

@@ -1,17 +1,42 @@
 from rapidata.api_client.models.box_shape import BoxShape
+from pydantic import BaseModel, field_validator, model_validator
 
-class Box:
+
+class Box(BaseModel):
     """
-    Used in the Locate and Draw Validation sets. All coordinates are in pixels.
-    
+    Used in the Locate and Draw Validation sets. All coordinates are in ratio of the image size (0.0 to 1.0).
+
     Args:
-        x_min (float): The minimum x value of the box.
-        y_min (float): The minimum y value of the box.
-        x_max (float): The maximum x value of the box.
-        y_max (float): The maximum y value of the box.
+        x_min (float): The minimum x value of the box in ratio of the image size.
+        y_min (float): The minimum y value of the box in ratio of the image size.
+        x_max (float): The maximum x value of the box in ratio of the image size.
+        y_max (float): The maximum y value of the box in ratio of the image size.
     """
-    def __init__(self, x_min: float, y_min: float, x_max: float, y_max: float):
-        self.x_min = x_min
-        self.y_min = y_min
-        self.x_max = x_max
-        self.y_max = y_max
+
+    x_min: float
+    y_min: float
+    x_max: float
+    y_max: float
+
+    @field_validator("x_min", "y_min", "x_max", "y_max")
+    @classmethod
+    def coordinates_between_zero_and_one(cls, v: float) -> float:
+        if not (0.0 <= v <= 1.0):
+            raise ValueError("Box coordinates must be between 0 and 1")
+        return v
+
+    @model_validator(mode="after")
+    def check_min_less_than_max(self) -> "Box":
+        if self.x_min >= self.x_max:
+            raise ValueError("x_min must be less than x_max")
+        if self.y_min >= self.y_max:
+            raise ValueError("y_min must be less than y_max")
+        return self
+
+    def to_model(self) -> BoxShape:
+        return BoxShape(
+            xMin=self.x_min * 100,
+            yMin=self.y_min * 100,
+            xMax=self.x_max * 100,
+            yMax=self.y_max * 100,
+        )