rapidata 2.36.1__tar.gz → 2.36.2__tar.gz

{rapidata-2.36.1 → rapidata-2.36.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.36.1
+Version: 2.36.2
 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.36.1 → rapidata-2.36.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapidata"
-version = "2.36.1"
+version = "2.36.2"
 description = "Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way."
 authors = ["Rapidata AG <info@rapidata.ai>"]
 license = "Apache-2.0"

{rapidata-2.36.1 → rapidata-2.36.2}/src/rapidata/__init__.py

@@ -1,11 +1,11 @@
-__version__ = "2.36.1"
+__version__ = "2.36.2"
 
 from .rapidata_client import (
     RapidataClient,
     DemographicSelection,
     LabelingSelection,
     EffortSelection,
-    RetrievalMode,
+    RapidataRetrievalMode,
     ValidationSelection,
     ConditionalValidationSelection,
     CappedSelection,

{rapidata-2.36.1 → rapidata-2.36.2}/src/rapidata/api_client/__init__.py

@@ -72,7 +72,6 @@ from rapidata.api_client.models.are_rapids_active_result import AreRapidsActiveR
 from rapidata.api_client.models.asset_metadata import AssetMetadata
 from rapidata.api_client.models.asset_metadata_asset import AssetMetadataAsset
 from rapidata.api_client.models.asset_metadata_model import AssetMetadataModel
-from rapidata.api_client.models.asset_type import AssetType
 from rapidata.api_client.models.attach_category_rapid_blueprint import AttachCategoryRapidBlueprint
 from rapidata.api_client.models.attach_category_result import AttachCategoryResult
 from rapidata.api_client.models.attach_category_truth import AttachCategoryTruth
@@ -223,6 +222,7 @@ from rapidata.api_client.models.get_pipeline_by_id_result_artifacts_value import
 from rapidata.api_client.models.get_public_orders_result import GetPublicOrdersResult
 from rapidata.api_client.models.get_public_responses_result import GetPublicResponsesResult
 from rapidata.api_client.models.get_rapid_responses_result import GetRapidResponsesResult
+from rapidata.api_client.models.get_recommended_validation_set_result import GetRecommendedValidationSetResult
 from rapidata.api_client.models.get_responses_result import GetResponsesResult
 from rapidata.api_client.models.get_sample_by_id_result import GetSampleByIdResult
 from rapidata.api_client.models.get_simple_workflow_results_model import GetSimpleWorkflowResultsModel
@@ -268,7 +268,6 @@ from rapidata.api_client.models.location_metadata import LocationMetadata
 from rapidata.api_client.models.location_metadata_exists_filter_config import LocationMetadataExistsFilterConfig
 from rapidata.api_client.models.location_metadata_model import LocationMetadataModel
 from rapidata.api_client.models.logic_operator import LogicOperator
-from rapidata.api_client.models.metadata_visibilities import MetadataVisibilities
 from rapidata.api_client.models.multi_asset import MultiAsset
 from rapidata.api_client.models.multi_asset_input import MultiAssetInput
 from rapidata.api_client.models.multi_asset_input1 import MultiAssetInput1
@@ -325,6 +324,7 @@ from rapidata.api_client.models.preview_order_model import PreviewOrderModel
 from rapidata.api_client.models.private_text_metadata_input import PrivateTextMetadataInput
 from rapidata.api_client.models.probabilistic_attach_category_referee_config import ProbabilisticAttachCategoryRefereeConfig
 from rapidata.api_client.models.probabilistic_attach_category_referee_info import ProbabilisticAttachCategoryRefereeInfo
+from rapidata.api_client.models.problem_details import ProblemDetails
 from rapidata.api_client.models.prompt_asset_metadata_input import PromptAssetMetadataInput
 from rapidata.api_client.models.prompt_asset_metadata_input_asset import PromptAssetMetadataInputAsset
 from rapidata.api_client.models.prompt_by_benchmark_result import PromptByBenchmarkResult
@@ -332,7 +332,6 @@ from rapidata.api_client.models.prompt_by_benchmark_result_paged_result import P
 from rapidata.api_client.models.prompt_metadata import PromptMetadata
 from rapidata.api_client.models.prompt_metadata_input import PromptMetadataInput
 from rapidata.api_client.models.prompt_metadata_model import PromptMetadataModel
-from rapidata.api_client.models.prompt_type import PromptType
 from rapidata.api_client.models.proxy_file_wrapper import ProxyFileWrapper
 from rapidata.api_client.models.public_order_model import PublicOrderModel
 from rapidata.api_client.models.public_rapid_response import PublicRapidResponse
@@ -340,7 +339,6 @@ from rapidata.api_client.models.public_text_metadata_input import PublicTextMeta
 from rapidata.api_client.models.query_model import QueryModel
 from rapidata.api_client.models.query_validation_model import QueryValidationModel
 from rapidata.api_client.models.rapid_issue import RapidIssue
-from rapidata.api_client.models.rapid_modality import RapidModality
 from rapidata.api_client.models.rapid_model import RapidModel
 from rapidata.api_client.models.rapid_model_paged_result import RapidModelPagedResult
 from rapidata.api_client.models.rapid_model_referee import RapidModelReferee

{rapidata-2.36.1 → rapidata-2.36.2}/src/rapidata/api_client/api/validation_set_api.py

@@ -16,24 +16,21 @@ from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
-from pydantic import Field, StrictBool, StrictBytes, StrictStr
+from pydantic import Field, StrictBool, StrictBytes, StrictStr, field_validator
 from typing import List, Optional, Tuple, Union
 from typing_extensions import Annotated
 from rapidata.api_client.models.add_validation_rapid_model import AddValidationRapidModel
 from rapidata.api_client.models.add_validation_rapid_result import AddValidationRapidResult
-from rapidata.api_client.models.asset_type import AssetType
 from rapidata.api_client.models.create_empty_validation_set_result import CreateEmptyValidationSetResult
 from rapidata.api_client.models.create_validation_set_model import CreateValidationSetModel
 from rapidata.api_client.models.get_available_validation_sets_result import GetAvailableValidationSetsResult
+from rapidata.api_client.models.get_recommended_validation_set_result import GetRecommendedValidationSetResult
 from rapidata.api_client.models.get_validation_rapids_result_paged_result import GetValidationRapidsResultPagedResult
 from rapidata.api_client.models.get_validation_set_by_id_result import GetValidationSetByIdResult
 from rapidata.api_client.models.import_validation_set_from_file_result import ImportValidationSetFromFileResult
-from rapidata.api_client.models.prompt_type import PromptType
 from rapidata.api_client.models.query_model import QueryModel
-from rapidata.api_client.models.rapid_modality import RapidModality
 from rapidata.api_client.models.update_dimensions_model import UpdateDimensionsModel
 from rapidata.api_client.models.update_should_alert_model import UpdateShouldAlertModel
-from rapidata.api_client.models.validation_set_model import ValidationSetModel
 from rapidata.api_client.models.validation_set_model_paged_result import ValidationSetModelPagedResult
 from rapidata.api_client.models.validation_set_zip_post_request_blueprint import ValidationSetZipPostRequestBlueprint
 
@@ -334,9 +331,10 @@ class ValidationSetApi:
     @validate_call
     def validation_set_recommended_get(
         self,
-        asset_type: Annotated[Optional[AssetType], Field(description="The types of assets that the validation set should contain. An asset type can be an image, video, audio, text, or any combination of these. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified asset types.")] = None,
-        modality: Annotated[Optional[RapidModality], Field(description="The rapid modalities that the validation set should contain. The modality is the type of rapid such as classify, compare, locate, etc. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified modalities.")] = None,
-        prompt_type: Annotated[Optional[PromptType], Field(description="The prompt types that the validation set should contain. A prompt type is the additional information that is presented to the user when solving a rapid. For example, a prompt type can be either text or an asset if the context is an image or video. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified prompt types.")] = None,
+        asset_type: Annotated[Optional[List[StrictStr]], Field(description="The types of assets that the validation set should contain. An asset type can be an image, video, audio, text, or any combination of these. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified asset types.")] = None,
+        modality: Annotated[Optional[List[StrictStr]], Field(description="The rapid modalities that the validation set should contain. The modality is the type of rapid such as classify, compare, locate, etc. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified modalities.")] = None,
+        prompt_type: Annotated[Optional[List[StrictStr]], Field(description="The prompt types that the validation set should contain. A prompt type is the additional information that is presented to the user when solving a rapid. For example, a prompt type can be either text or an asset if the context is an image or video. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified prompt types.")] = None,
+        instruction: Annotated[Optional[StrictStr], Field(description="An instruction that can be used to filter for validation sets that have similar instructions. An instruction is a text that is presented to the user when solving a rapid that explains how to solve the rapid.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -349,16 +347,19 @@ class ValidationSetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ValidationSetModel:
+    ) -> GetRecommendedValidationSetResult:
         """Gets a validation set that is available to the user and best matches the provided parameters.
 
+        This is not a hard filter, instead it is used to find validation sets that have similar characteristics to the provided instruction.
 
         :param asset_type: The types of assets that the validation set should contain. An asset type can be an image, video, audio, text, or any combination of these. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified asset types.
-        :type asset_type: AssetType
+        :type asset_type: List[str]
         :param modality: The rapid modalities that the validation set should contain. The modality is the type of rapid such as classify, compare, locate, etc. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified modalities.
-        :type modality: RapidModality
+        :type modality: List[str]
         :param prompt_type: The prompt types that the validation set should contain. A prompt type is the additional information that is presented to the user when solving a rapid. For example, a prompt type can be either text or an asset if the context is an image or video. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified prompt types.
-        :type prompt_type: PromptType
+        :type prompt_type: List[str]
+        :param instruction: An instruction that can be used to filter for validation sets that have similar instructions. An instruction is a text that is presented to the user when solving a rapid that explains how to solve the rapid.
+        :type instruction: 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
@@ -385,6 +386,7 @@ class ValidationSetApi:
             asset_type=asset_type,
             modality=modality,
             prompt_type=prompt_type,
+            instruction=instruction,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -392,7 +394,8 @@ class ValidationSetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ValidationSetModel",
+            '200': "GetRecommendedValidationSetResult",
+            '404': "ProblemDetails",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -408,9 +411,10 @@ class ValidationSetApi:
     @validate_call
     def validation_set_recommended_get_with_http_info(
         self,
-        asset_type: Annotated[Optional[AssetType], Field(description="The types of assets that the validation set should contain. An asset type can be an image, video, audio, text, or any combination of these. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified asset types.")] = None,
-        modality: Annotated[Optional[RapidModality], Field(description="The rapid modalities that the validation set should contain. The modality is the type of rapid such as classify, compare, locate, etc. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified modalities.")] = None,
-        prompt_type: Annotated[Optional[PromptType], Field(description="The prompt types that the validation set should contain. A prompt type is the additional information that is presented to the user when solving a rapid. For example, a prompt type can be either text or an asset if the context is an image or video. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified prompt types.")] = None,
+        asset_type: Annotated[Optional[List[StrictStr]], Field(description="The types of assets that the validation set should contain. An asset type can be an image, video, audio, text, or any combination of these. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified asset types.")] = None,
+        modality: Annotated[Optional[List[StrictStr]], Field(description="The rapid modalities that the validation set should contain. The modality is the type of rapid such as classify, compare, locate, etc. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified modalities.")] = None,
+        prompt_type: Annotated[Optional[List[StrictStr]], Field(description="The prompt types that the validation set should contain. A prompt type is the additional information that is presented to the user when solving a rapid. For example, a prompt type can be either text or an asset if the context is an image or video. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified prompt types.")] = None,
+        instruction: Annotated[Optional[StrictStr], Field(description="An instruction that can be used to filter for validation sets that have similar instructions. An instruction is a text that is presented to the user when solving a rapid that explains how to solve the rapid.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -423,16 +427,19 @@ class ValidationSetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ValidationSetModel]:
+    ) -> ApiResponse[GetRecommendedValidationSetResult]:
         """Gets a validation set that is available to the user and best matches the provided parameters.
 
+        This is not a hard filter, instead it is used to find validation sets that have similar characteristics to the provided instruction.
 
         :param asset_type: The types of assets that the validation set should contain. An asset type can be an image, video, audio, text, or any combination of these. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified asset types.
-        :type asset_type: AssetType
+        :type asset_type: List[str]
         :param modality: The rapid modalities that the validation set should contain. The modality is the type of rapid such as classify, compare, locate, etc. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified modalities.
-        :type modality: RapidModality
+        :type modality: List[str]
         :param prompt_type: The prompt types that the validation set should contain. A prompt type is the additional information that is presented to the user when solving a rapid. For example, a prompt type can be either text or an asset if the context is an image or video. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified prompt types.
-        :type prompt_type: PromptType
+        :type prompt_type: List[str]
+        :param instruction: An instruction that can be used to filter for validation sets that have similar instructions. An instruction is a text that is presented to the user when solving a rapid that explains how to solve the rapid.
+        :type instruction: 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
@@ -459,6 +466,7 @@ class ValidationSetApi:
             asset_type=asset_type,
             modality=modality,
             prompt_type=prompt_type,
+            instruction=instruction,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -466,7 +474,8 @@ class ValidationSetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ValidationSetModel",
+            '200': "GetRecommendedValidationSetResult",
+            '404': "ProblemDetails",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -482,9 +491,10 @@ class ValidationSetApi:
     @validate_call
     def validation_set_recommended_get_without_preload_content(
         self,
-        asset_type: Annotated[Optional[AssetType], Field(description="The types of assets that the validation set should contain. An asset type can be an image, video, audio, text, or any combination of these. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified asset types.")] = None,
-        modality: Annotated[Optional[RapidModality], Field(description="The rapid modalities that the validation set should contain. The modality is the type of rapid such as classify, compare, locate, etc. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified modalities.")] = None,
-        prompt_type: Annotated[Optional[PromptType], Field(description="The prompt types that the validation set should contain. A prompt type is the additional information that is presented to the user when solving a rapid. For example, a prompt type can be either text or an asset if the context is an image or video. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified prompt types.")] = None,
+        asset_type: Annotated[Optional[List[StrictStr]], Field(description="The types of assets that the validation set should contain. An asset type can be an image, video, audio, text, or any combination of these. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified asset types.")] = None,
+        modality: Annotated[Optional[List[StrictStr]], Field(description="The rapid modalities that the validation set should contain. The modality is the type of rapid such as classify, compare, locate, etc. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified modalities.")] = None,
+        prompt_type: Annotated[Optional[List[StrictStr]], Field(description="The prompt types that the validation set should contain. A prompt type is the additional information that is presented to the user when solving a rapid. For example, a prompt type can be either text or an asset if the context is an image or video. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified prompt types.")] = None,
+        instruction: Annotated[Optional[StrictStr], Field(description="An instruction that can be used to filter for validation sets that have similar instructions. An instruction is a text that is presented to the user when solving a rapid that explains how to solve the rapid.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -500,13 +510,16 @@ class ValidationSetApi:
     ) -> RESTResponseType:
         """Gets a validation set that is available to the user and best matches the provided parameters.
 
+        This is not a hard filter, instead it is used to find validation sets that have similar characteristics to the provided instruction.
 
         :param asset_type: The types of assets that the validation set should contain. An asset type can be an image, video, audio, text, or any combination of these. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified asset types.
-        :type asset_type: AssetType
+        :type asset_type: List[str]
         :param modality: The rapid modalities that the validation set should contain. The modality is the type of rapid such as classify, compare, locate, etc. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified modalities.
-        :type modality: RapidModality
+        :type modality: List[str]
         :param prompt_type: The prompt types that the validation set should contain. A prompt type is the additional information that is presented to the user when solving a rapid. For example, a prompt type can be either text or an asset if the context is an image or video. <para /> This parameter is a flag, meaning that it can be null or contain multiple values. If multiple values are provided, a validation set will be chosen that contains at least one of the specified prompt types.
-        :type prompt_type: PromptType
+        :type prompt_type: List[str]
+        :param instruction: An instruction that can be used to filter for validation sets that have similar instructions. An instruction is a text that is presented to the user when solving a rapid that explains how to solve the rapid.
+        :type instruction: 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
@@ -533,6 +546,7 @@ class ValidationSetApi:
             asset_type=asset_type,
             modality=modality,
             prompt_type=prompt_type,
+            instruction=instruction,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -540,7 +554,8 @@ class ValidationSetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ValidationSetModel",
+            '200': "GetRecommendedValidationSetResult",
+            '404': "ProblemDetails",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -554,6 +569,7 @@ class ValidationSetApi:
         asset_type,
         modality,
         prompt_type,
+        instruction,
         _request_auth,
         _content_type,
         _headers,
@@ -563,6 +579,9 @@ class ValidationSetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
+            'assetType': 'multi',
+            'modality': 'multi',
+            'promptType': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -578,15 +597,19 @@ class ValidationSetApi:
         # process the query parameters
         if asset_type is not None:
             
-            _query_params.append(('assetType', asset_type.value))
+            _query_params.append(('assetType', asset_type))
             
         if modality is not None:
             
-            _query_params.append(('modality', modality.value))
+            _query_params.append(('modality', modality))
             
         if prompt_type is not None:
             
-            _query_params.append(('promptType', prompt_type.value))
+            _query_params.append(('promptType', prompt_type))
+            
+        if instruction is not None:
+            
+            _query_params.append(('instruction', instruction))
             
         # process the header parameters
         # process the form parameters

{rapidata-2.36.1 → rapidata-2.36.2}/src/rapidata/api_client/models/__init__.py

@@ -32,7 +32,6 @@ from rapidata.api_client.models.are_rapids_active_result import AreRapidsActiveR
 from rapidata.api_client.models.asset_metadata import AssetMetadata
 from rapidata.api_client.models.asset_metadata_asset import AssetMetadataAsset
 from rapidata.api_client.models.asset_metadata_model import AssetMetadataModel
-from rapidata.api_client.models.asset_type import AssetType
 from rapidata.api_client.models.attach_category_rapid_blueprint import AttachCategoryRapidBlueprint
 from rapidata.api_client.models.attach_category_result import AttachCategoryResult
 from rapidata.api_client.models.attach_category_truth import AttachCategoryTruth
@@ -183,6 +182,7 @@ from rapidata.api_client.models.get_pipeline_by_id_result_artifacts_value import
 from rapidata.api_client.models.get_public_orders_result import GetPublicOrdersResult
 from rapidata.api_client.models.get_public_responses_result import GetPublicResponsesResult
 from rapidata.api_client.models.get_rapid_responses_result import GetRapidResponsesResult
+from rapidata.api_client.models.get_recommended_validation_set_result import GetRecommendedValidationSetResult
 from rapidata.api_client.models.get_responses_result import GetResponsesResult
 from rapidata.api_client.models.get_sample_by_id_result import GetSampleByIdResult
 from rapidata.api_client.models.get_simple_workflow_results_model import GetSimpleWorkflowResultsModel
@@ -228,7 +228,6 @@ from rapidata.api_client.models.location_metadata import LocationMetadata
 from rapidata.api_client.models.location_metadata_exists_filter_config import LocationMetadataExistsFilterConfig
 from rapidata.api_client.models.location_metadata_model import LocationMetadataModel
 from rapidata.api_client.models.logic_operator import LogicOperator
-from rapidata.api_client.models.metadata_visibilities import MetadataVisibilities
 from rapidata.api_client.models.multi_asset import MultiAsset
 from rapidata.api_client.models.multi_asset_input import MultiAssetInput
 from rapidata.api_client.models.multi_asset_input1 import MultiAssetInput1
@@ -285,6 +284,7 @@ from rapidata.api_client.models.preview_order_model import PreviewOrderModel
 from rapidata.api_client.models.private_text_metadata_input import PrivateTextMetadataInput
 from rapidata.api_client.models.probabilistic_attach_category_referee_config import ProbabilisticAttachCategoryRefereeConfig
 from rapidata.api_client.models.probabilistic_attach_category_referee_info import ProbabilisticAttachCategoryRefereeInfo
+from rapidata.api_client.models.problem_details import ProblemDetails
 from rapidata.api_client.models.prompt_asset_metadata_input import PromptAssetMetadataInput
 from rapidata.api_client.models.prompt_asset_metadata_input_asset import PromptAssetMetadataInputAsset
 from rapidata.api_client.models.prompt_by_benchmark_result import PromptByBenchmarkResult
@@ -292,7 +292,6 @@ from rapidata.api_client.models.prompt_by_benchmark_result_paged_result import P
 from rapidata.api_client.models.prompt_metadata import PromptMetadata
 from rapidata.api_client.models.prompt_metadata_input import PromptMetadataInput
 from rapidata.api_client.models.prompt_metadata_model import PromptMetadataModel
-from rapidata.api_client.models.prompt_type import PromptType
 from rapidata.api_client.models.proxy_file_wrapper import ProxyFileWrapper
 from rapidata.api_client.models.public_order_model import PublicOrderModel
 from rapidata.api_client.models.public_rapid_response import PublicRapidResponse
@@ -300,7 +299,6 @@ from rapidata.api_client.models.public_text_metadata_input import PublicTextMeta
 from rapidata.api_client.models.query_model import QueryModel
 from rapidata.api_client.models.query_validation_model import QueryValidationModel
 from rapidata.api_client.models.rapid_issue import RapidIssue
-from rapidata.api_client.models.rapid_modality import RapidModality
 from rapidata.api_client.models.rapid_model import RapidModel
 from rapidata.api_client.models.rapid_model_paged_result import RapidModelPagedResult
 from rapidata.api_client.models.rapid_model_referee import RapidModelReferee

{rapidata-2.36.1 → rapidata-2.36.2}/src/rapidata/api_client/models/add_validation_rapid_model.py

@@ -22,6 +22,7 @@ from typing import Any, ClassVar, Dict, List, Optional, Union
 from rapidata.api_client.models.add_validation_rapid_model_payload import AddValidationRapidModelPayload
 from rapidata.api_client.models.add_validation_rapid_model_truth import AddValidationRapidModelTruth
 from rapidata.api_client.models.dataset_dataset_id_datapoints_post_request_metadata_inner import DatasetDatasetIdDatapointsPostRequestMetadataInner
+from rapidata.api_client.models.feature_flag_model import FeatureFlagModel
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -34,7 +35,8 @@ class AddValidationRapidModel(BaseModel):
     truth: Optional[AddValidationRapidModelTruth] = None
     random_correct_probability: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The probability for an answer to be correct when randomly guessing.", alias="randomCorrectProbability")
     explanation: Optional[StrictStr] = Field(default=None, description="An explanation for the users if they answer the rapid incorrectly.")
-    __properties: ClassVar[List[str]] = ["payload", "metadata", "truth", "randomCorrectProbability", "explanation"]
+    feature_flags: Optional[List[FeatureFlagModel]] = Field(default=None, description="The feature flags to enable for the rapid.", alias="featureFlags")
+    __properties: ClassVar[List[str]] = ["payload", "metadata", "truth", "randomCorrectProbability", "explanation", "featureFlags"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -88,6 +90,13 @@ class AddValidationRapidModel(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of truth
         if self.truth:
             _dict['truth'] = self.truth.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in feature_flags (list)
+        _items = []
+        if self.feature_flags:
+            for _item_feature_flags in self.feature_flags:
+                if _item_feature_flags:
+                    _items.append(_item_feature_flags.to_dict())
+            _dict['featureFlags'] = _items
         # set to None if metadata (nullable) is None
         # and model_fields_set contains the field
         if self.metadata is None and "metadata" in self.model_fields_set:
@@ -108,6 +117,11 @@ class AddValidationRapidModel(BaseModel):
         if self.explanation is None and "explanation" in self.model_fields_set:
             _dict['explanation'] = None
 
+        # set to None if feature_flags (nullable) is None
+        # and model_fields_set contains the field
+        if self.feature_flags is None and "feature_flags" in self.model_fields_set:
+            _dict['featureFlags'] = None
+
         return _dict
 
     @classmethod
@@ -124,7 +138,8 @@ class AddValidationRapidModel(BaseModel):
             "metadata": [DatasetDatasetIdDatapointsPostRequestMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
             "truth": AddValidationRapidModelTruth.from_dict(obj["truth"]) if obj.get("truth") is not None else None,
             "randomCorrectProbability": obj.get("randomCorrectProbability"),
-            "explanation": obj.get("explanation")
+            "explanation": obj.get("explanation"),
+            "featureFlags": [FeatureFlagModel.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None
         })
         return _obj
 

{rapidata-2.36.1 → rapidata-2.36.2}/src/rapidata/api_client/models/asset_metadata.py

@@ -28,7 +28,7 @@ class AssetMetadata(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for AssetMetadata", alias="_t")
     asset: AssetMetadataAsset
-    visibilities: StrictStr
+    visibilities: List[StrictStr]
     __properties: ClassVar[List[str]] = ["_t", "asset", "visibilities"]
 
     @field_validator('t')
@@ -38,6 +38,14 @@ class AssetMetadata(BaseModel):
             raise ValueError("must be one of enum values ('AssetMetadata')")
         return value
 
+    @field_validator('visibilities')
+    def visibilities_validate_enum(cls, value):
+        """Validates the enum"""
+        for i in value:
+            if i not in set(['None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All']):
+                raise ValueError("each list item must be one of ('None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

{rapidata-2.36.1 → rapidata-2.36.2}/src/rapidata/api_client/models/boost_query_result.py

@@ -17,8 +17,10 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List
+from rapidata.api_client.models.boost_mode import BoostMode
+from rapidata.api_client.models.boost_status import BoostStatus
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -26,27 +28,13 @@ class BoostQueryResult(BaseModel):
     """
     BoostQueryResult
     """ # noqa: E501
-    status: StrictStr
-    mode: StrictStr
+    status: BoostStatus
+    mode: BoostMode
     active_campaigns: List[StrictStr] = Field(alias="activeCampaigns")
     inactive_campaigns: List[StrictStr] = Field(alias="inactiveCampaigns")
     unknown_campaigns: List[StrictInt] = Field(alias="unknownCampaigns")
     __properties: ClassVar[List[str]] = ["status", "mode", "activeCampaigns", "inactiveCampaigns", "unknownCampaigns"]
 
-    @field_validator('status')
-    def status_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Active', 'Inactive', 'Partial', 'Unknown']):
-            raise ValueError("must be one of enum values ('Active', 'Inactive', 'Partial', 'Unknown')")
-        return value
-
-    @field_validator('mode')
-    def mode_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Automatic', 'Manual']):
-            raise ValueError("must be one of enum values ('Automatic', 'Manual')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

{rapidata-2.36.1 → rapidata-2.36.2}/src/rapidata/api_client/models/campaign_query_result.py

@@ -18,8 +18,9 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List
+from rapidata.api_client.models.campaign_status import CampaignStatus
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -30,18 +31,11 @@ class CampaignQueryResult(BaseModel):
     id: StrictStr
     owner_mail: StrictStr = Field(alias="ownerMail")
     name: StrictStr
-    status: StrictStr
+    status: CampaignStatus
     priority: StrictInt
     created_at: datetime = Field(alias="createdAt")
     __properties: ClassVar[List[str]] = ["id", "ownerMail", "name", "status", "priority", "createdAt"]
 
-    @field_validator('status')
-    def status_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Created', 'Preview', 'Active', 'Analysis', 'Paused', 'Completed']):
-            raise ValueError("must be one of enum values ('Created', 'Preview', 'Active', 'Analysis', 'Paused', 'Completed')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

{rapidata-2.36.1 → rapidata-2.36.2}/src/rapidata/api_client/models/classification_metadata.py

@@ -28,7 +28,7 @@ class ClassificationMetadata(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for ClassificationMetadata", alias="_t")
     classification: StrictStr
-    visibilities: Optional[StrictStr] = None
+    visibilities: Optional[List[StrictStr]] = None
     __properties: ClassVar[List[str]] = ["_t", "classification", "visibilities"]
 
     @field_validator('t')
@@ -38,6 +38,17 @@ class ClassificationMetadata(BaseModel):
             raise ValueError("must be one of enum values ('ClassificationMetadata')")
         return value
 
+    @field_validator('visibilities')
+    def visibilities_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(['None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All']):
+                raise ValueError("each list item must be one of ('None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

{rapidata-2.36.1 → rapidata-2.36.2}/src/rapidata/api_client/models/compare_workflow_config.py

@@ -23,6 +23,7 @@ from rapidata.api_client.models.compare_workflow_config_metadata_value import Co
 from rapidata.api_client.models.compare_workflow_config_pair_maker_config import CompareWorkflowConfigPairMakerConfig
 from rapidata.api_client.models.compare_workflow_model1_referee import CompareWorkflowModel1Referee
 from rapidata.api_client.models.elo_config import EloConfig
+from rapidata.api_client.models.feature_flag import FeatureFlag
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -32,12 +33,13 @@ class CompareWorkflowConfig(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for CompareWorkflowConfig", alias="_t")
     criteria: StrictStr
-    elo_config: Optional[EloConfig] = Field(default=None, alias="eloConfig")
-    pair_maker_config: Optional[CompareWorkflowConfigPairMakerConfig] = Field(default=None, alias="pairMakerConfig")
     referee: CompareWorkflowModel1Referee
     target_country_codes: List[StrictStr] = Field(alias="targetCountryCodes")
     metadata: Dict[str, CompareWorkflowConfigMetadataValue]
-    __properties: ClassVar[List[str]] = ["_t", "criteria", "eloConfig", "pairMakerConfig", "referee", "targetCountryCodes", "metadata"]
+    elo_config: Optional[EloConfig] = Field(default=None, alias="eloConfig")
+    pair_maker_config: Optional[CompareWorkflowConfigPairMakerConfig] = Field(default=None, alias="pairMakerConfig")
+    feature_flags: Optional[List[FeatureFlag]] = Field(default=None, alias="featureFlags")
+    __properties: ClassVar[List[str]] = ["_t", "criteria", "referee", "targetCountryCodes", "metadata", "eloConfig", "pairMakerConfig", "featureFlags"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
@@ -85,12 +87,6 @@ class CompareWorkflowConfig(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of elo_config
-        if self.elo_config:
-            _dict['eloConfig'] = self.elo_config.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of pair_maker_config
-        if self.pair_maker_config:
-            _dict['pairMakerConfig'] = self.pair_maker_config.to_dict()
         # override the default output from pydantic by calling `to_dict()` of referee
         if self.referee:
             _dict['referee'] = self.referee.to_dict()
@@ -101,6 +97,19 @@ class CompareWorkflowConfig(BaseModel):
                 if self.metadata[_key_metadata]:
                     _field_dict[_key_metadata] = self.metadata[_key_metadata].to_dict()
             _dict['metadata'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of elo_config
+        if self.elo_config:
+            _dict['eloConfig'] = self.elo_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of pair_maker_config
+        if self.pair_maker_config:
+            _dict['pairMakerConfig'] = self.pair_maker_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in feature_flags (list)
+        _items = []
+        if self.feature_flags:
+            for _item_feature_flags in self.feature_flags:
+                if _item_feature_flags:
+                    _items.append(_item_feature_flags.to_dict())
+            _dict['featureFlags'] = _items
         return _dict
 
     @classmethod
@@ -115,8 +124,6 @@ class CompareWorkflowConfig(BaseModel):
         _obj = cls.model_validate({
             "_t": obj.get("_t") if obj.get("_t") is not None else 'CompareWorkflowConfig',
             "criteria": obj.get("criteria"),
-            "eloConfig": EloConfig.from_dict(obj["eloConfig"]) if obj.get("eloConfig") is not None else None,
-            "pairMakerConfig": CompareWorkflowConfigPairMakerConfig.from_dict(obj["pairMakerConfig"]) if obj.get("pairMakerConfig") is not None else None,
             "referee": CompareWorkflowModel1Referee.from_dict(obj["referee"]) if obj.get("referee") is not None else None,
             "targetCountryCodes": obj.get("targetCountryCodes"),
             "metadata": dict(
@@ -124,7 +131,10 @@ class CompareWorkflowConfig(BaseModel):
                 for _k, _v in obj["metadata"].items()
             )
             if obj.get("metadata") is not None
-            else None
+            else None,
+            "eloConfig": EloConfig.from_dict(obj["eloConfig"]) if obj.get("eloConfig") is not None else None,
+            "pairMakerConfig": CompareWorkflowConfigPairMakerConfig.from_dict(obj["pairMakerConfig"]) if obj.get("pairMakerConfig") is not None else None,
+            "featureFlags": [FeatureFlag.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None
         })
         return _obj