comtypes 1.4.1__zip → 1.4.3__zip

{comtypes-1.4.1/comtypes/tools → comtypes-1.4.3/comtypes/tools/codegenerator}/codegenerator.py

@@ -1,28 +1,30 @@
 # Code generator to generate code for everything contained in COM type
 # libraries.
-from __future__ import print_function
-import ctypes
 import keyword
 import logging
 import os
-import sys
 import textwrap
-from typing import (
-    Any,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Union as _UnionT,
-)
+from typing import Any
+from typing import Dict, List, Tuple
+from typing import Sequence
+from typing import Optional, Union as _UnionT
 import io
 
 import comtypes
 from comtypes import typeinfo
-from comtypes.tools import tlbparser, typedesc, typeannotator
+from comtypes.tools import tlbparser, typedesc
+from comtypes.tools.codegenerator import namespaces
+from comtypes.tools.codegenerator import packing
+from comtypes.tools.codegenerator.modulenamer import name_wrapper_module
+from comtypes.tools.codegenerator.helpers import (
+    get_real_type,
+    ASSUME_STRINGS,
+    ComMethodGenerator,
+    DispMethodGenerator,
+    DispPropertyGenerator,
+    TypeNamer,
+)
+from comtypes.tools.codegenerator import typeannotator
 
 
 version = comtypes.__version__
@@ -32,417 +34,45 @@ logger = logging.getLogger(__name__)
 __warn_on_munge__ = __debug__
 
 
-class lcid(object):
-    def __repr__(self):
-        return "_lcid"
-
-
-lcid = lcid()
-
-
-class dispid(object):
-    def __init__(self, memid):
-        self.memid = memid
-
-    def __repr__(self):
-        return "dispid(%s)" % self.memid
-
-
-class helpstring(object):
-    def __init__(self, text):
-        self.text = text
-
-    def __repr__(self):
-        return "helpstring(%r)" % self.text
-
-
-# XXX Should this be in ctypes itself?
-ctypes_names = {
-    "unsigned char": "c_ubyte",
-    "signed char": "c_byte",
-    "char": "c_char",
-    "wchar_t": "c_wchar",
-    "short unsigned int": "c_ushort",
-    "short int": "c_short",
-    "long unsigned int": "c_ulong",
-    "long int": "c_long",
-    "long signed int": "c_long",
-    "unsigned int": "c_uint",
-    "int": "c_int",
-    "long long unsigned int": "c_ulonglong",
-    "long long int": "c_longlong",
-    "double": "c_double",
-    "float": "c_float",
-    # Hm...
-    "void": "None",
-}
-
-
-def get_real_type(tp):
-    if type(tp) is typedesc.Typedef:
-        return get_real_type(tp.typ)
-    elif isinstance(tp, typedesc.CvQualifiedType):
-        return get_real_type(tp.typ)
-    return tp
-
-
-ASSUME_STRINGS = True
-
-
-def _calc_packing(struct, fields, pack, isStruct):
-    # Try a certain packing, raise PackingError if field offsets,
-    # total size ot total alignment is wrong.
-    if struct.size is None:  # incomplete struct
-        return -1
-    if struct.name in dont_assert_size:
-        return None
-    if struct.bases:
-        size = struct.bases[0].size
-        total_align = struct.bases[0].align
-    else:
-        size = 0
-        total_align = 8  # in bits
-    for i, f in enumerate(fields):
-        if f.bits:  # this code cannot handle bit field sizes.
-            # print "##XXX FIXME"
-            return -2  # XXX FIXME
-        s, a = storage(f.typ)
-        if pack is not None:
-            a = min(pack, a)
-        if size % a:
-            size += a - size % a
-        if isStruct:
-            if size != f.offset:
-                raise PackingError("field %s offset (%s/%s)" % (f.name, 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))
-    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))
-
-
-def calc_packing(struct, fields):
-    # try several packings, starting with unspecified packing
-    isStruct = isinstance(struct, typedesc.Structure)
-    for pack in [None, 16 * 8, 8 * 8, 4 * 8, 2 * 8, 1 * 8]:
-        try:
-            _calc_packing(struct, fields, pack, isStruct)
-        except PackingError as details:
-            continue
-        else:
-            if pack is None:
-                return None
-
-            return int(pack / 8)
-
-    raise PackingError("PACKING FAILED: %s" % details)
-
-
-class PackingError(Exception):
-    pass
-
-
-# XXX These should be filtered out in gccxmlparser.
-dont_assert_size = set(
-    [
-        "__si_class_type_info_pseudo",
-        "__class_type_info_pseudo",
-    ]
-)
-
-
-def storage(t):
-    # return the size and alignment of a type
-    if isinstance(t, typedesc.Typedef):
-        return storage(t.typ)
-    elif isinstance(t, typedesc.ArrayType):
-        s, a = storage(t.typ)
-        return s * (int(t.max) - int(t.min) + 1), a
-    return int(t.size), int(t.align)
-
-
-################################################################
-
-
-def name_wrapper_module(tlib):
-    """Determine the name of a typelib wrapper module"""
-    libattr = tlib.GetLibAttr()
-    modname = "_%s_%s_%s_%s" % (
-        str(libattr.guid)[1:-1].replace("-", "_"),
-        libattr.lcid,
-        libattr.wMajorVerNum,
-        libattr.wMinorVerNum,
-    )
-    return "comtypes.gen.%s" % modname
-
-
-def name_friendly_module(tlib):
-    """Determine the friendly-name of a typelib module.
-    If cannot get friendly-name from typelib, returns `None`.
-    """
-    try:
-        modulename = tlib.GetDocumentation(-1)[0]
-    except comtypes.COMError:
-        return
-    return "comtypes.gen.%s" % modulename
-
-
-################################################################
-
-_DefValType = _UnionT["lcid", Any, None]
-_IdlFlagType = _UnionT[str, dispid, helpstring]
-
-
-def _to_arg_definition(
-    type_name: str,
-    arg_name: str,
-    idlflags: List[str],
-    default: _DefValType,
-) -> str:
-    if default is not None:
-        elms = (idlflags, type_name, arg_name, default)
-        code = "        (%r, %s, '%s', %r)" % elms
-        if len(code) > 80:
-            code = (
-                "        (\n"
-                "            %r,\n"
-                "            %s,\n"
-                "            '%s',\n"
-                "            %r\n"
-                "        )"
-            ) % elms
-    else:
-        elms = (idlflags, type_name, arg_name)
-        code = "        (%r, %s, '%s')" % elms
-        if len(code) > 80:
-            code = (
-                "        (\n"
-                "            %r,\n"
-                "            %s,\n"
-                "            '%s',\n"
-                "        )"
-            ) % elms
-    return code
-
-
-class ComMethodGenerator(object):
-    def __init__(self, m: typedesc.ComMethod, isdual: bool) -> None:
-        self._m = m
-        self._isdual = isdual
-        self._stream = io.StringIO()
-        self._to_type_name = TypeNamer()
-
-    def generate(self):
-        # () -> str
-        if not self._m.arguments:
-            self._make_noargs()
-        else:
-            self._make_withargs()
-        return self._stream.getvalue()
-
-    def _get_common_elms(self) -> Tuple[List[_IdlFlagType], str, str]:
-        idlflags: List[_IdlFlagType] = []
-        if self._isdual:
-            idlflags.append(dispid(self._m.memid))
-            idlflags.extend(self._m.idlflags)
-        else:  # We don't include the dispid for non-dispatch COM interfaces
-            idlflags.extend(self._m.idlflags)
-        if __debug__ and self._m.doc:
-            idlflags.insert(1, helpstring(self._m.doc))
-        type_name = self._to_type_name(self._m.returns)
-        return (idlflags, type_name, self._m.name)
-
-    def _make_noargs(self) -> None:
-        elms = self._get_common_elms()
-        code = "    COMMETHOD(%r, %s, '%s')," % elms
-        if len(code) > 80:
-            code = (
-                "    COMMETHOD(\n"
-                "        %r,\n"
-                "        %s,\n"
-                "        '%s',\n"
-                "    ),"
-            ) % elms
-        print(code, file=self._stream)
-
-    def _make_withargs(self) -> None:
-        code = (
-            "    COMMETHOD(\n" "        %r,\n" "        %s,\n" "        '%s',"
-        ) % self._get_common_elms()
-        print(code, file=self._stream)
-        arglist = [_to_arg_definition(*i) for i in self._iter_args()]
-        print(",\n".join(arglist), file=self._stream)
-        print("    ),", file=self._stream)
-
-    def _iter_args(self) -> Iterator[Tuple[str, str, List[str], _DefValType]]:
-        for typ, arg_name, _f, _defval in self._m.arguments:
-            ###########################################################
-            # IDL files that contain 'open arrays' or 'conformant
-            # varying arrays' method parameters are strange.
-            # These arrays have both a 'size_is()' and
-            # 'length_is()' attribute, like this example from
-            # dia2.idl (in the DIA SDK):
-            #
-            # interface IDiaSymbol: IUnknown {
-            # ...
-            #     HRESULT get_dataBytes(
-            #         [in] DWORD cbData,
-            #         [out] DWORD *pcbData,
-            #         [out, size_is(cbData),
-            #          length_is(*pcbData)] BYTE data[]
-            #     );
-            #
-            # The really strange thing is that the decompiled type
-            # library then contains this declaration, which declares
-            # the interface itself as [out] method parameter:
-            #
-            # interface IDiaSymbol: IUnknown {
-            # ...
-            #     HRESULT _stdcall get_dataBytes(
-            #         [in] unsigned long cbData,
-            #         [out] unsigned long* pcbData,
-            #         [out] IDiaSymbol data);
-            #
-            # Of course, comtypes does not accept a COM interface
-            # as method parameter; so replace the parameter type
-            # with the comtypes spelling of 'unsigned char *', and
-            # mark the parameter as [in, out], so the IDL
-            # equivalent would be like this:
-            #
-            # interface IDiaSymbol: IUnknown {
-            # ...
-            #     HRESULT _stdcall get_dataBytes(
-            #         [in] unsigned long cbData,
-            #         [out] unsigned long* pcbData,
-            #         [in, out] BYTE data[]);
-            ###########################################################
-            idlflags = list(_f)  # shallow copy to avoid side effects
-            if isinstance(typ, typedesc.ComInterface):
-                type_name = "OPENARRAY"
-                if "in" not in idlflags:
-                    idlflags.append("in")
-            else:
-                type_name = self._to_type_name(typ)
-            if "lcid" in idlflags:  # and 'in' in idlflags:
-                default = lcid
-            else:
-                default = _defval
-            yield (type_name, arg_name, idlflags, default)
-
-
-class DispMethodGenerator(object):
-    def __init__(self, m: typedesc.DispMethod) -> None:
-        self._m = m
-        self._stream = io.StringIO()
-        self._to_type_name = TypeNamer()
-
-    def generate(self):
-        # () -> str
-        if not self._m.arguments:
-            self._make_noargs()
-        else:
-            self._make_withargs()
-        return self._stream.getvalue()
-
-    def _get_common_elms(self) -> Tuple[List[_IdlFlagType], str, str]:
-        idlflags: List[_IdlFlagType] = []
-        idlflags.append(dispid(self._m.dispid))
-        idlflags.extend(self._m.idlflags)
-        if __debug__ and self._m.doc:
-            idlflags.insert(1, helpstring(self._m.doc))
-        type_name = self._to_type_name(self._m.returns)
-        return (idlflags, type_name, self._m.name)
-
-    def _make_noargs(self) -> None:
-        elms = self._get_common_elms()
-        code = "    DISPMETHOD(%r, %s, '%s')," % elms
-        if len(code) > 80:
-            code = (
-                "    DISPMETHOD(\n"
-                "        %r,\n"
-                "        %s,\n"
-                "        '%s',\n"
-                "    ),"
-            ) % elms
-        print(code, file=self._stream)
-
-    def _make_withargs(self) -> None:
-        code = (
-            "    DISPMETHOD(\n" "        %r,\n" "        %s,\n" "        '%s',"
-        ) % self._get_common_elms()
-        print(code, file=self._stream)
-        arglist = [_to_arg_definition(*i) for i in self._iter_args()]
-        print(",\n".join(arglist), file=self._stream)
-        print("    ),", file=self._stream)
-
-    def _iter_args(self) -> Iterator[Tuple[str, str, List[str], _DefValType]]:
-        for typ, arg_name, idlflags, default in self._m.arguments:
-            type_name = self._to_type_name(typ)
-            yield (type_name, arg_name, idlflags, default)
-
-
-class DispPropertyGenerator(object):
-    def __init__(self, m: typedesc.DispProperty) -> None:
-        self._m = m
-        self._to_type_name = TypeNamer()
-
-    def generate(self):
-        # () -> str
-        elms = self._get_common_elms()
-        code = "    DISPPROPERTY(%r, %s, '%s')," % elms
-        if len(code) > 80:
-            code = (
-                "    DISPPROPERTY(\n"
-                "        %r,\n"
-                "        %s,\n"
-                "        '%s'\n"
-                "    ),"
-            ) % elms
-        return code + "\n"
-
-    def _get_common_elms(self) -> Tuple[List[_IdlFlagType], str, str]:
-        idlflags: List[_IdlFlagType] = []
-        idlflags.append(dispid(self._m.dispid))
-        idlflags.extend(self._m.idlflags)
-        if __debug__ and self._m.doc:
-            idlflags.insert(1, helpstring(self._m.doc))
-        type_name = self._to_type_name(self._m.typ)
-        return (idlflags, type_name, self._m.name)
+_InterfaceTypeDesc = _UnionT[
+    typedesc.ComInterface,
+    typedesc.ComInterfaceHead,
+    typedesc.ComInterfaceBody,
+    typedesc.DispInterface,
+    typedesc.DispInterfaceHead,
+    typedesc.DispInterfaceBody,
+]
 
 
 class CodeGenerator(object):
-    def __init__(self, known_symbols=None):
+    def __init__(self, known_symbols=None, known_interfaces=None) -> None:
         self.stream = io.StringIO()
-        self.imports = ImportedNamespaces()
-        self.declarations = DeclaredNamespaces()
-        self.enums = EnumerationNamespaces()
+        self.imports = namespaces.ImportedNamespaces()
+        self.declarations = namespaces.DeclaredNamespaces()
+        self.enums = namespaces.EnumerationNamespaces()
+        self.unnamed_enum_members: List[Tuple[str, int]] = []
         self._to_type_name = TypeNamer()
         self.known_symbols = known_symbols or {}
+        self.known_interfaces = known_interfaces or {}
 
         self.done = set()  # type descriptions that have been generated
         self.names = set()  # names that have been generated
         self.externals = []  # typelibs imported to generated module
-        self.aliases: Dict[str, str] = {}
+        self.enum_aliases: Dict[str, str] = {}
         self.last_item_class = False
 
     def generate(self, item):
         if item in self.done:
             return
+        if self._is_interface_typedesc(item):
+            self._define_interface(item)
+            return
         if isinstance(item, typedesc.StructureHead):
             name = getattr(item.struct, "name", None)
         else:
             name = getattr(item, "name", None)
         if name in self.known_symbols:
             self.imports.add(name, symbols=self.known_symbols)
-
             self.done.add(item)
             if isinstance(item, typedesc.Structure):
                 self.done.add(item.get_head())
@@ -572,6 +202,19 @@ class CodeGenerator(object):
         print(file=output)
         print(self.declarations.getvalue(), file=output)
         print(file=output)
+        if self.unnamed_enum_members:
+            print("# values for unnamed enumeration", file=output)
+            for n, v in self.unnamed_enum_members:
+                print(f"{n} = {v}", file=output)
+            print(file=output)
+        if self.enums:
+            print(self.enums.to_constants(), file=output)
+            print(file=output)
+        if self.enum_aliases:
+            print("# aliases for enums", file=output)
+            for k, v in self.enum_aliases.items():
+                print(f"{k} = {v}", file=output)
+            print(file=output)
         print(self.stream.getvalue(), file=output)
         print(self._make_dunder_all_part(), file=output)
         print(file=output)
@@ -596,12 +239,12 @@ class CodeGenerator(object):
         print(self._make_friendly_module_import_part(modname), file=output)
         print(file=output)
         print(file=output)
-        print(self.enums.getvalue(), file=output)
-        print(file=output)
-        print(file=output)
-        enum_aliases = self.enum_aliases
-        if enum_aliases:
-            for k, v in enum_aliases.items():
+        if self.enums:
+            print(self.enums.to_intflags(), file=output)
+            print(file=output)
+            print(file=output)
+        if self.enum_aliases:
+            for k, v in self.enum_aliases.items():
                 print(f"{k} = {v}", file=output)
             print(file=output)
             print(file=output)
@@ -639,10 +282,6 @@ class CodeGenerator(object):
             part = f"from {modname} import (\n{joined_names}\n)"
         return part
 
-    @property
-    def enum_aliases(self) -> Dict[str, str]:
-        return {k: v for k, v in self.aliases.items() if v in self.enums}
-
     def need_VARIANT_imports(self, value):
         text = repr(value)
         if "Decimal(" in text:
@@ -667,23 +306,19 @@ class CodeGenerator(object):
         if keyword.iskeyword(tp.name):
             # XXX use logging!
             if __warn_on_munge__:
-                print("# Fixing keyword as EnumValue for %s" % tp.name)
+                print(f"# Fixing keyword as EnumValue for {tp.name}")
         tp_name = self._to_type_name(tp)
-        print("%s = %d" % (tp_name, value), file=self.stream)
         if tp.enumeration.name:
             self.enums.add(tp.enumeration.name, tp_name, value)
+        else:
+            self.unnamed_enum_members.append((tp_name, value))
         self.names.add(tp_name)
 
     def Enumeration(self, tp: typedesc.Enumeration) -> None:
         self.last_item_class = False
-        if tp.name:
-            print("# values for enumeration '%s'" % tp.name, file=self.stream)
-        else:
-            print("# values for unnamed enumeration", file=self.stream)
         for item in tp.values:
             self.generate(item)
         if tp.name:
-            print("%s = c_int  # enum" % tp.name, file=self.stream)
             self.names.add(tp.name)
 
     def Typedef(self, tp: typedesc.Typedef) -> None:
@@ -697,9 +332,11 @@ class CodeGenerator(object):
             if definition in self.known_symbols:
                 self.declarations.add(tp.name, definition)
             else:
-                print("%s = %s" % (tp.name, definition), file=self.stream)
-                self.aliases[tp.name] = definition
-                self.last_item_class = False
+                if isinstance(tp.typ, typedesc.Enumeration):
+                    self.enum_aliases[tp.name] = definition
+                else:
+                    print(f"{tp.name} = {definition}", file=self.stream)
+                    self.last_item_class = False
         self.names.add(tp.name)
 
     def FundamentalType(self, item: typedesc.FundamentalType) -> None:
@@ -823,11 +460,11 @@ class CodeGenerator(object):
         # on COM interfaces:
         if not methods:
             try:
-                pack = calc_packing(body.struct, fields)
+                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)
-            except PackingError as details:
+            except packing.PackingError as details:
                 # if packing fails, write a warning comment to the output.
                 import warnings
 
@@ -884,7 +521,7 @@ class CodeGenerator(object):
                     "# The size and alignment check for %s is skipped."
                 )
                 print(msg % body.struct.name, file=self.stream)
-            elif body.struct.name not in dont_assert_size:
+            elif body.struct.name not in packing.dont_assert_size:
                 print(file=self.stream)
                 size = body.struct.size // 8
                 print(
@@ -1015,14 +652,14 @@ class CodeGenerator(object):
         self.last_item_class = True
 
         print("class %s(CoClass):" % coclass.name, file=self.stream)
-        doc = getattr(coclass, "doc", None)
-        if doc:
-            print(self._to_docstring(doc), 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)
         if self.filename is not None:
             print("    _typelib_path_ = typelib_path", file=self.stream)
-        # X print >> self.stream, "POINTER(%s).__ctypes_from_outparam__ = wrap" % coclass.name
+        # X print
+        # >> self.stream, "POINTER(%s).__ctypes_from_outparam__ = wrap" % coclass.name
 
         libid = coclass.tlibattr.guid
         wMajor, wMinor = coclass.tlibattr.wMajorVerNum, coclass.tlibattr.wMinorVerNum
@@ -1033,23 +670,11 @@ class CodeGenerator(object):
         print(file=self.stream)
         print(file=self.stream)
 
-        for itf, idlflags in coclass.interfaces:
+        for itf, _ in coclass.interfaces:
             self.generate(itf.get_head())
-        implemented = []
-        sources = []
-        for item in coclass.interfaces:
-            # item is (interface class, impltypeflags)
-            if item[1] & 2:  # IMPLTYPEFLAG_FSOURCE
-                # source interface
-                where = sources
-            else:
-                # sink interface
-                where = implemented
-            if item[1] & 1:  # IMPLTYPEFLAG_FDEAULT
-                # The default interface should be the first item on the list
-                where.insert(0, self._to_type_name(item[0]))
-            else:
-                where.append(self._to_type_name(item[0]))
+        impl, src = typedesc.groupby_impltypeflags(coclass.interfaces)
+        implemented = [self._to_type_name(itf) for itf in impl]
+        sources = [self._to_type_name(itf) for itf in src]
 
         if implemented:
             self.last_item_class = False
@@ -1066,11 +691,63 @@ class CodeGenerator(object):
 
         self.names.add(coclass.name)
 
+    def _is_interface_typedesc(
+        self, item: Any
+    ) -> "comtypes.hints.TypeGuard[_InterfaceTypeDesc]":
+        return isinstance(
+            item,
+            (
+                typedesc.ComInterface,
+                typedesc.ComInterfaceHead,
+                typedesc.ComInterfaceBody,
+                typedesc.DispInterface,
+                typedesc.DispInterfaceHead,
+                typedesc.DispInterfaceBody,
+            ),
+        )
+
+    def _define_interface(self, item: _InterfaceTypeDesc) -> None:
+        if isinstance(
+            item,
+            (
+                typedesc.ComInterfaceHead,
+                typedesc.ComInterfaceBody,
+                typedesc.DispInterfaceHead,
+                typedesc.DispInterfaceBody,
+            ),
+        ):
+            if self._is_known_interface(item.itf):
+                self.imports.add(item.itf.name, symbols=self.known_symbols)
+                self.done.add(item)
+                return
+        elif isinstance(item, (typedesc.ComInterface, typedesc.DispInterface)):
+            if self._is_known_interface(item):
+                self.imports.add(item.name, symbols=self.known_symbols)
+                self.done.add(item)
+                self.done.add(item.get_head())
+                self.done.add(item.get_body())
+                return
+        else:
+            raise TypeError
+        self.done.add(item)  # to avoid infinite recursion.
+        mth = getattr(self, type(item).__name__)
+        mth(item)
+
     def ComInterface(self, itf: typedesc.ComInterface) -> None:
         self.generate(itf.get_head())
         self.generate(itf.get_body())
         self.names.add(itf.name)
 
+    def _is_known_interface(
+        self, item: _UnionT[typedesc.ComInterface, typedesc.DispInterface]
+    ) -> bool:
+        """Returns whether an interface is statically defined in `comtypes`,
+        based on its name and iid.
+        """
+        if item.name in self.known_interfaces:
+            return self.known_interfaces[item.name] == item.iid
+        return False
+
     def _is_enuminterface(self, itf: typedesc.ComInterface) -> bool:
         # Check if this is an IEnumXXX interface
         if not itf.name.startswith("IEnum"):
@@ -1082,14 +759,11 @@ class CodeGenerator(object):
         return True
 
     def ComInterfaceHead(self, head: typedesc.ComInterfaceHead) -> None:
-        if head.itf.name in self.known_symbols:
-            return
-        base = head.itf.base
         if head.itf.base is None:
             # we don't beed to generate IUnknown
             return
-        self.generate(base.get_head())
-        self.more.add(base)
+        self.generate(head.itf.base.get_head())
+        self.more.add(head.itf.base)
         basename = self._to_type_name(head.itf.base)
 
         self.imports.add("comtypes", "GUID")
@@ -1101,9 +775,8 @@ class CodeGenerator(object):
         self.last_item_class = True
 
         print("class %s(%s):" % (head.itf.name, basename), file=self.stream)
-        doc = getattr(head.itf, "doc", None)
-        if doc:
-            print(self._to_docstring(doc), 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)
@@ -1130,11 +803,11 @@ class CodeGenerator(object):
             print("            return item", file=self.stream)
             print("        raise IndexError(index)", file=self.stream)
 
-        annotaions = typeannotator.ComInterfaceMembersAnnotator(head.itf).generate()
-        if annotaions:
+        annotations = typeannotator.ComInterfaceMembersAnnotator(head.itf).generate()
+        if annotations:
             print(file=self.stream)
             print("    if TYPE_CHECKING:  # commembers", file=self.stream)
-            print(annotaions, file=self.stream, end="")
+            print(annotations, file=self.stream)
 
         print(file=self.stream)
         print(file=self.stream)
@@ -1250,19 +923,18 @@ class CodeGenerator(object):
         self.last_item_class = True
 
         print("class %s(%s):" % (head.itf.name, basename), file=self.stream)
-        doc = getattr(head.itf, "doc", None)
-        if doc:
-            print(self._to_docstring(doc), 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("    _methods_ = []", file=self.stream)
 
-        annotaions = typeannotator.DispInterfaceMembersAnnotator(head.itf).generate()
-        if annotaions:
+        annotations = typeannotator.DispInterfaceMembersAnnotator(head.itf).generate()
+        if annotations:
             print(file=self.stream)
             print("    if TYPE_CHECKING:  # dispmembers", file=self.stream)
-            print(annotaions, file=self.stream, end="")
+            print(annotations, file=self.stream)
 
         print(file=self.stream)
         print(file=self.stream)
@@ -1304,7 +976,7 @@ class CodeGenerator(object):
         if __debug__ and m.doc:
             self.imports.add("comtypes", "helpstring")
         gen = ComMethodGenerator(m, isdual)
-        print(gen.generate(), file=self.stream, end="")
+        print(gen.generate(), file=self.stream)
         self.last_item_class = False
         for typ, _, _, default in m.arguments:
             if isinstance(typ, typedesc.ComInterface):
@@ -1322,7 +994,7 @@ class CodeGenerator(object):
         if __debug__ and m.doc:
             self.imports.add("comtypes", "helpstring")
         gen = DispMethodGenerator(m)
-        print(gen.generate(), file=self.stream, end="")
+        print(gen.generate(), file=self.stream)
         self.last_item_class = False
         for _, _, _, default in m.arguments:
             if default is not None:
@@ -1334,253 +1006,5 @@ class CodeGenerator(object):
         if __debug__ and prop.doc:
             self.imports.add("comtypes", "helpstring")
         gen = DispPropertyGenerator(prop)
-        print(gen.generate(), file=self.stream, end="")
+        print(gen.generate(), file=self.stream)
         self.last_item_class = False
-
-
-class TypeNamer(object):
-    def __call__(self, t: Any) -> str:
-        # Return a string, containing an expression which can be used
-        # to refer to the type. Assumes the 'from ctypes import *'
-        # namespace is available.
-        if isinstance(t, typedesc.SAFEARRAYType):
-            return "_midlSAFEARRAY(%s)" % 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)
-        elif isinstance(t, typedesc.ArrayType):
-            return "%s * %s" % (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)
-            else:
-                return "CFUNCTYPE(%s)" % ", ".join(args)
-        elif isinstance(t, typedesc.CvQualifiedType):
-            # const and volatile are ignored
-            return "%s" % self(t.typ)
-        elif isinstance(t, typedesc.FundamentalType):
-            return ctypes_names[t.name]
-        elif isinstance(t, typedesc.Structure):
-            return t.name
-        elif isinstance(t, typedesc.Enumeration):
-            if t.name:
-                return t.name
-            return "c_int"  # enums are integers
-        elif isinstance(t, typedesc.EnumValue):
-            if keyword.iskeyword(t.name):
-                return t.name + "_"
-            return t.name
-        elif isinstance(t, typedesc.External):
-            # 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 t.name
-
-    def _inspect_PointerType(
-        self, t: typedesc.PointerType, count: int = 0
-    ) -> Tuple[Any, int]:
-        if ASSUME_STRINGS:
-            x = get_real_type(t.typ)
-            if isinstance(x, typedesc.FundamentalType):
-                if x.name == "char":
-                    return typedesc.Typedef("STRING", x), count
-                elif x.name == "wchar_t":
-                    return typedesc.Typedef("WSTRING", x), count
-        if isinstance(t.typ, typedesc.FunctionType):
-            return t.typ, count
-        if isinstance(t.typ, typedesc.FundamentalType):
-            if t.typ.name == "void":
-                return typedesc.Typedef("c_void_p", t.typ), count
-        if isinstance(t.typ, typedesc.PointerType):
-            return self._inspect_PointerType(t.typ, count + 1)
-        return t.typ, count + 1
-
-
-class ImportedNamespaces(object):
-    def __init__(self):
-        self.data = {}
-
-    def add(self, name1, name2=None, symbols=None):
-        """Adds a namespace will be imported.
-
-        Examples:
-            >>> imports = ImportedNamespaces()
-            >>> imports.add('datetime')
-            >>> imports.add('ctypes', '*')
-            >>> imports.add('decimal', 'Decimal')
-            >>> imports.add('GUID', symbols={'GUID': 'comtypes'})
-            >>> for name in ('COMMETHOD', 'DISPMETHOD', 'IUnknown', 'dispid',
-            ...              'CoClass', 'BSTR', 'DISPPROPERTY'):
-            ...     imports.add('comtypes', name)
-            >>> imports.add('ctypes.wintypes')
-            >>> print(imports.getvalue())
-            from ctypes import *
-            import datetime
-            from decimal import Decimal
-            from comtypes import (
-                BSTR, CoClass, COMMETHOD, dispid, DISPMETHOD, DISPPROPERTY, GUID,
-                IUnknown
-            )
-            import ctypes.wintypes
-            >>> assert imports.get_symbols() == {
-            ...     'Decimal', 'GUID', 'COMMETHOD', 'DISPMETHOD', 'IUnknown',
-            ...     'dispid', 'CoClass', 'BSTR', 'DISPPROPERTY'
-            ... }
-        """
-        if name2 is None:
-            import_ = name1
-            if not symbols:
-                self.data[import_] = None
-                return
-            from_ = symbols[import_]
-        else:
-            from_, import_ = name1, name2
-        self.data[import_] = from_
-
-    def __contains__(self, item):
-        """Returns item has already added.
-
-        Examples:
-            >>> imports = ImportedNamespaces()
-            >>> imports.add('datetime')
-            >>> imports.add('ctypes', '*')
-            >>> 'datetime' in imports
-            True
-            >>> ('ctypes', '*') in imports
-            True
-            >>> 'os' in imports
-            False
-            >>> 'ctypes' in imports
-            False
-            >>> ('ctypes', 'c_int') in imports
-            False
-        """
-        if isinstance(item, tuple):
-            from_, import_ = item
-        else:
-            from_, import_ = None, item
-        if import_ in self.data:
-            return self.data[import_] == from_
-        return False
-
-    def get_symbols(self) -> Set[str]:
-        names = set()
-        for key, val in self.data.items():
-            if val is None or key == "*":
-                continue
-            names.add(key)
-        return names
-
-    def _make_line(self, from_, imports):
-        import_ = ", ".join(imports)
-        code = "from %s import %s" % (from_, 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_)
-        return code
-
-    def getvalue(self):
-        ns = {}
-        lines = []
-        for key, val in self.data.items():
-            if val is None:
-                ns[key] = val
-            elif key == "*":
-                lines.append("from %s import *" % val)
-            else:
-                ns.setdefault(val, set()).add(key)
-        for key, val in ns.items():
-            if val is None:
-                lines.append("import %s" % key)
-            else:
-                names = sorted(val, key=lambda s: s.lower())
-                lines.append(self._make_line(key, names))
-        return "\n".join(lines)
-
-
-class DeclaredNamespaces(object):
-    def __init__(self):
-        self.data = {}
-
-    def add(self, alias, definition, comment=None):
-        """Adds a namespace will be declared.
-
-        Examples:
-            >>> declarations = DeclaredNamespaces()
-            >>> declarations.add('STRING', 'c_char_p')
-            >>> declarations.add('_lcid', '0', 'change this if required')
-            >>> print(declarations.getvalue())
-            STRING = c_char_p
-            _lcid = 0  # change this if required
-            >>> assert declarations.get_symbols() == {
-            ...     'STRING', '_lcid'
-            ... }
-        """
-        self.data[(alias, definition)] = comment
-
-    def get_symbols(self) -> Set[str]:
-        names = set()
-        for alias, _ in self.data.keys():
-            names.add(alias)
-        return names
-
-    def getvalue(self):
-        lines = []
-        for (alias, definition), comment in self.data.items():
-            code = "%s = %s" % (alias, definition)
-            if comment:
-                code = code + "  # %s" % comment
-            lines.append(code)
-        return "\n".join(lines)
-
-
-class EnumerationNamespaces(object):
-    def __init__(self):
-        self.data: Dict[str, List[Tuple[str, int]]] = {}
-
-    def add(self, enum_name: str, member_name: str, value: int) -> None:
-        """Adds a namespace will be enumeration and its member.
-
-        Examples:
-            >>> enums = EnumerationNamespaces()
-            >>> enums.add('Foo', 'ham', 1)
-            >>> enums.add('Foo', 'spam', 2)
-            >>> enums.add('Bar', 'bacon', 3)
-            >>> assert 'Foo' in enums
-            >>> assert 'Baz' not in enums
-            >>> print(enums.getvalue())  # <BLANKLINE> is necessary for doctest
-            class Foo(IntFlag):
-                ham = 1
-                spam = 2
-            <BLANKLINE>
-            <BLANKLINE>
-            class Bar(IntFlag):
-                bacon = 3
-        """
-        self.data.setdefault(enum_name, []).append((member_name, value))
-
-    def __contains__(self, item: str) -> bool:
-        return item in self.data
-
-    def get_symbols(self) -> Set[str]:
-        return set(self.data)
-
-    def getvalue(self) -> str:
-        blocks = []
-        for enum_name, enum_members in self.data.items():
-            lines = []
-            lines.append(f"class {enum_name}(IntFlag):")
-            for member_name, value in enum_members:
-                lines.append(f"    {member_name} = {value}")
-            blocks.append("\n".join(lines))
-        return "\n\n\n".join(blocks)