Robot Framework PythonLibCore

Warnings

• breaking Python 3.7 support was dropped in PythonLibCore v4.2.0. Users on Python 3.7 must either upgrade their Python version or use an older version of `robotframework-pythonlibcore`.
  Fix: Upgrade to Python 3.8 or newer, or pin `robotframework-pythonlibcore` to `<4.2.0`.
• breaking Major Robot Framework versions require specific `pythonlibcore` compatibility. For instance, v3.0.0 dropped support for Robot Framework 3.1 and addressed issues with Robot Framework 4 and `typing.Union`. Version 4.3.0 added support for Robot Framework 7.0, and v4.5.0 supports Robot Framework 6.1 and newer.
  Fix: Always check the release notes for `robotframework-pythonlibcore` to ensure compatibility with your Robot Framework version. Upgrade or downgrade `robotframework-pythonlibcore` as needed.
• gotcha Prior to v4.4.1, a bug could cause custom keyword names defined via the `@keyword` decorator to 'leak', potentially leading to unexpected keyword resolution or conflicts.
  Fix: Upgrade to `robotframework-pythonlibcore` version 4.4.1 or newer to avoid this issue.
• gotcha Incorrect library import paths in Robot Framework are a common source of 'No keyword with name X found' errors. When importing a Python class-based library, ensure the import path correctly points to the module or class.
  Fix: If your library is in `mylibrary.py` and the class is `MyLibrary`, import it as `Library mylibrary.MyLibrary` or ensure `mylibrary.py` is directly in the Python module search path and can be imported as `Library mylibrary` (where the module's `__init__.py` or the module itself exposes `MyLibrary`).
• gotcha When developing a dynamic library with PythonLibCore, prefer inheriting `DynamicCore` (or `HybridCore`) and using the `@keyword` decorator on methods within your component classes. Avoid manually implementing `get_keyword_names()` and `run_keyword()` if you are using PythonLibCore's keyword discovery mechanism, as this can lead to keywords not being registered or found.
  Fix: Let `DynamicCore` handle keyword discovery by decorating methods with `@keyword` and passing component instances to `DynamicCore.__init__`.
• gotcha Version 4.5.0 includes a bug fix to avoid 'maximum recursion depth exceeded' errors on `getattr`. If you encounter this error in older versions, it might be related to this known issue.
  Fix: Upgrade to `robotframework-pythonlibcore` version 4.5.0 or newer.

Install

• pip install robotframework-pythonlibcore Install latest version

Imports

• DynamicCore

  from robotlibcore import DynamicCore

• HybridCore

  from robotlibcore import HybridCore

• keyword

  from robotlibcore import keyword

  While `robot.api.deco.keyword` also exists, `robotlibcore.keyword` is the intended decorator when building libraries with PythonLibCore, as it integrates seamlessly with its internal mechanisms.

Quickstart

This example demonstrates creating a Robot Framework test library using `DynamicCore` from `robotlibcore`. It defines two separate classes (`LibraryComponent1`, `LibraryComponent2`) that contain keywords, decorated with `@keyword`. These components are then passed to the `DynamicCore`'s constructor in the main `MyLibrary` class. It also shows a keyword directly implemented in the main library class.

from robotlibcore import DynamicCore, keyword

class LibraryComponent1:
    @keyword
    def my_first_keyword(self, arg):
        print(f"Executing My First Keyword with: {arg}")
        return f"Processed: {arg}"

class LibraryComponent2:
    @keyword('Custom Name Keyword')
    def another_keyword(self, value):
        print(f"Executing Another Keyword with value: {value}")
        return f"Custom handled: {value}"

class MyLibrary(DynamicCore):
    """Example Robot Framework library using PythonLibCore."""

    ROBOT_LIBRARY_SCOPE = 'TEST SUITE'

    def __init__(self):
        # Pass instances of classes containing keywords to DynamicCore
        libraries = [LibraryComponent1(), LibraryComponent2()]
        DynamicCore.__init__(self, libraries)

    @keyword
    def keyword_in_main_library(self, data):
        """A keyword directly in the main library class."""
        print(f"Keyword in main library received: {data}")
        return data.upper()

# To use this library in Robot Framework:
# *** Settings ***
# Library    MyLibrary.py
#
# *** Test Cases ***
# Example Test
#     ${result1}=    My First Keyword    hello
#     Log To Console    ${result1}
#     ${result2}=    Custom Name Keyword    world
#     Log To Console    ${result2}
#     ${result3}=    Keyword In Main Library    pythonlibcore
#     Log To Console    ${result3}