comtypes 1.1.14__zip → 1.2.1__zip

{comtypes-1.1.14 → comtypes-1.2.1}/comtypes/tools/tlbparser.py

@@ -1,17 +1,20 @@
 from __future__ import print_function
 import os
 import sys
-from ctypes import windll
-from ctypes import c_void_p
-from ctypes import sizeof
-from ctypes import alignment
-
-from comtypes import automation
-from comtypes import typeinfo
-from comtypes import COMError
+from ctypes import alignment, c_void_p, sizeof, windll
+
+from comtypes import automation, COMError, TYPE_CHECKING, typeinfo
 from comtypes.tools import typedesc
 from comtypes.client._code_cache import _get_module_filename
 
+if TYPE_CHECKING:
+    from typing import (
+        Any, Callable, Dict, List, Optional, Type, TypeVar, Tuple,
+        Union as _UnionT,
+    )
+    from ctypes import _CData, _Pointer
+    from comtypes import hints
+
 
 # Is the process 64-bit?
 is_64bits = sys.maxsize > 2**32
@@ -105,25 +108,26 @@ COMTYPES = {
 ################################################################
 
 class Parser(object):
+    if TYPE_CHECKING:
+        tlib = hints.AnnoField()  # type: typeinfo.ITypeLib
+        items = hints.AnnoField()  # type: Dict[str, Any]
 
     def make_type(self, tdesc, tinfo):
-        try:
+        # type: (typeinfo.TYPEDESC, typeinfo.ITypeInfo) -> Any
+        if tdesc.vt in COMTYPES:
             return COMTYPES[tdesc.vt]
-        except KeyError:
-            pass
-
         if tdesc.vt == automation.VT_CARRAY:
-            typ = self.make_type(tdesc._.lpadesc[0].tdescElem, tinfo)
-            for i in range(tdesc._.lpadesc[0].cDims):
-                typ = typedesc.ArrayType(typ,
-                                         tdesc._.lpadesc[0].rgbounds[i].lLbound,
-                                         tdesc._.lpadesc[0].rgbounds[i].cElements-1)
+            arraydesc = tdesc._.lpadesc[0]  # type: typeinfo.tagARRAYDESC
+            typ = self.make_type(arraydesc.tdescElem, tinfo)
+            for i in range(arraydesc.cDims):
+                typ = typedesc.ArrayType(
+                    typ, arraydesc.rgbounds[i].lLbound, arraydesc.rgbounds[i].cElements-1
+                )
             return typ
-
         elif tdesc.vt == automation.VT_PTR:
-            typ = self.make_type(tdesc._.lptdesc[0], tinfo)
+            ptrdesc = tdesc._.lptdesc[0]  # type: typeinfo.TYPEDESC
+            typ = self.make_type(ptrdesc, tinfo)
             return PTR(typ)
-
         elif tdesc.vt == automation.VT_USERDEFINED:
             try:
                 ti = tinfo.GetRefTypeInfo(tdesc._.hreftype)
@@ -136,26 +140,24 @@ class Parser(object):
                           (tlib_name, details, type_name)
                 import warnings
                 warnings.warn(message, UserWarning);
-                result = typedesc.Structure(type_name,
-                                            align=8,
-                                            members=[], bases=[],
-                                            size=0)
+                result = typedesc.Structure(
+                    type_name, align=8, members=[], bases=[], size=0
+                )
                 return result
             result = self.parse_typeinfo(ti)
             assert result is not None, ti.GetDocumentation(-1)[0]
             return result
-
         elif tdesc.vt == automation.VT_SAFEARRAY:
             # SAFEARRAY(<type>), see Don Box pp.331f
-            itemtype = self.make_type(tdesc._.lptdesc[0], tinfo)
-            return midlSAFEARRAY(itemtype)
-
+            safearraydesc = tdesc._.lptdesc[0]  # type: typeinfo.TYPEDESC
+            return midlSAFEARRAY(self.make_type(safearraydesc, tinfo))
         raise NotImplementedError(tdesc.vt)
 
     ################################################################
 
     # TKIND_ENUM = 0
     def ParseEnum(self, tinfo, ta):
+        # type: (typeinfo.ITypeInfo, typeinfo.TYPEATTR) -> typedesc.Enumeration
         ta = tinfo.GetTypeAttr()
         enum_name = tinfo.GetDocumentation(-1)[0]
         enum = typedesc.Enumeration(enum_name, 32, 32)
@@ -165,13 +167,14 @@ class Parser(object):
             vd = tinfo.GetVarDesc(i)
             name = tinfo.GetDocumentation(vd.memid)[0]
             assert vd.varkind == typeinfo.VAR_CONST
-            num_val = vd._.lpvarValue[0].value
+            num_val = vd._.lpvarValue[0].value  # type: int
             v = typedesc.EnumValue(name, num_val, enum)
             enum.add_value(v)
         return enum
 
     # TKIND_RECORD = 1
     def ParseRecord(self, tinfo, ta):
+        # type: (typeinfo.ITypeInfo, typeinfo.TYPEATTR) -> typedesc.Structure
         members = [] # will be filled later
         struct_name, doc, helpcntext, helpfile = tinfo.GetDocumentation(-1)
         struct = typedesc.Structure(struct_name,
@@ -211,6 +214,7 @@ class Parser(object):
 
     # TKIND_MODULE = 2
     def ParseModule(self, tinfo, ta):
+        # type: (typeinfo.ITypeInfo, typeinfo.TYPEATTR) -> None
         assert 0 == ta.cImplTypes
         # functions
         for i in range(ta.cFuncs):
@@ -253,6 +257,7 @@ class Parser(object):
 
     # TKIND_INTERFACE = 3
     def ParseInterface(self, tinfo, ta):
+        # type: (typeinfo.ITypeInfo, typeinfo.TYPEATTR) -> Optional[typedesc.ComInterface]
         itf_name, itf_doc = tinfo.GetDocumentation(-1)[0:2]
         assert ta.cImplTypes <= 1
         if ta.cImplTypes == 0 and itf_name != "IUnknown":
@@ -284,7 +289,6 @@ class Parser(object):
         members = []
         for i in range(ta.cFuncs):
             fd = tinfo.GetFuncDesc(i)
-##            func_name = tinfo.GetDocumentation(fd.memid)[0]
             func_name, func_doc = tinfo.GetDocumentation(fd.memid)[:2]
             assert fd.funckind == typeinfo.FUNC_PUREVIRTUAL
             returns = self.make_type(fd.elemdescFunc.tdesc, tinfo)
@@ -295,7 +299,6 @@ class Parser(object):
             flags = self.func_flags(fd.wFuncFlags)
             flags += self.inv_kind(fd.invkind)
             mth = typedesc.ComMethod(fd.invkind, fd.memid, func_name, returns, flags, func_doc)
-            mth.oVft = fd.oVft
             for p in range(fd.cParams):
                 typ = self.make_type(fd.lprgelemdescParam[p].tdesc, tinfo)
                 name = names[p+1]
@@ -303,7 +306,7 @@ class Parser(object):
                 if flags & typeinfo.PARAMFLAG_FHASDEFAULT:
                     # XXX should be handled by VARIANT itself
                     var = fd.lprgelemdescParam[p]._.paramdesc.pparamdescex[0].varDefaultValue
-                    default = var.value
+                    default = var.value  # type: Any
                 else:
                     default = None
                 mth.add_argument(typ, name, self.param_flags(flags), default)
@@ -317,6 +320,7 @@ class Parser(object):
 
     # TKIND_DISPATCH = 4
     def ParseDispatch(self, tinfo, ta):
+        # type: (typeinfo.ITypeInfo, typeinfo.TYPEATTR) -> typedesc.DispInterface
         itf_name, doc = tinfo.GetDocumentation(-1)[0:2]
         assert ta.cImplTypes == 1
 
@@ -372,20 +376,21 @@ class Parser(object):
             flags += self.inv_kind(fd.invkind)
             mth = typedesc.DispMethod(fd.memid, fd.invkind, func_name, returns, flags, func_doc)
             for p in range(fd.cParams):
-                typ = self.make_type(fd.lprgelemdescParam[p].tdesc, tinfo)
+                descparam = fd.lprgelemdescParam[p]
+                typ = self.make_type(descparam.tdesc, tinfo)
                 name = names[p+1]
-                flags = fd.lprgelemdescParam[p]._.paramdesc.wParamFlags
+                flags = descparam._.paramdesc.wParamFlags
                 if flags & typeinfo.PARAMFLAG_FHASDEFAULT:
-                    var = fd.lprgelemdescParam[p]._.paramdesc.pparamdescex[0].varDefaultValue
-                    default = var.value
+                    var = descparam._.paramdesc.pparamdescex[0].varDefaultValue  # type: ignore
+                    default = var.value  # type: Any
                 else:
                     default = None
                 mth.add_argument(typ, name, self.param_flags(flags), default)
             itf.members.append(mth)
-
         return itf
 
     def inv_kind(self, invkind):
+        # type: (int) -> List[str]
         NAMES = {automation.DISPATCH_METHOD: [],
                  automation.DISPATCH_PROPERTYPUT: ["propput"],
                  automation.DISPATCH_PROPERTYPUTREF: ["propputref"],
@@ -393,6 +398,7 @@ class Parser(object):
         return NAMES[invkind]
 
     def func_flags(self, flags):
+        # type: (int) -> List[str]
         # map FUNCFLAGS values to idl attributes
         NAMES = {typeinfo.FUNCFLAG_FRESTRICTED: "restricted",
                  typeinfo.FUNCFLAG_FSOURCE: "source",
@@ -410,6 +416,7 @@ class Parser(object):
         return [NAMES[bit] for bit in NAMES if bit & flags]
 
     def param_flags(self, flags):
+        # type: (int) -> List[str]
         # map PARAMFLAGS values to idl attributes
         NAMES = {typeinfo.PARAMFLAG_FIN: "in",
                  typeinfo.PARAMFLAG_FOUT: "out",
@@ -422,6 +429,7 @@ class Parser(object):
         return [NAMES[bit] for bit in NAMES if bit & flags]
 
     def coclass_type_flags(self, flags):
+        # type: (int) -> List[str]
         # map TYPEFLAGS values to idl attributes
         NAMES = {typeinfo.TYPEFLAG_FAPPOBJECT: "appobject",
                  # typeinfo.TYPEFLAG_FCANCREATE:
@@ -444,6 +452,7 @@ class Parser(object):
                [NEGATIVE_NAMES[bit] for bit in NEGATIVE_NAMES if not (bit & flags)]
 
     def interface_type_flags(self, flags):
+        # type: (int) -> List[str]
         # map TYPEFLAGS values to idl attributes
         NAMES = {typeinfo.TYPEFLAG_FAPPOBJECT: "appobject",
                  # typeinfo.TYPEFLAG_FCANCREATE:
@@ -466,6 +475,7 @@ class Parser(object):
                [NEGATIVE_NAMES[bit] for bit in NEGATIVE_NAMES if not (bit & flags)]
 
     def var_flags(self, flags):
+        # type: (int) -> List[str]
         NAMES = {typeinfo.VARFLAG_FREADONLY: "readonly",
                  typeinfo.VARFLAG_FSOURCE: "source",
                  typeinfo.VARFLAG_FBINDABLE: "bindable",
@@ -482,9 +492,9 @@ class Parser(object):
                  }
         return [NAMES[bit] for bit in NAMES if bit & flags]
 
-
     # TKIND_COCLASS = 5
     def ParseCoClass(self, tinfo, ta):
+        # type: (typeinfo.ITypeInfo, typeinfo.TYPEATTR) -> typedesc.CoClass
         # possible ta.wTypeFlags: helpstring, helpcontext, licensed,
         #        version, control, hidden, and appobject
         coclass_name, doc = tinfo.GetDocumentation(-1)[0:2]
@@ -507,6 +517,7 @@ class Parser(object):
 
     # TKIND_ALIAS = 6
     def ParseAlias(self, tinfo, ta):
+        # type: (typeinfo.ITypeInfo, typeinfo.TYPEATTR) -> typedesc.Typedef
         name = tinfo.GetDocumentation(-1)[0]
         typ = self.make_type(ta.tdescAlias, tinfo)
         alias = typedesc.Typedef(name, typ)
@@ -515,6 +526,7 @@ class Parser(object):
 
     # TKIND_UNION = 7
     def ParseUnion(self, tinfo, ta):
+        # type: (typeinfo.ITypeInfo, typeinfo.TYPEATTR) -> typedesc.Union
         union_name, doc, helpcntext, helpfile = tinfo.GetDocumentation(-1)
         members = []
         union = typedesc.Union(union_name,
@@ -549,6 +561,7 @@ class Parser(object):
     ################################################################
 
     def _typelib_module(self, tlib=None):
+        # type: (Optional[typeinfo.ITypeLib]) -> str
         if tlib is None:
             tlib = self.tlib
         # return a string that uniquely identifies a typelib.
@@ -556,6 +569,7 @@ class Parser(object):
         return str(tlib.GetLibAttr())
 
     def _register(self, name, value, tlib=None):
+        # type: (Optional[str], Any, Optional[typeinfo.ITypeLib]) -> None
         modname = self._typelib_module(tlib)
         fullname = "%s.%s" % (modname, name)
         if fullname in self.items:
@@ -567,6 +581,7 @@ class Parser(object):
         self.items[fullname] = value
 
     def parse_typeinfo(self, tinfo):
+        # type: (typeinfo.ITypeInfo) -> Any
         name = tinfo.GetDocumentation(-1)[0]
         modname = self._typelib_module()
         try:
@@ -579,11 +594,9 @@ class Parser(object):
             ta = tinfo.GetTypeAttr()
             size = ta.cbSizeInstance * 8
             align = ta.cbAlignment * 8
-            typ = typedesc.External(tlib,
-                                    name,
-                                    size,
-                                    align,
-                                    tlib.GetDocumentation(-1)[:2])
+            typ = typedesc.External(
+                tlib, name, size, align, tlib.GetDocumentation(-1)[:2]
+            )
             self._register(name, typ, tlib)
             return typ
 
@@ -730,36 +743,4 @@ def _py2exe_hint():
     import comtypes.typeinfo
     import comtypes.automation
 
-def generate_module(tlib, ofi, pathname):
-    known_symbols = {}
-    for name in ("comtypes.persist",
-                 "comtypes.typeinfo",
-                 "comtypes.automation",
-                 "comtypes._others",
-                 "comtypes",
-                 "ctypes.wintypes",
-                 "ctypes"):
-        try:
-            mod = __import__(name)
-        except ImportError:
-            if name == "comtypes._others":
-                continue
-            raise
-        for submodule in name.split(".")[1:]:
-            mod = getattr(mod, submodule)
-        for name in mod.__dict__:
-            known_symbols[name] = mod.__name__
-    p = TypeLibParser(tlib)
-    if pathname is None:
-        pathname = get_tlib_filename(tlib)
-    items = p.parse()
-
-    from .codegenerator import Generator
-
-    gen = Generator(ofi,
-                    known_symbols=known_symbols,
-                    )
-
-    gen.generate_code(list(items.values()), filename=pathname)
-
 # -eof-

{comtypes-1.1.14 → comtypes-1.2.1}/comtypes/tools/typedesc.py

@@ -2,10 +2,17 @@
 # in typedesc_base
 
 import ctypes
+from comtypes import TYPE_CHECKING
+from comtypes.typeinfo import ITypeLib, TLIBATTR
 from comtypes.tools.typedesc_base import *
 
+if TYPE_CHECKING:
+    from typing import Any, List, Optional, Tuple, Union as _UnionT
+
+
 class TypeLib(object):
     def __init__(self, name, guid, major, minor, doc=None):
+        # type: (str, str, int, int, Optional[str]) -> None
         self.name = name
         self.guid = guid
         self.major = major
@@ -17,12 +24,14 @@ class TypeLib(object):
 
 class Constant(object):
     def __init__(self, name, typ, value):
+        # type: (str, _UnionT[Typedef, FundamentalType], Any) -> None
         self.name = name
         self.typ = typ
         self.value = value
 
 class External(object):
     def __init__(self, tlib, name, size, align, docs=None):
+        # type: (ITypeLib, str, int, int, Optional[Tuple[str, str]]) -> None
         # the type library containing the symbol
         self.tlib = tlib
         # name of symbol
@@ -33,45 +42,52 @@ class External(object):
         self.docs = docs
 
     def get_head(self):
+        # type: () -> External
         # codegen might call this
         return self
 
 class SAFEARRAYType(object):
     def __init__(self, typ):
+        # type: (Any) -> None
         self.typ = typ
         self.align = self.size = ctypes.sizeof(ctypes.c_void_p) * 8
 
 class ComMethod(object):
     # custom COM method, parsed from typelib
     def __init__(self, invkind, memid, name, returns, idlflags, doc):
+        # type: (int, int, str, Any, List[str], Optional[str]) -> None
         self.invkind = invkind
         self.name = name
         self.returns = returns
         self.idlflags = idlflags
         self.memid = memid
         self.doc = doc
-        self.arguments = []
+        self.arguments = []  # type: List[Tuple[Any, str, List[str], Optional[Any]]]
 
     def add_argument(self, typ, name, idlflags, default):
+        # type: (Any, str, List[str], Optional[Any]) -> None
         self.arguments.append((typ, name, idlflags, default))
 
 class DispMethod(object):
     # dispatchable COM method, parsed from typelib
     def __init__(self, dispid, invkind, name, returns, idlflags, doc):
+        # type: (int, int, str, Any, List[str], Optional[str]) -> None
         self.dispid = dispid
         self.invkind = invkind
         self.name = name
         self.returns = returns
         self.idlflags = idlflags
         self.doc = doc
-        self.arguments = []
+        self.arguments = []  # type: List[Tuple[Any, str, List[str], Optional[Any]]]
 
     def add_argument(self, typ, name, idlflags, default):
+        # type: (Any, str, List[str], Optional[Any]) -> None
         self.arguments.append((typ, name, idlflags, default))
 
 class DispProperty(object):
     # dispatchable COM property, parsed from typelib
     def __init__(self, dispid, name, typ, idlflags, doc):
+        # type: (int, str, Any, List[str], Optional[Any]) -> None
         self.dispid = dispid
         self.name = name
         self.typ = typ
@@ -80,14 +96,17 @@ class DispProperty(object):
 
 class DispInterfaceHead(object):
     def __init__(self, itf):
+        # type: (DispInterface) -> None
         self.itf = itf
 
 class DispInterfaceBody(object):
     def __init__(self, itf):
+        # type: (DispInterface) -> None
         self.itf = itf
 
 class DispInterface(object):
     def __init__(self, name, members, base, iid, idlflags):
+        # type: (str, List[_UnionT[DispMethod, DispProperty]], Any, str, List[str]) -> None
         self.name = name
         self.members = members
         self.base = base
@@ -97,21 +116,26 @@ class DispInterface(object):
         self.itf_body = DispInterfaceBody(self)
 
     def get_body(self):
+        # type: () -> DispInterfaceBody
         return self.itf_body
 
     def get_head(self):
+        # type: () -> DispInterfaceHead
         return self.itf_head
 
 class ComInterfaceHead(object):
     def __init__(self, itf):
+        # type: (ComInterface) -> None
         self.itf = itf
 
 class ComInterfaceBody(object):
     def __init__(self, itf):
+        # type: (ComInterface) -> None
         self.itf = itf
 
 class ComInterface(object):
     def __init__(self, name, members, base, iid, idlflags):
+        # type: (str, List[ComMethod], Any, str, List[str]) -> None
         self.name = name
         self.members = members
         self.base = base
@@ -121,18 +145,22 @@ class ComInterface(object):
         self.itf_body = ComInterfaceBody(self)
 
     def get_body(self):
+        # type: () -> ComInterfaceBody
         return self.itf_body
 
     def get_head(self):
+        # type: () -> ComInterfaceHead
         return self.itf_head
 
 class CoClass(object):
     def __init__(self, name, clsid, idlflags, tlibattr):
+        # type: (str, str, List[str], TLIBATTR) -> None
         self.name = name
         self.clsid = clsid
         self.idlflags = idlflags
         self.tlibattr = tlibattr
-        self.interfaces = []
+        self.interfaces = []  # type: List[Tuple[Any, int]]
 
     def add_interface(self, itf, idlflags):
+        # type: (Any, int) -> None
         self.interfaces.append((itf, idlflags))

{comtypes-1.1.14 → comtypes-1.2.1}/comtypes/tools/typedesc_base.py

@@ -1,5 +1,12 @@
 # typedesc.py - classes representing C type descriptions
 
+import comtypes
+from comtypes import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, List, Optional, Tuple, Union as _UnionT, SupportsInt
+
+
 class Argument(object):
     "a Parameter in the argument list of a callable (Function, Method, ...)"
     def __init__(self, atype, name):
@@ -111,6 +118,7 @@ class Typedef(object):
 class ArrayType(object):
     location = None
     def __init__(self, typ, min, max):
+        # type: (Any, int, int) -> None
         self.typ = typ
         self.min = min
         self.max = max
@@ -118,27 +126,41 @@ class ArrayType(object):
 class StructureHead(object):
     location = None
     def __init__(self, struct):
+        # type: (_Struct_Union_Base) -> None
         self.struct = struct
 
 class StructureBody(object):
     location = None
     def __init__(self, struct):
+        # type: (_Struct_Union_Base) -> None
         self.struct = struct
 
 class _Struct_Union_Base(object):
+    if TYPE_CHECKING:
+        name = comtypes.hints.AnnoField()  # type: str
+        align = comtypes.hints.AnnoField()  # type: int
+        members = comtypes.hints.AnnoField()  # type: List[_UnionT[Field, Method, Constructor]]
+        bases = comtypes.hints.AnnoField()  # type: List[_Struct_Union_Base]
+        artificial = comtypes.hints.AnnoField()  # type: Optional[Any]
+        size = comtypes.hints.AnnoField()  # type: Optional[int]
+        _recordinfo_ = comtypes.hints.AnnoField()  # type: Tuple[str, int, int, int, str]
+
     location = None
     def __init__(self):
         self.struct_body = StructureBody(self)
         self.struct_head = StructureHead(self)
 
     def get_body(self):
+        # type: () -> StructureBody
         return self.struct_body
 
     def get_head(self):
+        # type: () -> StructureHead
         return self.struct_head
 
 class Structure(_Struct_Union_Base):
     def __init__(self, name, align, members, bases, size, artificial=None):
+        # type: (str, SupportsInt, List[Field], List[Any], Optional[SupportsInt], Optional[Any]) -> None
         self.name = name
         self.align = int(align)
         self.members = members
@@ -152,6 +174,7 @@ class Structure(_Struct_Union_Base):
 
 class Union(_Struct_Union_Base):
     def __init__(self, name, align, members, bases, size, artificial=None):
+        # type: (str, SupportsInt, List[Field], List[Any], Optional[SupportsInt], Optional[Any]) -> None
         self.name = name
         self.align = int(align)
         self.members = members
@@ -165,6 +188,7 @@ class Union(_Struct_Union_Base):
 
 class Field(object):
     def __init__(self, name, typ, bits, offset):
+        # type: (str, Any, Optional[Any], SupportsInt) -> None
         self.name = name
         self.typ = typ
         self.bits = bits
@@ -179,16 +203,19 @@ class CvQualifiedType(object):
 class Enumeration(object):
     location = None
     def __init__(self, name, size, align):
+        # type: (str, SupportsInt, SupportsInt) -> None
         self.name = name
         self.size = int(size)
         self.align = int(align)
-        self.values = []
+        self.values = []  # type: List[EnumValue]
 
     def add_value(self, v):
+        # type: (EnumValue) -> None
         self.values.append(v)
 
 class EnumValue(object):
     def __init__(self, name, value, enumeration):
+        # type: (str, int, Enumeration) -> None
         self.name = name
         self.value = value
         self.enumeration = enumeration