comtypes 1.4.7__zip → 1.4.9__zip

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/server/localserver.py

@@ -1,10 +1,16 @@
+import logging
+import queue
 import sys
-from ctypes import *
+from ctypes import byref, c_ulong, c_void_p, oledll
+from typing import TYPE_CHECKING, Any, Literal, Optional, Sequence, Type
+
 import comtypes
-from comtypes.hresult import *
+from comtypes import hresult
 from comtypes.server import IClassFactory
-import logging
-import queue
+
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+
 
 logger = logging.getLogger(__name__)
 _debug = logger.debug
@@ -16,31 +22,31 @@ REGCLS_SUSPENDED = 4  # register it as suspended, will be activated
 REGCLS_SURROGATE = 8  # must be used when a surrogate process
 
 
-def run(classes):
+def run(classes: Sequence[Type[comtypes.COMObject]]) -> None:
     classobjects = [ClassFactory(cls) for cls in classes]
     comtypes.COMObject.__run_localserver__(classobjects)
 
 
 class ClassFactory(comtypes.COMObject):
     _com_interfaces_ = [IClassFactory]
-    _locks = 0
-    _queue = None
-    regcls = REGCLS_MULTIPLEUSE
+    _locks: int = 0
+    _queue: Optional[queue.Queue] = None
+    regcls: int = REGCLS_MULTIPLEUSE
 
-    def __init__(self, cls, *args, **kw):
+    def __init__(self, cls: Type[comtypes.COMObject], *args, **kw) -> None:
         super(ClassFactory, self).__init__()
         self._cls = cls
         self._register_class()
         self._args = args
         self._kw = kw
 
-    def IUnknown_AddRef(self, this):
+    def IUnknown_AddRef(self, this: Any) -> int:
         return 2
 
-    def IUnknown_Release(self, this):
+    def IUnknown_Release(self, this: Any) -> int:
         return 1
 
-    def _register_class(self):
+    def _register_class(self) -> None:
         regcls = getattr(self._cls, "_regcls_", self.regcls)
         cookie = c_ulong()
         ptr = self._com_pointers_[comtypes.IUnknown._iid_]
@@ -55,19 +61,25 @@ class ClassFactory(comtypes.COMObject):
         )
         self.cookie = cookie
 
-    def _revoke_class(self):
+    def _revoke_class(self) -> None:
         oledll.ole32.CoRevokeClassObject(self.cookie)
 
-    def CreateInstance(self, this, punkOuter, riid, ppv):
+    def CreateInstance(
+        self,
+        this: Any,
+        punkOuter: Optional[Type["_Pointer[comtypes.IUnknown]"]],
+        riid: "_Pointer[comtypes.GUID]",
+        ppv: c_void_p,
+    ) -> int:
         _debug("ClassFactory.CreateInstance(%s)", riid[0])
         obj = self._cls(*self._args, **self._kw)
         result = obj.IUnknown_QueryInterface(None, riid, ppv)
         _debug("CreateInstance() -> %s", result)
         return result
 
-    def LockServer(self, this, fLock):
+    def LockServer(self, this: Any, fLock: bool) -> Literal[0]:
         if fLock:
             comtypes.COMObject.__server__.Lock()
         else:
             comtypes.COMObject.__server__.Unlock()
-        return S_OK
+        return hresult.S_OK

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/server/register.py

@@ -35,17 +35,19 @@ Now, debug the object, and when done delete logging info:
 
   python mycomobj.py /nodebug
 """
-import sys
+
+import logging
 import os
+import sys
 import winreg
-import logging
+from ctypes import WinError, c_ulong, c_wchar_p, create_string_buffer, sizeof, windll
+from typing import Iterator, Tuple
 
 import comtypes
-from comtypes.typeinfo import LoadTypeLibEx, UnRegisterTypeLib, REGKIND_REGISTER
+import comtypes.server.inprocserver
 from comtypes.hresult import *
 from comtypes.server import w_getopt
-import comtypes.server.inprocserver
-from ctypes import windll, c_ulong, c_wchar_p, WinError, sizeof, create_string_buffer
+from comtypes.typeinfo import REGKIND_REGISTER, LoadTypeLibEx, UnRegisterTypeLib
 
 _debug = logging.getLogger(__name__).debug
 
@@ -99,7 +101,7 @@ class Registrar(object):
                 'DeleteKey( %s\\CLSID\\%s\\Logging"'
                 % (_explain(winreg.HKEY_CLASSES_ROOT), clsid)
             )
-            hkey = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"CLSID\%s" % clsid)
+            hkey = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"CLSID\{clsid}")
             winreg.DeleteKey(hkey, "Logging")
         except WindowsError as detail:
             if get_winerror(detail) != 2:
@@ -114,7 +116,7 @@ class Registrar(object):
             'CreateKey( %s\\CLSID\\%s\\Logging"'
             % (_explain(winreg.HKEY_CLASSES_ROOT), clsid)
         )
-        hkey = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, r"CLSID\%s\Logging" % clsid)
+        hkey = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, rf"CLSID\{clsid}\Logging")
         for item in levels:
             name, value = item.split("=")
             v = getattr(logging, value)
@@ -146,8 +148,7 @@ class Registrar(object):
             self._register(cls, executable)
 
     def _register(self, cls, executable=None):
-        table = self._registry_entries(cls)
-        table.sort()
+        table = sorted(RegistryEntries(cls))
         _debug("Registering %s", cls)
         for hkey, subkey, valuename, value in table:
             _debug("[%s\\%s]", _explain(hkey), subkey)
@@ -158,7 +159,7 @@ class Registrar(object):
         tlib = getattr(cls, "_reg_typelib_", None)
         if tlib is not None:
             if hasattr(sys, "frozendllhandle"):
-                dll = self._get_serverdll()
+                dll = _get_serverdll()
                 _debug("LoadTypeLibEx(%s, REGKIND_REGISTER)", dll)
                 LoadTypeLibEx(dll, REGKIND_REGISTER)
             else:
@@ -183,7 +184,7 @@ class Registrar(object):
     def _unregister(self, cls, force=False):
         # If force==False, we only remove those entries that we
         # actually would have written.  It seems ATL does the same.
-        table = [t[:2] for t in self._registry_entries(cls)]
+        table = [t[:2] for t in RegistryEntries(cls)]
         # only unique entries
         table = list(set(table))
         table.sort()
@@ -213,23 +214,29 @@ class Registrar(object):
                     raise
         _debug("Done")
 
-    def _get_serverdll(self):
-        """Return the pathname of the dll hosting the COM object."""
-        handle = getattr(sys, "frozendllhandle", None)
-        if handle is not None:
-            buf = create_string_buffer(260)
-            windll.kernel32.GetModuleFileNameA(handle, buf, sizeof(buf))
-            return buf[:]
-        import _ctypes
 
-        return _ctypes.__file__
+def _get_serverdll():
+    """Return the pathname of the dll hosting the COM object."""
+    handle = getattr(sys, "frozendllhandle", None)
+    if handle is not None:
+        buf = create_string_buffer(260)
+        windll.kernel32.GetModuleFileNameA(handle, buf, sizeof(buf))
+        return buf[:]
+    import _ctypes
+
+    return _ctypes.__file__
+
+
+class RegistryEntries(object):
+    def __init__(self, cls):
+        self._cls = cls
 
     def _get_full_classname(self, cls):
         """Return <modulename>.<classname> for 'cls'."""
         modname = cls.__module__
         if modname == "__main__":
             modname = os.path.splitext(os.path.basename(sys.argv[0]))[0]
-        return "%s.%s" % (modname, cls.__name__)
+        return f"{modname}.{cls.__name__}"
 
     def _get_pythonpath(self, cls):
         """Return the filesystem path of the module containing 'cls'."""
@@ -237,8 +244,8 @@ class Registrar(object):
         dirname = os.path.dirname(sys.modules[modname].__file__)
         return os.path.abspath(dirname)
 
-    def _registry_entries(self, cls):
-        """Return a sequence of tuples containing registry entries.
+    def __iter__(self) -> Iterator[Tuple[int, str, str, str]]:
+        """Return a iterator of tuples containing registry entries.
 
         The tuples must be (key, subkey, name, value).
 
@@ -258,16 +265,13 @@ class Registrar(object):
         Note that the first part of the progid string is typically the
         IDL library name of the type library containing the coclass.
         """
+        cls = self._cls
         HKCR = winreg.HKEY_CLASSES_ROOT
 
-        # table format: rootkey, subkey, valuename, value
-        table = []
-        append = lambda *args: table.append(args)
-
         # basic entry - names the comobject
-        reg_clsid = str(
-            cls._reg_clsid_
-        )  # that's the only required attribute for registration
+
+        # that's the only required attribute for registration
+        reg_clsid = str(cls._reg_clsid_)
         reg_desc = getattr(cls, "_reg_desc_", "")
         if not reg_desc:
             # Simple minded algorithm to construct a description from
@@ -277,95 +281,83 @@ class Registrar(object):
             )
             if reg_desc:
                 reg_desc = reg_desc.replace(".", " ")
-        append(HKCR, "CLSID\\%s" % reg_clsid, "", reg_desc)
+        yield (HKCR, f"CLSID\\{reg_clsid}", "", reg_desc)
 
         reg_progid = getattr(cls, "_reg_progid_", None)
         if reg_progid:
             # for ProgIDFromCLSID:
-            append(HKCR, "CLSID\\%s\\ProgID" % reg_clsid, "", reg_progid)  # 1
+            yield (HKCR, f"CLSID\\{reg_clsid}\\ProgID", "", reg_progid)  # 1
 
             # for CLSIDFromProgID
             if reg_desc:
-                append(HKCR, reg_progid, "", reg_desc)  # 2
-            append(HKCR, "%s\\CLSID" % reg_progid, "", reg_clsid)  # 3
+                yield (HKCR, reg_progid, "", reg_desc)  # 2
+            yield (HKCR, f"{reg_progid}\\CLSID", "", reg_clsid)  # 3
 
             reg_novers_progid = getattr(cls, "_reg_novers_progid_", None)
             if reg_novers_progid:
-                append(
+                yield (
                     HKCR,
-                    "CLSID\\%s\\VersionIndependentProgID" % reg_clsid,  # 1a
+                    f"CLSID\\{reg_clsid}\\VersionIndependentProgID",  # 1a
                     "",
                     reg_novers_progid,
                 )
                 if reg_desc:
-                    append(HKCR, reg_novers_progid, "", reg_desc)  # 2a
-                append(HKCR, "%s\\CurVer" % reg_novers_progid, "", reg_progid)  #
-                append(HKCR, "%s\\CLSID" % reg_novers_progid, "", reg_clsid)  # 3a
+                    yield (HKCR, reg_novers_progid, "", reg_desc)  # 2a
+                yield (HKCR, f"{reg_novers_progid}\\CurVer", "", reg_progid)  #
+                yield (HKCR, f"{reg_novers_progid}\\CLSID", "", reg_clsid)  # 3a
 
-        clsctx = getattr(cls, "_reg_clsctx_", 0)
+        clsctx: int = getattr(cls, "_reg_clsctx_", 0)
+        localsvr_ctx = bool(clsctx & comtypes.CLSCTX_LOCAL_SERVER)
+        inprocsvr_ctx = bool(clsctx & comtypes.CLSCTX_INPROC_SERVER)
 
-        if clsctx & comtypes.CLSCTX_LOCAL_SERVER and not hasattr(
-            sys, "frozendllhandle"
-        ):
+        if localsvr_ctx and not hasattr(sys, "frozendllhandle"):
             exe = sys.executable
             if " " in exe:
-                exe = '"%s"' % exe
+                exe = f'"{exe}"'
             if not hasattr(sys, "frozen"):
                 if not __debug__:
-                    exe = "%s -O" % exe
+                    exe = f"{exe} -O"
                 script = os.path.abspath(sys.modules[cls.__module__].__file__)
                 if " " in script:
-                    script = '"%s"' % script
-                append(
-                    HKCR,
-                    "CLSID\\%s\\LocalServer32" % reg_clsid,
-                    "",
-                    "%s %s" % (exe, script),
-                )
+                    script = f'"{script}"'
+                yield (HKCR, rf"CLSID\{reg_clsid}\LocalServer32", "", f"{exe} {script}")
             else:
-                append(HKCR, "CLSID\\%s\\LocalServer32" % reg_clsid, "", "%s" % exe)
+                yield (HKCR, rf"CLSID\{reg_clsid}\LocalServer32", "", f"{exe}")
 
         # Register InprocServer32 only when run from script or from
         # py2exe dll server, not from py2exe exe server.
-        if clsctx & comtypes.CLSCTX_INPROC_SERVER and getattr(sys, "frozen", None) in (
-            None,
-            "dll",
-        ):
-            append(
-                HKCR, "CLSID\\%s\\InprocServer32" % reg_clsid, "", self._get_serverdll()
-            )
+        if inprocsvr_ctx and getattr(sys, "frozen", None) in (None, "dll"):
+            yield (HKCR, rf"CLSID\{reg_clsid}\InprocServer32", "", _get_serverdll())
             # only for non-frozen inproc servers the PythonPath/PythonClass is needed.
             if (
                 not hasattr(sys, "frozendllhandle")
                 or not comtypes.server.inprocserver._clsid_to_class
             ):
-                append(
+                yield (
                     HKCR,
-                    "CLSID\\%s\\InprocServer32" % reg_clsid,
+                    rf"CLSID\{reg_clsid}\InprocServer32",
                     "PythonClass",
                     self._get_full_classname(cls),
                 )
-                append(
+                yield (
                     HKCR,
-                    "CLSID\\%s\\InprocServer32" % reg_clsid,
+                    rf"CLSID\{reg_clsid}\InprocServer32",
                     "PythonPath",
                     self._get_pythonpath(cls),
                 )
 
             reg_threading = getattr(cls, "_reg_threading_", None)
             if reg_threading is not None:
-                append(
+                yield (
                     HKCR,
-                    "CLSID\\%s\\InprocServer32" % reg_clsid,
+                    rf"CLSID\{reg_clsid}\InprocServer32",
                     "ThreadingModel",
                     reg_threading,
                 )
 
         reg_tlib = getattr(cls, "_reg_typelib_", None)
         if reg_tlib is not None:
-            append(HKCR, "CLSID\\%s\\Typelib" % reg_clsid, "", reg_tlib[0])
-
-        return table
+            yield (HKCR, rf"CLSID\{reg_clsid}\Typelib", "", reg_tlib[0])
 
 
 ################################################################
@@ -380,10 +372,7 @@ def unregister(cls):
 
 
 def UseCommandLine(*classes):
-    usage = (
-        """Usage: %s [-regserver] [-unregserver] [-nodebug] [-f logformat] [-l loggername=level]"""
-        % sys.argv[0]
-    )
+    usage = f"""Usage: {sys.argv[0]} [-regserver] [-unregserver] [-nodebug] [-f logformat] [-l loggername=level]"""
     opts, args = w_getopt.w_getopt(
         sys.argv[1:], "regserver unregserver embedding l: f: nodebug"
     )

comtypes-1.4.9/comtypes/server/w_getopt.py

@@ -0,0 +1,48 @@
+from typing import Sequence, Tuple
+
+
+class GetoptError(Exception):
+    pass
+
+
+def w_getopt(
+    args: Sequence[str], options: str
+) -> Tuple[Sequence[Tuple[str, str]], Sequence[str]]:
+    """A getopt for Windows.
+
+    Options may start with either '-' or '/', the option names may
+    have more than one letter (/tlb or -RegServer), and option names
+    are case insensitive.
+
+    Returns two elements, just as getopt.getopt.  The first is a list
+    of (option, value) pairs in the same way getopt.getopt does, but
+    there is no '-' or '/' prefix to the option name, and the option
+    name is always lower case.  The second is the list of arguments
+    which do not belong to an option.
+
+    Different from getopt.getopt, a single argument not belonging to an option
+    does not terminate parsing.
+    """
+    opts = []
+    arguments = []
+    while args:
+        if args[0][:1] in "/-":
+            arg = args[0][1:]  # strip the '-' or '/'
+            arg = arg.lower()
+
+            if arg + ":" in options:
+                try:
+                    opts.append((arg, args[1]))
+                except IndexError:
+                    raise GetoptError(f"option '{args[0]}' requires an argument")
+                args = args[1:]
+            elif arg in options:
+                opts.append((arg, ""))
+            else:
+                raise GetoptError(f"invalid option '{args[0]}'")
+            args = args[1:]
+        else:
+            arguments.append(args[0])
+            args = args[1:]
+
+    return opts, arguments

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/shelllink.py

@@ -1,9 +1,8 @@
-from __future__ import print_function
 from ctypes import c_char_p, c_int, c_short, c_wchar_p
 from ctypes import POINTER
 from ctypes import byref, create_string_buffer, create_unicode_buffer
 from ctypes.wintypes import DWORD, WIN32_FIND_DATAA, WIN32_FIND_DATAW, MAX_PATH
-from typing import Tuple, TYPE_CHECKING
+from typing import Tuple, TYPE_CHECKING, Literal
 
 from comtypes import IUnknown, GUID, COMMETHOD, HRESULT, CoClass
 
@@ -18,19 +17,24 @@ SLGP_UNCPRIORITY = 0x2
 SLGP_RAWPATH = 0x4
 
 # for SetShowCmd, GetShowCmd
-##SW_SHOWNORMAL
-##SW_SHOWMAXIMIZED
-##SW_SHOWMINNOACTIVE
-
+SW_SHOWNORMAL = 0x01
+SW_SHOWMAXIMIZED = 0x03
+SW_SHOWMINNOACTIVE = 0x07
 
 # for Resolve
-##SLR_INVOKE_MSI
-##SLR_NOLINKINFO
-##SLR_NO_UI
-##SLR_NOUPDATE
-##SLR_NOSEARCH
-##SLR_NOTRACK
-##SLR_UPDATE
+SLR_INVOKE_MSI = 0x0080
+SLR_NOLINKINFO = 0x0040
+SLR_NO_UI = 0x0001
+SLR_NOUPDATE = 0x0008
+SLR_NOSEARCH = 0x0010
+SLR_NOTRACK = 0x0020
+SLR_UPDATE = 0x0004
+
+# for Hotkey
+HOTKEYF_ALT = 0x04
+HOTKEYF_CONTROL = 0x02
+HOTKEYF_EXT = 0x08
+HOTKEYF_SHIFT = 0x01
 
 # fake these...
 ITEMIDLIST = c_int
@@ -123,25 +127,26 @@ class IShellLinkA(IUnknown):
     ]
 
     if TYPE_CHECKING:
-        # fmt: off
-        def GetIDList(self) -> hints.Incomplete: ...  # noqa
-        def SetIDList(self, pidl: hints.Incomplete) -> hints.Incomplete: ...  # noqa
-        def SetDescription(self, pszName: bytes) -> hints.Incomplete: ...  # noqa
-        def SetWorkingDirectory(self, pszDir: bytes) -> hints.Hresult: ...   # noqa
-        def SetArguments(self, pszArgs: bytes) -> hints.Hresult: ...   # noqa
+
+        def GetIDList(self) -> hints.Incomplete: ...
+        def SetIDList(self, pidl: hints.Incomplete) -> hints.Incomplete: ...
+        def SetDescription(self, pszName: bytes) -> hints.Incomplete: ...
+        def SetWorkingDirectory(self, pszDir: bytes) -> hints.Hresult: ...
+        def SetArguments(self, pszArgs: bytes) -> hints.Hresult: ...
         @property
-        def Hotkey(self) -> int: ...   # noqa
+        def Hotkey(self) -> int: ...
         @Hotkey.setter
-        def Hotkey(self, pwHotkey: int) -> None: ...   # noqa
+        def Hotkey(self, pwHotkey: int) -> None: ...
         @property
-        def ShowCmd(self) -> int: ...   # noqa
+        def ShowCmd(self) -> int: ...
         @ShowCmd.setter
-        def ShowCmd(self, piShowCmd: int) -> None: ...   # noqa
-        def SetIconLocation(self, pszIconPath: bytes, iIcon: int) -> hints.Hresult: ...   # noqa
-        def SetRelativePath(self, pszPathRel: bytes, dwReserved: hints.Literal[0]) -> hints.Hresult: ...   # noqa
-        def Resolve(self, hwnd: int, fFlags: int) -> hints.Hresult: ...   # noqa
-        def SetPath(self, pszFile: bytes) -> hints.Hresult: ...   # noqa
-        # fmt: on
+        def ShowCmd(self, piShowCmd: int) -> None: ...
+        def SetIconLocation(self, pszIconPath: bytes, iIcon: int) -> hints.Hresult: ...
+        def SetRelativePath(
+            self, pszPathRel: bytes, dwReserved: Literal[0]
+        ) -> hints.Hresult: ...
+        def Resolve(self, hwnd: int, fFlags: int) -> hints.Hresult: ...
+        def SetPath(self, pszFile: bytes) -> hints.Hresult: ...
 
     def GetPath(self, flags: int = SLGP_SHORTPATH) -> bytes:
         buf = create_string_buffer(MAX_PATH)
@@ -257,25 +262,26 @@ class IShellLinkW(IUnknown):
     ]
 
     if TYPE_CHECKING:
-        # fmt: off
-        def GetIDList(self) -> hints.Incomplete: ...  # noqa
-        def SetIDList(self, pidl: hints.Incomplete) -> hints.Incomplete: ...  # noqa
-        def SetDescription(self, pszName: str) -> hints.Incomplete: ...  # noqa
-        def SetWorkingDirectory(self, pszDir: str) -> hints.Hresult: ...   # noqa
-        def SetArguments(self, pszArgs: str) -> hints.Hresult: ...   # noqa
+
+        def GetIDList(self) -> hints.Incomplete: ...
+        def SetIDList(self, pidl: hints.Incomplete) -> hints.Incomplete: ...
+        def SetDescription(self, pszName: str) -> hints.Incomplete: ...
+        def SetWorkingDirectory(self, pszDir: str) -> hints.Hresult: ...
+        def SetArguments(self, pszArgs: str) -> hints.Hresult: ...
         @property
-        def Hotkey(self) -> int: ...   # noqa
+        def Hotkey(self) -> int: ...
         @Hotkey.setter
-        def Hotkey(self, pwHotkey: int) -> None: ...   # noqa
+        def Hotkey(self, pwHotkey: int) -> None: ...
         @property
-        def ShowCmd(self) -> int: ...   # noqa
+        def ShowCmd(self) -> int: ...
         @ShowCmd.setter
-        def ShowCmd(self, piShowCmd: int) -> None: ...   # noqa
-        def SetIconLocation(self, pszIconPath: str, iIcon: int) -> hints.Hresult: ...   # noqa
-        def SetRelativePath(self, pszPathRel: str, dwReserved: hints.Literal[0]) -> hints.Hresult: ...   # noqa
-        def Resolve(self, hwnd: int, fFlags: int) -> hints.Hresult: ...   # noqa
-        def SetPath(self, pszFile: str) -> hints.Hresult: ...   # noqa
-        # fmt: on
+        def ShowCmd(self, piShowCmd: int) -> None: ...
+        def SetIconLocation(self, pszIconPath: str, iIcon: int) -> hints.Hresult: ...
+        def SetRelativePath(
+            self, pszPathRel: str, dwReserved: Literal[0]
+        ) -> hints.Hresult: ...
+        def Resolve(self, hwnd: int, fFlags: int) -> hints.Hresult: ...
+        def SetPath(self, pszFile: str) -> hints.Hresult: ...
 
     def GetPath(self, flags: int = SLGP_SHORTPATH) -> str:
         buf = create_unicode_buffer(MAX_PATH)
@@ -311,27 +317,3 @@ class ShellLink(CoClass):
     _reg_clsid_ = GUID("{00021401-0000-0000-C000-000000000046}")
     _idlflags_ = []
     _com_interfaces_ = [IShellLinkW, IShellLinkA]
-
-
-if __name__ == "__main__":
-
-    import sys
-    import comtypes
-    from comtypes.client import CreateObject
-    from comtypes.persist import IPersistFile
-
-    shortcut = CreateObject(ShellLink)
-    print(shortcut)
-    ##help(shortcut)
-
-    shortcut.SetPath(sys.executable)
-
-    shortcut.SetDescription("Python %s" % sys.version)
-    shortcut.SetIconLocation(sys.executable, 1)
-
-    print(shortcut.GetPath(2))
-    print(shortcut.GetIconLocation())
-
-    pf = shortcut.QueryInterface(IPersistFile)
-    pf.Save("foo.lnk", True)
-    print(pf.GetCurFile())

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/test/TestComServer.py

@@ -33,6 +33,7 @@ from comtypes.gen import TestComServerLib
 
 ################################################################
 
+
 # Implement the CoClass.  Use the coclass from the wrapper as base
 # class, and use DualDispMixin as base class which provides default
 # implementations of IDispatch, IProvideClassInfo, IProvideClassInfo2
@@ -42,7 +43,6 @@ class TestComServer(
     TestComServerLib.TestComServer,  # the coclass from the typelib wrapper
     comtypes.server.connectionpoints.ConnectableObjectMixin,
 ):
-
     # The default interface from the typelib MUST be the first
     # interface, other interfaces can follow
 

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/test/TestDispServer.py

@@ -31,6 +31,7 @@ from comtypes.gen import TestDispServerLib
 
 ################################################################
 
+
 # Implement the CoClass by defining a subclass of the
 # TestDispServerLib.TestDispServer class in the wrapper file.  The
 # COMObject base class provides default implementations of the
@@ -42,7 +43,6 @@ class TestDispServer(
     TestDispServerLib.TestDispServer,  # the coclass from the typelib wrapper
     comtypes.server.connectionpoints.ConnectableObjectMixin,
 ):
-
     # The default interface from the typelib MUST be the first
     # interface, other interfaces can follow
 

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/test/__init__.py

@@ -1,6 +1,5 @@
 # comtypes.test package.
 
-from __future__ import print_function
 import ctypes
 import getopt
 import os
@@ -65,7 +64,7 @@ def requires(resource, msg=None):
         return
     if not is_resource_enabled(resource):
         if msg is None:
-            msg = "Use of the `%s' resource not enabled" % resource
+            msg = f"Use of the `{resource}` resource not enabled"
         raise ResourceDenied(msg)
 
 
@@ -95,12 +94,10 @@ def get_tests(package, mask, verbosity):
         except ResourceDenied as detail:
             skipped.append(modname)
             if verbosity > 1:
-                print("Skipped %s: %s" % (modname, detail), file=sys.stderr)
+                print(f"Skipped {modname}: {detail}", file=sys.stderr)
             continue
         except Exception as detail:
-            print(
-                "Warning: could not import %s: %s" % (modname, detail), file=sys.stderr
-            )
+            print(f"Warning: could not import {modname}: {detail}", file=sys.stderr)
             continue
         for name in dir(mod):
             if name.startswith("_"):
@@ -150,9 +147,9 @@ def test_with_refcounts(runner, verbosity, testcase):
         cleanup()
         refcounts[i] = sys.gettotalrefcount() - rc
     if [_f for _f in refcounts if _f]:
-        print("%s leaks:\n\t" % testcase, refcounts)
+        print(f"{testcase} leaks:\n\t", refcounts)
     elif verbosity:
-        print("%s: ok." % testcase)
+        print(f"{testcase}: ok.")
 
 
 class TestRunner(unittest.TextTestRunner):
@@ -181,21 +178,21 @@ class TestRunner(unittest.TextTestRunner):
                     len(skipped) != 1 and "s" or "",
                 )
             )
-            self.stream.writeln("Unavailable resources: %s" % ", ".join(requested))
+            self.stream.writeln(f"Unavailable resources: {', '.join(requested)}")
         else:
             self.stream.writeln(
-                "Ran %d test%s in %.3fs" % (run, run != 1 and "s" or "", timeTaken)
+                f"Ran {run} test{'s' if run != 1 else ''} in {timeTaken:.3f}s"
             )
         self.stream.writeln()
         if not result.wasSuccessful():
             self.stream.write("FAILED (")
             failed, errored = list(map(len, (result.failures, result.errors)))
             if failed:
-                self.stream.write("failures=%d" % failed)
+                self.stream.write(f"failures={failed}")
             if errored:
                 if failed:
                     self.stream.write(", ")
-                self.stream.write("errors=%d" % errored)
+                self.stream.write(f"errors={errored}")
             self.stream.writeln(")")
         else:
             self.stream.writeln("OK")