Support for keyword only arguments

Author: aaltat

atest/DynamicTypesAnnotationsLibrary.py

@@ -73,3 +73,11 @@ def keyword_robot_types_and_bool_defaults(self, arg1, arg2=False):
     @keyword
     def keyword_exception_annotations(self, arg: 'NotHere'):
         return arg
+
+    @keyword
+    def keyword_only_arguments(self, *varargs, some='value'):
+        return f'{some}: {type(some)}, {varargs}: {type(varargs)}'
+
+    @keyword
+    def keyword_only_arguments_many(self, *varargs, some='value', other=None):
+        return f'{some}: {type(some)}, {other}: {type(other)}, {varargs}: {type(varargs)}'

src/robotlibcore.py

@@ -101,36 +101,59 @@ def get_keyword_arguments(self, name):
         kw_method = self.__get_keyword(name)
         if kw_method is None:
             return None
-        args, defaults, varargs, kwargs = self.__get_arg_spec(kw_method)
-        if robot_version >= '3.2':
-            args += self.__new_default_spec(defaults)
-        else:
+        args, defaults, varargs, kwargs, kwonlydefaults = self.__get_arg_spec(kw_method)
+        if self.__rf_31:
             args += self.__old_default_spec(defaults)
+        else:
+            args += self.__new_default_spec(defaults)
         if varargs:
             args.append('*%s' % varargs)
         if kwargs:
             args.append('**%s' % kwargs)
+        if kwonlydefaults:
+            args += self.__kwonlydefaults_spec(kwonlydefaults)
         return args
 
+    @property
+    def __rf_31(self):
+        return robot_version < '3.2'
+
     def __new_default_spec(self, defaults):
         return [(name, value) for name, value in defaults]
 
     def __old_default_spec(self, defaults):
         return ['{}={}'.format(name, value) for name, value in defaults]
 
+    def __kwonlydefaults_spec(self, kwonlydefaults):
+        args = []
+        for argument, default_value in kwonlydefaults.items():
+            if self.__rf_31:
+                args.append(self.__old_kwonlydefaults_spec(argument, default_value))
+            else:
+                args.append(self.__new_kwonlydefaults_spec(argument, default_value))
+        return args
+
+    def __new_kwonlydefaults_spec(self, argument, default_value):
+        return (argument, default_value)
+
+    def __old_kwonlydefaults_spec(self, argument, default_value):
+        return '%s=%s' % (argument, default_value)
+
     def __get_arg_spec(self, kw):
         if PY2:
             spec = inspect.getargspec(kw)
             keywords = spec.keywords
+            kwonlydefaults = {}
         else:
             spec = inspect.getfullargspec(kw)
             keywords = spec.varkw
+            kwonlydefaults = spec.kwonlydefaults
         args = spec.args[1:] if inspect.ismethod(kw) else spec.args  # drop self
         defaults = spec.defaults or ()
         nargs = len(args) - len(defaults)
         mandatory = args[:nargs]
         defaults = zip(args[nargs:], defaults)
-        return mandatory, defaults, spec.varargs, keywords
+        return mandatory, defaults, spec.varargs, keywords, kwonlydefaults
 
     def get_keyword_tags(self, name):
         self.__get_keyword_tags_supported = True
@@ -181,7 +204,7 @@ def __get_typing_hints(self, method):
         return hints
 
     def __join_defaults_with_types(self, method, types):
-        _, defaults, _, _ = self.__get_arg_spec(method)
+        _, defaults, _, _, _ = self.__get_arg_spec(method)
         for name, value in defaults:
             if name not in types and isinstance(value, (bool, type(None))):
                 types[name] = type(value)

utest/test_robotlibcore.py

@@ -3,9 +3,11 @@
 import pytest
 from robot import __version__ as robot__version
 
-from robotlibcore import HybridCore
+from robotlibcore import HybridCore, PY2
 from HybridLibrary import HybridLibrary
 from DynamicLibrary import DynamicLibrary
+if not PY2:
+    from DynamicTypesAnnotationsLibrary import DynamicTypesAnnotationsLibrary
 
 
 def test_keyword_names():
@@ -37,8 +39,12 @@ def test_dir():
                 '_DynamicCore__get_keyword_tags_supported',
                 '_DynamicCore__get_typing_hints',
                 '_DynamicCore__join_defaults_with_types',
+                '_DynamicCore__kwonlydefaults_spec',
                 '_DynamicCore__new_default_spec',
+                '_DynamicCore__new_kwonlydefaults_spec',
                 '_DynamicCore__old_default_spec',
+                '_DynamicCore__old_kwonlydefaults_spec',
+                '_DynamicCore__rf_31',
                 '_HybridCore__get_members',
                 '_HybridCore__get_members_from_instance',
                 '_custom_name',
@@ -76,8 +82,12 @@ def test_dir():
                                                  '_DynamicCore__get_keyword_path',
                                                  '_DynamicCore__get_keyword_tags_supported',
                                                  '_DynamicCore__join_defaults_with_types',
+                                                 '_DynamicCore__kwonlydefaults_spec',
                                                  '_DynamicCore__new_default_spec',
+                                                 '_DynamicCore__new_kwonlydefaults_spec',
                                                  '_DynamicCore__old_default_spec',
+                                                 '_DynamicCore__old_kwonlydefaults_spec',
+                                                 '_DynamicCore__rf_31',
                                                  'get_keyword_arguments',
                                                  'get_keyword_documentation',
                                                  'get_keyword_source',
@@ -124,6 +134,22 @@ def test_get_keyword_arguments_rf32():
     assert args('__foobar__') is None
 
 
+@pytest.mark.skipif(PY2, reason='Only for Python 3')
+@pytest.mark.skipif(robot__version < '3.2', reason='For RF 3.2 or greater')
+def test_keyword_only_arguments_for_get_keyword_arguments_rf32():
+    args = DynamicTypesAnnotationsLibrary(1).get_keyword_arguments
+    assert args('keyword_only_arguments') == ['*varargs', ('some', 'value')]
+    assert args('keyword_only_arguments_many') == ['*varargs', ('some', 'value'), ('other', None)]
+
+
+@pytest.mark.skipif(PY2, reason='Only for Python 3')
+@pytest.mark.skipif(robot__version > '3.2', reason='For RF 3.1')
+def test_keyword_only_arguments_for_get_keyword_arguments_rf31():
+    args = DynamicTypesAnnotationsLibrary(1).get_keyword_arguments
+    assert args('keyword_only_arguments') == ['*varargs', 'some=value']
+    assert args('keyword_only_arguments_many') == ['*varargs', 'some=value', 'other=None']
+
+
 def test_get_keyword_documentation():
     doc = DynamicLibrary().get_keyword_documentation
     assert doc('function') == ''