rapidata 2.8.0__tar.gz → 2.9.0__tar.gz

{rapidata-2.8.0 → rapidata-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.8.0
+Version: 2.9.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
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: colorama (==0.4.6)
 Requires-Dist: deprecated (>=1.2.14,<2.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pillow (>=10.4.0,<11.0.0)
 Requires-Dist: pydantic (>=2.8.2,<3.0.0)
 Requires-Dist: pyjwt (>=2.9.0,<3.0.0)

{rapidata-2.8.0 → rapidata-2.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapidata"
-version = "2.8.0"
+version = "2.9.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"
@@ -18,6 +18,7 @@ tqdm = "^4.66.5"
 deprecated = "^1.2.14"
 colorama = "0.4.6"
 tinytag = "^2.0.0"
+pandas = "^2.2.3"
 
 [tool.poetry.group.dev.dependencies]
 python-dotenv = "^1.0.1"

{rapidata-2.8.0 → rapidata-2.9.0}/src/rapidata/rapidata_client/order/rapidata_order.py

@@ -8,6 +8,7 @@ from typing import Optional, cast, Any
 from rapidata.api_client.models.workflow_artifact_model import WorkflowArtifactModel
 from rapidata.api_client.models.preliminary_download_model import PreliminaryDownloadModel
 from tqdm import tqdm
+from rapidata.rapidata_client.order.rapidata_results import RapidataResults
 
 class RapidataOrder:
     """
@@ -154,13 +155,13 @@ class RapidataOrder:
         
         return progress
     
-    def __get_preliminary_results(self) -> dict[str, Any]:
+    def __get_preliminary_results(self) -> RapidataResults:
         pipeline_id = self.__get_pipeline_id()
         try: 
             download_id = self.__openapi_service.pipeline_api.pipeline_pipeline_id_preliminary_download_post(pipeline_id, PreliminaryDownloadModel(sendEmail=False)).download_id
             while not (preliminary_results := self.__openapi_service.pipeline_api.pipeline_preliminary_download_preliminary_download_id_get(preliminary_download_id=download_id)):
                 sleep(1)
-            return json.loads(preliminary_results.decode())
+            return RapidataResults(json.loads(preliminary_results.decode()))
         
         except ApiException as e:
             # Handle API exceptions
@@ -169,7 +170,7 @@ class RapidataOrder:
             # Handle JSON parsing errors
             raise Exception(f"Failed to parse preliminary order results: {str(e)}") from e
 
-    def get_results(self, preliminary_results=False) -> dict[str, Any]:
+    def get_results(self, preliminary_results: bool=False) -> RapidataResults:
         """
         Gets the results of the order. 
         If the order is still processing, this method will block until the order is completed and then return the results.
@@ -194,7 +195,7 @@ class RapidataOrder:
 
         try:
             # Get the raw result string
-            return self.__openapi_service.order_api.order_get_order_results_get(id=self.order_id) # type: ignore
+            return RapidataResults(self.__openapi_service.order_api.order_get_order_results_get(id=self.order_id)) # type: ignore
         
         except ApiException as e:
             # Handle API exceptions

rapidata-2.9.0/src/rapidata/rapidata_client/order/rapidata_results.py

@@ -0,0 +1,143 @@
+import pandas as pd
+from typing import Any
+from pandas.core.indexes.base import Index
+import json
+
+class RapidataResults(dict):
+    """
+    A specialized dictionary class for handling Rapidata API results.
+    Extends the built-in dict class with specialized methods.
+    """
+    def to_pandas(self) -> pd.DataFrame:
+        """
+        Converts the results to a pandas DataFrame.
+        
+        For Compare results, creates standardized A/B columns for metrics like:
+        - aggregatedResults
+        - aggregatedResultsRatios
+        - summedUserScores
+        - summedUserScoresRatios
+        
+        For regular results, flattens nested dictionaries into columns with underscore-separated names.
+        
+        Returns:
+            pd.DataFrame: A DataFrame containing the processed results
+        """
+        if "results" not in self or not self["results"]:
+            return pd.DataFrame()
+        
+        if self["info"].get("orderType") == "Compare":
+            return self._compare_to_pandas()
+        
+        if self["info"].get("orderType") is None:
+            print("Warning: Results are old and Order type is not specified. Dataframe might be wrong.")
+
+        # Get the structure from first item
+        first_item = self["results"][0]
+        columns = []
+        path_map = {}  # Maps flattened column names to paths to reach the values
+        
+        # Build the column structure once
+        self._build_column_structure(first_item, columns, path_map)
+        
+        # Extract data using the known structure
+        data = []
+        for item in self["results"]:
+            row = []
+            for path in path_map.values():
+                value = self._get_value_from_path(item, path)
+                row.append(value)
+            data.append(row)
+            
+        return pd.DataFrame(data, columns=Index(columns))
+    
+    def _build_column_structure(
+        self, 
+        d: dict[str, Any], 
+        columns: list[str], 
+        path_map: dict[str, list[str]], 
+        parent_key: str = '', 
+        current_path: list[str] | None = None
+    ) -> None:
+        """
+        Builds the column structure and paths to reach values in nested dictionaries.
+        
+        Args:
+            d: The dictionary to analyze
+            columns: List to store column names
+            path_map: Dictionary mapping column names to paths for accessing values
+            parent_key: The parent key for nested dictionaries
+            current_path: The current path in the dictionary structure
+        """
+        if current_path is None:
+            current_path = []
+            
+        for key, value in d.items():
+            new_key = f"{parent_key}_{key}" if parent_key else key
+            new_path: list[str] = current_path + [key]
+            
+            if isinstance(value, dict):
+                self._build_column_structure(value, columns, path_map, new_key, new_path)
+            else:
+                columns.append(new_key)
+                path_map[new_key] = new_path
+    
+    def _get_value_from_path(self, d: dict[str, Any], path: list[str]) -> Any:
+        """
+        Retrieves a value from a nested dictionary using a path list.
+        
+        Args:
+            d: The dictionary to retrieve the value from
+            path: List of keys forming the path to the desired value
+            
+        Returns:
+            The value at the specified path, or None if the path doesn't exist
+        """
+        for key in path[:-1]:
+            d = d.get(key, {})
+        return d.get(path[-1])
+
+    def _compare_to_pandas(self):
+        """
+        Converts Compare results to a pandas DataFrame dynamically.
+        """
+        if not self.get("results"):
+            return pd.DataFrame()
+
+        rows = []
+        for result in self["results"]:
+            # Get the image names from the first metric we find
+            for key in result:
+                if isinstance(result[key], dict) and len(result[key]) == 2:
+                    assets = list(result[key].keys())
+                    break
+            else:
+                continue
+
+            asset_a, asset_b = assets[0], assets[1]
+            
+            # Initialize row with non-comparative fields
+            row = {
+                key: value for key, value in result.items() 
+                if not isinstance(value, dict)
+            }
+            
+            # Handle comparative metrics
+            for key, values in result.items():
+                if isinstance(values, dict) and len(values) == 2:
+                    row[f'A_{key}'] = values[asset_a]
+                    row[f'B_{key}'] = values[asset_b]
+                    
+            rows.append(row)
+            
+        return pd.DataFrame(rows)
+
+    def to_json(self, path: str="./results.json"):
+        """
+        Saves the results to a JSON file.
+        
+        Args:
+            path: The file path where the JSON should be saved. Defaults to "./results.json".
+        """
+        with open(path, 'w') as f:
+            json.dump(self, f)

{rapidata-2.8.0 → rapidata-2.9.0}/src/rapidata/rapidata_client/validation/validation_set_manager.py

@@ -47,7 +47,7 @@ class ValidationSetManager:
             instruction (str): The instruction by which the labeler will answer.
             answer_options (list[str]): The options to choose from when answering.
             datapoints (list[str]): The datapoints that will be used for validation.
-            truths (list[list[str]]): The truths for each datapoint. Outher list is for each datapoint, inner list is for each truth.\n
+            truths (list[list[str]]): The truths for each datapoint. Outer list is for each datapoint, inner list is for each truth.\n
                 example:
                     options: ["yes", "no", "maybe"]
                     datapoints: ["datapoint1", "datapoint2"]
@@ -161,7 +161,7 @@ class ValidationSetManager:
         Args:
             name (str): The name of the validation set. (will not be shown to the labeler)
             instruction (str): The instruction to show to the labeler.
-            truths (list[list[int]]): The truths for each datapoint. Outher list is for each datapoint, inner list is for each truth.\n
+            truths (list[list[int]]): The truths for each datapoint. Outer list is for each datapoint, inner list is for each truth.\n
                 example:
                     datapoints: ["datapoint1", "datapoint2"]
                     sentences: ["this example 1", "this example 2"]
@@ -214,7 +214,7 @@ class ValidationSetManager:
         Args:
             name (str): The name of the validation set. (will not be shown to the labeler)
             instruction (str): The instruction to show to the labeler.
-            truths (list[list[Box]]): The truths for each datapoint. Outher list is for each datapoint, inner list is for each truth.\n
+            truths (list[list[Box]]): The truths for each datapoint. Outer list is for each datapoint, inner list is for each truth.\n
                 example:
                     datapoints: ["datapoint1", "datapoint2"]
                     truths: [[Box(0, 0, 100, 100)], [Box(50, 50, 150, 150)]] -> first datapoint the object is in the top left corner, second datapoint the object is in the center
@@ -266,7 +266,7 @@ class ValidationSetManager:
         Args:
             name (str): The name of the validation set. (will not be shown to the labeler)
             instruction (str): The instruction to show to the labeler.
-            truths (list[list[Box]]): The truths for each datapoint. Outher list is for each datapoint, inner list is for each truth.\n
+            truths (list[list[Box]]): The truths for each datapoint. Outer list is for each datapoint, inner list is for each truth.\n
                 example:
                     datapoints: ["datapoint1", "datapoint2"]
                     truths: [[Box(0, 0, 100, 100)], [Box(50, 50, 150, 150)]] -> first datapoint the object is in the top left corner, second datapoint the object is in the center
@@ -318,7 +318,7 @@ class ValidationSetManager:
             name (str): The name of the validation set. (will not be shown to the labeler)
             instruction (str): The instruction to show to the labeler.
             truths (list[list[tuple[int, int]]]): The truths for each datapoint defined as start and endpoint based on miliseconds. 
-            Outher list is for each datapoint, inner list is for each truth.\n
+                Outer list is for each datapoint, inner list is for each truth.\n
                 example:
                     datapoints: ["datapoint1", "datapoint2"]
                     truths: [[(0, 10)], [(20, 30)]] -> first datapoint the correct interval is from 0 to 10, second datapoint the correct interval is from 20 to 30
@@ -396,9 +396,6 @@ class ValidationSetManager:
         if validation_set_id is None:
             raise ValueError("Failed to create validation set")
 
-        if print_confirmation:
-            print(f"Validation set '{name}' created with ID {validation_set_id}")
-
         validation_set = RapidataValidationSet(
             name=name,
             validation_set_id=validation_set_id,
@@ -408,6 +405,12 @@ class ValidationSetManager:
         for rapid in tqdm(rapids, desc="Uploading validation tasks"):
             validation_set.add_rapid(rapid)
         
+        if print_confirmation:
+            print()
+            print(f"Validation set '{name}' created with ID {validation_set_id}\n",
+                  f"Now viewable under: https://app.{self.__openapi_service.enviroment}/validation-set/detail/{validation_set_id}",
+                  sep="")
+            
         return validation_set