comtypes 1.4.8__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.8 → 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__)
@@ -48,23 +53,23 @@ def _find_gen_dir():
         # check type of executable image to determine a subdirectory
         # where generated modules are placed.
         ftype = getattr(sys, "frozen", None)
-        version_str = "%d%d" % sys.version_info[:2]
+        pymaj, pymin = sys.version_info[:2]
         if ftype == None:
             # Python script
-            subdir = r"Python\Python%s\comtypes_cache" % version_str
+            subdir = rf"Python\Python{pymaj:d}{pymin:d}\comtypes_cache"
             basedir = _get_appdata_dir()
 
         elif ftype == "dll":
             # dll created with py2exe
             path = _get_module_filename(sys.frozendllhandle)
             base = os.path.splitext(os.path.basename(path))[0]
-            subdir = r"comtypes_cache\%s-%s" % (base, version_str)
+            subdir = rf"comtypes_cache\{base}-{pymaj:d}{pymin:d}"
             basedir = tempfile.gettempdir()
 
         else:  # ftype in ('windows_exe', 'console_exe')
             # exe created by py2exe
             base = os.path.splitext(os.path.basename(sys.executable))[0]
-            subdir = r"comtypes_cache\%s-%s" % (base, version_str)
+            subdir = rf"comtypes_cache\{base}-{pymaj:d}{pymin:d}"
             basedir = tempfile.gettempdir()
 
         gen_dir = os.path.join(basedir, subdir)

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/client/_constants.py

@@ -118,7 +118,7 @@ class Constants(object):
                     # XXX is necessary warning? should use logging?
                     # import comtypes.tools
                     # if comtypes.tools.__warn_on_munge__:
-                    #     print("# Fixing keyword as VAR_CONST for %s" % name)
+                    #     print(f"# Fixing keyword as VAR_CONST for {name}")
                     name += "_"
                 members[name] = vdesc._.lpvarValue[0].value
         return _frozen_attr_dict(members)

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.8 → 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
@@ -227,7 +274,7 @@ class EventDumper(object):
         def handler(self, this, *args, **kw):
             # XXX handler is called with 'this'.  Should we really print "None" instead?
             args = (None,) + args
-            print("Event %s(%s)" % (name, ", ".join([repr(a) for a in args])))
+            print(f"Event {name}({', '.join([repr(a) for a in args])})")
 
         return comtypes.instancemethod(handler, self, EventDumper)
 
@@ -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.8 → 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)
@@ -139,20 +139,16 @@ def _load_tlib(obj: Any) -> typeinfo.ITypeLib:
     elif isinstance(obj, GUID):
         clsid = str(obj)
         # lookup associated typelib in registry
-        with winreg.OpenKey(
-            winreg.HKEY_CLASSES_ROOT, r"CLSID\%s\TypeLib" % clsid
-        ) as key:
+        with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"CLSID\{clsid}\TypeLib") as key:
             libid = winreg.EnumValue(key, 0)[1]
-        with winreg.OpenKey(
-            winreg.HKEY_CLASSES_ROOT, r"CLSID\%s\Version" % clsid
-        ) as key:
+        with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"CLSID\{clsid}\Version") as key:
             ver = winreg.EnumValue(key, 0)[1].split(".")
         return typeinfo.LoadRegTypeLib(GUID(libid), int(ver[0]), int(ver[1]), 0)
     # obj is a sequence containing libid
     elif isinstance(obj, (tuple, list)):
         libid, ver = obj[0], obj[1:]
         if not ver:  # case of version numbers are not containing
-            with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"TypeLib\%s" % libid) as key:
+            with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"TypeLib\{libid}") as key:
                 ver = [int(v, base=16) for v in winreg.EnumKey(key, 0).split(".")]
         return typeinfo.LoadRegTypeLib(GUID(libid), *ver)
     # obj is a COMObject implementation
@@ -161,7 +157,7 @@ def _load_tlib(obj: Any) -> typeinfo.ITypeLib:
     # obj is a pointer of ITypeLib
     elif isinstance(obj, ctypes.POINTER(typeinfo.ITypeLib)):
         return obj  # type: ignore
-    raise TypeError("'%r' is not supported type for loading typelib" % obj)
+    raise TypeError(f"'{obj!r}' is not supported type for loading typelib")
 
 
 def _get_existing_module(tlib: typeinfo.ITypeLib) -> Optional[types.ModuleType]:

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.8 → 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.8 → 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):
@@ -67,7 +66,7 @@ class NamedProperty(object):
 
     def __iter__(self):
         """Explicitly disallow iteration."""
-        msg = "%r is not iterable" % self.disp
+        msg = f"{self.disp!r} is not iterable"
         raise TypeError(msg)
 
 
@@ -151,7 +150,7 @@ class Dispatch(object):
                 if descr.cParams == 1:
                     return self._comobj._invoke(descr.memid, descr.invkind, 0)
             else:
-                raise RuntimeError("funckind %d not yet implemented" % descr.funckind)
+                raise RuntimeError(f"funckind {descr.funckind:d} not yet implemented")
             put = self.__bind(name, DISPATCH_PROPERTYPUT)
             putref = self.__bind(name, DISPATCH_PROPERTYPUTREF)
             return NamedProperty(self, descr, put, putref)

{comtypes-1.4.8 → 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