comtypes 1.4.8__zip → 1.4.10__zip

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/errorinfo.py

@@ -1,10 +1,11 @@
 import sys
 from ctypes import *
-from comtypes import IUnknown, HRESULT, COMMETHOD, GUID, BSTR
+from ctypes.wintypes import DWORD, ULONG
+
+from comtypes import BSTR, COMMETHOD, GUID, HRESULT, IUnknown
 from comtypes.hresult import *
 
 LPCOLESTR = c_wchar_p
-DWORD = c_ulong
 
 
 class ICreateErrorInfo(IUnknown):
@@ -45,26 +46,38 @@ class ISupportErrorInfo(IUnknown):
 
 
 ################################################################
-_oleaut32 = oledll.oleaut32
+_oleaut32 = OleDLL("oleaut32")
+
+_CreateErrorInfo = _oleaut32.CreateErrorInfo
+_CreateErrorInfo.argtypes = [POINTER(POINTER(ICreateErrorInfo))]
+_CreateErrorInfo.restype = HRESULT
+
+_GetErrorInfo = _oleaut32.GetErrorInfo
+_GetErrorInfo.argtypes = [ULONG, POINTER(POINTER(IErrorInfo))]
+_GetErrorInfo.restype = HRESULT
+
+_SetErrorInfo = _oleaut32.SetErrorInfo
+_SetErrorInfo.argtypes = [ULONG, POINTER(IErrorInfo)]
+_SetErrorInfo.restype = HRESULT
 
 
 def CreateErrorInfo():
     cei = POINTER(ICreateErrorInfo)()
-    _oleaut32.CreateErrorInfo(byref(cei))
+    _CreateErrorInfo(byref(cei))
     return cei
 
 
 def GetErrorInfo():
     """Get the error information for the current thread."""
     errinfo = POINTER(IErrorInfo)()
-    if S_OK == _oleaut32.GetErrorInfo(0, byref(errinfo)):
+    if S_OK == _GetErrorInfo(0, byref(errinfo)):
         return errinfo
     return None
 
 
 def SetErrorInfo(errinfo):
     """Set error information for the current thread."""
-    return _oleaut32.SetErrorInfo(0, errinfo)
+    return _SetErrorInfo(0, errinfo)
 
 
 def ReportError(
@@ -89,7 +102,7 @@ def ReportError(
             ei.SetSource(
                 progid
             )  # progid for the class or application that created the error
-    _oleaut32.SetErrorInfo(0, ei)
+    _SetErrorInfo(0, ei)
     return hresult
 
 
@@ -103,9 +116,9 @@ def ReportException(
             tb = tb.tb_next
         line = tb.tb_frame.f_lineno
         name = tb.tb_frame.f_globals["__name__"]
-        text = "%s: %s (%s, line %d)" % (typ, value, name, line)
+        text = f"{typ}: {value} ({name}, line {line:d})"
     else:
-        text = "%s: %s" % (typ, value)
+        text = f"{typ}: {value}"
     return ReportError(
         text,
         iid,

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/git.py

@@ -5,18 +5,18 @@ between different threading appartments.
 """
 
 from ctypes import *
+from ctypes.wintypes import DWORD
+
 from comtypes import (
-    IUnknown,
-    STDMETHOD,
+    CLSCTX_INPROC_SERVER,
     COMMETHOD,
     GUID,
     HRESULT,
+    STDMETHOD,
     CoCreateInstance,
-    CLSCTX_INPROC_SERVER,
+    IUnknown,
 )
 
-DWORD = c_ulong
-
 
 class IGlobalInterfaceTable(IUnknown):
     _iid_ = GUID("{00000146-0000-0000-C000-000000000046}")

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/hints.pyi

@@ -3,17 +3,11 @@
 # - utilities for type hints.
 import ctypes
 import sys
-from typing import Any as Any, ClassVar, Generic, NoReturn, TypeVar, overload
+from typing import Any as Any, ClassVar, Generic, NoReturn, Protocol, TypeVar, overload
 from typing import Optional, Union as _UnionT
-from typing import List, Tuple as Tuple, Type
+from typing import Tuple as Tuple, Type
 from typing import Callable, Iterator, Sequence
 
-if sys.version_info >= (3, 8):
-    from typing import Protocol
-    from typing import Literal as Literal
-else:
-    from typing_extensions import Protocol
-    from typing_extensions import Literal as Literal
 if sys.version_info >= (3, 9):
     from typing import Annotated as Annotated
 else:
@@ -30,10 +24,11 @@ else:
     from typing_extensions import Self as Self
 
 import comtypes
-from comtypes import IUnknown as IUnknown, GUID as GUID
+from comtypes import IUnknown as IUnknown, COMObject as COMObject, GUID as GUID
 from comtypes.automation import IDispatch as IDispatch, VARIANT as VARIANT
 from comtypes.server import IClassFactory as IClassFactory
-from comtypes.typeinfo import ITypeInfo as ITypeInfo
+from comtypes.server import localserver as localserver
+from comtypes.typeinfo import ITypeInfo as ITypeInfo, ITypeLib as ITypeLib
 from comtypes._safearray import tagSAFEARRAY as tagSAFEARRAY
 
 Incomplete: TypeAlias = Any
@@ -74,6 +69,8 @@ class LP_SAFEARRAY(ctypes._Pointer[tagSAFEARRAY], Generic[_CT]):
     def unpack(self: LP_SAFEARRAY[_T_Struct]) -> Sequence[_T_Struct]: ...
     @overload
     def unpack(self) -> Sequence[Any]: ...
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self: ...
 
 _T_coclass = TypeVar("_T_coclass", bound=comtypes.CoClass)
 
@@ -85,11 +82,6 @@ class FirstComItfOf(Generic[_T_coclass]):
     as an argument.
     """
 
-class _MethodTypeDesc(Protocol):
-    arguments: List[Tuple[Any, str, List[str], Optional[Any]]]
-    idlflags: List[str]
-    name: str
-
 _P_Put = ParamSpec("_P_Put")
 _R_Put = TypeVar("_R_Put")
 _P_PutRef = ParamSpec("_P_PutRef")

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/logutil.py

@@ -1,13 +1,25 @@
 # logutil.py
-import logging, ctypes
+import logging
+from ctypes import WinDLL
+from ctypes.wintypes import LPCSTR, LPCWSTR
+
+_kernel32 = WinDLL("kernel32")
+
+_OutputDebugStringA = _kernel32.OutputDebugStringA
+_OutputDebugStringA.argtypes = [LPCSTR]
+_OutputDebugStringA.restype = None
+
+_OutputDebugStringW = _kernel32.OutputDebugStringW
+_OutputDebugStringW.argtypes = [LPCWSTR]
+_OutputDebugStringW.restype = None
 
 
 class NTDebugHandler(logging.Handler):
     def emit(
         self,
         record,
-        writeA=ctypes.windll.kernel32.OutputDebugStringA,
-        writeW=ctypes.windll.kernel32.OutputDebugStringW,
+        writeA=_OutputDebugStringA,
+        writeW=_OutputDebugStringW,
     ):
         text = self.format(record)
         if isinstance(text, str):

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/messageloop.py

@@ -1,5 +1,5 @@
 import ctypes
-from ctypes import WinDLL, byref, WinError
+from ctypes import WinDLL, WinError, byref
 from ctypes.wintypes import MSG
 
 _user32 = WinDLL("user32")

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/persist.py

@@ -10,13 +10,11 @@ The 'DictPropertyBag' class is a class implementing the IPropertyBag
 interface, useful in client code.
 """
 
-from ctypes import c_int, c_ulong, c_ushort, c_wchar_p
-from ctypes import POINTER, Structure
-from ctypes.wintypes import WORD, DWORD, BOOL
+from ctypes import POINTER, Structure, c_int, c_ulong, c_ushort, c_wchar_p
+from ctypes.wintypes import BOOL, DWORD, WORD
 from typing import TYPE_CHECKING
 
-from comtypes import GUID, IUnknown, COMMETHOD, HRESULT
-from comtypes import IPersist
+from comtypes import COMMETHOD, GUID, HRESULT, IPersist, IUnknown
 from comtypes.automation import VARIANT, tagEXCEPINFO
 
 if TYPE_CHECKING:

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/safearray.py

@@ -1,13 +1,15 @@
-import threading
 import array
+import threading
+from ctypes import POINTER, Structure, byref, c_long, cast, memmove, pointer, sizeof
 from typing import TYPE_CHECKING
+
 import comtypes
-from ctypes import POINTER, Structure, byref, cast, c_long, memmove, pointer, sizeof
-from comtypes import _safearray, IUnknown, com_interface_registry
+from comtypes import IUnknown, _safearray, com_interface_registry
 from comtypes.patcher import Patch
 
 if TYPE_CHECKING:
     from typing import Type, TypeVar
+
     from comtypes import hints  # type: ignore
 
     _CT = TypeVar("_CT", bound=comtypes._CData)
@@ -73,11 +75,12 @@ def _midlSAFEARRAY(itemtype: "Type[_CT]") -> "Type[hints.LP_SAFEARRAY[_CT]]":
 def _make_safearray_type(itemtype):
     # Create and return a subclass of tagSAFEARRAY
     from comtypes.automation import (
-        _ctype_to_vartype,
+        VT_DISPATCH,
+        VT_HRESULT,
         VT_RECORD,
         VT_UNKNOWN,
         IDispatch,
-        VT_DISPATCH,
+        _ctype_to_vartype,
     )
 
     meta = type(_safearray.tagSAFEARRAY)
@@ -123,6 +126,15 @@ def _make_safearray_type(itemtype):
             one-dimensional arrays.  To create multidimensional arrys,
             numpy arrays must be passed.
             """
+            if cls._vartype_ == VT_HRESULT:
+                raise TypeError(
+                    # There are COM type libraries that define the
+                    # `_midlSAFEARRAY(HRESULT)` type; however, creating `HRESULT`
+                    # safearray pointer instance does not work.
+                    # See also: https://github.com/enthought/comtypes/issues/668
+                    "Cannot create SAFEARRAY type VT_HRESULT."
+                )
+
             if comtypes.npsupport.isndarray(value):
                 return cls.create_from_ndarray(value, extra)
 

comtypes-1.4.10/comtypes/server/__init__.py

@@ -0,0 +1,104 @@
+import ctypes
+from ctypes import HRESULT, POINTER, OleDLL, byref, c_void_p
+from ctypes.wintypes import DWORD, LPVOID
+from typing import TYPE_CHECKING, Any, Optional, Type
+
+import comtypes
+import comtypes.client
+import comtypes.client.dynamic
+from comtypes import GUID, STDMETHOD, IUnknown
+from comtypes.automation import IDispatch
+from comtypes.GUID import REFCLSID
+
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+
+    from comtypes import hints  # type: ignore
+
+
+################################################################
+# Interfaces
+class IClassFactory(IUnknown):
+    _iid_ = GUID("{00000001-0000-0000-C000-000000000046}")
+    _methods_ = [
+        STDMETHOD(
+            HRESULT,
+            "CreateInstance",
+            [POINTER(IUnknown), POINTER(GUID), POINTER(ctypes.c_void_p)],
+        ),
+        STDMETHOD(HRESULT, "LockServer", [ctypes.c_int]),
+    ]
+
+    def CreateInstance(
+        self,
+        punkouter: Optional[Type["_Pointer[IUnknown]"]] = None,
+        interface: Optional[Type[IUnknown]] = None,
+        dynamic: bool = False,
+    ) -> Any:
+        if dynamic:
+            if interface is not None:
+                raise ValueError("interface and dynamic are mutually exclusive")
+            itf = IDispatch
+        elif interface is None:
+            itf = IUnknown
+        else:
+            itf = interface
+        obj = POINTER(itf)()
+        self.__com_CreateInstance(punkouter, itf._iid_, byref(obj))  # type: ignore
+        if dynamic:
+            return comtypes.client.dynamic.Dispatch(obj)
+        elif interface is None:
+            # An interface was not specified, so return the best.
+            return comtypes.client.GetBestInterface(obj)
+        # An interface was specified and obj is already that interface.
+        return obj
+
+    if TYPE_CHECKING:
+
+        def LockServer(self, fLock: int) -> hints.Hresult: ...
+
+
+# class IExternalConnection(IUnknown):
+#     _iid_ = GUID("{00000019-0000-0000-C000-000000000046}")
+#     _methods_ = [
+#         STDMETHOD(HRESULT, "AddConnection", [c_ulong, c_ulong]),
+#         STDMETHOD(HRESULT, "ReleaseConnection", [c_ulong, c_ulong, c_ulong])]
+
+# The following code is untested:
+
+ACTIVEOBJECT_STRONG = 0x0
+ACTIVEOBJECT_WEAK = 0x1
+
+_oleaut32 = OleDLL("oleaut32")
+
+_RegisterActiveObject = _oleaut32.RegisterActiveObject
+_RegisterActiveObject.argtypes = [
+    c_void_p,
+    REFCLSID,
+    DWORD,
+    POINTER(DWORD),
+]
+_RegisterActiveObject.restype = HRESULT
+
+_RevokeActiveObject = _oleaut32.RevokeActiveObject
+_RevokeActiveObject.argtypes = [
+    DWORD,
+    LPVOID,
+]
+_RevokeActiveObject.restype = HRESULT
+
+
+def RegisterActiveObject(comobj: comtypes.COMObject, weak: bool = True) -> int:
+    punk = comobj._com_pointers_[IUnknown._iid_]
+    clsid = comobj._reg_clsid_
+    if weak:
+        flags = ACTIVEOBJECT_WEAK
+    else:
+        flags = ACTIVEOBJECT_STRONG
+    handle = ctypes.c_ulong()
+    _RegisterActiveObject(punk, byref(clsid), flags, byref(handle))
+    return handle.value
+
+
+def RevokeActiveObject(handle: int) -> None:
+    _RevokeActiveObject(handle, None)

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/server/automation.py

@@ -1,10 +1,9 @@
 import logging
-
 from ctypes import *
-from comtypes.hresult import *
 
 from comtypes import COMObject, IUnknown
 from comtypes.automation import IDispatch, IEnumVARIANT
+from comtypes.hresult import *
 
 logger = logging.getLogger(__name__)
 

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/server/connectionpoints.py

@@ -1,11 +1,11 @@
+import logging
 from ctypes import *
-from comtypes import IUnknown, COMObject, COMError
+
+from comtypes import COMError, COMObject, IUnknown
+from comtypes.automation import IDispatch
+from comtypes.connectionpoints import IConnectionPoint
 from comtypes.hresult import *
 from comtypes.typeinfo import LoadRegTypeLib
-from comtypes.connectionpoints import IConnectionPoint
-from comtypes.automation import IDispatch
-
-import logging
 
 logger = logging.getLogger(__name__)
 

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/server/inprocserver.py

@@ -1,12 +1,14 @@
 import ctypes
-from comtypes import COMObject, GUID
-from comtypes.server import IClassFactory
-from comtypes.hresult import *
-
-import sys
 import logging
+import sys
 import winreg
+from typing import TYPE_CHECKING, Any, Literal, Optional, Type
+
+from comtypes import GUID, COMObject, IUnknown, hresult
+from comtypes.server import IClassFactory
 
+if TYPE_CHECKING:
+    from ctypes import _Pointer
 
 logger = logging.getLogger(__name__)
 _debug = logger.debug
@@ -18,33 +20,39 @@ _critical = logger.critical
 class ClassFactory(COMObject):
     _com_interfaces_ = [IClassFactory]
 
-    def __init__(self, cls):
+    def __init__(self, cls: Type[COMObject]) -> None:
         super(ClassFactory, self).__init__()
         self._cls = cls
 
-    def IClassFactory_CreateInstance(self, this, punkOuter, riid, ppv):
+    def IClassFactory_CreateInstance(
+        self,
+        this: Any,
+        punkOuter: Optional[Type["_Pointer[IUnknown]"]],
+        riid: "_Pointer[GUID]",
+        ppv: ctypes.c_void_p,
+    ) -> int:
         _debug("ClassFactory.CreateInstance(%s)", riid[0])
         result = self._cls().IUnknown_QueryInterface(None, riid, ppv)
         _debug("CreateInstance() -> %s", result)
         return result
 
-    def IClassFactory_LockServer(self, this, fLock):
+    def IClassFactory_LockServer(self, this: Any, fLock: bool) -> Literal[0]:
         if fLock:
             COMObject.__server__.Lock()
         else:
             COMObject.__server__.Unlock()
-        return S_OK
+        return hresult.S_OK
 
 
 # will be set by py2exe boot script 'from outside'
 _clsid_to_class = {}
 
 
-def inproc_find_class(clsid):
+def inproc_find_class(clsid: GUID) -> Type[COMObject]:
     if _clsid_to_class:
         return _clsid_to_class[clsid]
 
-    key = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, "CLSID\\%s\\InprocServer32" % clsid)
+    key = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, f"CLSID\\{clsid}\\InprocServer32")
     try:
         pathdir = winreg.QueryValueEx(key, "PythonPath")[0]
     except:
@@ -70,7 +78,7 @@ def inproc_find_class(clsid):
 _logging_configured = False
 
 
-def _setup_logging(clsid):
+def _setup_logging(clsid: GUID) -> None:
     """Read from the registry, and configure the logging module.
 
     Currently, the handler (NTDebugHandler) is hardcoded.
@@ -109,7 +117,7 @@ def _setup_logging(clsid):
         logging.getLogger(name).setLevel(level)
 
 
-def DllGetClassObject(rclsid, riid, ppv):
+def DllGetClassObject(rclsid: int, riid: int, ppv: int) -> int:
     COMObject.__run_inprocserver__()
 
     iid = GUID.from_address(riid)
@@ -127,7 +135,7 @@ def DllGetClassObject(rclsid, riid, ppv):
 
         cls = inproc_find_class(clsid)
         if not cls:
-            return CLASS_E_CLASSNOTAVAILABLE
+            return hresult.CLASS_E_CLASSNOTAVAILABLE
 
         result = ClassFactory(cls).IUnknown_QueryInterface(
             None, ctypes.pointer(iid), ctypes.c_void_p(ppv)
@@ -136,12 +144,12 @@ def DllGetClassObject(rclsid, riid, ppv):
         return result
     except Exception:
         _critical("DllGetClassObject", exc_info=True)
-        return E_FAIL
+        return hresult.E_FAIL
 
 
-def DllCanUnloadNow():
+def DllCanUnloadNow() -> Literal[1]:  # S_FALSE
     COMObject.__run_inprocserver__()
     result = COMObject.__server__.DllCanUnloadNow()
     # To avoid a memory leak when PyInitialize()/PyUninitialize() are
     # called several times, we refuse to unload the dll.
-    return S_FALSE
+    return hresult.S_FALSE

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/server/localserver.py

@@ -1,10 +1,23 @@
-import sys
-from ctypes import *
-import comtypes
-from comtypes.hresult import *
-from comtypes.server import IClassFactory
 import logging
 import queue
+from ctypes import (
+    HRESULT,
+    POINTER,
+    OleDLL,
+    byref,
+    c_ulong,
+    c_void_p,
+)
+from ctypes.wintypes import DWORD, LPDWORD
+from typing import TYPE_CHECKING, Any, Literal, Optional, Sequence, Type
+
+import comtypes
+from comtypes import GUID, hresult
+from comtypes.server import IClassFactory
+
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+
 
 logger = logging.getLogger(__name__)
 _debug = logger.debug
@@ -15,38 +28,49 @@ REGCLS_MULTI_SEPARATE = 2  # multiple use, but separate control over each
 REGCLS_SUSPENDED = 4  # register it as suspended, will be activated
 REGCLS_SURROGATE = 8  # must be used when a surrogate process
 
+_ole32 = OleDLL("ole32")
+
+REFCLSID = POINTER(GUID)
+_CoRegisterClassObject = _ole32.CoRegisterClassObject
+_CoRegisterClassObject.argtypes = [REFCLSID, c_void_p, DWORD, DWORD, LPDWORD]
+_CoRegisterClassObject.restype = HRESULT
+
+_CoRevokeClassObject = _ole32.CoRevokeClassObject
+_CoRevokeClassObject.argtypes = [DWORD]
+_CoRevokeClassObject.restype = HRESULT
+
 
-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_]
         clsctx = self._cls._reg_clsctx_
         clsctx &= ~comtypes.CLSCTX_INPROC  # reset the inproc flags
-        oledll.ole32.CoRegisterClassObject(
+        _CoRegisterClassObject(
             byref(comtypes.GUID(self._cls._reg_clsid_)),
             ptr,
             clsctx,
@@ -55,19 +79,25 @@ class ClassFactory(comtypes.COMObject):
         )
         self.cookie = cookie
 
-    def _revoke_class(self):
-        oledll.ole32.CoRevokeClassObject(self.cookie)
+    def _revoke_class(self) -> None:
+        _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