comtypes 1.4.5__zip → 1.4.6__zip

{comtypes-1.4.5 → comtypes-1.4.6}/CHANGES.txt

@@ -1,6 +1,18 @@
 Comtypes CHANGELOG
 ==================
 
+Release 1.4.6
+--------------
+* Add tests and method annotations for ``IRecordInfo``. By @junkmd.
+* Improve static typings in ``automation``. By @junkmd.
+* Tidy up import part in some modules. By @junkmd.
+* Refer to ``Any`` and ``Tuple`` from the ``hints`` stub instead of directly importing them in generated modules. By @junkmd.
+* Modernize ``GUID.py``. By @junkmd.
+* Improve ``codegenerator.modulenamer`` static typing. By @junkmd.
+* Avoid using keywords in ``TYPE_CHECKING`` blocks. By @junkmd.
+* Improve member defining parts of ``ParseInterface`` and ``ParseDispatch``. By @junkmd.
+* Fix Annoying SyntaxWarning. By @v01d-gh.
+
 Release 1.4.5
 --------------
 * Split ``__init__.py`` into some modules. By @junkmd.

{comtypes-1.4.5/comtypes.egg-info → comtypes-1.4.6}/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/GUID.py

@@ -1,8 +1,12 @@
-from ctypes import *
-import sys
+from ctypes import oledll, windll
+from ctypes import byref, c_byte, c_ushort, c_ulong, c_wchar_p, Structure
+from typing import Any, TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from comtypes import hints  # type: ignore
 
-def binary(obj):
+
+def binary(obj: "GUID") -> bytes:
     return bytes(obj)
 
 
@@ -31,37 +35,32 @@ class GUID(Structure):
             _CLSIDFromString(str(name), byref(self))
 
     def __repr__(self):
-        return 'GUID("%s")' % str(self)
+        return f'GUID("{str(self)}")'
 
-    def __unicode__(self):
+    def __str__(self) -> str:
         p = c_wchar_p()
         _StringFromCLSID(byref(self), byref(p))
         result = p.value
         _CoTaskMemFree(p)
-        return result
-
-    __str__ = __unicode__
-
-    def __cmp__(self, other):
-        if isinstance(other, GUID):
-            return cmp(binary(self), binary(other))
-        return -1
+        # stringified `GUID_null` would be '{00000000-0000-0000-0000-000000000000}'
+        # Should we do `assert result is not None`?
+        return result  # type: ignore
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return self != GUID_null
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         return isinstance(other, GUID) and binary(self) == binary(other)
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         # We make GUID instances hashable, although they are mutable.
         return hash(binary(self))
 
-    def copy(self):
+    def copy(self) -> "GUID":
         return GUID(str(self))
 
     @classmethod
-    def from_progid(cls, progid):
+    def from_progid(cls, progid: Any) -> "hints.Self":
         """Get guid from progid, ..."""
         if hasattr(progid, "_reg_clsid_"):
             progid = progid._reg_clsid_
@@ -74,19 +73,20 @@ class GUID(Structure):
             _CLSIDFromProgID(str(progid), byref(inst))
             return inst
         else:
-            raise TypeError("Cannot construct guid from %r" % progid)
+            raise TypeError(f"Cannot construct guid from {progid!r}")
 
-    def as_progid(self):
-        "Convert a GUID into a progid"
+    def as_progid(self) -> str:
+        """Convert a GUID into a progid"""
         progid = c_wchar_p()
         _ProgIDFromCLSID(byref(self), byref(progid))
         result = progid.value
         _CoTaskMemFree(progid)
-        return result
+        # Should we do `assert result is not None`?
+        return result  # type: ignore
 
     @classmethod
-    def create_new(cls):
-        "Create a brand new guid"
+    def create_new(cls) -> "hints.Self":
+        """Create a brand new guid"""
         guid = cls()
         _CoCreateGuid(byref(guid))
         return guid

{comtypes-1.4.5 → comtypes-1.4.6}/comtypes/__init__.py

@@ -1,5 +1,5 @@
 # comtypes version numbers follow semver (http://semver.org/) and PEP 440
-__version__ = "1.4.5"
+__version__ = "1.4.6"
 
 try:
     from _ctypes import COMError  # noqa

{comtypes-1.4.5 → comtypes-1.4.6}/comtypes/_memberspec.py

@@ -1,16 +1,8 @@
 import ctypes
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    NamedTuple,
-    Optional,
-    Tuple,
-    Type,
-    Union as _UnionT,
-)
+from typing import Any, NamedTuple
+from typing import Dict, List, Tuple, Type
+from typing import Optional, Union as _UnionT
+from typing import Callable, Iterator
 
 from comtypes import _CData
 import comtypes

{comtypes-1.4.5 → comtypes-1.4.6}/comtypes/automation.py

@@ -7,18 +7,9 @@ from ctypes import *
 from ctypes import _Pointer
 from _ctypes import CopyComPointer
 from ctypes.wintypes import DWORD, LONG, UINT, VARIANT_BOOL, WCHAR, WORD
-from typing import (
-    Any,
-    Callable,
-    ClassVar,
-    List,
-    Optional,
-    TYPE_CHECKING,
-    Tuple,
-    Union as _UnionT,
-)
-
-from comtypes import BSTR, COMError, COMMETHOD, GUID, IID, IUnknown, STDMETHOD
+from typing import Any, ClassVar, Dict, List, Optional, TYPE_CHECKING, Type
+
+from comtypes import _CData, BSTR, COMError, COMMETHOD, GUID, IID, IUnknown, STDMETHOD
 from comtypes.hresult import *
 from comtypes._memberspec import _DispMemberSpec
 import comtypes.patcher
@@ -649,7 +640,7 @@ class _(object):
     def __setitem__(self, index, value):
         # This is to support the same sematics as a pointer instance:
         # variant[0] = value
-        self[index].value = value
+        self[index].value = value  # type: ignore
 
 
 ################################################################
@@ -789,28 +780,8 @@ DISPID_DESTRUCTOR = -7
 DISPID_COLLECT = -8
 
 
-RawGetIDsOfNamesFunc = Callable[
-    [_byref_type, "Array[c_wchar_p]", int, int, "Array[DISPID]"], int
-]
-# fmt: off
-RawInvokeFunc = Callable[
-    [
-        int, _byref_type, int, int,  # dispIdMember, riid, lcid, wFlags
-        _UnionT[_byref_type, DISPPARAMS],  # *pDispParams
-        _UnionT[_byref_type, VARIANT],  # pVarResult
-        _UnionT[_byref_type, EXCEPINFO, None],  # pExcepInfo
-        _UnionT[_byref_type, c_uint],  # puArgErr
-    ],
-    int,
-]
-# fmt: on
-
-
 class IDispatch(IUnknown):
     _disp_methods_: ClassVar[List[_DispMemberSpec]]
-    _GetTypeInfo: Callable[[int, int], IUnknown]
-    __com_GetIDsOfNames: RawGetIDsOfNamesFunc
-    __com_Invoke: RawInvokeFunc
 
     _iid_ = GUID("{00020400-0000-0000-C000-000000000046}")
     _methods_ = [
@@ -851,7 +822,7 @@ class IDispatch(IUnknown):
         """Return type information.  Index 0 specifies typeinfo for IDispatch"""
         import comtypes.typeinfo
 
-        result = self._GetTypeInfo(index, lcid)
+        result = self._GetTypeInfo(index, lcid)  # type: ignore
         return result.QueryInterface(comtypes.typeinfo.ITypeInfo)
 
     def GetIDsOfNames(self, *names: str, **kw: Any) -> List[int]:
@@ -860,7 +831,7 @@ class IDispatch(IUnknown):
         assert not kw
         arr = (c_wchar_p * len(names))(*names)
         ids = (DISPID * len(names))()
-        self.__com_GetIDsOfNames(riid_null, arr, len(names), lcid, ids)
+        self.__com_GetIDsOfNames(riid_null, arr, len(names), lcid, ids)  # type: ignore
         return ids[:]
 
     def _invoke(self, memid: int, invkind: int, lcid: int, *args: Any) -> Any:
@@ -880,7 +851,9 @@ class IDispatch(IUnknown):
                 dp.rgdispidNamedArgs = pointer(DISPID(DISPID_PROPERTYPUT))
             dp.rgvarg = array
 
-        self.__com_Invoke(memid, riid_null, lcid, invkind, dp, var, None, argerr)
+        self.__com_Invoke(  # type: ignore
+            memid, riid_null, lcid, invkind, dp, var, None, argerr
+        )
         return var._get_value(dynamic=True)
 
     def __make_dp(self, _invkind: int, *args: Any) -> DISPPARAMS:
@@ -916,7 +889,7 @@ class IDispatch(IUnknown):
         excepinfo = EXCEPINFO()
         argerr = c_uint()
         try:
-            self.__com_Invoke(
+            self.__com_Invoke(  # type: ignore
                 dispid,
                 riid_null,
                 _lcid,
@@ -980,7 +953,7 @@ _arraycode_to_vartype = {
     "B": VT_UI1,
 }
 
-_ctype_to_vartype = {
+_ctype_to_vartype: Dict[Type[_CData], int] = {
     c_byte: VT_I1,
     c_ubyte: VT_UI1,
     c_short: VT_I2,
@@ -1016,7 +989,7 @@ _ctype_to_vartype = {
     # POINTER(IDispatch): VT_DISPATCH,
 }
 
-_vartype_to_ctype = {}
+_vartype_to_ctype: Dict[int, Type[_CData]] = {}
 for c, v in _ctype_to_vartype.items():
     _vartype_to_ctype[v] = c
 _vartype_to_ctype[VT_INT] = _vartype_to_ctype[VT_I4]

{comtypes-1.4.5 → comtypes-1.4.6}/comtypes/client/__init__.py

@@ -12,15 +12,8 @@ import ctypes
 import logging
 import os
 import sys
-from typing import (
-    Any,
-    Optional,
-    overload,
-    Type,
-    TYPE_CHECKING,
-    TypeVar,
-    Union as _UnionT,
-)
+from typing import Any, overload, TypeVar, TYPE_CHECKING
+from typing import Optional, Type, Union as _UnionT
 
 import comtypes
 from comtypes.hresult import *

{comtypes-1.4.5 → comtypes-1.4.6}/comtypes/client/_code_cache.py

@@ -34,10 +34,10 @@ def _find_gen_dir():
     appended to comtypes.gen.__path__ .
 
     For a Python script using comtypes, the additional directory is
-    '%APPDATA%\<username>\Python\Python25\comtypes_cache'.
+    '%APPDATA%\\<username>\\Python\\Python25\\comtypes_cache'.
 
     For an executable frozen with py2exe, the additional directory is
-    '%TEMP%\comtypes_cache\<imagebasename>-25'.
+    '%TEMP%\\comtypes_cache\\<imagebasename>-25'.
     """
     _create_comtypes_gen_package()
     from comtypes import gen

{comtypes-1.4.5 → comtypes-1.4.6}/comtypes/hints.pyi

@@ -3,22 +3,10 @@
 # - utilities for type hints.
 import ctypes
 import sys
-from typing import (
-    Any,
-    Callable,
-    ClassVar,
-    Generic,
-    Iterator,
-    List,
-    NoReturn,
-    Sequence,
-    Tuple,
-    Type,
-    TypeVar,
-    Optional,
-    overload,
-    Union as _UnionT,
-)
+from typing import Any as Any, ClassVar, Generic, NoReturn, TypeVar, overload
+from typing import Optional, Union as _UnionT
+from typing import List, Tuple as Tuple, Type
+from typing import Callable, Iterator, Sequence
 
 if sys.version_info >= (3, 8):
     from typing import Protocol
@@ -35,9 +23,9 @@ else:
     from typing_extensions import Concatenate, ParamSpec, TypeAlias
     from typing_extensions import TypeGuard as TypeGuard
 if sys.version_info >= (3, 11):
-    from typing import Self
+    from typing import Self as Self
 else:
-    from typing_extensions import Self
+    from typing_extensions import Self as Self
 
 import comtypes
 from comtypes import IUnknown as IUnknown, GUID as GUID

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.5 → 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}"