comtypes 1.4.8__zip → 1.4.9__zip

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/client/_generate.py

@@ -139,20 +139,16 @@ def _load_tlib(obj: Any) -> typeinfo.ITypeLib:
     elif isinstance(obj, GUID):
         clsid = str(obj)
         # lookup associated typelib in registry
-        with winreg.OpenKey(
-            winreg.HKEY_CLASSES_ROOT, r"CLSID\%s\TypeLib" % clsid
-        ) as key:
+        with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"CLSID\{clsid}\TypeLib") as key:
             libid = winreg.EnumValue(key, 0)[1]
-        with winreg.OpenKey(
-            winreg.HKEY_CLASSES_ROOT, r"CLSID\%s\Version" % clsid
-        ) as key:
+        with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"CLSID\{clsid}\Version") as key:
             ver = winreg.EnumValue(key, 0)[1].split(".")
         return typeinfo.LoadRegTypeLib(GUID(libid), int(ver[0]), int(ver[1]), 0)
     # obj is a sequence containing libid
     elif isinstance(obj, (tuple, list)):
         libid, ver = obj[0], obj[1:]
         if not ver:  # case of version numbers are not containing
-            with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"TypeLib\%s" % libid) as key:
+            with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"TypeLib\{libid}") as key:
                 ver = [int(v, base=16) for v in winreg.EnumKey(key, 0).split(".")]
         return typeinfo.LoadRegTypeLib(GUID(libid), *ver)
     # obj is a COMObject implementation
@@ -161,7 +157,7 @@ def _load_tlib(obj: Any) -> typeinfo.ITypeLib:
     # obj is a pointer of ITypeLib
     elif isinstance(obj, ctypes.POINTER(typeinfo.ITypeLib)):
         return obj  # type: ignore
-    raise TypeError("'%r' is not supported type for loading typelib" % obj)
+    raise TypeError(f"'{obj!r}' is not supported type for loading typelib")
 
 
 def _get_existing_module(tlib: typeinfo.ITypeLib) -> Optional[types.ModuleType]:

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/client/lazybind.py

@@ -67,7 +67,7 @@ class NamedProperty(object):
 
     def __iter__(self):
         """Explicitly disallow iteration."""
-        msg = "%r is not iterable" % self.disp
+        msg = f"{self.disp!r} is not iterable"
         raise TypeError(msg)
 
 
@@ -151,7 +151,7 @@ class Dispatch(object):
                 if descr.cParams == 1:
                     return self._comobj._invoke(descr.memid, descr.invkind, 0)
             else:
-                raise RuntimeError("funckind %d not yet implemented" % descr.funckind)
+                raise RuntimeError(f"funckind {descr.funckind:d} not yet implemented")
             put = self.__bind(name, DISPATCH_PROPERTYPUT)
             putref = self.__bind(name, DISPATCH_PROPERTYPUTREF)
             return NamedProperty(self, descr, put, putref)

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

@@ -1,10 +1,10 @@
 import sys
 from ctypes import *
+from ctypes.wintypes import DWORD
 from comtypes import IUnknown, HRESULT, COMMETHOD, GUID, BSTR
 from comtypes.hresult import *
 
 LPCOLESTR = c_wchar_p
-DWORD = c_ulong
 
 
 class ICreateErrorInfo(IUnknown):
@@ -103,9 +103,9 @@ def ReportException(
             tb = tb.tb_next
         line = tb.tb_frame.f_lineno
         name = tb.tb_frame.f_globals["__name__"]
-        text = "%s: %s (%s, line %d)" % (typ, value, name, line)
+        text = f"{typ}: {value} ({name}, line {line:d})"
     else:
-        text = "%s: %s" % (typ, value)
+        text = f"{typ}: {value}"
     return ReportError(
         text,
         iid,

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

@@ -5,6 +5,7 @@ between different threading appartments.
 """
 
 from ctypes import *
+from ctypes.wintypes import DWORD
 from comtypes import (
     IUnknown,
     STDMETHOD,
@@ -15,8 +16,6 @@ from comtypes import (
     CLSCTX_INPROC_SERVER,
 )
 
-DWORD = c_ulong
-
 
 class IGlobalInterfaceTable(IUnknown):
     _iid_ = GUID("{00000146-0000-0000-C000-000000000046}")

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

@@ -3,17 +3,11 @@
 # - utilities for type hints.
 import ctypes
 import sys
-from typing import Any as Any, ClassVar, Generic, NoReturn, TypeVar, overload
+from typing import Any as Any, ClassVar, Generic, NoReturn, Protocol, TypeVar, overload
 from typing import Optional, Union as _UnionT
-from typing import List, Tuple as Tuple, Type
+from typing import Tuple as Tuple, Type
 from typing import Callable, Iterator, Sequence
 
-if sys.version_info >= (3, 8):
-    from typing import Protocol
-    from typing import Literal as Literal
-else:
-    from typing_extensions import Protocol
-    from typing_extensions import Literal as Literal
 if sys.version_info >= (3, 9):
     from typing import Annotated as Annotated
 else:
@@ -30,10 +24,11 @@ else:
     from typing_extensions import Self as Self
 
 import comtypes
-from comtypes import IUnknown as IUnknown, GUID as GUID
+from comtypes import IUnknown as IUnknown, COMObject as COMObject, GUID as GUID
 from comtypes.automation import IDispatch as IDispatch, VARIANT as VARIANT
 from comtypes.server import IClassFactory as IClassFactory
-from comtypes.typeinfo import ITypeInfo as ITypeInfo
+from comtypes.server import localserver as localserver
+from comtypes.typeinfo import ITypeInfo as ITypeInfo, ITypeLib as ITypeLib
 from comtypes._safearray import tagSAFEARRAY as tagSAFEARRAY
 
 Incomplete: TypeAlias = Any
@@ -74,6 +69,8 @@ class LP_SAFEARRAY(ctypes._Pointer[tagSAFEARRAY], Generic[_CT]):
     def unpack(self: LP_SAFEARRAY[_T_Struct]) -> Sequence[_T_Struct]: ...
     @overload
     def unpack(self) -> Sequence[Any]: ...
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self: ...
 
 _T_coclass = TypeVar("_T_coclass", bound=comtypes.CoClass)
 
@@ -85,11 +82,6 @@ class FirstComItfOf(Generic[_T_coclass]):
     as an argument.
     """
 
-class _MethodTypeDesc(Protocol):
-    arguments: List[Tuple[Any, str, List[str], Optional[Any]]]
-    idlflags: List[str]
-    name: str
-
 _P_Put = ParamSpec("_P_Put")
 _R_Put = TypeVar("_R_Put")
 _P_PutRef = ParamSpec("_P_PutRef")

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/safearray.py

@@ -78,6 +78,7 @@ def _make_safearray_type(itemtype):
         VT_UNKNOWN,
         IDispatch,
         VT_DISPATCH,
+        VT_HRESULT,
     )
 
     meta = type(_safearray.tagSAFEARRAY)
@@ -123,6 +124,15 @@ def _make_safearray_type(itemtype):
             one-dimensional arrays.  To create multidimensional arrys,
             numpy arrays must be passed.
             """
+            if cls._vartype_ == VT_HRESULT:
+                raise TypeError(
+                    # There are COM type libraries that define the
+                    # `_midlSAFEARRAY(HRESULT)` type; however, creating `HRESULT`
+                    # safearray pointer instance does not work.
+                    # See also: https://github.com/enthought/comtypes/issues/668
+                    "Cannot create SAFEARRAY type VT_HRESULT."
+                )
+
             if comtypes.npsupport.isndarray(value):
                 return cls.create_from_ndarray(value, extra)
 

comtypes-1.4.9/comtypes/server/__init__.py

@@ -0,0 +1,86 @@
+import ctypes
+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.automation import IDispatch
+
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+
+    from comtypes import hints  # type: ignore
+
+
+################################################################
+# Interfaces
+class IClassFactory(IUnknown):
+    _iid_ = GUID("{00000001-0000-0000-C000-000000000046}")
+    _methods_ = [
+        STDMETHOD(
+            HRESULT,
+            "CreateInstance",
+            [POINTER(IUnknown), POINTER(GUID), POINTER(ctypes.c_void_p)],
+        ),
+        STDMETHOD(HRESULT, "LockServer", [ctypes.c_int]),
+    ]
+
+    def CreateInstance(
+        self,
+        punkouter: Optional[Type["_Pointer[IUnknown]"]] = None,
+        interface: Optional[Type[IUnknown]] = None,
+        dynamic: bool = False,
+    ) -> Any:
+        if dynamic:
+            if interface is not None:
+                raise ValueError("interface and dynamic are mutually exclusive")
+            itf = IDispatch
+        elif interface is None:
+            itf = IUnknown
+        else:
+            itf = interface
+        obj = POINTER(itf)()
+        self.__com_CreateInstance(punkouter, itf._iid_, byref(obj))  # type: ignore
+        if dynamic:
+            return comtypes.client.dynamic.Dispatch(obj)
+        elif interface is None:
+            # An interface was not specified, so return the best.
+            return comtypes.client.GetBestInterface(obj)
+        # An interface was specified and obj is already that interface.
+        return obj
+
+    if TYPE_CHECKING:
+
+        def LockServer(self, fLock: int) -> hints.Hresult: ...
+
+
+# class IExternalConnection(IUnknown):
+#     _iid_ = GUID("{00000019-0000-0000-C000-000000000046}")
+#     _methods_ = [
+#         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 = ctypes.oledll.oleaut32
+
+
+def RegisterActiveObject(comobj: comtypes.COMObject, weak: bool = True) -> int:
+    punk = comobj._com_pointers_[IUnknown._iid_]
+    clsid = comobj._reg_clsid_
+    if weak:
+        flags = ACTIVEOBJECT_WEAK
+    else:
+        flags = ACTIVEOBJECT_STRONG
+    handle = ctypes.c_ulong()
+    oleaut32.RegisterActiveObject(punk, byref(clsid), flags, byref(handle))
+    return handle.value
+
+
+def RevokeActiveObject(handle: int) -> None:
+    oleaut32.RevokeActiveObject(handle, None)

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

@@ -1,12 +1,11 @@
 import ctypes
-from comtypes import COMObject, GUID
-from comtypes.server import IClassFactory
-from comtypes.hresult import *
-
-import sys
 import logging
+import sys
 import winreg
+from typing import Any, Literal, Optional, Type
 
+from comtypes import GUID, COMObject, IUnknown, hresult
+from comtypes.server import IClassFactory
 
 logger = logging.getLogger(__name__)
 _debug = logger.debug
@@ -18,33 +17,39 @@ _critical = logger.critical
 class ClassFactory(COMObject):
     _com_interfaces_ = [IClassFactory]
 
-    def __init__(self, cls):
+    def __init__(self, cls: Type[COMObject]) -> None:
         super(ClassFactory, self).__init__()
         self._cls = cls
 
-    def IClassFactory_CreateInstance(self, this, punkOuter, riid, ppv):
+    def IClassFactory_CreateInstance(
+        self,
+        this: Any,
+        punkOuter: Optional[Type["ctypes._Pointer[IUnknown]"]],
+        riid: "ctypes._Pointer[GUID]",
+        ppv: ctypes.c_void_p,
+    ) -> int:
         _debug("ClassFactory.CreateInstance(%s)", riid[0])
         result = self._cls().IUnknown_QueryInterface(None, riid, ppv)
         _debug("CreateInstance() -> %s", result)
         return result
 
-    def IClassFactory_LockServer(self, this, fLock):
+    def IClassFactory_LockServer(self, this: Any, fLock: bool) -> Literal[0]:
         if fLock:
             COMObject.__server__.Lock()
         else:
             COMObject.__server__.Unlock()
-        return S_OK
+        return hresult.S_OK
 
 
 # will be set by py2exe boot script 'from outside'
 _clsid_to_class = {}
 
 
-def inproc_find_class(clsid):
+def inproc_find_class(clsid: GUID) -> Type[COMObject]:
     if _clsid_to_class:
         return _clsid_to_class[clsid]
 
-    key = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, "CLSID\\%s\\InprocServer32" % clsid)
+    key = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, f"CLSID\\{clsid}\\InprocServer32")
     try:
         pathdir = winreg.QueryValueEx(key, "PythonPath")[0]
     except:
@@ -70,7 +75,7 @@ def inproc_find_class(clsid):
 _logging_configured = False
 
 
-def _setup_logging(clsid):
+def _setup_logging(clsid: GUID) -> None:
     """Read from the registry, and configure the logging module.
 
     Currently, the handler (NTDebugHandler) is hardcoded.
@@ -109,7 +114,7 @@ def _setup_logging(clsid):
         logging.getLogger(name).setLevel(level)
 
 
-def DllGetClassObject(rclsid, riid, ppv):
+def DllGetClassObject(rclsid: int, riid: int, ppv: int) -> int:
     COMObject.__run_inprocserver__()
 
     iid = GUID.from_address(riid)
@@ -127,7 +132,7 @@ def DllGetClassObject(rclsid, riid, ppv):
 
         cls = inproc_find_class(clsid)
         if not cls:
-            return CLASS_E_CLASSNOTAVAILABLE
+            return hresult.CLASS_E_CLASSNOTAVAILABLE
 
         result = ClassFactory(cls).IUnknown_QueryInterface(
             None, ctypes.pointer(iid), ctypes.c_void_p(ppv)
@@ -136,12 +141,12 @@ def DllGetClassObject(rclsid, riid, ppv):
         return result
     except Exception:
         _critical("DllGetClassObject", exc_info=True)
-        return E_FAIL
+        return hresult.E_FAIL
 
 
-def DllCanUnloadNow():
+def DllCanUnloadNow() -> Literal[1]:  # S_FALSE
     COMObject.__run_inprocserver__()
     result = COMObject.__server__.DllCanUnloadNow()
     # To avoid a memory leak when PyInitialize()/PyUninitialize() are
     # called several times, we refuse to unload the dll.
-    return S_FALSE
+    return hresult.S_FALSE

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

@@ -1,10 +1,16 @@
+import logging
+import queue
 import sys
-from ctypes import *
+from ctypes import byref, c_ulong, c_void_p, oledll
+from typing import TYPE_CHECKING, Any, Literal, Optional, Sequence, Type
+
 import comtypes
-from comtypes.hresult import *
+from comtypes import hresult
 from comtypes.server import IClassFactory
-import logging
-import queue
+
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+
 
 logger = logging.getLogger(__name__)
 _debug = logger.debug
@@ -16,31 +22,31 @@ REGCLS_SUSPENDED = 4  # register it as suspended, will be activated
 REGCLS_SURROGATE = 8  # must be used when a surrogate process
 
 
-def run(classes):
+def run(classes: Sequence[Type[comtypes.COMObject]]) -> None:
     classobjects = [ClassFactory(cls) for cls in classes]
     comtypes.COMObject.__run_localserver__(classobjects)
 
 
 class ClassFactory(comtypes.COMObject):
     _com_interfaces_ = [IClassFactory]
-    _locks = 0
-    _queue = None
-    regcls = REGCLS_MULTIPLEUSE
+    _locks: int = 0
+    _queue: Optional[queue.Queue] = None
+    regcls: int = REGCLS_MULTIPLEUSE
 
-    def __init__(self, cls, *args, **kw):
+    def __init__(self, cls: Type[comtypes.COMObject], *args, **kw) -> None:
         super(ClassFactory, self).__init__()
         self._cls = cls
         self._register_class()
         self._args = args
         self._kw = kw
 
-    def IUnknown_AddRef(self, this):
+    def IUnknown_AddRef(self, this: Any) -> int:
         return 2
 
-    def IUnknown_Release(self, this):
+    def IUnknown_Release(self, this: Any) -> int:
         return 1
 
-    def _register_class(self):
+    def _register_class(self) -> None:
         regcls = getattr(self._cls, "_regcls_", self.regcls)
         cookie = c_ulong()
         ptr = self._com_pointers_[comtypes.IUnknown._iid_]
@@ -55,19 +61,25 @@ class ClassFactory(comtypes.COMObject):
         )
         self.cookie = cookie
 
-    def _revoke_class(self):
+    def _revoke_class(self) -> None:
         oledll.ole32.CoRevokeClassObject(self.cookie)
 
-    def CreateInstance(self, this, punkOuter, riid, ppv):
+    def CreateInstance(
+        self,
+        this: Any,
+        punkOuter: Optional[Type["_Pointer[comtypes.IUnknown]"]],
+        riid: "_Pointer[comtypes.GUID]",
+        ppv: c_void_p,
+    ) -> int:
         _debug("ClassFactory.CreateInstance(%s)", riid[0])
         obj = self._cls(*self._args, **self._kw)
         result = obj.IUnknown_QueryInterface(None, riid, ppv)
         _debug("CreateInstance() -> %s", result)
         return result
 
-    def LockServer(self, this, fLock):
+    def LockServer(self, this: Any, fLock: bool) -> Literal[0]:
         if fLock:
             comtypes.COMObject.__server__.Lock()
         else:
             comtypes.COMObject.__server__.Unlock()
-        return S_OK
+        return hresult.S_OK