rapidata 2.33.0__py3-none-any.whl → 2.33.2__py3-none-any.whl

rapidata/__init__.py

@@ -1,10 +1,10 @@
-__version__ = "2.33.0"
+__version__ = "2.33.2"
 
 from .rapidata_client import (
     RapidataClient,
     DemographicSelection,
     LabelingSelection,
-    EffortEstimationSelection,
+    EffortSelection,
     RetrievalMode,
     ValidationSelection,
     ConditionalValidationSelection,

rapidata/rapidata_client/__init__.py

@@ -7,7 +7,7 @@ from .selection import (
     CappedSelection,
     ShufflingSelection,
     RetrievalMode,
-    EffortEstimationSelection,
+    EffortSelection,
 )
 from .datapoints import Datapoint
 from .datapoints.metadata import (

rapidata/rapidata_client/benchmark/participant/_participant.py

@@ -0,0 +1,102 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from tqdm import tqdm
+
+from rapidata.rapidata_client.datapoints.assets import MediaAsset
+from rapidata.rapidata_client.logging import logger
+from rapidata.rapidata_client.logging.output_manager import RapidataOutputManager
+from rapidata.api_client.models.create_sample_model import CreateSampleModel
+from rapidata.service.openapi_service import OpenAPIService
+
+
+class BenchmarkParticipant:
+    def __init__(self, name: str, id: str, openapi_service: OpenAPIService):
+        self.name = name
+        self.id = id
+        self.__openapi_service = openapi_service
+
+    def _process_single_sample_upload(
+        self,
+        asset: MediaAsset,
+        identifier: str,
+    ) -> tuple[MediaAsset | None, MediaAsset | None]:
+        """
+        Process single sample upload with retry logic and error tracking.
+        
+        Args:
+            asset: MediaAsset to upload
+            identifier: Identifier for the sample
+            
+        Returns:
+            tuple[MediaAsset | None, MediaAsset | None]: (successful_asset, failed_asset)
+        """
+        if asset.is_local():
+            files = [asset.to_file()]
+            urls = []
+        else:
+            files = []
+            urls = [asset.path]
+
+        last_exception = None
+        try:
+            self.__openapi_service.participant_api.participant_participant_id_sample_post(
+                participant_id=self.id,
+                model=CreateSampleModel(
+                    identifier=identifier
+                ),
+                files=files,
+                urls=urls
+            )
+            
+            return asset, None
+            
+        except Exception as e:
+            last_exception = e
+
+        logger.error(f"Upload failed for {identifier}. Error: {str(last_exception)}")
+        return None, asset
+
+    def upload_media(
+        self,
+        assets: list[MediaAsset],
+        identifiers: list[str],
+        max_workers: int = 10,
+    ) -> tuple[list[MediaAsset], list[MediaAsset]]:
+        """
+        Upload samples concurrently with proper error handling and progress tracking.
+        
+        Args:
+            assets: List of MediaAsset objects to upload
+            identifiers: List of identifiers matching the assets
+            max_workers: Maximum number of concurrent upload workers
+            
+        Returns:
+            tuple[list[str], list[str]]: Lists of successful and failed identifiers
+        """
+        successful_uploads: list[MediaAsset] = []
+        failed_uploads: list[MediaAsset] = []
+        total_uploads = len(assets)
+        
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = [
+                executor.submit(
+                    self._process_single_sample_upload,
+                    asset,
+                    identifier,
+                )
+                for asset, identifier in zip(assets, identifiers)
+            ]
+            
+            with tqdm(total=total_uploads, desc="Uploading media", disable=RapidataOutputManager.silent_mode) as pbar:
+                for future in as_completed(futures):
+                    try:
+                        successful_id, failed_id = future.result()
+                        if successful_id:
+                            successful_uploads.append(successful_id)
+                        if failed_id:
+                            failed_uploads.append(failed_id)
+                    except Exception as e:
+                        logger.error(f"Future execution failed: {str(e)}")
+                        
+                    pbar.update(1)
+        
+        return successful_uploads, failed_uploads

rapidata/rapidata_client/benchmark/rapidata_benchmark.py

@@ -11,14 +11,13 @@ from rapidata.api_client.models.url_asset_input import UrlAssetInput
 from rapidata.api_client.models.file_asset_model import FileAssetModel
 from rapidata.api_client.models.source_url_metadata_model import SourceUrlMetadataModel
 
+
+from rapidata.rapidata_client.benchmark.participant._participant import BenchmarkParticipant
 from rapidata.rapidata_client.logging import logger
 from rapidata.service.openapi_service import OpenAPIService
 
 from rapidata.rapidata_client.benchmark.leaderboard.rapidata_leaderboard import RapidataLeaderboard
-from rapidata.rapidata_client.datapoints.metadata import PromptIdentifierMetadata
 from rapidata.rapidata_client.datapoints.assets import MediaAsset
-from rapidata.rapidata_client.order._rapidata_dataset import RapidataDataset
-from rapidata.rapidata_client.datapoints.datapoint import Datapoint
 
 class RapidataBenchmark:
     """
@@ -250,7 +249,7 @@ class RapidataBenchmark:
             leaderboard_result.id,
             self.__openapi_service
         )
-    
+
     def evaluate_model(self, name: str, media: list[str], identifiers: list[str]) -> None:
         """
         Evaluates a model on the benchmark across all leaderboards.
@@ -272,11 +271,9 @@ class RapidataBenchmark:
 \nTo see the prompts that are associated with the identifiers, use the prompts property.")
         
         # happens before the creation of the participant to ensure all media paths are valid
-        assets = []
-        prompts_metadata: list[list[PromptIdentifierMetadata]] = []
-        for media_path, identifier in zip(media, identifiers):
+        assets: list[MediaAsset] = []
+        for media_path in media:
             assets.append(MediaAsset(media_path))
-            prompts_metadata.append([PromptIdentifierMetadata(identifier=identifier)])
 
         participant_result = self.__openapi_service.benchmark_api.benchmark_benchmark_id_participants_post(
             benchmark_id=self.id,
@@ -285,22 +282,27 @@ class RapidataBenchmark:
             )
         )
 
-        dataset = RapidataDataset(participant_result.dataset_id, self.__openapi_service)
-        
-        try:
-            dataset.add_datapoints([Datapoint(asset=asset, metadata=metadata) for asset, metadata in zip(assets, prompts_metadata)])
-        except Exception as e:
-            logger.warning(f"An error occurred while adding datapoints to the dataset: {e}")
-            upload_progress = self.__openapi_service.dataset_api.dataset_dataset_id_progress_get(
-                dataset_id=dataset.id
-            )
-            if upload_progress.ready == 0:
-                raise RuntimeError("None of the media was uploaded successfully. Please check the media paths and try again.")
-            
-            logger.warning(f"{upload_progress.failed} datapoints failed to upload. \n{upload_progress.ready} datapoints were uploaded successfully. \nEvaluation will continue with the uploaded datapoints.")
+        logger.info(f"Participant created: {participant_result.participant_id}")
 
-        self.__openapi_service.benchmark_api.benchmark_benchmark_id_participants_participant_id_submit_post(
-            benchmark_id=self.id,
+        participant = BenchmarkParticipant(name, participant_result.participant_id, self.__openapi_service)
+
+        successful_uploads, failed_uploads = participant.upload_media(
+            assets,
+            identifiers,
+        )
+
+        total_uploads = len(assets)
+        success_rate = (len(successful_uploads) / total_uploads * 100) if total_uploads > 0 else 0
+        logger.info(f"Upload complete: {len(successful_uploads)} successful, {len(failed_uploads)} failed ({success_rate:.1f}% success rate)")
+
+        if failed_uploads:
+            logger.error(f"Failed uploads for media: {[asset.path for asset in failed_uploads]}")
+            logger.warning("Some uploads failed. The model evaluation may be incomplete.")
+
+        if len(successful_uploads) == 0:
+            raise RuntimeError("No uploads were successful. The model evaluation will not be completed.")
+
+        self.__openapi_service.participant_api.participants_participant_id_submit_post(
             participant_id=participant_result.participant_id
         )
 

rapidata/rapidata_client/exceptions/failed_upload_exception.py

@@ -1,8 +1,14 @@
+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__(
@@ -17,3 +23,31 @@ class FailedUploadException(Exception):
 
     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/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/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/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/rapidata_client/selection/__init__.py

@@ -8,4 +8,4 @@ from .shuffling_selection import ShufflingSelection
 from .ab_test_selection import AbTestSelection
 from .static_selection import StaticSelection
 from .retrieval_modes import RetrievalMode
-from .effort_selection import EffortEstimationSelection
+from .effort_selection import EffortSelection

rapidata/rapidata_client/selection/effort_selection.py

@@ -3,9 +3,16 @@ from rapidata.api_client.models.effort_capped_selection import EffortCappedSelec
 from rapidata.rapidata_client.selection.retrieval_modes import RetrievalMode
 
 
-class EffortEstimationSelection(RapidataSelection):
-    
+class EffortSelection(RapidataSelection):
+    """
+    With this selection you can define the effort budget you have for a task.
+    As an example, you have a task that takes 10 seconds to complete. The effort budget would be 10.
 
+    Args:
+        effort_budget (int): The effort budget for the task.
+        retrieval_mode (RetrievalMode): The retrieval mode for the task.
+        max_iterations (int | None): The maximum number of iterations for the task.
+    """
     def __init__(self, effort_budget: int, retrieval_mode: RetrievalMode = RetrievalMode.Shuffled, max_iterations: int | None = None):
         self.effort_budget = effort_budget
         self.retrieval_mode = retrieval_mode

rapidata/service/openapi_service.py

@@ -10,6 +10,7 @@ from rapidata.api_client.api.rapid_api import RapidApi
 from rapidata.api_client.api.leaderboard_api import LeaderboardApi
 from rapidata.api_client.api.validation_set_api import ValidationSetApi
 from rapidata.api_client.api.workflow_api import WorkflowApi
+from rapidata.api_client.api.participant_api import ParticipantApi
 from rapidata.api_client.configuration import Configuration
 from rapidata.service.credential_manager import CredentialManager
 from rapidata.rapidata_client.api.rapidata_exception import RapidataApiClient
@@ -117,6 +118,10 @@ class OpenAPIService:
     @property
     def benchmark_api(self) -> BenchmarkApi:
         return BenchmarkApi(self.api_client)
+    
+    @property
+    def participant_api(self) -> ParticipantApi:
+        return ParticipantApi(self.api_client)
 
     def _get_rapidata_package_version(self):
         """

{rapidata-2.33.0.dist-info → rapidata-2.33.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.33.0
+Version: 2.33.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.33.0.dist-info → rapidata-2.33.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-rapidata/__init__.py,sha256=0vQS7SbFXnJfVsvrsivKMrHiaRZKLEFmlRBsAABKhpA,907
+rapidata/__init__.py,sha256=w07T5zXe_HttCELcde6bMq0eSbESIQnAIm6zEPLdMg8,897
 rapidata/api_client/__init__.py,sha256=tNSCpLEs-AyEZGCAYz9MM8gDEpA4KJKcdNL-dcvAAw0,34404
 rapidata/api_client/api/__init__.py,sha256=qjLeeJSnuPF_ar_nLknjnOqStBQnoCiz-O_rfZUBZrE,1489
 rapidata/api_client/api/benchmark_api.py,sha256=fr4krx4f3yN--DswD_Prpz-KU81ooG3Lcy-30_KU0dw,129751
@@ -533,13 +533,15 @@ rapidata/api_client/models/workflow_state.py,sha256=5LAK1se76RCoozeVB6oxMPb8p_5b
 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=sj425Ki-qiO2DCHnJ06r9LjfnGir7UpgXEonMh-LFag,62126
-rapidata/rapidata_client/__init__.py,sha256=VXI4s0R3D6qZYveZaP7eliG-YIxmkCIwOzfZTS_MWZc,1235
+rapidata/rapidata_client/__init__.py,sha256=CfkQxCdURXzJsVP6sxKmufze2u-IE_snG_G8NEkE_JM,1225
 rapidata/rapidata_client/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapidata/rapidata_client/api/rapidata_exception.py,sha256=BIdmHRrJUGW-Mqhp1H_suemZaR6w9TgjWq-ZW5iUPdQ,3878
 rapidata/rapidata_client/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapidata/rapidata_client/benchmark/leaderboard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapidata/rapidata_client/benchmark/leaderboard/rapidata_leaderboard.py,sha256=BDI0xJkTumbZy4dYqkzXy074jC9eaVWoJJDZ84uvatE,3906
-rapidata/rapidata_client/benchmark/rapidata_benchmark.py,sha256=CKMkP25_UzuT35ujJuKeZUgwHY5xfZP-BDcnig7wy7c,13634
+rapidata/rapidata_client/benchmark/participant/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rapidata/rapidata_client/benchmark/participant/_participant.py,sha256=yN82EWrZXYszsM8Ns0HRMXCTivltkyxcpGRK-cdT01Y,3683
+rapidata/rapidata_client/benchmark/rapidata_benchmark.py,sha256=03MXV3FWSWfm2iyOifXt-43wruzIPQenNBPmGZGKdds,13328
 rapidata/rapidata_client/benchmark/rapidata_benchmark_manager.py,sha256=_0ot7zRj1de5admMO7NZ7qVSCkwTYu6xOZI5dUkITuI,4592
 rapidata/rapidata_client/country_codes/__init__.py,sha256=FB9Dcks44J6C6YBSYmTmNZ71tE130x6NO_3aLJ8fKzQ,40
 rapidata/rapidata_client/country_codes/country_codes.py,sha256=ePHqeb7y9DWQZAnddBzPx1puYBcrgUjdR2sbFijuFD8,283
@@ -563,7 +565,7 @@ rapidata/rapidata_client/datapoints/metadata/_select_words_metadata.py,sha256=T8
 rapidata/rapidata_client/demographic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapidata/rapidata_client/demographic/demographic_manager.py,sha256=OaYrfrftU_p00X3BGlAjoky6_RPm0mhQwGnJsJSVca0,1203
 rapidata/rapidata_client/exceptions/__init__.py,sha256=2hbWRgjlCGuoLPVDloQmmH81uzm9F2OAX2iFGCJyRu8,59
-rapidata/rapidata_client/exceptions/failed_upload_exception.py,sha256=RZzNxnoKpKoFeHeT4fmRrGuDCHe4vcgBEP5pOwpfudk,665
+rapidata/rapidata_client/exceptions/failed_upload_exception.py,sha256=BIG6y5TYGXz507CfH74h0H2vF6QeoB2L7VtleFqAppY,2673
 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
@@ -587,22 +589,22 @@ rapidata/rapidata_client/logging/logger.py,sha256=9vULXUizGObQeqMY-CryiAQsq8xDZw
 rapidata/rapidata_client/logging/output_manager.py,sha256=AmSVZ2emVW5UWgOiNqkXNVRItsvd5Ox0hsIoZQhYYYo,653
 rapidata/rapidata_client/order/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapidata/rapidata_client/order/_rapidata_dataset.py,sha256=CYeDZJqHN3UWYvz5PSp8jAZ1NQIhAld467AolkVf24A,17438
-rapidata/rapidata_client/order/_rapidata_order_builder.py,sha256=fEOm0cbYHceSq2KCujjV5V3o-yO9gzZQkHXUAdm51T4,11569
-rapidata/rapidata_client/order/rapidata_order.py,sha256=E1HhZ6c7Nhjj_marJhW7JrNfjsIolP-few7Oh8r88Ns,12536
-rapidata/rapidata_client/order/rapidata_order_manager.py,sha256=wA4VsauGCszBgDNPsCvxt9UUElKmUQMca3OLkjDP0E8,37398
+rapidata/rapidata_client/order/_rapidata_order_builder.py,sha256=W1sdPRJ_p24Skfsnv9r8zldPRjkzsJopX_dCoge5qtI,12363
+rapidata/rapidata_client/order/rapidata_order.py,sha256=6YOAazdEk82sf8o3pal3iUqsKWN2nwy3BdNBgghkiU4,12783
+rapidata/rapidata_client/order/rapidata_order_manager.py,sha256=vq0wG5BSGeYB2LO_fwzOrrR40mKUmkcMPeBZF1pwgoY,38055
 rapidata/rapidata_client/order/rapidata_results.py,sha256=ZY0JyHMBZlR6-t6SqKt2OLEO6keR_KvKg9Wk6_I29x4,8653
 rapidata/rapidata_client/rapidata_client.py,sha256=jTkpu0YcizoxAzbfNdnY1S0xXX6Q0KEMi8boo0f2F5c,4274
 rapidata/rapidata_client/referee/__init__.py,sha256=q0Hv9nmfEpyChejtyMLT8hWKL0vTTf_UgUXPYNJ-H6M,153
 rapidata/rapidata_client/referee/_base_referee.py,sha256=MdFOhdxt3sRnWXLDKLJZKFdVpjBGn9jypPnWWQ6msQA,496
 rapidata/rapidata_client/referee/_early_stopping_referee.py,sha256=ULbokQZ91wc9D_20qHUhe55D28D9eTY1J1cMp_-oIDc,2088
 rapidata/rapidata_client/referee/_naive_referee.py,sha256=PVR8uy8hfRjr2DBzdOFyvou6S3swNc-4UvgjhO-09TU,1209
-rapidata/rapidata_client/selection/__init__.py,sha256=vC2XbykShj_VW1uz5IZfQQXjgeIzzdYqC3n0K2c8cIs,574
+rapidata/rapidata_client/selection/__init__.py,sha256=1QsMUieM-oleyOXX2mOhP36_P4h1foIIr3rW8WT8Eg0,564
 rapidata/rapidata_client/selection/_base_selection.py,sha256=tInbWOgxT_4CHkr5QHoG55ZcUi1ZmfcEGIwLKKCnN20,147
 rapidata/rapidata_client/selection/ab_test_selection.py,sha256=fymubkVMawqJmYp9FKzWXTki9tgBgoj3cOP8rG9oOd0,1284
 rapidata/rapidata_client/selection/capped_selection.py,sha256=iWhbM1LcayhgFm7oKADXCaKHGdiQIupI0jbYuuEVM2A,1184
 rapidata/rapidata_client/selection/conditional_validation_selection.py,sha256=OcNYSBi19vIcy2bLDmj9cv-gg5LFSvdjc3tooV0Z7Oc,2842
 rapidata/rapidata_client/selection/demographic_selection.py,sha256=l4vnNbzlf9ED6BKqN4k5cZXShkXu9L1C5DtO78Vwr5M,1454
-rapidata/rapidata_client/selection/effort_selection.py,sha256=uS8ctK2o-40Blu02jB5w7i8WtRSw21LhXszkkq30pM8,858
+rapidata/rapidata_client/selection/effort_selection.py,sha256=1p4CtwVJIyf4HZ-mPn0ohloe9dBxJFLhStG6jQNuxnE,1266
 rapidata/rapidata_client/selection/labeling_selection.py,sha256=0X8DJHgwvgwekEbzVxWPyzZ1QAPcULZNDjfLQYUlcLM,1348
 rapidata/rapidata_client/selection/rapidata_selections.py,sha256=lgwRivdzSnCri3K-Z-ngqR5RXwTl7iYuKTRpuyl5UMY,1853
 rapidata/rapidata_client/selection/retrieval_modes.py,sha256=J2jzPEJ4wdllm_RnU_FYPh3eO3xeZS7QUk-NXgTB2u4,668
@@ -642,8 +644,8 @@ rapidata/rapidata_client/workflow/_timestamp_workflow.py,sha256=tPi2zu1-SlE_ppbG
 rapidata/service/__init__.py,sha256=s9bS1AJZaWIhLtJX_ZA40_CK39rAAkwdAmymTMbeWl4,68
 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.33.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-rapidata-2.33.0.dist-info/METADATA,sha256=KPFe8uDzUQEVyva3VaRLK4LU350GuM9DEUNWNLEfFxI,1264
-rapidata-2.33.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-rapidata-2.33.0.dist-info/RECORD,,
+rapidata/service/openapi_service.py,sha256=v2fhPbHmD0J11ZRZY6f80PdIdGwpRFlbfMH9t8Ypg5A,5403
+rapidata-2.33.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+rapidata-2.33.2.dist-info/METADATA,sha256=YkByWAPnAWFN9E9m-9KbNDsgj9kV2kXuQcqA7raN2N0,1264
+rapidata-2.33.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+rapidata-2.33.2.dist-info/RECORD,,