rapidata 2.35.1__py3-none-any.whl → 2.35.3__py3-none-any.whl

rapidata/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.35.1"
+__version__ = "2.35.3"
 
 from .rapidata_client import (
     RapidataClient,
@@ -42,4 +42,5 @@ from .rapidata_client import (
     configure_logger,
     RapidataOutputManager,
     FailedUploadException,
+    rapidata_config,
 )

rapidata/api_client/api/leaderboard_api.py

@@ -3117,7 +3117,7 @@ class LeaderboardApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Updates the name of a leaderboard.
+        """Updates the response config of a leaderboard.
 
 
         :param leaderboard_id:  (required)
@@ -3187,7 +3187,7 @@ class LeaderboardApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Updates the name of a leaderboard.
+        """Updates the response config of a leaderboard.
 
 
         :param leaderboard_id:  (required)
@@ -3257,7 +3257,7 @@ class LeaderboardApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Updates the name of a leaderboard.
+        """Updates the response config of a leaderboard.
 
 
         :param leaderboard_id:  (required)

rapidata/api_client_README.md

@@ -135,7 +135,7 @@ Class | Method | HTTP request | Description
 *LeaderboardApi* | [**leaderboard_leaderboard_id_participants_post**](rapidata/api_client/docs/LeaderboardApi.md#leaderboard_leaderboard_id_participants_post) | **POST** /leaderboard/{leaderboardId}/participants | Creates a participant in a leaderboard.
 *LeaderboardApi* | [**leaderboard_leaderboard_id_prompts_get**](rapidata/api_client/docs/LeaderboardApi.md#leaderboard_leaderboard_id_prompts_get) | **GET** /leaderboard/{leaderboardId}/prompts | returns the paged prompts of a leaderboard by its ID.
 *LeaderboardApi* | [**leaderboard_leaderboard_id_prompts_post**](rapidata/api_client/docs/LeaderboardApi.md#leaderboard_leaderboard_id_prompts_post) | **POST** /leaderboard/{leaderboardId}/prompts | adds a new prompt to a leaderboard.
-*LeaderboardApi* | [**leaderboard_leaderboard_id_response_config_put**](rapidata/api_client/docs/LeaderboardApi.md#leaderboard_leaderboard_id_response_config_put) | **PUT** /leaderboard/{leaderboardId}/response-config | Updates the name of a leaderboard.
+*LeaderboardApi* | [**leaderboard_leaderboard_id_response_config_put**](rapidata/api_client/docs/LeaderboardApi.md#leaderboard_leaderboard_id_response_config_put) | **PUT** /leaderboard/{leaderboardId}/response-config | Updates the response config of a leaderboard.
 *LeaderboardApi* | [**leaderboard_leaderboard_id_runs_get**](rapidata/api_client/docs/LeaderboardApi.md#leaderboard_leaderboard_id_runs_get) | **GET** /leaderboard/{leaderboardId}/runs | Gets the runs related to a leaderboard
 *LeaderboardApi* | [**leaderboard_leaderboard_id_standings_get**](rapidata/api_client/docs/LeaderboardApi.md#leaderboard_leaderboard_id_standings_get) | **GET** /leaderboard/{leaderboardId}/standings | queries all the participants connected to leaderboard by its ID.
 *LeaderboardApi* | [**leaderboard_post**](rapidata/api_client/docs/LeaderboardApi.md#leaderboard_post) | **POST** /leaderboard | Creates a new leaderboard with the specified name and criteria.

rapidata/rapidata_client/__init__.py

@@ -16,14 +16,9 @@ from .datapoints.metadata import (
     PromptMetadata,
     SelectWordsMetadata,
 )
-from .datapoints.assets import (
-    MediaAsset, 
-    TextAsset, 
-    MultiAsset, 
-    RapidataDataTypes
-)
+from .datapoints.assets import MediaAsset, TextAsset, MultiAsset, RapidataDataTypes
 from .settings import (
-    RapidataSettings, 
+    RapidataSettings,
     TranslationBehaviourOptions,
     AlertOnFastResponse,
     TranslationBehaviour,
@@ -32,7 +27,7 @@ from .settings import (
     PlayVideoUntilTheEnd,
     CustomSetting,
     AllowNeitherBoth,
-    )
+)
 from .country_codes import CountryCodes
 from .filter import (
     CountryFilter,
@@ -49,11 +44,8 @@ from .filter import (
     ResponseCountFilter,
 )
 
-from .logging import (
-    configure_logger, 
-    logger,
-    RapidataOutputManager
-)
+from .logging import configure_logger, logger, RapidataOutputManager
 
 from .validation import Box
 from .exceptions import FailedUploadException
+from .config import rapidata_config

rapidata/rapidata_client/api/rapidata_exception.py

@@ -2,106 +2,135 @@ from typing import Optional, Any
 from rapidata.api_client.api_client import ApiClient, rest, ApiResponse, ApiResponseT
 from rapidata.api_client.exceptions import ApiException
 import json
+import threading
+from contextlib import contextmanager
 from rapidata.rapidata_client.logging import logger
 
+# Thread-local storage for controlling error logging
+_thread_local = threading.local()
+
+
+@contextmanager
+def suppress_rapidata_error_logging():
+    """Context manager to suppress error logging for RapidataApiClient calls."""
+    old_value = getattr(_thread_local, "suppress_error_logging", False)
+    _thread_local.suppress_error_logging = True
+    try:
+        yield
+    finally:
+        _thread_local.suppress_error_logging = old_value
+
+
+def _should_suppress_error_logging() -> bool:
+    """Check if error logging should be suppressed for the current thread."""
+    return getattr(_thread_local, "suppress_error_logging", False)
+
+
 class RapidataError(Exception):
     """Custom error class for Rapidata API errors."""
-    
+
     def __init__(
-        self, 
-        status_code: Optional[int] = None, 
-        message: str | None = None, 
+        self,
+        status_code: Optional[int] = None,
+        message: str | None = None,
         original_exception: Exception | None = None,
-        details: Any = None
+        details: Any = None,
     ):
         self.status_code = status_code
         self.message = message
         self.original_exception = original_exception
         self.details = details
-        
+
         # Create a nice error message
         error_msg = "Rapidata API Error"
         if status_code:
             error_msg += f" ({status_code})"
         if message:
             error_msg += f": {message}"
-            
+
         super().__init__(error_msg)
 
     def __str__(self):
-        """Return a string representation of the error."""        
+        """Return a string representation of the error."""
         # Extract information from message if available
         title = None
         errors = None
         trace_id = None
-        
+
         # Try to extract from details if available and is a dict
         if self.details and isinstance(self.details, dict):
-            title = self.details.get('title')
-            errors = self.details.get('errors')
-            trace_id = self.details.get('traceId')
-        
+            title = self.details.get("title")
+            errors = self.details.get("errors")
+            trace_id = self.details.get("traceId")
+
         # Build the error string
         error_parts = []
-        
+
         # Main error line
         if title:
             error_parts.append(f"{title}")
         else:
             error_parts.append(f"{self.message or 'Unknown error'}")
-        
+
         # Reasons
         if errors:
             if isinstance(errors, dict):
                 error_parts.append(f"Reasons: {json.dumps({'errors': errors})}")
             else:
                 error_parts.append(f"Reasons: {errors}")
-        
+
         # Trace ID
         if trace_id:
             error_parts.append(f"Trace Id: {trace_id}")
         else:
             error_parts.append("Trace Id: N/A")
-        
+
         return "\n".join(error_parts)
 
+
 class RapidataApiClient(ApiClient):
     """Custom API client that wraps errors in RapidataError."""
 
     def response_deserialize(
         self,
         response_data: rest.RESTResponse,
-        response_types_map: Optional[dict[str, ApiResponseT]] = None
+        response_types_map: Optional[dict[str, ApiResponseT]] = None,
     ) -> ApiResponse[ApiResponseT]:
         """Override the response_deserialize method to catch and convert exceptions."""
         try:
             return super().response_deserialize(response_data, response_types_map)
         except ApiException as e:
-            status_code = getattr(e, 'status', None)
+            status_code = getattr(e, "status", None)
             message = str(e)
             details = None
-            
+
             # Extract more detailed error message from response body if available
-            if hasattr(e, 'body') and e.body:
+            if hasattr(e, "body") and e.body:
                 try:
                     body_json = json.loads(e.body)
                     if isinstance(body_json, dict):
-                        if 'message' in body_json:
-                            message = body_json['message']
-                        elif 'error' in body_json:
-                            message = body_json['error']
-                        
+                        if "message" in body_json:
+                            message = body_json["message"]
+                        elif "error" in body_json:
+                            message = body_json["error"]
+
                         # Store the full error details for debugging
                         details = body_json
                 except (json.JSONDecodeError, AttributeError):
                     # If we can't parse the body as JSON, use the original message
                     pass
-            
-            error_formatted =  RapidataError(
-                status_code=status_code, 
-                message=message, 
+
+            error_formatted = RapidataError(
+                status_code=status_code,
+                message=message,
                 original_exception=e,
-                details=details
+                details=details,
             )
-            logger.error(f"Error: {error_formatted}")
+
+            # Only log error if not suppressed
+            if not _should_suppress_error_logging():
+                logger.error("Error: %s", error_formatted)
+            else:
+                logger.debug("Suppressed Error: %s", error_formatted)
+
             raise error_formatted from None

rapidata/rapidata_client/benchmark/participant/_participant.py

@@ -1,4 +1,5 @@
 from concurrent.futures import ThreadPoolExecutor, as_completed
+import time
 from tqdm import tqdm
 
 from rapidata.rapidata_client.datapoints.assets import MediaAsset
@@ -6,6 +7,10 @@ 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
+from rapidata.rapidata_client.config.config import rapidata_config
+from rapidata.rapidata_client.api.rapidata_exception import (
+    suppress_rapidata_error_logging,
+)
 
 
 class BenchmarkParticipant:
@@ -21,11 +26,11 @@ class BenchmarkParticipant:
     ) -> 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)
         """
@@ -37,20 +42,30 @@ class BenchmarkParticipant:
             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
+        for attempt in range(rapidata_config.upload_max_retries):
+            try:
+                with suppress_rapidata_error_logging():
+                    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
+                if attempt < rapidata_config.upload_max_retries - 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.upload_max_retries,
+                    )
 
         logger.error(f"Upload failed for {identifier}. Error: {str(last_exception)}")
         return None, asset
@@ -59,24 +74,24 @@ class BenchmarkParticipant:
         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:
+
+        with ThreadPoolExecutor(
+            max_workers=rapidata_config.max_upload_workers
+        ) as executor:
             futures = [
                 executor.submit(
                     self._process_single_sample_upload,
@@ -85,8 +100,12 @@ class BenchmarkParticipant:
                 )
                 for asset, identifier in zip(assets, identifiers)
             ]
-            
-            with tqdm(total=total_uploads, desc="Uploading media", disable=RapidataOutputManager.silent_mode) as pbar:
+
+            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()
@@ -96,7 +115,7 @@ class BenchmarkParticipant:
                             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_manager.py

@@ -8,6 +8,7 @@ from rapidata.api_client.models.root_filter import RootFilter
 from rapidata.api_client.models.filter import Filter
 from rapidata.api_client.models.sort_criterion import SortCriterion
 
+
 class RapidataBenchmarkManager:
     """
     A manager for benchmarks.
@@ -19,16 +20,18 @@ class RapidataBenchmarkManager:
     Args:
         openapi_service: The OpenAPIService instance for API interaction.
     """
+
     def __init__(self, openapi_service: OpenAPIService):
         self.__openapi_service = openapi_service
 
-    def create_new_benchmark(self, 
-                             name: str,
-                             identifiers: list[str],
-                             prompts: Optional[list[str | None]] = None,
-                             prompt_assets: Optional[list[str | None]] = None,
-                             tags: Optional[list[list[str] | None]] = None,
-                             ) -> RapidataBenchmark:
+    def create_new_benchmark(
+        self,
+        name: str,
+        identifiers: list[str],
+        prompts: Optional[list[str | None]] = None,
+        prompt_assets: Optional[list[str | None]] = None,
+        tags: Optional[list[list[str] | None]] = None,
+    ) -> RapidataBenchmark:
         """
         Creates a new benchmark with the given name, identifiers, prompts, and media assets.
         Everything is matched up by the indexes of the lists.
@@ -41,31 +44,54 @@ class RapidataBenchmarkManager:
             prompts: The prompts that will be registered for the benchmark.
             prompt_assets: The prompt assets that will be registered for the benchmark.
             tags: The tags that will be associated with the prompts to use for filtering the leaderboard results. They will NOT be shown to the users.
+
+        Example:
+            ```python
+            name = "Example Benchmark"
+            identifiers = ["id1", "id2", "id3"]
+            prompts = ["prompt 1", "prompt 2", "prompt 3"]
+            prompt_assets = ["https://assets.rapidata.ai/prompt_1.jpg", "https://assets.rapidata.ai/prompt_2.jpg", "https://assets.rapidata.ai/prompt_3.jpg"]
+            tags = [["tag1", "tag2"], ["tag2"], ["tag2", "tag3"]]
+
+            benchmark = create_new_benchmark(name=name, identifiers=identifiers, prompts=prompts, prompt_assets=prompt_assets, tags=tags)
+            ```
         """
         if not isinstance(name, str):
             raise ValueError("Name must be a string.")
-        
-        if prompts and (not isinstance(prompts, list) or not all(isinstance(prompt, str) or prompt is None for prompt in prompts)):
+
+        if prompts and (
+            not isinstance(prompts, list)
+            or not all(isinstance(prompt, str) or prompt is None for prompt in prompts)
+        ):
             raise ValueError("Prompts must be a list of strings or None.")
-        
-        if prompt_assets and (not isinstance(prompt_assets, list) or not all(isinstance(asset, str) or asset is None for asset in prompt_assets)):
+
+        if prompt_assets and (
+            not isinstance(prompt_assets, list)
+            or not all(
+                isinstance(asset, str) or asset is None for asset in prompt_assets
+            )
+        ):
             raise ValueError("Media assets must be a list of strings or None.")
-        
-        if not isinstance(identifiers, list) or not all(isinstance(identifier, str) for identifier in identifiers):
+
+        if not isinstance(identifiers, list) or not all(
+            isinstance(identifier, str) for identifier in identifiers
+        ):
             raise ValueError("Identifiers must be a list of strings.")
-        
+
         if prompts and len(identifiers) != len(prompts):
             raise ValueError("Identifiers and prompts must have the same length.")
-        
+
         if prompt_assets and len(identifiers) != len(prompt_assets):
             raise ValueError("Identifiers and media assets must have the same length.")
-        
+
         if not prompts and not prompt_assets:
-            raise ValueError("At least one of prompts or media assets must be provided.")
-        
+            raise ValueError(
+                "At least one of prompts or media assets must be provided."
+            )
+
         if len(set(identifiers)) != len(identifiers):
             raise ValueError("Identifiers must be unique.")
-        
+
         if tags and len(identifiers) != len(tags):
             raise ValueError("Identifiers and tags must have the same length.")
 
@@ -78,32 +104,49 @@ class RapidataBenchmarkManager:
         benchmark = RapidataBenchmark(name, benchmark_result.id, self.__openapi_service)
 
         prompts_list = prompts if prompts is not None else [None] * len(identifiers)
-        media_assets_list = prompt_assets if prompt_assets is not None else [None] * len(identifiers)
+        media_assets_list = (
+            prompt_assets if prompt_assets is not None else [None] * len(identifiers)
+        )
         tags_list = tags if tags is not None else [None] * len(identifiers)
 
-        for identifier, prompt, asset, tag in zip(identifiers, prompts_list, media_assets_list, tags_list):
+        for identifier, prompt, asset, tag in zip(
+            identifiers, prompts_list, media_assets_list, tags_list
+        ):
             benchmark.add_prompt(identifier, prompt, asset, tag)
 
         return benchmark
-    
+
     def get_benchmark_by_id(self, id: str) -> RapidataBenchmark:
         """
         Returns a benchmark by its ID.
         """
-        benchmark_result = self.__openapi_service.benchmark_api.benchmark_benchmark_id_get(
-            benchmark_id=id
+        benchmark_result = (
+            self.__openapi_service.benchmark_api.benchmark_benchmark_id_get(
+                benchmark_id=id
+            )
         )
-        return RapidataBenchmark(benchmark_result.name, benchmark_result.id, self.__openapi_service)
-    
-    def find_benchmarks(self, name: str = "", amount: int = 10) -> list[RapidataBenchmark]:
+        return RapidataBenchmark(
+            benchmark_result.name, benchmark_result.id, self.__openapi_service
+        )
+
+    def find_benchmarks(
+        self, name: str = "", amount: int = 10
+    ) -> list[RapidataBenchmark]:
         """
         Returns a list of benchmarks by their name.
         """
         benchmark_result = self.__openapi_service.benchmark_api.benchmarks_get(
             QueryModel(
                 page=PageInfo(index=1, size=amount),
-                filter=RootFilter(filters=[Filter(field="Name", operator="Contains", value=name)]),
-                sortCriteria=[SortCriterion(direction="Desc", propertyName="CreatedAt")]
+                filter=RootFilter(
+                    filters=[Filter(field="Name", operator="Contains", value=name)]
+                ),
+                sortCriteria=[
+                    SortCriterion(direction="Desc", propertyName="CreatedAt")
+                ],
             )
         )
-        return [RapidataBenchmark(benchmark.name, benchmark.id, self.__openapi_service) for benchmark in benchmark_result.items]
+        return [
+            RapidataBenchmark(benchmark.name, benchmark.id, self.__openapi_service)
+            for benchmark in benchmark_result.items
+        ]

rapidata/rapidata_client/config/__init__.py

@@ -0,0 +1 @@
+from .config import rapidata_config

rapidata/rapidata_client/config/config.py

@@ -0,0 +1,33 @@
+class _RapidataConfig:
+    def __init__(self):
+        self.__maxUploadWorkers: int = 10
+        self.__uploadMaxRetries: int = 3
+
+    @property
+    def max_upload_workers(self) -> int:
+        return self.__maxUploadWorkers
+
+    @max_upload_workers.setter
+    def max_upload_workers(self, value: int) -> None:
+        if value < 1:
+            raise ValueError("max_upload_workers must be greater than 0")
+        self.__maxUploadWorkers = value
+
+    @property
+    def upload_max_retries(self) -> int:
+        return self.__uploadMaxRetries
+
+    @upload_max_retries.setter
+    def upload_max_retries(self, value: int) -> None:
+        if value < 1:
+            raise ValueError("upload_max_retries must be greater than 0")
+        self.__uploadMaxRetries = value
+
+    def __str__(self) -> str:
+        return f"RapidataConfig(max_upload_workers={self.__maxUploadWorkers}, upload_max_retries={self.__uploadMaxRetries})"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+rapidata_config = _RapidataConfig()

rapidata/rapidata_client/datapoints/assets/_multi_asset.py

@@ -5,7 +5,7 @@ Defines the MultiAsset class for handling multiple BaseAsset instances.
 
 from rapidata.rapidata_client.datapoints.assets._base_asset import BaseAsset
 from rapidata.rapidata_client.datapoints.assets import MediaAsset, TextAsset
-from typing import Iterator, Sequence, cast
+from typing import Iterator, Sequence
 
 
 class MultiAsset(BaseAsset):
@@ -26,16 +26,16 @@ class MultiAsset(BaseAsset):
         """
         if len(assets) != 2:
             raise ValueError("Assets must come in pairs for comparison tasks.")
-        
+
         for asset in assets:
             if not isinstance(asset, (TextAsset, MediaAsset)):
-                raise TypeError("All assets must be a TextAsset or MediaAsset.")    
-        
+                raise TypeError("All assets must be a TextAsset or MediaAsset.")
+
         if not all(isinstance(asset, type(assets[0])) for asset in assets):
             raise ValueError("All assets must be of the same type.")
-        
+
         self.assets = assets
-        
+
     def __len__(self) -> int:
         """
         Get the number of assets in the MultiAsset.
@@ -56,6 +56,6 @@ class MultiAsset(BaseAsset):
 
     def __str__(self) -> str:
         return f"MultiAsset(assets={self.assets})"
-    
+
     def __repr__(self) -> str:
         return f"MultiAsset(assets={self.assets})"