Support for translations

Author: aaltat

atest/SmallLibrary.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+from typing import Optional
+
+from robot.api import logger
+from robotlibcore import DynamicCore, keyword
+
+class SmallLibrary(DynamicCore):
+    """Library documentation."""
+
+    def __init__(self, translation: Optional[Path] = None):
+        """__init__ documentation."""
+        logger.warn(translation.absolute())
+        logger.warn(type(translation))
+        
+        DynamicCore.__init__(self, [], translation.absolute())
+
+    @keyword(tags=["tag1", "tag2"])
+    def normal_keyword(self, arg: int, other: str) -> str:
+        """I have doc
+        
+        Multiple lines.
+        Other line.
+        """
+        data = f"{arg} {other}"
+        print(data)
+        return data
+    
+    def not_keyword(self, data: str) -> str:
+        print(data)
+        return data
+    
+    @keyword(name="This Is New Name", tags=["tag1", "tag2"])
+    def name_changed(self, some: int, other: int) -> int:
+        """This one too"""
+        print(f"{some} {type(some)}, {other} {type(other)}")
+        return some + other

atest/tests_types.robot

@@ -1,6 +1,7 @@
 *** Settings ***
 Library     DynamicTypesLibrary.py
 Library     DynamicTypesAnnotationsLibrary.py    xxx
+Library     SmallLibrary.py    ${CURDIR}/translation.json
 
 
 *** Variables ***
@@ -115,6 +116,11 @@ Python 3.10 New Type Hints
 Keyword With Named Only Arguments
     Kw With Named Arguments    arg=1
 
+SmallLibray With New Name
+    ${data} =    SmallLibrary.Other Name    123   abc
+    Should Be Equal    ${data}    123 abc
+    ${data} =    SmallLibrary.name_changed_again    1   2
+    Should Be Equal As Integers    ${data}    3
 
 *** Keywords ***
 Import DynamicTypesAnnotationsLibrary In Python 3.10 Only

atest/translation.json

@@ -0,0 +1,11 @@
+{
+    "normal_keyword": {
+        "name": "other_name",
+        "doc": "This is new doc"
+    },
+    "name_changed": {
+        "name": "name_changed_again",
+        "doc": "This is also replaced.\n\nnew line."
+    }
+    
+}

requirements-dev.txt

@@ -12,3 +12,4 @@ rellu >= 0.7
 twine
 wheel
 typing-extensions >= 4.5.0
+approvaltests >= 11.1.1

src/robotlibcore.py

@@ -19,10 +19,13 @@
 https://github.com/robotframework/PythonLibCore
 """
 import inspect
+import json
 import os
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Callable, List, Optional, Union, get_type_hints
 
+from robot.api import logger
 from robot.api.deco import keyword  # noqa: F401
 from robot.errors import DataError
 from robot.utils import Importer
@@ -42,28 +45,47 @@ class NoKeywordFound(PythonLibCoreException):
     pass
 
 
+def _translation(translation: Optional[Path] = None):
+    if translation and isinstance(translation, Path) and translation.is_file():
+        with translation.open("r") as file:
+            try:
+                return json.load(file)
+            except json.decoder.JSONDecodeError:
+                logger.warn(f"Could not find file: {translation}")
+                return {}
+    else:
+        return {}
+
+
 class HybridCore:
-    def __init__(self, library_components: List) -> None:
+    def __init__(self, library_components: List, translation: Optional[Path] = None) -> None:
         self.keywords = {}
         self.keywords_spec = {}
         self.attributes = {}
-        self.add_library_components(library_components)
-        self.add_library_components([self])
+        translation_data = _translation(translation)
+        self.add_library_components(library_components, translation_data)
+        self.add_library_components([self], translation_data)
         self.__set_library_listeners(library_components)
 
-    def add_library_components(self, library_components: List):
-        self.keywords_spec["__init__"] = KeywordBuilder.build(self.__init__)  # type: ignore
+    def add_library_components(self, library_components: List, translation: Optional[dict] = None):
+        translation = translation if translation else {}
+        self.keywords_spec["__init__"] = KeywordBuilder.build(self.__init__, translation)  # type: ignore
         for component in library_components:
             for name, func in self.__get_members(component):
                 if callable(func) and hasattr(func, "robot_name"):
                     kw = getattr(component, name)
-                    kw_name = func.robot_name or name
+                    kw_name = self.__get_keyword_name(func, name, translation)
                     self.keywords[kw_name] = kw
-                    self.keywords_spec[kw_name] = KeywordBuilder.build(kw)
+                    self.keywords_spec[kw_name] = KeywordBuilder.build(kw, translation)
                     # Expose keywords as attributes both using original
                     # method names as well as possible custom names.
                     self.attributes[name] = self.attributes[kw_name] = kw
 
+    def __get_keyword_name(self, func: Callable, name: str, translation: dict):
+        if name in translation:
+            return translation[name]["name"]
+        return func.robot_name or name
+
     def __set_library_listeners(self, library_components: list):
         listeners = self.__get_manually_registered_listeners()
         listeners.extend(self.__get_component_listeners([self, *library_components]))
@@ -198,13 +220,24 @@ def __get_keyword_path(self, method):
 
 class KeywordBuilder:
     @classmethod
-    def build(cls, function):
+    def build(cls, function, translation: Optional[dict] = None):
+        translation = translation if translation else {}
         return KeywordSpecification(
             argument_specification=cls._get_arguments(function),
-            documentation=inspect.getdoc(function) or "",
+            documentation=cls.get_doc(function, translation),
             argument_types=cls._get_types(function),
         )
 
+    @classmethod
+    def get_doc(cls, function, translation: dict):
+        if kw := cls._get_kw_transtation(function, translation):
+            return kw["doc"]
+        return inspect.getdoc(function) or ""
+
+    @classmethod
+    def _get_kw_transtation(cls, function, translation: dict):
+        return translation.get(function.__name__, {})
+
     @classmethod
     def unwrap(cls, function):
         return inspect.unwrap(function)

utest/test_keyword_builder.py

@@ -17,59 +17,59 @@ def dyn_types():
 
 
 def test_documentation(lib):
-    spec = KeywordBuilder.build(lib.positional_args)
+    spec = KeywordBuilder.build(lib.positional_args, {})
     assert spec.documentation == "Some documentation\n\nMulti line docs"
-    spec = KeywordBuilder.build(lib.positional_and_default)
+    spec = KeywordBuilder.build(lib.positional_and_default, {})
     assert spec.documentation == ""
 
 
 def test_no_args(lib):
-    spec = KeywordBuilder.build(lib.no_args)
+    spec = KeywordBuilder.build(lib.no_args, {})
     assert spec.argument_specification == []
 
 
 def test_positional_args(lib):
-    spec = KeywordBuilder.build(lib.positional_args)
+    spec = KeywordBuilder.build(lib.positional_args, {})
     assert spec.argument_specification == ["arg1", "arg2"]
 
 
 def test_positional_and_named(lib):
-    spec = KeywordBuilder.build(lib.positional_and_default)
+    spec = KeywordBuilder.build(lib.positional_and_default, {})
     assert spec.argument_specification == ["arg1", "arg2", ("named1", "string1"), ("named2", 123)]
 
 
 def test_named_only_default_only(lib):
-    spec = KeywordBuilder.build(lib.default_only)
+    spec = KeywordBuilder.build(lib.default_only, {})
     assert spec.argument_specification == [("named1", "string1"), ("named2", 123)]
 
 
 def test_varargs_and_kwargs(lib):
-    spec = KeywordBuilder.build(lib.varargs_kwargs)
+    spec = KeywordBuilder.build(lib.varargs_kwargs, {})
     assert spec.argument_specification == ["*vargs", "**kwargs"]
 
 
 def test_named_only_part2(lib):
-    spec = KeywordBuilder.build(lib.named_only)
+    spec = KeywordBuilder.build(lib.named_only, {})
     assert spec.argument_specification == ["*varargs", "key1", "key2"]
 
 
 def test_named_only(lib):
-    spec = KeywordBuilder.build(lib.named_only_with_defaults)
+    spec = KeywordBuilder.build(lib.named_only_with_defaults, {})
     assert spec.argument_specification == ["*varargs", "key1", "key2", ("key3", "default1"), ("key4", True)]
 
 
 def test_types_in_keyword_deco(lib):
-    spec = KeywordBuilder.build(lib.positional_args)
+    spec = KeywordBuilder.build(lib.positional_args, {})
     assert spec.argument_types == {"arg1": str, "arg2": int}
 
 
 def test_types_disabled_in_keyword_deco(lib):
-    spec = KeywordBuilder.build(lib.types_disabled)
+    spec = KeywordBuilder.build(lib.types_disabled, {})
     assert spec.argument_types is None
 
 
 def test_types_(lib):
-    spec = KeywordBuilder.build(lib.args_with_type_hints)
+    spec = KeywordBuilder.build(lib.args_with_type_hints, {})
     assert spec.argument_types == {"arg3": str, "arg4": type(None), "return": bool}
 
 

utest/test_plugin_api.py

@@ -1,4 +1,4 @@
-import my_plugin_test
+from helpers import my_plugin_test
 import pytest
 from robotlibcore import Module, PluginError, PluginParser
 
@@ -37,22 +37,22 @@ def test_plugins_string_to_modules(plugin_parser):
     ]
 
 
-def test_parse_plugins(plugin_parser):
-    plugins = plugin_parser.parse_plugins("my_plugin_test.TestClass")
+def test_parse_plugins(plugin_parser: PluginParser):
+    plugins = plugin_parser.parse_plugins("helpers.my_plugin_test.TestClass")
     assert len(plugins) == 1
     assert isinstance(plugins[0], my_plugin_test.TestClass)
-    plugins = plugin_parser.parse_plugins("my_plugin_test.TestClass,my_plugin_test.TestClassWithBase")
+    plugins = plugin_parser.parse_plugins("helpers.my_plugin_test.TestClass,helpers.my_plugin_test.TestClassWithBase")
     assert len(plugins) == 2
     assert isinstance(plugins[0], my_plugin_test.TestClass)
     assert isinstance(plugins[1], my_plugin_test.TestClassWithBase)
 
 
 def test_parse_plugins_as_list(plugin_parser):
-    plugins = plugin_parser.parse_plugins(["my_plugin_test.TestClass"])
+    plugins = plugin_parser.parse_plugins(["helpers.my_plugin_test.TestClass"])
     assert len(plugins) == 1
     assert isinstance(plugins[0], my_plugin_test.TestClass)
     plugins = plugin_parser.parse_plugins(
-        ["my_plugin_test.TestClass", "my_plugin_test.TestClassWithBase"]
+        ["helpers.my_plugin_test.TestClass", "helpers.my_plugin_test.TestClassWithBase"]
     )
     assert len(plugins) == 2
     assert isinstance(plugins[0], my_plugin_test.TestClass)
@@ -61,16 +61,16 @@ def test_parse_plugins_as_list(plugin_parser):
 
 def test_parse_plugins_with_base():
     parser = PluginParser(my_plugin_test.LibraryBase)
-    plugins = parser.parse_plugins("my_plugin_test.TestClassWithBase")
+    plugins = parser.parse_plugins("helpers.my_plugin_test.TestClassWithBase")
     assert len(plugins) == 1
     assert isinstance(plugins[0], my_plugin_test.TestClassWithBase)
     with pytest.raises(PluginError) as excinfo:
-        parser.parse_plugins("my_plugin_test.TestClass")
-    assert "Plugin does not inherit <class 'my_plugin_test.LibraryBase'>" in str(excinfo.value)
+        parser.parse_plugins("helpers.my_plugin_test.TestClass")
+    assert "Plugin does not inherit <class 'helpers.my_plugin_test.LibraryBase'>" in str(excinfo.value)
 
 
 def test_plugin_keywords(plugin_parser):
-    plugins = plugin_parser.parse_plugins("my_plugin_test.TestClass,my_plugin_test.TestClassWithBase")
+    plugins = plugin_parser.parse_plugins("helpers.my_plugin_test.TestClass,helpers.my_plugin_test.TestClassWithBase")
     keywords = plugin_parser.get_plugin_keywords(plugins)
     assert len(keywords) == 2
     assert keywords[0] == "another_keyword"
@@ -83,7 +83,7 @@ class PythonObject:
         y = 2
     python_object = PythonObject()
     parser = PluginParser(my_plugin_test.LibraryBase, [python_object])
-    plugins = parser.parse_plugins("my_plugin_test.TestPluginWithPythonArgs;4")
+    plugins = parser.parse_plugins("helpers.my_plugin_test.TestPluginWithPythonArgs;4")
     assert len(plugins) == 1
     plugin = plugins[0]
     assert plugin.python_class.x == 1