diff --git a/modules/python/src2/typing_stubs_generation/generation.py b/modules/python/src2/typing_stubs_generation/generation.py index 563c09cc87..084a37a94b 100644 --- a/modules/python/src2/typing_stubs_generation/generation.py +++ b/modules/python/src2/typing_stubs_generation/generation.py @@ -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) diff --git a/modules/python/src2/typing_stubs_generation/nodes/type_node.py b/modules/python/src2/typing_stubs_generation/nodes/type_node.py index 3f242e730e..a1b7ce5b46 100644 --- a/modules/python/src2/typing_stubs_generation/nodes/type_node.py +++ b/modules/python/src2/typing_stubs_generation/nodes/type_node.py @@ -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: diff --git a/modules/python/src2/typing_stubs_generation/predefined_types.py b/modules/python/src2/typing_stubs_generation/predefined_types.py index dd764f6112..c5f49b5122 100644 --- a/modules/python/src2/typing_stubs_generation/predefined_types.py +++ b/modules/python/src2/typing_stubs_generation/predefined_types.py @@ -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", 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(