RPA Framework

https://rpaframework.org
Admin
RPA Framework is a collection of open-source libraries and tools for Robotic Process Automation,...
Tokens:572,188
Snippets:6,095
Trust Score:7.4
Update:3 months ago
Show doc for...
Tokens:
Raw
### Initialize Netsuite and Get Data in Python

Source: https://rpaframework.org/libdoc/RPA_Netsuite.html

Basic Python example showing how to initialize the Netsuite library and connect, then retrieve account and currency data.

```Python
from RPA.Netsuite import Netsuite

ns = Netsuite()
ns.connect()
accounts = ns.get_accounts()
currencies = ns.get_currencies()


```

--------------------------------

### Connect to Database with Credentials

Source: https://rpaframework.org/libdoc/RPA_Database.html

Connects to a database using specified credentials and module. This example shows a direct connection setup.

```Robot Framework
Connect To Database  pymysql  database  username  password  host  port
```

--------------------------------

### Python Example: Connect and Get Netsuite Data

Source: https://rpaframework.org/libraries/netsuite/python.html

A basic Python snippet showing how to initialize the Netsuite library, connect to the service, and retrieve account and currency data.

```python
from RPA.Netsuite import Netsuite

ns = Netsuite()
ns.connect()
accounts = ns.get_accounts()
currencies = ns.get_currencies()

```

--------------------------------

### Example: Asserting OK Response

Source: https://rpaframework.org/libdoc/RPA_HTTP.html

Demonstrates using GET to retrieve a response and then asserting it is a 200 OK using Status Should Be and checking the reason phrase.

```robotframework
*** Test Cases ***


Test Get Request And Make Sure Is OK
    ${resp}= GET Custom Keyword That Returns OK or ERROR Response    case=pass
    Status Should Be    200    ${resp}
    Should Be Equal As Strings    OK    ${resp.reason}
```

--------------------------------

### Robot Framework Example: Open and Interact with Calculator

Source: https://rpaframework.org/libdoc/RPA_Desktop_Windows.html

Demonstrates opening the Calculator application using the 'Open using run dialog' keyword, sending keys for a calculation, and retrieving/validating the result. It also shows how to get window elements, specific elements by name or ID, and check element visibility and enabled state.

```Robot Framework
*** Settings ***
Library          RPA.Desktop.Windows
Suite Teardown   Close all applications

*** Tasks ***
Open Calculator using run dialog
    ${result}=              Open using run dialog    calc.exe   Calculator
    ${result}=              Get Window Elements
    Send Keys               5*2=
    ${result}=              Get element             partial name:Display is
    Log Many                ${result}
    ${result}=              Get element rich text   id:CalculatorResults
    Should Be Equal As Strings  ${result}  Display is 10
    ${result}=              Get element rectangle   partial name:Display is
    ${result}=              Is Element Visible      CalculatorResults
    ${result}=              Is Element Enabled      partial name:Display is

```

--------------------------------

### Example: Asserting 404 Response

Source: https://rpaframework.org/libdoc/RPA_HTTP.html

Demonstrates using GET to retrieve a response and then asserting it is a 404 Not Found using Status Should Be and checking the reason phrase.

```robotframework
*** Test Cases ***


Test Get Request And Make Sure Is A 404 Response
    ${resp}= GET Custom Keyword That Returns OK or ERROR Response    case=notfound
    Status Should Be    404    ${resp}
    Should Be Equal As Strings    NOT FOUND    ${resp.reason}
```

--------------------------------

### Get Work Item Variables (Python)

Source: https://rpaframework.org/libdoc/RPA_Robocorp_WorkItems.html

Python example demonstrating how to initialize the WorkItems library, get an input work item, and retrieve its variables. Note that the library does not implicitly load the first work item in Python.

```python
import logging
from RPA.Robocorp.WorkItems import WorkItems

def list_variables(item_id):
    library = WorkItems()
    library.get_input_work_item()

    variables = library.get_work_item_variables()
    for variable, value in variables.items():
        logging.info("%s = %s", variable, value)

```

--------------------------------

### Start Process with Work Items and Files (Robot Framework)

Source: https://rpaframework.org/libdoc/RPA_Robocorp_Process.html

Creates a work item with associated files and starts a process. Requires 'ProcessAPI' secret configuration and uses 'Create Input Work Item' and 'Start Configured Process' keywords.

```Robot Framework
*** Tasks ***
Start process with work items
    [Setup]   Initialize Process Library
    &{data}=  Create Dictionary  fname=Mark   lname=Monkey
    @{files}=  Create List
    ...   ${CURDIR}${/}workdata.xlsx
    ...   ${CURDIR}${/}other.csv
    ${item_id}=    Create Input Work Item
    ...   payload=${data}
    ...   files=${files}
    Start Configured Process
    ...  config_type=work_items
    ...  extra_info=${item_id}

```

--------------------------------

### Python Example: Open and Interact with Calculator

Source: https://rpaframework.org/libdoc/RPA_Desktop_Windows.html

Provides a Python implementation using the RPA.Desktop.Windows library to open the Calculator, perform a calculation by sending keys, and retrieve the result. Includes setup, function definitions for opening and calculating, and a main execution block.

```Python
from RPA.Desktop.Windows import Windows

win = Windows()

def open_calculator():
    win.open_from_search("calc.exe", "Calculator")
    elements = win.get_window_elements()

def make_calculations(expression):
    win.send_keys(expression)
    result = win.get_element_rich_text('id:CalculatorResults')
    return int(result.strip('Display is '))

if __name__ == "__main__":
    open_calculator()
    exp = '5*2='
    result = make_calculations(exp)
    print(f"Calculation result of '{exp}' is '{result}'")
    win.close_all_applications()

```

--------------------------------

### Start Configured Process

Source: https://rpaframework.org/libdoc/RPA_Robocorp_Process.html

Starts a Control Room process with the provided configuration.

```APIDOC
## Start Configured Process

### Description
Start a Control Room process with the provided configuration.

### Parameters
#### Query Parameters
- **config_type** (ConfigurationType) - Optional - Type of the start, defaults to ConfigurationType.default.
- **extra_info** (str | List | None) - Optional - Data to be sent with the start, for example, work item IDs.
- **process_id** (str) - Optional - Specific process to start.

### Return Type
str

### Response Example
```json
{
  "example": "string of the request response"
}
```
```

--------------------------------

### Install rpaframework-aws and rpaframework

Source: https://rpaframework.org/libdoc/RPA_Cloud_AWS.html

Recommended installation of the AWS library and the main framework package. Ensure to check for the latest versions on the rpaframework Github repository.

```yaml
channels:
  - conda-forge
dependencies:
  - python=3.7.5
  - pip=20.1
  - pip:
    - rpaframework==13.0.2
    - rpaframework-aws==1.0.3

```

--------------------------------

### Use Variables from Input Work Item (Robot Framework)

Source: https://rpaframework.org/libdoc/RPA_Robocorp_WorkItems.html

Robot Framework example showing how to access variables previously set in an input work item. The input item is loaded implicitly when the suite starts.

```robotframework
*** Settings ***
Library    RPA.Robocorp.WorkItems

*** Tasks ***
Use variables from Control Room
    Set task variables from work item
    Log    Variables are now available: s${user}, ${mail}

```

--------------------------------

### Install Local Package for Development

Source: https://rpaframework.org/index.html

Install an optional package, such as `rpaframework-aws`, as an editable version for local development using invoke.

```bash
invoke install-local --package <package_name>
```

--------------------------------

### Interacting with Swing Application Elements (Robot Framework)

Source: https://rpaframework.org/libraries/javaaccessbridge/python.html

This example demonstrates how to automate interactions with a Swing application using the Java Access Bridge library in Robot Framework. It covers starting the application, selecting a window, typing text into elements, and clicking buttons.

```robotframework
*** Settings ***
Library   RPA.JavaAccessBridge
Library   Process

*** Tasks ***
Write text into Swing application
    Start Process    java -jar BasicSwing.jar
    ...              shell=${TRUE}
    ...              cwd=${CURDIR}
    Select Window    Chat Frame
    Type Text    role:text
    ...          text for the textarea
    Type Text    role:text
    ...          text for the input field
    ...          index=1
    ...          clear=${TRUE}
    Click Element    role:push button and name:Send
```

--------------------------------

### Separate Installation of AWS, PDF, and Windows Libraries

Source: https://rpaframework.org/index.html

Installs AWS, PDF, and Windows libraries separately without the main rpaframework. Useful for specific needs.

```yaml
channels:
  - conda-forge
dependencies:
  - python=3.10.14
  - pip=24.0
  - pip:
    - Rpaframework-aws==5.3.3  # included in the rpaframework as an extra
    - Rpaframework-pdf==7.3.3  # included in the rpaframework by default
    - Rpaframework-windows==7.5.2  # included in the rpaframework by default

```

--------------------------------

### Azure Initialization and Service Setup

Source: https://rpaframework.org/libraries/cloud_azure/python.html

Demonstrates how to initialize the Azure library and specific services using environment variables or Robocorp Vault for authentication.

```APIDOC
## Initialization with Environment Variables

### Description
Initializes Azure services using subscription keys provided via environment variables.

### Method
`RPA.Cloud.Azure.Azure()`

### Parameters
None (relies on environment variables like `AZURE_TEXTANALYTICS_KEY` or `AZURE_SUBSCRIPTION_KEY`)

### Robot Framework Example
```robotframework
*** Settings ***
Library   RPA.Cloud.Azure

*** Tasks ***
Init Azure services
    Init Text Analytics Service
```

## Initialization with Robocorp Vault

### Description
Initializes Azure services using secrets stored in Robocorp Vault.

### Method
`RPA.Cloud.Azure.Azure(robocorp_vault_name='azure')` or `Set Robocorp Vault` keyword.

### Parameters
- `robocorp_vault_name` (str, optional): The name of the Robocorp Vault to use.
- `use_robocorp_vault` (bool, optional): Set to `${TRUE}` to use the vault.

### Robot Framework Example (Library Init)
```robotframework
*** Settings ***
Library   RPA.Cloud.Azure  robocorp_vault_name=azure

*** Tasks ***
Init Azure services
    Init Text Analytics Service  use_robocorp_vault=${TRUE}
```

### Robot Framework Example (Set Robocorp Vault Keyword)
```robotframework
*** Settings ***
Library   RPA.Cloud.Azure

*** Tasks ***
Init Azure services
    Set Robocorp Vault          vault_name=googlecloud
    Init Text Analytics Service  use_robocorp_vault=${TRUE}
```
```

--------------------------------

### Get value from JSON (Robot Framework - Extended)

Source: https://rpaframework.org/libdoc/RPA_JSON.html

This example demonstrates retrieving a specific value from a complex JSON structure using a JSONPath expression with filtering. It includes setup for the JSON data and assertions.

```robotframework
*** Settings ***
Library         RPA.JSON
Suite Setup     Ingest JSON

*** Variables ***
${JSON_STRING}      {
...                   "clients": [
...                     {
...                       "name": "Johnny Example",
...                       "email": "john@example.com",
...                       "orders": [
...                         {"address": "Streetroad 123", "state": "TX", "price": 103.20, "id":"guid-001"},
...                         {"address": "Streetroad 123", "state": "TX", "price": 98.99, "id":"guid-002"}
...                       ]
...                     },
...                     {
...                       "name": "Jane Example",
...                       "email": "jane@example.com",
...                       "orders": [
...                         {"address": "Waypath 321", "state": "WA", "price": 22.00, "id":"guid-003"},
...                         {"address": "Streetroad 123", "state": "TX", "price": 2330.01, "id":"guid-004"},
...                         {"address": "Waypath 321", "state": "WA", "price": 152.12, "id":"guid-005"}
...                       ]
...                     }
...                   ]
...                 }
${ID}               guid-003

*** Tasks ***
Get email for specific order id
    ${email}=    Get value from json    ${JSON_DOC}    $.clients[?(@..id=="${ID}")].email
    Log    
OUTPUT IS
 ${email}    console=${True}
    Should be equal as strings    ${email}    jane@example.com

*** Keywords ***
Ingest JSON
    ${doc}=    Convert string to json    ${JSON_STRING}
    Set suite variable    ${JSON_DOC}    ${doc}

```

--------------------------------

### Get Table Slice

Source: https://rpaframework.org/libdoc/RPA_Tables.html

Return a new Table from a range of given Table rows. If `start` is not defined, starts from the first row. If `end` is not defined, stops at the last row.

```robotframework
# Get all rows except first five
${slice}=    Get table slice    ${table}    start=5
```

```robotframework
# Get rows at indexes 5, 6, 7, 8, and 9
${slice}=    Get table slice    ${table}    start=5    end=10
```

```robotframework
# Get all rows except last five
${slice}=    Get table slice    ${table}    end=-5
```

--------------------------------

### Robot Framework: Initialize Storage, Create Bucket, Upload File, and List Files

Source: https://rpaframework.org/libdoc/RPA_Cloud_Google.html

Demonstrates how to initialize the storage service, create a new bucket, upload a file, and then list all files within that bucket using Robot Framework. Requires a service account JSON file for authentication.

```robotframework
*** Settings ***
Library   RPA.Cloud.Google

*** Variables ***
${SERVICE_ACCOUNT}    ${/}path${/}to${/}service_account.json
${BUCKET_NAME}            testbucket12213123123

*** Tasks ***
Upload a file into a new storage bucket
    [Setup]   Init Storage    ${SERVICE_ACCOUNT}
    Create Storage Bucket    ${BUCKET_NAME}
    Upload Storage File      ${BUCKET_NAME}
    ...   ${/}path${/}to${/}file.pdf
    ...   myfile.pdf
    @{files}         List Storage Files   ${BUCKET_NAME}
    FOR   ${file}  IN   @{files}
        Log  ${file}
    END

```

--------------------------------

### Connect to Database using Configuration File

Source: https://rpaframework.org/libraries/database/python.html

Demonstrates connecting to a database using a configuration file with `Connect To Database`. The example shows how to specify host, port, and SSL-related parameters within the config file.

```Robot Framework
Connect To Database  pymysql  database  username  password  host  port
Connect To Database  ${CURDIR}${/}resources${/}dbconfig.cfg

${secrets}=    Get Secret    azuredb
Connect To Database
...    mysql.connector
...    password=${secrets}[password] 
...    config_file=${CURDIR}${/}azure.cfg


```

--------------------------------

### Get Cell History

Source: https://rpaframework.org/libraries/smartsheet/python.html

Retrieves the history of a cell in a row of the current sheet. Supports both Robot Framework and Python examples.

```APIDOC
## Get Cell History

### Description
Retrieves the history of a cell in a row of the current sheet.

### Method Signature
`get_cell_history(_row : int | Row_, _column : int | str | Column_) -> List[Cell] | None`

### Parameters
*   **row** (int | Row_) - The row ID, row number, or a Row object.
*   **column** (int | str | Column_) - The column ID or title.

### Python Example
```python
ss = Smartsheet(access_token=access_token)
cell_history = ss.get_cell_history(1, "Approval")
for revision in cell_history:
    print(f"Modified by {revision.modified_by.email}")
```
```

--------------------------------

### Database Configuration File Example

Source: https://rpaframework.org/libdoc/RPA_Database.html

An example of a configuration file for database connections, specifying host, port, username, database, client flags, and SSL settings.

```INI
[default]
host=hostname.mysql.database.azure.com
port=3306
username=username@hostname
database=databasename
client_flags=SSL,FOUND_ROWS
ssl_ca=DigiCertGlobalRootG2.crt.pem

```

--------------------------------

### Get Browser Ids Example

Source: https://rpaframework.org/libdoc/RPA_Browser_Selenium.html

Retrieves the indices of all active browsers. Useful for iterating through and managing multiple browser instances.

```Robot Framework
@{browser_ids}= | Get Browser Ids |  |
FOR | ${id} | IN | @{browser_ids}
| @{window_titles}= | Get Window Titles | browser=${id}
| Log | Browser ${id} has these windows: ${window_titles} |
END
```

--------------------------------

### Get Table Dimensions Example

Source: https://rpaframework.org/libdoc/RPA_Tables.html

Obtain the dimensions (number of rows and columns) of a table. The result is returned as a tuple of two integers.

```robotframework
${rows}  ${columns}=    Get table dimensions    ${table}
Log    Table has ${rows} rows and ${columns} columns.
```

--------------------------------

### Local File Work Item Example

Source: https://rpaframework.org/libdoc/RPA_Robocorp_WorkItems.html

An example of a local JSON file structure for a single input work item, including its payload and files.

```json
[
    {
        "payload": {
            "variable1": "a-string-value",
            "variable2": ["a", "list", "value"]
        },
        "files": {
            "file1": "path/to/file.ext"
        }
    }
]

```

--------------------------------

### Get Browser Aliases Example

Source: https://rpaframework.org/libdoc/RPA_Browser_Selenium.html

Retrieves aliases of active browsers. Useful for managing multiple browser instances with distinct names.

```Robot Framework
Open Browser | https://example.com | alias=BrowserA |
Open Browser | https://example.com | alias=BrowserB |
&{aliases} | Get Browser Aliases |  | # &{aliases} = { BrowserA=1|BrowserB=2 }
Log | ${aliases.BrowserA} |  | # logs `1`
FOR | ${alias} | IN | @{aliases}
| Log | ${alias} | # logs `BrowserA` and `BrowserB`
END
```

--------------------------------

### Open Browser and Manage Windows

Source: https://rpaframework.org/libdoc/RPA_Browser_Selenium.html

Demonstrates opening multiple browsers and windows, switching between them, and navigating to different URLs. Use aliases to manage different browser instances.

```Robot Framework
Open Browser | https://robotframework.org | ${BROWSER} | alias=BrowserA | # BrowserA with first window is opened.
Execute Javascript | window.open() |  |  | # In BrowserA second window is opened.
Switch Window | locator=NEW |  |  | # Switched to second window in BrowserA
Go To | https://robocon.io |  |  | # Second window navigates to robocon site.
Execute Javascript | window.open() |  |  | # In BrowserA third window is opened.
${handle} | Switch Window | locator=NEW |  | # Switched to third window in BrowserA
Go To | https://github.com/robotframework/ |  |  | # Third windows goes to robot framework github site.
Open Browser | https://github.com | ${BROWSER} | alias=BrowserB | # BrowserB with first windows is opened.
${location} | Get Location |  |  | # ${location} is: https://www.github.com
Switch Window | ${handle} | browser=BrowserA |  | # BrowserA second windows is selected.
${location} | Get Location |  |  | # ${location} = https://robocon.io/
@{locations 1} | Get Locations |  |  | # By default, lists locations under the currectly active browser (BrowserA).
@{locations 2} | Get Locations | browser=ALL |  | # By using browser=ALL argument keyword list all locations from all browsers.
```

--------------------------------

### Google Cloud Library Initialization and Basic Usage

Source: https://rpaframework.org/libraries/cloud_google/python.html

Demonstrates how to initialize the Google library and use basic functions like text detection and speech synthesis.

```APIDOC
## Python Initialization and Basic Usage

### Description
Initializes the Google library with a service account and demonstrates basic usage of Vision API for text detection and Text-to-Speech API for speech synthesis.

### Method
`Google()`

### Parameters
- `service_account` (str | None) - Path to the service account JSON file.
- `vault_name` (str | None) - Name of the vault.
- `vault_secret_key` (str | None) - Secret key for the vault.
- `cloud_auth_type` (str) - Type of cloud authentication, defaults to 'serviceaccount'.

### Initialization Examples
```python
from RPA.Cloud.Google import Google

library = Google()
service_account = '/path/to/service_account.json'

library.init_vision(service_account)
library.init_text_to_speech(service_account)

response = library.detect_text('imagefile.png', 'result.json')
library.synthesize_speech('I want this said aloud', target_file='said.mp3')
```
```

--------------------------------

### Get OAuth Token Example

Source: https://rpaframework.org/libdoc/RPA_Email_Exchange.html

Exchanges an authorization code for an access token. Requires the client secret and the response URL from the OAuth flow.

```Robot Framework
*** Tasks ***
Finish OAuth Flow
    ${token} =      Get OAuth Token
    ...     client_secret=GOCSPX-******mqZAW89
    ...     response_url=${resp_url}  # redirect of Generate OAuth URL


```

--------------------------------

### Desktop Class Initialization

Source: https://rpaframework.org/libraries/desktop/python.html

Initializes the Desktop library. Optionally, a path to a locator file can be provided.

```APIDOC
## _RPA.Desktop.Desktop

### Description
Initializes the Desktop library for cross-platform desktop automation.

### Parameters
*   **_locators_path** (str | None) - Optional path to a locator file.
```

--------------------------------

### Initialize RPA.Desktop Library (Python)

Source: https://rpaframework.org/libdoc/RPA_Desktop.html

Initialize the Desktop library instance in Python scripts.

```python
from RPA.Desktop import Desktop
desktop = Desktop()
```

--------------------------------

### Get Table Slice

Source: https://rpaframework.org/libraries/tables/python.html

Extract a subset of rows from a table based on start and end indices. Supports negative indexing and omitting start/end for full range.

```robotframework
# Get all rows except first five
${slice}=    Get table slice    ${table}    start=5

# Get rows at indexes 5, 6, 7, 8, and 9
${slice}=    Get table slice    ${table}    start=5    end=10

# Get all rows except last five
${slice}=    Get table slice    ${table}    end=-5
```

--------------------------------

### Robot Framework Example for Completion Create

Source: https://rpaframework.org/libdoc/RPA_OpenAI.html

Demonstrates how to use the Completion Create keyword in Robot Framework to generate a tagline for an ice cream shop. Sets a custom temperature.

```robotframework
*** Settings ***
Library    RPA.OpenAI

*** Tasks ***
Create Icecream Tagline
    ${response}  Completion Create
    ...     Write a tagline for an icecream shop.
    ...     temperature=0.6
    Log     ${response}
```

--------------------------------

### Get Table Row Examples

Source: https://rpaframework.org/libdoc/RPA_Tables.html

Retrieve an entire row from a table. By default, it returns the row as a dictionary, but can be configured to return a list using the 'as_list' argument.

```robotframework
# returns the first row in the table
${first}=    Get table row    ${orders}
```

```robotframework
# returns the last row in the table
${last}=      Get table row    ${orders}    -1    as_list=${TRUE}
```

--------------------------------

### Python Example for Completion Create

Source: https://rpaframework.org/libdoc/RPA_OpenAI.html

Shows how to use the completion_create function in Python to generate a tagline for an ice cream shop. A custom temperature is specified.

```python
from RPA.OpenAI import OpenAI

baselib = OpenAI()

result = baselib.completion_create(
    'Create a tagline for icecream shop',
    temperature=0.6,
)
print(result)
```

--------------------------------

### Manage Assets Task

Source: https://rpaframework.org/libdoc/RPA_Robocorp_Storage.html

Example of managing assets using the List Assets, Set Text Asset, Get Text Asset, and Delete Asset keywords.

```robotframework
*** Tasks ***
Manage Assets
    @{assets} =    List Assets
    Log List    ${assets}

    Set Text Asset    my-asset    My string asset value
    ${value} =      Get Text Asset       my-asset
    Log     Asset value: ${value}

    Delete Asset    my-asset

```

--------------------------------

### Java Locator Examples

Source: https://rpaframework.org/libraries/javaaccessbridge/python.html

Illustrates how to construct Java locators using 'name' and 'role' properties, including combining properties and using parent-child relationships.

```text
role:push button and name:Clear
```

```text
name:Find Purchase Orders > name:NumberField
```

--------------------------------

### Get Browser Logs

Source: https://rpaframework.org/libraries/browser_selenium/python.html

Fetches browser log entries, such as console output or performance events. Requires a Chromium-based browser and specific setup for performance logs.

```robotframework
Open Available Browser https://example.com browser_selection=Chrome headless=${True} |
Execute Javascript console.error(“boom”) |
${logs}= Get Browser Logs |
FOR ${entry} IN @{logs} |
Log ${entry}[level]: ${entry}[message] |
END |
```

```robotframework
Open Browser https://example.com | … options=set_capability(‘goog:loggingPrefs’, {‘performance’: ‘ALL’}) |
```

--------------------------------

### Get Java Elements and Interact (Robot Framework)

Source: https://rpaframework.org/libdoc/RPA_JavaAccessBridge.html

Retrieve Java elements using various locators and interact with them within Robot Framework. Examples demonstrate using `Get Elements` with `java_elements=True` and then interacting with the returned elements using keywords like `Click Element` and `Type Text`.

```Robot Framework
${elements}=    Get Elements
...    role:push button and name:Send
...    java_elements=True
Evaluate   $elements[0].click()
Click Element    ${elements}[0]    action=False
Type Text
...    ${elements}[0]
...    moretext
...    clear=True
...    typing=False
```

--------------------------------

### Create Output Work Items with Variables and Files (Robot Framework)

Source: https://rpaframework.org/libraries/robocorp_workitems/python.html

Robot Framework example for creating output work items with both variables and files in a single operation. It demonstrates setting variables and specifying a file path.

```Robot Framework
*** Tasks ***
Create and save output items with variables and files in one go
    ${customers} =  Load customer data
    FOR     ${customer}    IN    @{customers}
        &{customer_vars} =    Create Dictionary    id=${customer.id}
        ...     name=${customer.name}
        Create Output Work Item     variables=${customer_vars}
        ...     files=devdata${/}report.csv   save=${True}
    END

```

--------------------------------

### Get Computer Information with Robot Framework

Source: https://rpaframework.org/libdoc/RPA_Desktop_OperatingSystem.html

Demonstrates how to retrieve boot time, machine name, username, and memory statistics using the OperatingSystem library in Robot Framework. Ensure the library is imported in the Settings section.

```robotframework
*** Settings ***
Library    RPA.Desktop.OperatingSystem

*** Tasks ***
Get computer information
    ${boot_time}=   Get Boot Time  as_datetime=${TRUE}
    ${machine}=     Get Machine Name
    ${username}=    Get Username
    &{memory}=      Get Memory Stats
    Log Many        ${memory}

```

--------------------------------

### Get Matching Signatures in Python

Source: https://rpaframework.org/libdoc/RPA_DocumentAI_Base64AI.html

This Python snippet demonstrates how to use the `get_matching_signatures` method from the `Base64AI` library. It requires the library to be installed and image file paths as input.

```python
from RPA.DocumentAI.Base64AI import Base64AI

lib = Base64AI()
sigs = lib.get_matching_signatures(
    "driving-license.jpg", "signed-check.png"
)


```

--------------------------------

### Get Table Slice

Source: https://rpaframework.org/libdoc/RPA_Tables.html

Returns a new Table object containing a specified range of rows from the original Table. Supports slicing from the start, to the end, or a specific range.

```APIDOC
## Get Table Slice

### Description
Return a new Table from a range of given Table rows.
If `start` is not defined, starts from the first row. If `end` is not defined, stops at the last row.

### Arguments
* **table** (Table) - Table to read from
* **start** (int | str | None) - Optional - Start index (inclusive). Defaults to the first row if not defined.
* **end** (int | str | None) - Optional - End index (exclusive). Defaults to the last row if not defined.

### Return Type
Table | List[List]

### Examples
```robotframework
# Get all rows except first five
${slice}=    Get table slice    ${table}    start=5

# Get rows at indexes 5, 6, 7, 8, and 9
${slice}=    Get table slice    ${table}    start=5    end=10

# Get all rows except last five
${slice}=    Get table slice    ${table}    end=-5
```
```

--------------------------------

### Importing

Source: https://rpaframework.org/libdoc/RPA_Excel_Application.html

Initialize the library instance by wrapping the COM Windows app. Optionally, configure automatic exit.

```APIDOC
## Importing

### Description
Initialize the library instance by wrapping the COM Windows app.

### Arguments
* `args` ** `kwargs`
* `autoexit` (bool): Automatically close the app when the process finishes.

### Keyword Signature
`Importing(**kwargs)`
```

--------------------------------

### Start and Get Document Text Detection Results

Source: https://rpaframework.org/libdoc/RPA_Cloud_AWS.html

Initiates asynchronous document text detection and retrieves all results once analysis is complete. Requires Textract client initialization.

```robotframework
Init Textract Client  %{AWS_KEY_ID}  %{AWS_KEY_SECRET}  %{AWS_REGION}
${jobid}=    Start Document Text Detection  s3bucket_name  invoice.pdf
# Wait for job completion and collect all blocks
${response}=   Get Document Text Detection    ${jobid}  collect_all_results=True
# Model will contain all pages of the invoice.pdf
${model}=    Convert Textract Response To Model    ${response}
```

--------------------------------

### Create Output Work Item and Set Variables (Robot Framework)

Source: https://rpaframework.org/libdoc/RPA_Robocorp_WorkItems.html

Robot Framework example demonstrating how to create a new output work item and assign variables to it. Ensure to call 'Save Work Item' to persist changes.

```robotframework
*** Settings ***
Library    RPA.Robocorp.WorkItems

*** Tasks ***
Save variables to Control Room
    Create Output Work Item
    Set work item variables    user=Dude    mail=address@company.com
    Save Work Item

```

--------------------------------

### Get Browser Logs Example

Source: https://rpaframework.org/libdoc/RPA_Browser_Selenium.html

Retrieves JavaScript console logs from a Chromium-based browser. Ensure the browser is opened with appropriate settings if performance logs are needed.

```Robot Framework
Open Available Browser https://example.com browser_selection=Chrome headless=${True}
Execute Javascript console.error("boom")
${logs}= Get Browser Logs
FOR ${entry} IN @{logs}
Log ${entry}[level]: ${entry}[message]
END
```

```Robot Framework
Open Browser https://example.com
... options=set_capability('goog:loggingPrefs', {'performance': 'ALL'})
```

--------------------------------

### Create and Execute HubSpot Batch in Robot Framework

Source: https://rpaframework.org/libdoc/RPA_Hubspot.html

This Robot Framework example demonstrates how to create a new batch, add multiple company inputs, execute the batch, and log the IDs of the newly created companies. Ensure 'RPA.Hubspot' and 'RPA.Robocorp.Vault' libraries are imported and HubSpot authorization is set up.

```robotframework
*** Settings ***
Library         RPA.Hubspot
Library         RPA.Robocorp.Vault
Task Setup      Authorize Hubspot

*** Tasks ***
Create objects via batch
    Create new batch
    Add input to batch    name=Nokia    country=Finland
    Add input to batch    name=Google    country=USA
    ${new_companies}=    Execute batch
    Log    The first new company added has the new id ${{$new_companies[0].id}}

*** Keywords ***
Authorize Hubspot
    ${secrets}=    Get secret    hubspot
    Auth with api key    ${secrets}[API_KEY]

```

--------------------------------

### Get Pipeline Stages Example

Source: https://rpaframework.org/libraries/hubspot/python.html

Retrieves pipeline stages for a given object type and pipeline ID. It demonstrates how to use the stages to filter search results for deals.

```robotframework
*** Settings ***
Library         RPA.Hubspot
Library         RPA.Robocorp.Vault

Task Setup      Authorize Hubspot

*** Tasks ***
Use pipeline stages
    ${stages}=    Get pipeline stages    DEALS    Default
    ${closed_won_stage_id}=    Set variable    ${stages}[Closed Won][id]
    ${deals}=    Search for objects    DEALS
    ...    dealstage    EQ    ${closed_won_stage_id}
    Log    Deals that have been won: ${deals}

*** Keywords ***
Authorize Hubspot
    ${secrets}=    Get secret    hubspot
    Auth with api key    ${secrets}[API_KEY]
```

--------------------------------

### Initialize and Scan Documents with DocumentAI

Source: https://rpaframework.org/libraries/documentai/python.html

Demonstrates initializing different DocumentAI engines (Base64 AI and Nanonets) and scanning a document using each. It shows how to switch between engines and retrieve results.

```robotframework
*** Settings ***
Library    RPA.DocumentAI

*** Tasks ***
Scan Documents
    Init Engine    base64ai    vault=document_ai:base64ai
    Init Engine    nanonets    vault=document_ai:nanonets

    Switch Engine   base64ai
    Predict    invoice.png
    ${data} =    Get Result
    Log List    ${data}

    Switch Engine   nanonets
    Predict    invoice.png      model=858e4b37-6679-4552-9481-d5497dfc0b4a
    ${data} =    Get Result
    Log List    ${data}
```

--------------------------------

### Open Application by Name or Path

Source: https://rpaframework.org/libdoc/RPA_Desktop.html

Starts an application. It can be launched by its executable name if it's in the system's PATH, or by providing the full path to the executable. Command-line arguments can also be passed.

```Robot Framework
Open application    notepad.exe
```

```Robot Framework
Open application    c:\path\to\program.exe    --example-argument
```

--------------------------------

### Get Table Column Example

Source: https://rpaframework.org/libdoc/RPA_Tables.html

Extract all values from a specified column in a table and return them as a list. This is useful for collecting data from a single field across multiple records.

```robotframework
${emails}=    Get table column    ${users}    E-Mail Address
```

--------------------------------

### Connect to Database and Query Orders

Source: https://rpaframework.org/libraries/database/python.html

Example demonstrating how to connect to a database using Robot Framework and retrieve order data. It uses the `Connect To Database` and `Query` keywords.

```Robot Framework
*** Settings ***
Library         RPA.Database

*** Tasks ***
Get Orders From Database
    Connect To Database  pymysql  tester  user  password  127.0.0.1
    @{orders}            Query    Select * FROM incoming_orders
    FOR   ${order}  IN  @{orders}
        Handle Order  ${order}
    END


```

--------------------------------

### Upload File to S3 Bucket and List Files

Source: https://rpaframework.org/libdoc/RPA_Cloud_AWS.html

Example demonstrating how to upload a file to an S3 bucket and then list all files within that bucket. Requires S3 client initialization.

```robotframework
*** Settings ***
Library   RPA.Cloud.AWS   region=us-east-1

*** Variables ***
${BUCKET_NAME}        testbucket12213123123

*** Tasks ***
Upload a file into S3 bucket
    [Setup]   Init S3 Client
    Upload File      ${BUCKET_NAME}   ${/}path${/}to${/}file.pdf
    @{files}         List Files   ${BUCKET_NAME}
    FOR   ${file}  IN   @{files}
        Log  ${file}
    END

```

--------------------------------

### Get Current Work Item Example

Source: https://rpaframework.org/libdoc/RPA_Robocorp_WorkItems.html

Retrieves the currently active work item. This is useful for manually accessing the active item when it's not automatically set by other keywords.

```robotframework
*** Tasks ***
Example task
    ${input} =    Get Current Work Item
    ${output} =   Create Output Work Item
    Set Current Work Item    ${input}
```

--------------------------------

### Connect to Database and Query Orders in Python

Source: https://rpaframework.org/libraries/database/python.html

Python example for connecting to a database and querying orders using the RPA.Database library. It shows how to load secrets and establish a connection.

```Python
from RPA.Database import Database
from RPA.Robocorp.Vault import FileSecrets

filesecrets = FileSecrets("secrets.json")
secrets = filesecrets.get_secret("databasesecrets")

db = Database()
db.connect_to_database('pymysql',
                    secrets["DATABASE"],
                    secrets["USERNAME"],
                    secrets["PASSWORD"],
                    '127.0.0.1'
                    )
orders = db.query("SELECT * FROM incoming_orders")
for order in orders:
    print(order)


```

--------------------------------

### Get JSON Values - Python Example

Source: https://rpaframework.org/libdoc/RPA_JSON.html

Extracts specific values from a JSON object using a JSONPath expression in Python. Ensure the JSON object is correctly formatted.

```python
from RPA.JSON import JSON

# Get all the names for all people
people = {"People": [{"Name": "Mark"}, {"Name": "Jane"}]}
names = JSON().get_values_from_json(people, "$.People[*].Name")
print(second)

```

--------------------------------

### Get Work Item File Example

Source: https://rpaframework.org/libdoc/RPA_Robocorp_WorkItems.html

Downloads a specific file attached to a work item to the local disk. If no destination path is provided, it defaults to the current working directory.

```robotframework
*** Tasks ***
Example task
    ${path}=    Get work item file    input.xls
    Open workbook    ${path}
```

--------------------------------

### Touch File Example

Source: https://rpaframework.org/libdoc/RPA_FileSystem.html

Creates a new file or updates the modification and access times of an existing file.

```robotframework
Touch File    path/to/your/file.txt
```

--------------------------------

### Get Table Cell Examples

Source: https://rpaframework.org/libdoc/RPA_Tables.html

Retrieve a specific cell's value from a table using row and column indices or names. Negative indices can be used to access rows/columns from the end.

```robotframework
# Get the value in the first row and first column
Get table cell    ${table}    0    0
```

```robotframework
# Get the value in the last row and first column
Get table cell    ${table}   -1    0
```

```robotframework
# Get the value in the last row and last column
Get table cell    ${table}   -1    -1
```

```robotframework
# Get the value in the third row and column "Name"
Get table cell    ${table}    2    Name
```

--------------------------------

### Get Work Item Files Example

Source: https://rpaframework.org/libdoc/RPA_Robocorp_WorkItems.html

Downloads multiple files attached to a work item that match a given wildcard pattern. It returns a list of absolute paths to the downloaded files.

```robotframework
*** Tasks ***
Example task
    ${paths}=    Get work item files    customer_*.xlsx
    FOR  ${path}  IN  @{paths}
        Handle customer file    ${path}
    END
```

--------------------------------

### Start Document Analysis with Textract

Source: https://rpaframework.org/libraries/cloud_aws/python.html

This example shows how to initiate an asynchronous document analysis job using Textract and then retrieve the results. The `collect_all_results=True` argument ensures all blocks are fetched, and the response can be converted into a model.

```robotframework
Init Textract Client  %{AWS_KEY_ID}  %{AWS_KEY_SECRET}  %{AWS_REGION}
${jobid}=    Start Document Analysis  s3bucket_name  invoice.pdf
# Wait for job completion and collect all blocks
${response}=    Get Document Analysis  ${jobid}  collect_all_results=True
# Model will contain all pages of the invoice.pdf
${model}=    Convert Textract Response To Model    ${response}

```

--------------------------------

### Generate Library Documentation Locally

Source: https://rpaframework.org/index.html

Generate the library documentation and preview it locally. This involves running make commands and accessing a local web server.

```bash
make docs
make local
```

--------------------------------

### Get JSON Values - Robot Framework Example

Source: https://rpaframework.org/libdoc/RPA_JSON.html

Extracts specific values from a JSON object using a JSONPath expression in Robot Framework. Requires the 'Convert string to JSON' keyword for initial parsing.

```robotframework
*** Task ***
Get all the names for all people
    &{people}=    Convert string to JSON   {"People": [{"Name": "Mark"}, {"Name": "Jane"}]}
    @{names}=     Get values from JSON     ${people}   $.People[*].Name

```

--------------------------------

### Start and Get Textract Document Analysis Results

Source: https://rpaframework.org/libdoc/RPA_Cloud_AWS.html

Initiates an asynchronous document analysis job with Textract and retrieves the results. Use 'collect_all_results=True' to wait for completion and fetch all blocks. The response dictionary contains 'JobStatus'.

```python
Init Textract Client    %{AWS_KEY_ID}    %{AWS_KEY_SECRET}    %{AWS_REGION}
```

```python
${jobid}=    Start Document Analysis    s3bucket_name    invoice.pdf
```

```python
# Wait for job completion and collect all blocks
${response}=    Get Document Analysis    ${jobid}    collect_all_results=True
```

```python
# Model will contain all pages of the invoice.pdf
${model}=    Convert Textract Response To Model    ${response}
```

--------------------------------

### Import RPA.Windows Library

Source: https://rpaframework.org/libdoc/RPA_Windows.html

Demonstrates how to import the RPA.Windows library in a Robot Framework project.

```Robot Framework
*** Settings ***
Library    RPA.Windows
```

--------------------------------

### Mark Emails as Read/Unread (Robot Framework)

Source: https://rpaframework.org/libraries/outlook_application/python.html

Demonstrates how to mark emails as read or unread using the `Mark Email As Read` keyword. This requires a list of emails obtained, for example, via the `Get Emails` keyword.

```robotframework
${emails}=  Get Emails
# Mark all as read
FOR  ${email}  IN  @{emails}
    Mark Email As Read  ${email}
END

# Mark all as unread
FOR  ${email}  IN  @{emails}
    Mark Email As Read  ${email}  False
END

```

--------------------------------

### Process Class Initialization and Usage

Source: https://rpaframework.org/libraries/robocorp_process/python.html

Demonstrates how to initialize the Process library in Python and interact with Control Room work items, including listing and retrying failed items.

```APIDOC
## Process Class

### Description
A library for interacting with Control Room (CR) Process API endpoints. It allows for managing process runs, step runs, and work item states.

### Initialization
```python
from RPA.Robocorp.Process import Process
from RPA.Robocorp.Vault import Vault

secrets = Vault().get_secret("ProcessAPI")
process = Process(
    secrets["workspace_id"],
    secrets["process_id"],
    secrets["apikey"]
)
```

### Methods
#### `list_process_work_items()`
Lists all work items associated with the current process.

#### `retry_work_item(item_id: str)`
Retries a specific work item identified by its ID.

### Example Usage
```python

def retry_failed_items():
    items = process.list_process_work_items()
    for item in items:
        if item["state"] == "FAILED":
            print("FAILED work item: %s" % item["id"])
            result = process.retry_work_item(item["id"])
            print(result)

if __name__ == "__main__":
    retry_failed_items()
```
```

--------------------------------

### Get Current Work Item and Set Active Item

Source: https://rpaframework.org/libraries/robocorp_workitems/python.html

Example demonstrating how to retrieve the current work item and manually set the active work item. This is useful for explicit control over the work item context.

```Robot Framework
*** Tasks ***
Example task
    ${input} =    Get Current Work Item
    ${output} =   Create Output Work Item
    Set Current Work Item    ${input}

```

--------------------------------

### Computer Vision Service Example

Source: https://rpaframework.org/libraries/cloud_azure/python.html

Shows how to initialize the Computer Vision service and analyze an image using its URL.

```APIDOC
## Vision Analyze

### Description
Analyzes an image provided by a URL to extract visual features.

### Method
`Vision Analyze` (Robot Framework)
`library.vision_analyze()` (Python)

### Parameters
- `image_url` (str): The URL of the image to analyze.
- `visual_features` (str): A comma-separated string of features to extract (e.g., 'Faces,ImageType').

### Robot Framework Example
```robotframework
*** Settings ***
Library  RPA.Cloud.Azure

*** Variables ***
${IMAGE_URL}   IMAGE_URL
${FEATURES}    Faces,ImageType

*** Tasks ***
Visioning image information
   Init Computer Vision Service
   &{result}   Vision Analyze  image_url=${IMAGE_URL}  visual_features=${FEATURES}
   @{faces}    Set Variable  ${result}[faces]
   FOR  ${face}  IN   @{faces}
      Log  Age: ${face}[age], Gender: ${face}[gender], Rectangle: ${face}[faceRectangle]
   END
```

### Python Example
```python
library = Azure()
library.init_computer_vision_service()
response = library.vision_analyze(
   image_url=URL_TO_IMAGE,
   visual_features="Faces,ImageType",
)
meta = response['metadata']
print(
   f"Image dimensions {meta['width']}x{meta['height']} pixels"
)

for face in response["faces"]:
   left = face["faceRectangle"]["left"]
   top = face["faceRectangle"]["top"]
   width = face["faceRectangle"]["width"]
   height = face["faceRectangle"]["height"]
   print(f"Detected a face, gender:{face['gender']}, age: {face['age']}")
   print(f"      Face rectangle: (left={left}, top={top})")
   print(f"      Face rectangle: (width={width}, height={height})")
```
```

--------------------------------

### Get Email for Specific Order ID (Robot Framework)

Source: https://rpaframework.org/libraries/json/python.html

Retrieves the email address associated with a specific order ID from a nested JSON structure. This example demonstrates filtering within arrays using JSONPath.

```Robot Framework
*** Settings ***
Library         RPA.JSON
Suite Setup     Ingest JSON

*** Variables ***
${JSON_STRING}      {
...                   "clients": [
...                     {
...                       "name": "Johnny Example",
...                       "email": "john@example.com",
...                       "orders": [
...                         {"address": "Streetroad 123", "state": "TX", "price": 103.20, "id":"guid-001"},
...                         {"address": "Streetroad 123", "state": "TX", "price": 98.99, "id":"guid-002"}
...                       ]
...                     },
...                     {
...                       "name": "Jane Example",
...                       "email": "jane@example.com",
...                       "orders": [
...                         {"address": "Waypath 321", "state": "WA", "price": 22.00, "id":"guid-003"},
...                         {"address": "Streetroad 123", "state": "TX", "price": 2330.01, "id":"guid-004"},
...                         {"address": "Waypath 321", "state": "WA", "price": 152.12, "id":"guid-005"}
...                       ]
...                     }
...                   ]
...                 }
${ID}               guid-003

*** Tasks ***
Get email for specific order id
    ${email}=    Get value from json    ${JSON_DOC}    $.clients[?(@..id=="${ID}")].email
    Log    \nOUTPUT IS\n ${email}    console=${True}
    Should be equal as strings    ${email}    jane@example.com

*** Keywords ***
Ingest JSON
    ${doc}=    Convert string to json    ${JSON_STRING}
    Set suite variable    ${JSON_DOC}    ${doc}
```

--------------------------------

### Open Application

Source: https://rpaframework.org/libdoc/RPA_Desktop.html

Starts a specified application. Can be invoked by application name (if in system PATH) or by the full path to its executable. Supports passing command-line arguments.

```APIDOC
## Open Application

### Description
Start a given application by name (if in PATH), or by path to executable.

### Arguments
* **name_or_path** (str) - Name or path of application
* **args** (str *) - Command line arguments for application

### Return Type
Application

### Example:
```
Open application    notepad.exe
Open application    c:\path\to\program.exe    --example-argument
```
```
Tokens:
Raw