comtypes 1.4.8__zip → 1.4.9__zip

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

@@ -1,5 +1,5 @@
 import ctypes
-from typing import Any, NamedTuple
+from typing import Any, Literal, NamedTuple
 from typing import Dict, List, Tuple, Type
 from typing import Optional, Union as _UnionT
 from typing import Callable, Iterator
@@ -64,7 +64,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 +92,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 +118,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 +382,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 +432,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 +605,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 +630,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.9/comtypes/_post_coinit/_cominterface_meta_patcher.py

@@ -0,0 +1,153 @@
+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.9}/comtypes/_post_coinit/misc.py

@@ -16,9 +16,9 @@ if TYPE_CHECKING:
     from comtypes import hints as hints  # noqa  # type: ignore
 
 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._memberspec import COMMETHOD
 from comtypes._post_coinit.unknwn import IUnknown
 
 

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/_post_coinit/unknwn.py

@@ -1,23 +1,17 @@
 # https://learn.microsoft.com/en-us/windows/win32/api/unknwn/
 
-from ctypes import byref, c_ulong, c_void_p, HRESULT, POINTER
-from _ctypes import COMError
-
 import logging
 import sys
-import types
-from typing import ClassVar, TYPE_CHECKING, TypeVar
-from typing import Optional
-from typing import List, Type
-
-from comtypes import GUID, patcher, _ole32_nohresult, com_interface_registry
-from comtypes._idl_stuff import STDMETHOD
-from comtypes._memberspec import ComMemberGenerator, DispMemberGenerator
-from comtypes._memberspec import _ComMemberSpec, _DispMemberSpec
-from comtypes._py_instance_method import instancemethod
+from ctypes import HRESULT, POINTER, byref, c_ulong, c_void_p
+from typing import TYPE_CHECKING, ClassVar, List, Optional, Type, TypeVar
 
+from comtypes import GUID, _ole32_nohresult, com_interface_registry
+from comtypes._memberspec import STDMETHOD, ComMemberGenerator, DispMemberGenerator
+from comtypes._post_coinit import _cominterface_meta_patcher as _meta_patch
+from comtypes._post_coinit.instancemethod import instancemethod
 
-_all_slice = slice(None, None, None)
+if TYPE_CHECKING:
+    from comtypes._memberspec import _ComMemberSpec, _DispMemberSpec
 
 logger = logging.getLogger(__name__)
 
@@ -58,8 +52,8 @@ class _cominterface_meta(type):
 
     _case_insensitive_: bool
     _iid_: GUID
-    _methods_: List[_ComMemberSpec]
-    _disp_methods_: List[_DispMemberSpec]
+    _methods_: List["_ComMemberSpec"]
+    _disp_methods_: List["_DispMemberSpec"]
 
     # This flag is set to True by the atexit handler which calls
     # CoUninitialize.
@@ -136,68 +130,11 @@ class _cominterface_meta(type):
         _pointer_type_cache[self] = p
 
         if self._case_insensitive_:
-            self._patch_case_insensitive_to_ptr_type(p)
-        self._patch_reference_fix_to_ptrptr_type(POINTER(p))  # type: ignore
+            _meta_patch.case_insensitive(p)
+        _meta_patch.reference_fix(POINTER(p))  # type: ignore
 
         return self
 
-    @staticmethod
-    def _patch_case_insensitive_to_ptr_type(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
-                )
-
-    @staticmethod
-    def _patch_reference_fix_to_ptrptr_type(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 __setattr__(self, name, value):
         if name == "_methods_":
             # XXX I'm no longer sure why the code generator generates
@@ -225,94 +162,11 @@ class _cominterface_meta(type):
 
         # XXX These special methods should be generated by the code generator.
         if has_name("Count"):
-
-            @patcher.Patch(self)
-            class _(object):
-                def __len__(self):
-                    "Return the the 'self.Count' property."
-                    return self.Count
-
+            _meta_patch.sized(self)
         if has_name("Item"):
-
-            @patcher.Patch(self)
-            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 = "%r object does not support item assignment"
-                        raise TypeError(msg % type(self))
-
+            _meta_patch.callable_and_subscriptable(self)
         if has_name("_NewEnum"):
-
-            @patcher.Patch(self)
-            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)
+            _meta_patch.iterator(self)
 
     def _make_case_insensitive(self):
         # The __map_case__ dictionary maps lower case names to the
@@ -325,7 +179,7 @@ class _cominterface_meta(type):
             d.update(getattr(self, "__map_case__", {}))
             self.__map_case__ = d
 
-    def _make_dispmethods(self, methods: List[_DispMemberSpec]) -> None:
+    def _make_dispmethods(self, methods: List["_DispMemberSpec"]) -> None:
         if self._case_insensitive_:
             self._make_case_insensitive()
         # create dispinterface methods and properties on the interface 'self'
@@ -357,7 +211,7 @@ class _cominterface_meta(type):
                 raise TypeError(f"baseinterface '{itf.__name__}' has no _methods_")
         return result
 
-    def _make_methods(self, methods: List[_ComMemberSpec]) -> None:
+    def _make_methods(self, methods: List["_ComMemberSpec"]) -> None:
         if self._case_insensitive_:
             self._make_case_insensitive()
         # register com interface. we insist on an _iid_ in THIS class!
@@ -375,12 +229,12 @@ class _cominterface_meta(type):
             member_gen.add(m)
         for name, func, raw_func, is_prop in member_gen.methods():
             raw_mth = instancemethod(raw_func, None, self)
-            setattr(self, "_%s__com_%s" % (self.__name__, name), raw_mth)
+            setattr(self, f"_{self.__name__}__com_{name}", raw_mth)
             mth = instancemethod(func, None, self)
             if not is_prop:
                 # We install the method in the class, except when it's a property.
                 # And we make sure we don't overwrite a property that's already present.
-                mthname = name if not hasattr(self, name) else ("_%s" % name)
+                mthname = name if not hasattr(self, name) else f"_{name}"
                 setattr(self, mthname, mth)
             # For a method, this is the real name.
             # For a property, this is the name WITHOUT the _set_ or _get_ prefix.
@@ -391,7 +245,7 @@ class _cominterface_meta(type):
         # create public properties / attribute accessors
         for name, accessor in member_gen.properties():
             # Again, we should not overwrite class attributes that are already present.
-            propname = name if not hasattr(self, name) else ("_%s" % name)
+            propname = name if not hasattr(self, name) else f"_{name}"
             setattr(self, propname, accessor)
             # COM is case insensitive
             if self._case_insensitive_:
@@ -423,7 +277,7 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
             #
             if not type(self)._com_shutting_down:
                 _debug("Release %s", self)
-                self.Release()
+                self.Release()  # type: ignore
 
     def __eq__(self, other):
         if not isinstance(other, _compointer_base):
@@ -446,7 +300,7 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
 
     def __repr__(self):
         ptr = super(_compointer_base, self).value
-        return "<%s ptr=0x%x at %x>" % (self.__class__.__name__, ptr or 0, id(self))
+        return f"<{self.__class__.__name__} ptr=0x{ptr or 0:x} at {id(self):x}>"
 
     # This fixes the problem when there are multiple python interface types
     # wrapping the same COM interface.  This could happen because some interfaces
@@ -482,8 +336,8 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
                 # a kind of QueryInterface
                 return table[cls._iid_]
             except KeyError:
-                raise TypeError("Interface %s not supported" % cls._iid_)
-        return value.QueryInterface(cls.__com_interface__)
+                raise TypeError(f"Interface {cls._iid_} not supported")
+        return value.QueryInterface(cls.__com_interface__)  # type: ignore
 
 
 ################################################################
@@ -524,7 +378,7 @@ class IUnknown(_IUnknown_Base, metaclass=_cominterface_meta):
 
     _case_insensitive_: ClassVar[bool] = False
     _iid_: ClassVar[GUID] = GUID("{00000000-0000-0000-C000-000000000046}")
-    _methods_: ClassVar[List[_ComMemberSpec]] = [
+    _methods_: ClassVar[List["_ComMemberSpec"]] = [
         STDMETHOD(HRESULT, "QueryInterface", [POINTER(GUID), POINTER(c_void_p)]),
         STDMETHOD(c_ulong, "AddRef"),
         STDMETHOD(c_ulong, "Release"),

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

@@ -1,7 +1,7 @@
 """SAFEARRAY api functions, data types, and constants."""
 
 from ctypes import c_uint, c_ushort, c_void_p, POINTER, Structure, WinDLL
-from ctypes.wintypes import DWORD, LONG, UINT
+from ctypes.wintypes import DWORD, LONG, UINT, USHORT
 
 from comtypes import HRESULT, GUID
 
@@ -19,7 +19,6 @@ from comtypes import HRESULT, GUID
 
 VARTYPE = c_ushort
 PVOID = c_void_p
-USHORT = c_ushort
 
 _oleaut32 = WinDLL("oleaut32")