comtypes 1.4.9__zip → 1.4.11__zip

comtypes-1.4.11/comtypes/client/_create.py

@@ -0,0 +1,147 @@
+import logging
+from typing import TYPE_CHECKING, Any, Optional, Type, TypeVar, overload
+from typing import Union as _UnionT
+
+import comtypes
+import comtypes.client.dynamic
+from comtypes import COSERVERINFO, GUID, CoClass, IUnknown, automation
+from comtypes.client._managing import _manage
+
+if TYPE_CHECKING:
+    from comtypes import hints  # type: ignore
+
+
+_T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
+logger = logging.getLogger(__name__)
+
+
+################################################################
+#
+# Object creation
+#
+if TYPE_CHECKING:
+
+    @overload
+    def GetClassObject(
+        progid: _UnionT[str, Type[CoClass], GUID],
+        clsctx: Optional[int] = None,
+        pServerInfo: Optional[COSERVERINFO] = None,
+        interface: None = None,
+    ) -> hints.IClassFactory: ...
+    @overload
+    def GetClassObject(
+        progid: _UnionT[str, Type[CoClass], GUID],
+        clsctx: Optional[int] = None,
+        pServerInfo: Optional[COSERVERINFO] = None,
+        interface: Type[_T_IUnknown] = hints.IClassFactory,
+    ) -> _T_IUnknown: ...
+
+
+def GetClassObject(progid, clsctx=None, pServerInfo=None, interface=None):
+    # type: (_UnionT[str, Type[CoClass], GUID], Optional[int], Optional[COSERVERINFO], Optional[Type[IUnknown]]) -> IUnknown
+    """Create and return the class factory for a COM object.
+
+    'clsctx' specifies how to create the object, use the CLSCTX_... constants.
+    'pServerInfo', if used, must be a pointer to a comtypes.COSERVERINFO instance
+    'interface' may be used to request an interface other than IClassFactory
+    """
+    clsid = GUID.from_progid(progid)
+    return comtypes.CoGetClassObject(clsid, clsctx, pServerInfo, interface)
+
+
+@overload
+def CreateObject(progid: _UnionT[str, Type[CoClass], GUID]) -> Any: ...
+@overload
+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,
+) -> _T_IUnknown: ...
+def CreateObject(
+    progid: _UnionT[str, Type[CoClass], GUID],  # which object to create
+    clsctx: Optional[int] = None,  # how to create the object
+    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
+) -> Any:
+    """Create a COM object from 'progid', and try to QueryInterface()
+    it to the most useful interface, generating typelib support on
+    demand.  A pointer to this interface is returned.
+
+    'progid' may be a string like "InternetExplorer.Application",
+       a string specifying a clsid, a GUID instance, or an object with
+       a _clsid_ attribute which should be any of the above.
+    'clsctx' specifies how to create the object, use the CLSCTX_... constants.
+    'machine' allows to specify a remote machine to create the object on.
+    'interface' allows to force a certain interface
+    'dynamic=True' will return a dynamic dispatch object
+    'pServerInfo', if used, must be a pointer to a comtypes.COSERVERINFO instance
+        This supercedes 'machine'.
+
+    You can also later request to receive events with GetEvents().
+    """
+    clsid = GUID.from_progid(progid)
+    logger.debug("%s -> %s", progid, clsid)
+    if dynamic:
+        if interface:
+            raise ValueError("interface and dynamic are mutually exclusive")
+        interface = automation.IDispatch
+    elif interface is None:
+        interface = getattr(progid, "_com_interfaces_", [None])[0]
+    if machine is None and pServerInfo is None:
+        logger.debug(
+            "CoCreateInstance(%s, clsctx=%s, interface=%s)", clsid, clsctx, interface
+        )
+        obj = comtypes.CoCreateInstance(clsid, clsctx=clsctx, interface=interface)
+    else:
+        logger.debug(
+            "CoCreateInstanceEx(%s, clsctx=%s, interface=%s, machine=%s,\
+                        pServerInfo=%s)",
+            clsid,
+            clsctx,
+            interface,
+            machine,
+            pServerInfo,
+        )
+        if machine is not None and pServerInfo is not None:
+            msg = "You cannot set both the machine name and server info."
+            raise ValueError(msg)
+        obj = comtypes.CoCreateInstanceEx(
+            clsid,
+            clsctx=clsctx,
+            interface=interface,
+            machine=machine,
+            pServerInfo=pServerInfo,
+        )
+    if dynamic:
+        return comtypes.client.dynamic.Dispatch(obj)
+    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
+) -> Any: ...
+def CoGetObject(
+    displayname: str,
+    interface: Optional[Type[IUnknown]] = None,
+    dynamic: bool = False,
+) -> Any:
+    """Create an object by calling CoGetObject(displayname).
+
+    Additional parameters have the same meaning as in CreateObject().
+    """
+    if dynamic:
+        if interface is not None:
+            raise ValueError("interface and dynamic are mutually exclusive")
+        interface = automation.IDispatch
+    punk = comtypes.CoGetObject(displayname, interface)
+    if dynamic:
+        return comtypes.client.dynamic.Dispatch(punk)
+    return _manage(punk, clsid=None, interface=interface)

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/client/_events.py

@@ -1,55 +1,122 @@
 import ctypes
+import logging
 import traceback
+from _ctypes import COMError
+from ctypes import HRESULT, POINTER, WINFUNCTYPE, OleDLL, Structure, WinDLL, byref
+from ctypes.wintypes import (
+    BOOL,
+    DWORD,
+    HANDLE,
+    LPCSTR,
+    LPDWORD,
+    LPHANDLE,
+    LPVOID,
+    ULONG,
+)
+from typing import Any, Callable, Optional, Type
+from typing import Union as _UnionT
+
 import comtypes
-import comtypes.hresult
-import comtypes.automation
-import comtypes.typeinfo
-import comtypes.connectionpoints
+from comtypes import COMObject, IUnknown, hresult
+from comtypes._comobject import _MethodFinder
+from comtypes.automation import DISPATCH_METHOD, IDispatch
 from comtypes.client._generate import GetModule
-import logging
+from comtypes.connectionpoints import IConnectionPoint, IConnectionPointContainer
+from comtypes.typeinfo import GUIDKIND_DEFAULT_SOURCE_DISP_IID, IProvideClassInfo2
 
 logger = logging.getLogger(__name__)
 
 
+class SECURITY_ATTRIBUTES(Structure):
+    _fields_ = [
+        ("nLength", DWORD),
+        ("lpSecurityDescriptor", LPVOID),
+        ("bInheritHandle", BOOL),
+    ]
+
+
+_ole32 = OleDLL("ole32")
+
+_CoWaitForMultipleHandles = _ole32.CoWaitForMultipleHandles
+_CoWaitForMultipleHandles.argtypes = [DWORD, DWORD, ULONG, LPHANDLE, LPDWORD]
+_CoWaitForMultipleHandles.restype = HRESULT
+
+
+_kernel32 = WinDLL("kernel32")
+
+_CreateEventA = _kernel32.CreateEventA
+_CreateEventA.argtypes = [POINTER(SECURITY_ATTRIBUTES), BOOL, BOOL, LPCSTR]
+_CreateEventA.restype = HANDLE
+
+_SetEvent = _kernel32.SetEvent
+_SetEvent.argtypes = [HANDLE]
+_SetEvent.restype = BOOL
+
+PHANDLER_ROUTINE = WINFUNCTYPE(BOOL, DWORD)
+_SetConsoleCtrlHandler = _kernel32.SetConsoleCtrlHandler
+_SetConsoleCtrlHandler.argtypes = [PHANDLER_ROUTINE, BOOL]
+_SetConsoleCtrlHandler.restype = BOOL
+
+_CloseHandle = _kernel32.CloseHandle
+_CloseHandle.argtypes = [HANDLE]
+_CloseHandle.restype = BOOL
+
+_ReceiverType = _UnionT[COMObject, IUnknown]
+
+
 class _AdviseConnection(object):
-    def __init__(self, source, interface, receiver):
+    cp: Optional[IConnectionPoint]
+    cookie: Optional[int]
+    receiver: Optional[_ReceiverType]
+
+    def __init__(
+        self, source: IUnknown, interface: Type[IUnknown], receiver: _ReceiverType
+    ) -> None:
+        # Pre-initializing attributes to avoid AttributeError after failed connection.
         self.cp = None
         self.cookie = None
         self.receiver = None
         self._connect(source, interface, receiver)
 
-    def _connect(self, source, interface, receiver):
-        cpc = source.QueryInterface(comtypes.connectionpoints.IConnectionPointContainer)
-        self.cp = cpc.FindConnectionPoint(ctypes.byref(interface._iid_))
+    def _connect(
+        self, source: IUnknown, interface: Type[IUnknown], receiver: _ReceiverType
+    ) -> None:
+        cpc = source.QueryInterface(IConnectionPointContainer)
+        self.cp = cpc.FindConnectionPoint(byref(interface._iid_))
         logger.debug("Start advise %s", interface)
-        self.cookie = self.cp.Advise(receiver)
+        # Since `POINTER(IUnknown).from_param`(`_compointer_base.from_param`)
+        # can accept a `COMObject` instance, `IConnectionPoint.Advise` can
+        # take either a COM object or a COM interface pointer.
+        self.cookie = self.cp.Advise(receiver)  # type: ignore
         self.receiver = receiver
 
-    def disconnect(self):
+    def disconnect(self) -> None:
         if self.cookie:
+            assert self.cp is not None
             self.cp.Unadvise(self.cookie)
             logger.debug("Unadvised %s", self.cp)
             self.cp = None
             self.cookie = None
             del self.receiver
 
-    def __del__(self):
+    def __del__(self) -> None:
         try:
             if self.cookie is not None:
+                assert self.cp is not None
                 self.cp.Unadvise(self.cookie)
-        except (comtypes.COMError, WindowsError):
+        except (COMError, WindowsError):
             # Are we sure we want to ignore errors here?
             pass
 
 
-def FindOutgoingInterface(source):
+def FindOutgoingInterface(source: IUnknown) -> Type[IUnknown]:
     """XXX Describe the strategy that is used..."""
     # If the COM object implements IProvideClassInfo2, it is easy to
     # find the default outgoing interface.
     try:
-        pci = source.QueryInterface(comtypes.typeinfo.IProvideClassInfo2)
-        guid = pci.GetGUID(1)
-    except comtypes.COMError:
+        pci = source.QueryInterface(IProvideClassInfo2)
+        guid = pci.GetGUID(GUIDKIND_DEFAULT_SOURCE_DISP_IID)
+    except COMError:
         pass
     else:
         # another try: block needed?
@@ -68,7 +135,7 @@ def FindOutgoingInterface(source):
     # comtypes.client):
     clsid = source.__dict__.get("__clsid")
     try:
-        interface = comtypes.com_coclass_registry[clsid]._outgoing_interfaces_[0]
+        interface = comtypes.com_coclass_registry[clsid]._outgoing_interfaces_[0]  # type: ignore
     except KeyError:
         pass
     else:
@@ -86,7 +153,7 @@ def find_single_connection_interface(source):
     # Enumerate the connection interfaces.  If we find a single one,
     # return it, if there are more, we give up since we cannot
     # determine which one to use.
-    cpc = source.QueryInterface(comtypes.connectionpoints.IConnectionPointContainer)
+    cpc = source.QueryInterface(IConnectionPointContainer)
     enum = cpc.EnumConnectionPoints()
     iid = enum.next().GetConnectionInterface()
     try:
@@ -105,32 +172,33 @@ def find_single_connection_interface(source):
     return None
 
 
-def report_errors(func):
+def report_errors(func: Callable[..., Any]) -> Callable[..., Any]:
     # This decorator preserves parts of the decorated function
     # signature, so that the comtypes special-casing for the 'this'
     # parameter still works.
     if func.__code__.co_varnames[:2] == ("self", "this"):
 
-        def error_printer(self, this, *args, **kw):
+        def with_this(self, this, *args, **kw):
             try:
                 return func(self, this, *args, **kw)
             except:
                 traceback.print_exc()
                 raise
 
+        error_printer = with_this
+
     else:
 
-        def error_printer(*args, **kw):
+        def without_this(*args, **kw):
             try:
                 return func(*args, **kw)
             except:
                 traceback.print_exc()
                 raise
 
-    return error_printer
-
+        error_printer = without_this
 
-from comtypes._comobject import _MethodFinder
+    return error_printer
 
 
 class _SinkMethodFinder(_MethodFinder):
@@ -140,11 +208,11 @@ class _SinkMethodFinder(_MethodFinder):
     event handlers.
     """
 
-    def __init__(self, inst, sink):
+    def __init__(self, inst: COMObject, sink: Any) -> None:
         super(_SinkMethodFinder, self).__init__(inst)
         self.sink = sink
 
-    def find_method(self, fq_name, mthname):
+    def find_method(self, fq_name: str, mthname: str) -> Callable[..., Any]:
         impl = self._find_method(fq_name, mthname)
         # Caller of this method catches AttributeError,
         # so we need to be careful in the following code
@@ -159,7 +227,7 @@ class _SinkMethodFinder(_MethodFinder):
         except AttributeError as details:
             raise RuntimeError(details)
 
-    def _find_method(self, fq_name, mthname):
+    def _find_method(self, fq_name: str, mthname: str) -> Callable[..., Any]:
         try:
             return super(_SinkMethodFinder, self).find_method(fq_name, mthname)
         except AttributeError:
@@ -169,11 +237,11 @@ class _SinkMethodFinder(_MethodFinder):
                 return getattr(self.sink, mthname)
 
 
-def CreateEventReceiver(interface, handler):
-    class Sink(comtypes.COMObject):
+def CreateEventReceiver(interface: Type[IUnknown], handler: Any) -> COMObject:
+    class Sink(COMObject):
         _com_interfaces_ = [interface]
 
-        def _get_method_finder_(self, itf):
+        def _get_method_finder_(self, itf: Type[IUnknown]) -> _MethodFinder:
             # Use a special MethodFinder that will first try 'self',
             # then the sink.
             return _SinkMethodFinder(self, handler)
@@ -182,25 +250,25 @@ def CreateEventReceiver(interface, handler):
 
     # Since our Sink object doesn't have typeinfo, it needs a
     # _dispimpl_ dictionary to dispatch events received via Invoke.
-    if issubclass(interface, comtypes.automation.IDispatch) and not hasattr(
-        sink, "_dispimpl_"
-    ):
+    if issubclass(interface, IDispatch) and not hasattr(sink, "_dispimpl_"):
         finder = sink._get_method_finder_(interface)
         dispimpl = sink._dispimpl_ = {}
         for m in interface._methods_:
-            restype, mthname, argtypes, paramflags, idlflags, helptext = m
             # Can dispid be at a different index? Should check code generator...
             # ...but hand-written code should also work...
-            dispid = idlflags[0]
-            impl = finder.get_impl(interface, mthname, paramflags, idlflags)
+            dispid = m.idlflags[0]
+            assert isinstance(dispid, comtypes.dispid)
+            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?
-            dispimpl[(dispid, comtypes.automation.DISPATCH_METHOD)] = impl
+            dispimpl[(dispid, DISPATCH_METHOD)] = impl
 
     return sink
 
 
-def GetEvents(source, sink, interface=None):
+def GetEvents(
+    source: IUnknown, sink: Any, interface: Optional[Type[IUnknown]] = None
+) -> _AdviseConnection:
     """Receive COM events from 'source'.  Events will call methods on
     the 'sink' object.  'interface' is the source interface to use.
     """
@@ -218,7 +286,7 @@ def GetEvents(source, sink, interface=None):
 class EventDumper(object):
     """Universal sink for COM events."""
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> Callable[..., Any]:
         "Create event handler methods on demand"
         if name.startswith("__") and name.endswith("__"):
             raise AttributeError(name)
@@ -232,13 +300,15 @@ class EventDumper(object):
         return comtypes.instancemethod(handler, self, EventDumper)
 
 
-def ShowEvents(source, interface=None):
+def ShowEvents(
+    source: IUnknown, interface: Optional[Type[IUnknown]] = None
+) -> _AdviseConnection:
     """Receive COM events from 'source'.  A special event sink will be
     used that first prints the names of events that are found in the
     outgoing interface, and will also print out the events when they
     are fired.
     """
-    return comtypes.client.GetEvents(source, sink=EventDumper(), interface=interface)
+    return GetEvents(source, sink=EventDumper(), interface=interface)
 
 
 # This type is used inside 'PumpEvents', but if we create the type
@@ -246,8 +316,24 @@ def ShowEvents(source, interface=None):
 # garbage for each call.  So we define it here instead.
 _handles_type = ctypes.c_void_p * 1
 
+# The type of control signal received by the handler.
+CTRL_C_EVENT = 0
+CTRL_BREAK_EVENT = 1
+CTRL_CLOSE_EVENT = 2
+CTRL_LOGOFF_EVENT = 5
+CTRL_SHUTDOWN_EVENT = 6
 
-def PumpEvents(timeout):
+# Specifiers for the behavior of the CoWaitForMultipleHandles function.
+# tagCOWAIT_FLAGS = ctypes.c_int
+COWAIT_DEFAULT = 0
+COWAIT_WAITALL = 1
+COWAIT_ALERTABLE = 2
+COWAIT_INPUTAVAILABLE = 4
+COWAIT_DISPATCH_CALLS = 8
+COWAIT_DISPATCH_WINDOW_MESSAGES = 16
+
+
+def PumpEvents(timeout: Any) -> None:
     """This following code waits for 'timeout' seconds in the way
     required for COM, internally doing the correct things depending
     on the COM appartment of the current thread.  It is possible to
@@ -274,35 +360,32 @@ def PumpEvents(timeout):
     # CoWaitForMultipleHandles calls the Win32 function
     # MsgWaitForMultipleObjects.
 
-    hevt = ctypes.windll.kernel32.CreateEventA(None, True, False, None)
+    hevt = _CreateEventA(None, True, False, None)
     handles = _handles_type(hevt)
-    RPC_S_CALLPENDING = -2147417835
 
-    # @ctypes.WINFUNCTYPE(ctypes.c_int, ctypes.c_uint)
+    # @ctypes.WINFUNCTYPE(BOOL, DWORD)
     def HandlerRoutine(dwCtrlType):
-        if dwCtrlType == 0:  # CTRL+C
-            ctypes.windll.kernel32.SetEvent(hevt)
+        if dwCtrlType == CTRL_C_EVENT:  # CTRL+C
+            _SetEvent(hevt)
             return 1
         return 0
 
-    HandlerRoutine = ctypes.WINFUNCTYPE(ctypes.c_int, ctypes.c_uint)(HandlerRoutine)
-
-    ctypes.windll.kernel32.SetConsoleCtrlHandler(HandlerRoutine, 1)
+    _SetConsoleCtrlHandler(PHANDLER_ROUTINE(HandlerRoutine), 1)
 
     try:
         try:
-            res = ctypes.oledll.ole32.CoWaitForMultipleHandles(
-                0,
+            _CoWaitForMultipleHandles(
+                COWAIT_DEFAULT,
                 int(timeout * 1000),
                 len(handles),
                 handles,
-                ctypes.byref(ctypes.c_ulong()),
+                byref(ctypes.c_ulong()),
             )
         except WindowsError as details:
-            if details.winerror != RPC_S_CALLPENDING:  # timeout expired
+            if details.winerror != hresult.RPC_S_CALLPENDING:  # timeout expired
                 raise
         else:
             raise KeyboardInterrupt
     finally:
-        ctypes.windll.kernel32.CloseHandle(hevt)
-        ctypes.windll.kernel32.SetConsoleCtrlHandler(HandlerRoutine, 0)
+        _CloseHandle(hevt)
+        _SetConsoleCtrlHandler(PHANDLER_ROUTINE(HandlerRoutine), 0)

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/client/_generate.py

@@ -5,18 +5,16 @@ import logging
 import os
 import sys
 import types
-from typing import Any, Tuple, List, Mapping, Optional, Dict, Union as _UnionT
 import winreg
+from typing import Any, Dict, List, Mapping, Optional, Tuple
+from typing import Union as _UnionT
 
-from comtypes import GUID, typeinfo
 import comtypes.client
+from comtypes import GUID, typeinfo
 from comtypes.tools import codegenerator, tlbparser
 
-
 logger = logging.getLogger(__name__)
 
-PATH = os.environ["PATH"].split(os.pathsep)
-
 
 def _my_import(fullname: str) -> types.ModuleType:
     """helper function to import dotted modules"""

comtypes-1.4.11/comtypes/client/_managing.py

@@ -0,0 +1,114 @@
+import logging
+from _ctypes import COMError
+from typing import Any, Optional, Type
+
+import comtypes
+import comtypes.client.dynamic
+from comtypes import GUID, IUnknown, automation, typeinfo
+from comtypes.client._generate import GetModule
+
+logger = logging.getLogger(__name__)
+
+
+def wrap_outparam(punk: Any) -> Any:
+    logger.debug("wrap_outparam(%s)", punk)
+    if not punk:
+        return None
+    if punk.__com_interface__ == automation.IDispatch:
+        return GetBestInterface(punk)
+    return punk
+
+
+def GetBestInterface(punk: Any) -> Any:
+    """Try to QueryInterface a COM pointer to the 'most useful'
+    interface.
+
+    Get type information for the provided object, either via
+    IDispatch.GetTypeInfo(), or via IProvideClassInfo.GetClassInfo().
+    Generate a wrapper module for the typelib, and QI for the
+    interface found.
+    """
+    if not punk:  # NULL COM pointer
+        return punk  # or should we return None?
+    # find the typelib and the interface name
+    logger.debug("GetBestInterface(%s)", punk)
+    try:
+        try:
+            pci = punk.QueryInterface(typeinfo.IProvideClassInfo)
+            logger.debug("Does implement IProvideClassInfo")
+        except COMError:
+            # Some COM objects support IProvideClassInfo2, but not IProvideClassInfo.
+            # These objects are broken, but we support them anyway.
+            logger.debug(
+                "Does NOT implement IProvideClassInfo, trying IProvideClassInfo2"
+            )
+            pci = punk.QueryInterface(typeinfo.IProvideClassInfo2)
+            logger.debug("Does implement IProvideClassInfo2")
+        tinfo = pci.GetClassInfo()  # TypeInfo for the CoClass
+        # find the interface marked as default
+        ta = tinfo.GetTypeAttr()
+        for index in range(ta.cImplTypes):
+            if tinfo.GetImplTypeFlags(index) == 1:
+                break
+        else:
+            if ta.cImplTypes != 1:
+                # Hm, should we use dynamic now?
+                raise TypeError("No default interface found")
+            # Only one interface implemented, use that (even if
+            # not marked as default).
+            index = 0
+        href = tinfo.GetRefTypeOfImplType(index)
+        tinfo = tinfo.GetRefTypeInfo(href)
+    except COMError:
+        logger.debug("Does NOT implement IProvideClassInfo/IProvideClassInfo2")
+        try:
+            pdisp = punk.QueryInterface(automation.IDispatch)
+        except COMError:
+            logger.debug("No Dispatch interface: %s", punk)
+            return punk
+        try:
+            tinfo = pdisp.GetTypeInfo(0)
+        except COMError:
+            pdisp = comtypes.client.dynamic.Dispatch(pdisp)
+            logger.debug("IDispatch.GetTypeInfo(0) failed: %s" % pdisp)
+            return pdisp
+    typeattr = tinfo.GetTypeAttr()
+    logger.debug("Default interface is %s", typeattr.guid)
+    try:
+        punk.QueryInterface(IUnknown, typeattr.guid)
+    except COMError:
+        logger.debug("Does not implement default interface, returning dynamic object")
+        return comtypes.client.dynamic.Dispatch(punk)
+
+    itf_name = tinfo.GetDocumentation(-1)[0]  # interface name
+    tlib = tinfo.GetContainingTypeLib()[0]  # typelib
+
+    # import the wrapper, generating it on demand
+    mod = GetModule(tlib)
+    # Python interface class
+    interface = getattr(mod, itf_name)
+    logger.debug("Implements default interface from typeinfo %s", interface)
+    # QI for this interface
+    # XXX
+    # What to do if this fails?
+    # In the following example the engine.Eval() call returns
+    # such an object.
+    #
+    # engine = CreateObject("MsScriptControl.ScriptControl")
+    # engine.Language = "JScript"
+    # engine.Eval("[1, 2, 3]")
+    #
+    # Could the above code, as an optimization, check that QI works,
+    # *before* generating the wrapper module?
+    result = punk.QueryInterface(interface)
+    logger.debug("Final result is %s", result)
+    return result
+
+
+def _manage(
+    obj: Any, clsid: Optional[GUID], interface: Optional[Type[IUnknown]]
+) -> Any:
+    obj.__dict__["__clsid"] = str(clsid)
+    if interface is None:
+        obj = GetBestInterface(obj)
+    return obj

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/client/dynamic.py

@@ -1,10 +1,9 @@
 import ctypes
 from typing import Any, Dict, Optional, Set, Type, TypeVar
 
-from comtypes import automation
+from comtypes import GUID, COMError, IUnknown, _is_object, automation
+from comtypes import hresult as hres
 from comtypes.client import lazybind
-from comtypes import COMError, GUID, IUnknown, hresult as hres, _is_object
-
 
 _T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
 # These errors generally mean the property or method exists,

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/client/lazybind.py

@@ -1,16 +1,15 @@
 import comtypes
 import comtypes.automation
-
-from comtypes.automation import IEnumVARIANT
-from comtypes.automation import DISPATCH_METHOD
-from comtypes.automation import DISPATCH_PROPERTYGET
-from comtypes.automation import DISPATCH_PROPERTYPUT
-from comtypes.automation import DISPATCH_PROPERTYPUTREF
-
-from comtypes.automation import DISPID_VALUE
-from comtypes.automation import DISPID_NEWENUM
-
-from comtypes.typeinfo import FUNC_PUREVIRTUAL, FUNC_DISPATCH
+from comtypes.automation import (
+    DISPATCH_METHOD,
+    DISPATCH_PROPERTYGET,
+    DISPATCH_PROPERTYPUT,
+    DISPATCH_PROPERTYPUTREF,
+    DISPID_NEWENUM,
+    DISPID_VALUE,
+    IEnumVARIANT,
+)
+from comtypes.typeinfo import FUNC_DISPATCH, FUNC_PUREVIRTUAL
 
 
 class FuncDesc(object):