fix comments

Author: KsanaKozlova

numba_typing/tests/test_type_annotations.py

@@ -1,6 +1,7 @@
 import unittest
 import type_annotations
 from typing import Union, Dict, List, TypeVar
+from collections import namedtuple
 
 
 def check_equal(result, expected):
@@ -12,6 +13,21 @@ def check_equal(result, expected):
     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):
@@ -92,22 +108,17 @@ def test_add_vals_to_signature(self):
                      {'a': Dict[str, str], 'b': int}]
         vals = {'a': {'name': 3}, 'b': 3}
 
-        result = type_annotations.add_vals_to_signature(signature, vals)
-        expected = [[{'a': Dict[float, int], 'b': int}, {'a': {'name': 3}, 'b': 3}],
-                    [{'a': Dict[str, int], 'b': int}, {'a': {'name': 3}, 'b': 3}],
-                    [{'a': Dict[float, str], 'b': int}, {'a': {'name': 3}, 'b': 3}],
-                    [{'a': Dict[str, str], 'b': int}, {'a': {'name': 3}, 'b': 3}]]
-        self.assertEqual(result, expected)
+        Annotations = namedtuple('Annotations', ['parameters', 'defaults'])
 
-    def test_exist_typevar(self):
-        T = TypeVar('T', float, str)
-        S = TypeVar('S', int, str)
-        types = [List[List[T]], Dict[T, S], int, T, S]
-        expected = [{True}, {False, True}, {False}, {True}, {False}]
+        expected = Annotations(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})
 
-        for i in range(len(types)):
-            with self.subTest(types=i):
-                self.assertEqual(type_annotations.exist_typevar(types[i], T), expected[i])
+        result = type_annotations.add_vals_to_signature(signature, vals)
+
+        self.assertEqual(result, expected)
 
     def test_replace_typevar(self):
         T = TypeVar('T', int, str)
@@ -168,18 +179,21 @@ def test_product_annotations(self):
         annotations = ({'a': [T], 'b': [Dict[T, S]],
                         'c': [T, bool], 'd': [int]}, {'d': 3})
 
-        expected = [[{'a': int, 'b': Dict[int, float], 'c': int, 'd': int}, {'d': 3}],
-                    [{'a': int, 'b': Dict[int, bool], 'c': int, 'd': int}, {'d': 3}],
-                    [{'a': str, 'b': Dict[str, float], 'c': str, 'd': int}, {'d': 3}],
-                    [{'a': str, 'b': Dict[str, bool], 'c': str, 'd': int}, {'d': 3}],
-                    [{'a': int, 'b': Dict[int, float], 'c': bool, 'd': int}, {'d': 3}],
-                    [{'a': int, 'b': Dict[int, bool], 'c': bool, 'd': int}, {'d': 3}],
-                    [{'a': str, 'b': Dict[str, float], 'c': bool, 'd': int}, {'d': 3}],
-                    [{'a': str, 'b': Dict[str, bool], 'c': bool, 'd': int}, {'d': 3}]]
+        Annotations = namedtuple('Annotations', ['parameters', 'defaults'])
+
+        expected = Annotations(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(result, expected))
+        self.assertTrue(check_equal_annotations(result, expected))
 
 
 if __name__ == '__main__':

numba_typing/type_annotations.py

@@ -2,6 +2,7 @@
 from typing import get_type_hints, Union, TypeVar, _GenericAlias
 from itertools import product
 from copy import deepcopy
+from collections import namedtuple
 
 
 def get_func_annotations(func):
@@ -45,7 +46,6 @@ def product_annotations(annotations):
     types, vals = annotations
     list_of_sig = convert_to_sig_list(types)
     signature = []
-    #unique_typevars = get_internal_typevars(list_of_sig)
 
     for sig in list_of_sig:
         signature.extend(get_internal_typevars(sig))
@@ -55,13 +55,10 @@ def product_annotations(annotations):
 
 def add_vals_to_signature(signature, vals):
     '''Add default values ​​to all signatures'''
-    result = []
-    for sig in signature:
-        annotation = []
-        annotation.append(sig)
-        annotation.append(vals)
-        result.append(annotation)
-    return result
+    Annotations = namedtuple('Annotations', ['parameters', 'defaults'])
+    annotations = Annotations(signature, vals)
+
+    return annotations
 
 
 def convert_to_sig_list(types):
@@ -123,7 +120,7 @@ def update_sig(temp_sig, typevar):
     for constr_type in typevar.__constraints__:
         sig = {}
         for name, typ in temp_sig.items():
-            if True in exist_typevar(typ, typevar):
+            if typevar in get_typevars(typ):
                 sig[name] = replace_typevar(typ, typevar, constr_type)
             else:
                 sig[name] = typ
@@ -133,19 +130,6 @@ def update_sig(temp_sig, typevar):
     return result
 
 
-def exist_typevar(typ, typevar):
-    '''Сheck if there is a typevar in type (container)'''
-    if typ == typevar:
-        return {True, }
-    elif isinstance(typ, _GenericAlias):
-        result = set()
-        for arg in typ.__args__:
-            result.update(exist_typevar(arg, typevar))
-        return result
-
-    return {False, }
-
-
 def replace_typevar(typ, typevar, final_typ):
     '''Replace typevar with type in container
         For example: