arguments_annotation_default_func_class (#894)

* add getting annotation for func and classes

* fix pep8 remarks

* from inspect import signature, getfullargspecfix pep8 remarks

* another fix pep8 remarks

* another fix pep8 remarks

* another fix pep8 remarks

* small fix

* another small fixes

* another small fixes

* another small fixes

* add unit tests and handler for union

* fix comments

* add function expend_annotations

* add tests for function expend_annotations

* fix comment

* fix comments - improve product_annotations function

* add some functions that extend annotations

* add function and tests

* fix problem with tests

* fix comments

* rename annotation to signature

* fix comments

* small changes

* fix pep issues

Author: AlexanderKalistratov

numba_typing/tests/__init__.py

@@ -0,0 +1,196 @@
+import unittest
+import type_annotations
+from typing import Union, Dict, List, TypeVar
+from collections import namedtuple
+
+
+def check_equal(result, expected):
+    if len(result) != len(expected):
+        return False
+    for sig in result:
+        if sig not in expected:
+            return False
+    return True
+
+
+def check_equal_annotations(result, expected):
+
+    if len(result.parameters) != len(expected.parameters):
+        return False
+
+    for sig in result.parameters:
+        if sig not in expected.parameters:
+            return False
+
+    if result.defaults != expected.defaults:
+        return False
+
+    return True
+
+
+class TestTypeAnnotations(unittest.TestCase):
+
+    def test_get_func_annotations_exceptions(self):
+
+        def foo(a: int, b, c: str = "string"):
+            pass
+        with self.assertRaises(SyntaxError) as raises:
+            type_annotations.get_func_annotations(foo)
+        self.assertIn('No annotation for parameter b', str(raises.exception))
+
+    def test_get_cls_annotations(self):
+        class TestClass(object):
+            x: int = 3
+            y: str = "string"
+
+            def __init__(self, x, y):
+                self.x = x
+                self.y = y
+
+        result = type_annotations.get_cls_annotations(TestClass)
+        expected = ({'x': [int], 'y': [str]}, {})
+        self.assertEqual(result, expected)
+
+    def test_get_func_annotations(self):
+
+        def func_one(a: int, b: Union[int, float], c: str):
+            pass
+
+        def func_two(a: int = 2, b: str = "string", c: List[int] = [1, 2, 3]):
+            pass
+
+        def func_three(a: Dict[int, str], b: str = "string", c: int = 1):
+            pass
+
+        expected_results = {
+            func_one: ({'a': [int], 'b': [int, float], 'c': [str]}, {}),
+            func_two: ({'a': [int], 'b': [str], 'c': [List[int]]}, {'a': 2, 'b': 'string', 'c': [1, 2, 3]}),
+            func_three: ({'a': [Dict[int, str]], 'b': [str], 'c': [int]}, {'b': 'string', 'c': 1}),
+        }
+        for f, expected in expected_results.items():
+            with self.subTest(func=f.__name__):
+                self.assertEqual(type_annotations.get_func_annotations(f), expected)
+
+    def test_convert_to_sig_list(self):
+        T = TypeVar('T', int, str)
+        S = TypeVar('S', float, str)
+        annotations = [{'a': [int], 'b': [int, float], 'c': [S]},
+                       {'a': [int], 'b': [T], 'c': [S]},
+                       {'a': [int, str], 'b': [int, float], 'c': [S]}]
+
+        expected = [[{'a': int, 'b': int, 'c': S},
+                     {'a': int, 'b': float, 'c': S}],
+                    [{'a': int, 'b': T, 'c': S}],
+                    [{'a': int, 'b': int, 'c': S},
+                     {'a': int, 'b': float, 'c': S},
+                     {'a': str, 'b': int, 'c': S},
+                     {'a': str, 'b': float, 'c': S}]]
+
+        for i in range(len(annotations)):
+            with self.subTest(annotations=i):
+                self.assertEqual(type_annotations.convert_to_sig_list(annotations[i]), expected[i])
+
+    def test_get_typevars(self):
+        T = TypeVar('T', int, str)
+        S = TypeVar('S', float, str)
+        types = [List[T], Dict[T, S], int, T, List[List[T]]]
+
+        expected = [{T}, {T, S}, set(), {T}, {T}]
+
+        for i in range(len(types)):
+            with self.subTest(types=i):
+                self.assertEqual(type_annotations.get_typevars(types[i]), expected[i])
+
+    def test_add_vals_to_signature(self):
+        signature = [{'a': Dict[float, int], 'b': int},
+                     {'a': Dict[str, int], 'b': int},
+                     {'a': Dict[float, str], 'b': int},
+                     {'a': Dict[str, str], 'b': int}]
+        vals = {'a': {'name': 3}, 'b': 3}
+
+        expected = type_annotations.Signature(parameters=[{'a': Dict[float, int], 'b': int},
+                                                          {'a': Dict[str, int], 'b': int},
+                                                          {'a': Dict[float, str], 'b': int},
+                                                          {'a': Dict[str, str], 'b': int}],
+                                              defaults={'a': {'name': 3}, 'b': 3})
+
+        result = type_annotations.add_vals_to_signature(signature, vals)
+
+        self.assertEqual(result, expected)
+
+    def test_replace_typevar(self):
+        T = TypeVar('T', int, str)
+        S = TypeVar('S', float, str)
+
+        types = [List[List[T]], Dict[T, S], T]
+        expected = [List[List[int]], Dict[int, S], int]
+
+        for i in range(len(types)):
+            with self.subTest(types=i):
+                self.assertEqual(type_annotations.replace_typevar(types[i], T, int), expected[i])
+
+    def test_get_internal_typevars(self):
+
+        T = TypeVar('T', int, str)
+        S = TypeVar('S', float, bool)
+        signature = {'a': T, 'b': Dict[T, S]}
+        expected = [{'a': int, 'b': Dict[int, float]},
+                    {'a': int, 'b': Dict[int, bool]},
+                    {'a': str, 'b': Dict[str, float]},
+                    {'a': str, 'b': Dict[str, bool]}]
+
+        result = type_annotations.get_internal_typevars(signature)
+
+        self.assertTrue(check_equal(result, expected))
+
+    def test_update_sig(self):
+        T = TypeVar('T', int, str)
+        S = TypeVar('S', float, bool)
+
+        sig = {'a': T, 'b': Dict[T, S]}
+        expected = [{'a': T, 'b': Dict[T, float]},
+                    {'a': T, 'b': Dict[T, bool]}]
+        result = type_annotations.update_sig(sig, S)
+
+        self.assertEqual(result, expected)
+
+    def test_expand_typevars(self):
+        T = TypeVar('T', int, str)
+        S = TypeVar('S', float, bool)
+
+        sig = {'a': T, 'b': Dict[T, S], 'c': int}
+        unique_typevars = {T, S}
+        expected = [{'a': int, 'b': Dict[int, float], 'c': int},
+                    {'a': int, 'b': Dict[int, bool], 'c': int},
+                    {'a': str, 'b': Dict[str, float], 'c': int},
+                    {'a': str, 'b': Dict[str, bool], 'c': int}]
+
+        result = type_annotations.expand_typevars(sig, unique_typevars)
+
+        self.assertTrue(check_equal(result, expected))
+
+    def test_product_annotations(self):
+
+        T = TypeVar('T', int, str)
+        S = TypeVar('S', float, bool)
+
+        annotations = ({'a': [T], 'b': [Dict[T, S]],
+                        'c': [T, bool], 'd': [int]}, {'d': 3})
+
+        expected = type_annotations.Signature(parameters=[{'a': int, 'b': Dict[int, float], 'c': int, 'd': int},
+                                                          {'a': str, 'b': Dict[str, float], 'c': str, 'd': int},
+                                                          {'a': int, 'b': Dict[int, bool], 'c': int, 'd': int},
+                                                          {'a': str, 'b': Dict[str, bool], 'c': str, 'd': int},
+                                                          {'a': int, 'b': Dict[int, float], 'c': bool, 'd': int},
+                                                          {'a': str, 'b': Dict[str, float], 'c': bool, 'd': int},
+                                                          {'a': int, 'b': Dict[int, bool], 'c': bool, 'd': int},
+                                                          {'a': str, 'b': Dict[str, bool], 'c': bool, 'd': int}],
+                                              defaults={'d': 3})
+
+        result = type_annotations.product_annotations(annotations)
+
+        self.assertTrue(check_equal_annotations(result, expected))
+
+
+if __name__ == '__main__':
+    unittest.main()

numba_typing/tests/test_type_annotations.py

@@ -0,0 +1,150 @@
+from inspect import signature
+from typing import get_type_hints, Union, TypeVar, _GenericAlias
+from itertools import product
+from copy import deepcopy
+from collections import namedtuple
+
+Signature = namedtuple('Signature', ['parameters', 'defaults'])
+
+
+def get_func_annotations(func):
+    """Get annotations and default values of the fuction parameters."""
+    sig = signature(func)
+    annotations = {}
+    defaults = {}
+
+    for name, param in sig.parameters.items():
+        if param.annotation == sig.empty:
+            raise SyntaxError(f'No annotation for parameter {name}')
+
+        annotations[name] = get_annotation_types(param.annotation)
+        if param.default != sig.empty:
+            defaults[name] = param.default
+
+    return annotations, defaults
+
+
+def get_cls_annotations(cls):
+    """Get annotations of class attributes."""
+    annotations = get_type_hints(cls)
+    for x in annotations:
+        annotations[x] = get_annotation_types(annotations[x])
+    return annotations, {}
+
+
+def get_annotation_types(annotation):
+    """Get types of passed annotation."""
+    try:
+        if annotation.__origin__ is Union:
+            return list(annotation.__args__)
+    except AttributeError:
+        pass
+
+    return [annotation, ]
+
+
+def product_annotations(annotations):
+    '''Get all variants of annotations.'''
+    types, vals = annotations
+    list_of_sig = convert_to_sig_list(types)
+    signature = []
+
+    for sig in list_of_sig:
+        signature.extend(get_internal_typevars(sig))
+
+    return add_vals_to_signature(signature, vals)
+
+
+def add_vals_to_signature(sign, vals):
+    '''Add default values ​​to all signatures'''
+    signature = Signature(sign, vals)
+    return signature
+
+
+def convert_to_sig_list(types):
+    '''Expands all Unions'''
+    types_product = list(product(*types.values()))
+    names = list(types)
+    result = []
+
+    for sig in types_product:
+        sig_result = {}
+        for i in range(len(sig)):
+            sig_result[names[i]] = sig[i]
+        result.append(sig_result)
+
+    return result
+
+
+def get_internal_typevars(sig):
+    '''Get unique typevars in signature'''
+    unique_typevars = set()
+    for typ in sig.values():
+        unique_typevars.update(get_typevars(typ))
+
+    if len(unique_typevars) == 0:
+        return [sig]
+
+    return expand_typevars(sig, unique_typevars)
+
+
+def get_typevars(type):
+    '''Get unique typevars in type (container)'''
+    if isinstance(type, TypeVar) and type.__constraints__:
+        return {type, }
+    elif isinstance(type, _GenericAlias):
+        result = set()
+        for arg in type.__args__:
+            result.update(get_typevars(arg))
+        return result
+
+    return set()
+
+
+def expand_typevars(sig, unique_typevars):
+    '''Exstend all Typevars in signature'''
+    result = [sig]
+
+    for typevar in unique_typevars:
+        temp_result = []
+        for temp_sig in result:
+            temp_result.extend(update_sig(temp_sig, typevar))
+        result = temp_result
+
+    return result
+
+
+def update_sig(temp_sig, typevar):
+    '''Expand one typevar'''
+    result = []
+    for constr_type in typevar.__constraints__:
+        sig = {}
+        for name, typ in temp_sig.items():
+            if typevar in get_typevars(typ):
+                sig[name] = replace_typevar(typ, typevar, constr_type)
+            else:
+                sig[name] = typ
+
+        result.append(sig)
+
+    return result
+
+
+def replace_typevar(typ, typevar, final_typ):
+    '''Replace typevar with type in container
+        For example:
+        # typ = Dict[T, V]
+        # typevar = T(int, str)
+        # final_typ = int
+    '''
+
+    if typ == typevar:
+        return final_typ
+    elif isinstance(typ, _GenericAlias):
+        result = list()
+        for arg in typ.__args__:
+            result.append(replace_typevar(arg, typevar, final_typ))
+        result_type = typ.copy_with(tuple(result))
+        return result_type
+
+    return typ