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

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

@@ -5,14 +5,17 @@ from rapidata.rapidata_client.settings import (
     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.
@@ -20,6 +23,8 @@ class RapidataSettings:
         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,12 +32,20 @@ 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
-    translation_behaviour = TranslationBehaviour
-    free_text_minimum_characters = FreeTextMinimumCharacters
-    no_shuffle = NoShuffle
-    play_video_until_the_end = PlayVideoUntilTheEnd
-    allow_neither_both = AllowNeitherBoth
+    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

@@ -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/utils/__init__.py

@@ -0,0 +1,3 @@
+from .threaded_uploader import ThreadedUploader
+
+__all__ = ["ThreadedUploader"]

rapidata/rapidata_client/utils/threaded_uploader.py

@@ -0,0 +1,153 @@
+from typing import TypeVar, Generic, Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from tqdm import tqdm
+import time
+
+from rapidata.rapidata_client.config import logger
+from rapidata.rapidata_client.config.rapidata_config import rapidata_config
+
+from opentelemetry import context as otel_context
+
+T = TypeVar("T")
+
+
+class ThreadedUploader(Generic[T]):
+    """
+    A generic multi-threaded uploader that handles retries, progress tracking,
+    and OpenTelemetry context propagation.
+
+    Type Parameters:
+        T: The type of items being uploaded.
+    """
+
+    def __init__(
+        self,
+        upload_fn: Callable[[T, int], None],
+        description: str = "Uploading items",
+    ):
+        """
+        Initialize the threaded uploader.
+
+        Args:
+            upload_fn: A function that uploads a single item. Takes (item, index) as arguments.
+            description: Description shown in the progress bar.
+        """
+        self.upload_fn = upload_fn
+        self.description = description
+
+    def upload(self, items: list[T]) -> tuple[list[T], list[T]]:
+        """
+        Upload items in parallel using multiple threads.
+
+        Args:
+            items: List of items to upload.
+
+        Returns:
+            tuple[list[T], list[T]]: Lists of successful and failed uploads.
+        """
+        successful_uploads: list[T] = []
+        failed_uploads: list[T] = []
+
+        with tqdm(
+            total=len(items),
+            desc=self.description,
+            disable=rapidata_config.logging.silent_mode,
+        ) as progress_bar:
+
+            def process_upload_with_context(
+                context: otel_context.Context, item: T, index: int
+            ) -> tuple[list[T], list[T]]:
+                """Wrapper function that runs upload with the provided context."""
+                token = otel_context.attach(context)
+                try:
+                    return self._process_single_upload(item, index)
+                finally:
+                    otel_context.detach(token)
+
+            # Capture the current OpenTelemetry context before creating threads
+            current_context = otel_context.get_current()
+
+            with ThreadPoolExecutor(
+                max_workers=rapidata_config.upload.maxWorkers
+            ) as executor:
+                futures = [
+                    executor.submit(
+                        process_upload_with_context,
+                        current_context,
+                        item,
+                        i,
+                    )
+                    for i, item in enumerate(items)
+                ]
+
+                for future in as_completed(futures):
+                    try:
+                        chunk_successful, chunk_failed = future.result()
+                        successful_uploads.extend(chunk_successful)
+                        failed_uploads.extend(chunk_failed)
+                        progress_bar.update(len(chunk_successful) + len(chunk_failed))
+                    except Exception as e:
+                        logger.error("Future execution failed: %s", str(e))
+
+        if failed_uploads:
+            logger.error(
+                "Upload failed for %s items: %s",
+                len(failed_uploads),
+                failed_uploads,
+            )
+
+        return successful_uploads, failed_uploads
+
+    def _process_single_upload(
+        self,
+        item: T,
+        index: int,
+    ) -> tuple[list[T], list[T]]:
+        """
+        Process single upload with retry logic and error tracking.
+
+        Args:
+            item: Item to upload.
+            index: Sort index for the upload.
+
+        Returns:
+            tuple[list[T], list[T]]: Lists of successful and failed items.
+        """
+        logger.debug("Processing single upload for %s with index %s", item, index)
+
+        local_successful: list[T] = []
+        local_failed: list[T] = []
+
+        last_exception = None
+        for attempt in range(rapidata_config.upload.maxRetries):
+            try:
+                from rapidata.rapidata_client.api.rapidata_api_client import (
+                    suppress_rapidata_error_logging,
+                )
+
+                with suppress_rapidata_error_logging():
+                    self.upload_fn(item, index)
+
+                local_successful.append(item)
+                return local_successful, local_failed
+
+            except Exception as e:
+                last_exception = e
+                if attempt < rapidata_config.upload.maxRetries - 1:
+                    # Exponential backoff: wait 1s, then 2s, then 4s
+                    retry_delay = 2**attempt
+                    time.sleep(retry_delay)
+                    logger.debug("Error: %s", str(last_exception))
+                    logger.debug(
+                        "Retrying %s of %s...",
+                        attempt + 1,
+                        rapidata_config.upload.maxRetries,
+                    )
+
+        # If we get here, all retries failed
+        local_failed.append(item)
+        tqdm.write(
+            f"Upload failed for {item} after {rapidata_config.upload.maxRetries} attempts. \nFinal error: \n{str(last_exception)}"
+        )
+
+        return local_successful, local_failed

rapidata/rapidata_client/validation/__init__.py

@@ -1 +1,3 @@
+from .validation_set_manager import ValidationSetManager
+from .rapidata_validation_set import RapidataValidationSet
 from .rapids import Box

rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -3,9 +3,14 @@ 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, managed_print
-from rapidata.api_client.models.update_dimensions_model import UpdateDimensionsModel
+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:
@@ -20,13 +25,21 @@ 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.dimensions = dimensions
         self.validation_set_details_page = (
             f"https://app.{openapi_service.environment}/validation-set/detail/{self.id}"
         )
-        self.__openapi_service = openapi_service
+        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.
@@ -34,7 +47,9 @@ class RapidataValidationSet:
         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]):
@@ -43,13 +58,15 @@ class RapidataValidationSet:
         Args:
             dimensions (list[str]): The new dimensions of the validation set.
         """
-        logger.debug(
-            "Updating dimensions for validation set %s to %s", self.id, dimensions
-        )
-        self.__openapi_service.validation_api.validation_set_validation_set_id_dimensions_put(
-            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.
@@ -60,13 +77,33 @@ class RapidataValidationSet:
         Note:
             The userScore dimensions which are updated when a user answers a validation task are updated regardless of the value of `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_shouldalert_patch(
-            self.id, UpdateShouldAlertModel(shouldAlert=should_alert)
-        )
-        return self
+        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:
         """
@@ -87,8 +124,18 @@ class RapidataValidationSet:
                 + 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/__init__.py

@@ -1 +1,3 @@
 from .box import Box
+from .rapids import Rapid
+from .rapids_manager import RapidsManager

rapidata/rapidata_client/validation/rapids/_validation_rapid_uploader.py

@@ -0,0 +1,48 @@
+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.i_asset_input import IAssetInput
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
+from rapidata.rapidata_client.datapoints._asset_uploader import AssetUploader
+
+
+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=rapid.truth,
+                randomCorrectProbability=rapid.random_correct_probability,
+                explanation=rapid.explanation,
+                featureFlags=(
+                    [setting._to_feature_flag_model() 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,
+        )