rapidata 2.42.6__tar.gz → 2.43.0__tar.gz

{rapidata-2.42.6 → rapidata-2.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapidata
-Version: 2.42.6
+Version: 2.43.0
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 License-File: LICENSE

{rapidata-2.42.6 → rapidata-2.43.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapidata"
-version = "2.42.6"
+version = "2.43.0"
 description = "Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way."
 authors = ["Rapidata AG <info@rapidata.ai>"]
 license = "Apache-2.0"

{rapidata-2.42.6 → rapidata-2.43.0}/src/rapidata/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.42.6"
+__version__ = "2.43.0"
 
 from .rapidata_client import (
     RapidataClient,
@@ -17,6 +17,7 @@ from .rapidata_client import (
     FreeTextMinimumCharacters,
     NoShuffle,
     PlayVideoUntilTheEnd,
+    MuteVideo,
     CustomSetting,
     AllowNeitherBoth,
     SwapContextInstruction,

{rapidata-2.42.6 → rapidata-2.43.0}/src/rapidata/rapidata_client/__init__.py

@@ -27,6 +27,7 @@ from .settings import (
     CustomSetting,
     AllowNeitherBoth,
     SwapContextInstruction,
+    MuteVideo,
 )
 from .filter import (
     CountryFilter,

{rapidata-2.42.6 → rapidata-2.43.0}/src/rapidata/rapidata_client/benchmark/rapidata_benchmark.py

@@ -1,4 +1,4 @@
-import re
+import pandas as pd
 import urllib.parse
 import webbrowser
 from colorama import Fore
@@ -479,6 +479,33 @@ class RapidataBenchmark:
                 + Fore.RESET
             )
 
+    def get_overall_standings(self, tags: Optional[list[str]] = None) -> pd.DataFrame:
+        """
+        Returns an aggregated elo table of all leaderboards in the benchmark.
+        """
+        with tracer.start_as_current_span("get_overall_standings"):
+            participants = self._openapi_service.benchmark_api.benchmark_benchmark_id_standings_get(
+                benchmark_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
+                        ),
+                    }
+                )
+
+            return pd.DataFrame(standings)
+
     def __str__(self) -> str:
         return f"RapidataBenchmark(name={self.name}, id={self.id})"
 

{rapidata-2.42.6 → rapidata-2.43.0}/src/rapidata/rapidata_client/datapoints/_datapoint.py

@@ -19,6 +19,7 @@ class Datapoint(BaseModel):
     media_context: str | None = None
     sentence: str | None = None
     private_note: str | None = None
+    group: str | None = None
 
     @field_validator("context")
     @classmethod

{rapidata-2.42.6 → rapidata-2.43.0}/src/rapidata/rapidata_client/datapoints/_datapoint_uploader.py

@@ -45,6 +45,7 @@ class DatapointUploader:
                 asset=uploaded_asset,
                 metadata=metadata,
                 sortIndex=index,
+                group=datapoint.group,
             ),
         )
 

rapidata-2.43.0/src/rapidata/rapidata_client/datapoints/_datapoints_validator.py

@@ -0,0 +1,70 @@
+from itertools import zip_longest
+from typing import Literal, cast, Iterable
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+
+
+class DatapointsValidator:
+    @staticmethod
+    def validate_datapoints(
+        datapoints: list[str] | list[list[str]],
+        contexts: list[str] | None = None,
+        media_contexts: list[str] | None = None,
+        sentences: list[str] | None = None,
+        private_notes: list[str] | None = None,
+        groups: list[str] | None = None,
+    ) -> None:
+        if contexts and len(contexts) != len(datapoints):
+            raise ValueError("Number of contexts must match number of datapoints")
+        if media_contexts and len(media_contexts) != len(datapoints):
+            raise ValueError("Number of media contexts must match number of datapoints")
+        if sentences and len(sentences) != len(datapoints):
+            raise ValueError("Number of sentences must match number of datapoints")
+        if private_notes and len(private_notes) != len(datapoints):
+            raise ValueError("Number of private notes must match number of datapoints")
+        if groups and (
+            len(groups) != len(datapoints) or len(groups) != len(set(groups))
+        ):
+            raise ValueError(
+                "Number of groups must match number of datapoints and must be unique."
+            )
+
+    @staticmethod
+    def map_datapoints(
+        datapoints: list[str] | list[list[str]],
+        contexts: list[str] | None = None,
+        media_contexts: list[str] | None = None,
+        sentences: list[str] | None = None,
+        private_notes: list[str] | None = None,
+        groups: list[str] | None = None,
+        data_type: Literal["text", "media"] = "media",
+    ) -> list[Datapoint]:
+        DatapointsValidator.validate_datapoints(
+            datapoints=datapoints,
+            contexts=contexts,
+            media_contexts=media_contexts,
+            sentences=sentences,
+            private_notes=private_notes,
+            groups=groups,
+        )
+        return [
+            Datapoint(
+                asset=asset,
+                data_type=data_type,
+                context=context,
+                media_context=media_context,
+                sentence=sentence,
+                private_note=private_note,
+                group=group,
+            )
+            for asset, context, media_context, sentence, private_note, group in cast(
+                "Iterable[tuple[str | list[str], str | None, str | None, str | None, str | None, str | None]]",  # because iterator only supports 5 arguments with specific type casting
+                zip_longest(
+                    datapoints,
+                    contexts or [],
+                    media_contexts or [],
+                    sentences or [],
+                    private_notes or [],
+                    groups or [],
+                ),
+            )
+        ]

{rapidata-2.42.6 → rapidata-2.43.0}/src/rapidata/rapidata_client/filter/user_score_filter.py

@@ -23,12 +23,15 @@ class UserScoreFilter(RapidataFilter, BaseModel):
         This will only show the order to users that have a UserScore of >=0.5 and <=0.9
     """
 
-    lower_bound: float = 0.0
-    upper_bound: float = 1.0
+    lower_bound: float
+    upper_bound: float
     dimension: str | None = None
 
     def __init__(
-        self, lower_bound: float, upper_bound: float, dimension: str | None = None
+        self,
+        lower_bound: float = 0.0,
+        upper_bound: float = 1.0,
+        dimension: str | None = None,
     ):
         super().__init__(
             lower_bound=lower_bound, upper_bound=upper_bound, dimension=dimension

{rapidata-2.42.6 → rapidata-2.43.0}/src/rapidata/rapidata_client/order/_rapidata_order_builder.py

@@ -37,7 +37,11 @@ from rapidata.rapidata_client.referee import Referee
 from rapidata.rapidata_client.referee._naive_referee import NaiveReferee
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 from rapidata.rapidata_client.settings import RapidataSetting
-from rapidata.rapidata_client.workflow import Workflow, FreeTextWorkflow
+from rapidata.rapidata_client.workflow import (
+    Workflow,
+    FreeTextWorkflow,
+    MultiRankingWorkflow,
+)
 from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.api.rapidata_api_client import (
     suppress_rapidata_error_logging,
@@ -63,7 +67,7 @@ class RapidataOrderBuilder:
     ):
         self._name = name
         self.order_id: str | None = None
-        self.__openapi_service = openapi_service
+        self._openapi_service = openapi_service
         self.__dataset: Optional[RapidataDataset] = None
         self.__workflow: Workflow | None = None
         self.__referee: Referee | None = None
@@ -75,7 +79,7 @@ class RapidataOrderBuilder:
         self.__datapoints: list[Datapoint] = []
         self.__sticky_state_value: StickyStateLiteral | None = None
         self.__validation_set_manager: ValidationSetManager = ValidationSetManager(
-            self.__openapi_service
+            self._openapi_service
         )
 
     def _to_model(self) -> CreateOrderModel:
@@ -144,7 +148,7 @@ class RapidataOrderBuilder:
             with suppress_rapidata_error_logging():
                 self.__validation_set_id = (
                     (
-                        self.__openapi_service.validation_api.validation_set_recommended_get(
+                        self._openapi_service.validation_api.validation_set_recommended_get(
                             asset_type=[self.__datapoints[0].get_asset_type()],
                             modality=[self.__workflow.modality],
                             instruction=self.__workflow._get_instruction(),
@@ -205,7 +209,9 @@ class RapidataOrderBuilder:
         """
         if (
             rapidata_config.order.autoValidationSetCreation
-            and not isinstance(self.__workflow, FreeTextWorkflow)
+            and not isinstance(
+                self.__workflow, (FreeTextWorkflow, MultiRankingWorkflow)
+            )
             and not self.__selections
         ):
             new_validation_set = self._set_validation_set_id()
@@ -215,7 +221,7 @@ class RapidataOrderBuilder:
         order_model = self._to_model()
         logger.debug("Creating order with model: %s", order_model)
 
-        result = self.__openapi_service.order_api.order_post(
+        result = self._openapi_service.order_api.order_post(
             create_order_model=order_model
         )
 
@@ -230,7 +236,7 @@ class RapidataOrderBuilder:
                 + f"A new validation set was created. Please annotate {required_amount} datapoint{('s' if required_amount != 1 else '')} so the order runs correctly."
                 + Fore.RESET
             )
-            link = f"https://app.{self.__openapi_service.environment}/validation-set/detail/{self.__validation_set_id}/annotate?orderId={self.order_id}&required={required_amount}"
+            link = f"https://app.{self._openapi_service.environment}/validation-set/detail/{self.__validation_set_id}/annotate?orderId={self.order_id}&required={required_amount}"
             could_open_browser = webbrowser.open(link)
             if not could_open_browser:
                 encoded_url = urllib.parse.quote(link, safe="%/:=&?~#+!$,;'@()*[]")
@@ -245,7 +251,7 @@ class RapidataOrderBuilder:
             managed_print()
 
         self.__dataset = (
-            RapidataDataset(result.dataset_id, self.__openapi_service)
+            RapidataDataset(result.dataset_id, self._openapi_service)
             if result.dataset_id
             else None
         )
@@ -256,7 +262,7 @@ class RapidataOrderBuilder:
 
         order = RapidataOrder(
             order_id=self.order_id,
-            openapi_service=self.__openapi_service,
+            openapi_service=self._openapi_service,
             name=self._name,
         )
 
@@ -278,7 +284,7 @@ class RapidataOrderBuilder:
         logger.debug("Datapoints added to the order.")
         logger.debug("Setting order to preview")
         try:
-            self.__openapi_service.order_api.order_order_id_preview_post(self.order_id)
+            self._openapi_service.order_api.order_order_id_preview_post(self.order_id)
         except Exception:
             raise FailedUploadException(self.__dataset, order, failed_uploads)
         return order