comtypes 1.4.10__zip → 1.4.11__zip

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/client/_events.py

@@ -1,7 +1,8 @@
 import ctypes
 import logging
 import traceback
-from ctypes import HRESULT, POINTER, WINFUNCTYPE, OleDLL, Structure, WinDLL
+from _ctypes import COMError
+from ctypes import HRESULT, POINTER, WINFUNCTYPE, OleDLL, Structure, WinDLL, byref
 from ctypes.wintypes import (
     BOOL,
     DWORD,
@@ -12,13 +13,16 @@ from ctypes.wintypes import (
     LPVOID,
     ULONG,
 )
+from typing import Any, Callable, Optional, Type
+from typing import Union as _UnionT
 
 import comtypes
-import comtypes.automation
-import comtypes.connectionpoints
-import comtypes.hresult
-import comtypes.typeinfo
+from comtypes import COMObject, IUnknown, hresult
+from comtypes._comobject import _MethodFinder
+from comtypes.automation import DISPATCH_METHOD, IDispatch
 from comtypes.client._generate import GetModule
+from comtypes.connectionpoints import IConnectionPoint, IConnectionPointContainer
+from comtypes.typeinfo import GUIDKIND_DEFAULT_SOURCE_DISP_IID, IProvideClassInfo2
 
 logger = logging.getLogger(__name__)
 
@@ -57,46 +61,62 @@ _CloseHandle = _kernel32.CloseHandle
 _CloseHandle.argtypes = [HANDLE]
 _CloseHandle.restype = BOOL
 
+_ReceiverType = _UnionT[COMObject, IUnknown]
+
 
 class _AdviseConnection(object):
-    def __init__(self, source, interface, receiver):
+    cp: Optional[IConnectionPoint]
+    cookie: Optional[int]
+    receiver: Optional[_ReceiverType]
+
+    def __init__(
+        self, source: IUnknown, interface: Type[IUnknown], receiver: _ReceiverType
+    ) -> None:
+        # Pre-initializing attributes to avoid AttributeError after failed connection.
         self.cp = None
         self.cookie = None
         self.receiver = None
         self._connect(source, interface, receiver)
 
-    def _connect(self, source, interface, receiver):
-        cpc = source.QueryInterface(comtypes.connectionpoints.IConnectionPointContainer)
-        self.cp = cpc.FindConnectionPoint(ctypes.byref(interface._iid_))
+    def _connect(
+        self, source: IUnknown, interface: Type[IUnknown], receiver: _ReceiverType
+    ) -> None:
+        cpc = source.QueryInterface(IConnectionPointContainer)
+        self.cp = cpc.FindConnectionPoint(byref(interface._iid_))
         logger.debug("Start advise %s", interface)
-        self.cookie = self.cp.Advise(receiver)
+        # Since `POINTER(IUnknown).from_param`(`_compointer_base.from_param`)
+        # can accept a `COMObject` instance, `IConnectionPoint.Advise` can
+        # take either a COM object or a COM interface pointer.
+        self.cookie = self.cp.Advise(receiver)  # type: ignore
         self.receiver = receiver
 
-    def disconnect(self):
+    def disconnect(self) -> None:
         if self.cookie:
+            assert self.cp is not None
             self.cp.Unadvise(self.cookie)
             logger.debug("Unadvised %s", self.cp)
             self.cp = None
             self.cookie = None
             del self.receiver
 
-    def __del__(self):
+    def __del__(self) -> None:
         try:
             if self.cookie is not None:
+                assert self.cp is not None
                 self.cp.Unadvise(self.cookie)
-        except (comtypes.COMError, WindowsError):
+        except (COMError, WindowsError):
             # Are we sure we want to ignore errors here?
             pass
 
 
-def FindOutgoingInterface(source):
+def FindOutgoingInterface(source: IUnknown) -> Type[IUnknown]:
     """XXX Describe the strategy that is used..."""
     # If the COM object implements IProvideClassInfo2, it is easy to
     # find the default outgoing interface.
     try:
-        pci = source.QueryInterface(comtypes.typeinfo.IProvideClassInfo2)
-        guid = pci.GetGUID(1)
-    except comtypes.COMError:
+        pci = source.QueryInterface(IProvideClassInfo2)
+        guid = pci.GetGUID(GUIDKIND_DEFAULT_SOURCE_DISP_IID)
+    except COMError:
         pass
     else:
         # another try: block needed?
@@ -115,7 +135,7 @@ def FindOutgoingInterface(source):
     # comtypes.client):
     clsid = source.__dict__.get("__clsid")
     try:
-        interface = comtypes.com_coclass_registry[clsid]._outgoing_interfaces_[0]
+        interface = comtypes.com_coclass_registry[clsid]._outgoing_interfaces_[0]  # type: ignore
     except KeyError:
         pass
     else:
@@ -133,7 +153,7 @@ def find_single_connection_interface(source):
     # Enumerate the connection interfaces.  If we find a single one,
     # return it, if there are more, we give up since we cannot
     # determine which one to use.
-    cpc = source.QueryInterface(comtypes.connectionpoints.IConnectionPointContainer)
+    cpc = source.QueryInterface(IConnectionPointContainer)
     enum = cpc.EnumConnectionPoints()
     iid = enum.next().GetConnectionInterface()
     try:
@@ -152,32 +172,33 @@ def find_single_connection_interface(source):
     return None
 
 
-def report_errors(func):
+def report_errors(func: Callable[..., Any]) -> Callable[..., Any]:
     # This decorator preserves parts of the decorated function
     # signature, so that the comtypes special-casing for the 'this'
     # parameter still works.
     if func.__code__.co_varnames[:2] == ("self", "this"):
 
-        def error_printer(self, this, *args, **kw):
+        def with_this(self, this, *args, **kw):
             try:
                 return func(self, this, *args, **kw)
             except:
                 traceback.print_exc()
                 raise
 
+        error_printer = with_this
+
     else:
 
-        def error_printer(*args, **kw):
+        def without_this(*args, **kw):
             try:
                 return func(*args, **kw)
             except:
                 traceback.print_exc()
                 raise
 
-    return error_printer
-
+        error_printer = without_this
 
-from comtypes._comobject import _MethodFinder
+    return error_printer
 
 
 class _SinkMethodFinder(_MethodFinder):
@@ -187,11 +208,11 @@ class _SinkMethodFinder(_MethodFinder):
     event handlers.
     """
 
-    def __init__(self, inst, sink):
+    def __init__(self, inst: COMObject, sink: Any) -> None:
         super(_SinkMethodFinder, self).__init__(inst)
         self.sink = sink
 
-    def find_method(self, fq_name, mthname):
+    def find_method(self, fq_name: str, mthname: str) -> Callable[..., Any]:
         impl = self._find_method(fq_name, mthname)
         # Caller of this method catches AttributeError,
         # so we need to be careful in the following code
@@ -206,7 +227,7 @@ class _SinkMethodFinder(_MethodFinder):
         except AttributeError as details:
             raise RuntimeError(details)
 
-    def _find_method(self, fq_name, mthname):
+    def _find_method(self, fq_name: str, mthname: str) -> Callable[..., Any]:
         try:
             return super(_SinkMethodFinder, self).find_method(fq_name, mthname)
         except AttributeError:
@@ -216,11 +237,11 @@ class _SinkMethodFinder(_MethodFinder):
                 return getattr(self.sink, mthname)
 
 
-def CreateEventReceiver(interface, handler):
-    class Sink(comtypes.COMObject):
+def CreateEventReceiver(interface: Type[IUnknown], handler: Any) -> COMObject:
+    class Sink(COMObject):
         _com_interfaces_ = [interface]
 
-        def _get_method_finder_(self, itf):
+        def _get_method_finder_(self, itf: Type[IUnknown]) -> _MethodFinder:
             # Use a special MethodFinder that will first try 'self',
             # then the sink.
             return _SinkMethodFinder(self, handler)
@@ -229,25 +250,25 @@ def CreateEventReceiver(interface, handler):
 
     # Since our Sink object doesn't have typeinfo, it needs a
     # _dispimpl_ dictionary to dispatch events received via Invoke.
-    if issubclass(interface, comtypes.automation.IDispatch) and not hasattr(
-        sink, "_dispimpl_"
-    ):
+    if issubclass(interface, IDispatch) and not hasattr(sink, "_dispimpl_"):
         finder = sink._get_method_finder_(interface)
         dispimpl = sink._dispimpl_ = {}
         for m in interface._methods_:
-            restype, mthname, argtypes, paramflags, idlflags, helptext = m
             # Can dispid be at a different index? Should check code generator...
             # ...but hand-written code should also work...
-            dispid = idlflags[0]
-            impl = finder.get_impl(interface, mthname, paramflags, idlflags)
+            dispid = m.idlflags[0]
+            assert isinstance(dispid, comtypes.dispid)
+            impl = finder.get_impl(interface, m.name, m.paramflags, m.idlflags)
             # XXX Wouldn't work for 'propget', 'propput', 'propputref'
             # methods - are they allowed on event interfaces?
-            dispimpl[(dispid, comtypes.automation.DISPATCH_METHOD)] = impl
+            dispimpl[(dispid, DISPATCH_METHOD)] = impl
 
     return sink
 
 
-def GetEvents(source, sink, interface=None):
+def GetEvents(
+    source: IUnknown, sink: Any, interface: Optional[Type[IUnknown]] = None
+) -> _AdviseConnection:
     """Receive COM events from 'source'.  Events will call methods on
     the 'sink' object.  'interface' is the source interface to use.
     """
@@ -265,7 +286,7 @@ def GetEvents(source, sink, interface=None):
 class EventDumper(object):
     """Universal sink for COM events."""
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> Callable[..., Any]:
         "Create event handler methods on demand"
         if name.startswith("__") and name.endswith("__"):
             raise AttributeError(name)
@@ -279,13 +300,15 @@ class EventDumper(object):
         return comtypes.instancemethod(handler, self, EventDumper)
 
 
-def ShowEvents(source, interface=None):
+def ShowEvents(
+    source: IUnknown, interface: Optional[Type[IUnknown]] = None
+) -> _AdviseConnection:
     """Receive COM events from 'source'.  A special event sink will be
     used that first prints the names of events that are found in the
     outgoing interface, and will also print out the events when they
     are fired.
     """
-    return comtypes.client.GetEvents(source, sink=EventDumper(), interface=interface)
+    return GetEvents(source, sink=EventDumper(), interface=interface)
 
 
 # This type is used inside 'PumpEvents', but if we create the type
@@ -293,8 +316,24 @@ def ShowEvents(source, interface=None):
 # garbage for each call.  So we define it here instead.
 _handles_type = ctypes.c_void_p * 1
 
+# The type of control signal received by the handler.
+CTRL_C_EVENT = 0
+CTRL_BREAK_EVENT = 1
+CTRL_CLOSE_EVENT = 2
+CTRL_LOGOFF_EVENT = 5
+CTRL_SHUTDOWN_EVENT = 6
+
+# Specifiers for the behavior of the CoWaitForMultipleHandles function.
+# tagCOWAIT_FLAGS = ctypes.c_int
+COWAIT_DEFAULT = 0
+COWAIT_WAITALL = 1
+COWAIT_ALERTABLE = 2
+COWAIT_INPUTAVAILABLE = 4
+COWAIT_DISPATCH_CALLS = 8
+COWAIT_DISPATCH_WINDOW_MESSAGES = 16
+
 
-def PumpEvents(timeout):
+def PumpEvents(timeout: Any) -> None:
     """This following code waits for 'timeout' seconds in the way
     required for COM, internally doing the correct things depending
     on the COM appartment of the current thread.  It is possible to
@@ -323,11 +362,10 @@ def PumpEvents(timeout):
 
     hevt = _CreateEventA(None, True, False, None)
     handles = _handles_type(hevt)
-    RPC_S_CALLPENDING = -2147417835
 
     # @ctypes.WINFUNCTYPE(BOOL, DWORD)
     def HandlerRoutine(dwCtrlType):
-        if dwCtrlType == 0:  # CTRL+C
+        if dwCtrlType == CTRL_C_EVENT:  # CTRL+C
             _SetEvent(hevt)
             return 1
         return 0
@@ -336,15 +374,15 @@ def PumpEvents(timeout):
 
     try:
         try:
-            res = _CoWaitForMultipleHandles(
-                0,
+            _CoWaitForMultipleHandles(
+                COWAIT_DEFAULT,
                 int(timeout * 1000),
                 len(handles),
                 handles,
-                ctypes.byref(ctypes.c_ulong()),
+                byref(ctypes.c_ulong()),
             )
         except WindowsError as details:
-            if details.winerror != RPC_S_CALLPENDING:  # timeout expired
+            if details.winerror != hresult.RPC_S_CALLPENDING:  # timeout expired
                 raise
         else:
             raise KeyboardInterrupt

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/client/_generate.py

@@ -15,8 +15,6 @@ from comtypes.tools import codegenerator, tlbparser
 
 logger = logging.getLogger(__name__)
 
-PATH = os.environ["PATH"].split(os.pathsep)
-
 
 def _my_import(fullname: str) -> types.ModuleType:
     """helper function to import dotted modules"""

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

@@ -1,7 +1,15 @@
-import sys
-from ctypes import *
+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, dispid
+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
 
@@ -22,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
 
@@ -46,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.10 → comtypes-1.4.11}/comtypes/errorinfo.py

@@ -1,9 +1,14 @@
 import sys
-from ctypes 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 *
+from comtypes.hresult import DISP_E_EXCEPTION, S_OK
+
+if TYPE_CHECKING:
+    from comtypes import hints  # type: ignore
 
 LPCOLESTR = c_wchar_p
 
@@ -17,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):
@@ -34,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):
@@ -43,6 +62,9 @@ class ISupportErrorInfo(IUnknown):
             [], HRESULT, "InterfaceSupportsErrorInfo", (["in"], POINTER(GUID), "riid")
         )
     ]
+    if TYPE_CHECKING:
+
+        def InterfaceSupportsErrorInfo(self, riid: GUID) -> hints.Hresult: ...
 
 
 ################################################################
@@ -61,28 +83,36 @@ _SetErrorInfo.argtypes = [ULONG, POINTER(IErrorInfo)]
 _SetErrorInfo.restype = HRESULT
 
 
-def CreateErrorInfo():
+def CreateErrorInfo() -> ICreateErrorInfo:
+    """Creates an instance of a generic error object."""
     cei = POINTER(ICreateErrorInfo)()
     _CreateErrorInfo(byref(cei))
-    return 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 == _GetErrorInfo(0, byref(errinfo)):
-        return 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."""
+    # 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)
@@ -99,21 +129,29 @@ def ReportError(
         except WindowsError:
             pass
         else:
-            ei.SetSource(
-                progid
-            )  # progid for the class or application that created the error
-    _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.10 → 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.10 → 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.10 → comtypes-1.4.11}/comtypes/messageloop.py

@@ -1,31 +1,33 @@
 import ctypes
 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)