rapidata 2.13.0__py3-none-any.whl → 2.14.0__py3-none-any.whl

rapidata/rapidata_client/order/_rapidata_dataset.py

@@ -1,9 +1,10 @@
 from itertools import zip_longest
 
 from rapidata.api_client.models.datapoint_metadata_model import DatapointMetadataModel
-from rapidata.api_client.models.datapoint_metadata_model_metadata_inner import (
-    DatapointMetadataModelMetadataInner,
+from rapidata.api_client.models.create_datapoint_from_urls_model import (
+    CreateDatapointFromUrlsModelMetadataInner,
 )
+from rapidata.api_client.models.create_datapoint_from_urls_model import CreateDatapointFromUrlsModel
 from rapidata.api_client.models.upload_text_sources_to_dataset_model import (
     UploadTextSourcesToDatasetModel,
 )
@@ -14,12 +15,11 @@ from rapidata.service.openapi_service import OpenAPIService
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from tqdm import tqdm
 
-from pydantic import StrictBytes, StrictStr
-from typing import Optional, cast, Sequence, Generator
+from pydantic import StrictStr
+from typing import cast, Sequence, Generator
 from logging import Logger
-from requests.adapters import HTTPAdapter, Retry
 import time
-import requests
+import threading
 
 
 def chunk_list(lst: list, chunk_size: int) -> Generator:
@@ -77,149 +77,352 @@ class RapidataDataset:
                     future.result()  # This will raise any exceptions that occurred during execution
                     pbar.update(1)
 
-    def _add_media_from_paths(
+    def _process_single_upload(
         self,
-        media_paths: list[MediaAsset] | list[MultiAsset],
-        metadata: Sequence[Metadata] | None = None,
-        max_workers: int = 10,
-        max_retries: int = 5,
-        chunk_size: int = 50,
+        media_asset: MediaAsset | MultiAsset, 
+        meta: Metadata | None, 
+        index: int,
     ) -> tuple[list[str], list[str]]:
         """
-        Upload media paths in chunks with managed resources.
+        Process single upload with error tracking.
         
         Args:
-            media_paths: List of MediaAsset or MultiAsset objects to upload
-            metadata: Optional sequence of metadata matching media_paths length
-            max_workers: Maximum number of concurrent upload workers
-            max_retries: Maximum number of retry attempts per failed request
-            chunk_size: Number of items to process in each batch
+            media_asset: MediaAsset or MultiAsset to upload
+            meta: Optional metadata for the asset
+            index: Sort index for the upload
+            session: Requests session for HTTP requests
             
         Returns:
-            tuple[list[str], list[str]]: Lists of successful and failed URLs
-            
-        Raises:
-            ValueError: If metadata length doesn't match media_paths length
+            tuple[list[str], list[str]]: Lists of successful and failed identifiers
         """
-        if metadata is not None and len(metadata) != len(media_paths):
-            raise ValueError("metadata must be None or have the same length as media_paths")
-
-        # Configure session with retry logic
-        session = requests.Session()
-        retries = Retry(
-            total=max_retries,
-            backoff_factor=1,
-            status_forcelist=[500, 502, 503, 504],
-            allowed_methods=["GET"],
-            respect_retry_after_header=True
-        )
+        local_successful: list[str] = []
+        local_failed: list[str] = []
+        identifiers_to_track: list[str] = []
         
-        adapter = HTTPAdapter(
-            pool_connections=max_workers * 2,
-            pool_maxsize=max_workers * 4,
-            max_retries=retries
-        )
-        session.mount('http://', adapter)
-        session.mount('https://', adapter)
-
-        def upload_datapoint(
-            media_asset: MediaAsset | MultiAsset, 
-            meta: Metadata | None, 
-            index: int,
-            session: requests.Session
-        ) -> tuple[list[str], list[str]]:
-            """Process single upload with error tracking."""
-            local_successful: list[str] = []
-            local_failed: list[str] = []
-            identifiers_to_track: list[str] = []
-            
-            try:
-                # Get identifier for this upload (URL or file path)
-                if isinstance(media_asset, MediaAsset):
-                    media_asset.session = session
-                    assets = [media_asset]
-                    identifier = media_asset._url if media_asset._url else media_asset.path
-                    identifiers_to_track = [identifier] if identifier else []
-                elif isinstance(media_asset, MultiAsset):
-                    assets = cast(list[MediaAsset], media_asset.assets)
-                    for asset in assets:
-                        asset.session = session
-                    identifiers_to_track: list[str] = [
-                        (asset._url if asset._url else cast(str, asset.path)) 
-                        for asset in assets
-                    ]
-                else:
-                    raise ValueError(f"Unsupported asset type: {type(media_asset)}")
+        try:
+            # Get identifier for this upload (URL or file path)
+            if isinstance(media_asset, MediaAsset):
+                assets = [media_asset]
+                identifier = media_asset._url if media_asset._url else media_asset.path
+                identifiers_to_track = [identifier] if identifier else []
+            elif isinstance(media_asset, MultiAsset):
+                assets = cast(list[MediaAsset], media_asset.assets)
+                identifiers_to_track: list[str] = [
+                    (asset._url if asset._url else cast(str, asset.path)) 
+                    for asset in assets
+                ]
+            else:
+                raise ValueError(f"Unsupported asset type: {type(media_asset)}")
+
+            meta_model = meta.to_model() if meta else None
 
-                meta_model = meta.to_model() if meta else None
+            metadata = [CreateDatapointFromUrlsModelMetadataInner(meta_model)] if meta_model else []
+
+            local_paths: bool = assets[0].is_local()
+            files: list[StrictStr] = []
+            for asset in assets:
+                if isinstance(asset, MediaAsset):
+                    files.append(asset.path)
+
+            if local_paths:
                 model = DatapointMetadataModel(
                     datasetId=self.dataset_id,
-                    metadata=([DatapointMetadataModelMetadataInner(meta_model)] if meta_model else []),
+                    metadata=metadata,
                     sortIndex=index,
                 )
-
-                files: list[tuple[StrictStr, StrictBytes] | StrictStr | StrictBytes] = []
-                for asset in assets:
-                    if isinstance(asset, MediaAsset):
-                        files.append(asset.to_file())
-
                 upload_response = self.openapi_service.dataset_api.dataset_create_datapoint_post(
                     model=model,
-                    files=files
+                    files=files # type: ignore
                 )
+            else:
+                upload_response = self.openapi_service.dataset_api.dataset_dataset_id_datapoints_urls_post(
+                    dataset_id=self.dataset_id,
+                    create_datapoint_from_urls_model=CreateDatapointFromUrlsModel(
+                        urls=files,
+                        metadata=metadata,
+                        sortIndex=index
+                    ),
+                )
+                
+            if upload_response.errors:
+                error_msg = f"Error uploading datapoint: {upload_response.errors}"
+                self._logger.error(error_msg)
+                local_failed.extend(identifiers_to_track)
+                raise ValueError(error_msg)
 
-                if upload_response.errors:
-                    error_msg = f"Error uploading datapoint: {upload_response.errors}"
-                    self._logger.error(error_msg)
-                    local_failed.extend(identifiers_to_track)
-                    raise ValueError(error_msg)
-
-                local_successful.extend(identifiers_to_track)
+            local_successful.extend(identifiers_to_track)
 
-            except Exception as e:
-                self._logger.error(f"\nUpload failed for {identifiers_to_track}: {str(e)}") # \n to avoid same line as tqdm
-                local_failed.extend(identifiers_to_track)
+        except Exception as e:
+            self._logger.error(f"\nUpload failed for {identifiers_to_track}: {str(e)}") # \n to avoid same line as tqdm
+            local_failed.extend(identifiers_to_track)
 
-            return local_successful, local_failed
+        return local_successful, local_failed
 
+    def _get_progress_tracker(
+        self, 
+        total_uploads: int, 
+        stop_event: threading.Event, 
+        progress_error_event: threading.Event,
+        progress_poll_interval: float,
+    ) -> threading.Thread:
+        """
+        Create and return a progress tracking thread that shows actual API progress.
+        
+        Args:
+            total_uploads: Total number of uploads to track
+            initial_ready: Initial number of ready items
+            initial_progress: Initial progress state
+            stop_event: Event to signal thread to stop
+            progress_error_event: Event to signal an error in progress tracking
+            progress_poll_interval: Time between progress checks
+            
+        Returns:
+            threading.Thread: The progress tracking thread
+        """
+        def progress_tracking_thread():
+            try:
+                # Initialize progress bar with 0 completions
+                with tqdm(total=total_uploads, desc="Uploading datapoints") as pbar:
+                    prev_ready = 0
+                    prev_failed = 0
+                    stall_count = 0
+                    last_progress_time = time.time()
+                    
+                    # We'll wait for all uploads to finish + some extra time
+                    # for the backend to fully process everything
+                    all_uploads_complete = threading.Event()
+                    
+                    while not stop_event.is_set() or not all_uploads_complete.is_set():
+                        try:
+                            current_progress = self.openapi_service.dataset_api.dataset_dataset_id_progress_get(self.dataset_id)
+                            
+                            # Calculate items completed since our initialization
+                            completed_ready = current_progress.ready
+                            completed_failed = current_progress.failed
+                            total_completed = completed_ready + completed_failed
+                            
+                            # Calculate newly completed items since our last check
+                            new_ready = current_progress.ready - prev_ready
+                            new_failed = current_progress.failed - prev_failed
+                            
+                            # Update progress bar position to show actual completed items
+                            # First reset to match the actual completed count
+                            pbar.n = total_completed
+                            pbar.refresh()
+                            
+                            if new_ready > 0 or new_failed > 0:
+                                # We saw progress
+                                stall_count = 0
+                                last_progress_time = time.time()
+                            else:
+                                stall_count += 1
+                            
+                            # Update our tracking variables
+                            prev_ready = current_progress.ready
+                            prev_failed = current_progress.failed or 0
+                            
+                            # Check if stop_event was set (all uploads submitted)
+                            if stop_event.is_set():
+                                elapsed_since_last_progress = time.time() - last_progress_time
+                                
+                                # If we haven't seen progress for a while after all uploads were submitted
+                                if elapsed_since_last_progress > 5.0:
+                                    # If we're at 100%, we're done
+                                    if total_completed >= total_uploads:
+                                        all_uploads_complete.set()
+                                        break
+                                        
+                                    # If we're not at 100% but it's been a while with no progress
+                                    if stall_count > 5:
+                                        # We've polled several times with no progress, assume we're done
+                                        self._logger.warning(f"\nProgress seems stalled at {total_completed}/{total_uploads}. Please try again.")
+                                        break
+                                
+                        except Exception as e:
+                            self._logger.error(f"\nError checking progress: {str(e)}")
+                            stall_count += 1
+                            
+                            if stall_count > 10:  # Too many consecutive errors
+                                progress_error_event.set()
+                                break
+                        
+                        # Sleep before next poll
+                        time.sleep(progress_poll_interval)
+                
+            except Exception as e:
+                self._logger.error(f"Progress tracking thread error: {str(e)}")
+                progress_error_event.set()
+                
+        # Create and return the thread
+        progress_thread = threading.Thread(target=progress_tracking_thread)
+        progress_thread.daemon = True
+        return progress_thread
 
-        # Process uploads in chunks
+    def _process_uploads_in_chunks(
+        self,
+        media_paths: list[MediaAsset] | list[MultiAsset],
+        metadata: Sequence[Metadata] | None,
+        max_workers: int,
+        chunk_size: int,
+        stop_progress_tracking: threading.Event,
+        progress_tracking_error: threading.Event
+    ) -> tuple[list[str], list[str]]:
+        """
+        Process uploads in chunks with a ThreadPoolExecutor.
+        
+        Args:
+            media_paths: List of assets to upload
+            metadata: Optional sequence of metadata
+            session: Requests session for HTTP requests
+            max_workers: Maximum number of concurrent workers
+            chunk_size: Number of items to process in each batch
+            stop_progress_tracking: Event to signal progress tracking to stop
+            progress_tracking_error: Event to detect progress tracking errors
+            
+        Returns:
+            tuple[list[str], list[str]]: Lists of successful and failed uploads
+        """
         successful_uploads: list[str] = []
         failed_uploads: list[str] = []
-        total_uploads = len(media_paths)
-
-        with tqdm(total=total_uploads, desc="Uploading datapoints") as pbar:
-            for chunk_idx, chunk in enumerate(chunk_list(media_paths, chunk_size)):
-                chunk_metadata = metadata[chunk_idx * chunk_size:(chunk_idx + 1) * chunk_size] if metadata else None
-                
-                with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        
+        try:
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                # Process uploads in chunks to avoid overwhelming the system
+                for chunk_idx, chunk in enumerate(chunk_list(media_paths, chunk_size)):
+                    chunk_metadata = metadata[chunk_idx * chunk_size:(chunk_idx + 1) * chunk_size] if metadata else None
+                    
                     futures = [
                         executor.submit(
-                            upload_datapoint, 
+                            self._process_single_upload, 
                             media_asset, 
                             meta, 
-                            index=(chunk_idx * chunk_size + i),
-                            session=session
+                            index=(chunk_idx * chunk_size + i)
                         )
                         for i, (media_asset, meta) in enumerate(zip_longest(chunk, chunk_metadata or []))
                     ]
-
+                    
+                    # Wait for this chunk to complete before starting the next one
                     for future in as_completed(futures):
+                        if progress_tracking_error.is_set():
+                            raise RuntimeError("Progress tracking failed, aborting uploads")
+                            
                         try:
                             chunk_successful, chunk_failed = future.result()
                             successful_uploads.extend(chunk_successful)
                             failed_uploads.extend(chunk_failed)
                         except Exception as e:
                             self._logger.error(f"Future execution failed: {str(e)}")
-                        finally:
-                            pbar.update(1)
+        finally:
+            # Signal to the progress tracking thread that all uploads have been submitted
+            stop_progress_tracking.set()
+                
+        return successful_uploads, failed_uploads
 
-        # Log summary statistics
-        success_rate = len(successful_uploads) / total_uploads * 100 if total_uploads > 0 else 0
-        self._logger.info(f"Upload complete: {len(successful_uploads)} successful, {len(failed_uploads)} failed ({success_rate:.1f}% success rate)")
+    def _log_final_progress(
+        self, 
+        total_uploads: int, 
+        progress_poll_interval: float,
+        successful_uploads: list[str],
+        failed_uploads: list[str]
+    ) -> None:
+        """
+        Log the final progress of the upload operation.
+        
+        Args:
+            total_uploads: Total number of uploads
+            initial_ready: Initial number of ready items
+            initial_progress: Initial progress state
+            progress_poll_interval: Time between progress checks
+            successful_uploads: List of successful uploads for fallback reporting
+            failed_uploads: List of failed uploads for fallback reporting
+        """
+        try:            
+            # Get final progress
+            final_progress = self.openapi_service.dataset_api.dataset_dataset_id_progress_get(self.dataset_id)
+            total_ready = final_progress.ready
+            total_failed = final_progress.failed
+            
+            # Make sure we account for all uploads
+            if total_ready + total_failed < total_uploads:
+                # Try one more time after a longer wait
+                time.sleep(5 * progress_poll_interval)
+                final_progress = self.openapi_service.dataset_api.dataset_dataset_id_progress_get(self.dataset_id)
+                total_ready = final_progress.ready
+                total_failed = final_progress.failed
+            
+            success_rate = (total_ready / total_uploads * 100) if total_uploads > 0 else 0
+            
+            self._logger.info(f"Upload complete: {total_ready} ready, {total_uploads-total_ready} failed ({success_rate:.1f}% success rate)")
+            print(f"Upload complete, {total_ready} ready, {total_uploads-total_ready} failed ({success_rate:.1f}% success rate)")
+        except Exception as e:
+            self._logger.error(f"Error getting final progress: {str(e)}")
+            self._logger.info(f"Upload summary from local tracking: {len(successful_uploads)} succeeded, {len(failed_uploads)} failed")
 
         if failed_uploads:
             print(f"Failed uploads: {failed_uploads}")
 
-        return successful_uploads, failed_uploads
+    def _add_media_from_paths(
+        self,
+        media_paths: list[MediaAsset] | list[MultiAsset],
+        metadata: Sequence[Metadata] | None = None,
+        max_workers: int = 5,
+        chunk_size: int = 50,
+        progress_poll_interval: float = 0.5,
+    ) -> tuple[list[str], list[str]]:
+        """
+        Upload media paths in chunks with managed resources.
+        
+        Args:
+            media_paths: List of MediaAsset or MultiAsset objects to upload
+            metadata: Optional sequence of metadata matching media_paths length
+            max_workers: Maximum number of concurrent upload workers
+            chunk_size: Number of items to process in each batch
+            progress_poll_interval: Time in seconds between progress checks
+            
+        Returns:
+            tuple[list[str], list[str]]: Lists of successful and failed URLs
+            
+        Raises:
+            ValueError: If metadata length doesn't match media_paths length
+        """
+        if metadata is not None and len(metadata) != len(media_paths):
+            raise ValueError("metadata must be None or have the same length as media_paths")
+        
+        # Setup tracking variables
+        total_uploads = len(media_paths)
+        
+        # Create thread control events
+        stop_progress_tracking = threading.Event()
+        progress_tracking_error = threading.Event()
+        
+        # Create and start progress tracking thread
+        progress_thread = self._get_progress_tracker(
+            total_uploads, 
+            stop_progress_tracking, 
+            progress_tracking_error,
+            progress_poll_interval
+        )
+        progress_thread.start()
+        
+        # Process uploads in chunks
+        try:
+            successful_uploads, failed_uploads = self._process_uploads_in_chunks(
+                media_paths,
+                metadata,
+                max_workers,
+                chunk_size,
+                stop_progress_tracking,
+                progress_tracking_error
+            )
+        finally:
+            progress_thread.join(10)  # Add margin to the timeout for tqdm
+        
+        # Log final progress
+        self._log_final_progress(
+            total_uploads, 
+            progress_poll_interval,
+            successful_uploads,
+            failed_uploads
+        )
 
+        return successful_uploads, failed_uploads

rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -1,17 +1,14 @@
-from typing import Sequence
+from typing import Sequence, Optional
 from urllib3._collections import HTTPHeaderDict
 
 from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.assets.data_type_enum import RapidataDataTypes
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.order._rapidata_order_builder import RapidataOrderBuilder
 from rapidata.rapidata_client.metadata import PromptMetadata, SelectWordsMetadata
 from rapidata.rapidata_client.referee._naive_referee import NaiveReferee
 from rapidata.rapidata_client.referee._early_stopping_referee import EarlyStoppingReferee
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
-from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
-from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
 from rapidata.rapidata_client.workflow import (
     Workflow,
     ClassifyWorkflow,
@@ -20,7 +17,9 @@ from rapidata.rapidata_client.workflow import (
     SelectWordsWorkflow,
     LocateWorkflow,
     DrawWorkflow,
-    TimestampWorkflow)
+    TimestampWorkflow,
+    RankingWorkflow
+)
 from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
 from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
 from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
@@ -243,7 +242,66 @@ class RapidataOrderManager:
             selections=selections,
             settings=settings
         )
-    
+
+    def create_ranking_order(self,
+                             name: str,
+                             instruction: str,
+                             datapoints: list[str],
+                             responses_per_comparison: int,
+                             total_comparison_budget: int,
+                             random_comparisons_ratio: float = 0.5,
+                             elo_start: int = 1200,
+                             elo_k_factor: int = 40,
+                             elo_scaling_factor: int = 400,
+                             contexts: Optional[list[str]] = None,
+                             validation_set_id: Optional[str] = None,
+                             filters: Sequence[RapidataFilter] = [],
+                             settings: Sequence[RapidataSetting] = [],
+                             selections: Optional[Sequence[RapidataSelection]] = None) -> RapidataOrder:
+        """
+        Create a ranking order.
+
+        Args:
+            name (str): The name of the order.
+            instruction (str): The question asked from People when They see two datapoints.
+            datapoints (list[str]): A list of datapoints that will participate in the ranking.
+            total_comparison_budget (int): The total number of (pairwise-)comparisons that can be made.
+            random_comparisons_ratio (float, optional): The fraction of random comparisons in the ranking process.
+            The rest will focus on pairing similarly ranked datapoints.
+            elo_start (int, optional): The initial ELO rating assigned to each datapoint.
+            elo_k_factor (int, optional): The K-factor used for ELO updates.
+            elo_scaling_factor (int, optional): The scaling factor used in the ELO calculation.
+            responses_per_comparison (int, optional): The number of responses collected per comparison.
+            contexts (list[str], optional): The list of contexts for the comparison. Defaults to None.\n
+                If provided has to be the same length as datapoints and will be shown in addition to the instruction.
+                (Therefore will be different for each datapoint) Will be match up with the datapoints using the list index.
+            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.
+            settings (Sequence[RapidataSetting], optional): The list of settings for the order. Defaults to []. Decides how the tasks should be shown.
+            selections (Sequence[RapidataSelection], optional): The list of selections for the order. Defaults to None. Decides in what order the tasks should be shown.
+        """
+
+        assets = [MediaAsset(path=path) for path in datapoints]
+        return self._create_general_order(
+            name=name,
+            workflow=RankingWorkflow(
+                criteria=instruction,
+                elo_start=elo_start,
+                elo_k_factor=elo_k_factor,
+                elo_scaling_factor=elo_scaling_factor,
+                total_comparison_budget=total_comparison_budget,
+                random_comparisons_ratio=random_comparisons_ratio
+            ),
+            assets=assets,
+            responses_per_datapoint=responses_per_comparison,
+            contexts=contexts,
+            validation_set_id=validation_set_id,
+            filters=filters,
+            selections=selections,
+            settings=settings
+        )
+
     def create_free_text_order(self,
             name: str,
             instruction: str,

rapidata/rapidata_client/validation/rapids/rapids.py

@@ -16,10 +16,9 @@ from rapidata.api_client.models.add_validation_rapid_model_truth import (
     AddValidationRapidModelTruth,
 )
 
-from rapidata.api_client.models.datapoint_metadata_model_metadata_inner import (
-    DatapointMetadataModelMetadataInner,
+from rapidata.api_client.models.create_datapoint_from_urls_model import (
+    CreateDatapointFromUrlsModelMetadataInner,
 )
-
 from rapidata.service.openapi_service import OpenAPIService
 
 import requests
@@ -71,7 +70,7 @@ class Rapid():
             payload=AddValidationRapidModelPayload(self.payload),
             truth=AddValidationRapidModelTruth(self.truth),
             metadata=[
-              DatapointMetadataModelMetadataInner(meta.to_model())
+              CreateDatapointFromUrlsModelMetadataInner(meta.to_model())
               for meta in self.metadata
             ],
             randomCorrectProbability=self.randomCorrectProbability,
@@ -98,7 +97,7 @@ class Rapid():
           payload=AddValidationRapidModelPayload(self.payload),
           truth=AddValidationRapidModelTruth(self.truth),
           metadata=[
-              DatapointMetadataModelMetadataInner(meta.to_model())
+              CreateDatapointFromUrlsModelMetadataInner(meta.to_model())
               for meta in self.metadata
           ],
           randomCorrectProbability=self.randomCorrectProbability,

rapidata/rapidata_client/workflow/__init__.py

@@ -7,3 +7,4 @@ from ._free_text_workflow import FreeTextWorkflow
 from ._select_words_workflow import SelectWordsWorkflow
 from ._evaluation_workflow import EvaluationWorkflow
 from ._timestamp_workflow import TimestampWorkflow
+from ._ranking_workflow import RankingWorkflow

rapidata/rapidata_client/workflow/_ranking_workflow.py

@@ -0,0 +1,40 @@
+from rapidata.api_client import CompareWorkflowModelPairMakerConfig, OnlinePairMakerConfigModel, EloConfigModel
+from rapidata.api_client.models.compare_workflow_model import CompareWorkflowModel
+from rapidata.rapidata_client.workflow._base_workflow import Workflow
+
+class RankingWorkflow(Workflow):
+
+
+    def __init__(self,
+                 criteria: str,
+                 total_comparison_budget: int,
+                 random_comparisons_ratio,
+                 elo_start: int,
+                 elo_k_factor: int,
+                 elo_scaling_factor: int,
+                 ):
+        super().__init__(type="CompareWorkflowConfig")
+
+        self.criteria = criteria
+        self.pair_maker_config = CompareWorkflowModelPairMakerConfig(
+            OnlinePairMakerConfigModel(
+                _t='OnlinePairMaker',
+                totalComparisonBudget=total_comparison_budget,
+                randomMatchesRatio=random_comparisons_ratio,
+            )
+        )
+
+        self.elo_config = EloConfigModel(
+            startingElo=elo_start,
+            kFactor=elo_k_factor,
+            scalingFactor=elo_scaling_factor,
+        )
+
+    def _to_model(self) -> CompareWorkflowModel:
+
+        return CompareWorkflowModel(
+            _t="CompareWorkflow",
+            criteria=self.criteria,
+            eloConfig=self.elo_config,
+            pairMakerConfig=self.pair_maker_config
+        )

{rapidata-2.13.0.dist-info → rapidata-2.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.13.0
+Version: 2.14.0
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 Author: Rapidata AG