comtypes 1.4.4__zip → 1.4.6__zip

comtypes-1.4.6/comtypes/test/test_recordinfo.py

@@ -0,0 +1,79 @@
+# coding: utf-8
+
+import unittest
+
+from comtypes import typeinfo
+from comtypes.client import GetModule
+from ctypes import byref, pointer, sizeof
+
+ComtypesCppTestSrvLib_GUID = "{07D2AEE5-1DF8-4D2C-953A-554ADFD25F99}"
+
+try:
+    GetModule((ComtypesCppTestSrvLib_GUID, 1, 0, 0))
+    from comtypes.gen.ComtypesCppTestSrvLib import StructRecordParamTest
+
+    IMPORT_FAILED = False
+except (ImportError, OSError):
+    IMPORT_FAILED = True
+
+
+def _create_recordinfo() -> typeinfo.IRecordInfo:
+    return typeinfo.GetRecordInfoFromGuids(*StructRecordParamTest._recordinfo_)
+
+
+def _create_record(
+    question: str, answer: int, needs_clarification: bool
+) -> "StructRecordParamTest":
+    record = StructRecordParamTest()
+    record.question = question
+    record.answer = answer
+    record.needs_clarification = needs_clarification
+    return record
+
+
+@unittest.skipIf(IMPORT_FAILED, "This depends on the out of process COM-server.")
+class Test_IRecordInfo(unittest.TestCase):
+    def test_RecordCopy(self):
+        dst_rec = StructRecordParamTest()
+        ri = _create_recordinfo()
+        ri.RecordCopy(pointer(_create_record("foo", 3, True)), byref(dst_rec))
+        self.assertEqual(dst_rec.question, "foo")
+        self.assertEqual(dst_rec.answer, 3)
+        self.assertEqual(dst_rec.needs_clarification, True)
+
+    def test_GetGuid(self):
+        *_, expected_guid = StructRecordParamTest._recordinfo_
+        self.assertEqual(str(_create_recordinfo().GetGuid()), expected_guid)
+
+    def test_GetName(self):
+        self.assertEqual(
+            _create_recordinfo().GetName(),
+            StructRecordParamTest.__qualname__,
+        )
+
+    def test_GetSize(self):
+        self.assertEqual(
+            _create_recordinfo().GetSize(),
+            sizeof(StructRecordParamTest),
+        )
+
+    def test_GetTypeInfo(self):
+        ta = _create_recordinfo().GetTypeInfo().GetTypeAttr()
+        *_, expected_guid = StructRecordParamTest._recordinfo_
+        self.assertEqual(str(ta.guid), expected_guid)
+
+    def test_IsMatchingType(self):
+        ri = _create_recordinfo()
+        ti = ri.GetTypeInfo()
+        self.assertTrue(typeinfo.GetRecordInfoFromTypeInfo(ti).IsMatchingType(ri))
+
+    def test_RecordCreateCopy(self):
+        ri = _create_recordinfo()
+        actual = ri.RecordCreateCopy(byref(_create_record("foo", 3, True)))
+        self.assertIsInstance(actual, int)
+        dst_rec = StructRecordParamTest()
+        ri.RecordCopy(actual, byref(dst_rec))
+        ri.RecordDestroy(actual)
+        self.assertEqual(dst_rec.question, "foo")
+        self.assertEqual(dst_rec.answer, 3)
+        self.assertEqual(dst_rec.needs_clarification, True)

comtypes-1.4.6/comtypes/test/test_typeannotator.py

@@ -0,0 +1,127 @@
+import unittest
+
+from comtypes.tools import typedesc
+from comtypes.tools.codegenerator import typeannotator
+from comtypes.tools.tlbparser import (
+    BSTR_type,
+    HRESULT_type,
+    VARIANT_type,
+    VARIANT_BOOL_type,
+)
+
+
+iunknown_type = typedesc.ComInterface(
+    "IUnknown", None, "{00000000-0000-0000-C000-000000000046}", ["hidden"], None
+)
+idispatch_type = typedesc.ComInterface(
+    "IDispatch",
+    iunknown_type,
+    "{00020400-0000-0000-C000-000000000046}",
+    ["restricted"],
+    None,
+)
+void_type = typedesc.FundamentalType("void", 0, 0)
+
+
+class Test_AvoidUsingKeywords(unittest.TestCase):
+    def _create_typedesc_disp_interface(self) -> typedesc.DispInterface:
+        guid = "{00000000-0000-0000-0000-000000000000}"
+        itf = typedesc.DispInterface("IDispDerived", idispatch_type, guid, [], None)
+        ham = typedesc.DispProperty(0, "ham", BSTR_type, ["readonly"], None)
+        bacon = typedesc.DispMethod(
+            472, 1, "bacon", VARIANT_BOOL_type, ["hidden"], None
+        )
+        bacon.add_argument(VARIANT_type, "and", ["in"], None)
+        bacon.add_argument(VARIANT_type, "foo", ["in"], None)
+        get_spam = typedesc.DispMethod(6, 2, "spam", VARIANT_type, ["propget"], None)
+        get_spam.add_argument(VARIANT_type, "arg1", ["in", "optional"], None)
+        put_spam = typedesc.DispMethod(6, 4, "spam", void_type, ["propput"], None)
+        put_spam.add_argument(VARIANT_type, "arg1", ["in", "optional"], None)
+        put_spam.add_argument(VARIANT_type, "arg2", ["in"], None)
+        except_ = typedesc.DispProperty(1, "except", BSTR_type, ["readonly"], None)
+        raise_ = typedesc.DispMethod(
+            474, 1, "raise", VARIANT_BOOL_type, ["hidden"], None
+        )
+        raise_.add_argument(VARIANT_type, "foo", ["in"], None)
+        raise_.add_argument(VARIANT_type, "bar", ["in", "optional"], None)
+        get_def = typedesc.DispMethod(8, 2, "def", VARIANT_type, ["propget"], None)
+        get_def.add_argument(VARIANT_type, "arg1", ["in", "optional"], None)
+        put_def = typedesc.DispMethod(8, 4, "def", void_type, ["propput"], None)
+        put_def.add_argument(VARIANT_type, "arg1", ["in", "optional"], None)
+        put_def.add_argument(VARIANT_type, "arg2", ["in"], None)
+        for m in [ham, bacon, get_spam, put_spam, except_, raise_, get_def, put_def]:
+            itf.add_member(m)
+        return itf
+
+    def test_disp_interface(self):
+        itf = self._create_typedesc_disp_interface()
+        expected = (
+            "        @property  # dispprop\n"
+            "        def ham(self) -> hints.Incomplete: ...\n"
+            "        pass  # @property  # dispprop\n"
+            "        pass  # avoid using a keyword for def except(self) -> hints.Incomplete: ...\n"  # noqa
+            "        def bacon(self, *args: hints.Any, **kwargs: hints.Any) -> hints.Incomplete: ...\n"  # noqa
+            "        def _get_spam(self, arg1: hints.Incomplete = ...) -> hints.Incomplete: ...\n"  # noqa
+            "        def _set_spam(self, arg1: hints.Incomplete = ..., **kwargs: hints.Any) -> hints.Incomplete: ...\n"  # noqa
+            "        spam = hints.named_property('spam', _get_spam, _set_spam)\n"
+            "        pass  # avoid using a keyword for def raise(self, foo: hints.Incomplete, bar: hints.Incomplete = ...) -> hints.Incomplete: ...\n"  # noqa
+            "        def _get_def(self, arg1: hints.Incomplete = ...) -> hints.Incomplete: ...\n"  # noqa
+            "        def _set_def(self, arg1: hints.Incomplete = ..., **kwargs: hints.Any) -> hints.Incomplete: ...\n"  # noqa
+            "        pass  # avoid using a keyword for def = hints.named_property('def', _get_def, _set_def)"  # noqa
+        )
+        self.assertEqual(
+            expected, typeannotator.DispInterfaceMembersAnnotator(itf).generate()
+        )
+
+    def _create_typedesc_com_interface(self) -> typedesc.ComInterface:
+        guid = "{00000000-0000-0000-0000-000000000000}"
+        itf = typedesc.ComInterface(
+            "IUnkDerived", iunknown_type, guid, ["hidden"], None
+        )
+        spam = typedesc.ComMethod(
+            2, 1610678269, "spam", HRESULT_type, ["propget"], None
+        )
+        get_ham = typedesc.ComMethod(
+            2, 1610678270, "ham", HRESULT_type, ["propget"], None
+        )
+        put_ham = typedesc.ComMethod(
+            4, 1610678270, "ham", HRESULT_type, ["propput"], None
+        )
+        bacon = typedesc.ComMethod(1, 1610678271, "bacon", HRESULT_type, [], None)
+        bacon.add_argument(VARIANT_type, "foo", ["in"], None)
+        bacon.add_argument(VARIANT_type, "or", ["in"], None)
+        global_ = typedesc.ComMethod(
+            2, 1610678272, "global", HRESULT_type, ["propget"], None
+        )
+        get_class = typedesc.ComMethod(
+            2, 1610678273, "class", HRESULT_type, ["propget"], None
+        )
+        put_class = typedesc.ComMethod(
+            4, 1610678273, "class", HRESULT_type, ["propput"], None
+        )
+        pass_ = typedesc.ComMethod(1, 1610678274, "pass", HRESULT_type, [], None)
+        pass_.add_argument(VARIANT_type, "foo", ["in"], None)
+        pass_.add_argument(VARIANT_type, "bar", ["in", "optional"], None)
+        members = [spam, get_ham, put_ham, bacon, global_, get_class, put_class, pass_]
+        itf.extend_members(members)
+        return itf
+
+    def test_com_interface(self):
+        itf = self._create_typedesc_com_interface()
+        expected = (
+            "        def _get_spam(self) -> hints.Hresult: ...\n"
+            "        spam = hints.normal_property(_get_spam)\n"
+            "        def _get_ham(self) -> hints.Hresult: ...\n"
+            "        def _set_ham(self) -> hints.Hresult: ...\n"
+            "        ham = hints.normal_property(_get_ham, _set_ham)\n"
+            "        def bacon(self, *args: hints.Any, **kwargs: hints.Any) -> hints.Hresult: ...\n"  # noqa
+            "        def _get_global(self) -> hints.Hresult: ...\n"
+            "        pass  # avoid using a keyword for global = hints.normal_property(_get_global)\n"  # noqa
+            "        def _get_class(self) -> hints.Hresult: ...\n"
+            "        def _set_class(self) -> hints.Hresult: ...\n"
+            "        pass  # avoid using a keyword for class = hints.normal_property(_get_class, _set_class)\n"  # noqa
+            "        pass  # avoid using a keyword for def pass(self, foo: hints.Incomplete, bar: hints.Incomplete = ...) -> hints.Hresult: ..."  # noqa
+        )
+        self.assertEqual(
+            expected, typeannotator.ComInterfaceMembersAnnotator(itf).generate()
+        )

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/test/test_wmi.py

@@ -1,17 +1,10 @@
-import sys
 import unittest as ut
-from ctypes import POINTER
+
 from comtypes.client import CoGetObject
 from comtypes.test import requires
 
 requires("time")
 
-if sys.version_info >= (3, 0):
-    base_text_type = str
-    text_type = str
-else:
-    base_text_type = basestring
-    text_type = unicode
 
 # WMI has dual interfaces.
 # Some methods/properties have "[out] POINTER(VARIANT)" parameters.
@@ -19,7 +12,7 @@ else:
 # that's what VARIANT.__ctypes_from_outparam__ does.
 class Test(ut.TestCase):
     def test_wmi(self):
-        wmi = CoGetObject("winmgmts:")
+        wmi: "WbemScripting.ISWbemServices" = CoGetObject("winmgmts:")
         disks = wmi.InstancesOf("Win32_LogicalDisk")
 
         # There are different typelibs installed for WMI on win2k and winXP.
@@ -28,8 +21,8 @@ class Test(ut.TestCase):
         #     import comtypes.gen._565783C6_CB41_11D1_8B02_00600806D9B6_0_1_1 as mod
         #   WinXP:
         #     import comtypes.gen._565783C6_CB41_11D1_8B02_00600806D9B6_0_1_2 as mod
-        # So, the one that's referenced onm WbemScripting will be used, whether the actual
-        # typelib is available or not.  XXX
+        # So, the one that's referenced onm WbemScripting will be used, whether the
+        # actual typelib is available or not.  XXX
         from comtypes.gen import WbemScripting
 
         WbemScripting.wbemPrivilegeCreateToken
@@ -37,25 +30,25 @@ class Test(ut.TestCase):
         for item in disks:
             # obj[index] is forwarded to obj.Item(index)
             # .Value is a property with "[out] POINTER(VARIANT)" parameter.
+            item: "WbemScripting.ISWbemObject"
             a = item.Properties_["Caption"].Value
             b = item.Properties_.Item("Caption").Value
             c = item.Properties_("Caption").Value
             self.assertEqual(a, b)
             self.assertEqual(a, c)
-            self.assertTrue(isinstance(a, base_text_type))
-            self.assertTrue(isinstance(b, base_text_type))
-            self.assertTrue(isinstance(c, base_text_type))
+            self.assertTrue(isinstance(a, str))
+            self.assertTrue(isinstance(b, str))
+            self.assertTrue(isinstance(c, str))
             result = {}
             for prop in item.Properties_:
-                self.assertTrue(isinstance(prop.Name, base_text_type))
+                prop: "WbemScripting.ISWbemProperty"
+                self.assertTrue(isinstance(prop.Name, str))
                 prop.Value
                 result[prop.Name] = prop.Value
                 # print "\t", (prop.Name, prop.Value)
             self.assertEqual(len(item.Properties_), item.Properties_.Count)
             self.assertEqual(len(item.Properties_), len(result))
-            self.assertTrue(
-                isinstance(item.Properties_["Description"].Value, text_type)
-            )
+            self.assertTrue(isinstance(item.Properties_["Description"].Value, str))
         # len(obj) is forwared to obj.Count
         self.assertEqual(len(disks), disks.Count)
 

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/tools/codegenerator/codegenerator.py

@@ -196,7 +196,6 @@ class CodeGenerator(object):
         print("from typing import TYPE_CHECKING", file=output)
         print(file=output)
         print("if TYPE_CHECKING:", file=output)
-        print("    from typing import Any, Tuple", file=output)
         print("    from comtypes import hints", file=output)
         print(file=output)
         print(file=output)

comtypes-1.4.6/comtypes/tools/codegenerator/modulenamer.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+import comtypes
+from comtypes import typeinfo
+
+
+def name_wrapper_module(tlib: typeinfo.ITypeLib) -> str:
+    """Determine the name of a typelib wrapper module"""
+    libattr = tlib.GetLibAttr()
+    guid = str(libattr.guid)[1:-1].replace("-", "_")
+    modname = f"_{guid}_{libattr.lcid}_{libattr.wMajorVerNum}_{libattr.wMinorVerNum}"
+    return f"comtypes.gen.{modname}"
+
+
+def name_friendly_module(tlib: typeinfo.ITypeLib) -> Optional[str]:
+    """Determine the friendly-name of a typelib module.
+    If cannot get friendly-name from typelib, returns `None`.
+    """
+    try:
+        modulename = tlib.GetDocumentation(-1)[0]
+    except comtypes.COMError:
+        return
+    return f"comtypes.gen.{modulename}"

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/tools/codegenerator/typeannotator.py

@@ -1,18 +1,8 @@
 import abc
 import keyword
-from typing import (
-    Any,
-    Dict,
-    Generic,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-)
+from typing import Any, Generic, TypeVar, TYPE_CHECKING
+from typing import Dict, List, Optional, Sequence, Tuple
+from typing import Iterable, Iterator
 
 from comtypes.tools import typedesc
 
@@ -124,6 +114,8 @@ class _MethodsAnnotator(abc.ABC, Generic[_T_MTD]):
             content = f"{mem_name} = hints.named_property('{mem_name}', fset={setter})"
         else:
             return
+        if keyword.iskeyword(mem_name):
+            content = f"pass  # avoid using a keyword for {content}"
         self._define_member(content)
 
     def _define_normal_prop(
@@ -137,6 +129,8 @@ class _MethodsAnnotator(abc.ABC, Generic[_T_MTD]):
             content = f"{mem_name} = hints.normal_property(fset={setter})"
         else:
             return
+        if keyword.iskeyword(mem_name):
+            content = f"pass  # avoid using a keyword for {content}"
         self._define_member(content)
 
     def _define_member(self, content: str) -> None:
@@ -242,14 +236,14 @@ class ComMethodAnnotator(_MethodAnnotator[typedesc.ComMethod]):
         has_optional = False
         for _, argname, default in self.inarg_specs:
             if keyword.iskeyword(argname):
-                inargs = ["*args: Any", "**kwargs: Any"]
+                inargs = ["*args: hints.Any", "**kwargs: hints.Any"]
                 break
             if default is None:
                 if has_optional:
                     # probably propput or propputref
                     # HACK: Something that goes into this conditional branch
                     #       should be a special callback.
-                    inargs.append("**kwargs: Any")
+                    inargs.append("**kwargs: hints.Any")
                     break
                 inargs.append(f"{argname}: hints.Incomplete")
             else:
@@ -261,9 +255,12 @@ class ComMethodAnnotator(_MethodAnnotator[typedesc.ComMethod]):
         elif len(outargs) == 1:
             out = outargs[0]
         else:
-            out = "Tuple[" + ", ".join(outargs) + "]"
+            out = "hints.Tuple[" + ", ".join(outargs) + "]"
         in_ = ("self, " + ", ".join(inargs)) if inargs else "self"
-        return f"def {name}({in_}) -> {out}: ..."
+        content = f"def {name}({in_}) -> {out}: ..."
+        if keyword.iskeyword(name):
+            content = f"pass  # avoid using a keyword for {content}"
+        return content
 
 
 class ComMethodsAnnotator(_MethodsAnnotator[typedesc.ComMethod]):
@@ -285,14 +282,14 @@ class DispMethodAnnotator(_MethodAnnotator[typedesc.DispMethod]):
         has_optional = False
         for _, argname, default in self.inarg_specs:
             if keyword.iskeyword(argname):
-                inargs = ["*args: Any", "**kwargs: Any"]
+                inargs = ["*args: hints.Any", "**kwargs: hints.Any"]
                 break
             if default is None:
                 if has_optional:
                     # probably propput or propputref
                     # HACK: Something that goes into this conditional branch
                     #       should be a special callback.
-                    inargs.append("**kwargs: Any")
+                    inargs.append("**kwargs: hints.Any")
                     break
                 inargs.append(f"{argname}: hints.Incomplete")
             else:
@@ -300,7 +297,10 @@ class DispMethodAnnotator(_MethodAnnotator[typedesc.DispMethod]):
                 has_optional = True
         out = _to_outtype(self.method.returns)
         in_ = ("self, " + ", ".join(inargs)) if inargs else "self"
-        return f"def {name}({in_}) -> {out}: ..."
+        content = f"def {name}({in_}) -> {out}: ..."
+        if keyword.iskeyword(name):
+            content = f"pass  # avoid using a keyword for {content}"
+        return content
 
 
 class DispMethodsAnnotator(_MethodsAnnotator[typedesc.DispMethod]):
@@ -328,9 +328,14 @@ class DispInterfaceMembersAnnotator(object):
         props, methods = self._categorize_members()
         property_lines: List[str] = []
         for mem in props:
-            property_lines.append("@property  # dispprop")
             out = _to_outtype(mem.typ)
-            property_lines.append(f"def {mem.name}(self) -> {out}: ...")
+            decorator = "@property  # dispprop"
+            content = f"def {mem.name}(self) -> {out}: ..."
+            if keyword.iskeyword(mem.name):
+                decorator = f"pass  # {decorator}"
+                content = f"pass  # avoid using a keyword for {content}"
+            property_lines.append(decorator)
+            property_lines.append(content)
         dispprops = "\n".join(f"        {p}" for p in property_lines)
         dispmethods = DispMethodsAnnotator().generate(methods)
         return "\n".join(d for d in (dispprops, dispmethods) if d)

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/tools/tlbparser.py

@@ -298,27 +298,25 @@ class Parser(object):
             names = tinfo.GetNames(fd.memid, fd.cParams + 1)
             names.append("rhs")
             names = names[: fd.cParams + 1]
+            # function name first, then parameter names
             assert len(names) == fd.cParams + 1
             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
             )
-            for p in range(fd.cParams):
-                typ = self.make_type(fd.lprgelemdescParam[p].tdesc, tinfo)
-                name = names[p + 1]
-                flags = fd.lprgelemdescParam[p]._.paramdesc.wParamFlags
-                if flags & typeinfo.PARAMFLAG_FHASDEFAULT:
+            for j in range(fd.cParams):
+                elemdesc = fd.lprgelemdescParam[j]
+                typ = self.make_type(elemdesc.tdesc, tinfo)
+                name = names[j + 1]
+                paramdesc = elemdesc._.paramdesc
+                if paramdesc.wParamFlags & typeinfo.PARAMFLAG_FHASDEFAULT:
                     # XXX should be handled by VARIANT itself
-                    var = (
-                        fd.lprgelemdescParam[p]
-                        ._.paramdesc.pparamdescex[0]
-                        .varDefaultValue
-                    )
-                    default: Any = var.value
+                    default: Any = paramdesc.pparamdescex[0].varDefaultValue.value
                 else:
                     default = None
-                mth.add_argument(typ, name, self.param_flags(flags), default)
+                param_flags = self.param_flags(paramdesc.wParamFlags)
+                mth.add_argument(typ, name, param_flags, default)
             members.append((fd.oVft, mth))
         # Sort the methods by oVft (VTable offset): Some typeinfo
         # don't list methods in VTable order.
@@ -386,25 +384,25 @@ class Parser(object):
             names = tinfo.GetNames(fd.memid, fd.cParams + 1)
             names.append("rhs")
             names = names[: fd.cParams + 1]
-            assert (
-                len(names) == fd.cParams + 1
-            )  # function name first, then parameter names
+            # function name first, then parameter names
+            assert len(names) == fd.cParams + 1
             flags = self.func_flags(fd.wFuncFlags)
             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):
-                descparam = fd.lprgelemdescParam[p]
-                typ = self.make_type(descparam.tdesc, tinfo)
-                name = names[p + 1]
-                flags = descparam._.paramdesc.wParamFlags
-                if flags & typeinfo.PARAMFLAG_FHASDEFAULT:
-                    var = descparam._.paramdesc.pparamdescex[0].varDefaultValue  # type: ignore
-                    default: Any = var.value
+            for j in range(fd.cParams):
+                elemdesc = fd.lprgelemdescParam[j]
+                typ = self.make_type(elemdesc.tdesc, tinfo)
+                name = names[j + 1]
+                paramdesc = elemdesc._.paramdesc
+                if paramdesc.wParamFlags & typeinfo.PARAMFLAG_FHASDEFAULT:
+                    # XXX should be handled by VARIANT itself
+                    default: Any = paramdesc.pparamdescex[0].varDefaultValue.value
                 else:
                     default = None
-                mth.add_argument(typ, name, self.param_flags(flags), default)
+                param_flags = self.param_flags(paramdesc.wParamFlags)
+                mth.add_argument(typ, name, param_flags, default)
             itf.add_member(mth)
         return itf
 

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/tools/typedesc_base.py

@@ -1,12 +1,6 @@
 # typedesc.py - classes representing C type descriptions
-from typing import (
-    Any,
-    List,
-    Optional,
-    Tuple,
-    Union as _UnionT,
-    SupportsInt,
-)
+from typing import Any, SupportsInt
+from typing import List, Optional, Tuple, Union as _UnionT
 
 import comtypes
 

{comtypes-1.4.4 → comtypes-1.4.6}/comtypes/typeinfo.py

@@ -5,45 +5,22 @@
 # then hacked manually
 import os
 import sys
-from typing import (
-    Any,
-    Callable,
-    List,
-    Optional,
-    overload,
-    Sequence,
-    Type,
-    TypeVar,
-    Tuple,
-    Union as _UnionT,
-)
+from typing import Any, overload, TypeVar, TYPE_CHECKING
+from typing import List, Type, Tuple
+from typing import Optional, Union as _UnionT
+from typing import Callable, Sequence
 import weakref
 
 import ctypes
 from ctypes import HRESULT, POINTER, _Pointer, byref, c_int, c_void_p, c_wchar_p
 from ctypes.wintypes import DWORD, LONG, UINT, ULONG, WCHAR, WORD
-from comtypes import (
-    BSTR,
-    _CData,
-    COMMETHOD,
-    _GUID,
-    GUID,
-    IID,
-    IUnknown,
-    STDMETHOD,
-    TYPE_CHECKING,
-)
-from comtypes.automation import (
-    DISPID,
-    DISPPARAMS,
-    EXCEPINFO,
-    LCID,
-    SCODE,
-    VARIANT,
-    VARIANTARG,
-    VARTYPE,
-    tagVARIANT,
-)
+from comtypes import BSTR, _CData, COMMETHOD, _GUID, GUID, IID, IUnknown, STDMETHOD
+from comtypes.automation import DISPID, LCID, SCODE
+from comtypes.automation import DISPPARAMS, EXCEPINFO, VARIANT, VARIANTARG, VARTYPE
+
+if TYPE_CHECKING:
+    from comtypes import hints  # type: ignore
+
 
 _CT = TypeVar("_CT", bound=_CData)
 _T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
@@ -500,6 +477,27 @@ class IRecordInfo(IUnknown):
         # XXX Should SysFreeString the array contents. How to?
         return result
 
+    if TYPE_CHECKING:
+        # fmt: off
+        # def RecordInit
+        # def RecordClear
+        def RecordCopy(  # noqa
+            self, pvExisting: hints.Incomplete, pvNew: hints.Incomplete
+        ) -> hints.Hresult: ...
+        def GetGuid(self) -> GUID: ...  # noqa
+        def GetName(self) -> str: ...  # noqa
+        def GetSize(self) -> int: ...  # noqa
+        def GetTypeInfo(self) -> ITypeInfo: ...  # noqa
+        # def GetField
+        # def GetFieldNoCopy
+        # def PutField
+        # def PutFieldNoCopy
+        def IsMatchingType(self, value: "IRecordInfo") -> bool: ...  # noqa
+        # def RecordCreate
+        def RecordCreateCopy(self, pvSource: hints.Incomplete) -> int: ...  # noqa
+        def RecordDestroy(self, pvRecord: hints.Incomplete) -> hints.Hresult: ...  # noqa
+        # fmt: on
+
 
 IRecordInfo._methods_ = [
     COMMETHOD([], HRESULT, "RecordInit", (["in"], c_void_p, "pvNew")),
@@ -1201,7 +1199,7 @@ class N11tagELEMDESC5DOLLAR_204E(ctypes.Union):
 class tagPARAMDESC(ctypes.Structure):
     # C:/Programme/gccxml/bin/Vc71/PlatformSDK/oaidl.h 609
     if TYPE_CHECKING:
-        pparamdescex: "tagPARAMDESCEX"
+        pparamdescex: "_Pointer[tagPARAMDESCEX]"
         wParamFlags: int
 
 

{comtypes-1.4.4 → comtypes-1.4.6/comtypes.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: comtypes
-Version: 1.4.4
+Version: 1.4.6
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases