Return type information for Robot Framework type conversion (#22)

Add support for dynamic API get_keyword_types

Author: aaltat

atest/DynamicTypesAnnotationsLibrary.py

@@ -0,0 +1,75 @@
+from typing import List, Union, NewType
+
+from robot.api import logger
+
+from robotlibcore import DynamicCore, keyword
+
+UserId = NewType('UserId', int)
+
+
+class CustomObject(object):
+
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+
+class DynamicTypesAnnotationsLibrary(DynamicCore):
+
+    def __init__(self, arg: str):
+        DynamicCore.__init__(self, [])
+        self.instance_attribute = 'not keyword'
+        self.arg = arg
+
+    @keyword
+    def keyword_with_one_annotation(self, arg: str):
+        return arg
+
+    @keyword
+    def keyword_with_multiple_annotations(self, arg1: str, arg2: List):
+        return arg1, arg2
+
+    @keyword
+    def keyword_multiple_types(self, arg: Union[List, None]):
+        return arg
+
+    @keyword
+    def keyword_new_type(self, arg: UserId):
+        return arg
+
+    @keyword
+    def keyword_define_return_type(self, arg: str) -> None:
+        logger.info(arg)
+        return None
+
+    @keyword
+    def keyword_forward_references(self, arg: 'CustomObject'):
+        return arg
+
+    @keyword
+    def keyword_with_annotations_and_default(self, arg: str = 'Foobar'):
+        return arg
+
+    @keyword
+    def keyword_with_webdriver(self, arg: CustomObject):
+        return arg
+
+    @keyword
+    def keyword_default_and_annotation(self, arg1: int, arg2=False) -> str:
+        return '%s: %s, %s: %s' % (arg1, type(arg1), arg2, type(arg2))
+
+    @keyword(types={'arg': str})
+    def keyword_robot_types_and_annotations(self, arg: int):
+        return '%s: %s' % (arg, type(arg))
+
+    @keyword(types=None)
+    def keyword_robot_types_disabled_and_annotations(self, arg: int):
+        return '%s: %s' % (arg, type(arg))
+
+    @keyword(types={'arg1': str})
+    def keyword_robot_types_and_bool_defaults(self, arg1, arg2=False):
+        return '%s: %s, %s: %s' % (arg1, type(arg1), arg2, type(arg2))
+
+    @keyword
+    def keyword_exception_annotations(self, arg: 'NotHere'):
+        return arg

atest/DynamicTypesLibrary.py

@@ -0,0 +1,54 @@
+import sys
+
+from robotlibcore import DynamicCore, keyword
+
+
+class DynamicTypesLibrary(DynamicCore):
+
+    def __init__(self, arg=False):
+        DynamicCore.__init__(self, [])
+        self.instance_attribute = 'not keyword'
+        self.arg = arg
+
+    @keyword(types={'arg1': str})
+    def keyword_with_types(self, arg1):
+        return arg1
+
+    @keyword(types={'arg1': str})
+    def keyword_robot_types_and_bool_default(self, arg1, arg2=False):
+        return arg1, arg2
+
+    @keyword(types=None)
+    def keyword_with_disabled_types(self, arg1):
+        return arg1
+
+    @keyword(types={'arg1': str})
+    def keyword_with_one_type(self, arg1, arg2):
+        return arg1, arg2
+
+    @keyword
+    def keyword_with_no_args(self):
+        return False
+
+    def not_keyword(self):
+        return False
+
+    @keyword
+    def keyword_default_types(self, arg=None):
+        return arg
+
+    @keyword
+    def keyword_many_default_types(self, arg1=1, arg2='Foobar'):
+        return arg1, arg2
+
+    @keyword
+    def keyword_booleans(self, arg1=True, arg2=False):
+        return '%s: %s, %s: %s' % (arg1, type(arg1), arg2, type(arg2))
+
+    @keyword
+    def keyword_none(self, arg=None):
+        return '%s: %s' % (arg, type(arg))
+
+    @keyword
+    def is_python_3(self):
+        return sys.version_info >= (3,)

atest/run.py

@@ -15,16 +15,24 @@
 curdir = dirname(abspath(__file__))
 outdir = join(curdir, 'results')
 tests = join(curdir, 'tests.robot')
+tests_types = join(curdir, 'tests_types.robot')
 sys.path.insert(0, join(curdir, '..', 'src'))
 python_version = platform.python_version()
 for variant in library_variants:
     output = join(outdir, 'lib-%s-python-%s-robot-%s.xml' % (variant, python_version, rf_version))
     rc = run(tests, name=variant, variable='LIBRARY:%sLibrary' % variant,
-             output=output, report=None, log=None)
+             output=output, report=None, log=None, loglevel='debug')
     if rc > 250:
         sys.exit(rc)
     process_output(output, verbose=False)
+output = join(outdir, 'lib-DynamicTypesLibrary-python-%s-robot-%s.xml' % (python_version, rf_version))
+exclude = 'py3' if sys.version_info < (3,) else ''
+rc = run(tests_types, name='Types', output=output, report=None, log=None, loglevel='debug', exclude=exclude)
+if rc > 250:
+    sys.exit(rc)
+process_output(output, verbose=False)
 print('\nCombining results.')
+library_variants.append('DynamicTypesLibrary')
 rc = rebot(*(join(outdir, 'lib-%s-python-%s-robot-%s.xml' % (variant, python_version, rf_version)) for variant in library_variants),
            **dict(name='Acceptance Tests', outputdir=outdir, log='log-python-%s-robot-%s.html' % (python_version, rf_version),
                   report='report-python-%s-robot-%s.html' % (python_version, rf_version)))

atest/tests_types.robot

@@ -0,0 +1,60 @@
+*** Settings ***
+Library        DynamicTypesLibrary.py
+Suite Setup    Import DynamicTypesAnnotationsLibrary In Python 3 Only
+
+*** Test Cases ***
+Keyword Default Argument As Abject None
+    ${return} =    DynamicTypesLibrary.Keyword None    ${None}
+    Should Match Regexp    ${return}    None: <(class|type) 'NoneType'>
+
+Keyword Default Argument As Abject None Default Value
+    ${return} =    DynamicTypesLibrary.Keyword None
+    Should Match Regexp    ${return}    None: <(class|type) 'NoneType'>
+
+Keyword Default Argument As String None
+    ${return} =    DynamicTypesLibrary.Keyword None    None
+    Should Match Regexp    ${return}    None: <(class|type) 'NoneType'>
+
+Keyword Default As Booleans With Defaults
+    ${return}    DynamicTypesLibrary.Keyword Booleans
+    Should Match Regexp    ${return}    True: <(class|type) 'bool'>, False: <(class|type) 'bool'>
+
+Keyword Default As Booleans With Strings
+    ${return} =    DynamicTypesLibrary.Keyword Booleans    False    True
+    Should Match Regexp    ${return}    False: <(class|type) 'bool'>, True: <(class|type) 'bool'>
+
+Keyword Default As Booleans With Objects
+    ${return} =    DynamicTypesLibrary.Keyword Booleans    ${False}    ${True}
+    Should Match Regexp    ${return}    False: <(class|type) 'bool'>, True: <(class|type) 'bool'>
+
+Keyword Annonations And Bool Defaults Using Default
+    [Tags]    py3
+    ${return} =    DynamicTypesAnnotationsLibrary.Keyword Default And Annotation    42
+    Should Match Regexp    ${return}    42: <(class|type) 'int'>, False: <(class|type) 'bool'>
+
+Keyword Annonations And Bool Defaults Defining All Arguments
+    [Tags]    py3
+    ${return} =    DynamicTypesAnnotationsLibrary.Keyword Default And Annotation    1    true
+    Should Match Regexp    ${return}    1: <(class|type) 'int'>, True: <(class|type) 'bool'>
+
+Keyword Annonations And Bool Defaults Defining All Arguments And With Number
+    [Tags]    py3
+    ${return} =    DynamicTypesAnnotationsLibrary.Keyword Default And Annotation    ${1}    true
+    Should Match Regexp    ${return}    1: <(class|type) 'int'>, True: <(class|type) 'bool'>
+
+Keyword Annonations And Robot Types Disbales Argument Conversion
+    [Tags]    py3
+    ${return} =    DynamicTypesAnnotationsLibrary.Keyword Robot Types Disabled And Annotations    111
+    Should Match Regexp    ${return}    111: <(class|type) 'str'>
+
+
+Keyword Annonations And Robot Types Defined
+    [Tags]    py3
+    ${return} =    DynamicTypesAnnotationsLibrary.Keyword Robot Types And Bool Defaults    tidii    111
+    Should Match Regexp    ${return}    tidii: <(class|type) 'str'>, 111: <(class|type) 'str'>
+
+*** Keywords ***
+Import DynamicTypesAnnotationsLibrary In Python 3 Only
+    ${py3} =    DynamicTypesLibrary.Is Python 3
+    Run Keyword If     ${py3}
+    ...    Import Library      DynamicTypesAnnotationsLibrary.py    Dummy

src/robotlibcore.py

@@ -21,20 +21,13 @@
 
 import inspect
 import sys
-
 try:
-    from robot.api.deco import keyword
-except ImportError:  # Support RF < 2.9
-    def keyword(name=None, tags=()):
-        if callable(name):
-            return keyword()(name)
+    import typing
+except ImportError:
+    typing = None
 
-        def decorator(func):
-            func.robot_name = name
-            func.robot_tags = tags
-            return func
-        return decorator
 
+from robot.api.deco import keyword  # noqa F401
 
 PY2 = sys.version_info < (3,)
 
@@ -51,7 +44,7 @@ def __init__(self, library_components):
 
     def add_library_components(self, library_components):
         for component in library_components:
-            for name, func in self._get_members(component):
+            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
@@ -60,7 +53,7 @@ def add_library_components(self, library_components):
                     # method names as well as possible custom names.
                     self.attributes[name] = self.attributes[kw_name] = kw
 
-    def _get_members(self, component):
+    def __get_members(self, component):
         if inspect.ismodule(component):
             return inspect.getmembers(component)
         if inspect.isclass(component):
@@ -70,9 +63,9 @@ def _get_members(self, component):
             raise TypeError('Libraries must be modules or new-style class '
                             'instances, got old-style class {!r} instead.'
                             .format(component.__class__.__name__))
-        return self._get_members_from_instance(component)
+        return self.__get_members_from_instance(component)
 
-    def _get_members_from_instance(self, instance):
+    def __get_members_from_instance(self, instance):
         # Avoid calling properties by getting members from class, not instance.
         cls = type(instance)
         for name in dir(instance):
@@ -97,22 +90,22 @@ def get_keyword_names(self):
 
 
 class DynamicCore(HybridCore):
-    _get_keyword_tags_supported = False  # get_keyword_tags is new in RF 3.0.2
+    __get_keyword_tags_supported = False  # get_keyword_tags is new in RF 3.0.2
 
     def run_keyword(self, name, args, kwargs=None):
         return self.keywords[name](*args, **(kwargs or {}))
 
     def get_keyword_arguments(self, name):
         kw = self.keywords[name] if name != '__init__' else self.__init__
-        args, defaults, varargs, kwargs = self._get_arg_spec(kw)
+        args, defaults, varargs, kwargs = self.__get_arg_spec(kw)
         args += ['{}={}'.format(name, value) for name, value in defaults]
         if varargs:
             args.append('*{}'.format(varargs))
         if kwargs:
             args.append('**{}'.format(kwargs))
         return args
 
-    def _get_arg_spec(self, kw):
+    def __get_arg_spec(self, kw):
         if PY2:
             spec = inspect.getargspec(kw)
             keywords = spec.keywords
@@ -127,7 +120,7 @@ def _get_arg_spec(self, kw):
         return mandatory, defaults, spec.varargs, keywords
 
     def get_keyword_tags(self, name):
-        self._get_keyword_tags_supported = True
+        self.__get_keyword_tags_supported = True
         return self.keywords[name].robot_tags
 
     def get_keyword_documentation(self, name):
@@ -137,11 +130,50 @@ def get_keyword_documentation(self, name):
             return inspect.getdoc(self.__init__) or ''
         kw = self.keywords[name]
         doc = inspect.getdoc(kw) or ''
-        if kw.robot_tags and not self._get_keyword_tags_supported:
+        if kw.robot_tags and not self.__get_keyword_tags_supported:
             tags = 'Tags: {}'.format(', '.join(kw.robot_tags))
             doc = '{}\n\n{}'.format(doc, tags) if doc else tags
         return doc
 
+    def get_keyword_types(self, keyword_name):
+        method = self.__get_keyword(keyword_name)
+        if method == {}:
+            return method
+        types = getattr(method, 'robot_types', ())
+        if types is None:
+            return types
+        if not types:
+            types = self.__get_typing_hints(method)
+        types = self.__join_defaults_with_types(method, types)
+        return types
+
+    def __get_keyword(self, keyword_name):
+        if keyword_name == '__init__':
+            return self.__init__
+        if keyword_name.startswith('__') and keyword_name.endswith('__'):
+            return {}
+        method = self.keywords.get(keyword_name)
+        if not method:
+            raise ValueError('Keyword "%s" not found.' % keyword_name)
+        return method
+
+    def __get_typing_hints(self, method):
+        if PY2:
+            return {}
+        try:
+            hints = typing.get_type_hints(method)
+        except Exception:
+            hints = method.__annotations__
+        hints.pop('return', None)
+        return hints
+
+    def __join_defaults_with_types(self, method, types):
+        _, 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)
+        return types
+
 
 class StaticCore(HybridCore):
 

utest/run.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+import argparse
 import platform
 from os.path import abspath, dirname, join
 import sys
@@ -13,12 +14,20 @@
 src = join(curdir, '..', 'src')
 sys.path.insert(0, src)
 sys.path.insert(0, atest_dir)
-pytest_args = sys.argv[1:] + [
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--no-cov', dest='cov', action='store_false')
+parser.add_argument('--cov', dest='cov', action='store_true')
+parser.set_defaults(cov=True)
+args = parser.parse_args()
+
+pytest_args = [
     '-p', 'no:cacheprovider',
     '--junitxml=%s' % xunit_report,
     '-o', 'junit_family=xunit2',
-    '--cov=%s' % src,
     curdir
 ]
+if args.cov:
+    pytest_args.insert(0, '--cov=%s' % src)
 rc = pytest.main(pytest_args)
 sys.exit(rc)