Fix: Failed to refine 'Sequence[...]' and 'Callable[...]' (#324, #325)

nutti · Dec 29, 2024 · 6b935f4 · 6b935f4
1 parent 5c3fd0b
commit 6b935f4
Show file tree

Hide file tree

Showing 5 changed files with 92 additions and 24 deletions.
diff --git a/src/fake_bpy_module/transformer/data_type_refiner.py b/src/fake_bpy_module/transformer/data_type_refiner.py
@@ -80,10 +80,12 @@
 REGEX_MATCH_DESCRIPTION_TYPE_IN = re.compile(r"type in `(.*)`")
 REGEX_MATCH_DESCRIPTION_ENUMERATOR_IN = re.compile(r"^Enumerator in `(.*)`")
 
+# pylint: disable=C0301
 _REGEX_DATA_TYPE_OPTION_STR = re.compile(r"\(([a-zA-Z, ]+?)\)$")
 _REGEX_DATA_TYPE_OPTION_END_WITH_NONE = re.compile(r"or None$")
 _REGEX_DATA_TYPE_OPTION_OPTIONAL = re.compile(r"(^|^An |\()[oO]ptional(\s|\))")
 _REGEX_DATA_TYPE_STARTS_WITH_COLLECTION = re.compile(r"^(list|tuple|dict)")
+_REGEX_DATA_TYPE_MODIFIER_TYPES = re.compile(r"^(Sequence|Callable|list|dict|tuple)?\[(.+)\]$")  # noqa: E501
 
 REGEX_SPLIT_OR = re.compile(r" \| | or |,")
 
@@ -210,6 +212,9 @@ def _get_refined_data_type_fast(  # noqa: C901, PLR0911, PLR0912
         if dtype_str.startswith("`AnyType`"):
             return [make_data_type_node("typing.Any")]
 
+        if dtype_str == "None":
+            return [make_data_type_node("None")]
+
         if dtype_str in ("any", "Any", "Any type."):
             return [make_data_type_node("typing.Any")]
 
@@ -737,18 +742,28 @@ def _get_refined_data_type_splited(
         uniq_module_names = self._entry_points_cache["uniq_module_names"]
 
         # Handle Python typing syntax.
-        if m := re.match(r"^(list|dict|tuple)\[(.+)\]$", dtype_str):
-            elements = split_string_by_comma(m.group(2))
+        if m := _REGEX_DATA_TYPE_MODIFIER_TYPES.match(dtype_str):
+            modifier = m.group(1)
+            if modifier is None:
+                modifier = ""
+            elements = split_string_by_comma(m.group(2), False)
             elm_dtype_nodes: list[list[DataTypeNode]] = []
             for elm in elements:
                 dtype_nodes = self._get_refined_data_type_internal(
                     elm, module_name, variable_kind, additional_info)
                 if len(dtype_nodes) >= 1:
                     elm_dtype_nodes.append(dtype_nodes)
 
+            pydoc_to_typing_annotation = {
+                "Sequence": "collections.abc.Sequence",
+                "Callable": "collections.abc.Callable",
+            }
+
+            modifier = pydoc_to_typing_annotation.get(modifier, modifier)
+
             new_dtype_node = DataTypeNode()
             if len(elm_dtype_nodes) >= 1:
-                append_child(new_dtype_node, nodes.Text(f"{m.group(1)}["))
+                append_child(new_dtype_node, nodes.Text(f"{modifier}["))
                 for i, dtype_nodes in enumerate(elm_dtype_nodes):
                     for j, dtype_node in enumerate(dtype_nodes):
                         for child in dtype_node.children:
@@ -759,7 +774,7 @@ def _get_refined_data_type_splited(
                         append_child(new_dtype_node, nodes.Text(", "))
                 append_child(new_dtype_node, nodes.Text("]"))
             else:
-                append_child(new_dtype_node, nodes.Text(m.group(1)))
+                append_child(new_dtype_node, nodes.Text(modifier))
             return [new_dtype_node]
 
         # Ex. string, default "", -> string

diff --git a/src/fake_bpy_module/utils.py b/src/fake_bpy_module/utils.py
@@ -56,27 +56,28 @@ def append_child(node: nodes.Node, item: nodes.Node) -> nodes.Node:
 
 
 # pylint: disable=R0912,R0915
-def split_string_by(line: str, separator: str) -> list:
+def split_string_by(line: str, separator: str,
+                    workaround_special_brace_case: bool) -> list:
     level = 0
     splited = []
     current = ""
     line_to_parse = line
 
-    # Handle case "arg1[, arg2]" -> "arg1, arg2"
-    sp = line_to_parse.split(f"[{separator}")
-    sub_strings = []
-    for i, s in enumerate(sp):
-        if i == 0:
-            sub_strings.append(s)
-        else:
-            assert s[-1] == "]"
-            sub_strings.append(s[:-1])
-    line_to_parse = separator.join(sub_strings)
-
-    # Handle case "[arg1]"
-    m = _ARG_LIST_WITH_BRACE_REGEX.match(line_to_parse)
-    if m:
-        line_to_parse = f"{m.group(1)}"
+    if workaround_special_brace_case:
+        # Handle case "arg1[, arg2]" -> "arg1, arg2"
+        sp = line_to_parse.split(f"[{separator}")
+        sub_strings = []
+        for i, s in enumerate(sp):
+            if i == 0:
+                sub_strings.append(s)
+            else:
+                assert s[-1] == "]"
+                sub_strings.append(s[:-1])
+        line_to_parse = separator.join(sub_strings)
+
+        # Handle case "[arg1]"
+        if m := _ARG_LIST_WITH_BRACE_REGEX.match(line_to_parse):
+            line_to_parse = f"{m.group(1)}"
 
     for c in line_to_parse:
         if c in ("(", "{", "["):
@@ -102,9 +103,11 @@ def split_string_by(line: str, separator: str) -> list:
     return [s.strip() for s in splited]
 
 
-def split_string_by_comma(line: str) -> list:
-    return split_string_by(line, ",")
+def split_string_by_comma(
+        line: str, workaround_special_brace_case: bool = True) -> list:
+    return split_string_by(line, ",", workaround_special_brace_case)
 
 
-def split_string_by_bar(line: str) -> list:
-    return split_string_by(line, "|")
+def split_string_by_bar(
+        line: str, workaround_special_brace_case: bool = True) -> list:
+    return split_string_by(line, "|", workaround_special_brace_case)
diff --git a/...bpy_module_test/transformer_test_data/data_type_refiner_test/expect/special_data_type.xml b/...bpy_module_test/transformer_test_data/data_type_refiner_test/expect/special_data_type.xml
@@ -32,6 +32,23 @@
         <data-type-list>
             <data-type>
                 list[UnknownType]
+    <data>
+        <name>
+            data_python_typing_syntax_4
+        <description>
+        <data-type-list>
+            <data-type>
+                Sequence[int]
+    <data>
+        <name>
+            data_python_typing_syntax_5
+        <description>
+        <data-type-list>
+            <data-type>
+                Callable[[int, 
+                <class-ref>
+                    ClassA
+                ], None]
     <data>
         <name>
             data_parentheses_pair

diff --git a/...est/transformer_test_data/data_type_refiner_test/expect/special_data_type_transformed.xml b/...est/transformer_test_data/data_type_refiner_test/expect/special_data_type_transformed.xml
@@ -38,6 +38,31 @@
         <data-type-list>
             <data-type option="never none">
                 list
+    <data>
+        <name>
+            data_python_typing_syntax_4
+        <description>
+        <data-type-list>
+            <data-type option="never none">
+                collections.abc.Sequence[
+                int
+                ]
+    <data>
+        <name>
+            data_python_typing_syntax_5
+        <description>
+        <data-type-list>
+            <data-type option="never none">
+                collections.abc.Callable[
+                [
+                int
+                , 
+                <class-ref>
+                    module_1.ClassA
+                ]
+                , 
+                None
+                ]
     <data>
         <name>
             data_parentheses_pair

diff --git a/...e_test/transformer_test_data/data_type_refiner_test/input/special_data_type.rst b/...e_test/transformer_test_data/data_type_refiner_test/input/special_data_type.rst
@@ -12,6 +12,14 @@
 
    :type: list[UnknownType]
 
+.. data:: data_python_typing_syntax_4
+
+   :type: Sequence[int]
+
+.. data:: data_python_typing_syntax_5
+
+   :type: Callable[[int, :class:`ClassA`], None]
+
 .. data:: data_parentheses_pair
 
    :type: (:class:`ClassA`, :class:`module_2.ClassB`) pair