comtypes 1.4.16__tar.gz → 1.4.17__tar.gz

{comtypes-1.4.16 → comtypes-1.4.17}/CHANGES.txt

@@ -1,6 +1,17 @@
 Comtypes CHANGELOG
 ==================
 
+Release 1.4.17
+--------------
+* Unify Windows message handling APIs in ``messageloop.py``. By @junkmd.
+* Replace Internet Explorer with MSXML in ``test_eventinterface.py``. By @junkmd.
+* Improve error handling for ``GetEvents`` with currently unsupported COM servers. By @junkmd.
+* Refactor ``test_basic.py`` to use public APIs. By @junkmd.
+* Skip tests using ``util`` on Python 3.15 alpha/beta. By @junkmd.
+* Refine type hints for COM object creation and retrieval. By @junkmd.
+* Modernize ``IGlobalInterfaceTable`` with type hints. By @junkmd.
+* Fix ``UnboundLocalError`` when all struct packings fail in ``calc_packing``. By @ryanda9910.
+
 Release 1.4.16
 --------------
 * Decompose ``IStorage`` tests and enhance coverage. By @junkmd.

{comtypes-1.4.16/comtypes.egg-info → comtypes-1.4.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comtypes
-Version: 1.4.16
+Version: 1.4.17
 Summary: Pure Python COM package
 Author-email: Thomas Heller <theller@python.net>
 License-Expression: MIT

{comtypes-1.4.16 → comtypes-1.4.17}/comtypes/__init__.py

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

{comtypes-1.4.16 → comtypes-1.4.17}/comtypes/_post_coinit/misc.py

@@ -14,6 +14,7 @@ from ctypes import (
 )
 from ctypes.wintypes import DWORD, LPCWSTR, LPVOID
 from typing import TYPE_CHECKING, Any, Optional, TypeVar, overload
+from typing import Union as _UnionT
 
 from comtypes import CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER, CLSCTX_SERVER, GUID
 from comtypes._memberspec import COMMETHOD
@@ -21,7 +22,7 @@ from comtypes._post_coinit.unknwn import IUnknown
 from comtypes.GUID import REFCLSID
 
 if TYPE_CHECKING:
-    from ctypes import _Pointer
+    from ctypes import _CArgObject, _Pointer
 
     from comtypes import hints as hints  # noqa  # type: ignore
 
@@ -146,20 +147,20 @@ def CoCreateInstance(
 def CoGetClassObject(
     clsid: GUID,
     clsctx: Optional[int] = None,
-    pServerInfo: "Optional[COSERVERINFO]" = None,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
     interface: None = None,
 ) -> "hints.IClassFactory": ...
 @overload
 def CoGetClassObject(
     clsid: GUID,
     clsctx: Optional[int] = None,
-    pServerInfo: "Optional[COSERVERINFO]" = None,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
     interface: type[_T_IUnknown] = IUnknown,
 ) -> _T_IUnknown: ...
 def CoGetClassObject(
     clsid: GUID,
     clsctx: Optional[int] = None,
-    pServerInfo: "Optional[COSERVERINFO]" = None,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
     interface: Optional[type[IUnknown]] = None,
 ) -> IUnknown:
     if clsctx is None:
@@ -337,7 +338,7 @@ def CoCreateInstanceEx(
     interface: None = None,
     clsctx: Optional[int] = None,
     machine: Optional[str] = None,
-    pServerInfo: Optional[COSERVERINFO] = None,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
 ) -> IUnknown: ...
 @overload
 def CoCreateInstanceEx(
@@ -345,14 +346,14 @@ def CoCreateInstanceEx(
     interface: type[_T_IUnknown],
     clsctx: Optional[int] = None,
     machine: Optional[str] = None,
-    pServerInfo: Optional[COSERVERINFO] = None,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
 ) -> _T_IUnknown: ...
 def CoCreateInstanceEx(
     clsid: GUID,
     interface: Optional[type[IUnknown]] = None,
     clsctx: Optional[int] = None,
     machine: Optional[str] = None,
-    pServerInfo: Optional[COSERVERINFO] = None,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
 ) -> IUnknown:
     """The basic windows api to create a COM class object and return a
     pointer to an interface, possibly on another machine.

{comtypes-1.4.16 → comtypes-1.4.17}/comtypes/client/_activeobj.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, TypeVar, overload
+from typing import Any, Literal, Optional, TypeVar, overload
 from typing import Union as _UnionT
 
 import comtypes
@@ -14,10 +14,24 @@ _T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
 # Object creation
 #
 @overload
-def GetActiveObject(progid: _UnionT[str, type[CoClass], GUID]) -> Any: ...
+def GetActiveObject(
+    progid: _UnionT[str, type[CoClass], GUID],
+    interface: None = None,
+    dynamic: Literal[False] = False,
+) -> Any: ...
+@overload
+def GetActiveObject(
+    progid: _UnionT[str, type[CoClass], GUID],
+    interface: None = None,
+    dynamic: Literal[True] = True,
+) -> _UnionT[
+    "comtypes.client.lazybind.Dispatch", "comtypes.client.dynamic._Dispatch"
+]: ...
 @overload
 def GetActiveObject(
-    progid: _UnionT[str, type[CoClass], GUID], interface: type[_T_IUnknown]
+    progid: _UnionT[str, type[CoClass], GUID],
+    interface: type[_T_IUnknown] = IUnknown,
+    dynamic: Literal[False] = False,
 ) -> _T_IUnknown: ...
 def GetActiveObject(
     progid: _UnionT[str, type[CoClass], GUID],

{comtypes-1.4.16 → comtypes-1.4.17}/comtypes/client/_create.py

@@ -1,5 +1,5 @@
 import logging
-from typing import TYPE_CHECKING, Any, Optional, TypeVar, overload
+from typing import TYPE_CHECKING, Any, Literal, Optional, TypeVar, overload
 from typing import Union as _UnionT
 
 import comtypes
@@ -8,6 +8,8 @@ from comtypes import COSERVERINFO, GUID, CoClass, IUnknown, automation
 from comtypes.client._managing import _manage
 
 if TYPE_CHECKING:
+    from ctypes import _CArgObject
+
     from comtypes import hints  # type: ignore
 
 
@@ -23,20 +25,20 @@ logger = logging.getLogger(__name__)
 def GetClassObject(
     progid: _UnionT[str, type[CoClass], GUID],
     clsctx: Optional[int] = None,
-    pServerInfo: Optional[COSERVERINFO] = None,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
     interface: None = None,
 ) -> "hints.IClassFactory": ...
 @overload
 def GetClassObject(
     progid: _UnionT[str, type[CoClass], GUID],
     clsctx: Optional[int] = None,
-    pServerInfo: Optional[COSERVERINFO] = None,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
     interface: type[_T_IUnknown] = IUnknown,
 ) -> _T_IUnknown: ...
 def GetClassObject(
     progid: _UnionT[str, type[CoClass], GUID],
     clsctx: Optional[int] = None,
-    pServerInfo: Optional[COSERVERINFO] = None,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
     interface: Optional[type[IUnknown]] = None,
 ) -> IUnknown:
     """Create and return the class factory for a COM object.
@@ -56,9 +58,29 @@ def CreateObject(
     progid: _UnionT[str, type[CoClass], GUID],
     clsctx: Optional[int] = None,
     machine: Optional[str] = None,
-    interface: Optional[type[_T_IUnknown]] = None,
-    dynamic: bool = ...,
-    pServerInfo: Optional[COSERVERINFO] = None,
+    interface: None = None,
+    dynamic: Literal[False] = False,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
+) -> Any: ...
+@overload
+def CreateObject(
+    progid: _UnionT[str, type[CoClass], GUID],
+    clsctx: Optional[int] = None,
+    machine: Optional[str] = None,
+    interface: None = None,
+    dynamic: Literal[True] = True,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
+) -> _UnionT[
+    "comtypes.client.lazybind.Dispatch", "comtypes.client.dynamic._Dispatch"
+]: ...
+@overload
+def CreateObject(
+    progid: _UnionT[str, type[CoClass], GUID],
+    clsctx: Optional[int] = None,
+    machine: Optional[str] = None,
+    interface: type[_T_IUnknown] = IUnknown,
+    dynamic: Literal[False] = False,
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,
 ) -> _T_IUnknown: ...
 def CreateObject(
     progid: _UnionT[str, type[CoClass], GUID],  # which object to create
@@ -66,7 +88,7 @@ def CreateObject(
     machine: Optional[str] = None,  # where to create the object
     interface: Optional[type[IUnknown]] = None,  # the interface we want
     dynamic: bool = False,  # use dynamic dispatch
-    pServerInfo: Optional[COSERVERINFO] = None,  # server info struct for remoting
+    pServerInfo: "_UnionT[None, _CArgObject, COSERVERINFO]" = None,  # server info struct for remoting
 ) -> Any:
     """Create a COM object from 'progid', and try to QueryInterface()
     it to the most useful interface, generating typelib support on
@@ -122,12 +144,26 @@ def CreateObject(
     return _manage(obj, clsid, interface=interface)
 
 
-@overload
-def CoGetObject(displayname: str, interface: type[_T_IUnknown]) -> _T_IUnknown: ...
 @overload
 def CoGetObject(
-    displayname: str, interface: None = None, dynamic: bool = False
+    displayname: str,
+    interface: None = None,
+    dynamic: Literal[False] = False,
 ) -> Any: ...
+@overload
+def CoGetObject(
+    displayname: str,
+    interface: None = None,
+    dynamic: Literal[True] = True,
+) -> _UnionT[
+    "comtypes.client.lazybind.Dispatch", "comtypes.client.dynamic._Dispatch"
+]: ...
+@overload
+def CoGetObject(
+    displayname: str,
+    interface: type[_T_IUnknown],
+    dynamic: Literal[False] = False,
+) -> _T_IUnknown: ...
 def CoGetObject(
     displayname: str,
     interface: Optional[type[IUnknown]] = None,

{comtypes-1.4.16 → comtypes-1.4.17}/comtypes/client/_events.py

@@ -120,6 +120,10 @@ def FindOutgoingInterface(source: IUnknown) -> type[IUnknown]:
     except COMError:
         pass
     else:
+        if guid == comtypes.GUID():
+            # Some COM servers, even if they implement `IProvideClassInfo2`,
+            # may return GUID_NULL instead of the default source interface's GUID.
+            raise NotImplementedError("retrieved outgoing interface IID is GUID_NULL")
         # another try: block needed?
         try:
             interface = comtypes.com_interface_registry[str(guid)]
@@ -258,7 +262,15 @@ def CreateEventReceiver(interface: type[IUnknown], handler: Any) -> COMObject:
             # Can dispid be at a different index? Should check code generator...
             # ...but hand-written code should also work...
             dispid = m.idlflags[0]
-            assert isinstance(dispid, comtypes.dispid)
+            if not isinstance(dispid, comtypes.dispid):
+                # The interface is a subclass of `IDispatch` but its methods do not
+                # have DISPIDs, indicating it's not an interface suitable for event
+                # handling.
+                raise NotImplementedError(
+                    "Event receiver creation requires event methods to have DISPIDs "
+                    f"for dispatching, but '{interface.__name__}' ({interface._iid_}) "
+                    "lacks them, even though it inherits from 'IDispatch'."
+                )
             impl = finder.get_impl(interface, m.name, m.paramflags, m.idlflags)
             # XXX Wouldn't work for 'propget', 'propput', 'propputref'
             # methods - are they allowed on event interfaces?

{comtypes-1.4.16 → comtypes-1.4.17}/comtypes/git.py

@@ -4,12 +4,12 @@ The global interface table provides a way to marshal interface pointers
 between different threading appartments.
 """
 
-from ctypes import *
+from ctypes import POINTER
 from ctypes.wintypes import DWORD
+from typing import Type, TypeVar
 
 from comtypes import (
     CLSCTX_INPROC_SERVER,
-    COMMETHOD,
     GUID,
     HRESULT,
     STDMETHOD,
@@ -17,6 +17,8 @@ from comtypes import (
     IUnknown,
 )
 
+_T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
+
 
 class IGlobalInterfaceTable(IUnknown):
     _iid_ = GUID("{00000146-0000-0000-C000-000000000046}")
@@ -34,18 +36,22 @@ class IGlobalInterfaceTable(IUnknown):
         ),
     ]
 
-    def RegisterInterfaceInGlobal(self, obj, interface=IUnknown):
+    def RegisterInterfaceInGlobal(
+        self, obj: IUnknown, interface: Type[_T_IUnknown] = IUnknown
+    ) -> int:
         cookie = DWORD()
-        self.__com_RegisterInterfaceInGlobal(obj, interface._iid_, cookie)
+        self.__com_RegisterInterfaceInGlobal(obj, interface._iid_, cookie)  # type: ignore
         return cookie.value
 
-    def GetInterfaceFromGlobal(self, cookie, interface=IUnknown):
+    def GetInterfaceFromGlobal(
+        self, cookie: int, interface: Type[_T_IUnknown] = IUnknown
+    ) -> _T_IUnknown:
         ptr = POINTER(interface)()
-        self.__com_GetInterfaceFromGlobal(cookie, interface._iid_, ptr)
-        return ptr
+        self.__com_GetInterfaceFromGlobal(cookie, interface._iid_, ptr)  # type: ignore
+        return ptr  # type: ignore
 
-    def RevokeInterfaceFromGlobal(self, cookie):
-        self.__com_RevokeInterfaceFromGlobal(cookie)
+    def RevokeInterfaceFromGlobal(self, cookie: int) -> None:
+        self.__com_RevokeInterfaceFromGlobal(cookie)  # type: ignore
 
 
 # It was a pain to get this CLSID: it's neither in the registry, nor
@@ -69,20 +75,3 @@ __all__ = [
     "GetInterfaceFromGlobal",
 ]
 # fmt: on
-
-
-if __name__ == "__main__":
-    from comtypes.typeinfo import CreateTypeLib, ICreateTypeLib
-
-    tlib = CreateTypeLib("foo.bar")  # we don not save it later
-    assert (tlib.AddRef(), tlib.Release()) == (2, 1)
-
-    cookie = RegisterInterfaceInGlobal(tlib)
-    assert (tlib.AddRef(), tlib.Release()) == (3, 2)
-
-    GetInterfaceFromGlobal(cookie, ICreateTypeLib)
-    GetInterfaceFromGlobal(cookie, ICreateTypeLib)
-    GetInterfaceFromGlobal(cookie)
-    assert (tlib.AddRef(), tlib.Release()) == (3, 2)
-    RevokeInterfaceFromGlobal(cookie)
-    assert (tlib.AddRef(), tlib.Release()) == (2, 1)

{comtypes-1.4.16 → comtypes-1.4.17}/comtypes/messageloop.py

@@ -1,6 +1,7 @@
 import ctypes
-from ctypes import WinDLL, WinError, byref
-from ctypes.wintypes import MSG
+from ctypes import POINTER, WinDLL, WinError, byref
+from ctypes.wintypes import BOOL, HWND, MSG
+from ctypes.wintypes import LPLONG as LRESULT
 from typing import TYPE_CHECKING, SupportsIndex
 
 if TYPE_CHECKING:
@@ -10,12 +11,29 @@ if TYPE_CHECKING:
 
     _FilterCallable = Callable[["_CArgObject"], Iterable[Any]]  # type: ignore
 
+# PeekMessage options
+PM_NOREMOVE = 0x0000
+PM_REMOVE = 0x0001
+PM_NOYIELD = 0x0002
+
 _user32 = WinDLL("user32")
 
 GetMessage = _user32.GetMessageA
-GetMessage.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.c_uint]
+GetMessage.argtypes = [POINTER(MSG), HWND, ctypes.c_uint, ctypes.c_uint]
+GetMessage.restype = BOOL
+
 TranslateMessage = _user32.TranslateMessage
+TranslateMessage.argtypes = [POINTER(MSG)]
+TranslateMessage.restype = BOOL
+
 DispatchMessage = _user32.DispatchMessageA
+DispatchMessage.argtypes = [POINTER(MSG)]
+DispatchMessage.restype = LRESULT
+
+# https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-peekmessagea
+PeekMessage = _user32.PeekMessageA
+PeekMessage.argtypes = [POINTER(MSG), HWND, ctypes.c_uint, ctypes.c_uint, ctypes.c_uint]
+PeekMessage.restype = BOOL
 
 
 class _MessageLoop:

{comtypes-1.4.16 → comtypes-1.4.17}/comtypes/test/test_basic.py

@@ -1,9 +1,8 @@
-##import ut
 import unittest as ut
-from ctypes import HRESULT, POINTER, byref
+from ctypes import HRESULT, POINTER
 
 from comtypes import GUID, STDMETHOD, IUnknown
-from comtypes.typeinfo import ICreateTypeLib2, _CreateTypeLib2
+from comtypes.typeinfo import SYS_WIN32, CreateTypeLib, ICreateTypeLib2
 
 # XXX leaks references!
 
@@ -14,8 +13,6 @@ def method_count(interface):
 
 class BasicTest(ut.TestCase):
     def test_IUnknown(self):
-        from comtypes import IUnknown
-
         self.assertEqual(method_count(IUnknown), 3)
 
     def test_release(self):
@@ -24,8 +21,9 @@ class BasicTest(ut.TestCase):
     def test_refcounts(self):
         # Since all COM interfaces derive from IUnknown and have the same reference counting behavior, any interface
         # — whether ICreateTypeLib2 or otherwise — could be used for this test.
-        p = POINTER(ICreateTypeLib2)()
-        _CreateTypeLib2(1, "blabla", byref(p))
+        p = CreateTypeLib("blabla", syskind=SYS_WIN32)
+        self.assertIsInstance(p, ICreateTypeLib2)
+        self.assertIsInstance(p, IUnknown)
         # initial refcount is 2
         for i in range(2, 10):
             self.assertEqual(p.AddRef(), i)
@@ -35,8 +33,9 @@ class BasicTest(ut.TestCase):
     def test_qi(self):
         # Since all COM interfaces derive from IUnknown and have the same QueryInterface behavior, any interface
         # — whether ICreateTypeLib2 or otherwise — could be used for this test.
-        p = POINTER(ICreateTypeLib2)()
-        _CreateTypeLib2(1, "blabla", byref(p))
+        p = CreateTypeLib("blabla", syskind=SYS_WIN32)
+        self.assertIsInstance(p, ICreateTypeLib2)
+        self.assertIsInstance(p, IUnknown)
         self.assertEqual(p.AddRef(), 2)
         self.assertEqual(p.Release(), 1)
 
@@ -115,8 +114,6 @@ class BasicTest(ut.TestCase):
         self.assertEqual(a, b)
         self.assertEqual(hash(a), hash(b))
 
-        from comtypes.typeinfo import CreateTypeLib
-
         # we do not save the lib, so no file will be created.
         # these should NOT be identical
         a = CreateTypeLib("blahblah")

comtypes-1.4.17/comtypes/test/test_eventinterface.py

@@ -0,0 +1,155 @@
+import gc
+import tempfile
+import time
+import unittest as ut
+from ctypes import HRESULT, byref
+from ctypes.wintypes import MSG
+from pathlib import Path
+
+from comtypes import COMMETHOD, GUID, IUnknown
+from comtypes.automation import DISPID
+from comtypes.client import CreateObject, GetEvents
+from comtypes.messageloop import (
+    PM_REMOVE,
+    DispatchMessage,
+    PeekMessage,
+    TranslateMessage,
+)
+
+# The primary goal is to verify how `GetEvents` behaves when the
+# `interface` argument is explicitly specified versus when it is omitted,
+# using an object that has multiple outgoing event interfaces.
+
+
+class IPropertyNotifySink(IUnknown):
+    # https://learn.microsoft.com/en-us/windows/win32/api/ocidl/nn-ocidl-ipropertynotifysink
+    _iid_ = GUID("{9BFBBC02-EFF1-101A-84ED-00AA00341D07}")
+    _methods_ = [
+        # Called when a property has changed.
+        COMMETHOD([], HRESULT, "OnChanged", (["in"], DISPID, "dispid")),
+        # Called when an object wants to know if it's okay to change a property.
+        COMMETHOD([], HRESULT, "OnRequestEdit", (["in"], DISPID, "dispid")),
+    ]
+
+
+class EventSink:
+    def __init__(self):
+        self._events = []
+
+    # Events from the default dispatch interface
+    def onreadystatechange(self, this, *args):
+        self._events.append("onreadystatechange")
+
+    def ondataavailable(self, this, *args):
+        self._events.append("ondataavailable")
+
+    # Events from `IPropertyNotifySink`
+    def OnChanged(self, this, *args):
+        self._events.append("OnChanged")
+
+    def OnRequestEdit(self, this, *args):
+        self._events.append("OnRequestEdit")
+
+
+def PumpWaitingMessages():
+    msg = MSG()
+    while PeekMessage(byref(msg), 0, 0, 0, PM_REMOVE):
+        TranslateMessage(byref(msg))
+        DispatchMessage(byref(msg))
+
+
+class Test_MSXML(ut.TestCase):
+    def setUp(self):
+        # We use `Msxml2.DOMDocument` because it is a built-in Windows
+        # component that supports both a default source interface and the
+        # `IPropertyNotifySink` connection point.
+        self.doc = CreateObject("Msxml2.DOMDocument")
+        self.doc.async_ = True
+
+    def tearDown(self):
+        del self.doc
+        # Force garbage collection and wait slightly to ensure COM resources
+        # are released properly between tests.
+        gc.collect()
+        time.sleep(2)
+
+    def test_default_eventinterface(self):
+        # Verify that `GetEvents` automatically connects to the default source
+        # interface (dispatch events like `onreadystatechange`) when no
+        # interface is explicitly requested.
+        sink = EventSink()
+        conn = GetEvents(self.doc, sink)
+        self.doc.loadXML("<root/>")
+
+        # Give the message loop time to process incoming events.
+        for _ in range(50):
+            PumpWaitingMessages()
+            time.sleep(0.1)
+        # Should receive events from the default dispatch interface, but not
+        # events from `IPropertyNotifySink`.
+        self.assertIn("onreadystatechange", sink._events)
+        self.assertNotIn("OnChanged", sink._events)
+
+        del conn
+
+    def test_nondefault_eventinterface(self):
+        # Verify that `GetEvents` can connect to a non-default interface
+        # (like `IPropertyNotifySink`) when it is explicitly provided.
+        sink = EventSink()
+
+        conn = GetEvents(self.doc, sink, interface=IPropertyNotifySink)
+
+        self.doc.loadXML("<root/>")
+
+        # Give the message loop time to process incoming events.
+        for _ in range(50):
+            PumpWaitingMessages()
+            time.sleep(0.1)
+        # Should receive events from `IPropertyNotifySink`, but not events from
+        # the default dispatch interface.
+        self.assertNotIn("onreadystatechange", sink._events)
+        self.assertIn("OnChanged", sink._events)
+
+        del conn
+
+
+class Test_MSHTML(ut.TestCase):
+    def test_retrieved_outgoing_iid_is_guid_null(self):
+        doc = CreateObject("htmlfile")
+        sink = object()
+        # MSHTML's HTMLDocument (which is what `CreateObject('htmlfile')`
+        # returns) does not expose a valid default source interface through
+        # `IProvideClassInfo2`.
+        with self.assertRaises(NotImplementedError):
+            GetEvents(doc, sink)
+
+
+class Test_IMAPI2FS(ut.TestCase):
+    def setUp(self):
+        CLSID_MsftFileSystemImage = GUID("{2C941FC5-975B-59BE-A960-9A2A262853A5}")
+        self.image = CreateObject(CLSID_MsftFileSystemImage)
+        self.image.FileSystemsToCreate = 1  # FsiFileSystemISO9660
+        td = tempfile.TemporaryDirectory()
+        self.tmp_dir = Path(td.name)
+        self.addCleanup(td.cleanup)
+
+    def tearDown(self):
+        del self.image
+        # Force garbage collection and wait slightly to ensure COM resources
+        # are released properly between tests.
+        gc.collect()
+        time.sleep(2)
+
+    def test_event_methods_lack_dispids(self):
+        sink = object()
+        # The default event interface for IMAPI2's FileSystemImage is
+        # `DFileSystemImageEvents`. Although it inherits from `IDispatch`,
+        # it is a custom interface (`TKIND_INTERFACE`), not a dual or pure
+        # dispatch interface (`TKIND_DISPATCH`); therefore, its methods
+        # do not have DISPIDs.
+        with self.assertRaises(NotImplementedError):
+            GetEvents(self.image, sink)
+
+
+if __name__ == "__main__":
+    ut.main()

{comtypes-1.4.16 → comtypes-1.4.17}/comtypes/test/test_git.py

@@ -7,7 +7,7 @@ import unittest as ut
 from _ctypes import COMError
 from collections.abc import Iterator
 from ctypes import HRESULT, POINTER, OleDLL, WinDLL, byref
-from ctypes.wintypes import BOOL, DWORD, HANDLE, HWND, MSG, UINT
+from ctypes.wintypes import BOOL, DWORD, HANDLE, MSG
 from pathlib import Path
 from queue import Queue
 
@@ -18,16 +18,16 @@ from comtypes.git import (
     RegisterInterfaceInGlobal,
     RevokeInterfaceFromGlobal,
 )
-from comtypes.messageloop import DispatchMessage, TranslateMessage
+from comtypes.messageloop import (
+    PM_REMOVE,
+    DispatchMessage,
+    PeekMessage,
+    TranslateMessage,
+)
 from comtypes.persist import STGM_READ, IPersistFile
 
 _user32 = WinDLL("user32")
 
-# https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-peekmessagea
-PeekMessage = _user32.PeekMessageA
-PeekMessage.argtypes = [POINTER(MSG), HWND, UINT, UINT, UINT]
-PeekMessage.restype = BOOL
-
 # https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-msgwaitformultipleobjects
 MsgWaitForMultipleObjects = _user32.MsgWaitForMultipleObjects
 MsgWaitForMultipleObjects.restype = DWORD
@@ -49,8 +49,6 @@ _CoGetApartmentType.restype = HRESULT
 
 QS_ALLINPUT = 0x04FF  # All message types including SendMessage
 
-PM_REMOVE = 0x0001  # Remove message from queue after Peek
-
 APTTYPE_MAINSTA = 3
 
 RPC_E_WRONG_THREAD = -2147417842  # 0x8001010E