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

rapidata/rapidata_client/order/rapidata_order.py

@@ -14,11 +14,20 @@ from rapidata.api_client.models.campaign_artifact_model import CampaignArtifactM
 from rapidata.api_client.models.order_state import OrderState
 from rapidata.api_client.models.preview_order_model import PreviewOrderModel
 from rapidata.api_client.models.submit_order_model import SubmitOrderModel
-from rapidata.api_client.models.preliminary_download_model import PreliminaryDownloadModel
+from rapidata.api_client.models.preliminary_download_model import (
+    PreliminaryDownloadModel,
+)
 from rapidata.api_client.models.workflow_artifact_model import WorkflowArtifactModel
 from rapidata.rapidata_client.order.rapidata_results import RapidataResults
 from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.logging import logger, managed_print, RapidataOutputManager
+from rapidata.rapidata_client.logging import (
+    logger,
+    managed_print,
+    RapidataOutputManager,
+)
+from rapidata.rapidata_client.api.rapidata_exception import (
+    suppress_rapidata_error_logging,
+)
 
 
 class RapidataOrder:
@@ -47,45 +56,53 @@ class RapidataOrder:
         self.__workflow_id: str = ""
         self.__campaign_id: str = ""
         self.__pipeline_id: str = ""
-        self._max_retries = 10  
+        self._max_retries = 10
         self._retry_delay = 2
-        self.order_details_page = f"https://app.{self.__openapi_service.environment}/order/detail/{self.id}"
+        self.order_details_page = (
+            f"https://app.{self.__openapi_service.environment}/order/detail/{self.id}"
+        )
         logger.debug("RapidataOrder initialized")
 
     @property
     def created_at(self) -> datetime:
         """Returns the creation date of the order."""
         if not self.__created_at:
-            self.__created_at = self.__openapi_service.order_api.order_order_id_get(self.id).order_date
+            self.__created_at = self.__openapi_service.order_api.order_order_id_get(
+                self.id
+            ).order_date
         return self.__created_at
-    
+
     def run(self) -> "RapidataOrder":
         """Runs the order to start collecting responses."""
-        logger.info(f"Starting order '{self}'")
-        self.__openapi_service.order_api.order_order_id_submit_post(self.id, SubmitOrderModel(ignoreFailedDatapoints=True))
-        logger.debug(f"Order '{self}' has been started.")
-        managed_print(f"Order '{self.name}' is now viewable under: {self.order_details_page}")
+        logger.info("Starting order '%s'", self)
+        self.__openapi_service.order_api.order_order_id_submit_post(
+            self.id, SubmitOrderModel(ignoreFailedDatapoints=True)
+        )
+        logger.debug("Order '%s' has been started.", self)
+        managed_print(
+            f"Order '{self.name}' is now viewable under: {self.order_details_page}"
+        )
         return self
 
     def pause(self) -> None:
         """Pauses the order."""
-        logger.info(f"Pausing order '{self}'")
+        logger.info("Pausing order '%s'", self)
         self.__openapi_service.order_api.order_order_id_pause_post(self.id)
-        logger.debug(f"Order '{self}' has been paused.")
+        logger.debug("Order '%s' has been paused.", self)
         managed_print(f"Order '{self}' has been paused.")
 
     def unpause(self) -> None:
         """Unpauses/resumes the order."""
-        logger.info(f"Unpausing order '{self}'")
+        logger.info("Unpausing order '%s'", self)
         self.__openapi_service.order_api.order_order_id_resume_post(self.id)
-        logger.debug(f"Order '{self}' has been unpaused.")
+        logger.debug("Order '%s' has been unpaused.", self)
         managed_print(f"Order '{self}' has been unpaused.")
 
     def delete(self) -> None:
         """Deletes the order."""
-        logger.info(f"Deleting order '{self}'")
+        logger.info("Deleting order '%s'", self)
         self.__openapi_service.order_api.order_order_id_delete(self.id)
-        logger.debug(f"Order '{self}' has been deleted.")
+        logger.debug("Order '%s' has been deleted.", self)
         managed_print(f"Order '{self}' has been deleted.")
 
     def get_status(self) -> str:
@@ -104,31 +121,37 @@ class RapidataOrder:
         """
         return self.__openapi_service.order_api.order_order_id_get(self.id).state
 
-    def display_progress_bar(self, refresh_rate: int=5) -> None:
+    def display_progress_bar(self, refresh_rate: int = 5) -> None:
         """
         Displays a progress bar for the order processing using tqdm.
-        
-        Args: 
+
+        Args:
             refresh_rate: How often to refresh the progress bar, in seconds.
         """
         if refresh_rate < 1:
             raise ValueError("refresh_rate must be at least 1")
-        
+
         if self.get_status() == OrderState.CREATED:
             raise Exception("Order has not been started yet. Please start it first.")
-        
+
         while self.get_status() == OrderState.SUBMITTED:
-            managed_print(f"Order '{self}' is submitted and being reviewed. Standby...", end="\r")
+            managed_print(
+                f"Order '{self}' is submitted and being reviewed. Standby...", end="\r"
+            )
             sleep(1)
 
         if self.get_status() == OrderState.MANUALREVIEW:
             raise Exception(
-                f"Order '{self}' is in manual review. It might take some time to start. "
-                "To speed up the process, contact support (info@rapidata.ai).\n"
-                "Once started, run this method again to display the progress bar."
+                f"Order '{self}' is in manual review. It might take some time to start. To speed up the process, contact support (info@rapidata.ai).\nOnce started, run this method again to display the progress bar."
             )
-        
-        with tqdm(total=100, desc="Processing order", unit="%", bar_format="{desc}: {percentage:3.0f}%|{bar}| completed [{elapsed}<{remaining}, {rate_fmt}]", disable=RapidataOutputManager.silent_mode) as pbar:
+
+        with tqdm(
+            total=100,
+            desc="Processing order",
+            unit="%",
+            bar_format="{desc}: {percentage:3.0f}%|{bar}| completed [{elapsed}<{remaining}, {rate_fmt}]",
+            disable=RapidataOutputManager.silent_mode,
+        ) as pbar:
             last_percentage = 0
             while True:
                 current_percentage = self._workflow_progress.completion_percentage
@@ -149,8 +172,11 @@ class RapidataOrder:
         progress = None
         for _ in range(self._max_retries // 2):
             try:
-                workflow_id = self.__get_workflow_id()
-                progress = self.__openapi_service.workflow_api.workflow_workflow_id_progress_get(workflow_id)
+                with suppress_rapidata_error_logging():
+                    workflow_id = self.__get_workflow_id()
+                    progress = self.__openapi_service.workflow_api.workflow_workflow_id_progress_get(
+                        workflow_id
+                    )
                 break
             except Exception:
                 sleep(self._retry_delay * 2)
@@ -160,52 +186,71 @@ class RapidataOrder:
 
     def get_results(self, preliminary_results: bool = False) -> RapidataResults:
         """
-        Gets the results of the order. 
+        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.
 
         Args:
-            preliminary_results: If True, returns the preliminary results of the order. Defaults to False. 
+            preliminary_results: If True, returns the preliminary results of the order. Defaults to False.
                 Note that preliminary results are not final and may not contain all the datapoints & responses. Only the onese that are already available.
         """
-        logger.info(f"Getting results for order '{self}'...")
+        logger.info("Getting results for order '%s'...", self)
         if preliminary_results and self.get_status() not in [OrderState.COMPLETED]:
             return self.__get_preliminary_results()
-        
+
         elif preliminary_results and self.get_status() in [OrderState.COMPLETED]:
             managed_print("Order is already completed. Returning final results.")
 
-        while self.get_status() not in [OrderState.COMPLETED, OrderState.PAUSED, OrderState.MANUALREVIEW, OrderState.FAILED]:
+        while self.get_status() not in [
+            OrderState.COMPLETED,
+            OrderState.PAUSED,
+            OrderState.MANUALREVIEW,
+            OrderState.FAILED,
+        ]:
             sleep(5)
 
         try:
-            return RapidataResults(json.loads(self.__openapi_service.order_api.order_order_id_download_results_get(order_id=self.id)))
+            return RapidataResults(
+                json.loads(
+                    self.__openapi_service.order_api.order_order_id_download_results_get(
+                        order_id=self.id
+                    )
+                )
+            )
         except (ApiException, json.JSONDecodeError) as e:
             raise Exception(f"Failed to get order results: {str(e)}") from e
-        
+
     def view(self) -> None:
         """
         Opens the order details page in the browser.
-        
+
         Raises:
             Exception: If the order is not in processing state.
         """
         logger.info("Opening order details page in browser...")
         could_open_browser = webbrowser.open(self.order_details_page)
         if not could_open_browser:
-            encoded_url = urllib.parse.quote(self.order_details_page, safe="%/:=&?~#+!$,;'@()*[]")
-            managed_print(Fore.RED + f'Please open this URL in your browser: "{encoded_url}"' + Fore.RESET)
-        
+            encoded_url = urllib.parse.quote(
+                self.order_details_page, safe="%/:=&?~#+!$,;'@()*[]"
+            )
+            managed_print(
+                Fore.RED
+                + f"Please open this URL in your browser: '{encoded_url}'"
+                + Fore.RESET
+            )
+
     def preview(self) -> None:
         """
         Opens a preview of the order in the browser.
-        
+
         Raises:
             Exception: If the order is not in processing state.
         """
         logger.info("Opening order preview in browser...")
         if self.get_status() == OrderState.CREATED:
             logger.info("Order is still in state created. Setting it to preview.")
-            self.__openapi_service.order_api.order_order_id_preview_post(self.id, PreviewOrderModel(ignoreFailedDatapoints=True))
+            self.__openapi_service.order_api.order_order_id_preview_post(
+                self.id, PreviewOrderModel(ignoreFailedDatapoints=True)
+            )
             logger.info("Order is now in preview state.")
 
         campaign_id = self.__get_campaign_id()
@@ -213,14 +258,22 @@ class RapidataOrder:
         could_open_browser = webbrowser.open(auth_url)
         if not could_open_browser:
             encoded_url = urllib.parse.quote(auth_url, safe="%/:=&?~#+!$,;'@()*[]")
-            managed_print(Fore.RED + f'Please open this URL in your browser: "{encoded_url}"' + Fore.RESET)
+            managed_print(
+                Fore.RED
+                + f"Please open this URL in your browser: '{encoded_url}'"
+                + Fore.RESET
+            )
 
     def __get_pipeline_id(self) -> str:
         """Internal method to fetch and cache the pipeline ID."""
         if not self.__pipeline_id:
             for _ in range(self._max_retries):
                 try:
-                    self.__pipeline_id = self.__openapi_service.order_api.order_order_id_get(self.id).pipeline_id
+                    self.__pipeline_id = (
+                        self.__openapi_service.order_api.order_order_id_get(
+                            self.id
+                        ).pipeline_id
+                    )
                     break
                 except Exception:
                     sleep(self._retry_delay)
@@ -247,9 +300,17 @@ class RapidataOrder:
         pipeline_id = self.__get_pipeline_id()
         for _ in range(self._max_retries):
             try:
-                pipeline = self.__openapi_service.pipeline_api.pipeline_pipeline_id_get(pipeline_id)
-                self.__workflow_id = cast(WorkflowArtifactModel, pipeline.artifacts["workflow-artifact"].actual_instance).workflow_id
-                self.__campaign_id = cast(CampaignArtifactModel, pipeline.artifacts["campaign-artifact"].actual_instance).campaign_id
+                pipeline = self.__openapi_service.pipeline_api.pipeline_pipeline_id_get(
+                    pipeline_id
+                )
+                self.__workflow_id = cast(
+                    WorkflowArtifactModel,
+                    pipeline.artifacts["workflow-artifact"].actual_instance,
+                ).workflow_id
+                self.__campaign_id = cast(
+                    CampaignArtifactModel,
+                    pipeline.artifacts["campaign-artifact"].actual_instance,
+                ).campaign_id
                 return
             except Exception:
                 sleep(self._retry_delay)
@@ -262,7 +323,7 @@ class RapidataOrder:
             download_id = self.__openapi_service.pipeline_api.pipeline_pipeline_id_preliminary_download_post(
                 pipeline_id, PreliminaryDownloadModel(sendEmail=False)
             ).download_id
-            
+
             elapsed = 0
             timeout = 60
             while elapsed < timeout:

rapidata/rapidata_client/rapidata_client.py

@@ -5,7 +5,9 @@ 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.benchmark.rapidata_benchmark_manager import RapidataBenchmarkManager
+from rapidata.rapidata_client.benchmark.rapidata_benchmark_manager import (
+    RapidataBenchmarkManager,
+)
 
 from rapidata.rapidata_client.validation.validation_set_manager import (
     ValidationSetManager,
@@ -15,18 +17,19 @@ from rapidata.rapidata_client.demographic.demographic_manager import Demographic
 
 from rapidata.rapidata_client.logging import logger, managed_print
 
+
 class RapidataClient:
     """The Rapidata client is the main entry point for interacting with the Rapidata API. It allows you to create orders and validation sets."""
 
     def __init__(
-            self,
-            client_id: str | None = None,
-            client_secret: str | None = None,
-            environment: str = "rapidata.ai",
-            oauth_scope: str = "openid",
-            cert_path: str | None = None,
-            token: dict | None = None,
-            leeway: int = 60
+        self,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        environment: str = "rapidata.ai",
+        oauth_scope: str = "openid",
+        cert_path: str | None = None,
+        token: dict | None = None,
+        leeway: int = 60,
     ):
         """Initialize the RapidataClient. If both the client_id and client_secret are None, it will try using your credentials under "~/.config/rapidata/credentials.json".
         If this is not successful, it will open a browser window and ask you to log in, then save your new credentials in said json file.
@@ -69,7 +72,7 @@ class RapidataClient:
 
         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."""
         self._openapi_service.reset_credentials()
@@ -79,12 +82,14 @@ class RapidataClient:
             response = requests.get(
                 "https://api.github.com/repos/RapidataAI/rapidata-python-sdk/releases/latest",
                 headers={"Accept": "application/vnd.github.v3+json"},
-                timeout=3
+                timeout=3,
             )
             if response.status_code == 200:
                 latest_version = response.json()["tag_name"].lstrip("v")
                 if version.parse(latest_version) > version.parse(__version__):
-                    managed_print(f"""A new version of the Rapidata SDK is available: {latest_version}
-Your current version is: {__version__}""")
+                    managed_print(
+                        f"""A new version of the Rapidata SDK is available: {latest_version}
+Your current version is: {__version__}"""
+                    )
         except Exception as e:
-            logger.debug(f"Failed to check for updates: {e}")
+            logger.debug("Failed to check for updates: %s", e)

rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -4,6 +4,7 @@ from rapidata.rapidata_client.logging import logger
 from rapidata.api_client.models.update_dimensions_model import UpdateDimensionsModel
 from rapidata.api_client.models.update_should_alert_model import UpdateShouldAlertModel
 
+
 class RapidataValidationSet:
     """A class for interacting with a Rapidata validation set.
 
@@ -20,7 +21,7 @@ class RapidataValidationSet:
         self.id = validation_set_id
         self.name = name
         self.__openapi_service = openapi_service
-    
+
     def add_rapid(self, rapid: Rapid):
         """Add a Rapid to the validation set.
 
@@ -36,10 +37,14 @@ class RapidataValidationSet:
         Args:
             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_set_validation_set_id_dimensions_put(self.id, UpdateDimensionsModel(dimensions=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.
 
@@ -49,10 +54,11 @@ 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(f"Setting shouldAlert for validation set {self.id} to {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)
+            self.id, UpdateShouldAlertModel(shouldAlert=should_alert)
         )
         return self