rapidata 2.34.2__py3-none-any.whl → 2.35.0__py3-none-any.whl

rapidata/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.34.2"
+__version__ = "2.35.0"
 
 from .rapidata_client import (
     RapidataClient,

rapidata/api_client/__init__.py

@@ -404,6 +404,7 @@ from rapidata.api_client.models.update_campaign_model import UpdateCampaignModel
 from rapidata.api_client.models.update_dataset_name_model import UpdateDatasetNameModel
 from rapidata.api_client.models.update_dimensions_model import UpdateDimensionsModel
 from rapidata.api_client.models.update_leaderboard_name_model import UpdateLeaderboardNameModel
+from rapidata.api_client.models.update_leaderboard_response_config_model import UpdateLeaderboardResponseConfigModel
 from rapidata.api_client.models.update_order_name_model import UpdateOrderNameModel
 from rapidata.api_client.models.update_participant_name_model import UpdateParticipantNameModel
 from rapidata.api_client.models.update_prompt_tags_model import UpdatePromptTagsModel

rapidata/api_client/api/leaderboard_api.py

@@ -34,6 +34,7 @@ from rapidata.api_client.models.standing_by_leaderboard_paged_result import Stan
 from rapidata.api_client.models.standings_by_leaderboard_result import StandingsByLeaderboardResult
 from rapidata.api_client.models.submit_participant_result import SubmitParticipantResult
 from rapidata.api_client.models.update_leaderboard_name_model import UpdateLeaderboardNameModel
+from rapidata.api_client.models.update_leaderboard_response_config_model import UpdateLeaderboardResponseConfigModel
 
 from rapidata.api_client.api_client import ApiClient, RequestSerialized
 from rapidata.api_client.api_response import ApiResponse
@@ -3098,6 +3099,288 @@ class LeaderboardApi:
 
 
 
+    @validate_call
+    def leaderboard_leaderboard_id_response_config_put(
+        self,
+        leaderboard_id: StrictStr,
+        update_leaderboard_response_config_model: Optional[UpdateLeaderboardResponseConfigModel] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> None:
+        """Updates the name of a leaderboard.
+
+
+        :param leaderboard_id:  (required)
+        :type leaderboard_id: str
+        :param update_leaderboard_response_config_model: 
+        :type update_leaderboard_response_config_model: UpdateLeaderboardResponseConfigModel
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._leaderboard_leaderboard_id_response_config_put_serialize(
+            leaderboard_id=leaderboard_id,
+            update_leaderboard_response_config_model=update_leaderboard_response_config_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def leaderboard_leaderboard_id_response_config_put_with_http_info(
+        self,
+        leaderboard_id: StrictStr,
+        update_leaderboard_response_config_model: Optional[UpdateLeaderboardResponseConfigModel] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[None]:
+        """Updates the name of a leaderboard.
+
+
+        :param leaderboard_id:  (required)
+        :type leaderboard_id: str
+        :param update_leaderboard_response_config_model: 
+        :type update_leaderboard_response_config_model: UpdateLeaderboardResponseConfigModel
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._leaderboard_leaderboard_id_response_config_put_serialize(
+            leaderboard_id=leaderboard_id,
+            update_leaderboard_response_config_model=update_leaderboard_response_config_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def leaderboard_leaderboard_id_response_config_put_without_preload_content(
+        self,
+        leaderboard_id: StrictStr,
+        update_leaderboard_response_config_model: Optional[UpdateLeaderboardResponseConfigModel] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Updates the name of a leaderboard.
+
+
+        :param leaderboard_id:  (required)
+        :type leaderboard_id: str
+        :param update_leaderboard_response_config_model: 
+        :type update_leaderboard_response_config_model: UpdateLeaderboardResponseConfigModel
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._leaderboard_leaderboard_id_response_config_put_serialize(
+            leaderboard_id=leaderboard_id,
+            update_leaderboard_response_config_model=update_leaderboard_response_config_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _leaderboard_leaderboard_id_response_config_put_serialize(
+        self,
+        leaderboard_id,
+        update_leaderboard_response_config_model,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if leaderboard_id is not None:
+            _path_params['leaderboardId'] = leaderboard_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if update_leaderboard_response_config_model is not None:
+            _body_params = update_leaderboard_response_config_model
+
+
+
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json', 
+                        'text/json', 
+                        'application/*+json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='PUT',
+            resource_path='/leaderboard/{leaderboardId}/response-config',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
     @validate_call
     def leaderboard_leaderboard_id_runs_get(
         self,

rapidata/api_client/models/__init__.py

@@ -365,6 +365,7 @@ from rapidata.api_client.models.update_campaign_model import UpdateCampaignModel
 from rapidata.api_client.models.update_dataset_name_model import UpdateDatasetNameModel
 from rapidata.api_client.models.update_dimensions_model import UpdateDimensionsModel
 from rapidata.api_client.models.update_leaderboard_name_model import UpdateLeaderboardNameModel
+from rapidata.api_client.models.update_leaderboard_response_config_model import UpdateLeaderboardResponseConfigModel
 from rapidata.api_client.models.update_order_name_model import UpdateOrderNameModel
 from rapidata.api_client.models.update_participant_name_model import UpdateParticipantNameModel
 from rapidata.api_client.models.update_prompt_tags_model import UpdatePromptTagsModel

rapidata/api_client/models/filter.py

@@ -39,8 +39,8 @@ class Filter(BaseModel):
         if value is None:
             return value
 
-        if value not in set(['Eq', 'Neq', 'Gt', 'Gte', 'Lt', 'Lte', 'Contains', 'StartsWith', 'EndsWith']):
-            raise ValueError("must be one of enum values ('Eq', 'Neq', 'Gt', 'Gte', 'Lt', 'Lte', 'Contains', 'StartsWith', 'EndsWith')")
+        if value not in set(['Eq', 'Neq', 'Gt', 'Gte', 'Lt', 'Lte', 'Contains', 'StartsWith', 'EndsWith', 'In']):
+            raise ValueError("must be one of enum values ('Eq', 'Neq', 'Gt', 'Gte', 'Lt', 'Lte', 'Contains', 'StartsWith', 'EndsWith', 'In')")
         return value
 
     @field_validator('logic')

rapidata/api_client/models/filter_operator.py

@@ -35,6 +35,7 @@ class FilterOperator(str, Enum):
     CONTAINS = 'Contains'
     STARTSWITH = 'StartsWith'
     ENDSWITH = 'EndsWith'
+    IN = 'In'
 
     @classmethod
     def from_json(cls, json_str: str) -> Self:

rapidata/api_client/models/sample_by_participant.py

@@ -34,10 +34,11 @@ class SampleByParticipant(BaseModel):
     asset: DatapointAsset
     prompt: Optional[StrictStr] = None
     prompt_asset: Optional[GetValidationRapidsResultAsset] = Field(default=None, alias="promptAsset")
+    tags: List[StrictStr]
     created_at: Optional[datetime] = Field(default=None, alias="createdAt")
     owner_id: Optional[StrictStr] = Field(default=None, alias="ownerId")
     owner_mail: StrictStr = Field(alias="ownerMail")
-    __properties: ClassVar[List[str]] = ["id", "identifier", "asset", "prompt", "promptAsset", "createdAt", "ownerId", "ownerMail"]
+    __properties: ClassVar[List[str]] = ["id", "identifier", "asset", "prompt", "promptAsset", "tags", "createdAt", "ownerId", "ownerMail"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -111,6 +112,7 @@ class SampleByParticipant(BaseModel):
             "asset": DatapointAsset.from_dict(obj["asset"]) if obj.get("asset") is not None else None,
             "prompt": obj.get("prompt"),
             "promptAsset": GetValidationRapidsResultAsset.from_dict(obj["promptAsset"]) if obj.get("promptAsset") is not None else None,
+            "tags": obj.get("tags"),
             "createdAt": obj.get("createdAt"),
             "ownerId": obj.get("ownerId"),
             "ownerMail": obj.get("ownerMail")

rapidata/api_client/models/update_leaderboard_response_config_model.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    Rapidata.Dataset
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateLeaderboardResponseConfigModel(BaseModel):
+    """
+    The model used to update the name of a leaderboard.
+    """ # noqa: E501
+    response_budget: StrictInt = Field(description="The amount of responses that will be collected when onboarding a new participant.", alias="responseBudget")
+    min_responses: StrictInt = Field(description="The amount of responses that will be collected as a minimum on each matchup.", alias="minResponses")
+    __properties: ClassVar[List[str]] = ["responseBudget", "minResponses"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of UpdateLeaderboardResponseConfigModel from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UpdateLeaderboardResponseConfigModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "responseBudget": obj.get("responseBudget"),
+            "minResponses": obj.get("minResponses")
+        })
+        return _obj
+
+

rapidata/api_client_README.md

@@ -135,6 +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_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.
@@ -563,6 +564,7 @@ Class | Method | HTTP request | Description
  - [UpdateDatasetNameModel](rapidata/api_client/docs/UpdateDatasetNameModel.md)
  - [UpdateDimensionsModel](rapidata/api_client/docs/UpdateDimensionsModel.md)
  - [UpdateLeaderboardNameModel](rapidata/api_client/docs/UpdateLeaderboardNameModel.md)
+ - [UpdateLeaderboardResponseConfigModel](rapidata/api_client/docs/UpdateLeaderboardResponseConfigModel.md)
  - [UpdateOrderNameModel](rapidata/api_client/docs/UpdateOrderNameModel.md)
  - [UpdateParticipantNameModel](rapidata/api_client/docs/UpdateParticipantNameModel.md)
  - [UpdatePromptTagsModel](rapidata/api_client/docs/UpdatePromptTagsModel.md)

rapidata/rapidata_client/benchmark/_detail_mapper.py

@@ -0,0 +1,34 @@
+from typing import Literal
+
+
+class DetailMapper:
+    MIN_RESPONSES = 3
+
+    @staticmethod
+    def get_budget(
+        level_of_detail: Literal["low", "medium", "high", "very high"]
+    ) -> int:
+        if level_of_detail == "low":
+            return 2_000
+        elif level_of_detail == "medium":
+            return 4_000
+        elif level_of_detail == "high":
+            return 8_000
+        elif level_of_detail == "very high":
+            return 16_000
+        else:
+            raise ValueError(
+                "Invalid level of detail. Must be one of: 'low', 'medium', 'high', 'very high'"
+            )
+
+    @staticmethod
+    def get_level_of_detail(
+        response_budget: int,
+    ) -> Literal["low", "medium", "high", "very high"]:
+        if response_budget < 4_000:
+            return "low"
+        elif response_budget < 8_000:
+            return "medium"
+        elif response_budget < 16_000:
+            return "high"
+        return "very high"

rapidata/rapidata_client/benchmark/leaderboard/rapidata_leaderboard.py

@@ -1,7 +1,12 @@
 import pandas as pd
-from typing import Optional
+from typing import Literal, Optional
 
+from rapidata.rapidata_client.logging import logger
+from rapidata.rapidata_client.benchmark._detail_mapper import DetailMapper
 from rapidata.service.openapi_service import OpenAPIService
+from rapidata.api_client.models.update_leaderboard_response_config_model import (
+    UpdateLeaderboardResponseConfigModel,
+)
 
 
 class RapidataLeaderboard:
@@ -17,68 +22,79 @@ class RapidataLeaderboard:
         id: The ID of the leaderboard.
         openapi_service: The OpenAPIService instance for API interaction.
     """
-    def __init__(self, 
-                 name: str, 
-                 instruction: str, 
-                 show_prompt: bool, 
-                 show_prompt_asset: bool,
-                 inverse_ranking: bool, 
-                 min_responses: int,
-                 response_budget: int,
-                 id: str, 
-                 openapi_service: OpenAPIService):
+
+    def __init__(
+        self,
+        name: str,
+        instruction: str,
+        show_prompt: bool,
+        show_prompt_asset: bool,
+        inverse_ranking: bool,
+        response_budget: int,
+        id: str,
+        openapi_service: OpenAPIService,
+    ):
         self.__openapi_service = openapi_service
         self.__name = name
         self.__instruction = instruction
         self.__show_prompt = show_prompt
         self.__show_prompt_asset = show_prompt_asset
         self.__inverse_ranking = inverse_ranking
-        self.__min_responses = min_responses
         self.__response_budget = response_budget
         self.id = id
 
     @property
-    def response_budget(self) -> int:
+    def level_of_detail(self) -> Literal["low", "medium", "high", "very high"]:
         """
-        Returns the response budget of the leaderboard.
+        Returns the level of detail of the leaderboard.
         """
-        return self.__response_budget
-    
-    @property
-    def min_responses(self) -> int:
+        return DetailMapper.get_level_of_detail(self.__response_budget)
+
+    @level_of_detail.setter
+    def level_of_detail(
+        self, level_of_detail: Literal["low", "medium", "high", "very high"]
+    ):
         """
-        Returns the minimum number of responses required to be considered for the leaderboard.
+        Sets the level of detail of the leaderboard.
         """
-        return self.__min_responses
-    
+        logger.debug(f"Setting level of detail to {level_of_detail}")
+        self.__openapi_service.leaderboard_api.leaderboard_leaderboard_id_response_config_put(
+            leaderboard_id=self.id,
+            update_leaderboard_response_config_model=UpdateLeaderboardResponseConfigModel(
+                responseBudget=DetailMapper.get_budget(level_of_detail),
+                minResponses=DetailMapper.MIN_RESPONSES,
+            ),
+        )
+        self.__response_budget = DetailMapper.get_budget(level_of_detail)
+
     @property
     def show_prompt_asset(self) -> bool:
         """
         Returns whether the prompt asset is shown to the users.
         """
         return self.__show_prompt_asset
-    
+
     @property
     def inverse_ranking(self) -> bool:
         """
         Returns whether the ranking is inverse.
         """
         return self.__inverse_ranking
-    
+
     @property
     def show_prompt(self) -> bool:
         """
         Returns whether the prompt is shown to the users.
         """
         return self.__show_prompt
-    
+
     @property
     def instruction(self) -> str:
         """
         Returns the instruction of the leaderboard.
         """
         return self.__instruction
-    
+
     @property
     def name(self) -> str:
         """
@@ -100,28 +116,28 @@ class RapidataLeaderboard:
         """
 
         participants = self.__openapi_service.leaderboard_api.leaderboard_leaderboard_id_standings_get(
-            leaderboard_id=self.id,
-            tags=tags
+            leaderboard_id=self.id, tags=tags
         )
 
         standings = []
         for participant in participants.items:
-            standings.append({
-                "name": participant.name,
-                "wins": participant.wins,
-                "total_matches": participant.total_matches,
-                "score": round(participant.score, 2) if participant.score is not None else None,
-            })
+            standings.append(
+                {
+                    "name": participant.name,
+                    "wins": participant.wins,
+                    "total_matches": participant.total_matches,
+                    "score": (
+                        round(participant.score, 2)
+                        if participant.score is not None
+                        else None
+                    ),
+                }
+            )
 
         return pd.DataFrame(standings)
 
     def __str__(self) -> str:
         return f"RapidataLeaderboard(name={self.name}, instruction={self.instruction}, show_prompt={self.show_prompt}, leaderboard_id={self.id})"
-    
+
     def __repr__(self) -> str:
         return self.__str__()
-
-
-        
-
-

rapidata/rapidata_client/benchmark/rapidata_benchmark.py

@@ -1,24 +1,34 @@
 import re
-from typing import Optional
+from typing import Literal, Optional
 from rapidata.api_client.models.root_filter import RootFilter
 from rapidata.api_client.models.filter import Filter
 from rapidata.api_client.models.query_model import QueryModel
 from rapidata.api_client.models.page_info import PageInfo
 from rapidata.api_client.models.create_leaderboard_model import CreateLeaderboardModel
-from rapidata.api_client.models.create_benchmark_participant_model import CreateBenchmarkParticipantModel
+from rapidata.api_client.models.create_benchmark_participant_model import (
+    CreateBenchmarkParticipantModel,
+)
 from rapidata.api_client.models.submit_prompt_model import SubmitPromptModel
-from rapidata.api_client.models.submit_prompt_model_prompt_asset import SubmitPromptModelPromptAsset
+from rapidata.api_client.models.submit_prompt_model_prompt_asset import (
+    SubmitPromptModelPromptAsset,
+)
 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.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.benchmark.leaderboard.rapidata_leaderboard import (
+    RapidataLeaderboard,
+)
 from rapidata.rapidata_client.datapoints.assets import MediaAsset
+from rapidata.rapidata_client.benchmark._detail_mapper import DetailMapper
+
 
 class RapidataBenchmark:
     """
@@ -31,6 +41,7 @@ class RapidataBenchmark:
         id: The id of the benchmark.
         openapi_service: The OpenAPI service to use to interact with the Rapidata API.
     """
+
     def __init__(self, name: str, id: str, openapi_service: OpenAPIService):
         self.name = name
         self.id = id
@@ -40,51 +51,54 @@ class RapidataBenchmark:
         self.__leaderboards: list[RapidataLeaderboard] = []
         self.__identifiers: list[str] = []
         self.__tags: list[list[str]] = []
-    
+
     def __instantiate_prompts(self) -> None:
         current_page = 1
         total_pages = None
-        
+
         while True:
-            prompts_result = self.__openapi_service.benchmark_api.benchmark_benchmark_id_prompts_get(
-                benchmark_id=self.id,
-                request=QueryModel(
-                    page=PageInfo(
-                        index=current_page,
-                        size=100
-                    )
+            prompts_result = (
+                self.__openapi_service.benchmark_api.benchmark_benchmark_id_prompts_get(
+                    benchmark_id=self.id,
+                    request=QueryModel(page=PageInfo(index=current_page, size=100)),
                 )
             )
-            
+
             if prompts_result.total_pages is None:
-                raise ValueError("An error occurred while fetching prompts: total_pages is None")
-            
+                raise ValueError(
+                    "An error occurred while fetching prompts: total_pages is None"
+                )
+
             total_pages = prompts_result.total_pages
-            
+
             for prompt in prompts_result.items:
                 self.__prompts.append(prompt.prompt)
                 self.__identifiers.append(prompt.identifier)
                 if prompt.prompt_asset is None:
                     self.__prompt_assets.append(None)
                 else:
-                    assert isinstance(prompt.prompt_asset.actual_instance, FileAssetModel)
-                    source_url = prompt.prompt_asset.actual_instance.metadata["sourceUrl"].actual_instance
+                    assert isinstance(
+                        prompt.prompt_asset.actual_instance, FileAssetModel
+                    )
+                    source_url = prompt.prompt_asset.actual_instance.metadata[
+                        "sourceUrl"
+                    ].actual_instance
                     assert isinstance(source_url, SourceUrlMetadataModel)
                     self.__prompt_assets.append(source_url.url)
 
                 self.__tags.append(prompt.tags)
             if current_page >= total_pages:
                 break
-                
+
             current_page += 1
 
     @property
     def identifiers(self) -> list[str]:
         if not self.__identifiers:
             self.__instantiate_prompts()
-        
+
         return self.__identifiers
-    
+
     @property
     def prompts(self) -> list[str | None]:
         """
@@ -92,9 +106,9 @@ class RapidataBenchmark:
         """
         if not self.__prompts:
             self.__instantiate_prompts()
-        
+
         return self.__prompts
-    
+
     @property
     def prompt_assets(self) -> list[str | None]:
         """
@@ -102,9 +116,9 @@ class RapidataBenchmark:
         """
         if not self.__prompt_assets:
             self.__instantiate_prompts()
-        
+
         return self.__prompt_assets
-    
+
     @property
     def tags(self) -> list[list[str]]:
         """
@@ -112,9 +126,9 @@ class RapidataBenchmark:
         """
         if not self.__tags:
             self.__instantiate_prompts()
-        
+
         return self.__tags
-    
+
     @property
     def leaderboards(self) -> list[RapidataLeaderboard]:
         """
@@ -123,48 +137,62 @@ class RapidataBenchmark:
         if not self.__leaderboards:
             current_page = 1
             total_pages = None
-            
+
             while True:
-                leaderboards_result = self.__openapi_service.leaderboard_api.leaderboards_get(
-                    request=QueryModel(
-                        filter=RootFilter(
-                            filters=[
-                                Filter(field="BenchmarkId", operator="Eq", value=self.id)
+                leaderboards_result = (
+                    self.__openapi_service.leaderboard_api.leaderboards_get(
+                        request=QueryModel(
+                            filter=RootFilter(
+                                filters=[
+                                    Filter(
+                                        field="BenchmarkId",
+                                        operator="Eq",
+                                        value=self.id,
+                                    )
                                 ]
                             ),
-                        page=PageInfo(
-                            index=current_page,
-                            size=100
+                            page=PageInfo(index=current_page, size=100),
                         )
                     )
                 )
-                
+
                 if leaderboards_result.total_pages is None:
-                    raise ValueError("An error occurred while fetching leaderboards: total_pages is None")
-                
+                    raise ValueError(
+                        "An error occurred while fetching leaderboards: total_pages is None"
+                    )
+
                 total_pages = leaderboards_result.total_pages
-                
-                self.__leaderboards.extend([
-                    RapidataLeaderboard(
-                        leaderboard.name, 
-                        leaderboard.instruction, 
-                        leaderboard.show_prompt, 
-                        leaderboard.show_prompt_asset,
-                        leaderboard.is_inversed,
-                        leaderboard.min_responses,
-                        leaderboard.response_budget,
-                        leaderboard.id, 
-                        self.__openapi_service
-                        ) for leaderboard in leaderboards_result.items])
-                
+
+                self.__leaderboards.extend(
+                    [
+                        RapidataLeaderboard(
+                            leaderboard.name,
+                            leaderboard.instruction,
+                            leaderboard.show_prompt,
+                            leaderboard.show_prompt_asset,
+                            leaderboard.is_inversed,
+                            leaderboard.response_budget,
+                            leaderboard.id,
+                            self.__openapi_service,
+                        )
+                        for leaderboard in leaderboards_result.items
+                    ]
+                )
+
                 if current_page >= total_pages:
                     break
-                    
+
                 current_page += 1
-                
+
         return self.__leaderboards
-    
-    def add_prompt(self, identifier: str, prompt: str | None = None, asset: str | None = None, tags: Optional[list[str]] = None):
+
+    def add_prompt(
+        self,
+        identifier: str,
+        prompt: str | None = None,
+        asset: str | None = None,
+        tags: Optional[list[str]] = None,
+    ):
         """
         Adds a prompt to the benchmark.
 
@@ -179,25 +207,27 @@ class RapidataBenchmark:
 
         if not isinstance(identifier, str):
             raise ValueError("Identifier must be a string.")
-        
+
         if prompt is None and asset is None:
             raise ValueError("Prompt or asset must be provided.")
-        
+
         if prompt is not None and not isinstance(prompt, str):
             raise ValueError("Prompt must be a string.")
-        
+
         if asset is not None and not isinstance(asset, str):
             raise ValueError("Asset must be a string. That is the link to the asset.")
-        
+
         if identifier in self.identifiers:
             raise ValueError("Identifier already exists in the benchmark.")
-        
-        if asset is not None and not re.match(r'^https?://', asset):
+
+        if asset is not None and not re.match(r"^https?://", asset):
             raise ValueError("Asset must be a link to the asset.")
-        
-        if tags is not None and (not isinstance(tags, list) or not all(isinstance(tag, str) for tag in tags)):
+
+        if tags is not None and (
+            not isinstance(tags, list) or not all(isinstance(tag, str) for tag in tags)
+        ):
             raise ValueError("Tags must be a list of strings.")
-        
+
         self.__identifiers.append(identifier)
 
         self.__tags.append(tags)
@@ -209,25 +239,25 @@ class RapidataBenchmark:
             submit_prompt_model=SubmitPromptModel(
                 identifier=identifier,
                 prompt=prompt,
-                promptAsset=SubmitPromptModelPromptAsset(
-                    UrlAssetInput(
-                        _t="UrlAssetInput",
-                        url=asset
+                promptAsset=(
+                    SubmitPromptModelPromptAsset(
+                        UrlAssetInput(_t="UrlAssetInput", url=asset)
                     )
-                ) if asset is not None else None,
-                tags=tags
-            )
+                    if asset is not None
+                    else None
+                ),
+                tags=tags,
+            ),
         )
 
     def create_leaderboard(
-        self, 
-        name: str, 
-        instruction: str, 
+        self,
+        name: str,
+        instruction: str,
         show_prompt: bool = False,
         show_prompt_asset: bool = False,
         inverse_ranking: bool = False,
-        min_responses: int | None = None,
-        response_budget: int | None = None
+        level_of_detail: Literal["low", "medium", "high", "very high"] = "low",
     ) -> RapidataLeaderboard:
         """
         Creates a new leaderboard for the benchmark.
@@ -238,13 +268,8 @@ class RapidataBenchmark:
             show_prompt: Whether to show the prompt to the users. (default: False)
             show_prompt_asset: Whether to show the prompt asset to the users. (only works if the prompt asset is a URL) (default: False)
             inverse_ranking: Whether to inverse the ranking of the leaderboard. (if the question is inversed, e.g. "Which video is worse?")
-            min_responses: The minimum amount of responses that get collected per comparison. if None, it will be defaulted.
-            response_budget: The total amount of responses that get collected per new model evaluation. if None, it will be defaulted. Values below 2000 are not recommended.
+            level_of_detail: The level of detail of the leaderboard. This will effect how many comparisons are done per model evaluation. (default: "low")
         """
-
-        if response_budget is not None and response_budget < 2000:
-            logger.warning("Response budget is below 2000. This is not recommended.")
-
         leaderboard_result = self.__openapi_service.leaderboard_api.leaderboard_post(
             create_leaderboard_model=CreateLeaderboardModel(
                 benchmarkId=self.id,
@@ -253,12 +278,14 @@ class RapidataBenchmark:
                 showPrompt=show_prompt,
                 showPromptAsset=show_prompt_asset,
                 isInversed=inverse_ranking,
-                minResponses=min_responses,
-                responseBudget=response_budget
+                minResponses=DetailMapper.MIN_RESPONSES,
+                responseBudget=DetailMapper.get_budget(level_of_detail),
             )
         )
 
-        assert leaderboard_result.benchmark_id == self.id, "The leaderboard was not created for the correct benchmark."
+        assert (
+            leaderboard_result.benchmark_id == self.id
+        ), "The leaderboard was not created for the correct benchmark."
 
         return RapidataLeaderboard(
             name,
@@ -266,13 +293,14 @@ class RapidataBenchmark:
             show_prompt,
             show_prompt_asset,
             inverse_ranking,
-            leaderboard_result.min_responses,
             leaderboard_result.response_budget,
             leaderboard_result.id,
-            self.__openapi_service
+            self.__openapi_service,
         )
 
-    def evaluate_model(self, name: str, media: list[str], identifiers: list[str]) -> None:
+    def evaluate_model(
+        self, name: str, media: list[str], identifiers: list[str]
+    ) -> None:
         """
         Evaluates a model on the benchmark across all leaderboards.
 
@@ -284,14 +312,16 @@ class RapidataBenchmark:
         """
         if not media:
             raise ValueError("Media must be a non-empty list of strings")
-        
+
         if len(media) != len(identifiers):
             raise ValueError("Media and identifiers must have the same length")
-        
+
         if not all(identifier in self.identifiers for identifier in identifiers):
-            raise ValueError("All identifiers must be in the registered identifiers list. To see the registered identifiers, use the identifiers property.\
-\nTo see the prompts that are associated with the identifiers, use the prompts property.")
-        
+            raise ValueError(
+                "All identifiers must be in the registered identifiers list. To see the registered identifiers, use the identifiers property.\
+\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: list[MediaAsset] = []
         for media_path in media:
@@ -301,12 +331,14 @@ class RapidataBenchmark:
             benchmark_id=self.id,
             create_benchmark_participant_model=CreateBenchmarkParticipantModel(
                 name=name,
-            )
+            ),
         )
 
         logger.info(f"Participant created: {participant_result.participant_id}")
 
-        participant = BenchmarkParticipant(name, participant_result.participant_id, self.__openapi_service)
+        participant = BenchmarkParticipant(
+            name, participant_result.participant_id, self.__openapi_service
+        )
 
         successful_uploads, failed_uploads = participant.upload_media(
             assets,
@@ -314,15 +346,25 @@ class RapidataBenchmark:
         )
 
         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)")
+        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.")
+            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.")
+            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
@@ -330,6 +372,6 @@ class RapidataBenchmark:
 
     def __str__(self) -> str:
         return f"RapidataBenchmark(name={self.name}, id={self.id})"
-    
+
     def __repr__(self) -> str:
         return self.__str__()

{rapidata-2.34.2.dist-info → rapidata-2.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.34.2
+Version: 2.35.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

{rapidata-2.34.2.dist-info → rapidata-2.35.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-rapidata/__init__.py,sha256=_kFxSic1rowFfqj5HEJkNdrGtb1oe_MQmhcqPLnRDXg,897
-rapidata/api_client/__init__.py,sha256=N4Cx20ScEXZ9A2pdsn8ZPUuhnpeXlGByav3P_1ofQ_8,34733
+rapidata/__init__.py,sha256=LHrPkAuvFTYjxU8zeMmh15W2xmXsvyVcIK_bv8qScRg,897
+rapidata/api_client/__init__.py,sha256=fb2lqv3sj48wAgarp3g6hvtTgd7bfI01DJJLuBZQnFI,34850
 rapidata/api_client/api/__init__.py,sha256=dGnSE9oPO_ahGh-E1jtw4_VuM_vQueQFuv0IVMQo6uo,1546
 rapidata/api_client/api/benchmark_api.py,sha256=bC8hAPgHIDU5u1e0loWPWnZX33BW6gsAR8oc5199q2k,129777
 rapidata/api_client/api/campaign_api.py,sha256=406gNDALFb0sJhfx727ZM5_0GDX4iB0w5ym2dExLm4g,49894
@@ -12,7 +12,7 @@ rapidata/api_client/api/dataset_api.py,sha256=DUCEfP7jlMAAMdvEa-47xq0mq3MGcyk4DA
 rapidata/api_client/api/evaluation_workflow_api.py,sha256=E0Phmx54jzXx7LZYGquTqzZSrX2aE5PS9rAs5HdDjvs,15151
 rapidata/api_client/api/feedback_api.py,sha256=-ZI2-1HtQ7wAzBKClgXMmMHtYdgoZtWrpQql3p51qp0,11589
 rapidata/api_client/api/identity_api.py,sha256=LmK6cTXssNjCa1BteOMc8P4FsyRiHQ_Kr30vmWIAYko,55093
-rapidata/api_client/api/leaderboard_api.py,sha256=M82K7VI72c72Ij1_Svz7qm_ttVDuAilSi0g9B4BuU4g,167604
+rapidata/api_client/api/leaderboard_api.py,sha256=wGnMTeaYsyeWwvptdD5R3OJK42ZJWQhyJvwDmN3bqQc,179275
 rapidata/api_client/api/newsletter_api.py,sha256=3NU6HO5Gtm-RH-nx5hcp2CCE4IZmWHwTfCLMMz-Xpq4,22655
 rapidata/api_client/api/order_api.py,sha256=6hD7a_8LVGuGdT_k1lE-gQKCWcSAcFMJO5Nsdc8xgbM,214715
 rapidata/api_client/api/participant_api.py,sha256=eOoZDCRF61bmPAcoMWhOREgUp3rEYhrQLEPJq8o27b4,87709
@@ -29,7 +29,7 @@ rapidata/api_client/api_client.py,sha256=EDhxAOUc5JFWvFsF1zc726Q7GoEFkuB8uor5SlG
 rapidata/api_client/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
 rapidata/api_client/configuration.py,sha256=g472vHVPLBotq8EkfSXP4sbp7xnn-3sb8O8BBlRWK1I,15931
 rapidata/api_client/exceptions.py,sha256=eLLd1fxM0Ygf3IIG6aNx9hdy79drst5Cem0UjI_NamM,5978
-rapidata/api_client/models/__init__.py,sha256=1mQliyAedV6ftD2vpUt5Dnv_E8JyeCFkSMZB_YMutC4,32646
+rapidata/api_client/models/__init__.py,sha256=f6lXxDLfQKlvw0DZddgyzBZn3jEFyt5OBIitESxPbtQ,32763
 rapidata/api_client/models/ab_test_selection.py,sha256=xQcE1BgKSnkTcmIuroeVOAQcAhGkHLlMP9XjakMFgDc,4327
 rapidata/api_client/models/ab_test_selection_a_inner.py,sha256=VsCi27NBGxAtupB_sQZCzUEsTNNgSGV_Mo-Fi0UY1Jw,11657
 rapidata/api_client/models/add_campaign_artifact_result.py,sha256=4IvFVS-tLlL6eHsWp-IZ_ul5T30-h3YEwd2B5ioBbgY,2582
@@ -212,8 +212,8 @@ rapidata/api_client/models/file_asset_model_metadata_value.py,sha256=KiA2BENesZt
 rapidata/api_client/models/file_type.py,sha256=t7qrK5oEaVWWg7pis5mO2BviaVNuAUh7O1SNib_kfGw,783
 rapidata/api_client/models/file_type_metadata.py,sha256=qvRJ0SWEy2mPfvjGAc1GV5AMRjOm4EMXRAQ-sTupv6Q,3412
 rapidata/api_client/models/file_type_metadata_model.py,sha256=1BHfr0wk3HQSNmMTDWdROPtLsPwE88Z2D1YaEnOte7E,3308
-rapidata/api_client/models/filter.py,sha256=-gje_jVjRXyeguRj9yGuHgyi53hn871Z_2ULs_5yVr8,4541
-rapidata/api_client/models/filter_operator.py,sha256=hVWuGOU6iseDxdJCG4E-b5Pbb8w3rCLT26ukvmwx6G0,889
+rapidata/api_client/models/filter.py,sha256=cIvVdYntcGLQLgW0iNTqGdEj_jJQQBcMt9pF_l_FVug,4553
+rapidata/api_client/models/filter_operator.py,sha256=zPAPopNy6Jlw-3Gz-tEsape0SyriGvfXREij57bNdP4,903
 rapidata/api_client/models/form_file_wrapper.py,sha256=1KSzAKKGE_-yXTyIyjHi5ctc_CrGCRfkX3EMqlW0IFA,4208
 rapidata/api_client/models/free_text_payload.py,sha256=u5p0ybMMOH2ecmzT3FauQs0LgQgLNnUOD8Kk1umOqtw,2952
 rapidata/api_client/models/free_text_rapid_blueprint.py,sha256=Tpf2durJj9olZbI-QPl89BiLESrOs9fDbATpch8tRj4,2988
@@ -425,7 +425,7 @@ rapidata/api_client/models/root_filter.py,sha256=oBtXjKE0i3m_HmD1XeHwaLCFFQRkpkW
 rapidata/api_client/models/run_status.py,sha256=wtGbdMPDcpR35pMbczVABkYfERTWnocMon2s-uaaaUM,798
 rapidata/api_client/models/runs_by_leaderboard_result.py,sha256=5sRSV7d9rxjBbdTnWk10ke1GW4jVKZ8O5iSMclthryk,3581
 rapidata/api_client/models/runs_by_leaderboard_result_paged_result.py,sha256=Ts5gkkQLKIbISLay6xlVYdu0vyXxAwtY7mwQMKobC-Y,3559
-rapidata/api_client/models/sample_by_participant.py,sha256=N1DHLru8cPit7-sT_8a1Ein47slvtH6UsJwPUYmZjgs,4437
+rapidata/api_client/models/sample_by_participant.py,sha256=-CxSOHphruBeeSTblX4yrERL4o7PFx4ofnfyl9JMcko,4508
 rapidata/api_client/models/sample_by_participant_paged_result.py,sha256=FKobGmMEymLQwRbwdS5R-nox_AtFAxg9CuVopWNQgTk,3526
 rapidata/api_client/models/scrub_payload.py,sha256=tX-QU_a8GUQWBPb1GofGLFupucZF5TY2LUpqdyfHDSI,2920
 rapidata/api_client/models/scrub_range.py,sha256=2P__eZ4HeAxWcjFkp-p938Ih8GHf0rJea18sIGxUN0A,2527
@@ -494,6 +494,7 @@ rapidata/api_client/models/update_campaign_model.py,sha256=9mCp3fQZqtecsCQS1SBbf
 rapidata/api_client/models/update_dataset_name_model.py,sha256=IeGRrxo6G2fKfMwnoBFYj4BW9ksGo_8db21VcLYfLvc,2599
 rapidata/api_client/models/update_dimensions_model.py,sha256=jDg2114Y14AxcQHg_C6oTxMZ17Cq4vEQRtzeNjN70dk,2591
 rapidata/api_client/models/update_leaderboard_name_model.py,sha256=QmEy8MNkrQYyJtXR91MKN1j511YFIIW-ovN3MxvFoWw,2614
+rapidata/api_client/models/update_leaderboard_response_config_model.py,sha256=Jkp3zS358CD1EPhknNp1voUOAtuQFPBstlw1SMJc6JI,2978
 rapidata/api_client/models/update_order_model.py,sha256=RUlxnzLqO6o-w5EEPb8wv1ANRKpkSbs8PhGM42T35uw,2570
 rapidata/api_client/models/update_order_name_model.py,sha256=Cm8qZUJKgx1JTgkhlJcVNdLwPnRV8gqeeo7G4bVDOS4,2582
 rapidata/api_client/models/update_participant_name_model.py,sha256=PPXeS5euTpMt7QrmLWordYU1tGS1gZ-zwjgQDglld_g,2614
@@ -536,16 +537,17 @@ rapidata/api_client/models/workflow_split_model_filter_configs_inner.py,sha256=1
 rapidata/api_client/models/workflow_state.py,sha256=5LAK1se76RCoozeVB6oxMPb8p_5bhLZJqn7q5fFQWis,850
 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=hFJwQC9pI9JtopNmka-9TUPcRqhY3zhhrZj0ebJizVs,62286
+rapidata/api_client_README.md,sha256=5k-14YuFPSGEpYGJsIL0xwyEWeIvuWd3VOI7jFYw_dc,62649
 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/_detail_mapper.py,sha256=IcCW0d3_vwAdyG7V9P5UMPASoblk6JX5UEhrfHcaAIs,967
 rapidata/rapidata_client/benchmark/leaderboard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rapidata/rapidata_client/benchmark/leaderboard/rapidata_leaderboard.py,sha256=PKqcW_pQJLmNg_feLDCtF-9SufMw2_EU4yKFo6QxxR0,3950
+rapidata/rapidata_client/benchmark/leaderboard/rapidata_leaderboard.py,sha256=ucbE6wSNaT8Li_XTxoze1iEYppaHw8OTcqlP-PW5KMw,4767
 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=qk8Y0ShIawtSNsxhp3rZ-OOCFuh4Pl_w7K9IRnTNt3Y,14131
+rapidata/rapidata_client/benchmark/rapidata_benchmark.py,sha256=wZgN79jV4WF6HtNYl8gqTHArCEi8WHy3zN1xnxzTS6A,14268
 rapidata/rapidata_client/benchmark/rapidata_benchmark_manager.py,sha256=NnXCsU2_8SlGxdI51MeIUWK7Ku0pEylDSPhnzOPzTV0,5291
 rapidata/rapidata_client/country_codes/__init__.py,sha256=FB9Dcks44J6C6YBSYmTmNZ71tE130x6NO_3aLJ8fKzQ,40
 rapidata/rapidata_client/country_codes/country_codes.py,sha256=ePHqeb7y9DWQZAnddBzPx1puYBcrgUjdR2sbFijuFD8,283
@@ -649,7 +651,7 @@ rapidata/service/__init__.py,sha256=s9bS1AJZaWIhLtJX_ZA40_CK39rAAkwdAmymTMbeWl4,
 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=v2fhPbHmD0J11ZRZY6f80PdIdGwpRFlbfMH9t8Ypg5A,5403
-rapidata-2.34.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-rapidata-2.34.2.dist-info/METADATA,sha256=7bXBvmc-1hRDkklCi2EvcLlAelpTVVzghPj7cJdV6hc,1264
-rapidata-2.34.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-rapidata-2.34.2.dist-info/RECORD,,
+rapidata-2.35.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+rapidata-2.35.0.dist-info/METADATA,sha256=lGStAMXDWn_ztSIkIrN6bpJJ2HiZE7ivo1Z0LQ_eRAo,1264
+rapidata-2.35.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+rapidata-2.35.0.dist-info/RECORD,,