comtypes 1.4.5__zip → 1.4.6__zip

{comtypes-1.4.5 → 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.5 → 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.5 → 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.5 → 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.5 → comtypes-1.4.6/comtypes.egg-info}/PKG-INFO

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

{comtypes-1.4.5 → comtypes-1.4.6}/comtypes.egg-info/SOURCES.txt

@@ -103,11 +103,13 @@ comtypes/test/test_npsupport.py
 comtypes/test/test_outparam.py
 comtypes/test/test_propputref.py
 comtypes/test/test_pump_events.py
+comtypes/test/test_recordinfo.py
 comtypes/test/test_safearray.py
 comtypes/test/test_sapi.py
 comtypes/test/test_server.py
 comtypes/test/test_showevents.py
 comtypes/test/test_subinterface.py
+comtypes/test/test_typeannotator.py
 comtypes/test/test_typeinfo.py
 comtypes/test/test_urlhistory.py
 comtypes/test/test_variant.py

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

@@ -1,24 +0,0 @@
-import comtypes
-
-
-def name_wrapper_module(tlib):
-    """Determine the name of a typelib wrapper module"""
-    libattr = tlib.GetLibAttr()
-    modname = "_%s_%s_%s_%s" % (
-        str(libattr.guid)[1:-1].replace("-", "_"),
-        libattr.lcid,
-        libattr.wMajorVerNum,
-        libattr.wMinorVerNum,
-    )
-    return "comtypes.gen.%s" % modname
-
-
-def name_friendly_module(tlib):
-    """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 "comtypes.gen.%s" % modulename