comtypes 1.4.9__zip → 1.4.11__zip

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

@@ -1,11 +1,22 @@
-from ctypes import *
-from comtypes import IUnknown, COMObject, COMError
-from comtypes.hresult import *
-from comtypes.typeinfo import LoadRegTypeLib
-from comtypes.connectionpoints import IConnectionPoint
+import functools
+import logging
+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 GUID, COMObject, IUnknown
 from comtypes.automation import IDispatch
+from comtypes.connectionpoints import IConnectionPoint
+from comtypes.hresult import *
+from comtypes.typeinfo import ITypeInfo, LoadRegTypeLib
 
-import logging
+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):
+    def __init__(
+        self, sink_interface: Type[IUnknown], sink_typeinfo: ITypeInfo
+    ) -> None:
         super(ConnectionPointImpl, self).__init__()
-        self._connections = {}
+        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,61 +81,33 @@ 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):
     """Mixin which implements IConnectionPointContainer.
@@ -126,22 +117,30 @@ class ConnectableObjectMixin(object):
     integer index into the _outgoing_interfaces_ list.
     """
 
-    def __init__(self):
+    if TYPE_CHECKING:
+        _outgoing_interfaces_: ClassVar[List[Type[IDispatch]]]
+        _reg_typelib_: ClassVar[Tuple[str, int, int]]
+
+    def __init__(self) -> None:
         super(ConnectableObjectMixin, self).__init__()
-        self.__connections = {}
+        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.

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

@@ -1,12 +1,16 @@
-import ctypes
 import logging
 import sys
 import winreg
-from typing import Any, Literal, Optional, Type
+from ctypes import c_void_p, pointer
+from typing import TYPE_CHECKING, Any, Literal, Optional, Type
 
 from comtypes import GUID, COMObject, IUnknown, hresult
+from comtypes._comobject import InprocServer as _InprocRefCounter
 from comtypes.server import IClassFactory
 
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+
 logger = logging.getLogger(__name__)
 _debug = logger.debug
 _critical = logger.critical
@@ -24,9 +28,9 @@ class ClassFactory(COMObject):
     def IClassFactory_CreateInstance(
         self,
         this: Any,
-        punkOuter: Optional[Type["ctypes._Pointer[IUnknown]"]],
-        riid: "ctypes._Pointer[GUID]",
-        ppv: ctypes.c_void_p,
+        punkOuter: Optional[Type["_Pointer[IUnknown]"]],
+        riid: "_Pointer[GUID]",
+        ppv: c_void_p,
     ) -> int:
         _debug("ClassFactory.CreateInstance(%s)", riid[0])
         result = self._cls().IUnknown_QueryInterface(None, riid, ppv)
@@ -34,6 +38,7 @@ class ClassFactory(COMObject):
         return result
 
     def IClassFactory_LockServer(self, this: Any, fLock: bool) -> Literal[0]:
+        assert COMObject.__server__ is not None, "The inprocserver is not running yet"
         if fLock:
             COMObject.__server__.Lock()
         else:
@@ -55,7 +60,7 @@ def inproc_find_class(clsid: GUID) -> Type[COMObject]:
     except:
         _debug("NO path to insert")
     else:
-        if not pathdir in sys.path:
+        if pathdir not in sys.path:
             sys.path.insert(0, str(pathdir))
             _debug("insert path %r", pathdir)
         else:
@@ -135,7 +140,7 @@ def DllGetClassObject(rclsid: int, riid: int, ppv: int) -> int:
             return hresult.CLASS_E_CLASSNOTAVAILABLE
 
         result = ClassFactory(cls).IUnknown_QueryInterface(
-            None, ctypes.pointer(iid), ctypes.c_void_p(ppv)
+            None, pointer(iid), c_void_p(ppv)
         )
         _debug("DllGetClassObject() -> %s", result)
         return result
@@ -146,7 +151,8 @@ def DllGetClassObject(rclsid: int, riid: int, ppv: int) -> int:
 
 def DllCanUnloadNow() -> Literal[1]:  # S_FALSE
     COMObject.__run_inprocserver__()
-    result = COMObject.__server__.DllCanUnloadNow()
+    assert isinstance(COMObject.__server__, _InprocRefCounter)
+    result = COMObject.__server__.DllCanUnloadNow()  # noqa
     # To avoid a memory leak when PyInitialize()/PyUninitialize() are
     # called several times, we refuse to unload the dll.
     return hresult.S_FALSE

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

@@ -1,11 +1,11 @@
 import logging
 import queue
-import sys
-from ctypes import byref, c_ulong, c_void_p, oledll
+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 hresult
+from comtypes import GUID, COMObject, IUnknown, hresult
 from comtypes.server import IClassFactory
 
 if TYPE_CHECKING:
@@ -21,19 +21,30 @@ 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")
 
-def run(classes: Sequence[Type[comtypes.COMObject]]) -> None:
+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: Sequence[Type[COMObject]]) -> None:
     classobjects = [ClassFactory(cls) for cls in classes]
-    comtypes.COMObject.__run_localserver__(classobjects)
+    COMObject.__run_localserver__(classobjects)
 
 
-class ClassFactory(comtypes.COMObject):
+class ClassFactory(COMObject):
     _com_interfaces_ = [IClassFactory]
     _locks: int = 0
     _queue: Optional[queue.Queue] = None
     regcls: int = REGCLS_MULTIPLEUSE
 
-    def __init__(self, cls: Type[comtypes.COMObject], *args, **kw) -> None:
+    def __init__(self, cls: Type[COMObject], *args, **kw) -> None:
         super(ClassFactory, self).__init__()
         self._cls = cls
         self._register_class()
@@ -49,11 +60,11 @@ class ClassFactory(comtypes.COMObject):
     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_
+        ptr = self._com_pointers_[IUnknown._iid_]
+        clsctx = self._cls._reg_clsctx_  # type: ignore
         clsctx &= ~comtypes.CLSCTX_INPROC  # reset the inproc flags
-        oledll.ole32.CoRegisterClassObject(
-            byref(comtypes.GUID(self._cls._reg_clsid_)),
+        _CoRegisterClassObject(
+            byref(GUID(self._cls._reg_clsid_)),
             ptr,
             clsctx,
             regcls,
@@ -62,13 +73,13 @@ class ClassFactory(comtypes.COMObject):
         self.cookie = cookie
 
     def _revoke_class(self) -> None:
-        oledll.ole32.CoRevokeClassObject(self.cookie)
+        _CoRevokeClassObject(self.cookie)
 
     def CreateInstance(
         self,
         this: Any,
-        punkOuter: Optional[Type["_Pointer[comtypes.IUnknown]"]],
-        riid: "_Pointer[comtypes.GUID]",
+        punkOuter: Optional[Type["_Pointer[IUnknown]"]],
+        riid: "_Pointer[GUID]",
         ppv: c_void_p,
     ) -> int:
         _debug("ClassFactory.CreateInstance(%s)", riid[0])
@@ -78,8 +89,9 @@ class ClassFactory(comtypes.COMObject):
         return result
 
     def LockServer(self, this: Any, fLock: bool) -> Literal[0]:
+        assert COMObject.__server__ is not None, "The localserver is not running yet"
         if fLock:
-            comtypes.COMObject.__server__.Lock()
+            COMObject.__server__.Lock()
         else:
-            comtypes.COMObject.__server__.Unlock()
+            COMObject.__server__.Unlock()
         return hresult.S_OK