RPA Framework

Introduction 

RPA Framework is a collection of open-source libraries and tools for Robotic Process Automation (RPA), and it is designed to be used with both Robot Framework and Python. The goal is to offer well-documented and actively maintained core libraries for Software Robot Developers.

Learn more about RPA at Robocorp Documentation.

The project is:

100% Open Source
Sponsored by Robocorp
Optimized for Robocorp Control Room and Developer Tools
Accepting external contributions

Links

Homepage: https://www.github.com/robocorp/rpaframework/
Documentation: https://rpaframework.org/
PyPI: https://pypi.org/project/rpaframework/
Release notes: https://rpaframework.org/releasenotes.html
RSS feed: https://rpaframework.org/releases.xml

Packages 

From the above packages, rpaframework-core and rpaframework-recognition are support packages, which alone do not contain any libraries.

Libraries 

The RPA Framework project currently includes the following libraries:

The x in the PACKAGE column means that library is included in the rpaframework package and for example. x,pdf means that RPA.PDF library is provided in both the rpaframework and rpaframework-pdf packages.

LIBRARY NAME	DESCRIPTION	PACKAGE
Archive	Archiving TAR and ZIP files	x
Assistant	Display information to a user and request input.	assistant
Browser.Selenium	Control browsers and automate the web	x
Browser.Playwright	Newer way to control browsers	special (more below)
Calendar	For date and time manipulations	x
Cloud.AWS	Use Amazon AWS services	x,aws
Cloud.Azure	Use Microsoft Azure services	x
Cloud.Google	Use Google Cloud services	google
Crypto	Common hashing and encryption operations	x
Database	Interact with databases	x
Desktop	Cross-platform desktop automation	x
Desktop.Clipboard	Interact with the system clipboard	x
Desktop.OperatingSystem	Read OS information and manipulate processes	x
DocumentAI	Intelligent Document Processing wrapper	x
DocumentAI.Base64AI	Intelligent Document Processing service	x
DocumentAI.Nanonets	Intelligent Document Processing service	x
Email.Exchange	E-Mail operations (Exchange protocol)	x
Email.ImapSmtp	E-Mail operations (IMAP & SMTP)	x
Excel.Application	Control the Excel desktop application	x
Excel.Files	Manipulate Excel files directly	x
FileSystem	Read and manipulate files and paths	x
FTP	Interact with FTP servers	x
HTTP	Interact directly with web APIs	x
Hubspot	Access HubSpot CRM data objects	hubspot
Images	Manipulate images	x
JavaAccessBridge	Control Java applications	x
JSON	Manipulate JSON objects	x
MFA	Authenticate using one-time passwords (OTP) & OAuth2	x
MSGraph	Access Microsoft 365 via the Microsoft Graph API	x
Notifier	Notify messages using different services	x
OpenAI	Artificial Intelligence service	openai
Outlook.Application	Control the Outlook desktop application	x
PDF	Read and create PDF documents	x,pdf
Robocorp.Process	Use the Robocorp Process API	x
Robocorp.WorkItems	Use the Robocorp Work Items API	x
Robocorp.Vault	Use the Robocorp Secrets API	x
Robocorp.Storage	Use the Robocorp Asset Storage API	x
Salesforce	Salesforce operations	x
SAP	Control SAP GUI desktop client	x
Slack	Send messages and interact with Slack workspaces	x
Smartsheet	Access Smartsheet sheets	x
Tables	Manipulate, sort, and filter tabular data	x
Tasks	Control task execution	x
Twitter	Twitter API interface	x
Windows	Alternative library for Windows automation	x,windows
Word.Application	Control the Word desktop application	x

Installation of RPA.Browser.Playwright 

The RPA.Browser.Playwright at the moment requires special installation, because of the package size and the post install step it needs to be fully installed.

Minimum required conda.yaml to install Playwright:

channels:
  - conda-forge
dependencies:
  - python=3.10.14
  - nodejs=22.9.0
  - pip=24.0
  - pip:
    - robotframework-browser==18.8.1
    - rpaframework==31.1.2
rccPostInstall:
  - rfbrowser init

Installation 

Learn about installing Python packages at Installing Python Packages.

Default installation method with Robocorp Developer Tools using conda.yaml:

channels:
  - conda-forge
dependencies:
  - python=3.10.14
  - pip=24.0
  - pip:
    - rpaframework==31.1.2

To install all extra packages (including Playwright dependencies), you can use:

channels:
  - conda-forge
dependencies:
  - python=3.10.14
  - tesseract=5.4.1
  - nodejs=22.9.0
  - pip=24.0
  - pip:
    - robotframework-browser==18.8.1
    - rpaframework==31.1.2
    - rpaframework-aws==5.3.3
    - rpaframework-google==9.0.2
    - rpaframework-recognition==5.2.5
rccPostInstall:
  - rfbrowser init

Separate installation of AWS, PDF and Windows libraries without the main rpaframework:

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

Installation method with pip using Python venv:

python -m venv .venv
source .venv/bin/activate
pip install rpaframework

Note

Python 3.9.2 or higher is required (tested up to 3.13)

Example 

After installation the libraries can be directly imported inside Robot Framework:

*** Settings ***
Library    RPA.Browser.Selenium

*** Tasks ***
Login as user
    Open available browser    https://example.com
    Input text    id:user-name    ${USERNAME}
    Input text    id:password     ${PASSWORD}

The libraries are also available inside Python:

from RPA.Browser.Selenium import Selenium

lib = Selenium()

lib.open_available_browser("https://example.com")
lib.input_text("id:user-name", username)
lib.input_text("id:password", password)

Here is another example showing how to read an Excel file and filter rows using `RPA.Excel.Files`_ and `RPA.Tables`_ together:

*** Settings ***
Library    RPA.Excel.Files
Library    RPA.Tables

*** Tasks ***
Filter active employees
    Open workbook    employees.xlsx
    ${table}=    Read worksheet as table    header=True
    Close workbook
    ${active}=    Filter table by column    ${table}    Status    ==    Active
    Log    Found ${active.size} active employees

And the same example in Python:

from RPA.Excel.Files import Files
from RPA.Tables import Tables

excel = Files()
tables = Tables()

excel.open_workbook("employees.xlsx")
table = excel.read_worksheet_as_table(header=True)
excel.close_workbook()

active = tables.filter_table_by_column(table, "Status", "==", "Active")
print(f"Found {active.size} active employees")

Support and contact 

rpaframework.org for library documentation
Robocorp Documentation for guides and tutorials
#rpaframework channel in Robot Framework Slack if you have open questions or want to contribute
Communicate with your fellow Software Robot Developers and Robocorp experts at Robocorp Developers Slack

Contributing 

Found a bug? Missing a critical feature? Interested in contributing? Head over to the Contribution guide to see where to get started.

Development 

Repository development is Python based and requires Python 3.9.2 or higher (tested up to 3.13) installed on the development machine. Python 3.10.14 is the default version used in the Robocorp Robot template and is a solid choice. Versions 3.7.6 and 3.8.1 are known to have issues with some dependencies and are not supported.

Repository development tooling is based on uv and invoke. uv is used for dependency management, building and running the package. Invoke is used for scripting purposes, for example for linting, testing and publishing tasks.

Before writing any code, please read and acknowledge our extensive Dev Guide.

First steps to start developing:

Install uv (see uv installation docs)
git clone the repository
create a new Git branch or switch to correct branch or stay in master branch
- branch naming conventions: feature/name-of-feature, hotfix/name-of-the-issue, release/number-of-release
uv sync — installs the package and its dependencies into the .venv directory
if testing against Robocorp Robot which is using devdata/env.json:
- set environment variables
- or uv build and use the resulting .whl file (in the dist/ directory) in the Robot conda.yaml
- or push the .whl to a repository and reference the raw URL in conda.yaml
uv run python -m robot <ROBOT_ARGS> <TARGET_ROBOT_FILE>
- common ROBOT_ARGS from Robocorp Robot template: --report NONE --outputdir output --logtitle "Task log"
uv run python <TARGET_PYTHON_FILE>
invoke lint to make sure that code formatting follows rpaframework repository guidelines. Formatting is based on black and flake8 and those are run with invoke lint.

Library documentation can be generated from the repository root (the “meta” package level). Local changes to the main package are reflected automatically. For optional packages, use invoke install-local --package <package_name> (e.g. rpaframework-aws) to install them as editable versions. Reset with invoke install --reset.

uv sync and/or invoke install-local --package <package name>
make docs
open docs/build/html/index.html in a browser, or run make local and navigate to localhost:8000 for a live preview.

# Before
[tool.uv.sources]
rpaframework = { path = "packages/main", extras = ["cv", "playwright", "aws"] }
rpaframework-google = { version = "^4.0.0" }
rpaframework-windows = { version = "^4.0.0" }

# After
[tool.uv.sources]
rpaframework = { path = "packages/main", extras = ["cv", "playwright"] }
rpaframework-aws = { path = "packages/aws" }
rpaframework-google = { version = "^4.0.0" }
rpaframework-windows = { version = "^4.0.0" }

invoke test (runs both Python unittests and Robot Framework tests in the package tests/ directory)
- to run a specific Python test: uv run pytest path/to/test.py::test_function
- to run a specific Robot Framework test: inv testrobot -r <robot_name> -t <task_name>
git commit changes
git push changes to remote
create a pull request from the branch describing the changes in the description
update docs/source/releasenotes.rst with changes (commit and push)

Packaging and publishing are done after changes have been merged into master branch. All the following steps should be done within master branch.

git pull latest changes into master branch
in the package directory containing changes execute invoke lint and invoke test
update pyproject.toml with new version according to semantic versioning
update docs/source/releasenotes.rst with changes
in the repository root (so called “meta” package level) run command uv sync
git commit changed uv.lock files (on meta and target package level), releasenotes.rst and pyproject.toml with message “PACKAGE. version x.y.z”
git push
invoke publish after Github action on master branch is all green

Some recommended tools for development

Visual Studio Code as a code editor with following extensions:
GitHub Desktop will make version management less prone to errors

License 

This project is open-source and licensed under the terms of the Apache License 2.0.