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

rapidata/rapidata_client/selection/validation_selection.py

@@ -1,15 +1,38 @@
+from __future__ import annotations
 
-from rapidata.api_client.models.validation_selection import ValidationSelection as ValidationSelectionModel
-from rapidata.rapidata_client.selection.base_selection import Selection
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 
 
-class ValidationSelection(Selection):
+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.
+    """
 
     def __init__(self, validation_set_id: str, amount: int = 1):
         self.validation_set_id = validation_set_id
         self.amount = amount
 
+    def _to_model(self):
+        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 to_model(self):
-        return ValidationSelectionModel(_t="ValidationSelection", validationSetId=self.validation_set_id, amount=self.amount)
-    
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/settings/__init__.py

@@ -1,2 +1,12 @@
-from .feature_flags import FeatureFlags
-from .settings import Settings, TranslationBehaviour
+from .models import TranslationBehaviourOptions
+from .alert_on_fast_response import AlertOnFastResponse
+from .translation_behaviour import TranslationBehaviour
+from .free_text_minimum_characters import FreeTextMinimumCharacters
+from .no_shuffle import NoShuffle
+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

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from pydantic import BaseModel
+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})"

rapidata/rapidata_client/settings/alert_on_fast_response.py

@@ -0,0 +1,25 @@
+from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+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)?"
+            )
+        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

@@ -0,0 +1,17 @@
+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.
+    """
+
+    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

@@ -0,0 +1,22 @@
+from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+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."
+            )
+        if value > 40:
+            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/__init__.py

@@ -0,0 +1 @@
+from .translation_behaviour_options import TranslationBehaviourOptions

rapidata/rapidata_client/settings/models/translation_behaviour_options.py

@@ -0,0 +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

@@ -0,0 +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

@@ -0,0 +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
+        )

rapidata/rapidata_client/settings/rapidata_settings.py

@@ -0,0 +1,51 @@
+from rapidata.rapidata_client.settings import (
+    AlertOnFastResponse,
+    TranslationBehaviour,
+    FreeTextMinimumCharacters,
+    NoShuffle,
+    PlayVideoUntilTheEnd,
+    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): 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
+        from rapidata import FreeTextMinimumCharacters
+        settings=[FreeTextMinimumCharacters(10)]
+        ```
+
+        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
+    translation_behaviour = TranslationBehaviour
+    free_text_minimum_characters = FreeTextMinimumCharacters
+    no_shuffle = NoShuffle
+    play_video_until_the_end = PlayVideoUntilTheEnd
+    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

@@ -0,0 +1,20 @@
+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.value)

rapidata/rapidata_client/validation/__init__.py

@@ -0,0 +1 @@
+from .rapids import Box

rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -0,0 +1,141 @@
+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.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.
+
+    Represents a set of all the validation tasks that can be added to an order.
+
+    When added to an order, the tasks will be selected randomly from the set.
+
+    Attributes:
+        id (str): The ID of the validation set.
+        name (str): The name of the validation set.
+    """
+
+    def __init__(
+        self,
+        validation_set_id,
+        name: str,
+        dimensions: list[str],
+        openapi_service: OpenAPIService,
+    ):
+        self.id = validation_set_id
+        self.name = name
+        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.
+        """
+        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]):
+        """Update the dimensions of the validation set.
+
+        Args:
+            dimensions (list[str]): The new dimensions of the validation set.
+        """
+        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} dimensions: {self.dimensions}"
+
+    def __repr__(self):
+        return f"name: '{self.name}' id: {self.id} dimensions: {self.dimensions}"

rapidata/rapidata_client/validation/rapids/__init__.py

@@ -0,0 +1 @@
+from .box import Box

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

@@ -0,0 +1,42 @@
+from rapidata.api_client.models.box_shape import BoxShape
+from pydantic import BaseModel, field_validator, model_validator
+
+
+class Box(BaseModel):
+    """
+    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 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.
+    """
+
+    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,
+        )

rapidata/rapidata_client/validation/rapids/rapids.py

@@ -0,0 +1,29 @@
+from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+from typing import Literal, Any, Sequence
+from pydantic import BaseModel, model_validator, ConfigDict
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
+
+
+class Rapid(BaseModel):
+    asset: str | list[str]
+    payload: IRapidPayload
+    data_type: Literal["media", "text"] = "media"
+    truth: Any | None = None
+    context: str | None = None
+    media_context: str | None = None
+    sentence: str | None = None
+    random_correct_probability: float | None = None
+    explanation: str | None = None
+    settings: Sequence[RapidataSetting] | None = None
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, populate_by_name=True, extra="allow"
+    )
+
+    @model_validator(mode="after")
+    def check_sentence_and_context(self) -> "Rapid":
+        if isinstance(self.sentence, str) and isinstance(self.context, str):
+            raise ValueError(
+                "Both 'sentence' and 'context' cannot be strings at the same time."
+            )
+        return self