comtypes 1.4.7__zip → 1.4.9__zip

{comtypes-1.4.7 → 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.
@@ -69,12 +63,37 @@ class _cominterface_meta(type):
     def __new__(cls, name, bases, namespace):
         methods = namespace.pop("_methods_", None)
         dispmethods = namespace.pop("_disp_methods_", None)
-        new_cls = type.__new__(cls, name, bases, namespace)
+        self = type.__new__(cls, name, bases, namespace)
 
         if methods is not None:
-            new_cls._methods_ = methods
+            self._methods_ = methods
         if dispmethods is not None:
-            new_cls._disp_methods_ = dispmethods
+            self._disp_methods_ = dispmethods
+
+        # ` _compointer_meta` is a subclass inherited from `_cominterface_meta`.
+        # `_compointer_base` uses `_compointer_meta` as its metaclass.
+        # In other words, when the `__new__` method of this metaclass is called,
+        # `_compointer_base` type or an subclass of it might be created and assigned
+        # to `self`.
+        if bases == (c_void_p,):
+            # `self` is the `_compointer_base` type.
+            # On some versions of Python, `_compointer_base` is not yet available in
+            # the accessible namespace at this point in its initialization, and
+            # referencing it could raise a `NameError`.
+            # This metaclass is intended to be used only as a base class for defining
+            # the `_compointer_meta` or as the metaclass for the `IUnknown`, so the
+            # situation where the `bases` parameter is `(c_void_p,)` is limited to when
+            # the `_compointer_meta` is specified as the metaclass of the
+            # `_compointer_base`.
+            # Prevent specifying the metaclass type instance in the `bases` parameter
+            # when instantiating it, as this would lead to infinite recursion.
+            return self
+        if issubclass(self, _compointer_base):
+            # `self` is a `POINTER(interface)` type.
+            # Prevent creating/registering a pointer to a pointer (to a pointer...),
+            # which would lead to infinite recursion.
+            # Depending on a version or revision of Python, this may be essential.
+            return self
 
         # If we sublass a COM interface, for example:
         #
@@ -85,77 +104,36 @@ class _cominterface_meta(type):
         # subclass of POINTER(IUnknown) because of the way ctypes
         # typechecks work.
         if bases == (object,):
-            _ptr_bases = (new_cls, _compointer_base)
+            # `self` is the `IUnknown` type.
+            _ptr_bases = (self, _compointer_base)
         else:
-            _ptr_bases = (new_cls, POINTER(bases[0]))
-
-        # The interface 'new_cls' is used as a mixin.
+            # `self` is an interface type derived from `IUnknown`.
+            _ptr_bases = (self, POINTER(bases[0]))
+
+        # The interface 'self' is used as a mixin.
+        # HACK: Could `type(_compointer_base)` be replaced with `_compointer_meta`?
+        # `type(klass)` returns its metaclass.
+        # Since this specification, `type(_compointer_base)` will return the
+        # `_compointer_meta` type as per the class definition.
+        # The reason for this implementation might be a remnant of the differences in
+        # how metaclasses work between Python 3.x and Python 2.x.
+        # If there are no problems with the versions of Python that `comtypes`
+        # supports, this replacement could make the process flow easier to understand.
         p = type(_compointer_base)(
-            "POINTER(%s)" % new_cls.__name__,
+            f"POINTER({self.__name__})",
             _ptr_bases,
-            {"__com_interface__": new_cls, "_needs_com_addref_": None},
+            {"__com_interface__": self, "_needs_com_addref_": None},
         )
 
-        from ctypes import _pointer_type_cache
-
-        _pointer_type_cache[new_cls] = p
-
-        if new_cls._case_insensitive_:
-
-            @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)
-                    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
-                    )
-
-        @patcher.Patch(POINTER(p))
-        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(POINTER(p), self).__setitem__(index, value)
-                    return
-                from _ctypes import CopyComPointer
-
-                CopyComPointer(value, self)
-
-        return new_cls
+        from ctypes import _pointer_type_cache  # type: ignore
+
+        _pointer_type_cache[self] = p
+
+        if self._case_insensitive_:
+            _meta_patch.case_insensitive(p)
+        _meta_patch.reference_fix(POINTER(p))  # type: ignore
+
+        return self
 
     def __setattr__(self, name, value):
         if name == "_methods_":
@@ -184,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
@@ -284,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'
@@ -308,18 +203,15 @@ class _cominterface_meta(type):
 
     def __get_baseinterface_methodcount(self):
         "Return the number of com methods in the base interfaces"
-        try:
-            result = 0
-            for itf in self.mro()[1:-1]:
-                result += len(itf.__dict__["_methods_"])
-            return result
-        except KeyError as err:
-            (name,) = err.args
-            if name == "_methods_":
-                raise TypeError("baseinterface '%s' has no _methods_" % itf.__name__)
-            raise
-
-    def _make_methods(self, methods: List[_ComMemberSpec]) -> None:
+        result = 0
+        for itf in self.mro()[1:-1]:
+            if "_methods_" in vars(itf):
+                result += len(vars(itf)["_methods_"])
+            else:
+                raise TypeError(f"baseinterface '{itf.__name__}' has no _methods_")
+        return result
+
+    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!
@@ -337,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.
@@ -353,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_:
@@ -363,9 +255,11 @@ class _cominterface_meta(type):
 ################################################################
 
 
+# will not work if we change the order of the two base classes!
 class _compointer_meta(type(c_void_p), _cominterface_meta):
-    "metaclass for COM interface pointer classes"
-    # no functionality, but needed to avoid a metaclass conflict
+    """metaclass for COM interface pointer classes"""
+
+    pass  # no functionality, but needed to avoid a metaclass conflict
 
 
 class _compointer_base(c_void_p, metaclass=_compointer_meta):
@@ -383,22 +277,7 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
             #
             if not type(self)._com_shutting_down:
                 _debug("Release %s", self)
-                self.Release()
-
-    def __cmp__(self, other):
-        """Compare pointers to COM interfaces."""
-        # COM identity rule
-        #
-        # XXX To compare COM interface pointers, should we
-        # automatically QueryInterface for IUnknown on both items, and
-        # compare the pointer values?
-        if not isinstance(other, _compointer_base):
-            return 1
-
-        # get the value property of the c_void_p baseclass, this is the pointer value
-        return cmp(
-            super(_compointer_base, self).value, super(_compointer_base, other).value
-        )
+                self.Release()  # type: ignore
 
     def __eq__(self, other):
         if not isinstance(other, _compointer_base):
@@ -421,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
@@ -457,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
 
 
 ################################################################
@@ -499,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.7 → 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")