comtypes 1.4.9__zip → 1.4.11__zip

comtypes-1.4.11/comtypes/server/register.py

@@ -0,0 +1,478 @@
+"""comtypes.server.register - register and unregister a COM object.
+
+Exports the UseCommandLine function.  UseCommandLine is called with
+the COM object classes that a module exposes.  It parses the Windows
+command line and takes the appropriate actions.
+These command line options are supported:
+
+/regserver - register the classes with COM.
+/unregserver - unregister the classes with COM.
+
+/nodebug - remove all logging configuration from the registry.
+
+/l <name>=<level> - configure the logging level for the standard Python loggind module,
+this option may be used several times.
+
+/f <formatter> - specify the formatter string.
+
+Note: Registering and unregistering the objects does remove logging
+entries.  Configuring the logging does not change other registry
+entries, so it is possible to freeze a comobject with py2exe, register
+it, then configure logging afterwards to debug it, and delete the
+logging config afterwards.
+
+Sample usage:
+
+Register the COM object:
+
+  python mycomobj.py /regserver
+
+Configure logging info:
+
+  python mycomobj.py /l comtypes=INFO /l comtypes.server=DEBUG /f %(message)s
+
+Now, debug the object, and when done delete logging info:
+
+  python mycomobj.py /nodebug
+"""
+
+import _ctypes
+import abc
+import logging
+import os
+import sys
+import winreg
+from ctypes import WinDLL, WinError
+from ctypes.wintypes import HKEY, LONG, LPCWSTR, MAX_PATH
+from typing import Iterable, Iterator, List, Optional, Tuple, Type, Union
+from winreg import HKEY_CLASSES_ROOT as HKCR
+from winreg import HKEY_CURRENT_USER as HKCU
+from winreg import HKEY_LOCAL_MACHINE as HKLM
+
+import comtypes.server.inprocserver  # noqa
+from comtypes import CLSCTX_INPROC_SERVER, CLSCTX_LOCAL_SERVER
+from comtypes.hresult import TYPE_E_CANTLOADLIBRARY, TYPE_E_REGISTRYACCESS
+from comtypes.server.localserver import run as run_localserver
+from comtypes.server.w_getopt import w_getopt
+from comtypes.typeinfo import (
+    REGKIND_REGISTER,
+    GetModuleFileName,
+    LoadTypeLibEx,
+    UnRegisterTypeLib,
+)
+
+_debug = logging.getLogger(__name__).debug
+
+
+def get_winerror(exception: OSError) -> Optional[int]:
+    try:
+        return exception.winerror
+    except AttributeError:
+        return exception.errno
+
+
+# a SHDeleteKey function, will remove a registry key with all subkeys.
+def _non_zero(retval, func, args):
+    if retval:
+        raise WinError(retval)
+    return retval
+
+
+_shlwapi = WinDLL("shlwapi")
+LSTATUS = LONG
+SHDeleteKey = _shlwapi.SHDeleteKeyW
+SHDeleteKey.errcheck = _non_zero
+SHDeleteKey.argtypes = HKEY, LPCWSTR
+SHDeleteKey.restype = LSTATUS
+
+
+_KEYS = {
+    HKCR: "HKCR",
+    HKLM: "HKLM",
+    HKCU: "HKCU",
+}
+
+
+def _explain(hkey: int) -> Union[str, int]:
+    return _KEYS.get(hkey, hkey)
+
+
+def _delete_key(hkey: int, subkey: str, *, force: bool) -> None:
+    try:
+        if force:
+            _debug("SHDeleteKey %s\\%s", _explain(hkey), subkey)
+            SHDeleteKey(hkey, subkey)
+        else:
+            _debug("DeleteKey %s\\%s", _explain(hkey), subkey)
+            winreg.DeleteKey(hkey, subkey)
+    except WindowsError as detail:
+        if get_winerror(detail) != 2:
+            raise
+
+
+_Entry = Tuple[int, str, str, str]
+
+
+class Registrar(object):
+    """COM class registration.
+
+    The COM class can override what this does by implementing
+    _register and/or _unregister class methods.  These methods will be
+    called with the calling instance of Registrar, and so can call the
+    Registrars _register and _unregister methods which do the actual
+    work.
+    """
+
+    _frozen: Union[None, int, str]
+    _frozendllhandle: Optional[int]
+
+    def __init__(self) -> None:
+        self._frozen = getattr(sys, "frozen", None)
+        self._frozendllhandle = getattr(sys, "frozendllhandle", None)
+
+    def _generate_reg_entries(self, cls: Type) -> Iterable[_Entry]:
+        if self._frozen is None:
+            return InterpRegistryEntries(cls)
+        return FrozenRegistryEntries(cls, self._frozen, self._frozendllhandle)
+
+    def nodebug(self, cls: Type) -> None:
+        """Delete logging entries from the registry."""
+        clsid = cls._reg_clsid_
+        try:
+            _debug('DeleteKey( %s\\CLSID\\%s\\Logging"' % (_explain(HKCR), clsid))
+            hkey = winreg.OpenKey(HKCR, rf"CLSID\{clsid}")
+            winreg.DeleteKey(hkey, "Logging")
+        except WindowsError as detail:
+            if get_winerror(detail) != 2:
+                raise
+
+    def debug(self, cls: Type, levels: List[str], format: Optional[str]) -> None:
+        """Write entries in the registry to setup logging for this clsid."""
+        # handlers
+        # format
+        clsid = cls._reg_clsid_
+        _debug('CreateKey( %s\\CLSID\\%s\\Logging"' % (_explain(HKCR), clsid))
+        hkey = winreg.CreateKey(HKCR, rf"CLSID\{clsid}\Logging")
+        for item in levels:
+            name, value = item.split("=")
+            v = getattr(logging, value)
+            assert isinstance(v, int)
+        _debug("SetValueEx(levels, %s)" % levels)
+        winreg.SetValueEx(hkey, "levels", None, winreg.REG_MULTI_SZ, levels)
+        if format:
+            _debug("SetValueEx(format, %s)" % format)
+            winreg.SetValueEx(hkey, "format", None, winreg.REG_SZ, format)
+        else:
+            _debug("DeleteValue(format)")
+            try:
+                winreg.DeleteValue(hkey, "format")
+            except WindowsError as detail:
+                if get_winerror(detail) != 2:
+                    raise
+
+    def register(self, cls: Type, executable: Optional[str] = None) -> None:
+        """Register the COM server class."""
+        # First, we unregister the object with force=True, to force removal
+        # of all registry entries, even if we would not write them.
+        # Second, we create new entries.
+        # It seems ATL does the same.
+        mth = getattr(cls, "_register", None)
+        if mth is not None:
+            mth(self)
+        else:
+            self._unregister(cls, force=True)
+            self._register(cls, executable)
+
+    def _register(self, cls: Type, executable: Optional[str] = None) -> None:
+        table = sorted(self._generate_reg_entries(cls))
+        _debug("Registering %s", cls)
+        for hkey, subkey, valuename, value in table:
+            _debug("[%s\\%s]", _explain(hkey), subkey)
+            _debug('%s="%s"', valuename or "@", value)
+            k = winreg.CreateKey(hkey, subkey)
+            winreg.SetValueEx(k, valuename, None, winreg.REG_SZ, str(value))
+
+        tlib = getattr(cls, "_reg_typelib_", None)
+        if tlib is not None:
+            if self._frozendllhandle is not None:
+                frozen_dll = _get_serverdll(self._frozendllhandle)
+                _debug("LoadTypeLibEx(%s, REGKIND_REGISTER)", frozen_dll)
+                LoadTypeLibEx(frozen_dll, REGKIND_REGISTER)
+            else:
+                if executable:
+                    path = executable
+                elif self._frozen is not None:
+                    path = sys.executable
+                else:
+                    path = cls._typelib_path_
+                _debug("LoadTypeLibEx(%s, REGKIND_REGISTER)", path)
+                LoadTypeLibEx(path, REGKIND_REGISTER)
+        _debug("Done")
+
+    def unregister(self, cls: Type, force: bool = False) -> None:
+        """Unregister the COM server class."""
+        mth = getattr(cls, "_unregister", None)
+        if mth is not None:
+            mth(self)
+        else:
+            self._unregister(cls, force=force)
+
+    def _unregister(self, cls: Type, force: bool = False) -> None:
+        # 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._generate_reg_entries(cls)]
+        # reversed and only unique entries
+        table = reversed(sorted(list(set(table))))
+        _debug("Unregister %s", cls)
+        for hkey, subkey in table:
+            _delete_key(hkey, subkey, force=force)
+        tlib = getattr(cls, "_reg_typelib_", None)
+        if tlib is not None:
+            try:
+                _debug("UnRegisterTypeLib(%s, %s, %s)", *tlib)
+                UnRegisterTypeLib(*tlib)
+            except WindowsError as detail:
+                if not get_winerror(detail) in (
+                    TYPE_E_REGISTRYACCESS,
+                    TYPE_E_CANTLOADLIBRARY,
+                ):
+                    raise
+        _debug("Done")
+
+
+def _get_serverdll(handle: int) -> str:
+    """Return the pathname of the dll hosting the COM object."""
+    return GetModuleFileName(handle, MAX_PATH)
+
+
+class RegistryEntries(abc.ABC):
+    """Iterator of tuples containing registry entries.
+
+    The tuples must be (key, subkey, name, value).
+
+    Required entries:
+    =================
+    _reg_clsid_ - a string or GUID instance
+    _reg_clsctx_ - server type(s) to register
+
+    Optional entries:
+    =================
+    _reg_desc_ - a string
+    _reg_progid_ - a string naming the progid, typically 'MyServer.MyObject.1'
+    _reg_novers_progid_ - version independend progid, typically 'MyServer.MyObject'
+    _reg_typelib_ - an tuple (libid, majorversion, minorversion) specifying a typelib.
+    _reg_threading_ - a string specifying the threading model
+
+    Note that the first part of the progid string is typically the
+    IDL library name of the type library containing the coclass.
+    """
+
+    @abc.abstractmethod
+    def __iter__(self) -> Iterator[_Entry]: ...
+
+
+class FrozenRegistryEntries(RegistryEntries):
+    def __init__(
+        self,
+        cls: Type,
+        frozen: Union[str, int],
+        frozendllhandle: Optional[int] = None,
+    ) -> None:
+        self._cls = cls
+        self._frozen = frozen
+        self._frozendllhandle = frozendllhandle
+
+    def __iter__(self) -> Iterator[_Entry]:
+        # that's the only required attribute for registration
+        reg_clsid = str(self._cls._reg_clsid_)
+        yield from _iter_reg_entries(self._cls, reg_clsid)
+        clsctx: int = getattr(self._cls, "_reg_clsctx_", 0)
+        localsvr_ctx = bool(clsctx & CLSCTX_LOCAL_SERVER)
+        inprocsvr_ctx = bool(clsctx & CLSCTX_INPROC_SERVER)
+        if localsvr_ctx and self._frozendllhandle is None:
+            yield from _iter_frozen_local_ctx_entries(self._cls, reg_clsid)
+        if inprocsvr_ctx and self._frozen == "dll":
+            assert self._frozendllhandle is not None
+            frozen_dll = _get_serverdll(self._frozendllhandle)
+            yield from _iter_inproc_ctx_entries(reg_clsid, frozen_dll)
+            yield from _iter_inproc_threading_model_entries(self._cls, reg_clsid)
+        yield from _iter_tlib_entries(self._cls, reg_clsid)
+
+
+class InterpRegistryEntries(RegistryEntries):
+    def __init__(self, cls: Type) -> None:
+        self._cls = cls
+
+    def __iter__(self) -> Iterator[_Entry]:
+        # that's the only required attribute for registration
+        reg_clsid = str(self._cls._reg_clsid_)
+        yield from _iter_reg_entries(self._cls, reg_clsid)
+        clsctx: int = getattr(self._cls, "_reg_clsctx_", 0)
+        localsvr_ctx = bool(clsctx & CLSCTX_LOCAL_SERVER)
+        inprocsvr_ctx = bool(clsctx & CLSCTX_INPROC_SERVER)
+        if localsvr_ctx:
+            yield from _iter_interp_local_ctx_entries(self._cls, reg_clsid)
+        if inprocsvr_ctx:
+            yield from _iter_inproc_ctx_entries(reg_clsid, _ctypes.__file__)
+            # only for non-frozen inproc servers the PythonPath/PythonClass is needed.
+            yield from _iter_inproc_python_entries(self._cls, reg_clsid)
+            yield from _iter_inproc_threading_model_entries(self._cls, reg_clsid)
+        yield from _iter_tlib_entries(self._cls, reg_clsid)
+
+
+def _get_full_classname(cls: Type) -> str:
+    """Return <modulename>.<classname> for 'cls'."""
+    modname = cls.__module__
+    if modname == "__main__":
+        modname = os.path.splitext(os.path.basename(sys.argv[0]))[0]
+    return f"{modname}.{cls.__name__}"
+
+
+def _get_pythonpath(cls: Type) -> str:
+    """Return the filesystem path of the module containing 'cls'."""
+    modname = cls.__module__
+    dirname = os.path.dirname(sys.modules[modname].__file__)  # type: ignore
+    return os.path.abspath(dirname)
+
+
+def _iter_reg_entries(cls: Type, reg_clsid: str) -> Iterator[_Entry]:
+    # basic entry - names the comobject
+    reg_desc = getattr(cls, "_reg_desc_", "")
+    if not reg_desc:
+        # Simple minded algorithm to construct a description from the progid:
+        reg_desc = getattr(cls, "_reg_novers_progid_", getattr(cls, "_reg_progid_", ""))
+        if reg_desc:
+            reg_desc = reg_desc.replace(".", " ")
+    yield (HKCR, rf"CLSID\{reg_clsid}", "", reg_desc)
+
+    reg_progid = getattr(cls, "_reg_progid_", None)
+    if reg_progid:
+        # for ProgIDFromCLSID:
+        yield (HKCR, rf"CLSID\{reg_clsid}\ProgID", "", reg_progid)  # 1
+
+        # for CLSIDFromProgID
+        if reg_desc:
+            yield (HKCR, reg_progid, "", reg_desc)  # 2
+        yield (HKCR, rf"{reg_progid}\CLSID", "", reg_clsid)  # 3
+
+        reg_novers_progid = getattr(cls, "_reg_novers_progid_", None)
+        if reg_novers_progid:
+            yield (
+                HKCR,
+                rf"CLSID\{reg_clsid}\VersionIndependentProgID",  # 1a
+                "",
+                reg_novers_progid,
+            )
+            if reg_desc:
+                yield (HKCR, reg_novers_progid, "", reg_desc)  # 2a
+            yield (HKCR, rf"{reg_novers_progid}\CurVer", "", reg_progid)  #
+            yield (HKCR, rf"{reg_novers_progid}\CLSID", "", reg_clsid)  # 3a
+
+
+def _iter_interp_local_ctx_entries(cls: Type, reg_clsid: str) -> Iterator[_Entry]:
+    exe = sys.executable
+    exe = f'"{exe}"' if " " in exe else exe
+    exe = f"{exe} -O" if not __debug__ else exe
+    script = os.path.abspath(sys.modules[cls.__module__].__file__)  # type: ignore
+    script = f'"{script}"' if " " in script else script
+    yield (HKCR, rf"CLSID\{reg_clsid}\LocalServer32", "", f"{exe} {script}")
+
+
+def _iter_frozen_local_ctx_entries(cls: Type, reg_clsid: str) -> Iterator[_Entry]:
+    exe = sys.executable
+    exe = f'"{exe}"' if " " in exe else exe
+    yield (HKCR, rf"CLSID\{reg_clsid}\LocalServer32", "", f"{exe}")
+
+
+def _iter_inproc_ctx_entries(reg_clsid: str, dllfile: str) -> Iterator[_Entry]:
+    # Register InprocServer32 only when run from script or from
+    # py2exe dll server, not from py2exe exe server.
+    yield (HKCR, rf"CLSID\{reg_clsid}\InprocServer32", "", dllfile)
+
+
+def _iter_inproc_python_entries(cls: Type, reg_clsid: str) -> Iterator[_Entry]:
+    # only for non-frozen inproc servers the PythonPath/PythonClass is needed.
+    yield (
+        HKCR,
+        rf"CLSID\{reg_clsid}\InprocServer32",
+        "PythonClass",
+        _get_full_classname(cls),
+    )
+    yield (
+        HKCR,
+        rf"CLSID\{reg_clsid}\InprocServer32",
+        "PythonPath",
+        _get_pythonpath(cls),
+    )
+
+
+def _iter_inproc_threading_model_entries(cls: Type, reg_clsid: str) -> Iterator[_Entry]:
+    reg_threading = getattr(cls, "_reg_threading_", None)
+    if reg_threading is not None:
+        yield (
+            HKCR,
+            rf"CLSID\{reg_clsid}\InprocServer32",
+            "ThreadingModel",
+            reg_threading,
+        )
+
+
+def _iter_tlib_entries(cls: Type, reg_clsid: str) -> Iterator[_Entry]:
+    reg_tlib = getattr(cls, "_reg_typelib_", None)
+    if reg_tlib is not None:
+        yield (HKCR, rf"CLSID\{reg_clsid}\Typelib", "", reg_tlib[0])
+
+
+################################################################
+
+
+def register(cls: Type) -> None:
+    Registrar().register(cls)
+
+
+def unregister(cls: Type) -> None:
+    Registrar().unregister(cls)
+
+
+def UseCommandLine(*classes: Type) -> int:
+    usage = f"""Usage: {sys.argv[0]} [-regserver] [-unregserver] [-nodebug] [-f logformat] [-l loggername=level]"""
+    opts, args = w_getopt(sys.argv[1:], "regserver unregserver embedding l: f: nodebug")
+    if not opts:
+        sys.stderr.write(usage + "\n")
+        return 0  # nothing for us to do
+
+    levels = []
+    format = None
+    nodebug = False
+    runit = False
+    for option, value in opts:
+        if option == "regserver":
+            for cls in classes:
+                register(cls)
+        elif option == "unregserver":
+            for cls in classes:
+                unregister(cls)
+        elif option == "embedding":
+            runit = True
+        elif option == "f":
+            format = value
+        elif option == "l":
+            levels.append(value)
+        elif option == "nodebug":
+            nodebug = True
+
+    if levels or format is not None:
+        for cls in classes:
+            Registrar().debug(cls, levels, format)
+    if nodebug:
+        for cls in classes:
+            Registrar().nodebug(cls)
+
+    if runit:
+        run_localserver(classes)
+
+    return 1  # we have done something
+
+
+if __name__ == "__main__":
+    UseCommandLine()

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

@@ -1,11 +1,17 @@
-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, Literal
-
-from comtypes import IUnknown, GUID, COMMETHOD, HRESULT, CoClass
+from ctypes import (
+    POINTER,
+    byref,
+    c_char_p,
+    c_int,
+    c_short,
+    c_wchar_p,
+    create_string_buffer,
+    create_unicode_buffer,
+)
+from ctypes.wintypes import DWORD, MAX_PATH, WIN32_FIND_DATAA, WIN32_FIND_DATAW
+from typing import TYPE_CHECKING, Literal, Tuple
 
+from comtypes import COMMETHOD, GUID, HRESULT, CoClass, IUnknown
 
 if TYPE_CHECKING:
     from comtypes import hints  # type: ignore

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/stream.py

@@ -1,8 +1,11 @@
-from ctypes import Array, c_ubyte, c_ulong, HRESULT, POINTER, pointer
-from typing import Tuple, TYPE_CHECKING
+from ctypes import HRESULT, POINTER, c_ubyte, c_ulong, pointer
+from typing import TYPE_CHECKING, Tuple
 
 from comtypes import COMMETHOD, GUID, IUnknown
 
+if TYPE_CHECKING:
+    from ctypes import Array as _CArrayType
+
 
 class ISequentialStream(IUnknown):
     """Defines methods for the stream objects in sequence."""
@@ -38,7 +41,7 @@ class ISequentialStream(IUnknown):
         ),
     ]
 
-    def RemoteRead(self, cb: int) -> Tuple["Array[c_ubyte]", int]:
+    def RemoteRead(self, cb: int) -> Tuple["_CArrayType[c_ubyte]", int]:
         """Reads a specified number of bytes from the stream object into memory
         starting at the current seek pointer.
         """
@@ -51,7 +54,7 @@ class ISequentialStream(IUnknown):
 
     if TYPE_CHECKING:
 
-        def RemoteWrite(self, pv: "Array[c_ubyte]", cb: int) -> int:
+        def RemoteWrite(self, pv: "_CArrayType[c_ubyte]", cb: int) -> int:
             """Writes a specified number of bytes into the stream object starting at
             the current seek pointer.
             """

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

@@ -1,5 +1,6 @@
-import sys, os
 import logging
+import os
+import sys
 
 logging.basicConfig()
 ##logging.basicConfig(level=logging.DEBUG)
@@ -7,14 +8,14 @@ logging.basicConfig()
 
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), r"..\..")))
 
-import ctypes
 import comtypes
-from comtypes.hresult import *
 import comtypes.client
+import comtypes.connectionpoints
 import comtypes.errorinfo
 import comtypes.server
 import comtypes.server.connectionpoints
 import comtypes.typeinfo
+from comtypes.hresult import S_OK
 
 ################################################################
 
@@ -30,6 +31,7 @@ if not hasattr(sys, "frozen"):
 
 # Import the wrapper
 from comtypes.gen import TestComServerLib
+from comtypes.gen.TestComServerLib import ITestComServer  # noqa
 
 ################################################################
 
@@ -151,7 +153,4 @@ if __name__ == "__main__":
         import traceback
 
         traceback.print_exc()
-        if sys.version_info >= (3, 0):
-            input()
-        else:
-            raw_input()
+        input()

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

@@ -1,5 +1,6 @@
-import sys, os
 import logging
+import os
+import sys
 
 logging.basicConfig()
 ##logging.basicConfig(level=logging.DEBUG)
@@ -9,8 +10,9 @@ logging.basicConfig()
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), r"..\..")))
 
 import comtypes
-from comtypes.hresult import S_OK
+import comtypes.connectionpoints
 import comtypes.server.connectionpoints
+from comtypes.hresult import S_OK
 
 ################################################################
 

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

@@ -119,8 +119,8 @@ def usage():
 
 def test_with_refcounts(runner, verbosity, testcase):
     """Run testcase several times, tracking reference counts."""
-    import gc
     import ctypes
+    import gc
 
     ptc = ctypes._pointer_type_cache.copy()
     cfc = ctypes._c_functype_cache.copy()

comtypes-1.4.11/comtypes/test/find_memleak.py

@@ -0,0 +1,72 @@
+import gc
+from ctypes import POINTER, Structure, WinDLL, WinError, byref, c_size_t, sizeof
+from ctypes.wintypes import BOOL, DWORD, HANDLE
+
+################################################################
+
+
+class PROCESS_MEMORY_COUNTERS(Structure):
+    _fields_ = [
+        ("cb", DWORD),
+        ("PageFaultCount", DWORD),
+        ("PeakWorkingSetSize", c_size_t),
+        ("WorkingSetSize", c_size_t),
+        ("QuotaPeakPagedPoolUsage", c_size_t),
+        ("QuotaPagedPoolUsage", c_size_t),
+        ("QuotaPeakNonPagedPoolUsage", c_size_t),
+        ("QuotaNonPagedPoolUsage", c_size_t),
+        ("PagefileUsage", c_size_t),
+        ("PeakPagefileUsage", c_size_t),
+    ]
+
+    def __init__(self):
+        self.cb = sizeof(self)
+
+    def dump(self):
+        for n, _ in self._fields_[2:]:
+            print(n, getattr(self, n) / 1e6)
+
+
+_psapi = WinDLL("psapi")
+
+_GetProcessMemoryInfo = _psapi.GetProcessMemoryInfo
+_GetProcessMemoryInfo.argtypes = [HANDLE, POINTER(PROCESS_MEMORY_COUNTERS), DWORD]
+_GetProcessMemoryInfo.restype = BOOL
+
+
+def wss():
+    # Return the working set size (memory used by process)
+    pmi = PROCESS_MEMORY_COUNTERS()
+    if not _GetProcessMemoryInfo(-1, byref(pmi), sizeof(pmi)):
+        raise WinError()
+    return pmi.WorkingSetSize
+
+
+LOOPS = 10, 1000
+
+
+def find_memleak(func, loops=LOOPS):
+    # call 'func' several times, so that memory consumption
+    # stabilizes:
+    for j in range(loops[0]):
+        for k in range(loops[1]):
+            func()
+    gc.collect()
+    gc.collect()
+    gc.collect()
+    bytes = wss()
+    # call 'func' several times, recording the difference in
+    # memory consumption before and after the call.  Repeat this a
+    # few times, and return a list containing the memory
+    # consumption differences.
+    for j in range(loops[0]):
+        for k in range(loops[1]):
+            func()
+    gc.collect()
+    gc.collect()
+    gc.collect()
+    # return the increased in process size
+    result = wss() - bytes
+    # Sometimes the process size did decrease, we do not report leaks
+    # in this case:
+    return max(result, 0)

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/test/runtests.py

@@ -1,4 +1,5 @@
 import sys
+
 import comtypes.test
 
 

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/test/setup.py

@@ -1,6 +1,7 @@
 # all the unittests can be converted to exe-files.
-from distutils.core import setup
 import glob
+from distutils.core import setup
+
 import py2exe
 
 setup(name="test_*", console=glob.glob("test_*.py"))