rapidata 2.33.0__tar.gz → 2.33.1__tar.gz

{rapidata-2.33.0 → rapidata-2.33.1}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapidata"
-version = "2.33.0"
+version = "2.33.1"
 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.33.0 → rapidata-2.33.1}/src/rapidata/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.33.0"
+__version__ = "2.33.1"
 
 from .rapidata_client import (
     RapidataClient,

rapidata-2.33.1/src/rapidata/rapidata_client/exceptions/failed_upload_exception.py

@@ -0,0 +1,53 @@
+from typing import cast
+from rapidata.api_client.models.file_asset_model import FileAssetModel
+from rapidata.api_client.models.get_failed_datapoints_result import GetFailedDatapointsResult
+from rapidata.api_client.models.multi_asset_model import MultiAssetModel
+from rapidata.api_client.models.original_filename_metadata_model import OriginalFilenameMetadataModel
+from rapidata.api_client.models.source_url_metadata_model import SourceUrlMetadataModel
+from rapidata.rapidata_client.datapoints.assets import MediaAsset, MultiAsset
+from rapidata.rapidata_client.datapoints.datapoint import Datapoint
+from rapidata.rapidata_client.order._rapidata_dataset import RapidataDataset
+from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
+
+class FailedUploadException(Exception):
+    """Custom error class for Failed Uploads to the Rapidata order."""
+    def __init__(
+        self, 
+        dataset: RapidataDataset,
+        order: RapidataOrder,
+        failed_uploads: list[Datapoint]
+    ):
+        self.dataset = dataset
+        self.order = order
+        self.failed_uploads = failed_uploads
+
+    def __str__(self) -> str:
+        return f"Failed to upload {self.failed_uploads}"
+
+
+def _parse_failed_uploads(failed_uploads: GetFailedDatapointsResult) -> list[Datapoint]:
+    failed_datapoints = failed_uploads.datapoints
+    if not failed_datapoints:
+        return []
+    if isinstance(failed_datapoints[0].asset.actual_instance, FileAssetModel):
+        failed_assets = [MediaAsset(__get_asset_name(cast(FileAssetModel, datapoint.asset.actual_instance))) for datapoint in failed_datapoints]
+    elif isinstance(failed_datapoints[0].asset.actual_instance, MultiAssetModel):
+        failed_assets = []
+        backend_assets = [cast(MultiAssetModel, failed_upload.asset.actual_instance).assets for failed_upload in failed_datapoints]
+        for assets in backend_assets:
+            failed_assets.append(MultiAsset([MediaAsset(__get_asset_name(cast(FileAssetModel, asset.actual_instance))) for asset in assets if isinstance(asset.actual_instance, FileAssetModel)]))
+    else:
+        raise ValueError(f"Unsupported asset type: {type(failed_datapoints[0].asset.actual_instance)}")
+    
+    return [Datapoint(asset=asset) for asset in failed_assets]
+
+def __get_asset_name(failed_datapoint: FileAssetModel) -> str:
+    metadata = failed_datapoint.metadata
+    if "sourceUrl" in metadata:
+        return cast(SourceUrlMetadataModel, metadata["sourceUrl"].actual_instance).url
+    elif "originalFilename" in metadata:
+        return cast(OriginalFilenameMetadataModel, metadata["originalFilename"].actual_instance).original_filename
+    else:
+        return ""
+
+

{rapidata-2.33.0 → rapidata-2.33.1}/src/rapidata/rapidata_client/order/_rapidata_order_builder.py

@@ -1,4 +1,4 @@
-from typing import Optional, cast, Sequence
+from typing import Literal, Optional, cast, Sequence
 
 from rapidata.api_client.models.ab_test_selection_a_inner import AbTestSelectionAInner
 from rapidata.api_client.models.and_user_filter_model_filters_inner import AndUserFilterModelFiltersInner
@@ -6,12 +6,10 @@ from rapidata.api_client.models.create_order_model import CreateOrderModel
 from rapidata.api_client.models.create_order_model_referee import CreateOrderModelReferee
 from rapidata.api_client.models.create_order_model_workflow import CreateOrderModelWorkflow
 
-from rapidata.rapidata_client.datapoints.assets import MediaAsset, TextAsset, MultiAsset, BaseAsset
 from rapidata.rapidata_client.datapoints.datapoint import Datapoint
-from rapidata.rapidata_client.exceptions.failed_upload_exception import FailedUploadException
+from rapidata.rapidata_client.exceptions.failed_upload_exception import FailedUploadException, _parse_failed_uploads
 from rapidata.rapidata_client.filter import RapidataFilter
 from rapidata.rapidata_client.logging import logger, managed_print
-from rapidata.rapidata_client.datapoints.metadata import Metadata
 from rapidata.rapidata_client.order._rapidata_dataset import RapidataDataset
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.referee import Referee
@@ -19,7 +17,6 @@ from rapidata.rapidata_client.referee._naive_referee import NaiveReferee
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 from rapidata.rapidata_client.settings import RapidataSetting
 from rapidata.rapidata_client.workflow import Workflow
-from rapidata.rapidata_client.workflow._compare_workflow import CompareWorkflow
 from rapidata.service.openapi_service import OpenAPIService
 
 
@@ -50,6 +47,7 @@ class RapidataOrderBuilder:
         self.__selections: list[RapidataSelection] = []
         self.__priority: int | None = None
         self.__datapoints: list[Datapoint] = []
+        self.__sticky_state: Literal["None", "Temporary", "Permanent"] | None = None
 
     def _to_model(self) -> CreateOrderModel:
         """
@@ -92,6 +90,7 @@ class RapidataOrderBuilder:
                 else None
             ),
             priority=self.__priority,
+            stickyState=self.__sticky_state,
         )
 
     def _create(self) -> RapidataOrder:
@@ -148,8 +147,12 @@ class RapidataOrderBuilder:
         
         logger.debug("Media added to the order.")
         logger.debug("Setting order to preview")
-        self.__openapi_service.order_api.order_order_id_preview_post(self.order_id)
-
+        try:
+            self.__openapi_service.order_api.order_order_id_preview_post(self.order_id)
+        except Exception:
+            failed_uploads = _parse_failed_uploads(self.__openapi_service.dataset_api.dataset_dataset_id_datapoints_failed_get(self.__dataset.id))
+            logger.error(f"Internal download error for datapoints: {failed_uploads}\nWARNING: Failed Datapoints in error do not contain metadata.")
+            raise FailedUploadException(self.__dataset, order, failed_uploads)
         return order
 
     def _workflow(self, workflow: Workflow) -> "RapidataOrderBuilder":
@@ -315,3 +318,13 @@ class RapidataOrderBuilder:
 
         self.__priority = priority
         return self
+    
+    def _sticky_state(self, sticky_state: Literal["None", "Temporary", "Permanent"] | None = None) -> "RapidataOrderBuilder":
+        """
+        Set the sticky state for the order.
+        """
+        if sticky_state is not None and sticky_state not in ["None", "Temporary", "Permanent"]:
+            raise TypeError("Sticky state must be of type Literal['None', 'Temporary', 'Permanent'].")
+
+        self.__sticky_state = sticky_state
+        return self

{rapidata-2.33.0 → rapidata-2.33.1}/src/rapidata/rapidata_client/order/rapidata_order.py

@@ -12,6 +12,8 @@ from tqdm import tqdm
 from rapidata.api_client.exceptions import ApiException
 from rapidata.api_client.models.campaign_artifact_model import CampaignArtifactModel
 from rapidata.api_client.models.order_state import OrderState
+from rapidata.api_client.models.preview_order_model import PreviewOrderModel
+from rapidata.api_client.models.submit_order_model import SubmitOrderModel
 from rapidata.api_client.models.preliminary_download_model import PreliminaryDownloadModel
 from rapidata.api_client.models.workflow_artifact_model import WorkflowArtifactModel
 from rapidata.rapidata_client.order.rapidata_results import RapidataResults
@@ -60,7 +62,7 @@ class RapidataOrder:
     def run(self) -> "RapidataOrder":
         """Runs the order to start collecting responses."""
         logger.info(f"Starting order '{self}'")
-        self.__openapi_service.order_api.order_order_id_submit_post(self.id)
+        self.__openapi_service.order_api.order_order_id_submit_post(self.id, SubmitOrderModel(ignoreFailedDatapoints=True))
         logger.debug(f"Order '{self}' has been started.")
         managed_print(f"Order '{self.name}' is now viewable under: {self.order_details_page}")
         return self
@@ -203,7 +205,7 @@ class RapidataOrder:
         logger.info("Opening order preview in browser...")
         if self.get_status() == OrderState.CREATED:
             logger.info("Order is still in state created. Setting it to preview.")
-            self.__openapi_service.order_api.order_order_id_preview_post(self.id)
+            self.__openapi_service.order_api.order_order_id_preview_post(self.id, PreviewOrderModel(ignoreFailedDatapoints=True))
             logger.info("Order is now in preview state.")
 
         campaign_id = self.__get_campaign_id()

{rapidata-2.33.0 → rapidata-2.33.1}/src/rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -51,6 +51,7 @@ class RapidataOrderManager:
         self.settings = RapidataSettings
         self.selections = RapidataSelections
         self.__priority: int | None = None
+        self.__sticky_state: Literal["None", "Temporary", "Permanent"] | None = None
         logger.debug("RapidataOrderManager initialized")
     
     def _create_general_order(self,
@@ -124,13 +125,26 @@ class RapidataOrderManager:
                  ._settings(settings)
                  ._validation_set_id(validation_set_id if not selections else None)
                  ._priority(self.__priority)
+                 ._sticky_state(self.__sticky_state)
                  ._create()
                  )
         return order
     
     def _set_priority(self, priority: int):
+        if not isinstance(priority, int):
+            raise TypeError("Priority must be an integer")
+        
+        if priority < 0:
+            raise ValueError("Priority must be greater than 0")
+        
         self.__priority = priority
         
+    def _set_sticky_state(self, sticky_state: Literal["None", "Temporary", "Permanent"]):
+        if sticky_state not in ["None", "Temporary", "Permanent"]:
+            raise ValueError("Sticky state must be one of 'None', 'Temporary', 'Permanent'")
+        
+        self.__sticky_state = sticky_state
+        
     def create_classification_order(self,
             name: str,
             instruction: str,

rapidata-2.33.0/src/rapidata/rapidata_client/exceptions/failed_upload_exception.py

@@ -1,19 +0,0 @@
-from rapidata.rapidata_client.datapoints.datapoint import Datapoint
-from rapidata.rapidata_client.order._rapidata_dataset import RapidataDataset
-from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
-
-
-class FailedUploadException(Exception):
-    """Custom error class for Failed Uploads to the Rapidata order."""
-    def __init__(
-        self, 
-        dataset: RapidataDataset,
-        order: RapidataOrder,
-        failed_uploads: list[Datapoint]
-    ):
-        self.dataset = dataset
-        self.order = order
-        self.failed_uploads = failed_uploads
-
-    def __str__(self) -> str:
-        return f"Failed to upload {self.failed_uploads}"