rapidata 2.28.4__py3-none-any.whl → 2.29.0__py3-none-any.whl

rapidata/rapidata_client/benchmark/rapidata_benchmark.py

@@ -0,0 +1,227 @@
+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.submit_prompt_model import SubmitPromptModel
+
+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.metadata import PromptIdentifierMetadata
+from rapidata.rapidata_client.assets import MediaAsset
+from rapidata.rapidata_client.order._rapidata_dataset import RapidataDataset
+
+class RapidataBenchmark:
+    """
+    An instance of a Rapidata benchmark.
+
+    Used to interact with a specific benchmark in the Rapidata system, such as retrieving prompts and evaluating models.
+
+    Args:
+        name: The name that will be used to identify the benchmark on the overview.
+        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
+        self.__openapi_service = openapi_service
+        self.__prompts: list[str] = []
+        self.__leaderboards: list[RapidataLeaderboard] = []
+        self.__identifiers: 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
+                    )
+                )
+            )
+            
+            if prompts_result.total_pages is None:
+                raise ValueError("An error occurred while fetching prompts: total_pages is None")
+            
+            total_pages = prompts_result.total_pages
+            
+            self.__prompts.extend([prompt.prompt for prompt in prompts_result.items])
+            self.__identifiers.extend([prompt.identifier for prompt in prompts_result.items])
+            
+            if current_page >= total_pages:
+                break
+                
+            current_page += 1
+
+    @property
+    def prompts(self) -> list[str]:
+        """
+        Returns the prompts that are registered for the leaderboard.
+        """
+        if not self.__prompts:
+            self.__instantiate_prompts()
+        
+        return self.__prompts
+    
+    @property
+    def identifiers(self) -> list[str]:
+        if not self.__identifiers:
+            self.__instantiate_prompts()
+        
+        return self.__identifiers
+    
+    @property
+    def leaderboards(self) -> list[RapidataLeaderboard]:
+        """
+        Returns the leaderboards that are registered for the benchmark.
+        """
+        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)
+                                ]
+                            ),
+                        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")
+                
+                total_pages = leaderboards_result.total_pages
+                
+                self.__leaderboards.extend([
+                    RapidataLeaderboard(
+                        leaderboard.name, 
+                        leaderboard.instruction, 
+                        leaderboard.show_prompt, 
+                        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):
+        """
+        Adds a prompt to the benchmark.
+        """
+        if not isinstance(identifier, str) or not isinstance(prompt, str):
+            raise ValueError("Identifier and prompt must be strings.")
+        
+        if identifier in self.identifiers:
+            raise ValueError("Identifier already exists in the benchmark.")
+        
+        self.__identifiers.append(identifier)
+        self.__prompts.append(prompt)
+
+        self.__openapi_service.benchmark_api.benchmark_benchmark_id_prompt_post(
+            benchmark_id=self.id,
+            submit_prompt_model=SubmitPromptModel(
+                identifier=identifier,
+                prompt=prompt,
+            )
+        )
+
+    def create_leaderboard(self, name: str, instruction: str, show_prompt: bool) -> RapidataLeaderboard:
+        """
+        Creates a new leaderboard for the benchmark.
+        """
+        leaderboard_result = self.__openapi_service.leaderboard_api.leaderboard_post(
+            create_leaderboard_model=CreateLeaderboardModel(
+                benchmarkId=self.id,
+                name=name,
+                instruction=instruction,
+                showPrompt=show_prompt
+            )
+        )
+
+        assert leaderboard_result.benchmark_id == self.id, "The leaderboard was not created for the correct benchmark."
+
+        return RapidataLeaderboard(
+            name,
+            instruction,
+            show_prompt,
+            leaderboard_result.id,
+            self.__openapi_service
+        )
+    
+    def evaluate_model(self, name: str, media: list[str], identifiers: list[str]) -> None:
+        """
+        Evaluates a model on the benchmark across all leaderboards.
+
+        Args:
+            name: The name of the model.
+            media: The generated images/videos that will be used to evaluate the model.
+            identifiers: The identifiers that correspond to the media. The order of the identifiers must match the order of the media.
+                The identifiers that are used must be registered for the benchmark. To see the registered identifiers, use the identifiers property.
+        """
+        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.")
+        
+        # happens before the creation of the participant to ensure all media paths are valid
+        assets = []
+        prompts_metadata: list[list[PromptIdentifierMetadata]] = []
+        for media_path, identifier in zip(media, identifiers):
+            assets.append(MediaAsset(media_path))
+            prompts_metadata.append([PromptIdentifierMetadata(identifier=identifier)])
+
+        participant_result = self.__openapi_service.benchmark_api.benchmark_benchmark_id_participants_post(
+            benchmark_id=self.id,
+            create_benchmark_participant_model=CreateBenchmarkParticipantModel(
+                name=name,
+            )
+        )
+
+        dataset = RapidataDataset(participant_result.dataset_id, self.__openapi_service)
+        
+        try:
+            dataset._add_datapoints(assets, prompts_metadata)
+        except Exception as e:
+            logger.warning(f"An error occurred while adding datapoints to the dataset: {e}")
+            upload_progress = self.__openapi_service.dataset_api.dataset_dataset_id_progress_get(
+                dataset_id=dataset.id
+            )
+            if upload_progress.ready == 0:
+                raise RuntimeError("None of the media was uploaded successfully. Please check the media paths and try again.")
+            
+            logger.warning(f"{upload_progress.failed} datapoints failed to upload. \n{upload_progress.ready} datapoints were uploaded successfully. \nEvaluation will continue with the uploaded datapoints.")
+
+        self.__openapi_service.benchmark_api.benchmark_benchmark_id_participants_participant_id_submit_post(
+            benchmark_id=self.id,
+            participant_id=participant_result.participant_id
+        )
+
+    def __str__(self) -> str:
+        return f"RapidataBenchmark(name={self.name}, id={self.id})"
+    
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/benchmark/rapidata_benchmark_manager.py

@@ -0,0 +1,83 @@
+from rapidata.rapidata_client.benchmark.rapidata_benchmark import RapidataBenchmark
+from rapidata.api_client.models.create_benchmark_model import CreateBenchmarkModel
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.api_client.models.query_model import QueryModel
+from rapidata.api_client.models.page_info import PageInfo
+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.
+
+    Used to create and retrieve benchmarks.
+
+    A benchmark is a collection of leaderboards.
+
+    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: list[str],
+                             ) -> RapidataBenchmark:
+        """
+        Creates a new benchmark with the given name, prompts, and leaderboards.
+
+        Args:
+            name: The name of the benchmark.
+            prompts: The prompts that will be registered for the benchmark.
+        """
+        if not isinstance(name, str):
+            raise ValueError("Name must be a string.")
+        
+        if not isinstance(prompts, list) or not all(isinstance(prompt, str) for prompt in prompts):
+            raise ValueError("Prompts must be a list of strings.")
+        
+        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 len(identifiers) != len(prompts):
+            raise ValueError("Identifiers and prompts must have the same length.")
+        
+        if len(set(identifiers)) != len(identifiers):
+            raise ValueError("Identifiers must be unique.")
+
+        benchmark_result = self.__openapi_service.benchmark_api.benchmark_post(
+            create_benchmark_model=CreateBenchmarkModel(
+                name=name,
+            )
+        )
+
+        benchmark = RapidataBenchmark(name, benchmark_result.id, self.__openapi_service)
+        for identifier, prompt in zip(identifiers, prompts):
+            benchmark.add_prompt(identifier, prompt)
+
+        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
+        )
+        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")]
+            )
+        )
+        return [RapidataBenchmark(benchmark.name, benchmark.id, self.__openapi_service) for benchmark in benchmark_result.items]

rapidata/rapidata_client/filter/not_filter.py

@@ -1,7 +1,7 @@
 from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.not_user_filter_model import NotUserFilterModel
-from rapidata.api_client.models.create_order_model_user_filters_inner import CreateOrderModelUserFiltersInner
+from rapidata.api_client.models.and_user_filter_model_filters_inner import AndUserFilterModelFiltersInner
 
 
 class NotFilter(RapidataFilter):
@@ -27,4 +27,4 @@ class NotFilter(RapidataFilter):
         self.filter = filter
 
     def _to_model(self):
-        return NotUserFilterModel(_t="NotFilter", filter=CreateOrderModelUserFiltersInner(self.filter._to_model()))
+        return NotUserFilterModel(_t="NotFilter", filter=AndUserFilterModelFiltersInner(self.filter._to_model()))

rapidata/rapidata_client/filter/or_filter.py

@@ -1,7 +1,7 @@
 from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.or_user_filter_model import OrUserFilterModel
-from rapidata.api_client.models.create_order_model_user_filters_inner import CreateOrderModelUserFiltersInner
+from rapidata.api_client.models.and_user_filter_model_filters_inner import AndUserFilterModelFiltersInner
 
 
 class OrFilter(RapidataFilter):
@@ -27,4 +27,4 @@ class OrFilter(RapidataFilter):
         self.filters = filters
 
     def _to_model(self):
-        return OrUserFilterModel(_t="OrFilter", filters=[CreateOrderModelUserFiltersInner(filter._to_model()) for filter in self.filters])
+        return OrUserFilterModel(_t="OrFilter", filters=[AndUserFilterModelFiltersInner(filter._to_model()) for filter in self.filters])

rapidata/rapidata_client/metadata/__init__.py

@@ -4,3 +4,4 @@ from ._public_text_metadata import PublicTextMetadata
 from ._prompt_metadata import PromptMetadata
 from ._select_words_metadata import SelectWordsMetadata
 from ._media_asset_metadata import MediaAssetMetadata
+from ._prompt_identifier_metadata import PromptIdentifierMetadata

rapidata/rapidata_client/metadata/_media_asset_metadata.py

@@ -1,6 +1,7 @@
 from rapidata.api_client.models.prompt_asset_metadata_input import PromptAssetMetadataInput
 from rapidata.api_client.models.url_asset_input import UrlAssetInput
 from rapidata.rapidata_client.metadata._base_metadata import Metadata
+from rapidata.api_client.models.prompt_asset_metadata_input_asset import PromptAssetMetadataInputAsset
 
 
 class MediaAssetMetadata(Metadata):
@@ -11,5 +12,11 @@ class MediaAssetMetadata(Metadata):
 
     def to_model(self):
         return PromptAssetMetadataInput(
-            _t="PromptAssetMetadataInput", asset=UrlAssetInput(_t="UrlAssetInput", url=self._url)
+            _t="PromptAssetMetadataInput", 
+            asset=PromptAssetMetadataInputAsset(
+                actual_instance=UrlAssetInput(
+                    _t="UrlAssetInput", 
+                    url=self._url
+                )
+            )
         )

rapidata/rapidata_client/metadata/_prompt_identifier_metadata.py

@@ -0,0 +1,15 @@
+from rapidata.rapidata_client.metadata._base_metadata import Metadata
+from rapidata.api_client.models.private_text_metadata_input import (
+    PrivateTextMetadataInput,
+)
+
+
+class PromptIdentifierMetadata(Metadata):
+    def __init__(self, identifier: str):
+        super().__init__()
+        self._identifier = identifier
+
+    def to_model(self):
+        return PrivateTextMetadataInput(
+            _t="PrivateTextMetadataInput", identifier="prompt-id", text=self._identifier
+        )

rapidata/rapidata_client/order/_rapidata_dataset.py

@@ -22,7 +22,7 @@ def chunk_list(lst: list, chunk_size: int) -> Generator:
 class RapidataDataset:
 
     def __init__(self, dataset_id: str, openapi_service: OpenAPIService):
-        self.dataset_id = dataset_id
+        self.id = dataset_id
         self.openapi_service = openapi_service
         self.local_file_service = LocalFileService()
 
@@ -96,7 +96,7 @@ class RapidataDataset:
                 metadata=metadata,
             )
 
-            self.openapi_service.dataset_api.dataset_dataset_id_datapoints_texts_post(dataset_id=self.dataset_id, create_datapoint_from_text_sources_model=model)
+            self.openapi_service.dataset_api.dataset_dataset_id_datapoints_texts_post(dataset_id=self.id, create_datapoint_from_text_sources_model=model)
 
         total_uploads = len(text_assets)
         with ThreadPoolExecutor(max_workers=max_workers) as executor:
@@ -161,7 +161,7 @@ class RapidataDataset:
         for attempt in range(max_retries):
             try:
                 self.openapi_service.dataset_api.dataset_dataset_id_datapoints_post(
-                    dataset_id=self.dataset_id,
+                    dataset_id=self.id,
                     file=local_paths,
                     url=urls,
                     metadata=metadata,
@@ -222,7 +222,7 @@ class RapidataDataset:
                     
                     while not stop_event.is_set() or not all_uploads_complete.is_set():
                         try:
-                            current_progress = self.openapi_service.dataset_api.dataset_dataset_id_progress_get(self.dataset_id)
+                            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
@@ -365,7 +365,7 @@ class RapidataDataset:
         """
         try:            
             # Get final progress
-            final_progress = self.openapi_service.dataset_api.dataset_dataset_id_progress_get(self.dataset_id)
+            final_progress = self.openapi_service.dataset_api.dataset_dataset_id_progress_get(self.id)
             total_ready = final_progress.ready
             total_failed = final_progress.failed
             
@@ -373,7 +373,7 @@ class RapidataDataset:
             if total_ready + total_failed < total_uploads:
                 # Try one more time after a longer wait
                 time.sleep(5 * progress_poll_interval)
-                final_progress = self.openapi_service.dataset_api.dataset_dataset_id_progress_get(self.dataset_id)
+                final_progress = self.openapi_service.dataset_api.dataset_dataset_id_progress_get(self.id)
                 total_ready = final_progress.ready
                 total_failed = final_progress.failed
             

rapidata/rapidata_client/order/_rapidata_order_builder.py

@@ -5,8 +5,8 @@ from rapidata.api_client.models.create_order_model import CreateOrderModel
 from rapidata.api_client.models.create_order_model_referee import (
     CreateOrderModelReferee,
 )
-from rapidata.api_client.models.create_order_model_user_filters_inner import (
-    CreateOrderModelUserFiltersInner,
+from rapidata.api_client.models.and_user_filter_model_filters_inner import (
+    AndUserFilterModelFiltersInner,
 )
 from rapidata.api_client.models.create_order_model_workflow import (
     CreateOrderModelWorkflow,
@@ -83,7 +83,7 @@ class RapidataOrderBuilder:
             orderName=self._name,
             workflow=CreateOrderModelWorkflow(self.__workflow._to_model()),
             userFilters=[
-                CreateOrderModelUserFiltersInner(user_filter._to_model())
+                AndUserFilterModelFiltersInner(user_filter._to_model())
                 for user_filter in self.__user_filters
             ],
             referee=CreateOrderModelReferee(self.__referee._to_model()),
@@ -136,7 +136,7 @@ class RapidataOrderBuilder:
             else None
         )
         if self.__dataset:
-            logger.debug(f"Dataset created with ID: {self.__dataset.dataset_id}")
+            logger.debug(f"Dataset created with ID: {self.__dataset.id}")
         else:
             logger.warning("No dataset created for this order.")
 

rapidata/rapidata_client/order/rapidata_order.py

@@ -80,7 +80,7 @@ class RapidataOrder:
     def unpause(self) -> None:
         """Unpauses/resumes the order."""
         logger.info(f"Unpausing order '{self}'")
-        self.__openapi_service.order_api.order_resume_post(self.id)
+        self.__openapi_service.order_api.order_order_id_resume_post(self.id)
         logger.debug(f"Order '{self}' has been unpaused.")
         managed_print(f"Order '{self}' has been unpaused.")
 

rapidata/rapidata_client/rapidata_client.py

@@ -5,7 +5,7 @@ from rapidata import __version__
 from rapidata.service.openapi_service import OpenAPIService
 
 from rapidata.rapidata_client.order.rapidata_order_manager import RapidataOrderManager
-from rapidata.rapidata_client.leaderboard.rapidata_leaderboard_manager import RapidataLeaderboardManager
+from rapidata.rapidata_client.benchmark.rapidata_benchmark_manager import RapidataBenchmarkManager
 
 from rapidata.rapidata_client.validation.validation_set_manager import (
     ValidationSetManager,
@@ -67,8 +67,8 @@ class RapidataClient:
         logger.debug("Initializing DemographicManager")
         self._demographic = DemographicManager(openapi_service=self._openapi_service)
 
-        logger.debug("Initializing RapidataLeaderboardManager")
-        self.mri = RapidataLeaderboardManager(openapi_service=self._openapi_service)
+        logger.debug("Initializing RapidataBenchmarkManager")
+        self.mri = RapidataBenchmarkManager(openapi_service=self._openapi_service)
         
     def reset_credentials(self):
         """Reset the credentials saved in the configuration file for the current environment."""

rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -37,7 +37,7 @@ class RapidataValidationSet:
             dimensions (list[str]): The new dimensions of the validation set.
         """
         logger.debug(f"Updating dimensions for validation set {self.id} to {dimensions}")
-        self.__openapi_service.validation_api.validation_validation_set_id_dimensions_patch(self.id, UpdateDimensionsModel(dimensions=dimensions))
+        self.__openapi_service.validation_api.validation_set_validation_set_id_dimensions_put(self.id, UpdateDimensionsModel(dimensions=dimensions))
         return self
 
     def __str__(self):

rapidata/rapidata_client/validation/rapids/rapids.py

@@ -35,11 +35,11 @@ class Rapid():
         if isinstance(self.asset, TextAsset) or (isinstance(self.asset, MultiAsset) and isinstance(self.asset.assets[0], TextAsset)):
             openapi_service.validation_api.validation_set_validation_set_id_rapid_texts_post(
                 validation_set_id=validationSetId,
-                add_validation_text_rapid_model=self.__to_text_model(validationSetId)
+                add_validation_text_rapid_model=self.__to_text_model()
             )
 
         elif isinstance(self.asset, MediaAsset) or (isinstance(self.asset, MultiAsset) and isinstance(self.asset.assets[0], MediaAsset)):
-            model = self.__to_media_model(validationSetId)
+            model = self.__to_media_model()
             openapi_service.validation_api.validation_set_validation_set_id_rapid_files_post(
                 validation_set_id=validationSetId,
                 model=model[0], files=model[1]
@@ -48,7 +48,7 @@ class Rapid():
         else:
             raise TypeError("The asset must be a MediaAsset, TextAsset, or MultiAsset")
 
-    def __to_media_model(self, validationSetId: str) -> tuple[AddValidationRapidModel, list[StrictStr | tuple[StrictStr, StrictBytes] | StrictBytes]]:
+    def __to_media_model(self) -> tuple[AddValidationRapidModel, list[StrictStr | tuple[StrictStr, StrictBytes] | StrictBytes]]:
         assets: list[MediaAsset] = [] 
         if isinstance(self.asset, MultiAsset):
             for asset in self.asset.assets:
@@ -64,7 +64,6 @@ class Rapid():
             assets = [self.asset]
 
         return (AddValidationRapidModel(
-            validationSetId=validationSetId, # will be removed in the future
             payload=AddValidationRapidModelPayload(self.payload),
             truth=AddValidationRapidModelTruth(self.truth),
             metadata=[
@@ -75,7 +74,7 @@ class Rapid():
             explanation=self.explanation
         ), [asset.to_file() for asset in assets])
 
-    def __to_text_model(self, validationSetId: str) -> AddValidationTextRapidModel:
+    def __to_text_model(self) -> AddValidationTextRapidModel:
         texts: list[str] = []
         if isinstance(self.asset, MultiAsset):
             for asset in self.asset.assets:
@@ -91,7 +90,6 @@ class Rapid():
             texts = [self.asset.text]
 
         return AddValidationTextRapidModel(
-          validationSetId=validationSetId, # will be removed in the future
           payload=AddValidationRapidModelPayload(self.payload),
           truth=AddValidationRapidModelTruth(self.truth),
           metadata=[

rapidata/service/openapi_service.py

@@ -3,6 +3,7 @@ from importlib.metadata import version, PackageNotFoundError
 
 from rapidata.api_client.api.campaign_api import CampaignApi
 from rapidata.api_client.api.dataset_api import DatasetApi
+from rapidata.api_client.api.benchmark_api import BenchmarkApi
 from rapidata.api_client.api.order_api import OrderApi
 from rapidata.api_client.api.pipeline_api import PipelineApi
 from rapidata.api_client.api.rapid_api import RapidApi
@@ -112,6 +113,10 @@ class OpenAPIService:
     @property
     def leaderboard_api(self) -> LeaderboardApi:
         return LeaderboardApi(self.api_client)
+    
+    @property
+    def benchmark_api(self) -> BenchmarkApi:
+        return BenchmarkApi(self.api_client)
 
     def _get_rapidata_package_version(self):
         """

{rapidata-2.28.4.dist-info → rapidata-2.29.0.dist-info}/METADATA

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