rapidata 2.29.1__py3-none-any.whl → 2.31.0__py3-none-any.whl

rapidata/rapidata_client/benchmark/rapidata_benchmark.py

@@ -1,3 +1,4 @@
+import re
 from rapidata.api_client.models.root_filter import RootFilter
 from rapidata.api_client.models.filter import Filter
 from rapidata.api_client.models.query_model import QueryModel
@@ -5,6 +6,10 @@ from rapidata.api_client.models.page_info import PageInfo
 from rapidata.api_client.models.create_leaderboard_model import CreateLeaderboardModel
 from rapidata.api_client.models.create_benchmark_participant_model import CreateBenchmarkParticipantModel
 from rapidata.api_client.models.submit_prompt_model import SubmitPromptModel
+from rapidata.api_client.models.submit_prompt_model_prompt_asset import SubmitPromptModelPromptAsset
+from rapidata.api_client.models.url_asset_input import UrlAssetInput
+from rapidata.api_client.models.file_asset_model import FileAssetModel
+from rapidata.api_client.models.source_url_metadata_model import SourceUrlMetadataModel
 
 from rapidata.rapidata_client.logging import logger
 from rapidata.service.openapi_service import OpenAPIService
@@ -29,7 +34,8 @@ class RapidataBenchmark:
         self.name = name
         self.id = id
         self.__openapi_service = openapi_service
-        self.__prompts: list[str] = []
+        self.__prompts: list[str | None] = []
+        self.__prompt_assets: list[str | None] = []
         self.__leaderboards: list[RapidataLeaderboard] = []
         self.__identifiers: list[str] = []
 
@@ -53,8 +59,16 @@ class RapidataBenchmark:
             
             total_pages = prompts_result.total_pages
             
-            self.__prompts.extend([prompt.prompt for prompt in prompts_result.items])
-            self.__identifiers.extend([prompt.identifier for prompt in prompts_result.items])
+            for prompt in prompts_result.items:
+                self.__prompts.append(prompt.prompt)
+                self.__identifiers.append(prompt.identifier)
+                if prompt.prompt_asset is None:
+                    self.__prompt_assets.append(None)
+                else:
+                    assert isinstance(prompt.prompt_asset.actual_instance, FileAssetModel)
+                    source_url = prompt.prompt_asset.actual_instance.metadata["sourceUrl"].actual_instance
+                    assert isinstance(source_url, SourceUrlMetadataModel)
+                    self.__prompt_assets.append(source_url.url)
             
             if current_page >= total_pages:
                 break
@@ -62,7 +76,14 @@ class RapidataBenchmark:
             current_page += 1
 
     @property
-    def prompts(self) -> list[str]:
+    def identifiers(self) -> list[str]:
+        if not self.__identifiers:
+            self.__instantiate_prompts()
+        
+        return self.__identifiers
+    
+    @property
+    def prompts(self) -> list[str | None]:
         """
         Returns the prompts that are registered for the leaderboard.
         """
@@ -72,11 +93,14 @@ class RapidataBenchmark:
         return self.__prompts
     
     @property
-    def identifiers(self) -> list[str]:
-        if not self.__identifiers:
+    def prompt_assets(self) -> list[str | None]:
+        """
+        Returns the prompt assets that are registered for the benchmark.
+        """
+        if not self.__prompt_assets:
             self.__instantiate_prompts()
         
-        return self.__identifiers
+        return self.__prompt_assets
     
     @property
     def leaderboards(self) -> list[RapidataLeaderboard]:
@@ -112,6 +136,7 @@ class RapidataBenchmark:
                         leaderboard.name, 
                         leaderboard.instruction, 
                         leaderboard.show_prompt, 
+                        leaderboard.show_prompt_asset,
                         leaderboard.is_inversed,
                         leaderboard.min_responses,
                         leaderboard.response_budget,
@@ -126,24 +151,49 @@ class RapidataBenchmark:
                 
         return self.__leaderboards
     
-    def add_prompt(self, identifier: str, prompt: str):
+    def add_prompt(self, identifier: str, prompt: str | None = None, asset: str | None = None):
         """
         Adds a prompt to the benchmark.
+
+        Args:
+            identifier: The identifier of the prompt/asset that will be used to match up the media.
+            prompt: The prompt that will be used to evaluate the model.
+            asset: The asset that will be used to evaluate the model. Provided as a link to the asset.
         """
-        if not isinstance(identifier, str) or not isinstance(prompt, str):
-            raise ValueError("Identifier and prompt must be strings.")
+        if not isinstance(identifier, str):
+            raise ValueError("Identifier must be a string.")
+        
+        if prompt is None and asset is None:
+            raise ValueError("Prompt or asset must be provided.")
+        
+        if prompt is not None and not isinstance(prompt, str):
+            raise ValueError("Prompt must be a string.")
+        
+        if asset is not None and not isinstance(asset, str):
+            raise ValueError("Asset must be a string. That is the link to the asset.")
         
         if identifier in self.identifiers:
             raise ValueError("Identifier already exists in the benchmark.")
         
+        if asset is not None and not re.match(r'^https?://', asset):
+            raise ValueError("Asset must be a link to the asset.")
+        
         self.__identifiers.append(identifier)
+
         self.__prompts.append(prompt)
+        self.__prompt_assets.append(asset)
 
         self.__openapi_service.benchmark_api.benchmark_benchmark_id_prompt_post(
             benchmark_id=self.id,
             submit_prompt_model=SubmitPromptModel(
                 identifier=identifier,
                 prompt=prompt,
+                promptAsset=SubmitPromptModelPromptAsset(
+                    UrlAssetInput(
+                        _t="UrlAssetInput",
+                        url=asset
+                    )
+                ) if asset is not None else None
             )
         )
 
@@ -151,7 +201,8 @@ class RapidataBenchmark:
         self, 
         name: str, 
         instruction: str, 
-        show_prompt: bool, 
+        show_prompt: bool = False,
+        show_prompt_asset: bool = False,
         inverse_ranking: bool = False,
         min_responses: int | None = None,
         response_budget: int | None = None
@@ -162,7 +213,8 @@ class RapidataBenchmark:
         Args:
             name: The name of the leaderboard. (not shown to the users)
             instruction: The instruction decides how the models will be evaluated.
-            show_prompt: Whether to show the prompt to the users.
+            show_prompt: Whether to show the prompt to the users. (default: False)
+            show_prompt_asset: Whether to show the prompt asset to the users. (only works if the prompt asset is a URL) (default: False)
             inverse_ranking: Whether to inverse the ranking of the leaderboard. (if the question is inversed, e.g. "Which video is worse?")
             min_responses: The minimum amount of responses that get collected per comparison. if None, it will be defaulted.
             response_budget: The total amount of responses that get collected per new model evaluation. if None, it will be defaulted. Values below 2000 are not recommended.
@@ -177,6 +229,7 @@ class RapidataBenchmark:
                 name=name,
                 instruction=instruction,
                 showPrompt=show_prompt,
+                showPromptAsset=show_prompt_asset,
                 isInversed=inverse_ranking,
                 minResponses=min_responses,
                 responseBudget=response_budget
@@ -189,6 +242,7 @@ class RapidataBenchmark:
             name,
             instruction,
             show_prompt,
+            show_prompt_asset,
             inverse_ranking,
             leaderboard_result.min_responses,
             leaderboard_result.response_budget,

rapidata/rapidata_client/benchmark/rapidata_benchmark_manager.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from rapidata.rapidata_client.benchmark.rapidata_benchmark import RapidataBenchmark
 from rapidata.api_client.models.create_benchmark_model import CreateBenchmarkModel
 from rapidata.service.openapi_service import OpenAPIService
@@ -24,27 +25,40 @@ class RapidataBenchmarkManager:
     def create_new_benchmark(self, 
                              name: str,
                              identifiers: list[str],
-                             prompts: list[str],
+                             prompts: Optional[list[str]] = None,
+                             prompt_assets: Optional[list[str]] = None,
                              ) -> RapidataBenchmark:
         """
-        Creates a new benchmark with the given name, prompts, and leaderboards.
+        Creates a new benchmark with the given name, identifiers, prompts, and media assets.
+
+        prompts or prompt_assets must be provided.
 
         Args:
             name: The name of the benchmark.
             prompts: The prompts that will be registered for the benchmark.
+            prompt_assets: The prompt assets that will be registered for the benchmark.
         """
         if not isinstance(name, str):
             raise ValueError("Name must be a string.")
         
-        if not isinstance(prompts, list) or not all(isinstance(prompt, str) for prompt in prompts):
+        if prompts and (not isinstance(prompts, list) or not all(isinstance(prompt, str) for prompt in prompts)):
             raise ValueError("Prompts must be a list of strings.")
         
+        if prompt_assets and (not isinstance(prompt_assets, list) or not all(isinstance(asset, str) for asset in prompt_assets)):
+            raise ValueError("Media assets must be a list of strings.")
+        
         if not isinstance(identifiers, list) or not all(isinstance(identifier, str) for identifier in identifiers):
             raise ValueError("Identifiers must be a list of strings.")
         
-        if len(identifiers) != len(prompts):
+        if prompts and len(identifiers) != len(prompts):
             raise ValueError("Identifiers and prompts must have the same length.")
         
+        if prompt_assets and len(identifiers) != len(prompt_assets):
+            raise ValueError("Identifiers and media assets must have the same length.")
+        
+        if not prompts and not prompt_assets:
+            raise ValueError("At least one of prompts or media assets must be provided.")
+        
         if len(set(identifiers)) != len(identifiers):
             raise ValueError("Identifiers must be unique.")
 
@@ -55,8 +69,12 @@ class RapidataBenchmarkManager:
         )
 
         benchmark = RapidataBenchmark(name, benchmark_result.id, self.__openapi_service)
-        for identifier, prompt in zip(identifiers, prompts):
-            benchmark.add_prompt(identifier, prompt)
+
+        prompts_list = prompts if prompts is not None else [None] * len(identifiers)
+        media_assets_list = prompt_assets if prompt_assets is not None else [None] * len(identifiers)
+
+        for identifier, prompt, asset in zip(identifiers, prompts_list, media_assets_list):
+            benchmark.add_prompt(identifier, prompt, asset)
 
         return benchmark
     

rapidata/rapidata_client/filter/__init__.py

@@ -8,5 +8,6 @@ from .user_score_filter import UserScoreFilter
 from .custom_filter import CustomFilter
 from .not_filter import NotFilter
 from .or_filter import OrFilter
+from .and_filter import AndFilter
 from .response_count_filter import ResponseCountFilter
 from .new_user_filter import NewUserFilter

rapidata/rapidata_client/filter/_base_filter.py

@@ -29,6 +29,26 @@ class RapidataFilter:
         else:
             return OrFilter([self, other])
 
+    def __and__(self, other):
+        """Enable the & operator to create AndFilter combinations."""
+        if not isinstance(other, RapidataFilter):
+            return NotImplemented
+        
+        from rapidata.rapidata_client.filter.and_filter import AndFilter
+        
+        # If self is already an AndFilter, extend its filters list
+        if isinstance(self, AndFilter):
+            if isinstance(other, AndFilter):
+                return AndFilter(self.filters + other.filters)
+            else:
+                return AndFilter(self.filters + [other])
+        # If other is an AndFilter, prepend self to its filters
+        elif isinstance(other, AndFilter):
+            return AndFilter([self] + other.filters)
+        # Neither is an AndFilter, create a new one
+        else:
+            return AndFilter([self, other])
+
     def __invert__(self):
         """Enable the ~ operator to create NotFilter negations."""
         from rapidata.rapidata_client.filter.not_filter import NotFilter

rapidata/rapidata_client/filter/and_filter.py

@@ -0,0 +1,30 @@
+from typing import Any
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from rapidata.api_client.models.and_user_filter_model import AndUserFilterModel
+from rapidata.api_client.models.and_user_filter_model_filters_inner import AndUserFilterModelFiltersInner
+
+
+class AndFilter(RapidataFilter):
+    """A filter that combines multiple filters with a logical AND operation.
+    This class implements a logical AND operation on a list of filters, where the condition is met if all of the filters' conditions are met.
+
+    Args:
+        filters (list[RapidataFilter]): A list of filters to be combined with AND.
+        
+    Example:
+        ```python
+        from rapidata import AndFilter, LanguageFilter, CountryFilter
+
+        AndFilter([LanguageFilter(["en"]), CountryFilter(["US"])]) 
+        ```
+
+        This will match users who have their phone set to English AND are located in the United States.
+    """
+    def __init__(self, filters: list[RapidataFilter]):
+        if not all(isinstance(filter, RapidataFilter) for filter in filters):
+            raise ValueError("Filters must be a RapidataFilter object")
+        
+        self.filters = filters
+
+    def _to_model(self):
+        return AndUserFilterModel(_t="AndFilter", filters=[AndUserFilterModelFiltersInner(filter._to_model()) for filter in self.filters])

rapidata/rapidata_client/filter/rapidata_filters.py

@@ -5,7 +5,8 @@ from rapidata.rapidata_client.filter import (
     LanguageFilter, 
     UserScoreFilter,
     NotFilter,
-    OrFilter)
+    OrFilter,
+    AndFilter)
 
 class RapidataFilters:
     """RapidataFilters Classes
@@ -25,6 +26,7 @@ class RapidataFilters:
         language (LanguageFilter): Filters for users with a specific language.
         not_filter (NotFilter): Inverts the filter.
         or_filter (OrFilter): Combines multiple filters with a logical OR operation.
+        and_filter (AndFilter): Combines multiple filters with a logical AND operation.
 
     Example:
         ```python
@@ -40,10 +42,10 @@ class RapidataFilters:
 
         ```python
         from rapidata import AgeFilter, LanguageFilter, CountryFilter
-        filters=[~AgeFilter([AgeGroup.UNDER_18]), CountryFilter(["US"]) | LanguageFilter(["en"])]
+        filters=[~AgeFilter([AgeGroup.UNDER_18]), CountryFilter(["US"]) | (CountryFilter(["CA"]) & LanguageFilter(["en"]))]
         ```
 
-        This would return users who are not under 18 years old and are from the US or whose phones are set to English.
+        This would return users who are not under 18 years old and are from the US or who are from Canada and whose phones are set to English.
     """
     user_score = UserScoreFilter
     age = AgeFilter 
@@ -52,3 +54,4 @@ class RapidataFilters:
     language = LanguageFilter
     not_filter = NotFilter
     or_filter = OrFilter
+    and_filter = AndFilter

rapidata/rapidata_client/order/_rapidata_order_builder.py

@@ -58,7 +58,7 @@ class RapidataOrderBuilder:
         self.__settings: Sequence[RapidataSetting] | None = None
         self.__user_filters: list[RapidataFilter] = []
         self.__selections: list[RapidataSelection] = []
-        self.__priority: int = 50
+        self.__priority: int | None = None
         self.__assets: Sequence[BaseAsset] = []
 
     def _to_model(self) -> CreateOrderModel:
@@ -93,10 +93,14 @@ class RapidataOrderBuilder:
                 if self.__settings is not None
                 else None
             ),
-            selections=[
-                AbTestSelectionAInner(selection._to_model())
-                for selection in self.__selections
-            ],
+            selections=(
+                [
+                    AbTestSelectionAInner(selection._to_model())
+                    for selection in self.__selections
+                ]
+                if self.__selections
+                else None
+            ),
             priority=self.__priority,
         )
 
@@ -276,7 +280,7 @@ class RapidataOrderBuilder:
         self.__user_filters = filters
         return self
 
-    def _validation_set_id(self, validation_set_id: str) -> "RapidataOrderBuilder":
+    def _validation_set_id(self, validation_set_id: str | None = None) -> "RapidataOrderBuilder":
         """
         Set the validation set ID for the order.
 
@@ -286,7 +290,7 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
-        if not isinstance(validation_set_id, str):
+        if validation_set_id is not None and not isinstance(validation_set_id, str):
             raise TypeError("Validation set ID must be of type str.")
 
         self.__validation_set_id = validation_set_id
@@ -329,7 +333,7 @@ class RapidataOrderBuilder:
         self.__selections = selections  # type: ignore
         return self
 
-    def _priority(self, priority: int) -> "RapidataOrderBuilder":
+    def _priority(self, priority: int | None = None) -> "RapidataOrderBuilder":
         """
         Set the priority for the order.
 
@@ -339,7 +343,7 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
-        if not isinstance(priority, int):
+        if priority is not None and not isinstance(priority, int):
             raise TypeError("Priority must be of type int.")
 
         self.__priority = priority

rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -53,13 +53,8 @@ class RapidataOrderManager:
         self.filters = RapidataFilters
         self.settings = RapidataSettings
         self.selections = RapidataSelections
-        self.__priority = 50
+        self.__priority: int | None = None
         logger.debug("RapidataOrderManager initialized")
-
-    def __get_selections(self, validation_set_id: str | None, labeling_amount=3) -> Sequence[RapidataSelection]:
-        if validation_set_id:
-            return [ValidationSelection(validation_set_id=validation_set_id), LabelingSelection(amount=labeling_amount-1)]
-        return [LabelingSelection(amount=labeling_amount)]
     
     def _create_general_order(self,
             name: str,
@@ -75,7 +70,6 @@ class RapidataOrderManager:
             sentences: list[str] | None = None,
             selections: Sequence[RapidataSelection] = [],
             private_notes: list[str] | None = None,
-            default_labeling_amount: int = 3
         ) -> RapidataOrder:
 
         if not assets:
@@ -108,9 +102,6 @@ class RapidataOrderManager:
 
         if selections and validation_set_id:
             logger.warning("Warning: Both selections and validation_set_id provided. Ignoring validation_set_id.")
-        
-        if not selections:
-            selections = self.__get_selections(validation_set_id, labeling_amount=default_labeling_amount)
 
         prompts_metadata = [PromptMetadata(prompt=prompt) for prompt in contexts] if contexts else None
         sentence_metadata = [SelectWordsMetadata(select_words=sentence) for sentence in sentences] if sentences else None
@@ -135,6 +126,7 @@ class RapidataOrderManager:
                  ._filters(filters)
                  ._selections(selections) 
                  ._settings(settings)
+                 ._validation_set_id(validation_set_id if not selections else None)
                  ._priority(self.__priority)
                  ._create()
                  )
@@ -398,7 +390,6 @@ class RapidataOrderManager:
             filters=filters,
             selections=selections,
             settings=settings,
-            default_labeling_amount=1,
             private_notes=private_notes
         )
     
@@ -451,7 +442,6 @@ class RapidataOrderManager:
             selections=selections,
             settings=settings,
             sentences=sentences,
-            default_labeling_amount=2,
             private_notes=private_notes
         )
     
@@ -623,7 +613,6 @@ class RapidataOrderManager:
             filters=filters,
             selections=selections,
             settings=settings,
-            default_labeling_amount=2,
             private_notes=private_notes
         )
 

rapidata/rapidata_client/validation/rapids/rapids.py

@@ -1,14 +1,9 @@
-from pydantic import StrictBytes, StrictStr
 from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
 from rapidata.rapidata_client.metadata import Metadata
-from typing import Sequence
-from typing import Any
+from typing import Sequence, Any, cast
 from rapidata.api_client.models.add_validation_rapid_model import (
     AddValidationRapidModel,
 )
-from rapidata.api_client.models.add_validation_text_rapid_model import (
-    AddValidationTextRapidModel,
-)
 from rapidata.api_client.models.add_validation_rapid_model_payload import (
     AddValidationRapidModelPayload,
 )
@@ -32,38 +27,52 @@ class Rapid():
         logger.debug(f"Created Rapid with asset: {self.asset}, metadata: {self.metadata}, payload: {self.payload}, truth: {self.truth}, randomCorrectProbability: {self.randomCorrectProbability}, explanation: {self.explanation}")
 
     def _add_to_validation_set(self, validationSetId: str, openapi_service: OpenAPIService) -> None:
-        if isinstance(self.asset, TextAsset) or (isinstance(self.asset, MultiAsset) and isinstance(self.asset.assets[0], TextAsset)):
-            openapi_service.validation_api.validation_set_validation_set_id_rapid_texts_post(
+        model = self.__to_model()
+        assets = self.__convert_to_assets()
+        if isinstance(assets[0], TextAsset):
+            assert all(isinstance(asset, TextAsset) for asset in assets)
+            texts = cast(list[TextAsset], assets)
+            openapi_service.validation_api.validation_set_validation_set_id_rapid_post(
                 validation_set_id=validationSetId,
-                add_validation_text_rapid_model=self.__to_text_model()
+                model=model,
+                texts=[asset.text for asset in texts]
             )
 
-        elif isinstance(self.asset, MediaAsset) or (isinstance(self.asset, MultiAsset) and isinstance(self.asset.assets[0], MediaAsset)):
-            model = self.__to_media_model()
-            openapi_service.validation_api.validation_set_validation_set_id_rapid_files_post(
+        elif isinstance(assets[0], MediaAsset):
+            assert all(isinstance(asset, MediaAsset) for asset in assets)
+            files = cast(list[MediaAsset], assets)
+            openapi_service.validation_api.validation_set_validation_set_id_rapid_post(
                 validation_set_id=validationSetId,
-                model=model[0], files=model[1]
+                model=model,
+                files=[asset.to_file() for asset in files],
+                urls=[asset.path for asset in files if not asset.is_local()]
             )
             
         else:
             raise TypeError("The asset must be a MediaAsset, TextAsset, or MultiAsset")
-
-    def __to_media_model(self) -> tuple[AddValidationRapidModel, list[StrictStr | tuple[StrictStr, StrictBytes] | StrictBytes]]:
-        assets: list[MediaAsset] = [] 
+        
+    
+    def __convert_to_assets(self) -> list[MediaAsset | TextAsset]:
+        assets: list[MediaAsset | TextAsset] = [] 
         if isinstance(self.asset, MultiAsset):
             for asset in self.asset.assets:
                 if isinstance(asset, MediaAsset):
                     assets.append(asset)
+                elif isinstance(asset, TextAsset):
+                    assets.append(asset)
                 else:
-                    raise TypeError("The asset is a multiasset, but not all assets are MediaAssets")
+                    raise TypeError("The asset is a multiasset, but not all assets are MediaAssets or TextAssets")
 
         if isinstance(self.asset, TextAsset):
-            raise TypeError("The asset must contain Media")
+            assets = [self.asset]
 
         if isinstance(self.asset, MediaAsset):
             assets = [self.asset]
 
-        return (AddValidationRapidModel(
+        return assets
+
+    def __to_model(self) -> AddValidationRapidModel:
+        return AddValidationRapidModel(
             payload=AddValidationRapidModelPayload(self.payload),
             truth=AddValidationRapidModelTruth(self.truth),
             metadata=[
@@ -72,31 +81,4 @@ class Rapid():
             ],
             randomCorrectProbability=self.randomCorrectProbability,
             explanation=self.explanation
-        ), [asset.to_file() for asset in assets])
-
-    def __to_text_model(self) -> AddValidationTextRapidModel:
-        texts: list[str] = []
-        if isinstance(self.asset, MultiAsset):
-            for asset in self.asset.assets:
-                if isinstance(asset, TextAsset):
-                    texts.append(asset.text)
-                else:
-                    raise TypeError("The asset is a multiasset, but not all assets are TextAssets")
-
-        if isinstance(self.asset, MediaAsset):
-            raise TypeError("The asset must contain Text")
-
-        if isinstance(self.asset, TextAsset):
-            texts = [self.asset.text]
-
-        return AddValidationTextRapidModel(
-          payload=AddValidationRapidModelPayload(self.payload),
-          truth=AddValidationRapidModelTruth(self.truth),
-          metadata=[
-              DatasetDatasetIdDatapointsPostRequestMetadataInner(meta.to_model())
-              for meta in self.metadata
-          ],
-          randomCorrectProbability=self.randomCorrectProbability,
-          texts=texts,
-          explanation=self.explanation
-      )
+        )

rapidata/rapidata_client/validation/validation_set_manager.py

@@ -11,7 +11,6 @@ from rapidata.api_client.models.page_info import PageInfo
 from rapidata.api_client.models.root_filter import RootFilter
 from rapidata.api_client.models.filter import Filter
 from rapidata.api_client.models.sort_criterion import SortCriterion
-from urllib3._collections import HTTPHeaderDict # type: ignore[import]
 
 from rapidata.rapidata_client.validation.rapids.box import Box
 
@@ -527,9 +526,17 @@ class ValidationSetManager:
         )
 
         logger.debug("Adding rapids to validation set")
+        failed_rapids = []
         for rapid in tqdm(rapids, desc="Uploading validation tasks", disable=RapidataOutputManager.silent_mode):
-            validation_set.add_rapid(rapid)
-        
+            try: 
+                validation_set.add_rapid(rapid)
+            except Exception:
+                failed_rapids.append(rapid.asset)
+
+        if failed_rapids:
+            logger.error(f"Failed to add {len(failed_rapids)} datapoints to validation set: {failed_rapids}")
+            raise RuntimeError(f"Failed to add {len(failed_rapids)} datapoints to validation set: {failed_rapids}")
+
         managed_print()
         managed_print(f"Validation set '{name}' created with ID {validation_set_id}\n",
                 f"Now viewable under: https://app.{self.__openapi_service.environment}/validation-set/detail/{validation_set_id}",

{rapidata-2.29.1.dist-info → rapidata-2.31.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.29.1
+Version: 2.31.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