comtypes 1.4.9__zip → 1.4.11__zip

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

@@ -1,6 +1,15 @@
-import sys
-from ctypes import *
-from comtypes import IUnknown, COMMETHOD, GUID, HRESULT, dispid
+from ctypes import POINTER, Structure, c_ulong
+from typing import TYPE_CHECKING, Tuple
+from typing import Union as _UnionT
+
+from comtypes import COMMETHOD, GUID, HRESULT, IUnknown
+
+if TYPE_CHECKING:
+    from ctypes import _CArgObject, _Pointer
+
+    from comtypes import hints  # noqa  # type: ignore
+
+    REFIID = _UnionT[_Pointer[GUID], _CArgObject]
 
 _GUID = GUID
 
@@ -21,16 +30,35 @@ class IConnectionPointContainer(IUnknown):
     _iid_ = GUID("{B196B284-BAB4-101A-B69C-00AA00341D07}")
     _idlflags_ = []
 
+    if TYPE_CHECKING:
+
+        def EnumConnectionPoints(self) -> "IEnumConnectionPoints": ...
+        def FindConnectionPoint(self, riid: REFIID) -> "IConnectionPoint": ...
+
 
 class IConnectionPoint(IUnknown):
     _iid_ = GUID("{B196B286-BAB4-101A-B69C-00AA00341D07}")
     _idlflags_ = []
 
+    if TYPE_CHECKING:
+
+        def GetConnectionPointContainer(self) -> IConnectionPointContainer: ...
+        def Advise(self, pUnkSink: IUnknown) -> int: ...
+        def Unadvise(self, dwCookie: int) -> hints.Hresult: ...
+        def EnumConnections(self) -> "IEnumConnections": ...
+
 
 class IEnumConnections(IUnknown):
     _iid_ = GUID("{B196B287-BAB4-101A-B69C-00AA00341D07}")
     _idlflags_ = []
 
+    if TYPE_CHECKING:
+
+        def Next(self, cConnections: int) -> Tuple[tagCONNECTDATA, int]: ...
+        def Skip(self, cConnections: int) -> hints.Hresult: ...
+        def Reset(self) -> hints.Hresult: ...
+        def Clone(self) -> "IEnumConnections": ...
+
     def __iter__(self):
         return self
 
@@ -45,6 +73,13 @@ class IEnumConnectionPoints(IUnknown):
     _iid_ = GUID("{B196B285-BAB4-101A-B69C-00AA00341D07}")
     _idlflags_ = []
 
+    if TYPE_CHECKING:
+
+        def Next(self, cConnections: int) -> Tuple[IConnectionPoint, int]: ...
+        def Skip(self, cConnections: int) -> hints.Hresult: ...
+        def Reset(self) -> hints.Hresult: ...
+        def Clone(self) -> "IEnumConnectionPoints": ...
+
     def __iter__(self):
         return self
 

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

@@ -1,8 +1,14 @@
 import sys
-from ctypes import *
-from ctypes.wintypes import DWORD
-from comtypes import IUnknown, HRESULT, COMMETHOD, GUID, BSTR
-from comtypes.hresult import *
+from ctypes import POINTER, OleDLL, byref, c_wchar_p
+from ctypes.wintypes import DWORD, ULONG
+from typing import TYPE_CHECKING, Optional
+from typing import Union as _UnionT
+
+from comtypes import BSTR, COMMETHOD, GUID, HRESULT, IUnknown
+from comtypes.hresult import DISP_E_EXCEPTION, S_OK
+
+if TYPE_CHECKING:
+    from comtypes import hints  # type: ignore
 
 LPCOLESTR = c_wchar_p
 
@@ -16,6 +22,13 @@ class ICreateErrorInfo(IUnknown):
         COMMETHOD([], HRESULT, "SetHelpFile", (["in"], LPCOLESTR, "szHelpFile")),
         COMMETHOD([], HRESULT, "SetHelpContext", (["in"], DWORD, "dwHelpContext")),
     ]
+    if TYPE_CHECKING:
+
+        def SetGUID(self, rguid: GUID) -> hints.Hresult: ...
+        def SetSource(self, szSource: str) -> hints.Hresult: ...
+        def SetDescription(self, szDescription: str) -> hints.Hresult: ...
+        def SetHelpFile(self, szHelpFile: str) -> hints.Hresult: ...
+        def SetHelpContext(self, dwHelpContext: int) -> hints.Hresult: ...
 
 
 class IErrorInfo(IUnknown):
@@ -33,6 +46,13 @@ class IErrorInfo(IUnknown):
             [], HRESULT, "GetHelpContext", (["out"], POINTER(DWORD), "pdwHelpContext")
         ),
     ]
+    if TYPE_CHECKING:
+
+        def GetGUID(self) -> GUID: ...
+        def GetSource(self) -> str: ...
+        def GetDescription(self) -> str: ...
+        def GetHelpFile(self) -> str: ...
+        def GetHelpContext(self) -> int: ...
 
 
 class ISupportErrorInfo(IUnknown):
@@ -42,34 +62,57 @@ class ISupportErrorInfo(IUnknown):
             [], HRESULT, "InterfaceSupportsErrorInfo", (["in"], POINTER(GUID), "riid")
         )
     ]
+    if TYPE_CHECKING:
+
+        def InterfaceSupportsErrorInfo(self, riid: GUID) -> hints.Hresult: ...
 
 
 ################################################################
-_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():
+def CreateErrorInfo() -> ICreateErrorInfo:
+    """Creates an instance of a generic error object."""
     cei = POINTER(ICreateErrorInfo)()
-    _oleaut32.CreateErrorInfo(byref(cei))
-    return cei
+    _CreateErrorInfo(byref(cei))
+    return cei  # type: ignore
 
 
-def GetErrorInfo():
+def GetErrorInfo() -> Optional[IErrorInfo]:
     """Get the error information for the current thread."""
     errinfo = POINTER(IErrorInfo)()
-    if S_OK == _oleaut32.GetErrorInfo(0, byref(errinfo)):
-        return errinfo
+    if S_OK == _GetErrorInfo(0, byref(errinfo)):
+        return errinfo  # type: ignore
     return None
 
 
-def SetErrorInfo(errinfo):
+def SetErrorInfo(errinfo: _UnionT[IErrorInfo, ICreateErrorInfo]) -> "hints.Hresult":
     """Set error information for the current thread."""
-    return _oleaut32.SetErrorInfo(0, errinfo)
+    # ICreateErrorInfo can QueryInterface with IErrorInfo, so both types are
+    # accepted, thanks to the magic of from_param.
+    return _SetErrorInfo(0, errinfo)
 
 
 def ReportError(
-    text, iid, clsid=None, helpfile=None, helpcontext=0, hresult=DISP_E_EXCEPTION
-):
+    text: str,
+    iid: GUID,
+    clsid: _UnionT[None, str, GUID] = None,
+    helpfile: Optional[str] = None,
+    helpcontext: Optional[int] = 0,
+    hresult: int = DISP_E_EXCEPTION,
+) -> int:
     """Report a COM error.  Returns the passed in hresult value."""
     ei = CreateErrorInfo()
     ei.SetDescription(text)
@@ -86,21 +129,29 @@ def ReportError(
         except WindowsError:
             pass
         else:
-            ei.SetSource(
-                progid
-            )  # progid for the class or application that created the error
-    _oleaut32.SetErrorInfo(0, ei)
+            # progid for the class or application that created the error
+            ei.SetSource(progid)
+    SetErrorInfo(ei)
     return hresult
 
 
 def ReportException(
-    hresult, iid, clsid=None, helpfile=None, helpcontext=None, stacklevel=None
-):
+    hresult: int,
+    iid: GUID,
+    clsid: _UnionT[None, str, GUID] = None,
+    helpfile: Optional[str] = None,
+    helpcontext: Optional[int] = None,
+    stacklevel: Optional[int] = None,
+) -> int:
     """Report a COM exception.  Returns the passed in hresult value."""
     typ, value, tb = sys.exc_info()
     if stacklevel is not None:
         for _ in range(stacklevel):
+            if tb is None:
+                raise ValueError("'stacklevel' exceeds the available depth.")
             tb = tb.tb_next
+        if tb is None:
+            raise ValueError("'stacklevel' is specified, but no error information.")
         line = tb.tb_frame.f_lineno
         name = tb.tb_frame.f_globals["__name__"]
         text = f"{typ}: {value} ({name}, line {line:d})"

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

@@ -6,14 +6,15 @@ 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,
 )
 
 

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/hints.pyi

@@ -3,9 +3,10 @@
 # - utilities for type hints.
 import ctypes
 import sys
+from ctypes import _CData, _CDataType
 from typing import Any as Any, ClassVar, Generic, NoReturn, Protocol, TypeVar, overload
 from typing import Optional, Union as _UnionT
-from typing import Tuple as Tuple, Type
+from typing import List, Tuple as Tuple, Type
 from typing import Callable, Iterator, Sequence
 
 if sys.version_info >= (3, 9):
@@ -20,8 +21,10 @@ else:
     from typing_extensions import TypeGuard as TypeGuard
 if sys.version_info >= (3, 11):
     from typing import Self as Self
+    from typing import Unpack as Unpack
 else:
     from typing_extensions import Self as Self
+    from typing_extensions import Unpack as Unpack
 
 import comtypes
 from comtypes import IUnknown as IUnknown, COMObject as COMObject, GUID as GUID
@@ -41,7 +44,10 @@ Hresult: TypeAlias = int
 arguments and with `HRESULT` as its return type in its COM method definition.
 """
 
-_CT = TypeVar("_CT", bound=ctypes._CData)
+LP_LP_Vtbl: TypeAlias = ctypes._Pointer[ctypes._Pointer[ctypes.Structure]]
+"""A pointer to a pointer to a virtual function table."""
+
+_CT = TypeVar("_CT", bound=_CData)
 _T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
 _T_Struct = TypeVar("_T_Struct", bound=ctypes.Structure)
 
@@ -285,3 +291,10 @@ def to_dunder_setitem(
 ) -> Callable[Concatenate[_T_Inst, _P_Set], Any]: ...
 @overload
 def to_dunder_setitem(item: Any) -> Callable[..., NoReturn]: ...
+
+_PosParamFlagType: TypeAlias = Tuple[int, Optional[str]]
+_OptParamFlagType: TypeAlias = Tuple[int, Optional[str], Any]
+ParamFlagType: TypeAlias = _UnionT[_PosParamFlagType, _OptParamFlagType]
+_PosArgSpecElmType: TypeAlias = Tuple[List[str], Type[_CDataType], str]
+_OptArgSpecElmType: TypeAlias = Tuple[List[str], Type[_CDataType], str, Any]
+ArgSpecElmType: TypeAlias = _UnionT[_PosArgSpecElmType, _OptArgSpecElmType]

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

@@ -3,6 +3,8 @@
 #
 # Note that the codes should be written in decimal notation!
 
+from ctypes import c_long
+
 S_OK = 0
 S_FALSE = 1
 
@@ -53,13 +55,15 @@ DISP_E_UNKNOWNINTERFACE = -2147352575  # 0x80020001
 RPC_E_CHANGED_MODE = -2147417850  # 0x80010106
 RPC_E_SERVERFAULT = -2147417851  # 0x80010105
 
+RPC_E_NO_SYNC = -2147417824  # 0x80010120
+RPC_S_CALLPENDING = -2147417835  # 0x80010115
+
 # 'macros' and constants to create your own HRESULT values:
 
 
-def MAKE_HRESULT(sev, fac, code):
+def MAKE_HRESULT(sev: int, fac: int, code: int) -> int:
+    """Creates an HRESULT value from its component pieces."""
     # A hresult is SIGNED in comtypes
-    from ctypes import c_long
-
     return c_long((sev << 31 | fac << 16 | code)).value
 
 
@@ -70,12 +74,18 @@ FACILITY_ITF = 4
 FACILITY_WIN32 = 7
 
 
-def HRESULT_FROM_WIN32(x):
+def HRESULT_FROM_WIN32(x: int) -> int:
+    """Converts a system error code to an HRESULT value."""
     # make signed
-    from ctypes import c_long
-
     x = c_long(x).value
     if x < 0:
         return x
     # 0x80000000 | FACILITY_WIN32 << 16 | x & 0xFFFF
     return c_long(0x80070000 | (x & 0xFFFF)).value
+
+
+# Win32 error codes are defined as unsigned 32-bit integers. However, to
+# ensure compatibility with COM and other HRESULT-based APIs, Windows converts
+# them into HRESULT values by setting the high bit, ensuring a consistent way
+# to indicate failure across these APIs.
+RPC_S_SERVER_UNAVAILABLE = -2147023174  # 0x800706BA (WIN32: 1722 0x6BA)

{comtypes-1.4.9 → comtypes-1.4.11}/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.9 → comtypes-1.4.11}/comtypes/messageloop.py

@@ -1,31 +1,33 @@
 import ctypes
-from ctypes import WinDLL, byref, WinError
+from ctypes import WinDLL, WinError, byref
 from ctypes.wintypes import MSG
+from typing import TYPE_CHECKING, List, SupportsIndex
+
+if TYPE_CHECKING:
+    from ctypes import _CArgObject
+    from typing import Any, Callable, Iterable
+
+    _FilterCallable = Callable[["_CArgObject"], Iterable[Any]]  # type: ignore
 
 _user32 = WinDLL("user32")
 
 GetMessage = _user32.GetMessageA
-GetMessage.argtypes = [
-    ctypes.c_void_p,
-    ctypes.c_void_p,
-    ctypes.c_uint,
-    ctypes.c_uint,
-]
+GetMessage.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.c_uint]
 TranslateMessage = _user32.TranslateMessage
 DispatchMessage = _user32.DispatchMessageA
 
 
 class _MessageLoop(object):
-    def __init__(self):
-        self._filters = []
+    def __init__(self) -> None:
+        self._filters: List["_FilterCallable"] = []
 
-    def insert_filter(self, obj, index=-1):
+    def insert_filter(self, obj: "_FilterCallable", index: SupportsIndex = -1) -> None:
         self._filters.insert(index, obj)
 
-    def remove_filter(self, obj):
+    def remove_filter(self, obj: "_FilterCallable") -> None:
         self._filters.remove(obj)
 
-    def run(self):
+    def run(self) -> None:
         msg = MSG()
         lpmsg = byref(msg)
         while 1:
@@ -38,7 +40,7 @@ class _MessageLoop(object):
                 TranslateMessage(lpmsg)
                 DispatchMessage(lpmsg)
 
-    def filter_message(self, lpmsg):
+    def filter_message(self, lpmsg: "_CArgObject") -> bool:
         return any(list(filter(lpmsg)) for filter in self._filters)
 
 

{comtypes-1.4.9 → comtypes-1.4.11}/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.9 → comtypes-1.4.11}/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,12 +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,
-        VT_HRESULT,
+        _ctype_to_vartype,
     )
 
     meta = type(_safearray.tagSAFEARRAY)

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

@@ -1,5 +1,6 @@
 import ctypes
-from ctypes import HRESULT, POINTER, byref
+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
@@ -7,6 +8,7 @@ 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
@@ -67,7 +69,23 @@ class IClassFactory(IUnknown):
 ACTIVEOBJECT_STRONG = 0x0
 ACTIVEOBJECT_WEAK = 0x1
 
-oleaut32 = ctypes.oledll.oleaut32
+_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:
@@ -78,9 +96,9 @@ def RegisterActiveObject(comobj: comtypes.COMObject, weak: bool = True) -> int:
     else:
         flags = ACTIVEOBJECT_STRONG
     handle = ctypes.c_ulong()
-    oleaut32.RegisterActiveObject(punk, byref(clsid), flags, byref(handle))
+    _RegisterActiveObject(punk, byref(clsid), flags, byref(handle))
     return handle.value
 
 
 def RevokeActiveObject(handle: int) -> None:
-    oleaut32.RevokeActiveObject(handle, None)
+    _RevokeActiveObject(handle, None)

{comtypes-1.4.9 → comtypes-1.4.11}/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__)