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

rapidata/rapidata_client/settings/_rapidata_setting.py

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

rapidata/rapidata_client/settings/alert_on_fast_response.py

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

rapidata/rapidata_client/settings/allow_neither_both.py

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

rapidata/rapidata_client/settings/custom_setting.py

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

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

@@ -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.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,10 +58,16 @@ 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_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.
 
@@ -49,15 +77,65 @@ 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(f"Setting shouldAlert for validation set {self.id} to {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:
+        """
+        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/__init__.py

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