rapidata 2.41.3__py3-none-any.whl → 2.42.1__py3-none-any.whl

rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -2,16 +2,10 @@ from typing import Sequence, Optional, Literal
 from itertools import zip_longest
 
 from rapidata.rapidata_client.config.tracer import tracer
+from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
 from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.order._rapidata_order_builder import RapidataOrderBuilder
-from rapidata.rapidata_client.datapoints.metadata import (
-    PromptMetadata,
-    SelectWordsMetadata,
-    PrivateTextMetadata,
-    MediaAssetMetadata,
-    Metadata,
-)
 from rapidata.rapidata_client.referee._naive_referee import NaiveReferee
 from rapidata.rapidata_client.referee._early_stopping_referee import (
     EarlyStoppingReferee,
@@ -28,13 +22,17 @@ from rapidata.rapidata_client.workflow import (
     TimestampWorkflow,
     RankingWorkflow,
 )
-from rapidata.rapidata_client.datapoints.assets import MediaAsset, TextAsset, MultiAsset
 from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.rapidata_client.datapoints.metadata import (
+    PromptMetadata,
+    MediaAssetMetadata,
+)
 from rapidata.rapidata_client.filter import RapidataFilter
 from rapidata.rapidata_client.filter.rapidata_filters import RapidataFilters
 from rapidata.rapidata_client.settings import RapidataSettings, RapidataSetting
 from rapidata.rapidata_client.selection.rapidata_selections import RapidataSelections
 from rapidata.rapidata_client.config import logger, rapidata_config
+from rapidata.rapidata_client.datapoints._asset_uploader import AssetUploader
 
 from rapidata.api_client.models.query_model import QueryModel
 from rapidata.api_client.models.page_info import PageInfo
@@ -64,13 +62,15 @@ class RapidataOrderManager:
         self.selections = RapidataSelections
         self.__priority: int | None = None
         self.__sticky_state: Literal["None", "Temporary", "Permanent"] | None = None
+        self.__asset_uploader = AssetUploader(openapi_service)
         logger.debug("RapidataOrderManager initialized")
 
     def _create_general_order(
         self,
         name: str,
         workflow: Workflow,
-        assets: list[MediaAsset] | list[TextAsset] | list[MultiAsset],
+        assets: list[str] | list[list[str]],
+        data_type: Literal["media", "text"] = "media",
         responses_per_datapoint: int = 10,
         contexts: list[str] | None = None,
         media_contexts: list[str] | None = None,
@@ -89,22 +89,9 @@ class RapidataOrderManager:
         if contexts and len(contexts) != len(assets):
             raise ValueError("Number of contexts must match number of datapoints")
 
-        if contexts:
-            if any(not isinstance(context, str) for context in contexts) or any(
-                len(context) == 0 for context in contexts
-            ):
-                raise ValueError(
-                    "Contexts must all be strings that are not empty\nProvide list of strings or set contexts to None"
-                )
-
         if media_contexts and len(media_contexts) != len(assets):
             raise ValueError("Number of media contexts must match number of datapoints")
 
-        if media_contexts:
-            for media_context in media_contexts:
-                if not media_context.startswith("http"):
-                    raise ValueError("Media contexts must all be URLs")
-
         if sentences and len(sentences) != len(assets):
             raise ValueError("Number of sentences must match number of datapoints")
 
@@ -122,11 +109,15 @@ class RapidataOrderManager:
                 max_vote_count=responses_per_datapoint,
             )
 
+        if data_type not in ["media", "text"]:
+            raise ValueError("Data type must be one of 'media' or 'text'")
+
         logger.debug(
-            "Creating order with parameters: name %s, workflow %s, assets %s, responses_per_datapoint %s, contexts %s, media_contexts %s, validation_set_id %s, confidence_threshold %s, filters %s, settings %s, sentences %s, selections %s, private_notes %s",
+            "Creating order with parameters: name %s, workflow %s, datapoints %s, data_type %s, responses_per_datapoint %s, contexts %s, media_contexts %s, validation_set_id %s, confidence_threshold %s, filters %s, settings %s, sentences %s, selections %s, private_notes %s",
             name,
             workflow,
             assets,
+            data_type,
             responses_per_datapoint,
             contexts,
             media_contexts,
@@ -148,45 +139,25 @@ class RapidataOrderManager:
                 "Warning: Both selections and validation_set_id provided. Ignoring validation_set_id."
             )
 
-        prompts_metadata = (
-            [PromptMetadata(prompt=prompt) for prompt in contexts] if contexts else None
-        )
-        sentence_metadata = (
-            [SelectWordsMetadata(select_words=sentence) for sentence in sentences]
-            if sentences
-            else None
-        )
-
-        if prompts_metadata and sentence_metadata:
-            raise ValueError("You can only use contexts or sentences, not both")
-
-        asset_metadata: Sequence[Metadata] = (
-            [MediaAssetMetadata(url=context) for context in media_contexts]
-            if media_contexts
-            else []
-        )
-        prompt_metadata: Sequence[Metadata] = (
-            prompts_metadata or sentence_metadata or []
-        )
-        private_notes_metadata: Sequence[Metadata] = (
-            [PrivateTextMetadata(text=text) for text in private_notes]
-            if private_notes
-            else []
-        )
-
-        multi_metadata = [
-            [item for item in items if item is not None]
-            for items in zip_longest(
-                prompt_metadata, asset_metadata, private_notes_metadata
-            )
-        ]
-
         order = (
             order_builder._workflow(workflow)
             ._datapoints(
                 datapoints=[
-                    Datapoint(asset=asset, metadata=metadata)
-                    for asset, metadata in zip_longest(assets, multi_metadata)
+                    Datapoint(
+                        asset=asset,
+                        data_type=data_type,
+                        context=context,
+                        media_context=media_context,
+                        sentence=sentence,
+                        private_note=private_note,
+                    )
+                    for asset, context, media_context, sentence, private_note in zip_longest(
+                        assets,
+                        contexts or [],
+                        media_contexts or [],
+                        sentences or [],
+                        private_notes or [],
+                    )
                 ]
             )
             ._referee(referee)
@@ -269,21 +240,18 @@ class RapidataOrderManager:
         with tracer.start_as_current_span(
             "RapidataOrderManager.create_classification_order"
         ):
-            if data_type == "media":
-                assets = [MediaAsset(path=path) for path in datapoints]
-            elif data_type == "text":
-                assets = [TextAsset(text=text) for text in datapoints]
-            else:
-                raise ValueError(
-                    f"Unsupported data type: {data_type}, must be one of 'media' or 'text'"
-                )
+            if not isinstance(datapoints, list) or not all(
+                isinstance(datapoint, str) for datapoint in datapoints
+            ):
+                raise ValueError("Datapoints must be a list of strings")
 
             return self._create_general_order(
                 name=name,
                 workflow=ClassifyWorkflow(
                     instruction=instruction, answer_options=answer_options
                 ),
-                assets=assets,
+                assets=datapoints,
+                data_type=data_type,
                 responses_per_datapoint=responses_per_datapoint,
                 contexts=contexts,
                 media_contexts=media_contexts,
@@ -350,7 +318,7 @@ class RapidataOrderManager:
                 This will NOT be shown to the labelers but will be included in the result purely for your own reference.
         """
         with tracer.start_as_current_span("RapidataOrderManager.create_compare_order"):
-            if any(type(datapoint) != list for datapoint in datapoints):
+            if any(not isinstance(datapoint, list) for datapoint in datapoints):
                 raise ValueError("Each datapoint must be a list of 2 paths/texts")
 
             if any(len(datapoint) != 2 for datapoint in datapoints):
@@ -361,25 +329,11 @@ class RapidataOrderManager:
                     "A_B_naming must be a list of exactly two strings or None"
                 )
 
-            if data_type == "media":
-                assets = [
-                    MultiAsset([MediaAsset(path=path) for path in datapoint])
-                    for datapoint in datapoints
-                ]
-            elif data_type == "text":
-                assets = [
-                    MultiAsset([TextAsset(text=text) for text in datapoint])
-                    for datapoint in datapoints
-                ]
-            else:
-                raise ValueError(
-                    f"Unsupported data type: {data_type}, must be one of 'media' or 'text'"
-                )
-
             return self._create_general_order(
                 name=name,
                 workflow=CompareWorkflow(instruction=instruction, a_b_names=a_b_names),
-                assets=assets,
+                assets=datapoints,
+                data_type=data_type,
                 responses_per_datapoint=responses_per_datapoint,
                 contexts=contexts,
                 media_contexts=media_contexts,
@@ -401,6 +355,7 @@ class RapidataOrderManager:
         data_type: Literal["media", "text"] = "media",
         random_comparisons_ratio: float = 0.5,
         context: Optional[str] = None,
+        media_context: Optional[str] = None,
         validation_set_id: Optional[str] = None,
         filters: Sequence[RapidataFilter] = [],
         settings: Sequence[RapidataSetting] = [],
@@ -424,6 +379,8 @@ class RapidataOrderManager:
                 The rest will focus on pairing similarly ranked datapoints. Defaults to 0.5 and can be left untouched.
             context (str, optional): The context for all the comparison. Defaults to None.\n
                 If provided will be shown in addition to the instruction for all the matchups.
+            media_context (str, optional): The media context for all the comparison. Defaults to None.\n
+                If provided will be shown in addition to the instruction for all the matchups.
             validation_set_id (str, optional): The ID of the validation set. Defaults to None.\n
                 If provided, one validation task will be shown infront of the datapoints that will be labeled.
             filters (Sequence[RapidataFilter], optional): The list of filters for the order. Defaults to []. Decides who the tasks should be shown to.
@@ -435,13 +392,18 @@ class RapidataOrderManager:
             if len(datapoints) < 2:
                 raise ValueError("At least two datapoints are required")
 
-            if data_type == "media":
-                assets = [MediaAsset(path=path) for path in datapoints]
-            elif data_type == "text":
-                assets = [TextAsset(text=text) for text in datapoints]
-            else:
-                raise ValueError(
-                    f"Unsupported data type: {data_type}, must be one of 'media' or 'text'"
+            metadatas: list[Metadata] = []
+            if context:
+                if not isinstance(context, str) or context == "":
+                    raise ValueError("Context must be a non-empty string")
+                metadatas.append(PromptMetadata(context))
+            if media_context:
+                if not isinstance(media_context, str) or media_context == "":
+                    raise ValueError("Media context must be a non-empty string")
+                metadatas.append(
+                    MediaAssetMetadata(
+                        self.__asset_uploader.upload_asset(media_context)
+                    )
                 )
 
             return self._create_general_order(
@@ -450,9 +412,10 @@ class RapidataOrderManager:
                     criteria=instruction,
                     total_comparison_budget=total_comparison_budget,
                     random_comparisons_ratio=random_comparisons_ratio,
-                    context=context,
+                    metadatas=metadatas,
                 ),
-                assets=assets,
+                assets=datapoints,
+                data_type=data_type,
                 responses_per_datapoint=responses_per_comparison,
                 validation_set_id=validation_set_id,
                 filters=filters,
@@ -502,20 +465,11 @@ class RapidataOrderManager:
         with tracer.start_as_current_span(
             "RapidataOrderManager.create_free_text_order"
         ):
-
-            if data_type == "media":
-                assets = [MediaAsset(path=path) for path in datapoints]
-            elif data_type == "text":
-                assets = [TextAsset(text=text) for text in datapoints]
-            else:
-                raise ValueError(
-                    f"Unsupported data type: {data_type}, must be one of 'media' or 'text'"
-                )
-
             return self._create_general_order(
                 name=name,
                 workflow=FreeTextWorkflow(instruction=instruction),
-                assets=assets,
+                assets=datapoints,
+                data_type=data_type,
                 responses_per_datapoint=responses_per_datapoint,
                 contexts=contexts,
                 media_contexts=media_contexts,
@@ -563,14 +517,12 @@ class RapidataOrderManager:
         with tracer.start_as_current_span(
             "RapidataOrderManager.create_select_words_order"
         ):
-            assets = [MediaAsset(path=path) for path in datapoints]
-
             return self._create_general_order(
                 name=name,
                 workflow=SelectWordsWorkflow(
                     instruction=instruction,
                 ),
-                assets=assets,
+                assets=datapoints,
                 responses_per_datapoint=responses_per_datapoint,
                 validation_set_id=validation_set_id,
                 filters=filters,
@@ -619,12 +571,11 @@ class RapidataOrderManager:
                 This will NOT be shown to the labelers but will be included in the result purely for your own reference.
         """
         with tracer.start_as_current_span("RapidataOrderManager.create_locate_order"):
-            assets = [MediaAsset(path=path) for path in datapoints]
 
             return self._create_general_order(
                 name=name,
                 workflow=LocateWorkflow(target=instruction),
-                assets=assets,
+                assets=datapoints,
                 responses_per_datapoint=responses_per_datapoint,
                 contexts=contexts,
                 media_contexts=media_contexts,
@@ -674,12 +625,11 @@ class RapidataOrderManager:
                 This will NOT be shown to the labelers but will be included in the result purely for your own reference.
         """
         with tracer.start_as_current_span("RapidataOrderManager.create_draw_order"):
-            assets = [MediaAsset(path=path) for path in datapoints]
 
             return self._create_general_order(
                 name=name,
                 workflow=DrawWorkflow(target=instruction),
-                assets=assets,
+                assets=datapoints,
                 responses_per_datapoint=responses_per_datapoint,
                 contexts=contexts,
                 media_contexts=media_contexts,
@@ -735,22 +685,10 @@ class RapidataOrderManager:
         with tracer.start_as_current_span(
             "RapidataOrderManager.create_timestamp_order"
         ):
-            assets = [MediaAsset(path=path) for path in datapoints]
-
-            for asset in tqdm(
-                assets,
-                desc="Downloading assets and checking duration",
-                disable=rapidata_config.logging.silent_mode,
-            ):
-                if not asset.get_duration():
-                    raise ValueError(
-                        "The datapoints for this order must have a duration. (e.g. video or audio)"
-                    )
-
             return self._create_general_order(
                 name=name,
                 workflow=TimestampWorkflow(instruction=instruction),
-                assets=assets,
+                assets=datapoints,
                 responses_per_datapoint=responses_per_datapoint,
                 contexts=contexts,
                 media_contexts=media_contexts,

rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -8,6 +8,9 @@ from rapidata.api_client.models.update_validation_set_model import (
     UpdateValidationSetModel,
 )
 from rapidata.api_client.models.update_should_alert_model import UpdateShouldAlertModel
+from rapidata.rapidata_client.validation.rapids._validation_rapid_uploader import (
+    ValidationRapidUploader,
+)
 
 
 class RapidataValidationSet:
@@ -28,7 +31,8 @@ class RapidataValidationSet:
         self.validation_set_details_page = (
             f"https://app.{openapi_service.environment}/validation-set/detail/{self.id}"
         )
-        self.__openapi_service = openapi_service
+        self._openapi_service = openapi_service
+        self.validation_rapid_uploader = ValidationRapidUploader(openapi_service)
 
     def add_rapid(self, rapid: Rapid):
         """Add a Rapid to the validation set.
@@ -38,7 +42,7 @@ class RapidataValidationSet:
         """
         with tracer.start_as_current_span("RapidataValidationSet.add_rapid"):
             logger.debug("Adding rapid %s to validation set %s", rapid, self.id)
-            rapid._add_to_validation_set(self.id, self.__openapi_service)
+            self.validation_rapid_uploader.upload_rapid(rapid, self.id)
         return self
 
     def update_dimensions(self, dimensions: list[str]):
@@ -51,7 +55,7 @@ class RapidataValidationSet:
             logger.debug(
                 "Updating dimensions for validation set %s to %s", self.id, dimensions
             )
-            self.__openapi_service.validation_api.validation_set_validation_set_id_patch(
+            self._openapi_service.validation_api.validation_set_validation_set_id_patch(
                 self.id, UpdateValidationSetModel(dimensions=dimensions)
             )
             return self
@@ -69,7 +73,7 @@ class RapidataValidationSet:
             logger.debug(
                 "Setting shouldAlert for validation set %s to %s", self.id, should_alert
             )
-            self.__openapi_service.validation_api.validation_set_validation_set_id_patch(
+            self._openapi_service.validation_api.validation_set_validation_set_id_patch(
                 self.id, UpdateValidationSetModel(shouldAlert=should_alert)
             )
             return self
@@ -97,7 +101,7 @@ class RapidataValidationSet:
         """Deletes the validation set"""
         with tracer.start_as_current_span("RapidataValidationSet.delete"):
             logger.info("Deleting ValidationSet '%s'", self)
-            self.__openapi_service.validation_api.validation_set_validation_set_id_delete(
+            self._openapi_service.validation_api.validation_set_validation_set_id_delete(
                 self.id
             )
             logger.debug("ValidationSet '%s' has been deleted.", self)

rapidata/rapidata_client/validation/rapids/_validation_rapid_uploader.py

@@ -0,0 +1,101 @@
+from rapidata.rapidata_client.validation.rapids.rapids import Rapid
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.api_client.models.multi_asset_input_assets_inner import (
+    MultiAssetInput,
+    MultiAssetInputAssetsInner,
+)
+from rapidata.api_client.models.add_validation_rapid_new_model import (
+    AddValidationRapidNewModel,
+)
+from rapidata.api_client.models.add_validation_rapid_model_truth import (
+    AddValidationRapidModelTruth,
+)
+from rapidata.api_client.models.create_datapoint_from_files_model_metadata_inner import (
+    CreateDatapointFromFilesModelMetadataInner,
+)
+from rapidata.api_client.models.existing_asset_input import ExistingAssetInput
+from rapidata.rapidata_client.datapoints._asset_uploader import AssetUploader
+from rapidata.rapidata_client.datapoints.metadata import (
+    PromptMetadata,
+    MediaAssetMetadata,
+    SelectWordsMetadata,
+    Metadata,
+)
+from rapidata.api_client.models.add_validation_rapid_new_model_asset import (
+    AddValidationRapidNewModelAsset,
+)
+from rapidata.api_client.models.text_asset_input import TextAssetInput
+from rapidata.api_client.models.add_validation_rapid_model_payload import (
+    AddValidationRapidModelPayload,
+)
+
+
+class ValidationRapidUploader:
+    def __init__(self, openapi_service: OpenAPIService):
+        self.openapi_service = openapi_service
+        self.asset_uploader = AssetUploader(openapi_service)
+
+    def upload_rapid(self, rapid: Rapid, validation_set_id: str) -> None:
+        metadata = self._get_metadata(rapid)
+
+        uploaded_asset = (
+            self._handle_media_rapid(rapid)
+            if rapid.data_type == "media"
+            else self._handle_text_rapid(rapid)
+        )
+
+        self.openapi_service.validation_api.validation_set_validation_set_id_rapid_new_post(
+            validation_set_id=validation_set_id,
+            add_validation_rapid_new_model=AddValidationRapidNewModel(
+                asset=uploaded_asset,
+                metadata=metadata,
+                payload=self._get_payload(rapid),
+                truth=AddValidationRapidModelTruth(actual_instance=rapid.truth),
+                featureFlags=(
+                    [setting._to_feature_flag() for setting in rapid.settings]
+                    if rapid.settings
+                    else None
+                ),
+            ),
+        )
+
+    def _get_payload(self, rapid: Rapid) -> AddValidationRapidModelPayload:
+        if isinstance(rapid.payload, dict):
+            return AddValidationRapidModelPayload(actual_instance=rapid.payload)
+        return AddValidationRapidModelPayload(actual_instance=rapid.payload.to_dict())
+
+    def _get_metadata(
+        self, rapid: Rapid
+    ) -> list[CreateDatapointFromFilesModelMetadataInner]:
+        rapid_metadata: list[Metadata] = []
+        if rapid.context:
+            rapid_metadata.append(PromptMetadata(prompt=rapid.context))
+        if rapid.sentence:
+            rapid_metadata.append(SelectWordsMetadata(select_words=rapid.sentence))
+        if rapid.media_context:
+            rapid_metadata.append(
+                MediaAssetMetadata(
+                    internal_file_name=self.asset_uploader.upload_asset(
+                        rapid.media_context
+                    )
+                )
+            )
+
+        metadata = [
+            CreateDatapointFromFilesModelMetadataInner(
+                actual_instance=metadata.to_model()
+            )
+            for metadata in rapid_metadata
+        ]
+
+        return metadata
+
+    def _handle_text_rapid(self, rapid: Rapid) -> AddValidationRapidNewModelAsset:
+        return AddValidationRapidNewModelAsset(
+            actual_instance=self.asset_uploader.get_uploaded_text_input(rapid.asset),
+        )
+
+    def _handle_media_rapid(self, rapid: Rapid) -> AddValidationRapidNewModelAsset:
+        return AddValidationRapidNewModelAsset(
+            actual_instance=self.asset_uploader.get_uploaded_asset_input(rapid.asset),
+        )

rapidata/rapidata_client/validation/rapids/box.py

@@ -1,19 +1,43 @@
 from rapidata.api_client.models.box_shape import BoxShape
+from pydantic import BaseModel, field_validator, model_validator
 
 
-class Box:
+class Box(BaseModel):
     """
-    Used in the Locate and Draw Validation sets. All coordinates are in pixels.
+    Used in the Locate and Draw Validation sets. All coordinates are in ratio of the image size (0.0 to 1.0).
 
     Args:
-        x_min (float): The minimum x value of the box.
-        y_min (float): The minimum y value of the box.
-        x_max (float): The maximum x value of the box.
-        y_max (float): The maximum y value of the box.
+        x_min (float): The minimum x value of the box in ratio of the image size.
+        y_min (float): The minimum y value of the box in ratio of the image size.
+        x_max (float): The maximum x value of the box in ratio of the image size.
+        y_max (float): The maximum y value of the box in ratio of the image size.
     """
 
-    def __init__(self, x_min: float, y_min: float, x_max: float, y_max: float):
-        self.x_min = x_min
-        self.y_min = y_min
-        self.x_max = x_max
-        self.y_max = y_max
+    x_min: float
+    y_min: float
+    x_max: float
+    y_max: float
+
+    @field_validator("x_min", "y_min", "x_max", "y_max")
+    @classmethod
+    def coordinates_between_zero_and_one(cls, v: float) -> float:
+        if not (0.0 <= v <= 1.0):
+            raise ValueError("Box coordinates must be between 0 and 1")
+        return v
+
+    @model_validator(mode="after")
+    def check_min_less_than_max(self) -> "Box":
+        if self.x_min >= self.x_max:
+            raise ValueError("x_min must be less than x_max")
+        if self.y_min >= self.y_max:
+            raise ValueError("y_min must be less than y_max")
+        return self
+
+    def to_model(self) -> BoxShape:
+        return BoxShape(
+            _t="BoxShape",
+            xMin=self.x_min * 100,
+            yMin=self.y_min * 100,
+            xMax=self.x_max * 100,
+            yMax=self.y_max * 100,
+        )