comtypes 1.4.7__zip → 1.4.8__zip

{comtypes-1.4.7 → comtypes-1.4.8}/CHANGES.txt

@@ -1,6 +1,24 @@
 Comtypes CHANGELOG
 ==================
 
+Release 1.4.8
+--------------
+* Remove Python 3.7 and add Python 3.13 to the CI pipelines. By @junkmd.
+* Add constant definitions to ``shelllink``. By @junkmd.
+* Add more tests to ``test_stream``. By @junkmd.
+* Add the ``void_type`` definition to ``tlbparser``. By @junkmd.
+* Modernize ``tools.tlbparser.get_tlib_filename``. By @junkmd.
+* Extract the methods for parsing externals and dual interfaces from ``Parser.parse_typeinfo``. By @junkmd.
+* Fix type annotations referenced by ``tlbparser``. By @junkmd.
+* Modernize ``codegenerator.namespaces``. By @junkmd.
+* Improve static typing for ``CoGetClassObject`` and ``GetClassObject``. By @junkmd.
+* Refactor the ``__new__`` methods of ``_cominterface_meta`` and ``_coclass_meta``. By @junkmd.
+* Prevent errors caused by defining members with the same name within an enum type. By @junkmd.
+* Remove remaining ``__cmp__`` methods. By @newwingbird.
+* Remove remaining ``from __future__ import print_function`` lines. By @newwingbird.
+* Prevent ``itf`` to be an unbound variable in ``_cominterface_meta.__get_baseinterface_methodcount``. By @newwingbird.
+* Modify the metaclasses to ensure compatibility with Python 3.13 and earlier versions. By @junkmd.
+
 Release 1.4.7
 --------------
 * Improve ``_CArrayType`` alias import. By @junkmd.

{comtypes-1.4.7/comtypes.egg-info → comtypes-1.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: comtypes
-Version: 1.4.7
+Version: 1.4.8
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases
@@ -20,8 +20,9 @@ License-File: LICENSE.txt
 # comtypes
 
 ![Works on Windows only](https://img.shields.io/badge/-Windows-0078D6.svg?logo=windows&style=flat)  
-[![PyPI version](https://badge.fury.io/py/comtypes.svg)](https://pypi.org/project/comtypes/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - License](https://img.shields.io/pypi/l/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/comtypes)](https://pypi.org/project/comtypes/)  
-[![GitHub Repo stars](https://img.shields.io/github/stars/enthought/comtypes?style=social)](https://github.com/enthought/comtypes/stargazers) [![GitHub forks](https://img.shields.io/github/forks/enthought/comtypes?style=social)](https://github.com/enthought/comtypes/network/members)  
+[![PyPI version](https://badge.fury.io/py/comtypes.svg)](https://pypi.org/project/comtypes/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - Python Requires](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Fcomtypes%2Fjson&query=info.requires_python&label=Python Requires)](https://pypi.org/project/comtypes/)  
+[![PyPI - License](https://img.shields.io/pypi/l/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/comtypes)](https://pypi.org/project/comtypes/)  
+[![GitHub Repo stars](https://img.shields.io/github/stars/enthought/comtypes?style=social)](https://github.com/enthought/comtypes/stargazers) [![GitHub forks](https://img.shields.io/github/forks/enthought/comtypes?style=social)](https://github.com/enthought/comtypes/network/members) [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)  
 [![Tidelift Subscription](https://tidelift.com/badges/package/pypi/comtypes)](https://tidelift.com/subscription/pkg/pypi-comtypes?utm_source=pypi-comtypes&utm_medium=readme)
 
 
@@ -30,6 +31,7 @@ License-File: LICENSE.txt
 `comtypes` allows you to define, call, and implement custom and dispatch-based COM interfaces in pure Python.
 
 `comtypes` requires Windows and Python 3.8 or later.
+- Version <= [1.4.7](https://pypi.org/project/comtypes/1.4.7/) does not work with Python 3.13 as reported in [GH-618](https://github.com/enthought/comtypes/issues/618). Version [1.4.8](https://pypi.org/project/comtypes/1.4.8/) can work with Python 3.13.
 - Version [1.4.6](https://pypi.org/project/comtypes/1.4.6/) is the last version to support Python 3.7.
 - Version [1.2.1](https://pypi.org/project/comtypes/1.2.1/) is the last version to support Python 2.7 and 3.3–3.6.
 - `comtypes` does not work with Python 3.8.1 as reported in [GH-202](https://github.com/enthought/comtypes/issues/202). This bug has been fixed in Python >= 3.8.2.

{comtypes-1.4.7 → comtypes-1.4.8}/README.md

@@ -1,8 +1,9 @@
 # comtypes
 
 ![Works on Windows only](https://img.shields.io/badge/-Windows-0078D6.svg?logo=windows&style=flat)  
-[![PyPI version](https://badge.fury.io/py/comtypes.svg)](https://pypi.org/project/comtypes/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - License](https://img.shields.io/pypi/l/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/comtypes)](https://pypi.org/project/comtypes/)  
-[![GitHub Repo stars](https://img.shields.io/github/stars/enthought/comtypes?style=social)](https://github.com/enthought/comtypes/stargazers) [![GitHub forks](https://img.shields.io/github/forks/enthought/comtypes?style=social)](https://github.com/enthought/comtypes/network/members)  
+[![PyPI version](https://badge.fury.io/py/comtypes.svg)](https://pypi.org/project/comtypes/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - Python Requires](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Fcomtypes%2Fjson&query=info.requires_python&label=Python Requires)](https://pypi.org/project/comtypes/)  
+[![PyPI - License](https://img.shields.io/pypi/l/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/comtypes)](https://pypi.org/project/comtypes/)  
+[![GitHub Repo stars](https://img.shields.io/github/stars/enthought/comtypes?style=social)](https://github.com/enthought/comtypes/stargazers) [![GitHub forks](https://img.shields.io/github/forks/enthought/comtypes?style=social)](https://github.com/enthought/comtypes/network/members) [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)  
 [![Tidelift Subscription](https://tidelift.com/badges/package/pypi/comtypes)](https://tidelift.com/subscription/pkg/pypi-comtypes?utm_source=pypi-comtypes&utm_medium=readme)
 
 
@@ -11,6 +12,7 @@
 `comtypes` allows you to define, call, and implement custom and dispatch-based COM interfaces in pure Python.
 
 `comtypes` requires Windows and Python 3.8 or later.
+- Version <= [1.4.7](https://pypi.org/project/comtypes/1.4.7/) does not work with Python 3.13 as reported in [GH-618](https://github.com/enthought/comtypes/issues/618). Version [1.4.8](https://pypi.org/project/comtypes/1.4.8/) can work with Python 3.13.
 - Version [1.4.6](https://pypi.org/project/comtypes/1.4.6/) is the last version to support Python 3.7.
 - Version [1.2.1](https://pypi.org/project/comtypes/1.2.1/) is the last version to support Python 2.7 and 3.3–3.6.
 - `comtypes` does not work with Python 3.8.1 as reported in [GH-202](https://github.com/enthought/comtypes/issues/202). This bug has been fixed in Python >= 3.8.2.

{comtypes-1.4.7 → comtypes-1.4.8}/comtypes/__init__.py

@@ -1,5 +1,5 @@
 # comtypes version numbers follow semver (http://semver.org/) and PEP 440
-__version__ = "1.4.7"
+__version__ = "1.4.8"
 
 try:
     from _ctypes import COMError  # noqa

{comtypes-1.4.7 → comtypes-1.4.8}/comtypes/_comobject.py

@@ -349,7 +349,6 @@ else:
 
 
 class LocalServer(object):
-
     _queue = None
 
     def run(self, classobjects):

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

@@ -43,7 +43,7 @@ def _unpack_argspec(
 
 
 def _resolve_argspec(
-    items: Tuple[_ArgSpecElmType, ...]
+    items: Tuple[_ArgSpecElmType, ...],
 ) -> Tuple[Tuple[_ParamFlagType, ...], Tuple[Type[_CData], ...]]:
     """Unpacks and converts from argspec to paramflags and argtypes.
 

comtypes-1.4.8/comtypes/_meta.py

@@ -0,0 +1,95 @@
+# comtypes._meta helper module
+from ctypes import POINTER, c_void_p, cast
+import comtypes
+
+################################################################
+# metaclass for CoClass (in comtypes/__init__.py)
+
+
+def _wrap_coclass(self):
+    # We are an IUnknown pointer, represented as a c_void_p instance,
+    # but we really want this interface:
+    itf = self._com_interfaces_[0]
+    punk = cast(self, POINTER(itf))
+    result = punk.QueryInterface(itf)
+    result.__dict__["__clsid"] = str(self._reg_clsid_)
+    return result
+
+
+def _coclass_from_param(cls, obj):
+    if isinstance(obj, (cls._com_interfaces_[0], cls)):
+        return obj
+    raise TypeError(obj)
+
+
+#
+# The mro() of a POINTER(App) type, where class App is a subclass of CoClass:
+#
+#  POINTER(App)
+#   App
+#    CoClass
+#     c_void_p
+#      _SimpleCData
+#       _CData
+#        object
+
+
+class _coclass_meta(type):
+    # metaclass for CoClass
+    #
+    # When a CoClass subclass is created, create a POINTER(...) type
+    # for that class, with bases <coclass> and c_void_p.  Also, the
+    # POINTER(...) type gets a __ctypes_from_outparam__ method which
+    # will QueryInterface for the default interface: the first one on
+    # the coclass' _com_interfaces_ list.
+    def __new__(cls, name, bases, namespace):
+        self = type.__new__(cls, name, bases, namespace)
+        if bases == (object,):
+            # HACK: Could this conditional branch be removed since it is never reached?
+            # Since definition is `class CoClass(COMObject, metaclass=_coclass_meta)`,
+            # the `bases` parameter passed to the `_coclass_meta.__new__` would be
+            # `(COMObject,)`.
+            # Moreover, since the `COMObject` derives from `object` and does not specify
+            # a metaclass, `(object,)` will not be passed as the `bases` parameter
+            # to the `_coclass_meta.__new__`.
+            # 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 removal could make the process flow easier to understand.
+            return self
+        # XXX We should insist that a _reg_clsid_ is present.
+        if "_reg_clsid_" in namespace:
+            clsid = namespace["_reg_clsid_"]
+            comtypes.com_coclass_registry[str(clsid)] = self
+
+        # `_coclass_pointer_meta` is a subclass inherited from `_coclass_meta`.
+        # In other words, when the `__new__` method of this metaclass is called, an
+        # instance of `_coclass_pointer_meta` might be created and assigned to `self`.
+        if isinstance(self, _coclass_pointer_meta):
+            # `self` is the `_coclass_pointer_meta` type or a `POINTER(coclass)` type.
+            # Prevent creating/registering a pointer to a pointer (to a pointer...),
+            # or specifying the metaclass type instance in the `bases` parameter when
+            # instantiating it, which would lead to infinite recursion.
+            # Depending on a version or revision of Python, this may be essential.
+            return self
+
+        PTR = _coclass_pointer_meta(
+            f"POINTER({self.__name__})",
+            (self, c_void_p),
+            {
+                "__ctypes_from_outparam__": _wrap_coclass,
+                "from_param": classmethod(_coclass_from_param),
+            },
+        )
+        from ctypes import _pointer_type_cache  # type: ignore
+
+        _pointer_type_cache[self] = PTR
+
+        return self
+
+
+# will not work if we change the order of the two base classes!
+class _coclass_pointer_meta(type(c_void_p), _coclass_meta):
+    # metaclass for CoClass pointer
+
+    pass  # no functionality, but needed to avoid a metaclass conflict

{comtypes-1.4.7 → comtypes-1.4.8}/comtypes/_npsupport.py

@@ -1,4 +1,5 @@
-""" Consolidation of numpy support utilities. """
+"""Consolidation of numpy support utilities."""
+
 import sys
 
 is_64bits = sys.maxsize > 2**32

{comtypes-1.4.7 → comtypes-1.4.8}/comtypes/_post_coinit/__init__.py

@@ -12,4 +12,5 @@ This subpackage is called simultaneously with the initialization of `comtypes`.
 So it is necessary to maintain minimal settings to keep the lightweight action
 when the package is initialized.
 """
+
 from comtypes._post_coinit.unknwn import _shutdown  # noqa

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

@@ -88,15 +88,9 @@ class IServiceProvider(IUnknown):
 
 
 @overload
-def CoGetObject(displayname: str, interface: None) -> IUnknown:
-    ...
-
-
+def CoGetObject(displayname: str, interface: None) -> IUnknown: ...
 @overload
-def CoGetObject(displayname: str, interface: Type[_T_IUnknown]) -> _T_IUnknown:
-    ...
-
-
+def CoGetObject(displayname: str, interface: Type[_T_IUnknown]) -> _T_IUnknown: ...
 def CoGetObject(displayname: str, interface: Optional[Type[IUnknown]]) -> IUnknown:
     """Convert a displayname to a moniker, then bind and return the object
     identified by the moniker."""
@@ -117,20 +111,14 @@ def CoCreateInstance(
     interface: None = None,
     clsctx: Optional[int] = None,
     punkouter: Optional[_pUnkOuter] = None,
-) -> IUnknown:
-    ...
-
-
+) -> IUnknown: ...
 @overload
 def CoCreateInstance(
     clsid: GUID,
     interface: Type[_T_IUnknown],
     clsctx: Optional[int] = None,
     punkouter: Optional[_pUnkOuter] = None,
-) -> _T_IUnknown:
-    ...
-
-
+) -> _T_IUnknown: ...
 def CoCreateInstance(
     clsid: GUID,
     interface: Optional[Type[IUnknown]] = None,
@@ -153,14 +141,19 @@ def CoCreateInstance(
 if TYPE_CHECKING:
 
     @overload
-    def CoGetClassObject(clsid, clsctx=None, pServerInfo=None, interface=None):
-        # type: (GUID, Optional[int], Optional[COSERVERINFO], None) -> hints.IClassFactory
-        pass
-
+    def CoGetClassObject(
+        clsid: GUID,
+        clsctx: Optional[int] = None,
+        pServerInfo: "Optional[COSERVERINFO]" = None,
+        interface: None = None,
+    ) -> hints.IClassFactory: ...
     @overload
-    def CoGetClassObject(clsid, clsctx=None, pServerInfo=None, interface=None):
-        # type: (GUID, Optional[int], Optional[COSERVERINFO], Type[_T_IUnknown]) -> _T_IUnknown
-        pass
+    def CoGetClassObject(
+        clsid: GUID,
+        clsctx: Optional[int] = None,
+        pServerInfo: "Optional[COSERVERINFO]" = None,
+        interface: Type[_T_IUnknown] = hints.IClassFactory,
+    ) -> _T_IUnknown: ...
 
 
 def CoGetClassObject(clsid, clsctx=None, pServerInfo=None, interface=None):
@@ -177,15 +170,9 @@ def CoGetClassObject(clsid, clsctx=None, pServerInfo=None, interface=None):
 
 
 @overload
-def GetActiveObject(clsid: GUID, interface: None = None) -> IUnknown:
-    ...
-
-
+def GetActiveObject(clsid: GUID, interface: None = None) -> IUnknown: ...
 @overload
-def GetActiveObject(clsid: GUID, interface: Type[_T_IUnknown]) -> _T_IUnknown:
-    ...
-
-
+def GetActiveObject(clsid: GUID, interface: Type[_T_IUnknown]) -> _T_IUnknown: ...
 def GetActiveObject(
     clsid: GUID, interface: Optional[Type[IUnknown]] = None
 ) -> IUnknown:
@@ -335,10 +322,7 @@ def CoCreateInstanceEx(
     clsctx: Optional[int] = None,
     machine: Optional[str] = None,
     pServerInfo: Optional[COSERVERINFO] = None,
-) -> IUnknown:
-    ...
-
-
+) -> IUnknown: ...
 @overload
 def CoCreateInstanceEx(
     clsid: GUID,
@@ -346,10 +330,7 @@ def CoCreateInstanceEx(
     clsctx: Optional[int] = None,
     machine: Optional[str] = None,
     pServerInfo: Optional[COSERVERINFO] = None,
-) -> _T_IUnknown:
-    ...
-
-
+) -> _T_IUnknown: ...
 def CoCreateInstanceEx(
     clsid: GUID,
     interface: Optional[Type[IUnknown]] = None,

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

@@ -69,12 +69,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,49 +110,67 @@ 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
+        from ctypes import _pointer_type_cache  # type: ignore
 
-        _pointer_type_cache[new_cls] = p
+        _pointer_type_cache[self] = p
 
-        if new_cls._case_insensitive_:
+        if self._case_insensitive_:
+            self._patch_case_insensitive_to_ptr_type(p)
+        self._patch_reference_fix_to_ptrptr_type(POINTER(p))  # type: ignore
 
-            @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))
+        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
@@ -149,13 +192,11 @@ class _cominterface_meta(type):
                     # CopyComPointer should do if index != 0.
                     if bool(value):
                         value.AddRef()
-                    super(POINTER(p), self).__setitem__(index, value)
+                    super(pp, self).__setitem__(index, value)  # type: ignore
                     return
                 from _ctypes import CopyComPointer
 
-                CopyComPointer(value, self)
-
-        return new_cls
+                CopyComPointer(value, self)  # type: ignore
 
     def __setattr__(self, name, value):
         if name == "_methods_":
@@ -308,16 +349,13 @@ 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
+        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_:
@@ -363,9 +401,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):
@@ -385,21 +425,6 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
                 _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
-        )
-
     def __eq__(self, other):
         if not isinstance(other, _compointer_base):
             return False

{comtypes-1.4.7 → comtypes-1.4.8}/comtypes/client/__init__.py

@@ -138,22 +138,17 @@ wrap = GetBestInterface
 # Should we do this for POINTER(IUnknown) also?
 ctypes.POINTER(automation.IDispatch).__ctypes_from_outparam__ = wrap_outparam  # type: ignore
 
+
 ################################################################
 #
 # Object creation
 #
 @overload
-def GetActiveObject(progid: _UnionT[str, CoClass, GUID]) -> Any:
-    ...
-
-
+def GetActiveObject(progid: _UnionT[str, CoClass, GUID]) -> Any: ...
 @overload
 def GetActiveObject(
     progid: _UnionT[str, CoClass, GUID], interface: Type[_T_IUnknown]
-) -> _T_IUnknown:
-    ...
-
-
+) -> _T_IUnknown: ...
 def GetActiveObject(
     progid: _UnionT[str, CoClass, GUID],
     interface: Optional[Type[IUnknown]] = None,
@@ -193,14 +188,19 @@ def _manage(
 if TYPE_CHECKING:
 
     @overload
-    def GetClassObject(progid, clsctx=None, pServerInfo=None):
-        # type: (_UnionT[str, CoClass, GUID], Optional[int], Optional[comtypes.COSERVERINFO]) -> hints.IClassFactory
-        pass
-
+    def GetClassObject(
+        progid: _UnionT[str, CoClass, GUID],
+        clsctx: Optional[int] = None,
+        pServerInfo: Optional[comtypes.COSERVERINFO] = None,
+        interface: None = None,
+    ) -> hints.IClassFactory: ...
     @overload
-    def GetClassObject(progid, clsctx=None, pServerInfo=None, interface=None):
-        # type: (_UnionT[str, CoClass, GUID], Optional[int], Optional[comtypes.COSERVERINFO], Optional[Type[_T_IUnknown]]) -> _T_IUnknown
-        pass
+    def GetClassObject(
+        progid: _UnionT[str, CoClass, GUID],
+        clsctx: Optional[int] = None,
+        pServerInfo: Optional[comtypes.COSERVERINFO] = None,
+        interface: Type[_T_IUnknown] = hints.IClassFactory,
+    ) -> _T_IUnknown: ...
 
 
 def GetClassObject(progid, clsctx=None, pServerInfo=None, interface=None):
@@ -216,10 +216,7 @@ def GetClassObject(progid, clsctx=None, pServerInfo=None, interface=None):
 
 
 @overload
-def CreateObject(progid: _UnionT[str, Type[CoClass], GUID]) -> Any:
-    ...
-
-
+def CreateObject(progid: _UnionT[str, Type[CoClass], GUID]) -> Any: ...
 @overload
 def CreateObject(
     progid: _UnionT[str, Type[CoClass], GUID],
@@ -228,10 +225,7 @@ def CreateObject(
     interface: Optional[Type[_T_IUnknown]] = None,
     dynamic: bool = ...,
     pServerInfo: Optional[comtypes.COSERVERINFO] = None,
-) -> _T_IUnknown:
-    ...
-
-
+) -> _T_IUnknown: ...
 def CreateObject(
     progid: _UnionT[str, Type[CoClass], GUID],  # which object to create
     clsctx: Optional[int] = None,  # how to create the object
@@ -297,15 +291,11 @@ def CreateObject(
 
 
 @overload
-def CoGetObject(displayname: str, interface: Type[_T_IUnknown]) -> _T_IUnknown:
-    ...
-
-
+def CoGetObject(displayname: str, interface: Type[_T_IUnknown]) -> _T_IUnknown: ...
 @overload
-def CoGetObject(displayname: str, interface: None = None, dynamic: bool = False) -> Any:
-    ...
-
-
+def CoGetObject(
+    displayname: str, interface: None = None, dynamic: bool = False
+) -> Any: ...
 def CoGetObject(
     displayname: str,
     interface: Optional[Type[comtypes.IUnknown]] = None,

{comtypes-1.4.7 → comtypes-1.4.8}/comtypes/client/_code_cache.py

@@ -4,6 +4,7 @@ The main function is _find_gen_dir(), which on-demand creates the
 comtypes.gen package and returns a directory where generated code can
 be written to.
 """
+
 import ctypes, logging, os, sys, tempfile, types
 from ctypes import wintypes
 

{comtypes-1.4.7 → comtypes-1.4.8}/comtypes/client/_events.py

@@ -1,4 +1,3 @@
-from __future__ import print_function
 import ctypes
 import traceback
 import comtypes