comtypes 1.4.10__zip → 1.4.12__zip

comtypes-1.4.12/comtypes/hresult.py

@@ -0,0 +1,159 @@
+# comtypes.hresult
+# COM success and error codes
+#
+# Note that the codes should be written in decimal notation!
+
+from ctypes import c_long
+
+S_OK = 0
+S_FALSE = 1
+
+E_UNEXPECTED = -2147418113  # 0x8000FFFFL
+
+E_NOTIMPL = -2147467263  # 0x80004001L
+E_NOINTERFACE = -2147467262  # 0x80004002L
+E_POINTER = -2147467261  # 0x80004003L
+E_FAIL = -2147467259  # 0x80004005L
+E_INVALIDARG = -2147024809  # 0x80070057L
+E_OUTOFMEMORY = -2147024882  # 0x8007000EL
+
+CLASS_E_NOAGGREGATION = -2147221232  # 0x80040110L
+CLASS_E_CLASSNOTAVAILABLE = -2147221231  # 0x80040111L
+
+CO_E_CLASSSTRING = -2147221005  # 0x800401F3L
+
+# connection point error codes
+CONNECT_E_CANNOTCONNECT = -2147220990
+CONNECT_E_ADVISELIMIT = -2147220991
+CONNECT_E_NOCONNECTION = -2147220992
+
+TYPE_E_ELEMENTNOTFOUND = -2147352077  # 0x8002802BL
+
+TYPE_E_REGISTRYACCESS = -2147319780  # 0x8002801CL
+TYPE_E_CANTLOADLIBRARY = -2147312566  # 0x80029C4AL
+
+# all the DISP_E_ values from windows.h
+DISP_E_BUFFERTOOSMALL = -2147352557
+DISP_E_DIVBYZERO = -2147352558
+DISP_E_NOTACOLLECTION = -2147352559
+DISP_E_BADCALLEE = -2147352560
+DISP_E_PARAMNOTOPTIONAL = -2147352561  # 0x8002000F
+DISP_E_BADPARAMCOUNT = -2147352562  # 0x8002000E
+DISP_E_ARRAYISLOCKED = -2147352563  # 0x8002000D
+DISP_E_UNKNOWNLCID = -2147352564  # 0x8002000C
+DISP_E_BADINDEX = -2147352565  # 0x8002000B
+DISP_E_OVERFLOW = -2147352566  # 0x8002000A
+DISP_E_EXCEPTION = -2147352567  # 0x80020009
+DISP_E_BADVARTYPE = -2147352568  # 0x80020008
+DISP_E_NONAMEDARGS = -2147352569  # 0x80020007
+DISP_E_UNKNOWNNAME = -2147352570  # 0x80020006
+DISP_E_TYPEMISMATCH = -2147352571  # 0800020005
+DISP_E_PARAMNOTFOUND = -2147352572  # 0x80020004
+DISP_E_MEMBERNOTFOUND = -2147352573  # 0x80020003
+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: int, fac: int, code: int) -> int:
+    """Creates an HRESULT value from its component pieces."""
+    # A hresult is SIGNED in comtypes
+    return c_long((sev << 31 | fac << 16 | code)).value
+
+
+SEVERITY_ERROR = 1
+SEVERITY_SUCCESS = 0
+
+FACILITY_ITF = 4
+FACILITY_WIN32 = 7
+
+
+def HRESULT_FROM_WIN32(x: int) -> int:
+    """Converts a system error code to an HRESULT value."""
+    # make signed
+    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)
+
+
+################################################################
+# signed32bithex
+#
+# When using this package, error codes for exceptions like
+# `COMError` or `WindowsError` are base10 integers.
+#
+# However, as shown below, many technical references represent
+# HRESULT values using signed 32-bit hexadecimal notation:
+# https://learn.microsoft.com/en-us/windows/win32/seccrypto/common-hresult-values
+# https://learn.microsoft.com/en-us/windows/win32/learnwin32/error-codes-in-com
+#
+# If you search for the error code using the proper notation,
+# you might be able to find the reference.
+#
+# Don't be overly afraid of `COMError` or `WindowsError`!
+
+
+def signed32bithex_to_int(value: str, /) -> int:
+    """Converts a string in signed 32-bit hexadecimal notation to an integer.
+
+    Examples:
+
+        >>> signed32bithex_to_int('0x00000000') == 0  # S_OK
+        True
+        >>> signed32bithex_to_int('0x00000001') == 1  # S_FALSE
+        True
+        >>> signed32bithex_to_int('0x8000FFFF') == -2147418113  # E_UNEXPECTED
+        True
+    """
+    val = int(value, 16)
+    if val < 0x80000000:
+        return val
+    return val - 0x100000000
+
+
+def int_to_signed32bithex(value: int, /) -> str:
+    """Converts an integer to a string in signed 32-bit hexadecimal notation.
+
+    Examples:
+
+        >>> import comtypes.hresult as hr
+        >>> int_to_signed32bithex(hr.S_OK)
+        '0x00000000'
+        >>> int_to_signed32bithex(hr.S_FALSE)
+        '0x00000001'
+        >>> int_to_signed32bithex(hr.E_UNEXPECTED)
+        '0x8000FFFF'
+
+        >>> from comtypes import CoCreateInstance
+        >>> from comtypes import shelllink, automation
+        >>> CLSID_ShellLink = shelllink.ShellLink().IPersist_GetClassID()
+        >>> p = CoCreateInstance(CLSID_ShellLink)
+        >>> p.QueryInterface(shelllink.IShellLinkA)  # doctest: +ELLIPSIS
+        <POINTER(IShellLinkA) ptr=0x... at ...>
+        >>> p.QueryInterface(automation.IDispatch)  # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+            ...
+        _ctypes.COMError: (-2147467262, ..., (None, None, None, 0, None))
+        >>> int_to_signed32bithex(-2147467262)  # E_NOINTERFACE
+        '0x80004002'
+    """
+    # it is simpler than using `hex(value & 0xFFFFFFFF)`
+    return f"0x{value & 0xFFFFFFFF:08X}"
+
+
+################################################################

{comtypes-1.4.10 → comtypes-1.4.12}/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 = []
+class _MessageLoop:
+    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.10 → comtypes-1.4.12}/comtypes/patcher.py

@@ -1,4 +1,4 @@
-class Patch(object):
+class Patch:
     """
     Implements a class decorator suitable for patching an existing class with
     a new namespace.
@@ -69,7 +69,7 @@ def no_replace(f):
     return f
 
 
-class ReferenceEmptyClass(object):
+class ReferenceEmptyClass:
     """
     This empty class will serve as a reference for attributes present on
     any class.

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

@@ -12,7 +12,7 @@ interface, useful in client code.
 
 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 typing import TYPE_CHECKING, Any, Optional
 
 from comtypes import COMMETHOD, GUID, HRESULT, IPersist, IUnknown
 from comtypes.automation import VARIANT, tagEXCEPINFO
@@ -65,6 +65,13 @@ class IPropertyBag(IUnknown):
         ),
     ]
 
+    if TYPE_CHECKING:
+
+        def Read(
+            self, pszPropName: str, pVar: VARIANT, pErrorLog: Optional[IErrorLog]
+        ) -> Any: ...
+        def Write(self, pszPropName: str, pVar: Any) -> hints.Hresult: ...
+
 
 class IPersistPropertyBag(IPersist):
     _iid_ = GUID("{37D84F60-42CB-11CE-8135-00AA004BB851}")
@@ -266,7 +273,7 @@ class DictPropertyBag(COMObject):
     _com_interfaces_ = [IPropertyBag]
 
     def __init__(self, **kw):
-        super(DictPropertyBag, self).__init__()
+        super().__init__()
         self.values = kw
 
     def Read(self, this, name, pVar, errorlog):

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

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 _safearray_type_cache = {}
 
 
-class _SafeArrayAsNdArrayContextManager(object):
+class _SafeArrayAsNdArrayContextManager:
     """Context manager allowing safe arrays to be extracted as ndarrays.
 
     This is thread-safe.
@@ -110,7 +110,7 @@ def _make_safearray_type(itemtype):
             raise TypeError(itemtype)
 
     @Patch(POINTER(sa_type))
-    class _(object):
+    class _:
         # Should explain the ideas how SAFEARRAY is used in comtypes
         _itemtype_ = itemtype  # a ctypes type
         _vartype_ = vartype  # a VARTYPE value: VT_...
@@ -378,7 +378,7 @@ def _make_safearray_type(itemtype):
             return tuple(result)  # for compatibility with pywin32.
 
     @Patch(POINTER(POINTER(sa_type)))
-    class __(object):
+    class __:
         @classmethod
         def from_param(cls, value):
             if isinstance(value, cls._type_):
@@ -398,19 +398,19 @@ def _make_safearray_type(itemtype):
 def _ndarray_to_variant_array(value):
     """Convert an ndarray to VARIANT_dtype array"""
     # Check that variant arrays are supported
-    if comtypes.npsupport.interop.VARIANT_dtype is None:
+    if comtypes.npsupport.VARIANT_dtype is None:
         msg = "VARIANT ndarrays require NumPy 1.7 or newer."
         raise RuntimeError(msg)
-    numpy = comtypes.npsupport.interop.numpy
+    numpy = comtypes.npsupport.numpy
 
     # special cases
-    if numpy.issubdtype(value.dtype, comtypes.npsupport.interop.datetime64):
+    if numpy.issubdtype(value.dtype, comtypes.npsupport.datetime64):
         return _datetime64_ndarray_to_variant_array(value)
 
     from comtypes.automation import VARIANT
 
     # Empty array
-    varr = numpy.zeros(value.shape, comtypes.npsupport.interop.VARIANT_dtype, order="F")
+    varr = numpy.zeros(value.shape, comtypes.npsupport.VARIANT_dtype, order="F")
     # Convert each value to a variant and put it in the array.
     varr.flat = [VARIANT(v) for v in value.flat]
     return varr
@@ -423,12 +423,12 @@ def _datetime64_ndarray_to_variant_array(value):
     # fractional days.
     from comtypes.automation import VT_DATE
 
-    numpy = comtypes.npsupport.interop.numpy
+    numpy = comtypes.npsupport.numpy
     value = numpy.array(value, "datetime64[ns]")
-    value = value - comtypes.npsupport.interop.com_null_date64
+    value = value - comtypes.npsupport.com_null_date64
     # Convert to days
     value = value / numpy.timedelta64(1, "D")
-    varr = numpy.zeros(value.shape, comtypes.npsupport.interop.VARIANT_dtype, order="F")
+    varr = numpy.zeros(value.shape, comtypes.npsupport.VARIANT_dtype, order="F")
     varr["vt"] = VT_DATE
     varr["_"]["VT_R8"].flat = value.flat
     return varr

{comtypes-1.4.10 → comtypes-1.4.12}/comtypes/server/__init__.py

@@ -1,14 +1,13 @@
 import ctypes
-from ctypes import HRESULT, POINTER, OleDLL, byref, c_void_p
-from ctypes.wintypes import DWORD, LPVOID
+from ctypes import HRESULT, POINTER, byref
 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 import RevokeActiveObject as RevokeActiveObject
 from comtypes.automation import IDispatch
-from comtypes.GUID import REFCLSID
 
 if TYPE_CHECKING:
     from ctypes import _Pointer
@@ -64,41 +63,10 @@ class IClassFactory(IUnknown):
 #         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:
+    """Registers a pointer as the active object for its class and returns the handle."""
     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)
+    flags = comtypes.ACTIVEOBJECT_WEAK if weak else comtypes.ACTIVEOBJECT_STRONG
+    return comtypes.RegisterActiveObject(punk, clsid, flags)

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

@@ -22,7 +22,7 @@ class VARIANTEnumerator(COMObject):
             items  # keep, so that we can restore our iterator (in Reset, and Clone).
         )
         self.seq = iter(self.items)
-        super(VARIANTEnumerator, self).__init__()
+        super().__init__()
 
     def Next(self, this, celt, rgVar, pCeltFetched):
         if not rgVar:
@@ -75,7 +75,7 @@ class COMCollection(COMObject):
     def __init__(self, itemtype, collection):
         self.collection = collection
         self.itemtype = itemtype
-        super(COMCollection, self).__init__()
+        super().__init__()
 
     def _get_Item(self, this, pathname, pitem):
         if not pitem:

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

@@ -1,11 +1,22 @@
+import functools
 import logging
-from ctypes import *
+from _ctypes import COMError
+from ctypes import c_void_p, pointer
+from ctypes.wintypes import DWORD
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Tuple, Type
+from typing import Union as _UnionT
 
-from comtypes import COMError, COMObject, IUnknown
+from comtypes import GUID, COMObject, IUnknown
 from comtypes.automation import IDispatch
 from comtypes.connectionpoints import IConnectionPoint
 from comtypes.hresult import *
-from comtypes.typeinfo import LoadRegTypeLib
+from comtypes.typeinfo import ITypeInfo, LoadRegTypeLib
+
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+    from typing import ClassVar
+
+    from comtypes import hints  # type: ignore
 
 logger = logging.getLogger(__name__)
 
@@ -17,9 +28,11 @@ class ConnectionPointImpl(COMObject):
 
     _com_interfaces_ = [IConnectionPoint]
 
-    def __init__(self, sink_interface, sink_typeinfo):
-        super(ConnectionPointImpl, self).__init__()
-        self._connections = {}
+    def __init__(
+        self, sink_interface: Type[IUnknown], sink_typeinfo: ITypeInfo
+    ) -> None:
+        super().__init__()
+        self._connections: Dict[int, IUnknown] = {}
         self._cookie = 0
         self._sink_interface = sink_interface
         self._typeinfo = sink_typeinfo
@@ -27,7 +40,9 @@ class ConnectionPointImpl(COMObject):
     # per MSDN, all interface methods *must* be implemented, E_NOTIMPL
     # is no allowed return value
 
-    def IConnectionPoint_Advise(self, this, pUnk, pdwCookie):
+    def IConnectionPoint_Advise(
+        self, this: Any, pUnk: IUnknown, pdwCookie: "_Pointer[DWORD]"
+    ) -> "hints.Hresult":
         if not pUnk or not pdwCookie:
             return E_POINTER
         logger.debug("Advise")
@@ -39,7 +54,7 @@ class ConnectionPointImpl(COMObject):
         self._connections[self._cookie] = ptr
         return S_OK
 
-    def IConnectionPoint_Unadvise(self, this, dwCookie):
+    def IConnectionPoint_Unadvise(self, this: Any, dwCookie: int) -> "hints.Hresult":
         logger.debug("Unadvise %s", dwCookie)
         try:
             del self._connections[dwCookie]
@@ -47,13 +62,17 @@ class ConnectionPointImpl(COMObject):
             return CONNECT_E_NOCONNECTION
         return S_OK
 
-    def IConnectionPoint_GetConnectionPointContainer(self, this, ppCPC):
+    def IConnectionPoint_GetConnectionPointContainer(
+        self, this: Any, ppCPC: c_void_p
+    ) -> "hints.Hresult":
         return E_NOTIMPL
 
-    def IConnectionPoint_GetConnectionInterface(self, this, pIID):
+    def IConnectionPoint_GetConnectionInterface(
+        self, this: Any, pIID: "_Pointer[GUID]"
+    ) -> "hints.Hresult":
         return E_NOTIMPL
 
-    def _call_sinks(self, name, *args, **kw):
+    def _call_sinks(self, name: str, *args: Any, **kw: Any) -> List[Any]:
         results = []
         logger.debug("_call_sinks(%s, %s, *%s, **%s)", self, name, args, kw)
         # Is it an IDispatch derived interface?  Then, events have to be delivered
@@ -62,63 +81,35 @@ class ConnectionPointImpl(COMObject):
             # for better performance, we could cache the dispids.
             dispid = self._typeinfo.GetIDsOfNames(name)[0]
             for key, p in self._connections.items():
-                try:
-                    result = p.Invoke(dispid, *args, **kw)
-                except COMError as details:
-                    if details.hresult == -2147023174:
-                        logger.warning(
-                            "_call_sinks(%s, %s, *%s, **%s) failed; removing connection",
-                            self,
-                            name,
-                            args,
-                            kw,
-                            exc_info=True,
-                        )
-                        try:
-                            del self._connections[key]
-                        except KeyError:
-                            pass  # connection already gone
-                    else:
-                        logger.warning(
-                            "_call_sinks(%s, %s, *%s, **%s)",
-                            self,
-                            name,
-                            args,
-                            kw,
-                            exc_info=True,
-                        )
-                else:
-                    results.append(result)
+                mth = functools.partial(p.Invoke, dispid)  # type: ignore
+                results.extend(self._call_sink(name, key, mth, *args, **kw))
         else:
-            for p in self._connections.values():
-                try:
-                    result = getattr(p, name)(*args, **kw)
-                except COMError as details:
-                    if details.hresult == -2147023174:
-                        logger.warning(
-                            "_call_sinks(%s, %s, *%s, **%s) failed; removing connection",
-                            self,
-                            name,
-                            args,
-                            kw,
-                            exc_info=True,
-                        )
-                        del self._connections[key]
-                    else:
-                        logger.warning(
-                            "_call_sinks(%s, %s, *%s, **%s)",
-                            self,
-                            name,
-                            args,
-                            kw,
-                            exc_info=True,
-                        )
-                else:
-                    results.append(result)
+            for key, p in self._connections.items():
+                mth = getattr(p, name)
+                results.extend(self._call_sink(name, key, mth, *args, **kw))
         return results
 
+    def _call_sink(
+        self, name: str, key: int, mth: Callable[..., Any], *args: Any, **kw: Any
+    ) -> Iterator[Any]:
+        try:
+            result = mth(*args, **kw)
+        except COMError as details:
+            if details.hresult == RPC_S_SERVER_UNAVAILABLE:
+                warn_msg = "_call_sinks(%s, %s, *%s, **%s) failed; removing connection"
+                logger.warning(warn_msg, self, name, args, kw, exc_info=True)
+                try:
+                    del self._connections[key]
+                except KeyError:
+                    pass  # connection already gone
+            else:
+                warn_msg = "_call_sinks(%s, %s, *%s, **%s)"
+                logger.warning(warn_msg, self, name, args, kw, exc_info=True)
+        else:
+            yield result
 
-class ConnectableObjectMixin(object):
+
+class ConnectableObjectMixin:
     """Mixin which implements IConnectionPointContainer.
 
     Call Fire_Event(interface, methodname, *args, **kw) to fire an
@@ -126,22 +117,30 @@ class ConnectableObjectMixin(object):
     integer index into the _outgoing_interfaces_ list.
     """
 
-    def __init__(self):
-        super(ConnectableObjectMixin, self).__init__()
-        self.__connections = {}
+    if TYPE_CHECKING:
+        _outgoing_interfaces_: ClassVar[List[Type[IDispatch]]]
+        _reg_typelib_: ClassVar[Tuple[str, int, int]]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.__connections: Dict[Type[IDispatch], ConnectionPointImpl] = {}
 
         tlib = LoadRegTypeLib(*self._reg_typelib_)
         for itf in self._outgoing_interfaces_:
             typeinfo = tlib.GetTypeInfoOfGuid(itf._iid_)
             self.__connections[itf] = ConnectionPointImpl(itf, typeinfo)
 
-    def IConnectionPointContainer_EnumConnectionPoints(self, this, ppEnum):
+    def IConnectionPointContainer_EnumConnectionPoints(
+        self, this: Any, ppEnum: c_void_p
+    ) -> "hints.Hresult":
         # according to MSDN, E_NOTIMPL is specificially disallowed
         # because, without typeinfo, there's no way for the caller to
         # find out.
         return E_NOTIMPL
 
-    def IConnectionPointContainer_FindConnectionPoint(self, this, refiid, ppcp):
+    def IConnectionPointContainer_FindConnectionPoint(
+        self, this: Any, refiid: "_Pointer[GUID]", ppcp: c_void_p
+    ) -> "hints.Hresult":
         iid = refiid[0]
         logger.debug("FindConnectionPoint %s", iid)
         if not ppcp:
@@ -161,7 +160,9 @@ class ConnectableObjectMixin(object):
         logger.debug("No connectionpoint found")
         return CONNECT_E_NOCONNECTION
 
-    def Fire_Event(self, itf, name, *args, **kw):
+    def Fire_Event(
+        self, itf: _UnionT[int, Type[IDispatch]], name: str, *args: Any, **kw: Any
+    ) -> Any:
         # Fire event 'name' with arguments *args and **kw.
         # Accepts either an interface index or an interface as first argument.
         # Returns a list of results.