comtypes 1.4.9__zip → 1.4.10__zip

{comtypes-1.4.9 → comtypes-1.4.10}/CHANGES.txt

@@ -1,6 +1,25 @@
 Comtypes CHANGELOG
 ==================
 
+Release 1.4.10
+--------------
+* Replace ``GetModuleFileNameA`` with ``GetModuleFileNameW`` to prevent a ``TypeError``. By @junkmd.
+* Refactor ``server.register``. By @junkmd.
+* ``PythonClass`` and ``PythonPath`` are no longer registered in the registry for a frozen server. By @junkmd.
+* Use ``WinDLL``/``OleDLL`` instead of ``windll``/``oledll``. By @moi15moi.
+* In ``tools.tlbparser``, replace ``windll.oleaut32.QueryPathOfRegTypeLib`` with ``typeinfo.QueryPathOfRegTypeLib``. By @moi15moi.
+* Adjust ``QueryPathOfRegTypeLib`` docstring. By @moi15moi.
+* Reserve blank lines in the generated modules. By @junkmd.
+* Refactor ``tools`` subpackage. By @junkmd.
+* Add ``ActiveObjTest`` to ``test_comserver``. By @junkmd.
+* Replace deprecated install command in CI pipelines. By @moi15moi.
+* Remove unused parameters in ``_shutdown``. By @moi15moi.
+* Delete ``preview.bat``. By @moi15moi.
+* Remove unnecessary ``ruff`` lint rules from ``pyproject.toml``. By @moi15moi.
+* Refactor some code from ``client/__init__.py`` into modules. By @junkmd.
+* Remove workarounds for Windows CE in ``find_memleak``. By @junkmd.
+* Format import blocks and add ``extend-select = ["I"]`` to ``[tool.ruff.lint]``. By @junkmd.
+
 Release 1.4.9
 --------------
 * Separate patch processing within ``_com_interface_meta`` into a module. By @junkmd.

{comtypes-1.4.9/comtypes.egg-info → comtypes-1.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: comtypes
-Version: 1.4.9
+Version: 1.4.10
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases
@@ -16,6 +16,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Dynamic: download-url
 
 # comtypes
 

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

@@ -1,9 +1,8 @@
 """comtypes.GUID module"""
 
-from ctypes import oledll, windll
-from ctypes import byref, c_wchar_p, Structure
-from ctypes.wintypes import BYTE, WORD, DWORD
-from typing import Any, TYPE_CHECKING
+from ctypes import HRESULT, POINTER, OleDLL, Structure, WinDLL, byref, c_wchar_p
+from ctypes.wintypes import BYTE, DWORD, LPVOID, WORD
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from comtypes import hints  # type: ignore
@@ -13,15 +12,6 @@ def binary(obj: "GUID") -> bytes:
     return bytes(obj)
 
 
-_ole32 = oledll.ole32
-
-_StringFromCLSID = _ole32.StringFromCLSID
-_CoTaskMemFree = windll.ole32.CoTaskMemFree
-_ProgIDFromCLSID = _ole32.ProgIDFromCLSID
-_CLSIDFromString = _ole32.CLSIDFromString
-_CLSIDFromProgID = _ole32.CLSIDFromProgID
-_CoCreateGuid = _ole32.CoCreateGuid
-
 # Note: Comparing GUID instances by comparing their buffers
 # is slightly faster than using ole32.IsEqualGUID.
 
@@ -93,6 +83,37 @@ class GUID(Structure):
         return guid
 
 
+REFCLSID = POINTER(GUID)
+LPOLESTR = LPCOLESTR = c_wchar_p
+LPCLSID = POINTER(GUID)
+
+_ole32_nohresult = WinDLL("ole32")
+_ole32 = OleDLL("ole32")
+
+_StringFromCLSID = _ole32.StringFromCLSID
+_StringFromCLSID.argtypes = [REFCLSID, POINTER(LPOLESTR)]
+_StringFromCLSID.restype = HRESULT
+
+_CoTaskMemFree = _ole32_nohresult.CoTaskMemFree
+_CoTaskMemFree.argtypes = [LPVOID]
+_CoTaskMemFree.restype = None
+
+_ProgIDFromCLSID = _ole32.ProgIDFromCLSID
+_ProgIDFromCLSID.argtypes = [REFCLSID, POINTER(LPOLESTR)]
+_ProgIDFromCLSID.restype = HRESULT
+
+_CLSIDFromString = _ole32.CLSIDFromString
+_CLSIDFromString.argtypes = [LPCOLESTR, LPCLSID]
+_CLSIDFromString.restype = HRESULT
+
+_CLSIDFromProgID = _ole32.CLSIDFromProgID
+_CLSIDFromProgID.argtypes = [LPCOLESTR, LPCLSID]
+_CLSIDFromProgID.restype = HRESULT
+
+_CoCreateGuid = _ole32.CoCreateGuid
+_CoCreateGuid.argtypes = [POINTER(GUID)]
+_CoCreateGuid.restype = HRESULT
+
 GUID_null = GUID()
 
 __all__ = ["GUID"]

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

@@ -1,5 +1,5 @@
 # comtypes version numbers follow semver (http://semver.org/) and PEP 440
-__version__ = "1.4.9"
+__version__ = "1.4.10"
 
 try:
     from _ctypes import COMError  # noqa
@@ -15,31 +15,30 @@ except ImportError as e:
     raise ImportError(msg) from e
 
 import atexit
+import logging
+import sys
 
 # HACK: Workaround for projects that depend on this package
 # There should be several projects around the world that depend on this package
 # and indirectly reference the symbols of `ctypes` from `comtypes`.
 # If we remove the wildcard import from `ctypes`, they might break. So it is
 # left in the following line.
-from ctypes import *  # noqa
-from ctypes import HRESULT  # noqa
-from ctypes import _Pointer, _SimpleCData  # noqa
-from ctypes import c_int, c_ulong, oledll, windll
-from ctypes.wintypes import DWORD  # noqa
-import logging
-import sys
+from ctypes import *  # noqa  # type: ignore
+from ctypes import HRESULT, OleDLL, WinDLL, _SimpleCData, c_int, c_ulong
+from ctypes.wintypes import DWORD, LPVOID
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ctypes import _CData  # only in `typeshed`, private in runtime
+
     from comtypes import hints as hints  # noqa  # type: ignore
 else:
     _CData = _SimpleCData.__mro__[:-1][-1]
 
-from comtypes.GUID import GUID
 from comtypes import patcher  # noqa
 from comtypes._npsupport import interop as npsupport  # noqa
 from comtypes._tlib_version_checker import _check_version  # noqa
+from comtypes.GUID import GUID
 
 _all_slice = slice(None, None, None)
 
@@ -121,8 +120,18 @@ EOAC_NONE = 0
 
 ################################################################
 # Initialization and shutdown
-_ole32 = oledll.ole32
-_ole32_nohresult = windll.ole32  # use this for functions that don't return a HRESULT
+_ole32 = OleDLL("ole32")
+
+_CoInitializeEx = _ole32.CoInitializeEx
+_CoInitializeEx.argtypes = [LPVOID, DWORD]
+_CoInitializeEx.restype = HRESULT
+
+_ole32_nohresult = WinDLL("ole32")  # use this for functions that don't return a HRESULT
+
+_CoUninitialize = _ole32_nohresult.CoUninitialize
+_CoUninitialize.argtypes = []
+_CoUninitialize.restype = None
+
 
 COINIT_MULTITHREADED = 0x0
 COINIT_APARTMENTTHREADED = 0x2
@@ -138,7 +147,7 @@ def CoInitializeEx(flags=None):
     if flags is None:
         flags = getattr(sys, "coinit_flags", COINIT_APARTMENTTHREADED)
     logger.debug("CoInitializeEx(None, %s)", flags)
-    _ole32.CoInitializeEx(None, flags)
+    _CoInitializeEx(None, flags)
 
 
 # COM is initialized automatically for the thread that imports this
@@ -156,7 +165,7 @@ CoInitializeEx()
 # in which we are using COM
 def CoUninitialize():
     logger.debug("CoUninitialize()")
-    _ole32_nohresult.CoUninitialize()
+    _CoUninitialize()
 
 
 ################################################################

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

@@ -4,14 +4,16 @@ from _ctypes import COMError, CopyComPointer
 from ctypes import (
     POINTER,
     FormatError,
+    OleDLL,
     Structure,
+    WinDLL,
     byref,
     c_long,
     c_void_p,
-    oledll,
+    c_wchar_p,
     pointer,
-    windll,
 )
+from ctypes.wintypes import INT, LONG, LPVOID, UINT, ULONG, WORD
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -27,8 +29,9 @@ from typing import (
 )
 from typing import Union as _UnionT
 
-from comtypes import GUID, IPersist, IUnknown, hresult
+from comtypes import GUID, IPersist, IUnknown, _CoUninitialize, hresult
 from comtypes._vtbl import _MethodFinder, create_dispimpl, create_vtbl_mapping
+from comtypes.automation import DISPID, DISPPARAMS, EXCEPINFO, VARIANT
 from comtypes.errorinfo import ISupportErrorInfo
 from comtypes.typeinfo import IProvideClassInfo, IProvideClassInfo2, ITypeInfo
 
@@ -51,9 +54,10 @@ DISPATCH_PROPERTYPUTREF = 8
 
 ################################################################
 
+_kernel32 = WinDLL("kernel32")
 try:
-    _InterlockedIncrement = windll.kernel32.InterlockedIncrement
-    _InterlockedDecrement = windll.kernel32.InterlockedDecrement
+    _InterlockedIncrement = _kernel32.InterlockedIncrement
+    _InterlockedDecrement = _kernel32.InterlockedDecrement
 except AttributeError:
     import threading
 
@@ -82,14 +86,65 @@ else:
     _InterlockedIncrement.restype = c_long
     _InterlockedDecrement.restype = c_long
 
+_oleaut32 = WinDLL("oleaut32")
+
+_DispGetIDsOfNames = _oleaut32.DispGetIDsOfNames
+_DispGetIDsOfNames.argtypes = [
+    POINTER(ITypeInfo),
+    POINTER(c_wchar_p),
+    UINT,
+    POINTER(DISPID),
+]
+_DispGetIDsOfNames.restype = (
+    LONG  # technically, it is a HRESULT, but we want to avoid the OSError
+)
+
+_DispInvoke = _oleaut32.DispInvoke
+_DispInvoke.argtypes = [
+    LPVOID,
+    POINTER(ITypeInfo),
+    DISPID,
+    WORD,
+    POINTER(DISPPARAMS),
+    POINTER(VARIANT),
+    POINTER(EXCEPINFO),
+    POINTER(UINT),
+]
+_DispInvoke.restype = (
+    LONG  # technically, it is a HRESULT, but we want to avoid the OSError
+)
+
+
+_ole32_nohresult = WinDLL("ole32")
+_ole32 = OleDLL("ole32")
+
+_CoInitialize = _ole32_nohresult.CoInitialize
+_CoInitialize.argtypes = [LPVOID]
+_CoInitialize.restype = (
+    LONG  # technically, it is a HRESULT, but we want to avoid the OSError
+)
+
+_CoAddRefServerProcess = _ole32.CoAddRefServerProcess
+_CoAddRefServerProcess.argtypes = []
+_CoAddRefServerProcess.restype = ULONG
+
+_CoReleaseServerProcess = _ole32.CoReleaseServerProcess
+_CoReleaseServerProcess.argtypes = []
+_CoReleaseServerProcess.restype = ULONG
+
+
+_user32 = WinDLL("user32")
+
+_PostQuitMessage = _user32.PostQuitMessage
+_PostQuitMessage.argtypes = [INT]
+_PostQuitMessage.restype = None
+
 
 class LocalServer(object):
     _queue: Optional[queue.Queue] = None
 
     def run(self, classobjects: Sequence["hints.localserver.ClassFactory"]) -> None:
-        # Use windll instead of oledll so that we don't get an
-        # exception on a FAILED hresult:
-        hr = windll.ole32.CoInitialize(None)
+        hr = _CoInitialize(None)
         if hresult.RPC_E_CHANGED_MODE == hr:
             # we're running in MTA: no message pump needed
             _debug("Server running in MTA")
@@ -100,7 +155,7 @@ class LocalServer(object):
             if hr >= 0:
                 # we need a matching CoUninitialize() call for a successful
                 # CoInitialize().
-                windll.ole32.CoUninitialize()
+                _CoUninitialize()
             self.run_sta()
 
         for obj in classobjects:
@@ -116,15 +171,15 @@ class LocalServer(object):
         self._queue.get()
 
     def Lock(self) -> None:
-        oledll.ole32.CoAddRefServerProcess()
+        _CoAddRefServerProcess()
 
     def Unlock(self) -> None:
-        rc = oledll.ole32.CoReleaseServerProcess()
+        rc = _CoReleaseServerProcess()
         if rc == 0:
             if self._queue:
                 self._queue.put(42)
             else:
-                windll.user32.PostQuitMessage(0)
+                _PostQuitMessage(0)
 
 
 class InprocServer(object):
@@ -401,7 +456,7 @@ class COMObject(object):
             tinfo = self.__typeinfo
         except AttributeError:
             return hresult.E_NOTIMPL
-        return windll.oleaut32.DispGetIDsOfNames(tinfo, rgszNames, cNames, rgDispId)
+        return _DispGetIDsOfNames(tinfo, rgszNames, cNames, rgDispId)
 
     def IDispatch_Invoke(
         self,
@@ -432,7 +487,7 @@ class COMObject(object):
             # an error.
             interface = self._com_interfaces_[0]
             ptr = self._com_pointers_[interface._iid_]
-            return windll.oleaut32.DispInvoke(
+            return _DispInvoke(
                 ptr,
                 tinfo,
                 dispIdMember,

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

@@ -1,12 +1,20 @@
 import ctypes
-from typing import Any, Literal, NamedTuple
-from typing import Dict, List, Tuple, Type
-from typing import Optional, Union as _UnionT
-from typing import Callable, Iterator
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Literal,
+    NamedTuple,
+    Optional,
+    Tuple,
+    Type,
+)
+from typing import Union as _UnionT
 
-from comtypes import _CData
 import comtypes
-
+from comtypes import _CData
 
 _PositionalParamFlagType = Tuple[int, Optional[str]]
 _OptionalParamFlagType = Tuple[int, Optional[str], Any]

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

@@ -1,5 +1,6 @@
 # comtypes._meta helper module
 from ctypes import POINTER, c_void_p, cast
+
 import comtypes
 
 ################################################################

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/_post_coinit/_cominterface_meta_patcher.py

@@ -4,7 +4,6 @@ from typing import Type
 
 from comtypes import patcher
 
-
 _all_slice = slice(None, None, None)
 
 

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/_post_coinit/bstr.py

@@ -1,10 +1,15 @@
-from ctypes import _SimpleCData, windll
-from typing import Any, Callable, TYPE_CHECKING
+from ctypes import WinDLL, _SimpleCData
+from typing import TYPE_CHECKING, Any, Callable
 
 if TYPE_CHECKING:
     from comtypes import hints  # type: ignore
 
 
+_oleaut32 = WinDLL("oleaut32")
+
+_SysFreeString = _oleaut32.SysFreeString
+
+
 class BSTR(_SimpleCData):
     """The windows BSTR data type"""
 
@@ -18,9 +23,7 @@ class BSTR(_SimpleCData):
         self._needsfree = True
         return self.value
 
-    def __del__(
-        self, _free: Callable[["BSTR"], Any] = windll.oleaut32.SysFreeString
-    ) -> None:
+    def __del__(self, _free: Callable[["BSTR"], Any] = _SysFreeString) -> None:
         # Free the string if self owns the memory
         # or if instructed by __ctypes_from_outparam__.
         if self._b_base_ is None or self._needsfree:
@@ -35,3 +38,7 @@ class BSTR(_SimpleCData):
         # right thing, it doesn't ensure that SysFreeString is called
         # on destruction.
         return cls(value)
+
+
+_SysFreeString.argtypes = [BSTR]
+_SysFreeString.restype = None

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/_post_coinit/instancemethod.py

@@ -1,5 +1,4 @@
-from ctypes import pythonapi, py_object
-
+from ctypes import py_object, pythonapi
 
 pythonapi.PyInstanceMethod_New.argtypes = [py_object]
 pythonapi.PyInstanceMethod_New.restype = py_object

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/_post_coinit/misc.py

@@ -1,26 +1,28 @@
-from ctypes import c_ulong, c_ushort, c_void_p, c_wchar_p, HRESULT, Structure
-from ctypes import byref, cast, _Pointer, POINTER, pointer
-
-# fmt: off
-from typing import (  # noqa
-    Any, overload, TYPE_CHECKING, TypeVar,
-    # instead of `builtins`. see PEP585
-    Type,
-    # instead of `collections.abc`. see PEP585
-    Callable,
-    # instead of `A | B` and `None | A`. see PEP604
-    Optional,
+from ctypes import (
+    HRESULT,
+    POINTER,
+    OleDLL,
+    Structure,
+    byref,
+    c_ulong,
+    c_ushort,
+    c_void_p,
+    c_wchar_p,
+    cast,
+    pointer,
 )
-# fmt: on
-if TYPE_CHECKING:
-    from comtypes import hints as hints  # noqa  # type: ignore
+from ctypes.wintypes import DWORD, LPCWSTR, LPVOID
+from typing import TYPE_CHECKING, Any, Callable, Optional, Type, TypeVar, overload
 
-from comtypes import GUID
-from comtypes import CLSCTX_SERVER, CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER
-from comtypes import _ole32, oledll, DWORD
+from comtypes import CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER, CLSCTX_SERVER, GUID
 from comtypes._memberspec import COMMETHOD
 from comtypes._post_coinit.unknwn import IUnknown
 
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+
+    from comtypes import hints as hints  # noqa  # type: ignore
+
 
 def _is_object(obj):
     """This function determines if the argument is a COM object.  It
@@ -98,7 +100,7 @@ def CoGetObject(displayname: str, interface: Optional[Type[IUnknown]]) -> IUnkno
         interface = IUnknown
     punk = POINTER(interface)()
     # Do we need a way to specify the BIND_OPTS parameter?
-    _ole32.CoGetObject(str(displayname), None, byref(interface._iid_), byref(punk))
+    _CoGetObject(str(displayname), None, byref(interface._iid_), byref(punk))
     return punk  # type: ignore
 
 
@@ -134,7 +136,7 @@ def CoCreateInstance(
         interface = IUnknown
     p = POINTER(interface)()
     iid = interface._iid_
-    _ole32.CoCreateInstance(byref(clsid), punkouter, clsctx, byref(iid), byref(p))
+    _CoCreateInstance(byref(clsid), punkouter, clsctx, byref(iid), byref(p))
     return p  # type: ignore
 
 
@@ -178,7 +180,7 @@ def GetActiveObject(
 ) -> IUnknown:
     """Retrieves a pointer to a running object"""
     p = POINTER(IUnknown)()
-    oledll.oleaut32.GetActiveObject(byref(clsid), None, byref(p))
+    _GetActiveObject(byref(clsid), None, byref(p))
     if interface is not None:
         p = p.QueryInterface(interface)  # type: ignore
     return p  # type: ignore
@@ -236,6 +238,16 @@ class _COSERVERINFO(Structure):
         dwReserved2: int
 
 
+_oleaut32 = OleDLL("oleaut32")
+
+REFCLSID = POINTER(GUID)
+_GetActiveObject = _oleaut32.GetActiveObject
+_GetActiveObject.argtypes = [REFCLSID, LPVOID, POINTER(POINTER(IUnknown))]
+_GetActiveObject.restype = HRESULT
+
+
+_ole32 = OleDLL("ole32")
+
 COSERVERINFO = _COSERVERINFO
 _CoGetClassObject = _ole32.CoGetClassObject
 _CoGetClassObject.argtypes = [
@@ -245,6 +257,28 @@ _CoGetClassObject.argtypes = [
     POINTER(GUID),
     POINTER(c_void_p),
 ]
+_CoGetClassObject.restype = HRESULT
+
+_CoCreateInstance = _ole32.CoCreateInstance
+_CoCreateInstance.argtypes = [
+    REFCLSID,
+    POINTER(IUnknown),
+    DWORD,
+    POINTER(GUID),
+    POINTER(LPVOID),
+]
+_CoCreateInstance.restype = HRESULT
+
+_CoCreateInstanceEx = _ole32.CoCreateInstanceEx
+_CoCreateInstanceEx.argtypes = [
+    REFCLSID,
+    POINTER(IUnknown),
+    DWORD,
+    POINTER(COSERVERINFO),
+    DWORD,
+    POINTER(MULTI_QI),
+]
+_CoCreateInstanceEx.restype = HRESULT
 
 
 class tagBIND_OPTS(Structure):
@@ -258,6 +292,9 @@ class tagBIND_OPTS(Structure):
 
 # XXX Add __init__ which sets cbStruct?
 BIND_OPTS = tagBIND_OPTS
+_CoGetObject = _ole32.CoGetObject
+_CoGetObject.argtypes = [LPCWSTR, POINTER(BIND_OPTS), POINTER(GUID), POINTER(LPVOID)]
+_CoGetObject.restype = HRESULT
 
 
 class tagBIND_OPTS2(Structure):
@@ -360,7 +397,5 @@ def CoCreateInstanceEx(
         interface = IUnknown
     multiqi = MULTI_QI()
     multiqi.pIID = pointer(interface._iid_)  # type: ignore
-    _ole32.CoCreateInstanceEx(
-        byref(clsid), None, clsctx, pServerInfo, 1, byref(multiqi)
-    )
+    _CoCreateInstanceEx(byref(clsid), None, clsctx, pServerInfo, 1, byref(multiqi))
     return cast(multiqi.pItf, POINTER(interface))  # type: ignore

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/_post_coinit/unknwn.py

@@ -1,11 +1,10 @@
 # https://learn.microsoft.com/en-us/windows/win32/api/unknwn/
 
 import logging
-import sys
 from ctypes import HRESULT, POINTER, byref, c_ulong, c_void_p
 from typing import TYPE_CHECKING, ClassVar, List, Optional, Type, TypeVar
 
-from comtypes import GUID, _ole32_nohresult, com_interface_registry
+from comtypes import GUID, _CoUninitialize, com_interface_registry
 from comtypes._memberspec import STDMETHOD, ComMemberGenerator, DispMemberGenerator
 from comtypes._post_coinit import _cominterface_meta_patcher as _meta_patch
 from comtypes._post_coinit.instancemethod import instancemethod
@@ -17,12 +16,9 @@ logger = logging.getLogger(__name__)
 
 
 def _shutdown(
-    func=_ole32_nohresult.CoUninitialize,
+    func=_CoUninitialize,
     _debug=logger.debug,
-    _exc_clear=getattr(sys, "exc_clear", lambda: None),
 ):
-    # Make sure no COM pointers stay in exception frames.
-    _exc_clear()
     # Sometimes, CoUninitialize, running at Python shutdown,
     # raises an exception.  We suppress this when __debug__ is
     # False.

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

@@ -1,9 +1,9 @@
 """SAFEARRAY api functions, data types, and constants."""
 
-from ctypes import c_uint, c_ushort, c_void_p, POINTER, Structure, WinDLL
+from ctypes import POINTER, Structure, WinDLL, c_uint, c_ushort, c_void_p
 from ctypes.wintypes import DWORD, LONG, UINT, USHORT
 
-from comtypes import HRESULT, GUID
+from comtypes import GUID, HRESULT
 
 ################################################################
 # if __debug__:

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

@@ -575,23 +575,29 @@ class tagVARIANT(Structure):
 VARIANT = tagVARIANT
 VARIANTARG = VARIANT
 
+_oleaut32_nohresult = WinDLL("oleaut32")
+
+_SysAllocStringLen = _oleaut32_nohresult.SysAllocStringLen
+_SysAllocStringLen.argtypes = c_wchar_p, c_uint
+_SysAllocStringLen.restype = c_void_p
+
 _oleaut32 = OleDLL("oleaut32")
 
 _VariantChangeType = _oleaut32.VariantChangeType
 _VariantChangeType.argtypes = (POINTER(VARIANT), POINTER(VARIANT), c_ushort, VARTYPE)
+_VariantChangeType.restype = HRESULT
 
 _VariantClear = _oleaut32.VariantClear
 _VariantClear.argtypes = (POINTER(VARIANT),)
-
-_SysAllocStringLen = windll.oleaut32.SysAllocStringLen
-_SysAllocStringLen.argtypes = c_wchar_p, c_uint
-_SysAllocStringLen.restype = c_void_p
+_VariantClear.restype = HRESULT
 
 _VariantCopy = _oleaut32.VariantCopy
 _VariantCopy.argtypes = POINTER(VARIANT), POINTER(VARIANT)
+_VariantCopy.restype = HRESULT
 
 _VariantCopyInd = _oleaut32.VariantCopyInd
 _VariantCopyInd.argtypes = POINTER(VARIANT), POINTER(VARIANT)
+_VariantCopyInd.restype = HRESULT
 
 # some commonly used VARIANT instances
 VARIANT.null = VARIANT(None)