comtypes 1.4.7__zip → 1.4.9__zip

{comtypes-1.4.7 → 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.7 → 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.7 → comtypes-1.4.9}/comtypes/tools/codegenerator/namespaces.py

@@ -1,12 +1,28 @@
+from collections import Counter
 import textwrap
+from typing import overload
+from typing import Optional, Union as _UnionT
 from typing import Dict, List, Set, Tuple
+from typing import Iterator, Mapping, Sequence
+import warnings
 
 
 class ImportedNamespaces(object):
-    def __init__(self):
-        self.data = {}
+    def __init__(self) -> None:
+        self.data: Dict[str, Optional[str]] = {}
 
-    def add(self, name1, name2=None, symbols=None):
+    @overload
+    def add(self, modulename: str, /) -> None: ...
+    @overload
+    def add(self, modulename: str, symbolname: str, /) -> None: ...
+    @overload
+    def add(self, symbolname: str, /, *, symbols: Mapping[str, str]) -> None: ...
+    def add(
+        self,
+        name1: str,
+        name2: Optional[str] = None,
+        symbols: Optional[Mapping[str, str]] = None,
+    ) -> None:
         """Adds a namespace will be imported.
 
         Examples:
@@ -43,7 +59,7 @@ class ImportedNamespaces(object):
             from_, import_ = name1, name2
         self.data[import_] = from_
 
-    def __contains__(self, item):
+    def __contains__(self, item: _UnionT[str, Tuple[str, str]]) -> bool:
         """Returns item has already added.
 
         Examples:
@@ -77,31 +93,31 @@ class ImportedNamespaces(object):
             names.add(key)
         return names
 
-    def _make_line(self, from_, imports):
+    def _make_line(self, from_: str, imports: Sequence[str]) -> str:
         import_ = ", ".join(imports)
-        code = "from %s import %s" % (from_, import_)
+        code = f"from {from_} import {import_}"
         if len(code) <= 80:
             return code
         wrapper = textwrap.TextWrapper(
             subsequent_indent="    ", initial_indent="    ", break_long_words=False
         )
         import_ = "\n".join(wrapper.wrap(import_))
-        code = "from %s import (\n%s\n)" % (from_, import_)
+        code = f"from {from_} import (\n{import_}\n)"
         return code
 
-    def getvalue(self):
-        ns = {}
-        lines = []
+    def getvalue(self) -> str:
+        ns: Dict[str, Optional[Set[str]]] = {}
+        lines: List[str] = []
         for key, val in self.data.items():
             if val is None:
                 ns[key] = val
             elif key == "*":
-                lines.append("from %s import *" % val)
+                lines.append(f"from {val} import *")
             else:
-                ns.setdefault(val, set()).add(key)
+                ns.setdefault(val, set()).add(key)  # type: ignore
         for key, val in ns.items():
             if val is None:
-                lines.append("import %s" % key)
+                lines.append(f"import {key}")
             else:
                 names = sorted(val, key=lambda s: s.lower())
                 lines.append(self._make_line(key, names))
@@ -109,10 +125,10 @@ class ImportedNamespaces(object):
 
 
 class DeclaredNamespaces(object):
-    def __init__(self):
-        self.data = {}
+    def __init__(self) -> None:
+        self.data: Dict[Tuple[str, str], Optional[str]] = {}
 
-    def add(self, alias, definition, comment=None):
+    def add(self, alias: str, definition: str, comment: Optional[str] = None) -> None:
         """Adds a namespace will be declared.
 
         Examples:
@@ -134,18 +150,18 @@ class DeclaredNamespaces(object):
             names.add(alias)
         return names
 
-    def getvalue(self):
+    def getvalue(self) -> str:
         lines = []
         for (alias, definition), comment in self.data.items():
-            code = "%s = %s" % (alias, definition)
+            code = f"{alias} = {definition}"
             if comment:
-                code = code + "  # %s" % comment
+                code = code + f"  # {comment}"
             lines.append(code)
         return "\n".join(lines)
 
 
 class EnumerationNamespaces(object):
-    def __init__(self):
+    def __init__(self) -> None:
         self.data: Dict[str, List[Tuple[str, int]]] = {}
 
     def add(self, enum_name: str, member_name: str, value: int) -> None:
@@ -159,6 +175,14 @@ class EnumerationNamespaces(object):
             >>> assert enums
             >>> enums.add('Foo', 'spam', 2)
             >>> enums.add('Bar', 'bacon', 3)
+            >>> enums.add('Bar', 'egg', 4)
+            >>> import warnings
+            >>> with warnings.catch_warnings(record=True) as w:
+            ...     enums.add('Bar', 'egg', 5)
+            ...     print(w[-1].message.args[0].replace(', ', ',\\n'))
+            The 'egg' member of the 'Bar' enumeration is already assigned 4,
+            but it will be overwritten with 5,
+            based on the type information.
             >>> assert 'Foo' in enums
             >>> assert 'Baz' not in enums
             >>> print(enums.to_intflags())
@@ -169,6 +193,8 @@ class EnumerationNamespaces(object):
             <BLANKLINE>
             class Bar(IntFlag):
                 bacon = 3
+                # egg = 4  # duplicated. Perhaps there is a bug in the type library?
+                egg = 5  # duplicated. Perhaps there is a bug in the type library?
             >>> print(enums.to_constants())
             # values for enumeration 'Foo'
             ham = 1
@@ -177,9 +203,24 @@ class EnumerationNamespaces(object):
             <BLANKLINE>
             # values for enumeration 'Bar'
             bacon = 3
+            egg = 4  # duplicated within the 'Bar'. Perhaps there is a bug?
+            egg = 5  # duplicated within the 'Bar'. Perhaps there is a bug?
             Bar = c_int  # enum
         """
-        self.data.setdefault(enum_name, []).append((member_name, value))
+        members = self.data.setdefault(enum_name, [])
+        if members:
+            mapping = dict(members)
+            if member_name in mapping:
+                # This may be a bug in the COM type library.
+                # See also https://github.com/enthought/comtypes/issues/550
+                warnings.warn(
+                    f"The '{member_name}' member of the '{enum_name}' enumeration "
+                    f"is already assigned {mapping[member_name]}, "
+                    f"but it will be overwritten with {value}, "
+                    "based on the type information.",
+                    UserWarning,
+                )
+        members.append((member_name, value))
 
     def __contains__(self, item: str) -> bool:
         return item in self.data
@@ -190,23 +231,52 @@ class EnumerationNamespaces(object):
     def get_symbols(self) -> Set[str]:
         return set(self.data)
 
+    def _iter_members(
+        self, members: Sequence[Tuple[str, int]]
+    ) -> Iterator[Tuple[str, bool, int]]:
+        key_counter = Counter(m for m, _ in members)
+        decrementee = dict(key_counter)  # shallow copy
+        for name, value in members:
+            decrementee[name] -= 1
+            # definition, is_dupl, rest_dupl_count
+            yield f"{name} = {value}", key_counter[name] > 1, decrementee[name]
+
+    def _iter_items(self) -> Iterator[Tuple[str, Iterator[Tuple[str, bool, int]]]]:
+        for name, members in self.data.items():
+            yield name, self._iter_members(members)
+
     def to_constants(self) -> str:
         blocks = []
-        for enum_name, enum_members in self.data.items():
+        for enum_name, members in self._iter_items():
             lines = []
             lines.append(f"# values for enumeration '{enum_name}'")
-            for n, v in enum_members:
-                lines.append(f"{n} = {v}")
+            for definition, is_dupl, _ in members:
+                if is_dupl:
+                    msg1 = f"duplicated within the '{enum_name}'."
+                    msg2 = "Perhaps there is a bug?"
+                    lines.append(f"{definition}  # {msg1} {msg2}")
+                else:
+                    lines.append(definition)
             lines.append(f"{enum_name} = c_int  # enum")
             blocks.append("\n".join(lines))
         return "\n\n".join(blocks)
 
     def to_intflags(self) -> str:
         blocks = []
-        for enum_name, enum_members in self.data.items():
+        for enum_name, members in self._iter_items():
             lines = []
             lines.append(f"class {enum_name}(IntFlag):")
-            for member_name, value in enum_members:
-                lines.append(f"    {member_name} = {value}")
+            for definition, is_dupl, rest_dupl_count in members:
+                if is_dupl:
+                    msg = "duplicated. Perhaps there is a bug in the type library?"
+                    base_line = f"{definition}  # {msg}"
+                    if rest_dupl_count > 0:
+                        # Prevent raising `TypeError: Attempted to reuse key:`.
+                        # See https://github.com/enthought/comtypes/issues/550
+                        lines.append(f"    # {base_line}")
+                    else:
+                        lines.append(f"    {base_line}")
+                else:
+                    lines.append(f"    {definition}")
             blocks.append("\n".join(lines))
         return "\n\n\n".join(blocks)