rapidata 2.37.0__py3-none-any.whl → 3.0.0a8__py3-none-any.whl

rapidata/rapidata_client/logging/output_manager.py

@@ -1,20 +0,0 @@
-class RapidataOutputManager:
-    """Manages print outputs and progress bars for the Rapidata module."""
-    
-    silent_mode: bool = False
-
-    @classmethod
-    def enable_silent_mode(cls) -> None:
-        """Enable silent mode, suppressing all print outputs and progress bars, not logging."""
-        cls.silent_mode = True
-
-    @classmethod
-    def disable_silent_mode(cls) -> None:
-        """Disable silent mode, allowing outputs to be printed.
-        This is the default behavior.
-        """
-        cls.silent_mode = False
-
-def managed_print(*args, **kwargs) -> None:
-    if not RapidataOutputManager.silent_mode:
-        print(*args, **kwargs)

rapidata/rapidata_client/order/_rapidata_dataset.py

@@ -1,447 +0,0 @@
-from rapidata.rapidata_client.datapoints._datapoint import Datapoint
-from rapidata.rapidata_client.datapoints.assets import TextAsset, MediaAsset
-from rapidata.service import LocalFileService
-from rapidata.service.openapi_service import OpenAPIService
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from tqdm import tqdm
-
-from typing import Generator
-from rapidata.rapidata_client.logging import (
-    logger,
-    managed_print,
-    RapidataOutputManager,
-)
-import time
-import threading
-from rapidata.rapidata_client.api.rapidata_exception import (
-    suppress_rapidata_error_logging,
-)
-from rapidata.rapidata_client.config.rapidata_config import rapidata_config
-
-
-def chunk_list(lst: list, chunk_size: int) -> Generator:
-    for i in range(0, len(lst), chunk_size):
-        yield lst[i : i + chunk_size]
-
-
-class RapidataDataset:
-    def __init__(self, dataset_id: str, openapi_service: OpenAPIService):
-        self.id = dataset_id
-        self.openapi_service = openapi_service
-        self.local_file_service = LocalFileService()
-
-    def add_datapoints(
-        self,
-        datapoints: list[Datapoint],
-    ) -> tuple[list[Datapoint], list[Datapoint]]:
-        if not datapoints:
-            return [], []
-
-        effective_asset_type = datapoints[0]._get_effective_asset_type()
-
-        logger.debug(f"Config for datapoint upload: {rapidata_config}")
-
-        if issubclass(effective_asset_type, MediaAsset):
-            return self._add_media_from_paths(
-                datapoints,
-            )
-        elif issubclass(effective_asset_type, TextAsset):
-            return self._add_texts(datapoints)
-        else:
-            raise ValueError(f"Unsupported asset type: {effective_asset_type}")
-
-    def _add_texts(
-        self, datapoints: list[Datapoint]
-    ) -> tuple[list[Datapoint], list[Datapoint]]:
-
-        def upload_text_datapoint(datapoint: Datapoint, index: int) -> Datapoint:
-            model = datapoint.create_text_upload_model(index)
-
-            self.openapi_service.dataset_api.dataset_dataset_id_datapoints_texts_post(
-                dataset_id=self.id, create_datapoint_from_text_sources_model=model
-            )
-            return datapoint
-
-        successful_uploads: list[Datapoint] = []
-        failed_uploads: list[Datapoint] = []
-
-        total_uploads = len(datapoints)
-        with ThreadPoolExecutor(
-            max_workers=rapidata_config.maxUploadWorkers
-        ) as executor:
-            future_to_datapoint = {
-                executor.submit(upload_text_datapoint, datapoint, index=i): datapoint
-                for i, datapoint in enumerate(datapoints)
-            }
-
-            with tqdm(
-                total=total_uploads,
-                desc="Uploading text datapoints",
-                disable=RapidataOutputManager.silent_mode,
-            ) as pbar:
-                for future in as_completed(future_to_datapoint.keys()):
-                    datapoint = future_to_datapoint[future]
-                    try:
-                        result = future.result()
-                        pbar.update(1)
-                        successful_uploads.append(result)
-                    except Exception as e:
-                        failed_uploads.append(datapoint)
-                        logger.error("Upload failed for %s: %s", datapoint, str(e))
-
-        return successful_uploads, failed_uploads
-
-    def _process_single_upload(
-        self,
-        datapoint: Datapoint,
-        index: int,
-    ) -> tuple[list[Datapoint], list[Datapoint]]:
-        """
-        Process single upload with retry logic and error tracking.
-
-        Args:
-            media_asset: MediaAsset or MultiAsset to upload
-            meta_list: Optional sequence of metadata for the asset
-            index: Sort index for the upload
-            max_retries: Maximum number of retry attempts (default: 3)
-
-        Returns:
-            tuple[list[Datapoint], list[Datapoint]]: Lists of successful and failed datapoints
-        """
-        logger.debug("Processing single upload for %s with index %s", datapoint, index)
-
-        local_successful: list[Datapoint] = []
-        local_failed: list[Datapoint] = []
-
-        metadata = datapoint.get_prepared_metadata()
-
-        local_paths = datapoint.get_local_file_paths()
-        urls = datapoint.get_urls()
-
-        last_exception = None
-        for attempt in range(rapidata_config.uploadMaxRetries):
-            try:
-                with suppress_rapidata_error_logging():
-                    self.openapi_service.dataset_api.dataset_dataset_id_datapoints_post(
-                        dataset_id=self.id,
-                        file=local_paths,
-                        url=urls,
-                        metadata=metadata,
-                        sort_index=index,
-                    )
-
-                local_successful.append(datapoint)
-
-                return local_successful, local_failed
-
-            except Exception as e:
-                last_exception = e
-                if attempt < rapidata_config.uploadMaxRetries - 1:
-                    # Exponential backoff: wait 1s, then 2s, then 4s
-                    retry_delay = 2**attempt
-                    time.sleep(retry_delay)
-                    logger.debug("Error: %s", str(last_exception))
-                    logger.debug(
-                        "Retrying %s of %s...",
-                        attempt + 1,
-                        rapidata_config.uploadMaxRetries,
-                    )
-
-        # If we get here, all retries failed
-        local_failed.append(datapoint)
-        tqdm.write(
-            f"Upload failed for {datapoint} after {rapidata_config.uploadMaxRetries} attempts. \nFinal error: \n{str(last_exception)}"
-        )
-
-        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",
-                    disable=RapidataOutputManager.silent_mode,
-                ) 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.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
-                                        logger.warning(
-                                            "\nProgress seems stalled at %s/%s.",
-                                            total_completed,
-                                            total_uploads,
-                                        )
-                                        break
-
-                        except Exception as e:
-                            logger.error("\nError checking progress: %s", 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:
-                logger.error("Progress tracking thread error: %s", 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
-
-    def _process_uploads_in_chunks(
-        self,
-        datapoints: list[Datapoint],
-        chunk_size: int,
-        stop_progress_tracking: threading.Event,
-        progress_tracking_error: threading.Event,
-    ) -> tuple[list[Datapoint], list[Datapoint]]:
-        """
-        Process uploads in chunks with a ThreadPoolExecutor.
-
-        Args:
-            media_paths: List of assets to upload
-            multi_metadata: Optional sequence of sequences of metadata
-            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[Datapoint] = []
-        failed_uploads: list[Datapoint] = []
-
-        try:
-            with ThreadPoolExecutor(
-                max_workers=rapidata_config.maxUploadWorkers
-            ) as executor:
-                # Process uploads in chunks to avoid overwhelming the system
-                for chunk_idx, chunk in enumerate(chunk_list(datapoints, chunk_size)):
-                    futures = [
-                        executor.submit(
-                            self._process_single_upload,
-                            datapoint,
-                            index=(chunk_idx * chunk_size + i),
-                        )
-                        for i, datapoint in enumerate(chunk)
-                    ]
-
-                    # 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:
-                            logger.error("Future execution failed: %s", str(e))
-        finally:
-            # Signal to the progress tracking thread that all uploads have been submitted
-            stop_progress_tracking.set()
-
-        return successful_uploads, failed_uploads
-
-    def _log_final_progress(
-        self,
-        total_uploads: int,
-        progress_poll_interval: float,
-        successful_uploads: list[Datapoint],
-        failed_uploads: list[Datapoint],
-    ) -> 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.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.id
-                    )
-                )
-                total_ready = final_progress.ready
-                total_failed = final_progress.failed
-
-            success_rate = (
-                (total_ready / total_uploads * 100) if total_uploads > 0 else 0
-            )
-
-            logger.info(
-                "Upload complete: %s ready, %s failed (%s%% success rate)",
-                total_ready,
-                total_uploads - total_ready,
-                success_rate,
-            )
-        except Exception as e:
-            logger.error("Error getting final progress: %s", str(e))
-            logger.info(
-                "Upload summary from local tracking: %s succeeded, %s failed",
-                len(successful_uploads),
-                len(failed_uploads),
-            )
-
-        if failed_uploads:
-            logger.error("Failed uploads: %s", failed_uploads)
-
-    def _add_media_from_paths(
-        self,
-        datapoints: list[Datapoint],
-        chunk_size: int = 50,
-        progress_poll_interval: float = 0.5,
-    ) -> tuple[list[Datapoint], list[Datapoint]]:
-        """
-        Upload media paths in chunks with managed resources.
-
-        Args:
-            datapoints: List of Datapoint objects to upload
-            chunk_size: Number of items to process in each batch
-            progress_poll_interval: Time in seconds between progress checks
-        Returns:
-            tuple[list[Datapoint], list[Datapoint]]: Lists of successful and failed datapoints
-
-        Raises:
-            ValueError: If multi_metadata lengths don't match media_paths length
-        """
-
-        # Setup tracking variables
-        total_uploads = len(datapoints)
-
-        # 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(
-                datapoints,
-                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
-
-    def __str__(self) -> str:
-        return f"RapidataDataset(id={self.id})"
-
-    def __repr__(self) -> str:
-        return self.__str__()

rapidata/rapidata_client/workflow/_ranking_workflow.py

@@ -1,71 +0,0 @@
-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
-from rapidata.rapidata_client.datapoints.metadata import PromptMetadata
-from rapidata.api_client.models.dataset_dataset_id_datapoints_post_request_metadata_inner import (
-    DatasetDatasetIdDatapointsPostRequestMetadataInner,
-)
-from rapidata.api_client import ComparePayload
-from rapidata.rapidata_client.datapoints._datapoint import Datapoint
-from rapidata.api_client.models.rapid_modality import RapidModality
-
-
-class RankingWorkflow(Workflow):
-    modality = RapidModality.COMPARE
-
-    def __init__(
-        self,
-        criteria: str,
-        total_comparison_budget: int,
-        random_comparisons_ratio,
-        elo_start: int = 1200,
-        elo_k_factor: int = 40,
-        elo_scaling_factor: int = 400,
-        context: str | None = None,
-    ):
-        super().__init__(type="CompareWorkflowConfig")
-
-        self.context = (
-            [
-                DatasetDatasetIdDatapointsPostRequestMetadataInner(
-                    PromptMetadata(context).to_model()
-                )
-            ]
-            if context
-            else None
-        )
-
-        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,
-            metadata=self.context,
-        )
-
-    def _to_payload(self, datapoint: Datapoint) -> ComparePayload:
-        return ComparePayload(
-            _t="ComparePayload",
-            criteria=self.criteria,
-        )

rapidata/service/local_file_service.py

@@ -1,25 +0,0 @@
-import os
-from PIL import Image
-
-class LocalFileService:
-    
-    def load_image(self, image_path: str) -> Image.Image:
-        self.check_file_exists(image_path)
-        return Image.open(image_path)
-    
-    def load_images(self, image_paths: list[str]) -> list[Image.Image]:
-        return [self.load_image(image_path) for image_path in image_paths]
-    
-    def load_video(self, video_path: str):
-        self.check_file_exists(video_path)
-        return open(video_path, 'rb')
-    
-    def load_videos(self, video_paths: list[str]):
-        return [self.load_video(video_path) for video_path in video_paths]
-    
-    def _file_exists(self, file_path: str) -> bool:
-        return os.path.exists(file_path)
-    
-    def check_file_exists(self, file_path: str):
-        if not self._file_exists(file_path):
-            raise FileNotFoundError(f"File {file_path} not found.")

rapidata-2.37.0.dist-info/METADATA

@@ -1,35 +0,0 @@
-Metadata-Version: 2.3
-Name: rapidata
-Version: 2.37.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
-Author-email: info@rapidata.ai
-Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: authlib (>=1.5.1,<2.0.0)
-Requires-Dist: colorama (==0.4.6)
-Requires-Dist: deprecated (>=1.2.14,<2.0.0)
-Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: packaging (>=16.0.0)
-Requires-Dist: pandas (>=2.2.3,<3.0.0)
-Requires-Dist: pillow (>=10.4.0,<11.0.0)
-Requires-Dist: pydantic (>=2.8.2,<3.0.0)
-Requires-Dist: pyjwt (>=2.9.0,<3.0.0)
-Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
-Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: tinytag (>=2.0.0,<3.0.0)
-Requires-Dist: tqdm (>=4.66.5,<5.0.0)
-Description-Content-Type: text/markdown
-
-# Rapidata Python Client
-
-Python client to interface with the Rapidata API.
-
-Docs: https://docs.rapidata.ai/
-