Skip to content

Rapidata order

RapidataOrder #

RapidataOrder(
    name: str,
    order_id: str,
    openapi_service: OpenAPIService,
)

An instance of a Rapidata order.

Used to interact with a specific order in the Rapidata system, such as starting, pausing, and retrieving results.

Parameters:

Name Type Description Default
name str

The name of the order.

 required
order_id str

The ID of the order.

 required
openapi_service OpenAPIService

The OpenAPIService instance for API interaction.

 required
Source code in src/rapidata/rapidata_client/order/rapidata_order.py 
35
36
37
38
39
40
41
42
43
44
45
46
47
48
def __init__(
    self,
    name: str,
    order_id: str,
    openapi_service: OpenAPIService,
):
    self.order_id = order_id
    self.name = name
    self.__openapi_service = openapi_service
    self.__workflow_id: str = ""
    self.__campaign_id: str = ""
    self.__pipeline_id: str = ""
    self._max_retries = 10  
    self._retry_delay = 2

run #

run(print_link: bool = True) -> RapidataOrder

Runs the order to start collecting responses.

Source code in src/rapidata/rapidata_client/order/rapidata_order.py 
50
51
52
53
54
55
def run(self, print_link: bool = True) -> "RapidataOrder":
    """Runs the order to start collecting responses."""
    self.__openapi_service.order_api.order_submit_post(self.order_id)
    if print_link:
        print(f"Order '{self.name}' is now viewable under: https://app.{self.__openapi_service.environment}/order/detail/{self.order_id}")
    return self

pause #

pause() -> None

Pauses the order.

Source code in src/rapidata/rapidata_client/order/rapidata_order.py 
57
58
59
60
def pause(self) -> None:
    """Pauses the order."""
    self.__openapi_service.order_api.order_pause_post(self.order_id)
    print(f"Order '{self}' has been paused.")

unpause #

unpause() -> None

Unpauses/resumes the order.

Source code in src/rapidata/rapidata_client/order/rapidata_order.py 
62
63
64
65
def unpause(self) -> None:
    """Unpauses/resumes the order."""
    self.__openapi_service.order_api.order_resume_post(self.order_id)
    print(f"Order '{self}' has been unpaused.")

get_status #

get_status() -> str

Gets the status of the order.

States

Created: The order has been created but not started yet.

Preview: The order has been set up and ready but not collecting responses yet.

Submitted: The order has been submitted and is being reviewed.

ManualReview: The order is in manual review - something went wrong with the automatic approval.

Processing: The order is actively being processed.

Paused: The order has been paused.

Completed: The order has been completed.

Failed: The order has failed.

Source code in src/rapidata/rapidata_client/order/rapidata_order.py 
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
def get_status(self) -> str:
    """
    Gets the status of the order.

    States:
        Created: The order has been created but not started yet.\n
        Preview: The order has been set up and ready but not collecting responses yet.\n
        Submitted: The order has been submitted and is being reviewed.\n
        ManualReview: The order is in manual review - something went wrong with the automatic approval.\n
        Processing: The order is actively being processed.\n
        Paused: The order has been paused.\n
        Completed: The order has been completed.\n
        Failed: The order has failed.
    """
    return self.__openapi_service.order_api.order_order_id_get(self.order_id).state

display_progress_bar #

display_progress_bar(refresh_rate: int = 5) -> None

Displays a progress bar for the order processing using tqdm.

Parameters:

Name Type Description Default
refresh_rate int

How often to refresh the progress bar, in seconds.

 5
Source code in src/rapidata/rapidata_client/order/rapidata_order.py 
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
def display_progress_bar(self, refresh_rate: int=5) -> None:
    """
    Displays a progress bar for the order processing using tqdm.

    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:
        print(f"Order '{self.name}' is submitted and being reviewed. Standby...", end="\r")
        sleep(1)

    if self.get_status() == OrderState.MANUALREVIEW:
        raise Exception(
            f"Order '{self.name}' 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."
        )

    with tqdm(total=100, desc="Processing order", unit="%", bar_format="{desc}: {percentage:3.0f}%|{bar}| completed [{elapsed}<{remaining}, {rate_fmt}]") as pbar:
        last_percentage = 0
        while True:
            current_percentage = self._workflow_progress.completion_percentage
            if current_percentage > last_percentage:
                pbar.update(current_percentage - last_percentage)
                last_percentage = current_percentage

            if current_percentage >= 100:
                break

            sleep(refresh_rate)

get_results #

get_results(
    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.

Parameters:

Name Type Description Default
preliminary_results bool

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. This will throw an exception if there are no responses available yet.

 False
Source code in src/rapidata/rapidata_client/order/rapidata_order.py 
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
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.

    Args:
        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.
            This will throw an exception if there are no responses available yet.
    """

    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]:
        print("Order is already completed. Returning final results.")

    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.order_id)))
    except (ApiException, json.JSONDecodeError) as e:
        raise Exception(f"Failed to get order results: {str(e)}") from e

preview #

preview() -> None

Opens a preview of the order in the browser.

Raises:

Type Description
Exception

If the order is not in processing state.
Source code in src/rapidata/rapidata_client/order/rapidata_order.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
def preview(self) -> None:
    """
    Opens a preview of the order in the browser.

    Raises:
        Exception: If the order is not in processing state.
    """        
    campaign_id = self.__get_campaign_id()
    auth_url = f"https://app.{self.__openapi_service.environment}/order/detail/{self.order_id}/preview?campaignId={campaign_id}"
    could_open_browser = webbrowser.open(auth_url)
    if not could_open_browser:
        encoded_url = urllib.parse.quote(auth_url, safe="%/:=&?~#+!$,;'@()*[]")
        print(Fore.RED + f'Please open this URL in your browser: "{encoded_url}"' + Fore.RESET)