rapidata 2.36.2__py3-none-any.whl → 2.38.0__py3-none-any.whl

rapidata/rapidata_client/order/rapidata_results.py

@@ -2,56 +2,63 @@ import pandas as pd
 from typing import Any
 from pandas.core.indexes.base import Index
 import json
-from rapidata.rapidata_client.logging import managed_print
+from rapidata.rapidata_client.config import managed_print
+
 
 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, split_details: bool = False) -> pd.DataFrame:
         """
         Warning:
             This method is currently under development. The structure of the results may change in the future.
 
         Converts the results to a pandas DataFrame.
-        
+
         For Compare results, creates standardized A/B columns for metrics.
         For regular results, flattens nested dictionaries into columns with underscore-separated names.
-        
+
         Args:
             split_details: If True, splits each datapoint by its detailed results,
                           creating a row for each response with global metrics copied.
-                          
+
         Returns:
             pd.DataFrame: A DataFrame containing the processed results
-            
+
         Raises:
             ValueError: If split_details is True but no detailed results are found
         """
         if "results" not in self or not self["results"]:
             return pd.DataFrame()
-        
+
         if self["info"].get("orderType") is None:
-            managed_print("Warning: Results are old and Order type is not specified. Dataframe might be wrong.")
-        
+            managed_print(
+                "Warning: Results are old and Order type is not specified. Dataframe might be wrong."
+            )
+
         # Check for detailed results if split_details is True
         if split_details:
             if not self._has_detailed_results():
                 raise ValueError("No detailed results found in the data")
             return self._to_pandas_with_detailed_results()
-            
-        if self["info"].get("orderType") == "Compare" or self["info"].get("orderType") == "Ranking":
+
+        if (
+            self["info"].get("orderType") == "Compare"
+            or self["info"].get("orderType") == "Ranking"
+        ):
             return self._compare_to_pandas()
-        
+
         # 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"]:
@@ -60,82 +67,84 @@ class RapidataResults(dict):
                 value = self._get_value_from_path(item, path)
                 row.append(value)
             data.append(row)
-            
+
         return pd.DataFrame(data, columns=Index(columns))
-    
+
     def _has_detailed_results(self) -> bool:
         """
         Checks if the results contain detailed results.
-        
+
         Returns:
             bool: True if detailed results exist, False otherwise
         """
         if not self.get("results"):
             return False
-        
+
         first_result = self["results"][0]
-        return "detailedResults" in first_result and isinstance(first_result["detailedResults"], list)
-    
+        return "detailedResults" in first_result and isinstance(
+            first_result["detailedResults"], list
+        )
+
     def _to_pandas_with_detailed_results(self) -> pd.DataFrame:
         """
         Converts results to a pandas DataFrame with detailed results split into separate rows.
-        
+
         Returns:
             pd.DataFrame: A DataFrame with one row per detailed result
         """
         rows = []
-        
+
         for result in self["results"]:
             # Get all non-detailed results fields
             base_data = {k: v for k, v in result.items() if k != "detailedResults"}
-            
+
             # Process each detailed result
             for detailed_result in result["detailedResults"]:
                 row = base_data.copy()  # Copy base data for each detailed result
-                
+
                 # Add flattened detailed result data
                 flattened = self._flatten_dict(detailed_result)
                 for key, value in flattened.items():
                     row[key] = value
-                
+
                 rows.append(row)
-        
+
         return pd.DataFrame(rows)
-    
-    def _flatten_dict(self, d: dict[str, Any], parent_key: str = '') -> dict[str, Any]:
+
+    def _flatten_dict(self, d: dict[str, Any], parent_key: str = "") -> dict[str, Any]:
         """
         Flattens a nested dictionary into a single-level dictionary with underscore-separated keys.
-        
+
         Args:
             d: The dictionary to flatten
             parent_key: The parent key for nested dictionaries
-            
+
         Returns:
             dict: A flattened dictionary
         """
         items: list[tuple[str, Any]] = []
-        
+
         for key, value in d.items():
             new_key = f"{parent_key}_{key}" if parent_key else key
-            
+
             if isinstance(value, dict):
                 items.extend(self._flatten_dict(value, new_key).items())
             else:
                 items.append((new_key, value))
-                
+
         return dict(items)
 
     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
+        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
@@ -145,25 +154,27 @@ class RapidataResults(dict):
         """
         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)
+                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
         """
@@ -190,10 +201,11 @@ class RapidataResults(dict):
                 continue
 
             assets = [asset for asset in assets if asset not in ["Both", "Neither"]]
-            
+
             # Initialize row with non-comparative fields
             row = {
-                key: value for key, value in result.items() 
+                key: value
+                for key, value in result.items()
                 if not isinstance(value, dict)
             }
             row["assetA"] = assets[0]
@@ -203,26 +215,28 @@ class RapidataResults(dict):
             for key, values in result.items():
                 if isinstance(values, dict) and len(values) >= 2:
                     # Add main asset columns
-                    for i, asset in enumerate(assets[:2]):  # Limit to first 2 main assets
+                    for i, asset in enumerate(
+                        assets[:2]
+                    ):  # Limit to first 2 main assets
                         column_prefix = "A_" if i == 0 else "B_"
-                        row[f'{column_prefix}{key}'] = values.get(asset, 0)
-                    
+                        row[f"{column_prefix}{key}"] = values.get(asset, 0)
+
                     # Add special option columns if they exist
                     if "Both" in values:
-                        row[f'Both_{key}'] = values.get("Both", 0)
+                        row[f"Both_{key}"] = values.get("Both", 0)
                     if "Neither" in values:
-                        row[f'Neither_{key}'] = values.get("Neither", 0)
-                        
+                        row[f"Neither_{key}"] = values.get("Neither", 0)
+
             rows.append(row)
-            
+
         return pd.DataFrame(rows)
 
-    def to_json(self, path: str="./results.json") -> None:
+    def to_json(self, path: str = "./results.json") -> None:
         """
         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:
+        with open(path, "w") as f:
             json.dump(self, f)

rapidata/rapidata_client/rapidata_client.py

@@ -15,8 +15,12 @@ from rapidata.rapidata_client.validation.validation_set_manager import (
 
 from rapidata.rapidata_client.demographic.demographic_manager import DemographicManager
 
-from rapidata.rapidata_client.logging import logger, managed_print
-from rapidata.rapidata_client.config.rapidata_config import rapidata_config
+from rapidata.rapidata_client.config import (
+    logger,
+    tracer,
+    managed_print,
+    rapidata_config,
+)
 
 
 class RapidataClient:
@@ -48,31 +52,36 @@ class RapidataClient:
             order (RapidataOrderManager): The RapidataOrderManager instance.
             validation (ValidationSetManager): The ValidationSetManager instance.
         """
-        logger.debug("Checking version")
-        self._check_version()
-
-        logger.debug("Initializing OpenAPIService")
-        self._openapi_service = OpenAPIService(
-            client_id=client_id,
-            client_secret=client_secret,
-            environment=environment,
-            oauth_scope=oauth_scope,
-            cert_path=cert_path,
-            token=token,
-            leeway=leeway,
-        )
+        with tracer.start_as_current_span("RapidataClient.__init__"):
+            logger.debug("Checking version")
+            self._check_version()
+
+            logger.debug("Initializing OpenAPIService")
+            self._openapi_service = OpenAPIService(
+                client_id=client_id,
+                client_secret=client_secret,
+                environment=environment,
+                oauth_scope=oauth_scope,
+                cert_path=cert_path,
+                token=token,
+                leeway=leeway,
+            )
 
-        logger.debug("Initializing RapidataOrderManager")
-        self.order = RapidataOrderManager(openapi_service=self._openapi_service)
+            logger.debug("Initializing RapidataOrderManager")
+            self.order = RapidataOrderManager(openapi_service=self._openapi_service)
 
-        logger.debug("Initializing ValidationSetManager")
-        self.validation = ValidationSetManager(openapi_service=self._openapi_service)
+            logger.debug("Initializing ValidationSetManager")
+            self.validation = ValidationSetManager(
+                openapi_service=self._openapi_service
+            )
 
-        logger.debug("Initializing DemographicManager")
-        self._demographic = DemographicManager(openapi_service=self._openapi_service)
+            logger.debug("Initializing DemographicManager")
+            self._demographic = DemographicManager(
+                openapi_service=self._openapi_service
+            )
 
-        logger.debug("Initializing RapidataBenchmarkManager")
-        self.mri = RapidataBenchmarkManager(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."""
@@ -97,5 +106,9 @@ class RapidataClient:
                         f"""A new version of the Rapidata SDK is available: {latest_version}
 Your current version is: {__version__}"""
                     )
+                else:
+                    logger.debug(
+                        "Current version is up to date. Version: %s", __version__
+                    )
         except Exception as e:
             logger.debug("Failed to check for updates: %s", e)

rapidata/rapidata_client/selection/_base_selection.py

@@ -7,3 +7,9 @@ class RapidataSelection:
     @abstractmethod
     def _to_model(self) -> Any:
         pass
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"

rapidata/rapidata_client/selection/static_selection.py

@@ -1,22 +1,17 @@
-
-from rapidata.api_client.models.static_selection import StaticSelection as StaticSelectionModel
+from rapidata.api_client.models.static_selection import (
+    StaticSelection as StaticSelectionModel,
+)
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 
+
 class StaticSelection(RapidataSelection):
     """StaticSelection Class
 
     Given a list of RapidIds, theses specific rapids will be shown in order for every session.
-    
+
     Args:
         rapid_ids (list[str]): List of rapid ids to show.
     """
 
     def __init__(self, rapid_ids: list[str]):
         self.rapid_ids = rapid_ids
-
-    def _to_model(self) -> StaticSelectionModel:
-        return StaticSelectionModel(
-            _t="StaticSelection",
-            rapidIds=self.rapid_ids
-        )
-    

rapidata/rapidata_client/settings/_rapidata_setting.py

@@ -2,10 +2,18 @@ from pydantic import BaseModel
 from typing import Any
 from rapidata.api_client.models.feature_flag_model import FeatureFlagModel
 
+
 class RapidataSetting(BaseModel):
     """Base class for all settings"""
+
     key: str
     value: Any
 
     def _to_feature_flag(self) -> FeatureFlagModel:
         return FeatureFlagModel(key=self.key, value=str(self.value))
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}(key='{self.key}', value={self.value})"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(key={self.key!r}, value={self.value!r})"

rapidata/rapidata_client/settings/alert_on_fast_response.py

@@ -1,22 +1,25 @@
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
-from rapidata.rapidata_client.logging import managed_print
+from rapidata.rapidata_client.config import managed_print
+
 
 class AlertOnFastResponse(RapidataSetting):
     """
     Gives an alert as a pop up on the UI when the response time is less than the milliseconds.
-    
+
     Args:
         threshold (int): if the user responds in less than this time, an alert will be shown.
     """
-    
+
     def __init__(self, threshold: int):
         if not isinstance(threshold, int):
             raise ValueError("The alert must be an integer.")
         if threshold < 10:
-            managed_print(f"Warning: Are you sure you want to set the threshold so low ({threshold} milliseconds)?")
+            managed_print(
+                f"Warning: Are you sure you want to set the threshold so low ({threshold} milliseconds)?"
+            )
         if threshold > 25000:
             raise ValueError("The alert must be less than 25000 milliseconds.")
         if threshold < 0:
             raise ValueError("The alert must be greater than or equal to 0.")
-    
+
         super().__init__(key="alert_on_fast_response", value=threshold)

rapidata/rapidata_client/settings/free_text_minimum_characters.py

@@ -1,17 +1,22 @@
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
-from rapidata.rapidata_client.logging import managed_print, logger
+from rapidata.rapidata_client.config import managed_print
+
 
 class FreeTextMinimumCharacters(RapidataSetting):
     """
     Set the minimum number of characters a user has to type.
-    
+
     Args:
         value (int): The minimum number of characters for free text.
     """
 
     def __init__(self, value: int):
         if value < 1:
-            raise ValueError("The minimum number of characters must be greater than or equal to 1.")
+            raise ValueError(
+                "The minimum number of characters must be greater than or equal to 1."
+            )
         if value > 40:
-            managed_print(f"Warning: Are you sure you want to set the minimum number of characters at {value}?")
+            managed_print(
+                f"Warning: Are you sure you want to set the minimum number of characters at {value}?"
+            )
         super().__init__(key="free_text_minimum_characters", value=value)

rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -3,7 +3,7 @@ import urllib.parse
 from colorama import Fore
 from rapidata.rapidata_client.validation.rapids.rapids import Rapid
 from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.logging import logger, managed_print
+from rapidata.rapidata_client.config import logger, managed_print, tracer
 from rapidata.api_client.models.update_dimensions_model import UpdateDimensionsModel
 from rapidata.api_client.models.update_should_alert_model import UpdateShouldAlertModel
 
@@ -34,7 +34,9 @@ class RapidataValidationSet:
         Args:
             rapid (Rapid): The Rapid to add to the validation set.
         """
-        rapid._add_to_validation_set(self.id, self.__openapi_service)
+        with tracer.start_as_current_span("RapidataValidationSet.add_rapid"):
+            logger.debug("Adding rapid %s to validation set %s", rapid, self.id)
+            rapid._add_to_validation_set(self.id, self.__openapi_service)
         return self
 
     def update_dimensions(self, dimensions: list[str]):
@@ -43,13 +45,14 @@ class RapidataValidationSet:
         Args:
             dimensions (list[str]): The new dimensions of the validation set.
         """
-        logger.debug(
-            "Updating dimensions for validation set %s to %s", self.id, dimensions
-        )
-        self.__openapi_service.validation_api.validation_set_validation_set_id_dimensions_put(
-            self.id, UpdateDimensionsModel(dimensions=dimensions)
-        )
-        return self
+        with tracer.start_as_current_span("RapidataValidationSet.update_dimensions"):
+            logger.debug(
+                "Updating dimensions for validation set %s to %s", self.id, dimensions
+            )
+            self.__openapi_service.validation_api.validation_set_validation_set_id_dimensions_put(
+                self.id, UpdateDimensionsModel(dimensions=dimensions)
+            )
+            return self
 
     def update_should_alert(self, should_alert: bool):
         """Determines whether users should be alerted if they answer incorrectly.
@@ -60,13 +63,14 @@ class RapidataValidationSet:
         Note:
             The userScore dimensions which are updated when a user answers a validation task are updated regardless of the value of `should_alert`.
         """
-        logger.debug(
-            "Setting shouldAlert for validation set %s to %s", self.id, should_alert
-        )
-        self.__openapi_service.validation_api.validation_set_validation_set_id_shouldalert_patch(
-            self.id, UpdateShouldAlertModel(shouldAlert=should_alert)
-        )
-        return self
+        with tracer.start_as_current_span("RapidataValidationSet.update_should_alert"):
+            logger.debug(
+                "Setting shouldAlert for validation set %s to %s", self.id, should_alert
+            )
+            self.__openapi_service.validation_api.validation_set_validation_set_id_shouldalert_patch(
+                self.id, UpdateShouldAlertModel(shouldAlert=should_alert)
+            )
+            return self
 
     def view(self) -> None:
         """

rapidata/rapidata_client/validation/rapids/rapids.py

@@ -15,7 +15,7 @@ from rapidata.api_client.models.dataset_dataset_id_datapoints_post_request_metad
 )
 from rapidata.service.openapi_service import OpenAPIService
 
-from rapidata.rapidata_client.logging import logger
+from rapidata.rapidata_client.config import logger
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
 
 
@@ -109,3 +109,9 @@ class Rapid:
                 else None
             ),
         )
+
+    def __str__(self) -> str:
+        return f"Rapid(asset={self.asset}, metadata={self.metadata}, payload={self.payload}, truth={self.truth}, randomCorrectProbability={self.randomCorrectProbability}, explanation={self.explanation}, settings={self.settings})"
+
+    def __repr__(self) -> str:
+        return self.__str__()