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

rapidata/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.30.0"
+__version__ = "2.31.0"
 
 from .rapidata_client import (
     RapidataClient,

rapidata/api_client/api/benchmark_api.py

@@ -1650,6 +1650,273 @@ class BenchmarkApi:
 
 
 
+    @validate_call
+    def benchmark_benchmark_id_participants_participant_id_disable_post(
+        self,
+        benchmark_id: Annotated[StrictStr, Field(description="The benchmark the participant belongs to")],
+        participant_id: Annotated[StrictStr, Field(description="The id of the participant to be disabled")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> None:
+        """This endpoint disables a participant in a benchmark. this means that the participant will no longer actively be matched up against other participants and not collect further results. It will still be visible in the leaderboard.
+
+
+        :param benchmark_id: The benchmark the participant belongs to (required)
+        :type benchmark_id: str
+        :param participant_id: The id of the participant to be disabled (required)
+        :type participant_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._benchmark_benchmark_id_participants_participant_id_disable_post_serialize(
+            benchmark_id=benchmark_id,
+            participant_id=participant_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def benchmark_benchmark_id_participants_participant_id_disable_post_with_http_info(
+        self,
+        benchmark_id: Annotated[StrictStr, Field(description="The benchmark the participant belongs to")],
+        participant_id: Annotated[StrictStr, Field(description="The id of the participant to be disabled")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[None]:
+        """This endpoint disables a participant in a benchmark. this means that the participant will no longer actively be matched up against other participants and not collect further results. It will still be visible in the leaderboard.
+
+
+        :param benchmark_id: The benchmark the participant belongs to (required)
+        :type benchmark_id: str
+        :param participant_id: The id of the participant to be disabled (required)
+        :type participant_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._benchmark_benchmark_id_participants_participant_id_disable_post_serialize(
+            benchmark_id=benchmark_id,
+            participant_id=participant_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def benchmark_benchmark_id_participants_participant_id_disable_post_without_preload_content(
+        self,
+        benchmark_id: Annotated[StrictStr, Field(description="The benchmark the participant belongs to")],
+        participant_id: Annotated[StrictStr, Field(description="The id of the participant to be disabled")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """This endpoint disables a participant in a benchmark. this means that the participant will no longer actively be matched up against other participants and not collect further results. It will still be visible in the leaderboard.
+
+
+        :param benchmark_id: The benchmark the participant belongs to (required)
+        :type benchmark_id: str
+        :param participant_id: The id of the participant to be disabled (required)
+        :type participant_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._benchmark_benchmark_id_participants_participant_id_disable_post_serialize(
+            benchmark_id=benchmark_id,
+            participant_id=participant_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _benchmark_benchmark_id_participants_participant_id_disable_post_serialize(
+        self,
+        benchmark_id,
+        participant_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if benchmark_id is not None:
+            _path_params['benchmarkId'] = benchmark_id
+        if participant_id is not None:
+            _path_params['participantId'] = participant_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/benchmark/{benchmarkId}/participants/{participantId}/disable',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
     @validate_call
     def benchmark_benchmark_id_participants_participant_id_submit_post(
         self,

rapidata/api_client/api/dataset_api.py

@@ -1195,8 +1195,8 @@ class DatasetApi:
     def dataset_dataset_id_datapoints_post(
         self,
         dataset_id: Annotated[StrictStr, Field(description="The id of the dataset")],
-        prompt_asset: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The prompt asset is a file that can be added to the prompt metadata of the asset.")] = None,
-        file: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The files to upload from the local storage. Must be either images or videos.")] = None,
+        prompt_asset: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        file: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
         text: Annotated[Optional[List[StrictStr]], Field(description="The texts to upload. The length limit is set at 256 characters per text.")] = None,
         url: Annotated[Optional[List[StrictStr]], Field(description="Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>")] = None,
         metadata: Annotated[Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]], Field(description="Optional metadata to attach to the datapoint.")] = None,
@@ -1220,9 +1220,9 @@ class DatasetApi:
 
         :param dataset_id: The id of the dataset (required)
         :type dataset_id: str
-        :param prompt_asset: The prompt asset is a file that can be added to the prompt metadata of the asset.
+        :param prompt_asset:
         :type prompt_asset: List[bytearray]
-        :param file: The files to upload from the local storage. Must be either images or videos.
+        :param file:
         :type file: List[bytearray]
         :param text: The texts to upload. The length limit is set at 256 characters per text.
         :type text: List[str]
@@ -1286,8 +1286,8 @@ class DatasetApi:
     def dataset_dataset_id_datapoints_post_with_http_info(
         self,
         dataset_id: Annotated[StrictStr, Field(description="The id of the dataset")],
-        prompt_asset: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The prompt asset is a file that can be added to the prompt metadata of the asset.")] = None,
-        file: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The files to upload from the local storage. Must be either images or videos.")] = None,
+        prompt_asset: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        file: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
         text: Annotated[Optional[List[StrictStr]], Field(description="The texts to upload. The length limit is set at 256 characters per text.")] = None,
         url: Annotated[Optional[List[StrictStr]], Field(description="Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>")] = None,
         metadata: Annotated[Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]], Field(description="Optional metadata to attach to the datapoint.")] = None,
@@ -1311,9 +1311,9 @@ class DatasetApi:
 
         :param dataset_id: The id of the dataset (required)
         :type dataset_id: str
-        :param prompt_asset: The prompt asset is a file that can be added to the prompt metadata of the asset.
+        :param prompt_asset:
         :type prompt_asset: List[bytearray]
-        :param file: The files to upload from the local storage. Must be either images or videos.
+        :param file:
         :type file: List[bytearray]
         :param text: The texts to upload. The length limit is set at 256 characters per text.
         :type text: List[str]
@@ -1377,8 +1377,8 @@ class DatasetApi:
     def dataset_dataset_id_datapoints_post_without_preload_content(
         self,
         dataset_id: Annotated[StrictStr, Field(description="The id of the dataset")],
-        prompt_asset: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The prompt asset is a file that can be added to the prompt metadata of the asset.")] = None,
-        file: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The files to upload from the local storage. Must be either images or videos.")] = None,
+        prompt_asset: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        file: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
         text: Annotated[Optional[List[StrictStr]], Field(description="The texts to upload. The length limit is set at 256 characters per text.")] = None,
         url: Annotated[Optional[List[StrictStr]], Field(description="Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>")] = None,
         metadata: Annotated[Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]], Field(description="Optional metadata to attach to the datapoint.")] = None,
@@ -1402,9 +1402,9 @@ class DatasetApi:
 
         :param dataset_id: The id of the dataset (required)
         :type dataset_id: str
-        :param prompt_asset: The prompt asset is a file that can be added to the prompt metadata of the asset.
+        :param prompt_asset:
         :type prompt_asset: List[bytearray]
-        :param file: The files to upload from the local storage. Must be either images or videos.
+        :param file:
         :type file: List[bytearray]
         :param text: The texts to upload. The length limit is set at 256 characters per text.
         :type text: List[str]
@@ -1478,8 +1478,8 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
-            'promptAsset': 'csv',
-            'file': 'csv',
+            'promptAsset': 'multi',
+            'file': 'multi',
             'text': 'multi',
             'url': 'multi',
             'metadata': 'multi',

rapidata/api_client/api/validation_set_api.py

@@ -1402,7 +1402,7 @@ class ValidationSetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> AddValidationRapidResult:
-        """Adds a new validation rapid to the specified validation set using files to create the assets.
+        """(Deprecated) Adds a new validation rapid to the specified validation set using files to create the assets.
 
 
         :param validation_set_id: The ID of the validation set to add the rapid to. (required)
@@ -1432,6 +1432,7 @@ class ValidationSetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /validation-set/{validationSetId}/rapid/files is deprecated.", DeprecationWarning)
 
         _param = self._validation_set_validation_set_id_rapid_files_post_serialize(
             validation_set_id=validation_set_id,
@@ -1476,7 +1477,7 @@ class ValidationSetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[AddValidationRapidResult]:
-        """Adds a new validation rapid to the specified validation set using files to create the assets.
+        """(Deprecated) Adds a new validation rapid to the specified validation set using files to create the assets.
 
 
         :param validation_set_id: The ID of the validation set to add the rapid to. (required)
@@ -1506,6 +1507,7 @@ class ValidationSetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /validation-set/{validationSetId}/rapid/files is deprecated.", DeprecationWarning)
 
         _param = self._validation_set_validation_set_id_rapid_files_post_serialize(
             validation_set_id=validation_set_id,
@@ -1550,7 +1552,7 @@ class ValidationSetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Adds a new validation rapid to the specified validation set using files to create the assets.
+        """(Deprecated) Adds a new validation rapid to the specified validation set using files to create the assets.
 
 
         :param validation_set_id: The ID of the validation set to add the rapid to. (required)
@@ -1580,6 +1582,7 @@ class ValidationSetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /validation-set/{validationSetId}/rapid/files is deprecated.", DeprecationWarning)
 
         _param = self._validation_set_validation_set_id_rapid_files_post_serialize(
             validation_set_id=validation_set_id,
@@ -1688,6 +1691,343 @@ class ValidationSetApi:
 
 
 
+    @validate_call
+    def validation_set_validation_set_id_rapid_post(
+        self,
+        validation_set_id: Annotated[StrictStr, Field(description="The ID of the validation set to add the rapid to.")],
+        model: Optional[AddValidationRapidModel] = None,
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        texts: Annotated[Optional[List[StrictStr]], Field(description="The texts to use for the rapid.")] = None,
+        urls: Annotated[Optional[List[StrictStr]], Field(description="The urls to use for the rapid")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> AddValidationRapidResult:
+        """Adds a new validation rapid to the specified validation set using files to create the assets.
+
+
+        :param validation_set_id: The ID of the validation set to add the rapid to. (required)
+        :type validation_set_id: str
+        :param model:
+        :type model: AddValidationRapidModel
+        :param files:
+        :type files: List[bytearray]
+        :param texts: The texts to use for the rapid.
+        :type texts: List[str]
+        :param urls: The urls to use for the rapid
+        :type urls: List[str]
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._validation_set_validation_set_id_rapid_post_serialize(
+            validation_set_id=validation_set_id,
+            model=model,
+            files=files,
+            texts=texts,
+            urls=urls,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "AddValidationRapidResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def validation_set_validation_set_id_rapid_post_with_http_info(
+        self,
+        validation_set_id: Annotated[StrictStr, Field(description="The ID of the validation set to add the rapid to.")],
+        model: Optional[AddValidationRapidModel] = None,
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        texts: Annotated[Optional[List[StrictStr]], Field(description="The texts to use for the rapid.")] = None,
+        urls: Annotated[Optional[List[StrictStr]], Field(description="The urls to use for the rapid")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[AddValidationRapidResult]:
+        """Adds a new validation rapid to the specified validation set using files to create the assets.
+
+
+        :param validation_set_id: The ID of the validation set to add the rapid to. (required)
+        :type validation_set_id: str
+        :param model:
+        :type model: AddValidationRapidModel
+        :param files:
+        :type files: List[bytearray]
+        :param texts: The texts to use for the rapid.
+        :type texts: List[str]
+        :param urls: The urls to use for the rapid
+        :type urls: List[str]
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._validation_set_validation_set_id_rapid_post_serialize(
+            validation_set_id=validation_set_id,
+            model=model,
+            files=files,
+            texts=texts,
+            urls=urls,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "AddValidationRapidResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def validation_set_validation_set_id_rapid_post_without_preload_content(
+        self,
+        validation_set_id: Annotated[StrictStr, Field(description="The ID of the validation set to add the rapid to.")],
+        model: Optional[AddValidationRapidModel] = None,
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        texts: Annotated[Optional[List[StrictStr]], Field(description="The texts to use for the rapid.")] = None,
+        urls: Annotated[Optional[List[StrictStr]], Field(description="The urls to use for the rapid")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Adds a new validation rapid to the specified validation set using files to create the assets.
+
+
+        :param validation_set_id: The ID of the validation set to add the rapid to. (required)
+        :type validation_set_id: str
+        :param model:
+        :type model: AddValidationRapidModel
+        :param files:
+        :type files: List[bytearray]
+        :param texts: The texts to use for the rapid.
+        :type texts: List[str]
+        :param urls: The urls to use for the rapid
+        :type urls: List[str]
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._validation_set_validation_set_id_rapid_post_serialize(
+            validation_set_id=validation_set_id,
+            model=model,
+            files=files,
+            texts=texts,
+            urls=urls,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "AddValidationRapidResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _validation_set_validation_set_id_rapid_post_serialize(
+        self,
+        validation_set_id,
+        model,
+        files,
+        texts,
+        urls,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            'files': 'multi',
+            'texts': 'multi',
+            'urls': 'multi',
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if validation_set_id is not None:
+            _path_params['validationSetId'] = validation_set_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        if model is not None:
+            _form_params.append(('model', model))
+        if files is not None:
+            _files['files'] = files
+        if texts is not None:
+            _form_params.append(('texts', texts))
+        if urls is not None:
+            _form_params.append(('urls', urls))
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'text/plain', 
+                    'application/json', 
+                    'text/json'
+                ]
+            )
+
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'multipart/form-data'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/validation-set/{validationSetId}/rapid',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
     @validate_call
     def validation_set_validation_set_id_rapid_texts_post(
         self,
@@ -1706,7 +2046,7 @@ class ValidationSetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> AddValidationRapidResult:
-        """Adds a new validation rapid to the specified validation set using text sources to create the assets.
+        """(Deprecated) Adds a new validation rapid to the specified validation set using text sources to create the assets.
 
 
         :param validation_set_id: The ID of the validation set to add the rapid to. (required)
@@ -1734,6 +2074,7 @@ class ValidationSetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /validation-set/{validationSetId}/rapid/texts is deprecated.", DeprecationWarning)
 
         _param = self._validation_set_validation_set_id_rapid_texts_post_serialize(
             validation_set_id=validation_set_id,
@@ -1776,7 +2117,7 @@ class ValidationSetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[AddValidationRapidResult]:
-        """Adds a new validation rapid to the specified validation set using text sources to create the assets.
+        """(Deprecated) Adds a new validation rapid to the specified validation set using text sources to create the assets.
 
 
         :param validation_set_id: The ID of the validation set to add the rapid to. (required)
@@ -1804,6 +2145,7 @@ class ValidationSetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /validation-set/{validationSetId}/rapid/texts is deprecated.", DeprecationWarning)
 
         _param = self._validation_set_validation_set_id_rapid_texts_post_serialize(
             validation_set_id=validation_set_id,
@@ -1846,7 +2188,7 @@ class ValidationSetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Adds a new validation rapid to the specified validation set using text sources to create the assets.
+        """(Deprecated) Adds a new validation rapid to the specified validation set using text sources to create the assets.
 
 
         :param validation_set_id: The ID of the validation set to add the rapid to. (required)
@@ -1874,6 +2216,7 @@ class ValidationSetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /validation-set/{validationSetId}/rapid/texts is deprecated.", DeprecationWarning)
 
         _param = self._validation_set_validation_set_id_rapid_texts_post_serialize(
             validation_set_id=validation_set_id,

rapidata/api_client/models/get_standing_by_id_result.py

@@ -17,7 +17,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional, Union
 from typing import Optional, Set
 from typing_extensions import Self
@@ -31,10 +31,11 @@ class GetStandingByIdResult(BaseModel):
     benchmark_id: StrictStr = Field(alias="benchmarkId")
     dataset_id: StrictStr = Field(alias="datasetId")
     status: StrictStr
+    is_disabled: StrictBool = Field(alias="isDisabled")
     score: Optional[Union[StrictFloat, StrictInt]] = None
     wins: StrictInt
     total_matches: StrictInt = Field(alias="totalMatches")
-    __properties: ClassVar[List[str]] = ["id", "name", "benchmarkId", "datasetId", "status", "score", "wins", "totalMatches"]
+    __properties: ClassVar[List[str]] = ["id", "name", "benchmarkId", "datasetId", "status", "isDisabled", "score", "wins", "totalMatches"]
 
     @field_validator('status')
     def status_validate_enum(cls, value):
@@ -104,6 +105,7 @@ class GetStandingByIdResult(BaseModel):
             "benchmarkId": obj.get("benchmarkId"),
             "datasetId": obj.get("datasetId"),
             "status": obj.get("status"),
+            "isDisabled": obj.get("isDisabled"),
             "score": obj.get("score"),
             "wins": obj.get("wins"),
             "totalMatches": obj.get("totalMatches")

rapidata/api_client/models/participant_by_benchmark.py

@@ -36,8 +36,8 @@ class ParticipantByBenchmark(BaseModel):
     @field_validator('status')
     def status_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['Created', 'Submitted']):
-            raise ValueError("must be one of enum values ('Created', 'Submitted')")
+        if value not in set(['Created', 'Submitted', 'Disabled']):
+            raise ValueError("must be one of enum values ('Created', 'Submitted', 'Disabled')")
         return value
 
     model_config = ConfigDict(

rapidata/api_client/models/participant_status.py

@@ -28,6 +28,7 @@ class ParticipantStatus(str, Enum):
     """
     CREATED = 'Created'
     SUBMITTED = 'Submitted'
+    DISABLED = 'Disabled'
 
     @classmethod
     def from_json(cls, json_str: str) -> Self:

rapidata/api_client/models/standing_by_leaderboard.py

@@ -17,7 +17,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional, Union
 from typing import Optional, Set
 from typing_extensions import Self
@@ -34,7 +34,8 @@ class StandingByLeaderboard(BaseModel):
     score: Optional[Union[StrictFloat, StrictInt]] = None
     wins: StrictInt
     total_matches: StrictInt = Field(alias="totalMatches")
-    __properties: ClassVar[List[str]] = ["id", "name", "leaderboardId", "datasetId", "status", "score", "wins", "totalMatches"]
+    is_disabled: StrictBool = Field(alias="isDisabled")
+    __properties: ClassVar[List[str]] = ["id", "name", "leaderboardId", "datasetId", "status", "score", "wins", "totalMatches", "isDisabled"]
 
     @field_validator('status')
     def status_validate_enum(cls, value):
@@ -106,7 +107,8 @@ class StandingByLeaderboard(BaseModel):
             "status": obj.get("status"),
             "score": obj.get("score"),
             "wins": obj.get("wins"),
-            "totalMatches": obj.get("totalMatches")
+            "totalMatches": obj.get("totalMatches"),
+            "isDisabled": obj.get("isDisabled")
         })
         return _obj
 

rapidata/api_client_README.md

@@ -78,6 +78,7 @@ Class | Method | HTTP request | Description
 *BenchmarkApi* | [**benchmark_benchmark_id_participant_participant_id_delete**](rapidata/api_client/docs/BenchmarkApi.md#benchmark_benchmark_id_participant_participant_id_delete) | **DELETE** /benchmark/{benchmarkId}/participant/{participantId} | Deletes a participant on a benchmark.
 *BenchmarkApi* | [**benchmark_benchmark_id_participant_participant_id_get**](rapidata/api_client/docs/BenchmarkApi.md#benchmark_benchmark_id_participant_participant_id_get) | **GET** /benchmark/{benchmarkId}/participant/{participantId} | Gets a participant by it's Id.
 *BenchmarkApi* | [**benchmark_benchmark_id_participants_get**](rapidata/api_client/docs/BenchmarkApi.md#benchmark_benchmark_id_participants_get) | **GET** /benchmark/{benchmarkId}/participants | Query all participants within a benchmark
+*BenchmarkApi* | [**benchmark_benchmark_id_participants_participant_id_disable_post**](rapidata/api_client/docs/BenchmarkApi.md#benchmark_benchmark_id_participants_participant_id_disable_post) | **POST** /benchmark/{benchmarkId}/participants/{participantId}/disable | This endpoint disables a participant in a benchmark. this means that the participant will no longer actively be matched up against other participants and not collect further results. It will still be visible in the leaderboard.
 *BenchmarkApi* | [**benchmark_benchmark_id_participants_participant_id_submit_post**](rapidata/api_client/docs/BenchmarkApi.md#benchmark_benchmark_id_participants_participant_id_submit_post) | **POST** /benchmark/{benchmarkId}/participants/{participantId}/submit | Submits a participant to a benchmark.
 *BenchmarkApi* | [**benchmark_benchmark_id_participants_post**](rapidata/api_client/docs/BenchmarkApi.md#benchmark_benchmark_id_participants_post) | **POST** /benchmark/{benchmarkId}/participants | Creates a participant in a benchmark.
 *BenchmarkApi* | [**benchmark_benchmark_id_prompt_post**](rapidata/api_client/docs/BenchmarkApi.md#benchmark_benchmark_id_prompt_post) | **POST** /benchmark/{benchmarkId}/prompt | Adds a new prompt to a benchmark.
@@ -184,6 +185,7 @@ Class | Method | HTTP request | Description
 *ValidationSetApi* | [**validation_set_validation_set_id_export_get**](rapidata/api_client/docs/ValidationSetApi.md#validation_set_validation_set_id_export_get) | **GET** /validation-set/{validationSetId}/export | Exports all rapids of a validation-set to a file.
 *ValidationSetApi* | [**validation_set_validation_set_id_get**](rapidata/api_client/docs/ValidationSetApi.md#validation_set_validation_set_id_get) | **GET** /validation-set/{validationSetId} | Gets a validation set by the id.
 *ValidationSetApi* | [**validation_set_validation_set_id_rapid_files_post**](rapidata/api_client/docs/ValidationSetApi.md#validation_set_validation_set_id_rapid_files_post) | **POST** /validation-set/{validationSetId}/rapid/files | Adds a new validation rapid to the specified validation set using files to create the assets.
+*ValidationSetApi* | [**validation_set_validation_set_id_rapid_post**](rapidata/api_client/docs/ValidationSetApi.md#validation_set_validation_set_id_rapid_post) | **POST** /validation-set/{validationSetId}/rapid | Adds a new validation rapid to the specified validation set using files to create the assets.
 *ValidationSetApi* | [**validation_set_validation_set_id_rapid_texts_post**](rapidata/api_client/docs/ValidationSetApi.md#validation_set_validation_set_id_rapid_texts_post) | **POST** /validation-set/{validationSetId}/rapid/texts | Adds a new validation rapid to the specified validation set using text sources to create the assets.
 *ValidationSetApi* | [**validation_set_validation_set_id_rapids_get**](rapidata/api_client/docs/ValidationSetApi.md#validation_set_validation_set_id_rapids_get) | **GET** /validation-set/{validationSetId}/rapids | Queries the validation rapids for a specific validation set.
 *ValidationSetApi* | [**validation_set_zip_compare_post**](rapidata/api_client/docs/ValidationSetApi.md#validation_set_zip_compare_post) | **POST** /validation-set/zip/compare | Imports a compare validation set from a zip file.

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/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.30.0.dist-info → rapidata-2.31.0.dist-info}/METADATA

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

{rapidata-2.30.0.dist-info → rapidata-2.31.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
-rapidata/__init__.py,sha256=lZGJTZWN6zdNSbKfUglVkPO3Hr0Buj1qlU9GBGUYxq4,865
+rapidata/__init__.py,sha256=1J7X3wXGT2IlF9-Mt576ztUEGkXceBvfVxybgbO52wE,865
 rapidata/api_client/__init__.py,sha256=BgSOExnifSldFqbuk1ZWdHbrLKlntelU0IjKYUFf3MM,33738
 rapidata/api_client/api/__init__.py,sha256=V_nI5gljvhY0TmFLOdzpys9e1l9J6PokA8IxeYmynyg,1422
-rapidata/api_client/api/benchmark_api.py,sha256=cHyMXlPRmOq0a4ltq4neuCOnIALQ4gEgTIJloIKCejI,129276
+rapidata/api_client/api/benchmark_api.py,sha256=1TzLL4lratyFaFbNiCtfW8l_yIRRil4u6xpvM0250UE,140976
 rapidata/api_client/api/campaign_api.py,sha256=406gNDALFb0sJhfx727ZM5_0GDX4iB0w5ym2dExLm4g,49894
 rapidata/api_client/api/client_api.py,sha256=KKgUrEKfqmEAqUCRqcYKRb6G3GLwD6R-JSUsShmo7r8,54313
 rapidata/api_client/api/coco_api.py,sha256=d1ypa-JfIoPFEJwn3l-INZM5bS2wB1ifuJuvYXLSRC4,24165
 rapidata/api_client/api/compare_workflow_api.py,sha256=BG_cNnR1UO48Jfy2_ZLEcR2mknD0wXbDYKHLNVt4Szw,12833
 rapidata/api_client/api/customer_rapid_api.py,sha256=wrAPClQmSgghcEQI9fvXZQmdMlTh6_K007elRKEf1rw,80124
 rapidata/api_client/api/datapoint_api.py,sha256=bLNOJWtk3TBMU5tvFBSIbDk34YwkyEHarJgrISN4J3w,21308
-rapidata/api_client/api/dataset_api.py,sha256=96CitdOEPmMxNJyLQoX1yj4M68gCIsTAk-9XBdkgVUo,140720
+rapidata/api_client/api/dataset_api.py,sha256=DUCEfP7jlMAAMdvEa-47xq0mq3MGcyk4DA56f9OXZ2w,139572
 rapidata/api_client/api/evaluation_workflow_api.py,sha256=E0Phmx54jzXx7LZYGquTqzZSrX2aE5PS9rAs5HdDjvs,15151
 rapidata/api_client/api/feedback_api.py,sha256=-ZI2-1HtQ7wAzBKClgXMmMHtYdgoZtWrpQql3p51qp0,11589
 rapidata/api_client/api/identity_api.py,sha256=LmK6cTXssNjCa1BteOMc8P4FsyRiHQ_Kr30vmWIAYko,55093
@@ -21,7 +21,7 @@ rapidata/api_client/api/rapidata_identity_api_api.py,sha256=-kgoDuLdh-R4MQ7JPi3k
 rapidata/api_client/api/simple_workflow_api.py,sha256=yauSlkSwoZOl4P-1Wu0yU92GcEArpEd3xjFqImU2K1g,12763
 rapidata/api_client/api/user_info_api.py,sha256=FuuA95Beeky-rnqIoSUe2-WQ7oVTfq0RElX0jfKXT0w,10042
 rapidata/api_client/api/user_rapid_api.py,sha256=RXHAzSSGFohQqLUAZOKSaHt9EcT-7_n2vMto1SkSy4o,54323
-rapidata/api_client/api/validation_set_api.py,sha256=oy9crdaYLAfKmpg87keMkQ-UEc64gs2eKvhrEIq4Q5k,134762
+rapidata/api_client/api/validation_set_api.py,sha256=9MRvn33Zk47tMO8e_MFkGLY8p406eUnmrvHO_0QZ5JQ,149536
 rapidata/api_client/api/workflow_api.py,sha256=a5gMW-E7Mie-OK74J5SRoV6Wl1D4-AFCCfpxQ8ewCkQ,66871
 rapidata/api_client/api_client.py,sha256=EDhxAOUc5JFWvFsF1zc726Q7GoEFkuB8uor5SlGx9K4,27503
 rapidata/api_client/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
@@ -249,7 +249,7 @@ rapidata/api_client/models/get_simple_workflow_result_overview_result.py,sha256=
 rapidata/api_client/models/get_simple_workflow_results_model.py,sha256=r4DZspzPrwaI4DrC4OH-mwUvibcS0TzK9O8CFnsURSc,4289
 rapidata/api_client/models/get_simple_workflow_results_result.py,sha256=WNBHFW-D6tlMzNp9P7nGfoDoarjjwb2YwjlCCV1tA00,4411
 rapidata/api_client/models/get_simple_workflow_results_result_paged_result.py,sha256=DWimv7FmvJmixjQvDFeTE_Q5jHLpLdQmPlXF_9iWSiY,3616
-rapidata/api_client/models/get_standing_by_id_result.py,sha256=QtRtkRH_W1eWutu4kGFcP-mU8gD1nuSNxb-fzee8Aog,3716
+rapidata/api_client/models/get_standing_by_id_result.py,sha256=X7KGEjB7vkkkENqqOnOXXKR4KP3N_4JT6UAq8Xd7Vcg,3847
 rapidata/api_client/models/get_validation_rapids_query.py,sha256=teC4ryyIXJkRwafaSorysBIsKJuO5C1L8f6juJMwrNs,4894
 rapidata/api_client/models/get_validation_rapids_query_paged_result.py,sha256=ifyJ7Iy7VzTWxtwb2q5q5id927Iil00V3Nk9QqclsDo,3567
 rapidata/api_client/models/get_validation_rapids_result.py,sha256=dTQb5Ju4FAHNQldxY-7Vou62YdmcH3LDQJMdtvITB_c,6815
@@ -350,11 +350,11 @@ rapidata/api_client/models/order_state.py,sha256=Vnt5CdDKom-CVsoG0sDaAXYgNkUTnkT
 rapidata/api_client/models/original_filename_metadata.py,sha256=_VViiu2YOW6P4KaMZsbfYneXEcEnm4AroVEVVzOpHlM,3215
 rapidata/api_client/models/original_filename_metadata_model.py,sha256=LsbJg_t1FdhwdfF4URn6rxB2huUim6e15PrdxLTcaQo,3111
 rapidata/api_client/models/page_info.py,sha256=8vmnkRGqq38mIQCOMInYrPLFDBALxkWZUM-Z_M1-XK4,2766
-rapidata/api_client/models/participant_by_benchmark.py,sha256=pJ5HCTpFffhwu8bL4dq5GrCTURQZnddlW7bX82beQ0M,3167
+rapidata/api_client/models/participant_by_benchmark.py,sha256=grmCDPkZ38ThAaUO7DNewS4lQHPPc_I9j9bLAphFwn8,3191
 rapidata/api_client/models/participant_by_benchmark_paged_result.py,sha256=VEnfUsy8-s47_3SogL0EKMH4IErrYL3ecIe0yZBseYM,3550
 rapidata/api_client/models/participant_by_leaderboard.py,sha256=155CAfOxIYdXMLT481GY2IEkPG3IJWmpasFQwnmhfU0,3790
 rapidata/api_client/models/participant_by_leaderboard_paged_result.py,sha256=r92XzY-nGOdV2_TYHZe9kG5ksPDzyBQ8Nwkqs_c5yoE,3566
-rapidata/api_client/models/participant_status.py,sha256=QzDThyfxmMFRcbZt0qYMOqN-gcp_qiMq0I0zLWvvDog,778
+rapidata/api_client/models/participant_status.py,sha256=gpQfr8iW5I9fS9DGQe1X_tpPtU5hpWs0db_fbmMQrJE,804
 rapidata/api_client/models/pipeline_id_workflow_artifact_id_put_request.py,sha256=4HeDc5IvTpjPHH6xy5OAlpPL8dWwxrR9Vwsej3dK6LA,5979
 rapidata/api_client/models/pipeline_id_workflow_config_put_request.py,sha256=gWKIfBeI0-sURGA6haMP8vehYYBPrvetQo6oL0oFIRY,5951
 rapidata/api_client/models/pipeline_id_workflow_put_request.py,sha256=yblj0m6_Dql5JCbnQD93JEvkL-H5ZvgG__DMGj5uMAg,5909
@@ -446,7 +446,7 @@ rapidata/api_client/models/sort_criterion.py,sha256=klwKhELiScAGHRL8yF_TtL0X_4Z4
 rapidata/api_client/models/sort_direction.py,sha256=yNLZqvgL5fHbD98kMWFAsfgqn3gKM_GFIyRVfheZydI,748
 rapidata/api_client/models/source_url_metadata.py,sha256=TL2Joe1EDgnwDJ3_rQy36laM6dvaLBTez3psyQUKaN0,3072
 rapidata/api_client/models/source_url_metadata_model.py,sha256=UWd1nG-awsV5Q2fsrqdPDgc7bI_pGag0ubIlwEEKMZk,2988
-rapidata/api_client/models/standing_by_leaderboard.py,sha256=C-JTr05882R8btI3MybNPuUn_D0S_r-uqtjpz_oKeTg,3726
+rapidata/api_client/models/standing_by_leaderboard.py,sha256=NmSu-ES9WBj8eZR0jRQC9wr93OghOonxJ2OjWuGBP9Y,3857
 rapidata/api_client/models/standing_by_leaderboard_paged_result.py,sha256=zOlbN2Pxc0y5M9MaDTB5znl0V-6CZIzGZWBlcZGdeVg,3542
 rapidata/api_client/models/standing_status.py,sha256=1uIPH2EDit3fsq9LAnspG1xRzZrgFyKAju6Dq7Vka4M,781
 rapidata/api_client/models/static_rapid_selection_config.py,sha256=RnjyRhAOaxmJ2PW-X2m4G0QZlm-8vw2d9ZO5uneNOtg,3073
@@ -524,7 +524,7 @@ rapidata/api_client/models/workflow_split_model_filter_configs_inner.py,sha256=1
 rapidata/api_client/models/workflow_state.py,sha256=5LAK1se76RCoozeVB6oxMPb8p_5bhLZJqn7q5fFQWis,850
 rapidata/api_client/models/zip_entry_file_wrapper.py,sha256=06CoNJD3x511K3rnSmkrwwhc9GbQxwxF-c0ldOyJbAs,4240
 rapidata/api_client/rest.py,sha256=rtIMcgINZOUaDFaJIinJkXRSddNJmXvMRMfgO2Ezk2o,10835
-rapidata/api_client_README.md,sha256=-CgEFsbrZGqmyS0tOlIgbgij-ApyqQtdUJcye0kmdXs,58480
+rapidata/api_client_README.md,sha256=xdgbo29fmH1jD1-o5U7eT9noDoh8yBQWextKrM4L1_k,59284
 rapidata/rapidata_client/__init__.py,sha256=MLl41ZPDYezE9ookAjHS75wFqfCTOKq-U01GJbHFjrA,1133
 rapidata/rapidata_client/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapidata/rapidata_client/api/rapidata_exception.py,sha256=BIdmHRrJUGW-Mqhp1H_suemZaR6w9TgjWq-ZW5iUPdQ,3878
@@ -544,9 +544,10 @@ rapidata/rapidata_client/country_codes/__init__.py,sha256=FB9Dcks44J6C6YBSYmTmNZ
 rapidata/rapidata_client/country_codes/country_codes.py,sha256=ePHqeb7y9DWQZAnddBzPx1puYBcrgUjdR2sbFijuFD8,283
 rapidata/rapidata_client/demographic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapidata/rapidata_client/demographic/demographic_manager.py,sha256=RE4r6NNAXinNAlRMgAcG4te4pF4whv81xbyAW2V9XMM,1192
-rapidata/rapidata_client/filter/__init__.py,sha256=SqxlEotA_O1Lgw3Um6VPBE2P5Hw7OUVZRSBbsv1GJbI,514
-rapidata/rapidata_client/filter/_base_filter.py,sha256=EytjAqeDX_x3D5WoFwwtr8L2ok5-Ga-JEvkRnkuBQbw,1433
+rapidata/rapidata_client/filter/__init__.py,sha256=j_Kfz_asNVxwp56SAN2saB7ZAHg3smL5_W2sSitmuJY,548
+rapidata/rapidata_client/filter/_base_filter.py,sha256=cPLl0ddWB8QU6Luspnub_KXiTEfEFOVBEdnxhJOjoWs,2269
 rapidata/rapidata_client/filter/age_filter.py,sha256=oRjGY65gE_X8oa0D0XRyvKAb4_Z6XOOaGTWykRSfLFA,739
+rapidata/rapidata_client/filter/and_filter.py,sha256=AlQ-M81_SgVjH7EAghRa5J7u2I6l41ADx9gP2PT0stY,1343
 rapidata/rapidata_client/filter/campaign_filter.py,sha256=6ZT11-gub8349QcRwuHt8AcBY18F7BdLRZ2Ch_vjLyU,735
 rapidata/rapidata_client/filter/country_filter.py,sha256=JqCzxePRizXQbN4YzwLmrx9ozKgw0ra6N_enEq36imI,948
 rapidata/rapidata_client/filter/custom_filter.py,sha256=XZgqJhKCy7m2P0Dx8fk7vVszbdKc7gT2U07dWi3hXgU,885
@@ -558,7 +559,7 @@ rapidata/rapidata_client/filter/models/gender.py,sha256=aXg6Kql2BIy8d5d1lCVi1axM
 rapidata/rapidata_client/filter/new_user_filter.py,sha256=qU7d6cSslGEO_N1tYPS4Ru3cGbQYH2_I5dJPNPHvtCM,369
 rapidata/rapidata_client/filter/not_filter.py,sha256=05uZMNPfguNPONP2uYYtuxx-5UAYdmc8gwSAEHMiK3k,1183
 rapidata/rapidata_client/filter/or_filter.py,sha256=EomsXyYec4beAA63LYfIsh8dO4So1duI7VlLW8VPfzY,1339
-rapidata/rapidata_client/filter/rapidata_filters.py,sha256=aHl8bjvL0wJLhzm6BCHy7mPGYYYKTLZhY0WZVeHx0ZA,2014
+rapidata/rapidata_client/filter/rapidata_filters.py,sha256=l_pPOA56f8hiacAgr3om5j6IpTP-BGOB247c_uhuYzM,2194
 rapidata/rapidata_client/filter/response_count_filter.py,sha256=sDv9Dvy0FbnIQRSAxFGrUf9SIMISTNxnlAQcrFKBjXE,1989
 rapidata/rapidata_client/filter/user_score_filter.py,sha256=2C78zkWm5TnfkxGbV1ER2xB7s9ynpacaibzyRZKG8Cc,1566
 rapidata/rapidata_client/logging/__init__.py,sha256=4gLxePW8TvgYDZmPWMcf6fA8bEyu35vMKOmlPj5oXNE,110
@@ -612,9 +613,9 @@ rapidata/rapidata_client/validation/__init__.py,sha256=s5wHVtcJkncXSFuL9I0zNwccN
 rapidata/rapidata_client/validation/rapidata_validation_set.py,sha256=h6aicVyrBePfzS5-cPk_hPgmePUqCB3yAbGB_tTXYg0,1814
 rapidata/rapidata_client/validation/rapids/__init__.py,sha256=WU5PPwtTJlte6U90MDakzx4I8Y0laj7siw9teeXj5R0,21
 rapidata/rapidata_client/validation/rapids/box.py,sha256=t3_Kn6doKXdnJdtbwefXnYKPiTKHneJl9E2inkDSqL8,589
-rapidata/rapidata_client/validation/rapids/rapids.py,sha256=9uyXzjujoDLsp8Hdlyuw1f7IbKdGDoMuth7rPqhxRqY,4742
+rapidata/rapidata_client/validation/rapids/rapids.py,sha256=bsDPp8IJ_7dQOJP7U9IVqfLKctY5YP58gDBX8Ixrpc4,3827
 rapidata/rapidata_client/validation/rapids/rapids_manager.py,sha256=s5VAq8H5CKACWfmIQuz9kHC8t2nd-xEHGGUj9pIfXKI,14386
-rapidata/rapidata_client/validation/validation_set_manager.py,sha256=hhtnrXw09FGcL7Xnm58I-vQT4mdhtOWsbR8HhOfeoeU,30323
+rapidata/rapidata_client/validation/validation_set_manager.py,sha256=yQTZSAnqTT0xnwESPIEykQG-34UP9oyoavpNA0KuRIU,30626
 rapidata/rapidata_client/workflow/__init__.py,sha256=7nXcY91xkxjHudBc9H0fP35eBBtgwHGWTQKbb-M4h7Y,477
 rapidata/rapidata_client/workflow/_base_workflow.py,sha256=XyIZFKS_RxAuwIHS848S3AyLEHqd07oTD_5jm2oUbsw,762
 rapidata/rapidata_client/workflow/_classify_workflow.py,sha256=9bT54wxVJgxC-zLk6MVNbseFpzYrvFPjt7DHvxqYfnk,1736
@@ -630,7 +631,7 @@ rapidata/service/__init__.py,sha256=s9bS1AJZaWIhLtJX_ZA40_CK39rAAkwdAmymTMbeWl4,
 rapidata/service/credential_manager.py,sha256=pUEEtp6VrFWYhfUUtyqmS0AlRqe2Y0kFkY6o22IT4KM,8682
 rapidata/service/local_file_service.py,sha256=pgorvlWcx52Uh3cEG6VrdMK_t__7dacQ_5AnfY14BW8,877
 rapidata/service/openapi_service.py,sha256=xoGBACpUhG0H-tadSBa8A91LHyfI7n-FCT2JlrERqco,5221
-rapidata-2.30.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-rapidata-2.30.0.dist-info/METADATA,sha256=O2h84JP3EaVGDaxeuGTLcnerkEES1kaCB12aY6WOWuc,1264
-rapidata-2.30.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-rapidata-2.30.0.dist-info/RECORD,,
+rapidata-2.31.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+rapidata-2.31.0.dist-info/METADATA,sha256=I0oM2qAap3-ZDUa67lvb0L8wgIY9K3x9HArj6dW0ALc,1264
+rapidata-2.31.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+rapidata-2.31.0.dist-info/RECORD,,