rapidata 2.31.2__py3-none-any.whl → 2.33.0__py3-none-any.whl

rapidata/rapidata_client/order/_rapidata_dataset.py

@@ -2,8 +2,9 @@ from itertools import zip_longest
 
 from rapidata.api_client.models.create_datapoint_from_text_sources_model import CreateDatapointFromTextSourcesModel
 from rapidata.api_client.models.dataset_dataset_id_datapoints_post_request_metadata_inner import DatasetDatasetIdDatapointsPostRequestMetadataInner
-from rapidata.rapidata_client.metadata._base_metadata import Metadata
-from rapidata.rapidata_client.assets import TextAsset, MediaAsset, MultiAsset, BaseAsset
+from rapidata.rapidata_client.datapoints.datapoint import Datapoint
+from rapidata.rapidata_client.datapoints.metadata import Metadata
+from rapidata.rapidata_client.datapoints.assets import TextAsset, MediaAsset, MultiAsset, BaseAsset
 from rapidata.service import LocalFileService
 from rapidata.service.openapi_service import OpenAPIService
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -14,109 +15,73 @@ from rapidata.rapidata_client.logging import logger, managed_print, RapidataOutp
 import time
 import threading
 
-
 def chunk_list(lst: list, chunk_size: int) -> Generator:
     for i in range(0, len(lst), chunk_size):
         yield lst[i:i + chunk_size]
 
 class RapidataDataset:
-
     def __init__(self, dataset_id: str, openapi_service: OpenAPIService):
         self.id = dataset_id
         self.openapi_service = openapi_service
         self.local_file_service = LocalFileService()
 
-    def _get_effective_asset_type(self, datapoints: Sequence[BaseAsset]) -> type:
-        if not datapoints:
-            raise ValueError("Cannot determine asset type from empty datapoints list.")
-            
-        first_item = datapoints[0]
-        
-        if isinstance(first_item, MultiAsset):
-            if not first_item.assets:
-                raise ValueError("MultiAsset cannot be empty.")
-            return type(first_item.assets[0])
-        
-        return type(first_item)
-
-    def _add_datapoints(
+    def add_datapoints(
         self,
-        datapoints: Sequence[BaseAsset],
-        metadata_list: Sequence[Sequence[Metadata]] | None = None,
-        max_workers: int = 10,
-    ):
-        effective_asset_type = self._get_effective_asset_type(datapoints)
+        datapoints: list[Datapoint],
+    ) -> tuple[list[Datapoint], list[Datapoint]]:
+        if not datapoints:
+            return [], []
         
-        for item in datapoints:
-            if isinstance(item, MultiAsset):
-                if not all(isinstance(asset, effective_asset_type) for asset in item.assets):
-                    raise ValueError("All MultiAssets must contain the same type of assets.")
-            elif not isinstance(item, (MediaAsset, TextAsset, MultiAsset)):
-                raise ValueError("All datapoints must be MediaAsset, TextAsset, or MultiAsset.")
+        effective_asset_type = datapoints[0]._get_effective_asset_type()
         
         if issubclass(effective_asset_type, MediaAsset):
-            media_datapoints = cast(list[MediaAsset] | list[MultiAsset], datapoints)
-            self._add_media_from_paths(media_datapoints, metadata_list, max_workers)
+            return self._add_media_from_paths(datapoints)
         elif issubclass(effective_asset_type, TextAsset):
-            text_datapoints = cast(list[TextAsset] | list[MultiAsset], datapoints)
-            self._add_texts(text_datapoints, metadata_list)
+            return self._add_texts(datapoints)
         else:
             raise ValueError(f"Unsupported asset type: {effective_asset_type}")
 
     def _add_texts(
         self,
-        text_assets: list[TextAsset] | list[MultiAsset],
-        metadata_list: Sequence[Sequence[Metadata]] | None = None,
+        datapoints: list[Datapoint],
         max_workers: int = 10,
-    ):
-        for text_asset in text_assets:
-            if isinstance(text_asset, MultiAsset):
-                assert all(
-                    isinstance(asset, TextAsset) for asset in text_asset.assets
-                ), "All assets in a MultiAsset must be of type TextAsset."
-
-        def upload_text_datapoint(text_asset: TextAsset | MultiAsset, metadata_per_datapoint: Sequence[Metadata] | None, index: int) -> None:
-            if isinstance(text_asset, TextAsset):
-                texts = [text_asset.text]
-            elif isinstance(text_asset, MultiAsset):
-                texts = [asset.text for asset in text_asset.assets if isinstance(asset, TextAsset)]
-            else:
-                raise ValueError(f"Unsupported asset type: {type(text_asset)}")
+    ) -> tuple[list[Datapoint], list[Datapoint]]:
+        
+        def upload_text_datapoint(datapoint: Datapoint, index: int) -> Datapoint:
+            model = datapoint.create_text_upload_model(index)
             
-            metadata = []
-            if metadata_per_datapoint:
-                for meta in metadata_per_datapoint:
-                    meta_model = meta.to_model() if meta else None
-                    if meta_model:
-                        metadata.append(DatasetDatasetIdDatapointsPostRequestMetadataInner(meta_model))
-
-            model = CreateDatapointFromTextSourcesModel(
-                textSources=texts,
-                sortIndex=index,
-                metadata=metadata,
-            )
-
             self.openapi_service.dataset_api.dataset_dataset_id_datapoints_texts_post(dataset_id=self.id, create_datapoint_from_text_sources_model=model)
+            return datapoint
+
+        successful_uploads: list[Datapoint] = []
+        failed_uploads: list[Datapoint] = []
 
-        total_uploads = len(text_assets)
+        total_uploads = len(datapoints)
         with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            futures = [
-                executor.submit(upload_text_datapoint, text_asset, metadata, index=i)
-                for i, (text_asset, metadata) in enumerate(zip_longest(text_assets, metadata_list or []))
-            ]
+            future_to_datapoint = {
+                executor.submit(upload_text_datapoint, datapoint, index=i): datapoint
+                for i, datapoint in enumerate(datapoints)
+            }
 
             with tqdm(total=total_uploads, desc="Uploading text datapoints", disable=RapidataOutputManager.silent_mode) as pbar:
-                for future in as_completed(futures):
-                    future.result()  # This will raise any exceptions that occurred during execution
-                    pbar.update(1)
+                for future in as_completed(future_to_datapoint.keys()):
+                    datapoint = future_to_datapoint[future]
+                    try:
+                        result = future.result()
+                        pbar.update(1)
+                        successful_uploads.append(result)
+                    except Exception as e:
+                        failed_uploads.append(datapoint)
+                        logger.error(f"Upload failed for {datapoint}: {str(e)}")
+
+        return successful_uploads, failed_uploads
 
     def _process_single_upload(
         self,
-        media_asset: MediaAsset | MultiAsset, 
-        meta_list: Sequence[Metadata] | None, 
+        datapoint: Datapoint,
         index: int,
         max_retries: int = 3,
-    ) -> tuple[list[str], list[str]]:
+    ) -> tuple[list[Datapoint], list[Datapoint]]:
         """
         Process single upload with retry logic and error tracking.
         
@@ -127,35 +92,15 @@ class RapidataDataset:
             max_retries: Maximum number of retry attempts (default: 3)
             
         Returns:
-            tuple[list[str], list[str]]: Lists of successful and failed identifiers
+            tuple[list[Datapoint], list[Datapoint]]: Lists of successful and failed datapoints
         """
-        local_successful: list[str] = []
-        local_failed: list[str] = []
-        identifiers_to_track: list[str] = []
-        
-        # Get identifier for this upload (URL or file path)
-        if isinstance(media_asset, MediaAsset):
-            assets = [media_asset]
-            identifier = media_asset._url if media_asset._url else media_asset.path
-            identifiers_to_track = [identifier] if identifier else []
-        elif isinstance(media_asset, MultiAsset):
-            assets = cast(list[MediaAsset], media_asset.assets)
-            identifiers_to_track = [
-                (asset._url if asset._url else cast(str, asset.path)) 
-                for asset in assets
-            ]
-        else:
-            raise ValueError(f"Unsupported asset type: {type(media_asset)}")
+        local_successful: list[Datapoint] = []
+        local_failed: list[Datapoint] = []
 
-        metadata: list[DatasetDatasetIdDatapointsPostRequestMetadataInner] = []
-        if meta_list:
-            for meta in meta_list:
-                meta_model = meta.to_model() if meta else None
-                if meta_model:
-                    metadata.append(DatasetDatasetIdDatapointsPostRequestMetadataInner(meta_model))
+        metadata = datapoint.get_prepared_metadata()
 
-        local_paths = [asset.to_file() for asset in assets if asset.is_local()]
-        urls = [asset.path for asset in assets if not asset.is_local()]
+        local_paths = datapoint.get_local_file_paths()
+        urls = datapoint.get_urls()
 
         last_exception = None
         for attempt in range(max_retries):
@@ -168,8 +113,8 @@ class RapidataDataset:
                     sort_index=index,
                 )
                 
-                # If we get here, the upload was successful
-                local_successful.extend(identifiers_to_track)
+                local_successful.append(datapoint)
+
                 return local_successful, local_failed
                 
             except Exception as e:
@@ -181,8 +126,8 @@ class RapidataDataset:
                     managed_print(f"\nRetrying {attempt + 1} of {max_retries}...\n")
                     
         # If we get here, all retries failed
-        logger.error(f"\nUpload failed for {identifiers_to_track} after {max_retries} attempts. Final error: {str(last_exception)}")
-        local_failed.extend(identifiers_to_track)
+        local_failed.append(datapoint)
+        logger.error(f"\nUpload failed for {datapoint} after {max_retries} attempts. Final error: {str(last_exception)}")
 
         return local_successful, local_failed
 
@@ -288,13 +233,12 @@ class RapidataDataset:
 
     def _process_uploads_in_chunks(
         self,
-        media_paths: list[MediaAsset] | list[MultiAsset],
-        multi_metadata: Sequence[Sequence[Metadata]] | None,
+        datapoints: list[Datapoint],
         max_workers: int,
         chunk_size: int,
         stop_progress_tracking: threading.Event,
         progress_tracking_error: threading.Event
-    ) -> tuple[list[str], list[str]]:
+    ) -> tuple[list[Datapoint], list[Datapoint]]:
         """
         Process uploads in chunks with a ThreadPoolExecutor.
         
@@ -309,23 +253,20 @@ class RapidataDataset:
         Returns:
             tuple[list[str], list[str]]: Lists of successful and failed uploads
         """
-        successful_uploads: list[str] = []
-        failed_uploads: list[str] = []
+        successful_uploads: list[Datapoint] = []
+        failed_uploads: list[Datapoint] = []
         
         try:
             with ThreadPoolExecutor(max_workers=max_workers) as executor:
                 # Process uploads in chunks to avoid overwhelming the system
-                for chunk_idx, chunk in enumerate(chunk_list(media_paths, chunk_size)):
-                    chunk_multi_metadata = multi_metadata[chunk_idx * chunk_size:(chunk_idx + 1) * chunk_size] if multi_metadata else None
-                    
+                for chunk_idx, chunk in enumerate(chunk_list(datapoints, chunk_size)):
                     futures = [
                         executor.submit(
                             self._process_single_upload, 
-                            media_asset, 
-                            meta_list, 
+                            datapoint, 
                             index=(chunk_idx * chunk_size + i)
                         )
-                        for i, (media_asset, meta_list) in enumerate(zip_longest(chunk, chunk_multi_metadata or []))
+                        for i, datapoint in enumerate(chunk)
                     ]
                     
                     # Wait for this chunk to complete before starting the next one
@@ -349,8 +290,8 @@ class RapidataDataset:
         self, 
         total_uploads: int, 
         progress_poll_interval: float,
-        successful_uploads: list[str],
-        failed_uploads: list[str]
+        successful_uploads: list[Datapoint],
+        failed_uploads: list[Datapoint]
     ) -> None:
         """
         Log the final progress of the upload operation.
@@ -389,37 +330,29 @@ class RapidataDataset:
 
     def _add_media_from_paths(
         self,
-        media_paths: list[MediaAsset] | list[MultiAsset],
-        multi_metadata: Sequence[Sequence[Metadata]] | None = None,
+        datapoints: list[Datapoint],
         max_workers: int = 10,
         chunk_size: int = 50,
         progress_poll_interval: float = 0.5,
-    ) -> tuple[list[str], list[str]]:
+    ) -> tuple[list[Datapoint], list[Datapoint]]:
         """
         Upload media paths in chunks with managed resources.
         
         Args:
-            media_paths: List of MediaAsset or MultiAsset objects to upload
-            multi_metadata: Optional sequence of sequences of metadata matching media_paths length
+            datapoints: List of Datapoint objects to upload
             max_workers: Maximum number of concurrent upload workers
             chunk_size: Number of items to process in each batch
             progress_poll_interval: Time in seconds between progress checks
             
         Returns:
-            tuple[list[str], list[str]]: Lists of successful and failed URLs
+            tuple[list[Datapoint], list[Datapoint]]: Lists of successful and failed datapoints
             
         Raises:
             ValueError: If multi_metadata lengths don't match media_paths length
         """
-
-        if multi_metadata and not len(multi_metadata) == len(media_paths):
-            raise ValueError("The number of assets must match the number of metadatas.")
-        
-        if multi_metadata and not all(len(data) == len(multi_metadata[0]) for data in multi_metadata):
-            raise ValueError("All metadatas must have the same length.")
         
         # Setup tracking variables
-        total_uploads = len(media_paths)
+        total_uploads = len(datapoints)
         
         # Create thread control events
         stop_progress_tracking = threading.Event()
@@ -437,8 +370,7 @@ class RapidataDataset:
         # Process uploads in chunks
         try:
             successful_uploads, failed_uploads = self._process_uploads_in_chunks(
-                media_paths,
-                multi_metadata,
+                datapoints,
                 max_workers,
                 chunk_size,
                 stop_progress_tracking,
@@ -455,7 +387,10 @@ class RapidataDataset:
             failed_uploads
         )
 
-        if failed_uploads:
-            raise RuntimeError(f"Upload failed for {failed_uploads}")
-
         return successful_uploads, failed_uploads
+
+    def __str__(self) -> str:
+        return f"RapidataDataset(id={self.id})"
+    
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/order/_rapidata_order_builder.py

@@ -1,35 +1,26 @@
-from rapidata.api_client.models.ab_test_selection_a_inner import (
-    AbTestSelectionAInner,
-)
+from typing import Optional, cast, Sequence
+
+from rapidata.api_client.models.ab_test_selection_a_inner import AbTestSelectionAInner
+from rapidata.api_client.models.and_user_filter_model_filters_inner import AndUserFilterModelFiltersInner
 from rapidata.api_client.models.create_order_model import CreateOrderModel
-from rapidata.api_client.models.create_order_model_referee import (
-    CreateOrderModelReferee,
-)
-from rapidata.api_client.models.and_user_filter_model_filters_inner import (
-    AndUserFilterModelFiltersInner,
-)
-from rapidata.api_client.models.create_order_model_workflow import (
-    CreateOrderModelWorkflow,
-)
+from rapidata.api_client.models.create_order_model_referee import CreateOrderModelReferee
+from rapidata.api_client.models.create_order_model_workflow import CreateOrderModelWorkflow
 
-from rapidata.rapidata_client.settings import RapidataSetting
-from rapidata.rapidata_client.metadata._base_metadata import Metadata
+from rapidata.rapidata_client.datapoints.assets import MediaAsset, TextAsset, MultiAsset, BaseAsset
+from rapidata.rapidata_client.datapoints.datapoint import Datapoint
+from rapidata.rapidata_client.exceptions.failed_upload_exception import FailedUploadException
+from rapidata.rapidata_client.filter import RapidataFilter
+from rapidata.rapidata_client.logging import logger, managed_print
+from rapidata.rapidata_client.datapoints.metadata import Metadata
 from rapidata.rapidata_client.order._rapidata_dataset import RapidataDataset
+from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
+from rapidata.rapidata_client.referee import Referee
 from rapidata.rapidata_client.referee._naive_referee import NaiveReferee
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
-from rapidata.rapidata_client.filter import RapidataFilter
+from rapidata.rapidata_client.settings import RapidataSetting
 from rapidata.rapidata_client.workflow import Workflow
-from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
-from rapidata.rapidata_client.referee import Referee
-from rapidata.service.openapi_service import OpenAPIService
-
 from rapidata.rapidata_client.workflow._compare_workflow import CompareWorkflow
-
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset, BaseAsset
-
-from typing import Optional, cast, Sequence
-
-from rapidata.rapidata_client.logging import logger, managed_print
+from rapidata.service.openapi_service import OpenAPIService
 
 
 class RapidataOrderBuilder:
@@ -53,13 +44,12 @@ class RapidataOrderBuilder:
         self.__dataset: Optional[RapidataDataset]
         self.__workflow: Workflow | None = None
         self.__referee: Referee | None = None
-        self.__multi_metadata: Sequence[Sequence[Metadata]] | None = None
         self.__validation_set_id: str | None = None
         self.__settings: Sequence[RapidataSetting] | None = None
         self.__user_filters: list[RapidataFilter] = []
         self.__selections: list[RapidataSelection] = []
         self.__priority: int | None = None
-        self.__assets: Sequence[BaseAsset] = []
+        self.__datapoints: list[Datapoint] = []
 
     def _to_model(self) -> CreateOrderModel:
         """
@@ -104,7 +94,7 @@ class RapidataOrderBuilder:
             priority=self.__priority,
         )
 
-    def _create(self, max_upload_workers: int = 10) -> RapidataOrder:
+    def _create(self) -> RapidataOrder:
         """
         Create the Rapidata order by making the necessary API calls based on the builder's configuration.
 
@@ -120,12 +110,6 @@ class RapidataOrderBuilder:
         """
         order_model = self._to_model()
         logger.debug(f"Creating order with model: {order_model}")
-        if isinstance(
-            self.__workflow, CompareWorkflow
-        ):  # Temporary fix; will be handled by backend in the future
-            assert all(
-                isinstance(item, MultiAsset) for item in self.__assets
-            ), "The media paths must be of type MultiAsset for comparison tasks."
 
         result = self.__openapi_service.order_api.order_post(
             create_order_model=order_model
@@ -154,7 +138,13 @@ class RapidataOrderBuilder:
         logger.debug("Adding media to the order.")
 
         if self.__dataset:
-            self.__dataset._add_datapoints(self.__assets, self.__multi_metadata, max_upload_workers)
+            _, failed_uploads = self.__dataset.add_datapoints(self.__datapoints)
+            
+            if failed_uploads:
+                raise FailedUploadException(self.__dataset, order, failed_uploads)
+        
+        else:
+            raise RuntimeError(f"No dataset created for this order. order_id: {self.order_id}")
         
         logger.debug("Media added to the order.")
         logger.debug("Setting order to preview")
@@ -194,46 +184,23 @@ class RapidataOrderBuilder:
         self.__referee = referee
         return self
 
-    def _media(
+    def _datapoints(
         self,
-        assets: Sequence[BaseAsset],
-        multi_metadata: Sequence[Sequence[Metadata]] | None = None,
+        datapoints: list[Datapoint],
     ) -> "RapidataOrderBuilder":
         """
-        Set the media assets for the order.
+        Set the datapoints for the order.
 
         Args:
-            assets: (list[MediaAsset] | list[TextAsset] | list[MultiAsset]): The paths of the media assets to be set.
-            multi_metadata: (list[list[Metadata]] | None, optional): Metadatas for the media assets. Defaults to None.
+            datapoints: (Sequence[Datapoint]): The datapoints to be set.
 
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
-        if not isinstance(assets, list):
-            raise TypeError("Media paths must be provided as a list of paths.")
-
-        for a in assets:
-            if not isinstance(a, (MediaAsset, TextAsset, MultiAsset)):
-                raise TypeError(
-                    "Media paths must be of type MediaAsset, TextAsset, or MultiAsset."
-                )
-
-        if multi_metadata:
-            for data in multi_metadata:
-                if not isinstance(data, list):
-                    raise TypeError("Metadata must be provided as a list of Metadata objects.")
-                for d in data:
-                    if not isinstance(d, Metadata):
-                        raise TypeError("Metadata must be of type Metadata.")
-
-        if multi_metadata and not len(multi_metadata) == len(assets):
-            raise ValueError("The number of assets must match the number of metadatas.")
-        
-        if multi_metadata and not all(len(data) == len(multi_metadata[0]) for data in multi_metadata):
-            raise ValueError("All metadatas must have the same length.")
+        if not isinstance(datapoints, list):
+            raise TypeError("Datapoints must be provided as a list of Datapoint objects.")
 
-        self.__assets = assets
-        self.__multi_metadata = multi_metadata
+        self.__datapoints = datapoints
         return self
 
     def _settings(self, settings: Sequence[RapidataSetting]) -> "RapidataOrderBuilder":

rapidata/rapidata_client/order/rapidata_order.py

@@ -50,11 +50,6 @@ class RapidataOrder:
         self.order_details_page = f"https://app.{self.__openapi_service.environment}/order/detail/{self.id}"
         logger.debug("RapidataOrder initialized")
 
-    @property
-    def order_id(self) -> str:
-        managed_print(f"order_id is deprecated. Use id instead.")
-        return self.id
-    
     @property
     def created_at(self) -> datetime:
         """Returns the creation date of the order."""

rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -4,7 +4,7 @@ from itertools import zip_longest
 from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.order._rapidata_order_builder import RapidataOrderBuilder
-from rapidata.rapidata_client.metadata import PromptMetadata, SelectWordsMetadata, PrivateTextMetadata, MediaAssetMetadata, Metadata
+from rapidata.rapidata_client.datapoints.metadata import PromptMetadata, SelectWordsMetadata, PrivateTextMetadata, MediaAssetMetadata, Metadata
 from rapidata.rapidata_client.referee._naive_referee import NaiveReferee
 from rapidata.rapidata_client.referee._early_stopping_referee import EarlyStoppingReferee
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
@@ -19,7 +19,8 @@ from rapidata.rapidata_client.workflow import (
     TimestampWorkflow,
     RankingWorkflow
 )
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
+from rapidata.rapidata_client.datapoints.assets import MediaAsset, TextAsset, MultiAsset
+from rapidata.rapidata_client.datapoints.datapoint import Datapoint
 from rapidata.rapidata_client.filter import RapidataFilter
 from rapidata.rapidata_client.filter.rapidata_filters import RapidataFilters
 from rapidata.rapidata_client.settings import RapidataSettings, RapidataSetting
@@ -114,9 +115,8 @@ class RapidataOrderManager:
 
         order = (order_builder
                  ._workflow(workflow)
-                 ._media(
-                     assets=assets,
-                     multi_metadata=multi_metadata
+                 ._datapoints(
+                     datapoints=[Datapoint(asset=asset, metadata=metadata) for asset, metadata in zip_longest(assets, multi_metadata)]
                      )
                  ._referee(referee)
                  ._filters(filters)

rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -2,7 +2,7 @@ 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.api_client.models.update_should_alert_model import UpdateShouldAlertModel
 
 class RapidataValidationSet:
     """A class for interacting with a Rapidata validation set.
@@ -39,6 +39,22 @@ class RapidataValidationSet:
         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
+    
+    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`.
+        """
+        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
 
     def __str__(self):
         return f"name: '{self.name}' id: {self.id}"

rapidata/rapidata_client/validation/rapids/rapids.py

@@ -1,5 +1,5 @@
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
-from rapidata.rapidata_client.metadata import Metadata
+from rapidata.rapidata_client.datapoints.assets import MediaAsset, TextAsset, MultiAsset
+from rapidata.rapidata_client.datapoints.metadata import Metadata
 from typing import Sequence, Any, cast
 from rapidata.api_client.models.add_validation_rapid_model import (
     AddValidationRapidModel,

rapidata/rapidata_client/validation/rapids/rapids_manager.py

@@ -1,7 +1,7 @@
 import os
 from rapidata.api_client import AttachCategoryTruth, BoundingBoxTruth, BoxShape, ClassifyPayload, ComparePayload, CompareTruth, LinePayload, LocateBoxTruth, LocatePayload, ScrubPayload, ScrubRange, ScrubTruth, TranscriptionPayload, TranscriptionTruth, TranscriptionWord
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
-from rapidata.rapidata_client.metadata import Metadata
+from rapidata.rapidata_client.datapoints.assets import MediaAsset, TextAsset, MultiAsset
+from rapidata.rapidata_client.datapoints.metadata import Metadata
 from rapidata.rapidata_client.validation.rapids.box import Box
 
 from typing import Sequence, Literal

rapidata/rapidata_client/validation/validation_set_manager.py

@@ -5,7 +5,7 @@ from rapidata.api_client.models.create_validation_set_model import CreateValidat
 from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.validation.rapids.rapids_manager import RapidsManager
 from rapidata.rapidata_client.validation.rapids.rapids import Rapid
-from rapidata.rapidata_client.metadata import PromptMetadata, MediaAssetMetadata
+from rapidata.rapidata_client.datapoints.metadata import PromptMetadata, MediaAssetMetadata
 
 from rapidata.api_client.models.page_info import PageInfo
 from rapidata.api_client.models.root_filter import RootFilter

rapidata/rapidata_client/workflow/_ranking_workflow.py

@@ -1,7 +1,7 @@
 from rapidata.api_client import CompareWorkflowModelPairMakerConfig, OnlinePairMakerConfigModel, EloConfigModel
 from rapidata.api_client.models.compare_workflow_model import CompareWorkflowModel
 from rapidata.rapidata_client.workflow._base_workflow import Workflow
-from rapidata.rapidata_client.metadata import PromptMetadata
+from rapidata.rapidata_client.datapoints.metadata import PromptMetadata
 from rapidata.api_client.models.dataset_dataset_id_datapoints_post_request_metadata_inner import DatasetDatasetIdDatapointsPostRequestMetadataInner
 
 

{rapidata-2.31.2.dist-info → rapidata-2.33.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.31.2
+Version: 2.33.0
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 Author: Rapidata AG