Trial.

See python/cpython#124520 (comment)

Author: junkmd

comtypes/_meta.py

@@ -34,6 +34,9 @@ def _coclass_from_param(cls, obj):
 #        object
 
 
+_initializing_coclass_meta = False
+
+
 class _coclass_meta(type):
     # metaclass for CoClass
     #
@@ -42,28 +45,32 @@ class _coclass_meta(type):
     # 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)
+    def __init__(self, name, bases, namespace):
         if bases == (object,):
-            return self
+            return
         # 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
-        PTR = _coclass_pointer_meta(
-            f"POINTER({self.__name__})",
-            (self, c_void_p),
-            {
-                "__ctypes_from_outparam__": _wrap_coclass,
-                "from_param": classmethod(_coclass_from_param),
-            },
-        )
+        global _initializing_coclass_meta
+        if _initializing_coclass_meta:
+            return
+        try:
+            _initializing_coclass_meta = True
+            PTR = _coclass_pointer_meta(
+                "POINTER(%s)" % self.__name__,
+                (self, c_void_p),
+                {
+                    "__ctypes_from_outparam__": _wrap_coclass,
+                    "from_param": classmethod(_coclass_from_param),
+                },
+            )
+        finally:
+            _initializing_coclass_meta = False
         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):

comtypes/_post_coinit/unknwn.py

@@ -51,6 +51,9 @@ def _shutdown(
 # The metaclasses...
 
 
+_initializing_cominterface_meta = False
+
+
 class _cominterface_meta(type):
     """Metaclass for COM interfaces.  Automatically creates high level
     methods from COMMETHOD lists.
@@ -66,35 +69,45 @@ class _cominterface_meta(type):
     _com_shutting_down = False
 
     # Creates also a POINTER type for the newly created class.
-    def __new__(cls, name, bases, namespace):
-        methods = namespace.pop("_methods_", None)
-        dispmethods = namespace.pop("_disp_methods_", None)
-        self = type.__new__(cls, name, bases, namespace)
+    def __init(self, name, bases, namespace):
+        methods = namespace.get("_methods_", None)
+        dispmethods = namespace.get("_disp_methods_", None)
 
         if methods is not None:
-            self._methods_ = methods
+            self._make_methods(methods)
+            self._make_specials()
         if dispmethods is not None:
-            self._disp_methods_ = dispmethods
+            self._make_dispmethods(dispmethods)
+            self._make_specials()
 
-        # If we sublass a COM interface, for example:
-        #
-        # class IDispatch(IUnknown):
-        #     ....
-        #
-        # then we need to make sure that POINTER(IDispatch) is a
-        # subclass of POINTER(IUnknown) because of the way ctypes
-        # typechecks work.
-        if bases == (object,):
-            _ptr_bases = (self, _compointer_base)
-        else:
-            _ptr_bases = (self, POINTER(bases[0]))
+        global _initializing_cominterface_meta
 
-        # The interface 'self' is used as a mixin.
-        p = type(_compointer_base)(
-            f"POINTER({self.__name__})",
-            _ptr_bases,
-            {"__com_interface__": self, "_needs_com_addref_": None},
-        )
+        if _initializing_cominterface_meta:
+            return
+
+        try:
+            _initializing_cominterface_meta = True
+            # If we sublass a COM interface, for example:
+            #
+            # class IDispatch(IUnknown):
+            #     ....
+            #
+            # then we need to make sure that POINTER(IDispatch) is a
+            # subclass of POINTER(IUnknown) because of the way ctypes
+            # typechecks work.
+            if bases == (object,):
+                _ptr_bases = (self, _compointer_base)
+            else:
+                _ptr_bases = (self, POINTER(bases[0]))
+
+            # The interface 'self' is used as a mixin.
+            p = type(_compointer_base)(
+                f"POINTER({self.__name__})",
+                _ptr_bases,
+                {"__com_interface__": self, "_needs_com_addref_": None},
+            )
+        finally:
+            _initializing_cominterface_meta = False
 
         from ctypes import _pointer_type_cache  # type: ignore
 
@@ -104,7 +117,14 @@ def __new__(cls, name, bases, namespace):
             self._patch_case_insensitive_to_ptr_type(p)
         self._patch_reference_fix_to_ptrptr_type(POINTER(p))  # type: ignore
 
-        return self
+    if sys.version_info >= (3, 13):
+        __init__ = __init
+    else:
+
+        def __new__(cls, name, bases, namespace):
+            self = type.__new__(cls, name, bases, namespace)
+            self.__init(name, bases, namespace)
+            return self
 
     @staticmethod
     def _patch_case_insensitive_to_ptr_type(p: Type) -> None:

comtypes/safearray.py

@@ -81,9 +81,7 @@ def _make_safearray_type(itemtype):
     )
 
     meta = type(_safearray.tagSAFEARRAY)
-    sa_type = meta.__new__(
-        meta, "SAFEARRAY_%s" % itemtype.__name__, (_safearray.tagSAFEARRAY,), {}
-    )
+    sa_type = meta(f"SAFEARRAY_{itemtype.__name__}", (_safearray.tagSAFEARRAY,), {})
 
     try:
         vartype = _ctype_to_vartype[itemtype]