comtypes 1.4.8__zip → 1.4.10__zip

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/_memberspec.py

@@ -1,12 +1,20 @@
 import ctypes
-from typing import Any, NamedTuple
-from typing import Dict, List, Tuple, Type
-from typing import Optional, Union as _UnionT
-from typing import Callable, Iterator
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Literal,
+    NamedTuple,
+    Optional,
+    Tuple,
+    Type,
+)
+from typing import Union as _UnionT
 
-from comtypes import _CData
 import comtypes
-
+from comtypes import _CData
 
 _PositionalParamFlagType = Tuple[int, Optional[str]]
 _OptionalParamFlagType = Tuple[int, Optional[str], Any]
@@ -64,7 +72,7 @@ def _resolve_argspec(
                 elif typ is ctypes.POINTER(VARIANT):
                     defval = ctypes.pointer(VARIANT.missing)
                 else:
-                    # msg = ("'optional' only allowed for VARIANT and VARIANT*, not for %s" % typ.__name__)
+                    # msg = f"'optional' only allowed for VARIANT and VARIANT*, not for {typ.__name__}"
                     # warnings.warn(msg, IDLWarning, stacklevel=2)
                     defval = typ()
         if defval is _NOTHING:
@@ -92,7 +100,7 @@ class _ComMemberSpec(NamedTuple):
 class _DispMemberSpec(NamedTuple):
     """Specifier for a slot of dispinterface method or property."""
 
-    what: str
+    what: Literal["DISPMETHOD", "DISPPROPERTY"]
     name: str
     idlflags: Tuple[_UnionT[str, int], ...]
     restype: Optional[Type[_CData]]
@@ -118,6 +126,78 @@ def _is_spec_prop(m: _MemberSpec):
     return any(f in ("propget", "propput", "propputref") for f in m.idlflags)
 
 
+################################################################
+# IDL stuff
+
+
+class helpstring(str):
+    "Specifies the helpstring for a COM method or property."
+
+
+class defaultvalue(object):
+    "Specifies the default value for parameters marked optional."
+
+    def __init__(self, value):
+        self.value = value
+
+
+class dispid(int):
+    "Specifies the DISPID of a method or property."
+
+
+# XXX STDMETHOD, COMMETHOD, DISPMETHOD, and DISPPROPERTY should return
+# instances with more methods or properties, and should not behave as an unpackable.
+
+
+def STDMETHOD(restype, name, argtypes=()) -> _ComMemberSpec:
+    "Specifies a COM method slot without idlflags"
+    return _ComMemberSpec(restype, name, argtypes, None, (), None)
+
+
+def DISPMETHOD(idlflags, restype, name, *argspec) -> _DispMemberSpec:
+    "Specifies a method of a dispinterface"
+    return _DispMemberSpec("DISPMETHOD", name, tuple(idlflags), restype, argspec)
+
+
+def DISPPROPERTY(idlflags, proptype, name) -> _DispMemberSpec:
+    "Specifies a property of a dispinterface"
+    return _DispMemberSpec("DISPPROPERTY", name, tuple(idlflags), proptype, ())
+
+
+# tuple(idlflags) is for the method itself: (dispid, 'readonly')
+
+# sample generated code:
+#     DISPPROPERTY([5, 'readonly'], OLE_YSIZE_HIMETRIC, 'Height'),
+#     DISPMETHOD(
+#         [6], None, 'Render', ([], c_int, 'hdc'), ([], c_int, 'x'), ([], c_int, 'y')
+#     )
+
+
+def COMMETHOD(idlflags, restype, methodname, *argspec) -> _ComMemberSpec:
+    """Specifies a COM method slot with idlflags.
+
+    XXX should explain the sematics of the arguments.
+    """
+    # collect all helpstring instances
+    # We should suppress docstrings when Python is started with -OO
+    # join them together(does this make sense?) and replace by None if empty.
+    helptext = "".join(t for t in idlflags if isinstance(t, helpstring)) or None
+    paramflags, argtypes = _resolve_argspec(argspec)
+    if "propget" in idlflags:
+        name = f"_get_{methodname}"
+    elif "propput" in idlflags:
+        name = f"_set_{methodname}"
+    elif "propputref" in idlflags:
+        name = f"_setref_{methodname}"
+    else:
+        name = methodname
+    return _ComMemberSpec(
+        restype, name, argtypes, paramflags, tuple(idlflags), helptext
+    )
+
+
+################################################################
+
 _PropFunc = Optional[Callable[..., Any]]
 _DocType = Optional[str]
 
@@ -310,7 +390,7 @@ class PropertyGenerator(object):
                 # Hm, must be a descriptor where the __get__ method
                 # returns a bound object having __getitem__ and
                 # __setitem__ methods.
-                prop = named_property("%s.%s" % (self._cls_name, name), fget, fset, doc)
+                prop = named_property(f"{self._cls_name}.{name}", fget, fset, doc)
             yield (name, prop)
 
     def to_propget_keys(self, m: _MemberSpec) -> Tuple[str, _DocType, int]:
@@ -360,7 +440,7 @@ class DispPropertyGenerator(PropertyGenerator):
 
 
 class ComMemberGenerator(object):
-    def __init__(self, cls_name: str, vtbl_offset: int, iid: comtypes.GUID) -> None:
+    def __init__(self, cls_name: str, vtbl_offset: int, iid: "comtypes.GUID") -> None:
         self._vtbl_offset = vtbl_offset
         self._iid = iid
         self._props = ComPropertyGenerator(cls_name)
@@ -533,11 +613,11 @@ class bound_named_property(object):
             self.fset(self.instance, index, value)
 
     def __repr__(self):
-        return "<bound_named_property %r at %x>" % (self.name, id(self))
+        return f"<bound_named_property {self.name!r} at {id(self):x}>"
 
     def __iter__(self):
         """Explicitly disallow iteration."""
-        msg = "%r is not iterable" % self.name
+        msg = f"{self.name!r} is not iterable"
         raise TypeError(msg)
 
 
@@ -558,4 +638,4 @@ class named_property(object):
         raise AttributeError("Unsettable attribute")
 
     def __repr__(self):
-        return "<named_property %r at %x>" % (self.name, id(self))
+        return f"<named_property {self.name!r} at {id(self):x}>"

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/_meta.py

@@ -1,5 +1,6 @@
 # comtypes._meta helper module
 from ctypes import POINTER, c_void_p, cast
+
 import comtypes
 
 ################################################################

comtypes-1.4.10/comtypes/_post_coinit/_cominterface_meta_patcher.py

@@ -0,0 +1,152 @@
+import types
+from _ctypes import COMError
+from typing import Type
+
+from comtypes import patcher
+
+_all_slice = slice(None, None, None)
+
+
+def case_insensitive(p: Type) -> None:
+    @patcher.Patch(p)
+    class CaseInsensitive(object):
+        # case insensitive attributes for COM methods and properties
+        def __getattr__(self, name):
+            """Implement case insensitive access to methods and properties"""
+            try:
+                fixed_name = self.__map_case__[name.lower()]
+            except KeyError:
+                raise AttributeError(name)  # Should we use exception-chaining?
+            if fixed_name != name:  # prevent unbounded recursion
+                return getattr(self, fixed_name)
+            raise AttributeError(name)
+
+        # __setattr__ is pretty heavy-weight, because it is called for
+        # EVERY attribute assignment.  Settings a non-com attribute
+        # through this function takes 8.6 usec, while without this
+        # function it takes 0.7 sec - 12 times slower.
+        #
+        # How much faster would this be if implemented in C?
+        def __setattr__(self, name, value):
+            """Implement case insensitive access to methods and properties"""
+            object.__setattr__(self, self.__map_case__.get(name.lower(), name), value)
+
+
+def reference_fix(pp: Type) -> None:
+    @patcher.Patch(pp)
+    class ReferenceFix(object):
+        def __setitem__(self, index, value):
+            # We override the __setitem__ method of the
+            # POINTER(POINTER(interface)) type, so that the COM
+            # reference count is managed correctly.
+            #
+            # This is so that we can implement COM methods that have to
+            # return COM pointers more easily and consistent.  Instead of
+            # using CopyComPointer in the method implementation, we can
+            # simply do:
+            #
+            # def GetTypeInfo(self, this, ..., pptinfo):
+            #     if not pptinfo: return E_POINTER
+            #     pptinfo[0] = a_com_interface_pointer
+            #     return S_OK
+            if index != 0:
+                # CopyComPointer, which is in _ctypes, does only
+                # handle an index of 0.  This code does what
+                # CopyComPointer should do if index != 0.
+                if bool(value):
+                    value.AddRef()
+                super(pp, self).__setitem__(index, value)  # type: ignore
+                return
+            from _ctypes import CopyComPointer
+
+            CopyComPointer(value, self)  # type: ignore
+
+
+def sized(itf: Type) -> None:
+    @patcher.Patch(itf)
+    class _(object):
+        def __len__(self):
+            "Return the the 'self.Count' property."
+            return self.Count
+
+
+def callable_and_subscriptable(itf: Type) -> None:
+    @patcher.Patch(itf)
+    class _(object):
+        # 'Item' is the 'default' value.  Make it available by
+        # calling the instance (Not sure this makes sense, but
+        # win32com does this also).
+        def __call__(self, *args, **kw):
+            "Return 'self.Item(*args, **kw)'"
+            return self.Item(*args, **kw)
+
+        # does this make sense? It seems that all standard typelibs I've
+        # seen so far that support .Item also support ._NewEnum
+        @patcher.no_replace
+        def __getitem__(self, index):
+            "Return 'self.Item(index)'"
+            # Handle tuples and all-slice
+            if isinstance(index, tuple):
+                args = index
+            elif index == _all_slice:
+                args = ()
+            else:
+                args = (index,)
+
+            try:
+                result = self.Item(*args)
+            except COMError as err:
+                (hresult, text, details) = err.args
+                if hresult == -2147352565:  # DISP_E_BADINDEX
+                    raise IndexError("invalid index")
+                else:
+                    raise
+
+            # Note that result may be NULL COM pointer. There is no way
+            # to interpret this properly, so it is returned as-is.
+
+            # Hm, should we call __ctypes_from_outparam__ on the
+            # result?
+            return result
+
+        @patcher.no_replace
+        def __setitem__(self, index, value):
+            "Attempt 'self.Item[index] = value'"
+            try:
+                self.Item[index] = value
+            except COMError as err:
+                (hresult, text, details) = err.args
+                if hresult == -2147352565:  # DISP_E_BADINDEX
+                    raise IndexError("invalid index")
+                else:
+                    raise
+            except TypeError:
+                msg = f"{type(self)!r} object does not support item assignment"
+                raise TypeError(msg)
+
+
+def iterator(itf: Type) -> None:
+    @patcher.Patch(itf)
+    class _(object):
+        def __iter__(self):
+            "Return an iterator over the _NewEnum collection."
+            # This method returns a pointer to _some_ _NewEnum interface.
+            # It relies on the fact that the code generator creates next()
+            # methods for them automatically.
+            #
+            # Better would maybe to return an object that
+            # implements the Python iterator protocol, and
+            # forwards the calls to the COM interface.
+            enum = self._NewEnum
+            if isinstance(enum, types.MethodType):
+                # _NewEnum should be a propget property, with dispid -4.
+                #
+                # Sometimes, however, it is a method.
+                enum = enum()
+            if hasattr(enum, "Next"):
+                return enum
+            # _NewEnum returns an IUnknown pointer, QueryInterface() it to
+            # IEnumVARIANT
+            from comtypes.automation import IEnumVARIANT
+
+            return enum.QueryInterface(IEnumVARIANT)

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/_post_coinit/bstr.py

@@ -1,10 +1,15 @@
-from ctypes import _SimpleCData, windll
-from typing import Any, Callable, TYPE_CHECKING
+from ctypes import WinDLL, _SimpleCData
+from typing import TYPE_CHECKING, Any, Callable
 
 if TYPE_CHECKING:
     from comtypes import hints  # type: ignore
 
 
+_oleaut32 = WinDLL("oleaut32")
+
+_SysFreeString = _oleaut32.SysFreeString
+
+
 class BSTR(_SimpleCData):
     """The windows BSTR data type"""
 
@@ -18,9 +23,7 @@ class BSTR(_SimpleCData):
         self._needsfree = True
         return self.value
 
-    def __del__(
-        self, _free: Callable[["BSTR"], Any] = windll.oleaut32.SysFreeString
-    ) -> None:
+    def __del__(self, _free: Callable[["BSTR"], Any] = _SysFreeString) -> None:
         # Free the string if self owns the memory
         # or if instructed by __ctypes_from_outparam__.
         if self._b_base_ is None or self._needsfree:
@@ -35,3 +38,7 @@ class BSTR(_SimpleCData):
         # right thing, it doesn't ensure that SysFreeString is called
         # on destruction.
         return cls(value)
+
+
+_SysFreeString.argtypes = [BSTR]
+_SysFreeString.restype = None

comtypes-1.4.8/comtypes/_py_instance_method.py → comtypes-1.4.10/comtypes/_post_coinit/instancemethod.py

@@ -1,5 +1,4 @@
-from ctypes import pythonapi, py_object
-
+from ctypes import py_object, pythonapi
 
 pythonapi.PyInstanceMethod_New.argtypes = [py_object]
 pythonapi.PyInstanceMethod_New.restype = py_object

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/_post_coinit/misc.py

@@ -1,26 +1,28 @@
-from ctypes import c_ulong, c_ushort, c_void_p, c_wchar_p, HRESULT, Structure
-from ctypes import byref, cast, _Pointer, POINTER, pointer
-
-# fmt: off
-from typing import (  # noqa
-    Any, overload, TYPE_CHECKING, TypeVar,
-    # instead of `builtins`. see PEP585
-    Type,
-    # instead of `collections.abc`. see PEP585
-    Callable,
-    # instead of `A | B` and `None | A`. see PEP604
-    Optional,
+from ctypes import (
+    HRESULT,
+    POINTER,
+    OleDLL,
+    Structure,
+    byref,
+    c_ulong,
+    c_ushort,
+    c_void_p,
+    c_wchar_p,
+    cast,
+    pointer,
 )
-# fmt: on
-if TYPE_CHECKING:
-    from comtypes import hints as hints  # noqa  # type: ignore
+from ctypes.wintypes import DWORD, LPCWSTR, LPVOID
+from typing import TYPE_CHECKING, Any, Callable, Optional, Type, TypeVar, overload
 
-from comtypes import GUID
-from comtypes._idl_stuff import COMMETHOD  # noqa
-from comtypes import CLSCTX_SERVER, CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER
-from comtypes import _ole32, oledll, DWORD
+from comtypes import CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER, CLSCTX_SERVER, GUID
+from comtypes._memberspec import COMMETHOD
 from comtypes._post_coinit.unknwn import IUnknown
 
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+
+    from comtypes import hints as hints  # noqa  # type: ignore
+
 
 def _is_object(obj):
     """This function determines if the argument is a COM object.  It
@@ -98,7 +100,7 @@ def CoGetObject(displayname: str, interface: Optional[Type[IUnknown]]) -> IUnkno
         interface = IUnknown
     punk = POINTER(interface)()
     # Do we need a way to specify the BIND_OPTS parameter?
-    _ole32.CoGetObject(str(displayname), None, byref(interface._iid_), byref(punk))
+    _CoGetObject(str(displayname), None, byref(interface._iid_), byref(punk))
     return punk  # type: ignore
 
 
@@ -134,7 +136,7 @@ def CoCreateInstance(
         interface = IUnknown
     p = POINTER(interface)()
     iid = interface._iid_
-    _ole32.CoCreateInstance(byref(clsid), punkouter, clsctx, byref(iid), byref(p))
+    _CoCreateInstance(byref(clsid), punkouter, clsctx, byref(iid), byref(p))
     return p  # type: ignore
 
 
@@ -178,7 +180,7 @@ def GetActiveObject(
 ) -> IUnknown:
     """Retrieves a pointer to a running object"""
     p = POINTER(IUnknown)()
-    oledll.oleaut32.GetActiveObject(byref(clsid), None, byref(p))
+    _GetActiveObject(byref(clsid), None, byref(p))
     if interface is not None:
         p = p.QueryInterface(interface)  # type: ignore
     return p  # type: ignore
@@ -236,6 +238,16 @@ class _COSERVERINFO(Structure):
         dwReserved2: int
 
 
+_oleaut32 = OleDLL("oleaut32")
+
+REFCLSID = POINTER(GUID)
+_GetActiveObject = _oleaut32.GetActiveObject
+_GetActiveObject.argtypes = [REFCLSID, LPVOID, POINTER(POINTER(IUnknown))]
+_GetActiveObject.restype = HRESULT
+
+
+_ole32 = OleDLL("ole32")
+
 COSERVERINFO = _COSERVERINFO
 _CoGetClassObject = _ole32.CoGetClassObject
 _CoGetClassObject.argtypes = [
@@ -245,6 +257,28 @@ _CoGetClassObject.argtypes = [
     POINTER(GUID),
     POINTER(c_void_p),
 ]
+_CoGetClassObject.restype = HRESULT
+
+_CoCreateInstance = _ole32.CoCreateInstance
+_CoCreateInstance.argtypes = [
+    REFCLSID,
+    POINTER(IUnknown),
+    DWORD,
+    POINTER(GUID),
+    POINTER(LPVOID),
+]
+_CoCreateInstance.restype = HRESULT
+
+_CoCreateInstanceEx = _ole32.CoCreateInstanceEx
+_CoCreateInstanceEx.argtypes = [
+    REFCLSID,
+    POINTER(IUnknown),
+    DWORD,
+    POINTER(COSERVERINFO),
+    DWORD,
+    POINTER(MULTI_QI),
+]
+_CoCreateInstanceEx.restype = HRESULT
 
 
 class tagBIND_OPTS(Structure):
@@ -258,6 +292,9 @@ class tagBIND_OPTS(Structure):
 
 # XXX Add __init__ which sets cbStruct?
 BIND_OPTS = tagBIND_OPTS
+_CoGetObject = _ole32.CoGetObject
+_CoGetObject.argtypes = [LPCWSTR, POINTER(BIND_OPTS), POINTER(GUID), POINTER(LPVOID)]
+_CoGetObject.restype = HRESULT
 
 
 class tagBIND_OPTS2(Structure):
@@ -360,7 +397,5 @@ def CoCreateInstanceEx(
         interface = IUnknown
     multiqi = MULTI_QI()
     multiqi.pIID = pointer(interface._iid_)  # type: ignore
-    _ole32.CoCreateInstanceEx(
-        byref(clsid), None, clsctx, pServerInfo, 1, byref(multiqi)
-    )
+    _CoCreateInstanceEx(byref(clsid), None, clsctx, pServerInfo, 1, byref(multiqi))
     return cast(multiqi.pItf, POINTER(interface))  # type: ignore