comtypes 1.4.9__zip → 1.4.10__zip

comtypes-1.4.10/comtypes/client/__init__.py

@@ -0,0 +1,42 @@
+"""comtypes.client - High level client level COM support package."""
+
+import ctypes
+import logging
+
+from comtypes import automation
+from comtypes.client import dynamic, lazybind  # noqa
+from comtypes.client._code_cache import _find_gen_dir
+from comtypes.client._constants import Constants  # noqa
+from comtypes.client._events import GetEvents, PumpEvents, ShowEvents
+from comtypes.client._generate import GetModule
+from comtypes.client._managing import GetBestInterface, _manage, wrap_outparam  # noqa
+from comtypes.hresult import *  # noqa
+
+gen_dir = _find_gen_dir()
+import comtypes.gen  # noqa
+
+### for testing
+##gen_dir = None
+
+logger = logging.getLogger(__name__)
+
+
+# backwards compatibility:
+wrap = GetBestInterface
+
+# Should we do this for POINTER(IUnknown) also?
+ctypes.POINTER(automation.IDispatch).__ctypes_from_outparam__ = wrap_outparam  # type: ignore
+
+from comtypes.client._activeobj import GetActiveObject
+from comtypes.client._create import (
+    CoGetObject,
+    CreateObject,
+    GetClassObject,
+)
+
+# fmt: off
+__all__ = [
+    "CreateObject", "GetActiveObject", "CoGetObject", "GetEvents",
+    "ShowEvents", "PumpEvents", "GetModule", "GetClassObject",
+]
+# fmt: on

comtypes-1.4.10/comtypes/client/_activeobj.py

@@ -0,0 +1,46 @@
+from typing import Any, Optional, Type, TypeVar, overload
+from typing import Union as _UnionT
+
+import comtypes
+import comtypes.client.dynamic
+from comtypes import GUID, CoClass, IUnknown, automation
+from comtypes.client._managing import _manage
+
+_T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
+
+
+################################################################
+#
+# Object creation
+#
+@overload
+def GetActiveObject(progid: _UnionT[str, Type[CoClass], GUID]) -> Any: ...
+@overload
+def GetActiveObject(
+    progid: _UnionT[str, Type[CoClass], GUID], interface: Type[_T_IUnknown]
+) -> _T_IUnknown: ...
+def GetActiveObject(
+    progid: _UnionT[str, Type[CoClass], GUID],
+    interface: Optional[Type[IUnknown]] = None,
+    dynamic: bool = False,
+) -> Any:
+    """Return a pointer to a running COM object that has been
+    registered with COM.
+
+    'progid' may be a string like "Excel.Application",
+       a string specifying a clsid, a GUID instance, or an object with
+       a _clsid_ attribute which should be any of the above.
+    'interface' allows to force a certain interface.
+    'dynamic=True' will return a dynamic dispatch object.
+    """
+    clsid = GUID.from_progid(progid)
+    if dynamic:
+        if interface is not None:
+            raise ValueError("interface and dynamic are mutually exclusive")
+        interface = automation.IDispatch
+    elif interface is None:
+        interface = getattr(progid, "_com_interfaces_", [None])[0]
+    obj = comtypes.GetActiveObject(clsid, interface=interface)
+    if dynamic:
+        return comtypes.client.dynamic.Dispatch(obj)
+    return _manage(obj, clsid, interface=interface)

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/client/_code_cache.py

@@ -5,7 +5,12 @@ comtypes.gen package and returns a directory where generated code can
 be written to.
 """
 
-import ctypes, logging, os, sys, tempfile, types
+import ctypes
+import logging
+import os
+import sys
+import tempfile
+import types
 from ctypes import wintypes
 
 logger = logging.getLogger(__name__)

comtypes-1.4.10/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.10}/comtypes/client/_events.py

@@ -1,16 +1,63 @@
 import ctypes
+import logging
 import traceback
+from ctypes import HRESULT, POINTER, WINFUNCTYPE, OleDLL, Structure, WinDLL
+from ctypes.wintypes import (
+    BOOL,
+    DWORD,
+    HANDLE,
+    LPCSTR,
+    LPDWORD,
+    LPHANDLE,
+    LPVOID,
+    ULONG,
+)
+
 import comtypes
-import comtypes.hresult
 import comtypes.automation
-import comtypes.typeinfo
 import comtypes.connectionpoints
+import comtypes.hresult
+import comtypes.typeinfo
 from comtypes.client._generate import GetModule
-import logging
 
 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
+
+
 class _AdviseConnection(object):
     def __init__(self, source, interface, receiver):
         self.cp = None
@@ -274,24 +321,22 @@ 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)
+            _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(
+            res = _CoWaitForMultipleHandles(
                 0,
                 int(timeout * 1000),
                 len(handles),
@@ -304,5 +349,5 @@ def PumpEvents(timeout):
         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.10}/comtypes/client/_generate.py

@@ -5,14 +5,14 @@ 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)

comtypes-1.4.10/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.10}/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.10}/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):

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/connectionpoints.py

@@ -1,6 +1,7 @@
 import sys
 from ctypes import *
-from comtypes import IUnknown, COMMETHOD, GUID, HRESULT, dispid
+
+from comtypes import COMMETHOD, GUID, HRESULT, IUnknown, dispid
 
 _GUID = GUID
 

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/errorinfo.py

@@ -1,7 +1,8 @@
 import sys
 from ctypes import *
-from ctypes.wintypes import DWORD
-from comtypes import IUnknown, HRESULT, COMMETHOD, GUID, BSTR
+from ctypes.wintypes import DWORD, ULONG
+
+from comtypes import BSTR, COMMETHOD, GUID, HRESULT, IUnknown
 from comtypes.hresult import *
 
 LPCOLESTR = c_wchar_p
@@ -45,26 +46,38 @@ class ISupportErrorInfo(IUnknown):
 
 
 ################################################################
-_oleaut32 = oledll.oleaut32
+_oleaut32 = OleDLL("oleaut32")
+
+_CreateErrorInfo = _oleaut32.CreateErrorInfo
+_CreateErrorInfo.argtypes = [POINTER(POINTER(ICreateErrorInfo))]
+_CreateErrorInfo.restype = HRESULT
+
+_GetErrorInfo = _oleaut32.GetErrorInfo
+_GetErrorInfo.argtypes = [ULONG, POINTER(POINTER(IErrorInfo))]
+_GetErrorInfo.restype = HRESULT
+
+_SetErrorInfo = _oleaut32.SetErrorInfo
+_SetErrorInfo.argtypes = [ULONG, POINTER(IErrorInfo)]
+_SetErrorInfo.restype = HRESULT
 
 
 def CreateErrorInfo():
     cei = POINTER(ICreateErrorInfo)()
-    _oleaut32.CreateErrorInfo(byref(cei))
+    _CreateErrorInfo(byref(cei))
     return cei
 
 
 def GetErrorInfo():
     """Get the error information for the current thread."""
     errinfo = POINTER(IErrorInfo)()
-    if S_OK == _oleaut32.GetErrorInfo(0, byref(errinfo)):
+    if S_OK == _GetErrorInfo(0, byref(errinfo)):
         return errinfo
     return None
 
 
 def SetErrorInfo(errinfo):
     """Set error information for the current thread."""
-    return _oleaut32.SetErrorInfo(0, errinfo)
+    return _SetErrorInfo(0, errinfo)
 
 
 def ReportError(
@@ -89,7 +102,7 @@ def ReportError(
             ei.SetSource(
                 progid
             )  # progid for the class or application that created the error
-    _oleaut32.SetErrorInfo(0, ei)
+    _SetErrorInfo(0, ei)
     return hresult
 
 

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/git.py

@@ -6,14 +6,15 @@ between different threading appartments.
 
 from ctypes import *
 from ctypes.wintypes import DWORD
+
 from comtypes import (
-    IUnknown,
-    STDMETHOD,
+    CLSCTX_INPROC_SERVER,
     COMMETHOD,
     GUID,
     HRESULT,
+    STDMETHOD,
     CoCreateInstance,
-    CLSCTX_INPROC_SERVER,
+    IUnknown,
 )
 
 

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/logutil.py

@@ -1,13 +1,25 @@
 # logutil.py
-import logging, ctypes
+import logging
+from ctypes import WinDLL
+from ctypes.wintypes import LPCSTR, LPCWSTR
+
+_kernel32 = WinDLL("kernel32")
+
+_OutputDebugStringA = _kernel32.OutputDebugStringA
+_OutputDebugStringA.argtypes = [LPCSTR]
+_OutputDebugStringA.restype = None
+
+_OutputDebugStringW = _kernel32.OutputDebugStringW
+_OutputDebugStringW.argtypes = [LPCWSTR]
+_OutputDebugStringW.restype = None
 
 
 class NTDebugHandler(logging.Handler):
     def emit(
         self,
         record,
-        writeA=ctypes.windll.kernel32.OutputDebugStringA,
-        writeW=ctypes.windll.kernel32.OutputDebugStringW,
+        writeA=_OutputDebugStringA,
+        writeW=_OutputDebugStringW,
     ):
         text = self.format(record)
         if isinstance(text, str):

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/messageloop.py

@@ -1,5 +1,5 @@
 import ctypes
-from ctypes import WinDLL, byref, WinError
+from ctypes import WinDLL, WinError, byref
 from ctypes.wintypes import MSG
 
 _user32 = WinDLL("user32")

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/persist.py

@@ -10,13 +10,11 @@ The 'DictPropertyBag' class is a class implementing the IPropertyBag
 interface, useful in client code.
 """
 
-from ctypes import c_int, c_ulong, c_ushort, c_wchar_p
-from ctypes import POINTER, Structure
-from ctypes.wintypes import WORD, DWORD, BOOL
+from ctypes import POINTER, Structure, c_int, c_ulong, c_ushort, c_wchar_p
+from ctypes.wintypes import BOOL, DWORD, WORD
 from typing import TYPE_CHECKING
 
-from comtypes import GUID, IUnknown, COMMETHOD, HRESULT
-from comtypes import IPersist
+from comtypes import COMMETHOD, GUID, HRESULT, IPersist, IUnknown
 from comtypes.automation import VARIANT, tagEXCEPINFO
 
 if TYPE_CHECKING: