comtypes 1.4.8__zip → 1.4.9__zip

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/test/test_win32com_interop.py

@@ -1,19 +1,37 @@
 import unittest
-
-from ctypes import PyDLL, py_object, c_void_p, byref, POINTER
+from ctypes import POINTER, PyDLL, byref, c_void_p, py_object
 from ctypes.wintypes import BOOL
 
-from comtypes import IUnknown
+from comtypes import COMObject, IUnknown
+from comtypes.automation import VARIANT, IDispatch
 from comtypes.client import CreateObject
-from comtypes.automation import IDispatch
-from comtypes.test import requires
 
-requires("pythoncom")
 try:
     import pythoncom
     import win32com.client
 
-    skip = False
+    IMPORT_FAILED = False
+    # pywin32 is available.  The pythoncom dll contains two handy
+    # exported functions that allow to create a VARIANT from a Python
+    # object, also a function that unpacks a VARIANT into a Python
+    # object.
+    #
+    # This allows us to create und unpack SAFEARRAY instances
+    # contained in VARIANTs, and check for consistency with the
+    # comtypes code.
+    _dll = PyDLL(pythoncom.__file__)
+
+    # c:/sf/pywin32/com/win32com/src/oleargs.cpp 213
+    # PyObject *PyCom_PyObjectFromVariant(const VARIANT *var)
+    unpack = _dll.PyCom_PyObjectFromVariant
+    unpack.restype = py_object
+    unpack.argtypes = (POINTER(VARIANT),)
+
+    # c:/sf/pywin32/com/win32com/src/oleargs.cpp 54
+    # BOOL PyCom_VariantFromPyObject(PyObject *obj, VARIANT *var)
+    _pack = _dll.PyCom_VariantFromPyObject
+    _pack.argtypes = py_object, POINTER(VARIANT)
+    _pack.restype = BOOL
     # We use the PyCom_PyObjectFromIUnknown function in pythoncom25.dll to
     # convert a comtypes COM pointer into a pythoncom COM pointer.
     # Fortunately this function is exported by the dll...
@@ -30,17 +48,58 @@ except ImportError:
     # if it is available since pythoncom is not a project dependency and adding tests depending
     # on the vagaries of various testing environments is not deterministic.
     # TODO: Evaluate if we should just remove this test or what.
-    skip = True
+    IMPORT_FAILED = True
 
 
 def setUpModule():
-    if skip:
+    if IMPORT_FAILED:
         raise unittest.SkipTest(
             "This test requires the pythoncom library installed.  If this is "
             "important tests then we need to add dev dependencies to the project that include pythoncom."
         )
 
 
+################################################################
+
+
+def pack(obj):
+    var = VARIANT()
+    _pack(obj, byref(var))
+    return var
+
+
+class PyWinSafeArrayTest(unittest.TestCase):
+    def test_1dim(self):
+        data = (1, 2, 3)
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+    def test_2dim(self):
+        data = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+    def test_3dim(self):
+        data = (((1, 2), (3, 4), (5, 6)), ((7, 8), (9, 10), (11, 12)))
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+    def test_4dim(self):
+        data = (
+            (((1, 2), (3, 4)), ((5, 6), (7, 8))),
+            (((9, 10), (11, 12)), ((13, 14), (15, 16))),
+        )
+        variant = pack(data)
+        self.assertEqual(variant.value, data)
+        self.assertEqual(unpack(variant), data)
+
+
+################################################################
+
+
 def comtypes2pywin(ptr, interface=None):
     """Convert a comtypes pointer 'ptr' into a pythoncom
     PyI<interface> object.
@@ -56,9 +115,6 @@ def comtypes2pywin(ptr, interface=None):
     return _PyCom_PyObjectFromIUnknown(ptr, byref(interface._iid_), True)
 
 
-################################################################
-
-
 def comtypes_get_refcount(ptr):
     """Helper function for testing: return the COM reference count of
     a comtypes COM object"""
@@ -66,9 +122,6 @@ def comtypes_get_refcount(ptr):
     return ptr.Release()
 
 
-from comtypes import COMObject
-
-
 class MyComObject(COMObject):
     """A completely trivial COM object implementing IDispatch. Calling
     any methods will return the error code E_NOTIMPL (except the
@@ -77,42 +130,33 @@ class MyComObject(COMObject):
     _com_interfaces_ = [IDispatch]
 
 
-################################################################
-
-
-class Test(unittest.TestCase):
-    def tearDown(self):
-        if hasattr(self, "ie"):
-            self.ie.Quit()
-            del self.ie
-
+class ConvertComtypesPtrToPythonComObjTest(unittest.TestCase):
     def test_mycomobject(self):
         o = MyComObject()
         p = comtypes2pywin(o, IDispatch)
         disp = win32com.client.Dispatch(p)
         self.assertEqual(repr(disp), "<COMObject <unknown>>")
 
-    def test_ie(self):
-        # Convert a comtypes COM interface pointer into a win32com COM
-        # pointer.
-        ie = self.ie = CreateObject("InternetExplorer.Application")
+    def test_refcount(self):
+        # Convert a comtypes COM interface pointer into a win32com COM pointer.
+        dic = CreateObject("Scripting.Dictionary")
         # The COM refcount of the created object is 1:
-        self.assertEqual(comtypes_get_refcount(ie), 1)
-        # IE starts invisible:
-        self.assertEqual(ie.Visible, False)
+        self.assertEqual(comtypes_get_refcount(dic), 1)
+        dic["foo"] = "bar"
+        self.assertEqual(dic.Item("foo"), "bar")
 
         # Create a pythoncom PyIDispatch object from it:
-        p = comtypes2pywin(ie, interface=IDispatch)
-        self.assertEqual(comtypes_get_refcount(ie), 2)
+        p = comtypes2pywin(dic, interface=IDispatch)
+        self.assertEqual(comtypes_get_refcount(dic), 2)
 
         # Make it usable...
         disp = win32com.client.Dispatch(p)
-        self.assertEqual(comtypes_get_refcount(ie), 2)
-        self.assertEqual(disp.Visible, False)
+        self.assertEqual(comtypes_get_refcount(dic), 2)
+        self.assertEqual(disp.Item("foo"), "bar")
 
         # Cleanup and make sure that the COM refcounts are correct
         del p, disp
-        self.assertEqual(comtypes_get_refcount(ie), 1)
+        self.assertEqual(comtypes_get_refcount(dic), 1)
 
 
 if __name__ == "__main__":

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/test/test_wmi.py

@@ -1,9 +1,6 @@
 import unittest as ut
 
 from comtypes.client import CoGetObject
-from comtypes.test import requires
-
-requires("time")
 
 
 # WMI has dual interfaces.

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/tools/codegenerator/codegenerator.py

@@ -128,9 +128,9 @@ class CodeGenerator(object):
                 path = self._make_relative_path(filename, comtypes.gen.__path__[0])
                 self.imports.add("os")
                 definition = (
-                    "os.path.normpath(\n"
-                    "    os.path.abspath(os.path.join(os.path.dirname(__file__),\n"
-                    "                                 %r)))" % path
+                    f"os.path.normpath(\n"
+                    f"    os.path.abspath(os.path.join(os.path.dirname(__file__),\n"
+                    f"                                 {path!r})))"
                 )
                 self.declarations.add("typelib_path", definition)
                 p = os.path.normpath(
@@ -293,7 +293,7 @@ class CodeGenerator(object):
         indent = "    " * depth
         # some chars are replaced to avoid causing a `SyntaxError`
         repled = orig.replace("\\", r"\\").replace('"', r"'")
-        return '%s"""%s"""' % (indent, repled)
+        return f'{indent}"""{repled}"""'
 
     def ArrayType(self, tp: typedesc.ArrayType) -> None:
         self.generate(get_real_type(tp.typ))
@@ -347,7 +347,7 @@ class CodeGenerator(object):
             self.more.add(struct)
         if head.struct.location:
             self.last_item_class = False
-            print("# %s %s" % head.struct.location, file=self.stream)
+            print(f"# {head.struct.location}", file=self.stream)
         basenames = [self._to_type_name(b) for b in head.struct.bases]
         if basenames:
             self.imports.add("comtypes", "GUID")
@@ -362,7 +362,7 @@ class CodeGenerator(object):
                 m.name for m in head.struct.members if type(m) is typedesc.Method
             ]
             print(
-                "class %s(%s):" % (head.struct.name, ", ".join(basenames)),
+                f"class {head.struct.name}({', '.join(basenames)}):",
                 file=self.stream,
             )
             print(
@@ -397,7 +397,7 @@ class CodeGenerator(object):
                 print("assert 0, 'cannot generate code for IUnknown'", file=self.stream)
                 print(file=self.stream)
                 print(file=self.stream)
-                print("class %s(_com_interface):" % head.struct.name, file=self.stream)
+                print(f"class {head.struct.name}(_com_interface):", file=self.stream)
                 print("    pass", file=self.stream)
                 print(file=self.stream)
                 print(file=self.stream)
@@ -408,10 +408,10 @@ class CodeGenerator(object):
 
                 self.last_item_class = True
 
-                print("class %s(Structure):" % head.struct.name, file=self.stream)
+                print(f"class {head.struct.name}(Structure):", file=self.stream)
                 if hasattr(head.struct, "_recordinfo_"):
                     print(
-                        "    _recordinfo_ = %r" % (head.struct._recordinfo_,),
+                        f"    _recordinfo_ = {head.struct._recordinfo_!r}",
                         file=self.stream,
                     )
                 else:
@@ -425,7 +425,7 @@ class CodeGenerator(object):
 
                 self.last_item_class = True
 
-                print("class %s(Union):" % head.struct.name, file=self.stream)
+                print(f"class {head.struct.name}(Union):", file=self.stream)
                 print("    pass", file=self.stream)
                 print(file=self.stream)
                 print(file=self.stream)
@@ -462,14 +462,14 @@ class CodeGenerator(object):
                 pack = packing.calc_packing(body.struct, fields)
                 if pack is not None:
                     self.last_item_class = False
-                    print("%s._pack_ = %s" % (body.struct.name, pack), file=self.stream)
+                    print(f"{body.struct.name}._pack_ = {pack}", file=self.stream)
             except packing.PackingError as details:
                 # if packing fails, write a warning comment to the output.
                 import warnings
 
                 message = "Structure %s: %s" % (body.struct.name, details)
                 warnings.warn(message, UserWarning)
-                print("# WARNING: %s" % details, file=self.stream)
+                print(f"# WARNING: {details}", file=self.stream)
                 self.last_item_class = False
 
         if fields:
@@ -482,9 +482,9 @@ class CodeGenerator(object):
 
             self.last_item_class = False
 
-            print("%s._fields_ = [" % body.struct.name, file=self.stream)
+            print(f"{body.struct.name}._fields_ = [", file=self.stream)
             if body.struct.location:
-                print("    # %s %s" % body.struct.location, file=self.stream)
+                print(f"    # {body.struct.location}", file=self.stream)
             # unnamed fields will get autogenerated names "_", "_1". "_2", "_3", ...
             unnamed_index = 0
             for f in fields:
@@ -495,20 +495,19 @@ class CodeGenerator(object):
                         fieldname = "_"
                     unnamed_index += 1
                     print(
-                        "    # Unnamed field renamed to '%s'" % fieldname,
+                        f"    # Unnamed field renamed to '{fieldname}'",
                         file=self.stream,
                     )
                 else:
                     fieldname = f.name
                 if f.bits is None:
                     print(
-                        "    ('%s', %s)," % (fieldname, self._to_type_name(f.typ)),
+                        f"    ('{fieldname}', {self._to_type_name(f.typ)}),",
                         file=self.stream,
                     )
                 else:
                     print(
-                        "    ('%s', %s, %s),"
-                        % (fieldname, self._to_type_name(f.typ), f.bits),
+                        f"    ('{fieldname}', {self._to_type_name(f.typ)}, {f.bits}),",
                         file=self.stream,
                     )
             print("]", file=self.stream)
@@ -524,14 +523,12 @@ class CodeGenerator(object):
                 print(file=self.stream)
                 size = body.struct.size // 8
                 print(
-                    "assert sizeof(%s) == %s, sizeof(%s)"
-                    % (body.struct.name, size, body.struct.name),
+                    f"assert sizeof({body.struct.name}) == {size}, sizeof({body.struct.name})",
                     file=self.stream,
                 )
                 align = body.struct.align // 8
                 print(
-                    "assert alignment(%s) == %s, alignment(%s)"
-                    % (body.struct.name, align, body.struct.name),
+                    f"assert alignment({body.struct.name}) == {align}, alignment({body.struct.name})",
                     file=self.stream,
                 )
 
@@ -542,27 +539,24 @@ class CodeGenerator(object):
                 print(file=self.stream)
 
             self.last_item_class = False
-            print("%s._methods_ = [" % body.struct.name, file=self.stream)
+            print(f"{body.struct.name}._methods_ = [", file=self.stream)
             if body.struct.location:
-                print("# %s %s" % body.struct.location, file=self.stream)
+                print(f"# {body.struct.location}", file=self.stream)
 
             for m in methods:
                 if m.location:
-                    print("    # %s %s" % m.location, file=self.stream)
+                    print(f"    # {m.location}", file=self.stream)
                 print(
                     (
-                        "    COMMETHOD(\n"
-                        "        [], \n"
-                        "        %s,\n"
-                        "        '%s',\n"
-                    )
-                    % (self._to_type_name(m.returns), m.name),
+                        f"    COMMETHOD(\n"
+                        f"        [], \n"
+                        f"        {self._to_type_name(m.returns)},\n"
+                        f"        '{m.name}',\n"
+                    ),
                     file=self.stream,
                 )
                 for a in m.iterArgTypes():
-                    print(
-                        "        ([], %s),\n" % self._to_type_name(a), file=self.stream
-                    )
+                    print(f"        ([], {self._to_type_name(a)}),\n", file=self.stream)
                     print("    ),", file=self.stream)
             print("]", file=self.stream)
 
@@ -589,10 +583,10 @@ class CodeGenerator(object):
             print(self._to_docstring(lib.doc), file=self.stream)
 
         if lib.name:
-            print("    name = %r" % lib.name, file=self.stream)
+            print(f"    name = {lib.name!r}", file=self.stream)
 
         print(
-            "    _reg_typelib_ = (%r, %r, %r)" % (lib.guid, lib.major, lib.minor),
+            f"    _reg_typelib_ = ({lib.guid!r}, {lib.major!r}, {lib.minor!r})",
             file=self.stream,
         )
         print(file=self.stream)
@@ -608,7 +602,7 @@ class CodeGenerator(object):
     def Constant(self, tp: typedesc.Constant) -> None:
         self.last_item_class = False
         print(
-            "%s = %r  # Constant %s" % (tp.name, tp.value, self._to_type_name(tp.typ)),
+            f"{tp.name} = {tp.value!r}  # Constant {self._to_type_name(tp.typ)}",
             file=self.stream,
         )
         self.names.add(tp.name)
@@ -650,11 +644,11 @@ class CodeGenerator(object):
 
         self.last_item_class = True
 
-        print("class %s(CoClass):" % coclass.name, file=self.stream)
+        print(f"class {coclass.name}(CoClass):", file=self.stream)
         if coclass.doc:
             print(self._to_docstring(coclass.doc), file=self.stream)
-        print("    _reg_clsid_ = GUID(%r)" % coclass.clsid, file=self.stream)
-        print("    _idlflags_ = %s" % coclass.idlflags, file=self.stream)
+        print(f"    _reg_clsid_ = GUID({coclass.clsid!r})", file=self.stream)
+        print(f"    _idlflags_ = {coclass.idlflags}", file=self.stream)
         if self.filename is not None:
             print("    _typelib_path_ = typelib_path", file=self.stream)
         # X print
@@ -663,7 +657,7 @@ class CodeGenerator(object):
         libid = coclass.tlibattr.guid
         wMajor, wMinor = coclass.tlibattr.wMajorVerNum, coclass.tlibattr.wMinorVerNum
         print(
-            "    _reg_typelib_ = (%r, %s, %s)" % (str(libid), wMajor, wMinor),
+            f"    _reg_typelib_ = ({str(libid)!r}, {wMajor}, {wMinor})",
             file=self.stream,
         )
         print(file=self.stream)
@@ -678,13 +672,13 @@ class CodeGenerator(object):
         if implemented:
             self.last_item_class = False
             print(
-                "%s._com_interfaces_ = [%s]" % (coclass.name, ", ".join(implemented)),
+                f"{coclass.name}._com_interfaces_ = [{', '.join(implemented)}]",
                 file=self.stream,
             )
         if sources:
             self.last_item_class = False
             print(
-                "%s._outgoing_interfaces_ = [%s]" % (coclass.name, ", ".join(sources)),
+                f"{coclass.name}._outgoing_interfaces_ = [{', '.join(sources)}]",
                 file=self.stream,
             )
 
@@ -773,13 +767,13 @@ class CodeGenerator(object):
 
         self.last_item_class = True
 
-        print("class %s(%s):" % (head.itf.name, basename), file=self.stream)
+        print(f"class {head.itf.name}({basename}):", file=self.stream)
         if head.itf.doc:
             print(self._to_docstring(head.itf.doc), file=self.stream)
 
         print("    _case_insensitive_ = True", file=self.stream)
-        print("    _iid_ = GUID(%r)" % head.itf.iid, file=self.stream)
-        print("    _idlflags_ = %s" % head.itf.idlflags, file=self.stream)
+        print(f"    _iid_ = GUID({head.itf.iid!r})", file=self.stream)
+        print(f"    _idlflags_ = {head.itf.idlflags}", file=self.stream)
 
         if self._is_enuminterface(head.itf):
             print(file=self.stream)
@@ -826,7 +820,7 @@ class CodeGenerator(object):
             print(file=self.stream)
 
         self.last_item_class = False
-        print("%s._methods_ = [" % body.itf.name, file=self.stream)
+        print(f"{body.itf.name}._methods_ = [", file=self.stream)
         for m in body.itf.members:
             if isinstance(m, typedesc.ComMethod):
                 self.make_ComMethod(m, "dual" in body.itf.idlflags)
@@ -839,8 +833,8 @@ class CodeGenerator(object):
             "################################################################",
             file=self.stream,
         )
-        print("# code template for %s implementation" % body.itf.name, file=self.stream)
-        print("# class %s_Impl(object):" % body.itf.name, file=self.stream)
+        print(f"# code template for {body.itf.name} implementation", file=self.stream)
+        print(f"# class {body.itf.name}_Impl(object):", file=self.stream)
 
         methods = {}
         for m in body.itf.members:
@@ -862,43 +856,43 @@ class CodeGenerator(object):
         for name, (typ, inargs, outargs, doc) in methods.items():
             if typ == 0:  # method
                 print(
-                    "#     def %s(%s):" % (name, ", ".join(["self"] + inargs)),
+                    f"#     def {name}({', '.join(['self'] + inargs)}):",
                     file=self.stream,
                 )
-                print("#         %r" % (doc or "-no docstring-"), file=self.stream)
-                print("#         #return %s" % (", ".join(outargs)), file=self.stream)
+                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
+                print(f"#         #return {', '.join(outargs)}", file=self.stream)
             elif typ == 1:  # propget
                 print("#     @property", file=self.stream)
                 print(
-                    "#     def %s(%s):" % (name, ", ".join(["self"] + inargs)),
+                    f"#     def {name}({', '.join(['self'] + inargs)}):",
                     file=self.stream,
                 )
-                print("#         %r" % (doc or "-no docstring-"), file=self.stream)
-                print("#         #return %s" % (", ".join(outargs)), file=self.stream)
+                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
+                print(f"#         #return {', '.join(outargs)}", file=self.stream)
             elif typ == 2:  # propput
                 print(
-                    "#     def _set(%s):" % ", ".join(["self"] + inargs + outargs),
+                    f"#     def _set({', '.join(['self'] + inargs + outargs)}):",
                     file=self.stream,
                 )
-                print("#         %r" % (doc or "-no docstring-"), file=self.stream)
+                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
                 print(
-                    "#     %s = property(fset = _set, doc = _set.__doc__)" % name,
+                    f"#     {name} = property(fset = _set, doc = _set.__doc__)",
                     file=self.stream,
                 )
             elif typ == 3:  # propget + propput
                 print(
-                    "#     def _get(%s):" % ", ".join(["self"] + inargs),
+                    f"#     def _get({', '.join(['self'] + inargs)}):",
                     file=self.stream,
                 )
-                print("#         %r" % (doc or "-no docstring-"), file=self.stream)
-                print("#         #return %s" % (", ".join(outargs)), file=self.stream)
+                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
+                print(f"#         #return {', '.join(outargs)}", file=self.stream)
                 print(
-                    "#     def _set(%s):" % ", ".join(["self"] + inargs + outargs),
+                    f"#     def _set({', '.join(['self'] + inargs + outargs)}):",
                     file=self.stream,
                 )
-                print("#         %r" % (doc or "-no docstring-"), file=self.stream)
+                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
                 print(
-                    "#     %s = property(_get, _set, doc = _set.__doc__)" % name,
+                    f"#     {name} = property(_get, _set, doc = _set.__doc__)",
                     file=self.stream,
                 )
             else:
@@ -921,12 +915,12 @@ class CodeGenerator(object):
 
         self.last_item_class = True
 
-        print("class %s(%s):" % (head.itf.name, basename), file=self.stream)
+        print(f"class {head.itf.name}({basename}):", file=self.stream)
         if head.itf.doc:
             print(self._to_docstring(head.itf.doc), file=self.stream)
         print("    _case_insensitive_ = True", file=self.stream)
-        print("    _iid_ = GUID(%r)" % head.itf.iid, file=self.stream)
-        print("    _idlflags_ = %s" % head.itf.idlflags, file=self.stream)
+        print(f"    _iid_ = GUID({head.itf.iid!r})", file=self.stream)
+        print(f"    _idlflags_ = {head.itf.idlflags}", file=self.stream)
         print("    _methods_ = []", file=self.stream)
 
         annotations = typeannotator.DispInterfaceMembersAnnotator(head.itf).generate()
@@ -955,7 +949,7 @@ class CodeGenerator(object):
 
         self.last_item_class = False
 
-        print("%s._disp_methods_ = [" % body.itf.name, file=self.stream)
+        print(f"{body.itf.name}._disp_methods_ = [", file=self.stream)
         for m in body.itf.members:
             if isinstance(m, typedesc.DispMethod):
                 self.make_DispMethod(m)

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/tools/codegenerator/helpers.py

@@ -22,7 +22,7 @@ class dispid(object):
         self.memid = memid
 
     def __repr__(self):
-        return "dispid(%s)" % self.memid
+        return f"dispid({self.memid})"
 
 
 class helpstring(object):
@@ -30,7 +30,7 @@ class helpstring(object):
         self.text = text
 
     def __repr__(self):
-        return "helpstring(%r)" % self.text
+        return f"helpstring({self.text!r})"
 
 
 # XXX Should this be in ctypes itself?
@@ -299,22 +299,22 @@ class TypeNamer(object):
         # to refer to the type. Assumes the 'from ctypes import *'
         # namespace is available.
         if isinstance(t, typedesc.SAFEARRAYType):
-            return "_midlSAFEARRAY(%s)" % self(t.typ)
+            return f"_midlSAFEARRAY({self(t.typ)})"
         # if isinstance(t, typedesc.CoClass):
         #     return "%s._com_interfaces_[0]" % t.name
         if isinstance(t, typedesc.Typedef):
             return t.name
         if isinstance(t, typedesc.PointerType):
             _t, pcnt = self._inspect_PointerType(t)
-            return "%s%s%s" % ("POINTER(" * pcnt, self(_t), ")" * pcnt)
+            return f"{'POINTER(' * pcnt}{self(_t)}{')' * pcnt}"
         elif isinstance(t, typedesc.ArrayType):
-            return "%s * %s" % (self(t.typ), int(t.max) + 1)
+            return f"{self(t.typ)} * {int(t.max) + 1}"
         elif isinstance(t, typedesc.FunctionType):
             args = [self(x) for x in [t.returns] + list(t.iterArgTypes())]
             if "__stdcall__" in t.attributes:
-                return "WINFUNCTYPE(%s)" % ", ".join(args)
+                return f"WINFUNCTYPE({', '.join(args)})"
             else:
-                return "CFUNCTYPE(%s)" % ", ".join(args)
+                return f"CFUNCTYPE({', '.join(args)})"
         elif isinstance(t, typedesc.CvQualifiedType):
             # const and volatile are ignored
             return "%s" % self(t.typ)
@@ -334,7 +334,7 @@ class TypeNamer(object):
             # t.symbol_name - symbol to generate
             # t.tlib - the ITypeLib pointer to the typelibrary containing the symbols definition
             modname = name_wrapper_module(t.tlib)
-            return "%s.%s" % (modname, t.symbol_name)
+            return f"{modname}.{t.symbol_name}"
         return t.name
 
     def _inspect_PointerType(

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/tools/codegenerator/packing.py

@@ -25,20 +25,20 @@ def _calc_packing(struct, fields, pack, isStruct):
             size += a - size % a
         if isStruct:
             if size != f.offset:
-                raise PackingError("field %s offset (%s/%s)" % (f.name, size, f.offset))
+                raise PackingError(f"field {f.name} offset ({size}/{f.offset})")
             size += s
         else:
             size = max(size, s)
         total_align = max(total_align, a)
     if total_align != struct.align:
-        raise PackingError("total alignment (%s/%s)" % (total_align, struct.align))
+        raise PackingError(f"total alignment ({total_align}/{struct.align})")
     a = total_align
     if pack is not None:
         a = min(pack, a)
     if size % a:
         size += a - size % a
     if size != struct.size:
-        raise PackingError("total size (%s/%s)" % (size, struct.size))
+        raise PackingError(f"total size ({size}/{struct.size})")
 
 
 def calc_packing(struct, fields):
@@ -55,7 +55,7 @@ def calc_packing(struct, fields):
 
             return int(pack / 8)
 
-    raise PackingError("PACKING FAILED: %s" % details)
+    raise PackingError(f"PACKING FAILED: {details}")
 
 
 class PackingError(Exception):

{comtypes-1.4.8 → comtypes-1.4.9}/comtypes/tools/codegenerator/typeannotator.py

@@ -1,19 +1,19 @@
 import abc
 import keyword
-from typing import Any, Generic, TypeVar, TYPE_CHECKING
+from typing import Any, Generic, Protocol, TypeVar
 from typing import Dict, List, Optional, Sequence, Tuple
 from typing import Iterable, Iterator
 
 from comtypes.tools import typedesc
 
-if TYPE_CHECKING:
-    from comtypes import hints
 
+class _MethodTypeDesc(Protocol):
+    arguments: List[Tuple[Any, str, List[str], Optional[Any]]]
+    idlflags: List[str]
+    name: str
 
-if TYPE_CHECKING:
-    _T_MTD = TypeVar("_T_MTD", bound=hints._MethodTypeDesc)
-else:
-    _T_MTD = TypeVar("_T_MTD")
+
+_T_MTD = TypeVar("_T_MTD", bound=_MethodTypeDesc)
 
 
 class _MethodAnnotator(abc.ABC, Generic[_T_MTD]):