RPA.Assistant

module RPA.Assistant

class RPA.Assistant.Assistant

The Assistant library provides a way to display information to a user and request input while a robot is running. It allows building processes that require human interaction. Also it offers capabilities of running other robots inside the current one and determine what to display to the user based on his previous responses.

It is not included in the rpaframework package, so in order to use it you have to add rpaframework-assistant with the desired version in your conda.yaml file

Some examples of use-cases could be the following:

  • Displaying generated files after an execution is finished
  • Displaying dynamic and user-friendly error messages
  • Requesting passwords or other personal information
  • Running Keywords based on user’s actions
  • Displaying dynamic content based on user’s actions
  • Automating based on files created by the user

Workflow

The library is used to create dialogs, i.e. windows, that can be composed on-the-fly based on the current state of the execution.

The content of the dialog is defined by calling relevant keywords such as Add text or Add file input. When the dialog is opened the content is generated based on the previous keywords.

Depending on the way the dialog is started, the execution will either block or continue while the dialog is open. During this time the user can freely edit any possible input fields or handle other tasks.

After the user has successfully submitted the dialog, any possible entered input will be returned as a result. The user also has the option to abort by closing the dialog window forcefully.

Results

Each input field has a required name argument that controls what the value will be called in the result object. Each input name should be unique, and must not be called submit as that is reserved for the submit button value.

A result object is a Robot Framework DotDict, where each key is the name of the input field and the value is what the user entered. The data type of each field depends on the input. For instance, a text input will have a string, a checkbox will have a boolean, and a file input will have a list of paths.

If the user closed the window before submitting or there was an internal error, the results object returned by Run Dialog or Ask User won’t have a “submit” key.

Layouting

By default elements are added to the assistant dialog from top to bottom, with a bit of margin around each element to add spaciousness. This margin is added as a Container you can manually use Open Container to override the default container. You can use it to set smaller margins.

You can combine layouting elements with each other. Layouting elements need to be closed with the corresponding Close keyword. (So Open Row and then Close Row.)

Open Row can be used to layout elements in the same row.

Open Column can be used to layout elements in columns.

Open Stack and multiple Open Container’s inside it can be used to set positions like Center, Topleft, BottomRight, or coordinate tuples likes (0, 0), (100, 100) and such.

Open Container can bse used for absolute positioning inside a Stack, or anywhere for setting background color or margins and paddings.

Open Navbar can be used to make a navigation bar that will stay at the top of the dialog. Its contents won’t be cleared when.

Examples

def success_dialog(): assistant = Assistant() assistant.add_icon("success") assistant.add_heading("Your orders have been processed") assistant.add_files("*.txt") assistant.run_dialog(title="Success") def failure_dialog(): assistant = Assistant() assistant.add_icon("failure") assistant.add_heading("There was an error") assistant.add_text("The assistant failed to login to the Enterprise portal") assistant.add_link("https://robocorp.com/docs", label="Troubleshooting guide") assistant.add_files("*.txt") assistant.run_dialog(title="Failure") def large_dialog(): assistant = Assistant() assistant.add_heading("A real chonker", size="large") assistant.add_image("fat-cat.jpeg") assistant.run_dialog(title="Large", height=1024, width=1024) def confirmation_dialog(): assistant = Assistant() assistant.add_icon("warning") assistant.add_heading("Delete user ${username}?") assistant.add_submit_buttons(buttons="No, Yes", default="Yes") result = assistant.run_dialog() if result.submit == "Yes": delete_user(username) def input_from_dialog(): assistant = Assistant() assistant.add_heading("Send feedback") assistant.add_text_input("email", label="E-mail address") assistant.add_text_input("message", label="Feedback", placeholder="Enter feedback here", maximum_rows=5) assistant.add_submit_buttons("Submit", default="Submit") result = assistant.run_dialog() send_feedback_message(result.email, result.message)

variable ROBOT_AUTO_KEYWORDS

ROBOT_AUTO_KEYWORDS = False

variable ROBOT_LIBRARY_DOC_FORMAT

ROBOT_LIBRARY_DOC_FORMAT = 'REST'

variable ROBOT_LIBRARY_SCOPE

ROBOT_LIBRARY_SCOPE = 'GLOBAL'

method add_button

add_button(label: str, function: Union[Callable, str], *args, location: VerticalLocation = VerticalLocation.Left, **kwargs)

Create a button and execute the function as a callback when pressed.

Parameters
  • label – Text for the button
  • function – Python function or Robot Keyword name, that will get *args and **kwargs passed into it
Examples

def first_view(): assistant = Assistant() assistant.add_heading("Here is the first view of the app") assistant.add_button("Change view", second_view) assistant.run_dialog() def second_view(): assistant = Assistant() assistant.add_heading("Let's build an infinite loop") assistant.add_button("Change view", first_view) assistant.run_dialog()

method add_checkbox

add_checkbox(name: str, label: str, default: bool = False)

Add a checkbox element

Parameters
  • name – Name of result field
  • label – Label text for checkbox
  • default – Default checked state

Adds a checkbox that indicates a true or false value. The selection will be available in the name field of the result, and the label text will be shown next to the checkbox.

The boolean default value will define the initial checked state of the element.

Examples

def select_checkboxes(): assistant = Assistant() assistant.add_heading("Enable features") assistant.add_checkbox(name="vault", label="Enable vault", default=True) assistant.add_checkbox(name="triggers", label="Enable triggers", default=False) assistant.add_checkbox(name="assistants", label="Enable assistants", default=True) result = assistant.run_dialog() if(result.vault): enable_vault()

method add_date_input

add_date_input(name: str, default: Optional[Union[date, str]] = None, label: Optional[str] = None)

Add a date input element.

Parameters
  • name – Name of the result field
  • default – The default set date
  • label – Label for the date input field

Displays a date input. The selection the user makes will be available as a date object in the name field of the result. The default argument can be a pre-set date as object or string in “YYYY-MM-DD” format, otherwise the current date is used.

Examples

def select_birthdate(): assistant = Assistant() assistant.add_heading("Enter your birthdate") assistant.add_date_input("birthdate", default="1993-04-26") result = assistant.run_dialog() print("User birthdate year should be: ", result.birthdate.year)

method add_drop_down

add_drop_down(name: str, options: Union[List[str], str], default: Optional[str] = None, label: Optional[str] = None)

Add a drop-down element

Parameters
  • name – Name of result field
  • options – List of drop-down options
  • default – The default selection
  • label – Label for input field

Creates a drop-down menu with the given options. The selection the user makes will be available in the name field of the result.

The default argument can be one of the defined options, and the dialog automatically selects that option for the input.

A custom label text can also be added.

Examples

def select_user_type_from_drop_down(): assistant = Assistant() assistant.add_heading("Select user type") assistant.add_drop_down( name="user_type", options="Admin,Maintainer,Operator", default="Operator", label="User type" ) result = assistant.run_dialog() print("User type should be: ", result.user_type)

method add_file

add_file(path: str, label: Optional[str] = None)

Add a file element, which links to a local file

Parameters
  • path – The path to the file
  • label – A custom label text for the file

Adds a button which opens a local file with the corresponding default application. Can be used for instance to display generated files from the robot to the end-user.

Optionally a custom label can be given for the button text. By default uses the filename of the linked file.

Examples

def open_file_button(): path = generate_order_files() assistant = Assistant() assistant.add_heading("Current orders") assistant.add_file(path, label="Current") assistant.run_dialog()

method add_file_input

add_file_input(name: str, label: Optional[str] = None, source: Optional[str] = None, file_type: Optional[str] = None, multiple: bool = False)

Add a file input element

Parameters
  • name – Name of result field
  • label – Label for input field
  • source – Default source directory
  • file_type – Accepted file types
  • multiple – Allow selecting multiple files

Adds a native file selection dialog for inputting one or more files. The list of selected files will be available in the name field of the result.

By default opens up in the user’s home directory, but it can be set to a custom path with the source argument.

The argument file_type restricts the possible file extensions that the user can select. The format of the argument is as follows: pdf,png,svg. For instance, an argument to limit options to Excel files could be: xls,xlsx.

To allow selecting more than one file, the multiple argument can be enabled.

Examples

def multiple_file_selections(): assistant = Assistant() # This can be any one file assistant.add_file_input(name="anything") # This can be multiple files assistant.add_file_input(name="multiple", multiple=True) # This opens the select dialog to a custom folder assistant.add_file_input(name="src", source="C:\Temp\Output") # This restricts files to certain types assistant.add_file_input(name="types", file_type="pdf") # Every file input result is a list of paths result = assistant.run_dialog() for path in result.multiple: print("Selected file: ", path)

method add_files

add_files(pattern: str)

Add multiple file elements according to the given file pattern

  • Parameters: pattern – File matching pattern

See the keyword Add file for information about the inserted element itself.

The keyword uses Unix-style glob patterns for finding matching files, and the supported pattern expressions are as follow:

PatternMeaning
*Match everything
?Match any single character
[seq]Match any character in seq
[!seq]Match any character not in seq
**Match all files, directories, and subdirectories

If a filename has any of these special characters, they can be escaped by wrapping them with square brackets.

Examples

def open_multiple_files_buttons(): assistant = Assistant() # Add all excel files assistant.add_file("*.xlsx") # Add all log files in any subdirectory assistant.add_file("**/*.log") # Add all PDFs between order0 and order9 assistant.add_file("order[0-9].pdf") assistant.run_dialog()

method add_flet_icon

add_flet_icon(icon: str, color: Optional[str] = None, size: Optional[int] = 24)

Add an icon from a large gallery of icons.

Parameters
Examples

def add_custom_icon() assistant = Assistant() assistant.add_heading("Check icon") assistant.add_flet_icon(icon="check_circle_rounded", color="FF00FF", size="48") assistant.run_dialog()

method add_heading

add_heading(heading: str, size: Size = Size.Medium)

Add a centered heading text element

Parameters
  • heading – The text content for the heading
  • size – The size of the heading

Supported size values are Small, Medium, and Large. By default uses the value Medium.

Examples

def add_dialog_heading(): assistant = Assistant() assistant.add_heading("User information", size="large") assistant.add_heading("Location", size="small") assistant.add_text_input("address", label="User address") assistant.run_dialog()

method add_hidden_input

add_hidden_input(name: str, value: str)

Add a hidden input element

Parameters
  • name – Name of result feild
  • value – Value for input

Adds a special hidden result field that is not visible to the user and always contains the given static value.

Can be used to keep user input together with already known values such as user IDs, or to ensure that dialogs with differing elements all have the same fields in results.

Examples

def get_user_information(): assistant = Assistant() user_id = "Your user value" assistant.add_hidden_input("user_id", user_id) assistant.add_text_input("username") result = assistant.run_dialog() enter_user_information(result.user_id, result.username)

method add_icon

add_icon(variant: Icon, size: int = 48)

Add an icon element from RPA.Assistant’s short icon list.

Parameters
  • variant – The icon type
  • size – The size of the icon

Adds an icon which can be used to indicate status or the type of dialog being presented.

The currently supported icon types are:

NameDescription
SuccessA green check mark
WarningAn orange warning triangle
FailureA red cross or X mark

The size of the icon can also be changed, to a given height/width of pixels.

Examples

def confirmation_dialog(): assistant = Assistant() assistant.add_icon("warning", size="64") assistant.add_heading("Do you want to delete this order?") assistant.add_submit_buttons(buttons="No, Yes") result = assistant.run_dialog()

method add_image

add_image(url_or_path: str, width: Optional[int] = None, height: Optional[int] = None)

Add an image element, from a local file or remote URL

Parameters
  • url_or_path – The location of the image
  • width – The static width of the image, in pixels
  • height – The static height of the image, in pixels

Adds an inline image to the dialog, which can either point to a local file path on the executing machine or to a remote URL. If it’s a local file path it has to be absolute path.

By default the image is resized to fit the width of the dialog window, but the width and/or height can be explicitly defined to a custom value. If only one of the dimensions is given, the other is automatically changed to maintain the correct aspect ratio.


add_link(url: str, label: Optional[str] = None)

Add an external URL link element

Parameters
  • url – The URL for the link
  • label – A custom label text for the link

Adds a clickable link element, which opens the user’s default browser to the given url. Optionally a label can be given which is shown as the link text, instead of the raw URL.

Examples

def add_troubleshoot_link(): assistant = Assistant() assistant.add_heading("An error occurred") assistant.add_text("See link for documentation") assistant.add_link("https://robocorp.com/docs", label="Troubleshooting") assistant.run_dialog()

method add_loading_bar

add_loading_bar(name: str, width: int = 16, bar_height: int = 16, color: Optional[str] = None, tooltip: Optional[str] = None, value: Optional[float] = None)

Add a loading bar.

Parameters

method add_loading_spinner

add_loading_spinner(name: str, width: int = 16, height: int = 16, stroke_width: int = 2, color: Optional[str] = None, tooltip: Optional[str] = None, value: Optional[float] = None)

Add a loading spinner.

Parameters

method add_next_ui_button

add_next_ui_button(label: str, function: Union[Callable, str])

Create a button that leads to the next UI page, calling the passed keyword or function, and passing current form results as first positional argument to it.

Parameters
  • label – Text for the button
  • function – Python function or Robot Keyword name, that will take form results as its first argument
Examples

def main_form(): assistant = Assistant() assistant.add_heading("Username input") assistant.add_text_input("username_1", placeholder="username") assistant.add_next_ui_button("Show customer details", customer_details) assistant.run_dialog() def customer_details(form): assistant = Assistant() user_data = retrieve_user_data(form.username_1) assistant.add_heading("Retrieved Data") assistant.add_text(user_data[phone_number]) assistant.add_text(user_data[address]) assistant.run_dialog()

method add_password_input

add_password_input(name: str, label: Optional[str] = None, placeholder: Optional[str] = None)

Add a password input element

Parameters
  • name – Name of result field
  • label – Label for field
  • placeholder – Placeholder text in input field

Adds a text field that hides the user’s input. The entered content will be available in the name field of the result.

For customizing the look of the input, the label text can be given to add a descriptive label and the placholder text can be given to act as an example of the input value.

Examples

def change_password(): assistant = Assistant() assistant.add_heading("Change password") assistant.add_text_input("username", label="Current username") assistant.add_password_input("password", label="New password") assistant.add_submit_buttons(buttons="Submit") result = assistant.run_dialog() change_user_password(result.username, result.password)

method add_radio_buttons

add_radio_buttons(name: str, options: Union[List[str], str], default: Optional[str] = None, label: Optional[str] = None)

Add radio button elements

Parameters
  • name – Name of result field
  • options – List of drop-down options
  • default – The default selection
  • label – Label for input field

Creates a set of radio buttons with the given options. The selection the user makes will be available in the name field of the result.

The default argument can be one of the defined options, and the dialog automatically selects that option for the input.

A custom label text can also be added.

Examples

def select_user_type_from_radio_buttons(): assistant = Assistant() assistant.add_heading("Select user type") assistant.add_radio_buttons( name="user_type", options="Admin,Maintainer,Operator", default="Operator", label="User type" ) result = assistant.run_dialog() print("User type should be: ", result.user_type)

method add_slider

add_slider(name: str, slider_min: Union[int, float] = 0, slider_max: Union[int, float] = 100, thumb_text='{value}', steps: Optional[int] = None, default: Optional[Union[int, float]] = None, decimals: Optional[int] = 1)

Add a slider input.

Parameters
  • name – Name of result field
  • slider_min – Minimum value of the slider
  • slider_max – Maximum value of the slider
  • thumb_label – Text to display when the slider is being slided. Use the placeholder {value} for the number. (thumb text {value%} will display values: 0%, 100%)
  • steps – Amount of steps for the slider. If None, the slider will be continuous. For integer output, specify a steps value where all the steps will be integers, or implement rounding when retrieving the result.
  • default – Default value for the slider. Must be between min and max.
  • decimals – How many decimals should the value have and show.
def create_percentage_slider(): assistant = Assistant() assistant.add_text("Percentage slider") assistant.add_slider( name="percentage", slider_min=0, slider_max=100, thumb_text="{value}%", steps=100, decimals=1 ) assistant.run_dialog()

method add_submit_buttons

add_submit_buttons(buttons: Union[List[str], str], default: Optional[str] = None)

Add custom submit buttons

Parameters
  • buttons – Submit button options
  • default – The primary button

The result field will always be called submit and will contain the pressed button text as a value.

If one of the custom options should be the preferred option, the default argument controls which one is highlighted with an accent color.

Examples

def delete_user_warning(): assistant = Assistant() username = "user_01" assistant.add_icon("warning") assistant.add_heading(f"Delete user {username}?") assistant.add_submit_buttons(buttons="No, Yes", default="Yes") result = assistant.run_dialog() if result.submit == "Yes": delete_user(username)

method add_text

add_text(text: str, size: Size = Size.Medium)

Add a text paragraph element, for larger bodies of text

Parameters
  • text – The text content for the paragraph
  • size – The size of the text

Supported size values are Small, Medium, and Large. By default uses the value Medium.

Examples

def show_error_dialog(): error = "Your error message" assistant = Assistant() assistant.add_heading("An error occurred") assistant.add_text("There was an error while requesting user information") assistant.add_text(f"{error}", size="small") assistant.run_dialog()

method add_text_input

add_text_input(name: str, label: Optional[str] = None, placeholder: Optional[str] = None, validation: Optional[Union[Callable, str]] = None, default: Optional[str] = None, required: bool = False, minimum_rows: Optional[int] = None, maximum_rows: Optional[int] = None)

Add a text input element

Parameters
  • name – Name of result field
  • label – Label for field
  • placeholder – Placeholder text in input field
  • validation – Validation function for the input field
  • default – Default value if the field wasn’t completed
  • required – If true, will display an error if not completed
  • minimum_rows – Minimum number of rows to display for the input field
  • maximum_rows – Maximum number of rows to display for the input field, the input content can be longer but a scrollbar will appear

Adds a text field that can be filled by the user. The entered content will be available in the name field of the result.

For customizing the look of the input, the label text can be given to add a descriptive label and the placholder text can be given to act as an example of the input value.

The default value will be assigned to the input field if the user doesn’t complete it. If provided, the placeholder won’t be shown. This is None by default. Also, if a default value is provided and the user deletes it, None will be the corresponding value in the results dictionary.

Examples

Validation example:

import re def validate_email(email): # E-mail specification is complicated, this matches that the e-mail has # at least one character before and after the @ sign, and at least one # character after the dot. regex = r"^.+@.+\..+" valid = re.match(regex, email) if not valid: return "Invalid email address" def open_dialog(): assistant.add_heading("Send feedback") assistant.add_text_input("email", label="Email", validation=validate_email) result = run_dialog() print(result.email)

method ask_user

ask_user(timeout: int = 180, **options: Any)

Same as Run Dialog it will create a dialog from all the defined elements and block until the user has handled it. It will also add by default a submit and close buttons.

Parameters
  • timeout – Time to wait for dialog to complete, in seconds
  • options – Options for the dialog

Returns a result object with all input values.

For more information about possible options for opening the dialog, see the documentation for the keyword Run Dialog.

Examples

def ask_user_dialog(): assistant = Assistant() assistant.add_heading("Please enter your username") assistant.add_text_input("username") result = assistant.ask_user() print("The username is: ", result.username)

method clear_dialog

clear_dialog()

Clear dialog and results while it is running.


method close_column

close_column()

Closes previously opened Column.

Raises LayoutError if called with no Column open, or if another layout element was opened more recently than a Column.


method close_container

close_container()

Close previously opened container.

Raises LayoutError if called with no Row open, or if another layout element was opened more recently than a row.


method close_navbar

close_navbar()

Close previously opened navbar.

Raises LayoutError if called with no Row open, or if another layout element was opened more recently than a row.


method close_row

close_row()

Close previously opened row.

Raises LayoutError if called with no Row open, or if another layout element was opened more recently than a row.


method close_stack

close_stack()

Close previously opened Stack.

Raises LayoutError if called with no Stack open, or if another layout element was opened more recently than a Stack.


method open_column

open_column()

Open a Column layout container. Following Add <element> calls will add items into that Column until Close Column is called.

def double_column_layout(): assistant = Assistant() assistant.open_row() assistant.open_column() assistant.add_text("First item in the first column") assistant.add_text("Second item on the first column") assistant.close_column() assistant.open_column() assistant.add_text("First item on the second column") assistant.close_column() assistant.close_row() assistant.run_dialog()

method open_container

open_container(margin: Optional[int] = 5, padding: Optional[int] = None, width: Optional[int] = None, height: Optional[int] = None, background_color: Optional[str] = None, location: Optional[Union[Location, Tuple[int, int]]] = None)

Open a single element container. The following Add <element> calls adds an element inside the container. Can be used for styling elements.

Parameters
  • margin – How much margin to add around the container. RPA.Assistant adds by default a container of margin 5 around all elements, to have a smaller margin use containers with smaller margin value for elements.

  • padding – How much padding to add around the content of the container.

  • width – Width of the container.

  • height – Height of the container.

  • bgcolor – Background color for the container. Default depends on icon. Allowed values are colors from [https://github.com/flet-dev/flet/blob/035b00104f782498d084c2fd7ee96132a542ab7f/sdk/python/packages/flet-core/src/flet_core/colors.py#L37|Flet Documentation] (in the format black12, red500) or ARGB/RGB (#FFXXYYZZ or #XXYYZZ).XXYYZZ

  • location

    Where to place the container (A Location value or tuple of ints). Only works inside a Stack layout element.

    To use any Center___ or ___Center locations you must define width and height to the element.

def padded_element_with_background(): assistant = Assistant() assistant.open_container(padding=20, background_color="blue500") assistant.add_text("Sample text") assistant.close_container() assistant.run_dialog()

method open_navbar

open_navbar(title: Optional[str] = None)

Create a Navigation Bar. Following Add <element> calls will add items into the Navbar until Close Navbar is called.

Navbar doesn’t clear when Clear Dialog is called.

Only one Navbar can be initialized at a time. Trying to make a second one will raise a LayoutError.

def go_to_start_menu(): assistant = Assistant() assistant.add_heading("Start menu") assistant.add_text("Start menu content") assistant.run_dialog() def assistant_navbar(): assistant = Assistant() assistant.open_navbar(title="Assistant") assistant.add_button("menu", go_to_start_menu) assistant.close_navbar() assistant.run_dialog()

method open_row

open_row()

Open a row layout container. Following Add <element> calls will add items into that row until Close Row is called.

def side_by_side_elements(): assistant = Assistant() assistant.open_row() assistant.add_text("First item on the row") assistant.add_text("Second item on the row") assistant.close_row() assistant.run_dialog()

method open_stack

open_stack(width: Optional[int] = None, height: Optional[int] = None)

Create a “Stack” layout element. Stack can be used to position elements absolutely and to have overlapping elements in your layout. Use Container’s top and left arguments to position the elements in a stack.

def absolutely_positioned_elements(): # Positioning containers with relative location values requires # absolute size for the Stack assistant = Assistant() assistant.open_stack(height=360, width=360) assistant.open_container(width=64, height=64, location=Center) assistant.add_text("center") assistant.close_container() assistant.open_container(width=64, height=64, location=TopRight) assistant.add_text("top right") assistant.close_container() assistant.open_container(width=64, height=64, location=BottomRight) assistant.add_text("bottom right") assistant.close_container() assistant.close_stack() assistant.run_dialog()

method refresh_dialog

refresh_dialog()

Can be used to update UI elements when adding elements while dialog is running


method run_dialog

run_dialog(timeout: int = 180, title: str = 'Assistant', height: Union[int, typing_extensions.Literal[AUTO]] = 'AUTO', width: int = 480, on_top: bool = False, location: Optional[Union[WindowLocation, Tuple[int, int]]] = None)

Create a dialog from all the defined elements and block until the user has handled it.

Parameters
  • timeout – Time to wait for dialog to complete, in seconds
  • title – Title of dialog
  • height – Height of dialog (in pixels or ‘AUTO’)
  • width – Width of dialog (in pixels)
  • on_top – Show dialog always on top of other windows
  • location – Where to place the dialog (options are Center, TopLeft, or a tuple of ints)

If the location argument is None it will let the operating system place the window.

Returns a result object with all input values.

When the dialog closes elements are cleared.

Examples

def open_dialog(): assistant = Assistant() assistant.add_heading("Please enter your username") assistant.add_text_input("username") result = assistant.run_dialog() print("The username is: ", result.username)

method set_title

set_title(title: str)

Set dialog title when it is running.