comtypes 1.4.9__zip → 1.4.11__zip

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

@@ -1,6 +1,47 @@
 Comtypes CHANGELOG
 ==================
 
+Release 1.4.11
+--------------
+* Improve ``PARAMFLAG_...`` and ``DISPATCH_...`` constants definitions and imports. By @junkmd.
+* Introduce the ``_CDataType`` alias from typeshed. By @junkmd.
+* Replace ``260`` literals/constant definitions with imports from ``ctypes.wintypes.MAX_PATH``. By @junkmd.
+* Replace ``client._code_cache._get_module_filename`` with ``typeinfo.GetModuleFileName``. By @junkmd.
+* Improve ``client._code_cache.SHGetSpecialFolderPath`` definition. By @junkmd.
+* Add type annotations to many modules. By @junkmd.
+* Add constants to many modules. By @junkmd.
+* Improve import block styles to many modules. By @junkmd.
+* Add ``SupportErrorInfoTest`` to ``test_comserver``. By @junkmd.
+* Add ``test_errorinfo``. By @junkmd.
+* Improve the type safety of ``errorinfo.ReportException``. By @junkmd.
+* Change the method of retrieving the values of each field in ``_...MemberSpec`` from unpacking to dot access. By @junkmd.
+* Split ``server.connectionpoints.ConnectionPointImpl._call_sinks``. By @junkmd.
+* Refactor ``create_vtbl_mapping``, ``create_dispimpl`` and ``_encode_idl``. By @junkmd.
+* Add ``test_hresult``. By @junkmd.
+* Add ``Test_Vtbl`` to ``test_comobject.py``. By @junkmd.
+* Delint ``IUnknown_AddRef`` and ``IUnknown_Release``. By @junkmd.
+* Convert ``assertRaises`` usage to context manager for improved readability. By @junkmd.
+* Remove the unused ``PATH`` variable from ``client/_generate.py``. By @moi15moi.
+
+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.11}/PKG-INFO

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

{comtypes-1.4.9 → comtypes-1.4.11}/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.11}/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.11"
 
 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 typing import TYPE_CHECKING
+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, Dict, Type
 
 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,17 +165,17 @@ CoInitializeEx()
 # in which we are using COM
 def CoUninitialize():
     logger.debug("CoUninitialize()")
-    _ole32_nohresult.CoUninitialize()
+    _CoUninitialize()
 
 
 ################################################################
 # global registries.
 
 # allows to find interface classes by guid strings (iid)
-com_interface_registry = {}
+com_interface_registry: Dict[str, Type["IUnknown"]] = {}
 
 # allows to find coclasses by guid strings (clsid)
-com_coclass_registry = {}
+com_coclass_registry: Dict[str, Type["CoClass"]] = {}
 
 
 ################################################################

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

@@ -4,14 +4,15 @@ from _ctypes import COMError, CopyComPointer
 from ctypes import (
     POINTER,
     FormatError,
-    Structure,
+    OleDLL,
+    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,10 +28,21 @@ from typing import (
 )
 from typing import Union as _UnionT
 
-from comtypes import GUID, IPersist, IUnknown, hresult
+import comtypes
+from comtypes import GUID, IPersist, IUnknown, _CoUninitialize, hresult
+from comtypes._memberspec import DISPATCH_METHOD as DISPATCH_METHOD
+from comtypes._memberspec import DISPATCH_PROPERTYGET as DISPATCH_PROPERTYGET
+from comtypes._memberspec import DISPATCH_PROPERTYPUT as DISPATCH_PROPERTYPUT
+from comtypes._memberspec import DISPATCH_PROPERTYPUTREF as DISPATCH_PROPERTYPUTREF
 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
+from comtypes.typeinfo import (
+    GUIDKIND_DEFAULT_SOURCE_DISP_IID,
+    IProvideClassInfo,
+    IProvideClassInfo2,
+    ITypeInfo,
+)
 
 if TYPE_CHECKING:
     from ctypes import _CArgObject, _Pointer
@@ -43,17 +55,13 @@ _debug = logger.debug
 ################################################################
 # COM object implementation
 
-# so we don't have to import comtypes.automation
-DISPATCH_METHOD = 1
-DISPATCH_PROPERTYGET = 2
-DISPATCH_PROPERTYPUT = 4
-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 +90,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 +159,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 +175,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):
@@ -155,18 +214,18 @@ class COMObject(object):
     _reg_clsid_: ClassVar[GUID]
     _reg_typelib_: ClassVar[Tuple[str, int, int]]
     __typelib: "hints.ITypeLib"
-    _com_pointers_: Dict[GUID, "_Pointer[_Pointer[Structure]]"]
-    _dispimpl_: Dict[Tuple[int, int], Callable[..., Any]]
+    _com_pointers_: Dict[GUID, "hints.LP_LP_Vtbl"]
+    _dispimpl_: Dict[Tuple[comtypes.dispid, int], Callable[..., Any]]
 
-    def __new__(cls, *args, **kw):
+    def __new__(cls, *args: Any, **kw: Any) -> "hints.Self":
         self = super(COMObject, cls).__new__(cls)
         if isinstance(self, c_void_p):
             # We build the VTables only for direct instances of
             # CoClass, not for POINTERs to CoClass.
-            return self
+            return self  # type: ignore
         if hasattr(self, "_com_interfaces_"):
             self.__prepare_comobject()
-        return self
+        return self  # type: ignore
 
     def __prepare_comobject(self) -> None:
         # When a CoClass instance is created, COM pointers to all
@@ -271,10 +330,10 @@ class COMObject(object):
     def IUnknown_AddRef(
         self,
         this: Any,
-        __InterlockedIncrement: Callable[[c_long], int] = _InterlockedIncrement,
+        _increment: Callable[[c_long], int] = _InterlockedIncrement,
         _debug=_debug,
     ) -> int:
-        result = __InterlockedIncrement(self._refcnt)
+        result = _increment(self._refcnt)
         if result == 1:
             self.__keep__(self)
         _debug("%r.AddRef() -> %s", self, result)
@@ -288,14 +347,14 @@ class COMObject(object):
     def IUnknown_Release(
         self,
         this: Any,
-        __InterlockedDecrement: Callable[[c_long], int] = _InterlockedDecrement,
+        _decrement: Callable[[c_long], int] = _InterlockedDecrement,
         _debug=_debug,
     ) -> int:
         # If this is called at COM shutdown, _InterlockedDecrement()
         # must still be available, although module level variables may
         # have been deleted already - so we supply it as default
         # argument.
-        result = __InterlockedDecrement(self._refcnt)
+        result = _decrement(self._refcnt)
         _debug("%r.Release() -> %s", self, result)
         if result == 0:
             self._final_release_()
@@ -362,8 +421,7 @@ class COMObject(object):
     # IProvideClassInfo2::GetGUID implementation
 
     def IProvideClassInfo2_GetGUID(self, dwGuidKind: int) -> GUID:
-        # GUIDKIND_DEFAULT_SOURCE_DISP_IID = 1
-        if dwGuidKind != 1:
+        if dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID:
             raise WindowsError(hresult.E_INVALIDARG)
         return self._outgoing_interfaces_[0]._iid_
 
@@ -401,7 +459,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 +490,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,
@@ -461,10 +519,7 @@ class COMObject(object):
         #
         params = pDispParams[0]
 
-        if wFlags & (4 | 8):
-            # DISPATCH_PROPERTYPUT
-            # DISPATCH_PROPERTYPUTREF
-            #
+        if wFlags & (DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF):
             # How are the parameters unpacked for propertyput
             # operations with additional parameters?  Can propput
             # have additional args?
@@ -475,9 +530,7 @@ class COMObject(object):
             # DISPATCH_PROPERTYPUTREF is specified.
             return mth(this, *args)
 
-        else:
-            # DISPATCH_METHOD
-            # DISPATCH_PROPERTYGET
+        else:  # wFlags & (DISPATCH_METHOD | DISPATCH_PROPERTYGET)
             # the positions of named arguments
             #
             # 2to3 has problems to translate 'range(...)[::-1]'