comtypes 1.4.10__zip → 1.4.11__zip

{comtypes-1.4.10 → comtypes-1.4.11}/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):
+    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.10 → comtypes-1.4.11}/comtypes/server/inprocserver.py

@@ -1,10 +1,11 @@
-import ctypes
 import logging
 import sys
 import winreg
+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:
@@ -29,7 +30,7 @@ class ClassFactory(COMObject):
         this: Any,
         punkOuter: Optional[Type["_Pointer[IUnknown]"]],
         riid: "_Pointer[GUID]",
-        ppv: ctypes.c_void_p,
+        ppv: c_void_p,
     ) -> int:
         _debug("ClassFactory.CreateInstance(%s)", riid[0])
         result = self._cls().IUnknown_QueryInterface(None, riid, ppv)
@@ -37,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:
@@ -58,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:
@@ -138,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
@@ -149,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.10 → comtypes-1.4.11}/comtypes/server/localserver.py

@@ -1,18 +1,11 @@
 import logging
 import queue
-from ctypes import (
-    HRESULT,
-    POINTER,
-    OleDLL,
-    byref,
-    c_ulong,
-    c_void_p,
-)
+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 import GUID, COMObject, IUnknown, hresult
 from comtypes.server import IClassFactory
 
 if TYPE_CHECKING:
@@ -40,18 +33,18 @@ _CoRevokeClassObject.argtypes = [DWORD]
 _CoRevokeClassObject.restype = HRESULT
 
 
-def run(classes: Sequence[Type[comtypes.COMObject]]) -> None:
+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()
@@ -67,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
         _CoRegisterClassObject(
-            byref(comtypes.GUID(self._cls._reg_clsid_)),
+            byref(GUID(self._cls._reg_clsid_)),
             ptr,
             clsctx,
             regcls,
@@ -85,8 +78,8 @@ class ClassFactory(comtypes.COMObject):
     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])
@@ -96,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

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/server/register.py

@@ -43,7 +43,7 @@ import os
 import sys
 import winreg
 from ctypes import WinDLL, WinError
-from ctypes.wintypes import HKEY, LONG, LPCWSTR
+from ctypes.wintypes import HKEY, LONG, LPCWSTR, MAX_PATH
 from typing import Iterable, Iterator, List, Optional, Tuple, Type, Union
 from winreg import HKEY_CLASSES_ROOT as HKCR
 from winreg import HKEY_CURRENT_USER as HKCU
@@ -242,7 +242,7 @@ class Registrar(object):
 
 def _get_serverdll(handle: int) -> str:
     """Return the pathname of the dll hosting the COM object."""
-    return GetModuleFileName(handle, 260)
+    return GetModuleFileName(handle, MAX_PATH)
 
 
 class RegistryEntries(abc.ABC):

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_GUID.py

@@ -30,25 +30,24 @@ class Test(unittest.TestCase):
         )
 
     def test_invalid_constructor_arg(self):
-        self.assertRaises(WindowsError, GUID, "abc")
+        with self.assertRaises(WindowsError):
+            GUID("abc")
 
     def test_from_progid(self):
         self.assertEqual(
             GUID.from_progid("Scripting.FileSystemObject"),
             GUID("{0D43FE01-F093-11CF-8940-00A0C9054228}"),
         )
-        self.assertRaises(WindowsError, GUID.from_progid, "abc")
+        with self.assertRaises(WindowsError):
+            GUID.from_progid("abc")
 
     def test_as_progid(self):
         self.assertEqual(
             GUID("{0D43FE01-F093-11CF-8940-00A0C9054228}").as_progid(),
             "Scripting.FileSystemObject",
         )
-        self.assertRaises(
-            WindowsError,
-            lambda guid: guid.as_progid(),
-            GUID("{00000000-0000-0000-C000-000000000046}"),
-        )
+        with self.assertRaises(WindowsError):
+            GUID("{00000000-0000-0000-C000-000000000046}").as_progid()
 
     def test_create_new(self):
         self.assertNotEqual(GUID.create_new(), GUID.create_new())

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_basic.py

@@ -61,7 +61,8 @@ class BasicTest(ut.TestCase):
         self.assertEqual(method_count(IMyInterface), 3)
 
         # assigning _methods_ does not work until we have an _iid_!
-        self.assertRaises(AttributeError, setattr, IMyInterface, "_methods_", [])
+        with self.assertRaises(AttributeError):
+            setattr(IMyInterface, "_methods_", [])
         IMyInterface._iid_ = GUID.create_new()
         IMyInterface._methods_ = []
         self.assertEqual(method_count(IMyInterface), 3)
@@ -96,9 +97,11 @@ class BasicTest(ut.TestCase):
             _iid_ = GUID.create_new()
 
         # We cannot assign _methods_ to IDerived before IBase has it's _methods_:
-        self.assertRaises(TypeError, lambda: setattr(IDerived, "_methods_", []))
+        with self.assertRaises(TypeError):
+            setattr(IDerived, "_methods_", [])
         # Make sure that setting _methods_ failed completely.
-        self.assertRaises(KeyError, lambda: IDerived.__dict__["_methods_"])
+        with self.assertRaises(KeyError):
+            IDerived.__dict__["_methods_"]
         IBase._methods_ = []
         # Now it works:
         IDerived._methods_ = []

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_collections.py

@@ -60,7 +60,8 @@ class Test(unittest.TestCase):
 
         # slicing is not (yet?) supported
         cv.Reset()
-        self.assertRaises(ArgumentError, lambda: cv[:])
+        with self.assertRaises(ArgumentError):
+            cv[:]
 
     @unittest.skip("This test takes a long time.  Do we need it? Can it be rewritten?")
     def test_leaks_1(self):
@@ -151,10 +152,12 @@ class TestCollectionInterface(unittest.TestCase):
         self.assertAccessInterface(d)
 
     def test_named_property_no_length(self):
-        self.assertRaises(TypeError, len, self.d.Item)
+        with self.assertRaises(TypeError):
+            len(self.d.Item)
 
     def test_named_property_not_iterable(self):
-        self.assertRaises(TypeError, list, self.d.Item)
+        with self.assertRaises(TypeError):
+            list(self.d.Item)
 
 
 if __name__ == "__main__":

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_comobject.py

@@ -4,9 +4,10 @@ from ctypes import POINTER, byref, pointer
 from unittest import mock
 
 import comtypes.client
-from comtypes import CLSCTX_SERVER, COMObject, IUnknown, hresult
+from comtypes import CLSCTX_SERVER, COMObject, IPersist, IUnknown, hresult
 from comtypes._post_coinit.misc import _CoCreateInstance
 from comtypes.automation import IDispatch
+from comtypes.typeinfo import GUIDKIND_DEFAULT_SOURCE_DISP_IID
 
 comtypes.client.GetModule("UIAutomationCore.dll")
 comtypes.client.GetModule("scrrun.dll")
@@ -131,11 +132,9 @@ class Test_IProvideClassInfo_GetClassInfo(ut.TestCase):
 
 class Test_IProvideClassInfo2_GetGUID(ut.TestCase):
     def test(self):
-        # GUIDKIND_DEFAULT_SOURCE_DISP_IID = 1
-        self.assertEqual(
-            stdole.StdFont().IProvideClassInfo2_GetGUID(1),
-            stdole.FontEvents._iid_,
-        )
+        obj = stdole.StdFont()
+        actual = obj.IProvideClassInfo2_GetGUID(GUIDKIND_DEFAULT_SOURCE_DISP_IID)
+        self.assertEqual(actual, stdole.FontEvents._iid_)
 
 
 class Test_IPersist_GetClassID(ut.TestCase):
@@ -144,3 +143,17 @@ class Test_IPersist_GetClassID(ut.TestCase):
             uiac.CUIAutomation().IPersist_GetClassID(),
             uiac.CUIAutomation._reg_clsid_,
         )
+
+
+class Test_Vtbl(ut.TestCase):
+    def test_com_pointers(self):
+        stdpic = stdole.StdPicture()
+        cuia = uiac.CUIAutomation()
+        self.assertIs(
+            type(stdpic._com_pointers_[IPersist._iid_]),
+            type(cuia._com_pointers_[IPersist._iid_]),
+        )
+        self.assertIn(IDispatch._iid_, stdpic._com_pointers_)
+        self.assertNotIn(IDispatch._iid_, cuia._com_pointers_)
+        self.assertIn(stdole.IPictureDisp._iid_, stdpic._com_pointers_)
+        self.assertIn(uiac.IUIAutomation._iid_, cuia._com_pointers_)

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_comserver.py

@@ -5,7 +5,7 @@ from typing import Any
 
 import comtypes.server
 import comtypes.test.TestComServer
-from comtypes import BSTR
+from comtypes import BSTR, errorinfo, hresult, shelllink
 from comtypes.automation import VARIANT, _midlSAFEARRAY
 from comtypes.client import CreateObject, GetActiveObject
 from comtypes.server.register import register, unregister
@@ -201,6 +201,26 @@ class ActiveObjTest(unittest.TestCase):
         self._doit(weak=False)
 
 
+class SupportErrorInfoTest(unittest.TestCase):
+    def create_object(self):
+        return CreateObject(
+            comtypes.test.TestComServer.TestComServer,
+            interface=comtypes.test.TestComServer.ITestComServer,
+        )
+
+    def test_returns_S_OK(self):
+        psei = self.create_object().QueryInterface(errorinfo.ISupportErrorInfo)
+        iid = comtypes.test.TestComServer.ITestComServer._iid_
+        hr = psei.InterfaceSupportsErrorInfo(iid)
+        self.assertEqual(hr, hresult.S_OK)
+
+    def test_returns_S_FALSE(self):
+        psei = self.create_object().QueryInterface(errorinfo.ISupportErrorInfo)
+        iid = shelllink.IShellLinkW._iid_
+        hr = psei.InterfaceSupportsErrorInfo(iid)
+        self.assertEqual(hr, hresult.S_FALSE)
+
+
 class VariantTest(unittest.TestCase):
     def test_UDT(self):
         from comtypes.gen.TestComServerLib import MYCOLOR
@@ -277,7 +297,10 @@ class TestEvents(unittest.TestCase):
         import comtypes.test.test_comserver
 
         doctest.testmod(
-            comtypes.test.test_comserver, verbose=False, optionflags=doctest.ELLIPSIS
+            comtypes.test.test_comserver,
+            verbose=False,
+            optionflags=doctest.ELLIPSIS,
+            raise_on_error=True,
         )
 
 

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_dict.py

@@ -14,7 +14,8 @@ class Test(unittest.TestCase):
 
         # Count is a normal propget, no propput
         self.assertEqual(d.Count, 0)
-        self.assertRaises(AttributeError, lambda: setattr(d, "Count", -1))
+        with self.assertRaises(AttributeError):
+            setattr(d, "Count", -1)
 
         # HashVal is a 'named' propget, no propput
         ##d.HashVal

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_dyndispatch.py

@@ -66,10 +66,12 @@ class Test(unittest.TestCase):
         self.assertEqual(d3.Item["baz"], 3.14)
 
     def test_named_property_no_length(self):
-        self.assertRaises(TypeError, len, self.d.Item)
+        with self.assertRaises(TypeError):
+            len(self.d.Item)
 
     def test_named_property_not_iterable(self):
-        self.assertRaises(TypeError, list, self.d.Item)
+        with self.assertRaises(TypeError):
+            list(self.d.Item)
 
     def assertAccessInterface(self, d):
         """Asserts access via indexing and named property"""