Made some pre-defined Python types optional to disable modules

2026-07-29 07:13:02 +04:00 · 2024-11-27 14:34:33 +03:00
parent 0ca98d437b
commit a8f4019932
3 changed files with 205 additions and 128 deletions
@@ -706,6 +706,10 @@ def _generate_typing_module(root: NamespaceNode, output_path: Path) -> None:
        output_path (Path): Path to typing module directory, where __init__.pyi
            will be written.
    """
+
+    def has_all_required_modules(type_node: TypeNode) -> bool:
+        return all(em in root.namespaces for em in node.required_modules)
+
    def register_alias_links_from_aggregated_type(type_node: TypeNode) -> None:
        assert isinstance(type_node, AggregatedTypeNode), \
            f"Provided type node '{type_node.ctype_name}' is not an aggregated type"
@@ -791,6 +795,10 @@ def _generate_typing_module(root: NamespaceNode, output_path: Path) -> None:
    # Resolve each node and register aliases
    TypeNode.compatible_to_runtime_usage = True
    for node in PREDEFINED_TYPES.values():
+        # if node does not have at least one required module skip it
+        # e.g. GArgs requires G-API module, so if build without G-API GArgs is not included
+        if not has_all_required_modules(node):
+            continue
        node.resolve(root)
        if isinstance(node, AliasTypeNode):
            register_alias(node)
@@ -1,6 +1,7 @@
 from typing import Sequence, Generator, Tuple, Optional, Union
 import weakref
 import abc
+from itertools import chain

 from .node import ASTNode, ASTNodeType

@@ -30,8 +31,9 @@ class TypeNode(abc.ABC):
    "typing.Optional[Size]"
    """

-    def __init__(self, ctype_name: str) -> None:
+    def __init__(self, ctype_name: str, required_modules: Tuple[str, ...] = ()) -> None:
        self.ctype_name = ctype_name
+        self._required_modules = required_modules

    @abc.abstractproperty
    def typename(self) -> str:
@@ -113,6 +115,10 @@ class TypeNode(abc.ABC):
        """
        yield from ()

+    @property
+    def required_modules(self) -> Tuple[str, ...]:
+        return self._required_modules
+
    @property
    def is_resolved(self) -> bool:
        return True
@@ -173,8 +179,10 @@ class AnyTypeNode(TypeNode):
 class PrimitiveTypeNode(TypeNode):
    """Type node representing a primitive built-in types e.g. int, float, str.
    """
-    def __init__(self, ctype_name: str, typename: Optional[str] = None) -> None:
-        super().__init__(ctype_name)
+    def __init__(self, ctype_name: str,
+                 typename: Optional[str] = None,
+                 required_modules: Tuple[str, ...] = ()) -> None:
+        super().__init__(ctype_name, required_modules)
        self._typename = typename if typename is not None else ctype_name

    @property
@@ -182,28 +190,32 @@ class PrimitiveTypeNode(TypeNode):
        return self._typename

    @classmethod
-    def int_(cls, ctype_name: Optional[str] = None):
+    def int_(cls, ctype_name: Optional[str] = None,
+             required_modules: Tuple[str, ...] = ()):
        if ctype_name is None:
            ctype_name = "int"
-        return PrimitiveTypeNode(ctype_name, typename="int")
+        return PrimitiveTypeNode(ctype_name, typename="int", required_modules=required_modules)

    @classmethod
-    def float_(cls, ctype_name: Optional[str] = None):
+    def float_(cls, ctype_name: Optional[str] = None,
+               required_modules: Tuple[str, ...] = ()):
        if ctype_name is None:
            ctype_name = "float"
-        return PrimitiveTypeNode(ctype_name, typename="float")
+        return PrimitiveTypeNode(ctype_name, typename="float", required_modules=required_modules)

    @classmethod
-    def bool_(cls, ctype_name: Optional[str] = None):
+    def bool_(cls, ctype_name: Optional[str] = None,
+              required_modules: Tuple[str, ...] = ()):
        if ctype_name is None:
            ctype_name = "bool"
-        return PrimitiveTypeNode(ctype_name, typename="bool")
+        return PrimitiveTypeNode(ctype_name, typename="bool", required_modules=required_modules)

    @classmethod
-    def str_(cls, ctype_name: Optional[str] = None):
+    def str_(cls, ctype_name: Optional[str] = None,
+             required_modules: Tuple[str, ...] = ()):
        if ctype_name is None:
            ctype_name = "string"
-        return PrimitiveTypeNode(ctype_name, "str")
+        return PrimitiveTypeNode(ctype_name, "str", required_modules=required_modules)


 class AliasRefTypeNode(TypeNode):
@@ -224,8 +236,9 @@ class AliasRefTypeNode(TypeNode):
    ```
    """
    def __init__(self, alias_ctype_name: str,
-                 alias_export_name: Optional[str] = None):
-        super().__init__(alias_ctype_name)
+                 alias_export_name: Optional[str] = None,
+                 required_modules: Tuple[str, ...] = ()):
+        super().__init__(alias_ctype_name, required_modules)
        if alias_export_name is None:
            self.alias_export_name = alias_ctype_name
        else:
@@ -258,8 +271,9 @@ class AliasTypeNode(TypeNode):
    """
    def __init__(self, ctype_name: str, value: TypeNode,
                 export_name: Optional[str] = None,
-                 doc: Optional[str] = None) -> None:
-        super().__init__(ctype_name)
+                 doc: Optional[str] = None,
+                 required_modules: Tuple[str, ...] = ()) -> None:
+        super().__init__(ctype_name, required_modules)
        self.value = value
        self._export_name = export_name
        self.doc = doc
@@ -298,20 +312,21 @@ class AliasTypeNode(TypeNode):

    @classmethod
    def int_(cls, ctype_name: str, export_name: Optional[str] = None,
-             doc: Optional[str] = None):
-        return cls(ctype_name, PrimitiveTypeNode.int_(), export_name, doc)
+             doc: Optional[str] = None, required_modules: Tuple[str, ...] = ()):
+        return cls(ctype_name, PrimitiveTypeNode.int_(), export_name, doc, required_modules)

    @classmethod
    def float_(cls, ctype_name: str, export_name: Optional[str] = None,
-               doc: Optional[str] = None):
-        return cls(ctype_name, PrimitiveTypeNode.float_(), export_name, doc)
+               doc: Optional[str] = None, required_modules: Tuple[str, ...] = ()):
+        return cls(ctype_name, PrimitiveTypeNode.float_(), export_name, doc, required_modules)

    @classmethod
    def array_ref_(cls, ctype_name: str, array_ref_name: str,
                   shape: Optional[Tuple[int, ...]],
                   dtype: Optional[str] = None,
                   export_name: Optional[str] = None,
-                   doc: Optional[str] = None):
+                   doc: Optional[str] = None,
+                   required_modules: Tuple[str, ...] = ()):
        """Create alias to array reference alias `array_ref_name`.

        This is required to preserve backward compatibility with Python < 3.9
@@ -332,65 +347,74 @@ class AliasTypeNode(TypeNode):
        else:
            doc += f". NDArray(shape={shape}, dtype={dtype})"
        return cls(ctype_name, AliasRefTypeNode(array_ref_name),
-                   export_name, doc)
+                   export_name, doc, required_modules)

    @classmethod
    def union_(cls, ctype_name: str, items: Tuple[TypeNode, ...],
               export_name: Optional[str] = None,
-               doc: Optional[str] = None):
+               doc: Optional[str] = None,
+               required_modules: Tuple[str, ...] = ()):
        return cls(ctype_name, UnionTypeNode(ctype_name, items),
-                   export_name, doc)
+                   export_name, doc, required_modules)

    @classmethod
    def optional_(cls, ctype_name: str, item: TypeNode,
                  export_name: Optional[str] = None,
-                  doc: Optional[str] = None):
-        return cls(ctype_name, OptionalTypeNode(item), export_name, doc)
+                  doc: Optional[str] = None,
+                  required_modules: Tuple[str, ...] = ()):
+        return cls(ctype_name, OptionalTypeNode(item), export_name, doc, required_modules)

    @classmethod
    def sequence_(cls, ctype_name: str, item: TypeNode,
                  export_name: Optional[str] = None,
-                  doc: Optional[str] = None):
+                  doc: Optional[str] = None,
+                  required_modules: Tuple[str, ...] = ()):
        return cls(ctype_name, SequenceTypeNode(ctype_name, item),
-                   export_name, doc)
+                   export_name, doc, required_modules)

    @classmethod
    def tuple_(cls, ctype_name: str, items: Tuple[TypeNode, ...],
               export_name: Optional[str] = None,
-               doc: Optional[str] = None):
+               doc: Optional[str] = None,
+               required_modules: Tuple[str, ...] = ()):
        return cls(ctype_name, TupleTypeNode(ctype_name, items),
-                   export_name, doc)
+                   export_name, doc, required_modules)

    @classmethod
    def class_(cls, ctype_name: str, class_name: str,
               export_name: Optional[str] = None,
-               doc: Optional[str] = None):
+               doc: Optional[str] = None,
+               required_modules: Tuple[str, ...] = ()):
        return cls(ctype_name, ASTNodeTypeNode(class_name),
-                   export_name, doc)
+                   export_name, doc, required_modules)

    @classmethod
    def callable_(cls, ctype_name: str,
                  arg_types: Union[TypeNode, Sequence[TypeNode]],
                  ret_type: TypeNode = NoneTypeNode("void"),
                  export_name: Optional[str] = None,
-                  doc: Optional[str] = None):
+                  doc: Optional[str] = None,
+                  required_modules: Tuple[str, ...] = ()):
        return cls(ctype_name,
                   CallableTypeNode(ctype_name, arg_types, ret_type),
-                   export_name, doc)
+                   export_name, doc, required_modules)

    @classmethod
    def ref_(cls, ctype_name: str, alias_ctype_name: str,
             alias_export_name: Optional[str] = None,
-             export_name: Optional[str] = None, doc: Optional[str] = None):
+             export_name: Optional[str] = None,
+             doc: Optional[str] = None,
+             required_modules: Tuple[str, ...] = ()):
        return cls(ctype_name,
                   AliasRefTypeNode(alias_ctype_name, alias_export_name),
-                   export_name, doc)
+                   export_name, doc, required_modules)

    @classmethod
    def dict_(cls, ctype_name: str, key_type: TypeNode, value_type: TypeNode,
-              export_name: Optional[str] = None, doc: Optional[str] = None):
+              export_name: Optional[str] = None, doc: Optional[str] = None,
+              required_modules: Tuple[str, ...] = ()):
        return cls(ctype_name, DictTypeNode(ctype_name, key_type, value_type),
-                   export_name, doc)
+                   export_name, doc, required_modules)


 class ConditionalAliasTypeNode(TypeNode):
@@ -451,6 +475,11 @@ class ConditionalAliasTypeNode(TypeNode):
    def required_usage_imports(self) -> Generator[str, None, None]:
        yield "import cv2.typing"

+    @property
+    def required_modules(self) -> Tuple[str, ...]:
+        return (*self.positive_branch_type.required_modules,
+                *self.negative_branch_type.required_modules)
+
    @property
    def is_resolved(self) -> bool:
        return self.positive_branch_type.is_resolved \
@@ -519,8 +548,9 @@ class ASTNodeTypeNode(TypeNode):
    too expensive and error prone.
    """
    def __init__(self, ctype_name: str, typename: Optional[str] = None,
-                 module_name: Optional[str] = None) -> None:
-        super().__init__(ctype_name)
+                 module_name: Optional[str] = None,
+                 required_modules: Tuple[str, ...] = ()) -> None:
+        super().__init__(ctype_name, required_modules)
        self._typename = typename if typename is not None else ctype_name
        self._module_name = module_name
        self._ast_node: Optional[weakref.ProxyType[ASTNode]] = None
@@ -607,14 +637,20 @@ class ASTNodeTypeNode(TypeNode):
 class AggregatedTypeNode(TypeNode):
    """Base type node for type nodes representing an aggregation of another
    type nodes e.g. tuple, sequence or callable."""
-    def __init__(self, ctype_name: str, items: Sequence[TypeNode]) -> None:
-        super().__init__(ctype_name)
+    def __init__(self, ctype_name: str, items: Sequence[TypeNode],
+                 required_modules: Tuple[str, ...] = ()) -> None:
+        super().__init__(ctype_name, required_modules)
        self.items = list(items)

    @property
    def is_resolved(self) -> bool:
        return all(item.is_resolved for item in self.items)

+    @property
+    def required_modules(self) -> Tuple[str, ...]:
+        return (*chain.from_iterable(item.required_modules for item in self.items),
+                *self._required_modules)
+
    def resolve(self, root: ASTNode) -> None:
        errors = []
        for item in filter(lambda item: not item.is_resolved, self):
@@ -690,8 +726,9 @@ class SequenceTypeNode(ContainerTypeNode):
    """Type node representing a homogeneous collection of elements with
    possible unknown length.
    """
-    def __init__(self, ctype_name: str, item: TypeNode) -> None:
-        super().__init__(ctype_name, (item, ))
+    def __init__(self, ctype_name: str, item: TypeNode,
+                 required_modules: Tuple[str, ...] = ()) -> None:
+        super().__init__(ctype_name, (item, ), required_modules)

    @property
    def type_format(self) -> str:
@@ -737,8 +774,9 @@ class OptionalTypeNode(ContainerTypeNode):
    """Type node representing optional type which is effectively is a union
    of value type node and None.
    """
-    def __init__(self, value: TypeNode) -> None:
-        super().__init__(value.ctype_name, (value,))
+    def __init__(self, value: TypeNode,
+                 required_modules: Tuple[str, ...] = ()) -> None:
+        super().__init__(value.ctype_name, (value,), required_modules)

    @property
    def type_format(self) -> str:
@@ -755,8 +793,9 @@ class DictTypeNode(ContainerTypeNode):
    """Type node representing a homogeneous key-value mapping.
    """
    def __init__(self, ctype_name: str, key_type: TypeNode,
-                 value_type: TypeNode) -> None:
-        super().__init__(ctype_name, (key_type, value_type))
+                 value_type: TypeNode,
+                 required_modules: Tuple[str, ...] = ()) -> None:
+        super().__init__(ctype_name, (key_type, value_type), required_modules)

    @property
    def key_type(self) -> TypeNode:
@@ -794,11 +833,12 @@ class CallableTypeNode(AggregatedTypeNode):
    """
    def __init__(self, ctype_name: str,
                 arg_types: Union[TypeNode, Sequence[TypeNode]],
-                 ret_type: TypeNode = NoneTypeNode("void")) -> None:
+                 ret_type: TypeNode = NoneTypeNode("void"),
+                 required_modules: Tuple[str, ...] = ()) -> None:
        if isinstance(arg_types, TypeNode):
-            super().__init__(ctype_name, (arg_types, ret_type))
+            super().__init__(ctype_name, (arg_types, ret_type), required_modules)
        else:
-            super().__init__(ctype_name, (*arg_types, ret_type))
+            super().__init__(ctype_name, (*arg_types, ret_type), required_modules)

    @property
    def arg_types(self) -> Sequence[TypeNode]:
@@ -842,8 +882,9 @@ class CallableTypeNode(AggregatedTypeNode):
 class ClassTypeNode(ContainerTypeNode):
    """Type node representing types themselves (refer to typing.Type)
    """
-    def __init__(self, value: TypeNode) -> None:
-        super().__init__(value.ctype_name, (value,))
+    def __init__(self, value: TypeNode,
+                 required_modules: Tuple[str, ...] = ()) -> None:
+        super().__init__(value.ctype_name, (value,), required_modules)

    @property
    def type_format(self) -> str:
@@ -118,38 +118,6 @@ _PREDEFINED_TYPES = (
                         export_name="DescriptorExtractor"),
    AliasTypeNode.class_("FeatureExtractor", "Feature2D",
                         export_name="FeatureExtractor"),
-    AliasTypeNode.union_("GProtoArg",
-                         items=(AliasRefTypeNode("Scalar"),
-                                ASTNodeTypeNode("GMat"),
-                                ASTNodeTypeNode("GOpaqueT"),
-                                ASTNodeTypeNode("GArrayT"))),
-    SequenceTypeNode("GProtoArgs", AliasRefTypeNode("GProtoArg")),
-    AliasTypeNode.sequence_("GProtoInputArgs", AliasRefTypeNode("GProtoArg")),
-    AliasTypeNode.sequence_("GProtoOutputArgs", AliasRefTypeNode("GProtoArg")),
-    AliasTypeNode.union_(
-        "GRunArg",
-        items=(AliasRefTypeNode("Mat", "MatLike"),
-               AliasRefTypeNode("Scalar"),
-               ASTNodeTypeNode("GOpaqueT"),
-               ASTNodeTypeNode("GArrayT"),
-               SequenceTypeNode("GRunArg", AnyTypeNode("GRunArg")),
-               NoneTypeNode("GRunArg"))
-    ),
-    AliasTypeNode.optional_("GOptRunArg", AliasRefTypeNode("GRunArg")),
-    AliasTypeNode.union_("GMetaArg",
-                         items=(ASTNodeTypeNode("GMat"),
-                                AliasRefTypeNode("Scalar"),
-                                ASTNodeTypeNode("GOpaqueT"),
-                                ASTNodeTypeNode("GArrayT"))),
-    AliasTypeNode.union_("Prim",
-                         items=(ASTNodeTypeNode("gapi.wip.draw.Text"),
-                                ASTNodeTypeNode("gapi.wip.draw.Circle"),
-                                ASTNodeTypeNode("gapi.wip.draw.Image"),
-                                ASTNodeTypeNode("gapi.wip.draw.Line"),
-                                ASTNodeTypeNode("gapi.wip.draw.Rect"),
-                                ASTNodeTypeNode("gapi.wip.draw.Mosaic"),
-                                ASTNodeTypeNode("gapi.wip.draw.Poly"))),
-    SequenceTypeNode("Prims", AliasRefTypeNode("Prim")),
    AliasTypeNode.array_ref_("Matx33f",
                             array_ref_name="NumPyArrayFloat32",
                             shape=(3, 3),
@@ -168,44 +136,23 @@ _PREDEFINED_TYPES = (
                             dtype="numpy.float64"),
    NDArrayTypeNode("vector<uchar>", dtype="numpy.uint8"),
    NDArrayTypeNode("vector_uchar", dtype="numpy.uint8"),
-    TupleTypeNode("GMat2", items=(ASTNodeTypeNode("GMat"),
-                                  ASTNodeTypeNode("GMat"))),
-    ASTNodeTypeNode("GOpaque", "GOpaqueT"),
-    ASTNodeTypeNode("GArray", "GArrayT"),
-    AliasTypeNode.union_("GTypeInfo",
-                         items=(ASTNodeTypeNode("GMat"),
-                                AliasRefTypeNode("Scalar"),
-                                ASTNodeTypeNode("GOpaqueT"),
-                                ASTNodeTypeNode("GArrayT"))),
-    SequenceTypeNode("GCompileArgs", ASTNodeTypeNode("GCompileArg")),
-    SequenceTypeNode("GTypesInfo", AliasRefTypeNode("GTypeInfo")),
-    SequenceTypeNode("GRunArgs", AliasRefTypeNode("GRunArg")),
-    SequenceTypeNode("GMetaArgs", AliasRefTypeNode("GMetaArg")),
-    SequenceTypeNode("GOptRunArgs", AliasRefTypeNode("GOptRunArg")),
-    AliasTypeNode.callable_(
-        "detail_ExtractArgsCallback",
-        arg_types=SequenceTypeNode("GTypesInfo", AliasRefTypeNode("GTypeInfo")),
-        ret_type=SequenceTypeNode("GRunArgs", AliasRefTypeNode("GRunArg")),
-        export_name="ExtractArgsCallback"
-    ),
-    AliasTypeNode.callable_(
-        "detail_ExtractMetaCallback",
-        arg_types=SequenceTypeNode("GTypesInfo", AliasRefTypeNode("GTypeInfo")),
-        ret_type=SequenceTypeNode("GMetaArgs", AliasRefTypeNode("GMetaArg")),
-        export_name="ExtractMetaCallback"
-    ),
-    AliasTypeNode.class_("LayerId", "DictValue"),
+
+    # DNN, optional
+    AliasTypeNode.class_("LayerId", "DictValue", required_modules=("dnn",)),
    AliasTypeNode.dict_("LayerParams",
                        key_type=PrimitiveTypeNode.str_(),
                        value_type=UnionTypeNode("DictValue", items=(
                            PrimitiveTypeNode.int_(),
                            PrimitiveTypeNode.float_(),
                            PrimitiveTypeNode.str_())
-                        )),
-    PrimitiveTypeNode.int_("cvflann_flann_distance_t"),
-    PrimitiveTypeNode.int_("flann_flann_distance_t"),
-    PrimitiveTypeNode.int_("cvflann_flann_algorithm_t"),
-    PrimitiveTypeNode.int_("flann_flann_algorithm_t"),
+                        ),
+                        required_modules=("dnn",)),
+
+    # Flann, optional
+    PrimitiveTypeNode.int_("cvflann_flann_distance_t", required_modules=("flann",)),
+    PrimitiveTypeNode.int_("flann_flann_distance_t", required_modules=("flann",)),
+    PrimitiveTypeNode.int_("cvflann_flann_algorithm_t", required_modules=("flann",)),
+    PrimitiveTypeNode.int_("flann_flann_algorithm_t", required_modules=("flann",)),
    AliasTypeNode.dict_("flann_IndexParams",
                        key_type=PrimitiveTypeNode.str_(),
                        value_type=UnionTypeNode("flann_IndexParams::value", items=(
@@ -213,7 +160,9 @@ _PREDEFINED_TYPES = (
                            PrimitiveTypeNode.int_(),
                            PrimitiveTypeNode.float_(),
                            PrimitiveTypeNode.str_())
-                        ), export_name="IndexParams"),
+                        ),
+                        export_name="IndexParams",
+                        required_modules=("flann",)),
    AliasTypeNode.dict_("flann_SearchParams",
                        key_type=PrimitiveTypeNode.str_(),
                        value_type=UnionTypeNode("flann_IndexParams::value", items=(
@@ -221,17 +170,96 @@ _PREDEFINED_TYPES = (
                            PrimitiveTypeNode.int_(),
                            PrimitiveTypeNode.float_(),
                            PrimitiveTypeNode.str_())
-                        ), export_name="SearchParams"),
-    AliasTypeNode.dict_("map_string_and_string", PrimitiveTypeNode.str_("map_string_and_string::key"),
-                        PrimitiveTypeNode.str_("map_string_and_string::value")),
-    AliasTypeNode.dict_("map_string_and_int", PrimitiveTypeNode.str_("map_string_and_int::key"),
-                        PrimitiveTypeNode.int_("map_string_and_int::value")),
-    AliasTypeNode.dict_("map_string_and_vector_size_t", PrimitiveTypeNode.str_("map_string_and_vector_size_t::key"),
-                        SequenceTypeNode("map_string_and_vector_size_t::value", PrimitiveTypeNode.int_("size_t"))),
-    AliasTypeNode.dict_("map_string_and_vector_float", PrimitiveTypeNode.str_("map_string_and_vector_float::key"),
-                        SequenceTypeNode("map_string_and_vector_float::value", PrimitiveTypeNode.float_())),
-    AliasTypeNode.dict_("map_int_and_double", PrimitiveTypeNode.int_("map_int_and_double::key"),
-                        PrimitiveTypeNode.float_("map_int_and_double::value")),
+                        ),
+                        export_name="SearchParams",
+                        required_modules=("flann",)),
+    AliasTypeNode.dict_("map_string_and_string",
+                        PrimitiveTypeNode.str_("map_string_and_string::key"),
+                        PrimitiveTypeNode.str_("map_string_and_string::value"),
+                        required_modules=("flann",)),
+    AliasTypeNode.dict_("map_string_and_int",
+                        PrimitiveTypeNode.str_("map_string_and_int::key"),
+                        PrimitiveTypeNode.int_("map_string_and_int::value"),
+                        required_modules=("flann",)),
+    AliasTypeNode.dict_("map_string_and_vector_size_t",
+                        PrimitiveTypeNode.str_("map_string_and_vector_size_t::key"),
+                        SequenceTypeNode("map_string_and_vector_size_t::value", PrimitiveTypeNode.int_("size_t")),
+                        required_modules=("flann",)),
+    AliasTypeNode.dict_("map_string_and_vector_float",
+                        PrimitiveTypeNode.str_("map_string_and_vector_float::key"),
+                        SequenceTypeNode("map_string_and_vector_float::value", PrimitiveTypeNode.float_()),
+                        required_modules=("flann",)),
+    AliasTypeNode.dict_("map_int_and_double",
+                        PrimitiveTypeNode.int_("map_int_and_double::key"),
+                        PrimitiveTypeNode.float_("map_int_and_double::value"),
+                        required_modules=("flann",)),
+
+    # G-API, optional
+    AliasTypeNode.union_("GProtoArg",
+                         items=(AliasRefTypeNode("Scalar"),
+                                ASTNodeTypeNode("GMat"),
+                                ASTNodeTypeNode("GOpaqueT"),
+                                ASTNodeTypeNode("GArrayT")),
+                         required_modules=("gapi",)),
+    SequenceTypeNode("GProtoArgs", AliasRefTypeNode("GProtoArg"), required_modules=("gapi",)),
+    AliasTypeNode.sequence_("GProtoInputArgs", AliasRefTypeNode("GProtoArg"), required_modules=("gapi",)),
+    AliasTypeNode.sequence_("GProtoOutputArgs", AliasRefTypeNode("GProtoArg"), required_modules=("gapi",)),
+    AliasTypeNode.union_(
+        "GRunArg",
+        items=(AliasRefTypeNode("Mat", "MatLike"),
+               AliasRefTypeNode("Scalar"),
+               ASTNodeTypeNode("GOpaqueT"),
+               ASTNodeTypeNode("GArrayT"),
+               SequenceTypeNode("GRunArg", AnyTypeNode("GRunArg")),
+               NoneTypeNode("GRunArg")),
+        required_modules=("gapi",)
+    ),
+    AliasTypeNode.optional_("GOptRunArg", AliasRefTypeNode("GRunArg"), required_modules=("gapi",)),
+    AliasTypeNode.union_("GMetaArg",
+                         items=(ASTNodeTypeNode("GMat"),
+                                AliasRefTypeNode("Scalar"),
+                                ASTNodeTypeNode("GOpaqueT"),
+                                ASTNodeTypeNode("GArrayT")),
+                         required_modules=("gapi",)),
+    AliasTypeNode.union_("Prim",
+                         items=(ASTNodeTypeNode("gapi.wip.draw.Text"),
+                                ASTNodeTypeNode("gapi.wip.draw.Circle"),
+                                ASTNodeTypeNode("gapi.wip.draw.Image"),
+                                ASTNodeTypeNode("gapi.wip.draw.Line"),
+                                ASTNodeTypeNode("gapi.wip.draw.Rect"),
+                                ASTNodeTypeNode("gapi.wip.draw.Mosaic"),
+                                ASTNodeTypeNode("gapi.wip.draw.Poly")),
+                         required_modules=("gapi",)),
+    SequenceTypeNode("Prims", AliasRefTypeNode("Prim"), required_modules=("gapi",)),
+    TupleTypeNode("GMat2", items=(ASTNodeTypeNode("GMat"),
+                                  ASTNodeTypeNode("GMat")), required_modules=("gapi",)),
+    ASTNodeTypeNode("GOpaque", "GOpaqueT", required_modules=("gapi",)),
+    ASTNodeTypeNode("GArray", "GArrayT", required_modules=("gapi",)),
+    AliasTypeNode.union_("GTypeInfo",
+                         items=(ASTNodeTypeNode("GMat"),
+                                AliasRefTypeNode("Scalar"),
+                                ASTNodeTypeNode("GOpaqueT"),
+                                ASTNodeTypeNode("GArrayT")),
+                         required_modules=("gapi",)),
+    SequenceTypeNode("GCompileArgs", ASTNodeTypeNode("GCompileArg"), required_modules=("gapi",)),
+    SequenceTypeNode("GTypesInfo", AliasRefTypeNode("GTypeInfo"), required_modules=("gapi",)),
+    SequenceTypeNode("GRunArgs", AliasRefTypeNode("GRunArg"), required_modules=("gapi",)),
+    SequenceTypeNode("GMetaArgs", AliasRefTypeNode("GMetaArg"), required_modules=("gapi",)),
+    SequenceTypeNode("GOptRunArgs", AliasRefTypeNode("GOptRunArg"), required_modules=("gapi",)),
+    AliasTypeNode.callable_(
+        "detail_ExtractArgsCallback",
+        arg_types=SequenceTypeNode("GTypesInfo", AliasRefTypeNode("GTypeInfo")),
+        ret_type=SequenceTypeNode("GRunArgs", AliasRefTypeNode("GRunArg")),
+        export_name="ExtractArgsCallback",
+        required_modules=("gapi",)
+    ),
+    AliasTypeNode.callable_(
+        "detail_ExtractMetaCallback",
+        arg_types=SequenceTypeNode("GTypesInfo", AliasRefTypeNode("GTypeInfo")),
+        ret_type=SequenceTypeNode("GMetaArgs", AliasRefTypeNode("GMetaArg")),
+        export_name="ExtractMetaCallback",
+        required_modules=("gapi",)
+    ),
 )

 PREDEFINED_TYPES = dict(