comtypes 1.4.0__zip → 1.4.2__zip

{comtypes-1.4.0 → comtypes-1.4.2}/comtypes/tools/codegenerator.py

@@ -208,28 +208,26 @@ def _to_arg_definition(
     default: _DefValType,
 ) -> str:
     if default is not None:
-        elms = (idlflags, type_name, arg_name, default)
-        code = "        (%r, %s, '%s', %r)" % elms
+        code = f"        ({idlflags!r}, {type_name}, '{arg_name}', {default!r})"
         if len(code) > 80:
             code = (
                 "        (\n"
-                "            %r,\n"
-                "            %s,\n"
-                "            '%s',\n"
-                "            %r\n"
+                f"            {idlflags!r},\n"
+                f"            {type_name},\n"
+                f"            '{arg_name}',\n"
+                f"            {default!r}\n"
                 "        )"
-            ) % elms
+            )
     else:
-        elms = (idlflags, type_name, arg_name)
-        code = "        (%r, %s, '%s')" % elms
+        code = f"        ({idlflags!r}, {type_name}, '{arg_name}')"
         if len(code) > 80:
             code = (
                 "        (\n"
-                "            %r,\n"
-                "            %s,\n"
-                "            '%s',\n"
+                f"            {idlflags!r},\n"
+                f"            {type_name},\n"
+                f"            '{arg_name}',\n"
                 "        )"
-            ) % elms
+            )
     return code
 
 
@@ -237,16 +235,15 @@ class ComMethodGenerator(object):
     def __init__(self, m: typedesc.ComMethod, isdual: bool) -> None:
         self._m = m
         self._isdual = isdual
-        self._stream = io.StringIO()
+        self.data: List[str] = []
         self._to_type_name = TypeNamer()
 
-    def generate(self):
-        # () -> str
+    def generate(self) -> str:
         if not self._m.arguments:
             self._make_noargs()
         else:
             self._make_withargs()
-        return self._stream.getvalue()
+        return "\n".join(self.data)
 
     def _get_common_elms(self) -> Tuple[List[_IdlFlagType], str, str]:
         idlflags: List[_IdlFlagType] = []
@@ -261,26 +258,30 @@ class ComMethodGenerator(object):
         return (idlflags, type_name, self._m.name)
 
     def _make_noargs(self) -> None:
-        elms = self._get_common_elms()
-        code = "    COMMETHOD(%r, %s, '%s')," % elms
+        flags, type_name, member_name = self._get_common_elms()
+        code = f"    COMMETHOD({flags!r}, {type_name}, '{member_name}'),"
         if len(code) > 80:
             code = (
                 "    COMMETHOD(\n"
-                "        %r,\n"
-                "        %s,\n"
-                "        '%s',\n"
+                f"        {flags!r},\n"
+                f"        {type_name},\n"
+                f"        '{member_name}',\n"
                 "    ),"
-            ) % elms
-        print(code, file=self._stream)
+            )
+        self.data.append(code)
 
     def _make_withargs(self) -> None:
+        flags, type_name, member_name = self._get_common_elms()
         code = (
-            "    COMMETHOD(\n" "        %r,\n" "        %s,\n" "        '%s',"
-        ) % self._get_common_elms()
-        print(code, file=self._stream)
+            "    COMMETHOD(\n"
+            f"        {flags!r},\n"
+            f"        {type_name},\n"
+            f"        '{member_name}',"
+        )
+        self.data.append(code)
         arglist = [_to_arg_definition(*i) for i in self._iter_args()]
-        print(",\n".join(arglist), file=self._stream)
-        print("    ),", file=self._stream)
+        self.data.append(",\n".join(arglist))
+        self.data.append("    ),")
 
     def _iter_args(self) -> Iterator[Tuple[str, str, List[str], _DefValType]]:
         for typ, arg_name, _f, _defval in self._m.arguments:
@@ -341,16 +342,15 @@ class ComMethodGenerator(object):
 class DispMethodGenerator(object):
     def __init__(self, m: typedesc.DispMethod) -> None:
         self._m = m
-        self._stream = io.StringIO()
+        self.data: List[str] = []
         self._to_type_name = TypeNamer()
 
-    def generate(self):
-        # () -> str
+    def generate(self) -> str:
         if not self._m.arguments:
             self._make_noargs()
         else:
             self._make_withargs()
-        return self._stream.getvalue()
+        return "\n".join(self.data)
 
     def _get_common_elms(self) -> Tuple[List[_IdlFlagType], str, str]:
         idlflags: List[_IdlFlagType] = []
@@ -362,26 +362,30 @@ class DispMethodGenerator(object):
         return (idlflags, type_name, self._m.name)
 
     def _make_noargs(self) -> None:
-        elms = self._get_common_elms()
-        code = "    DISPMETHOD(%r, %s, '%s')," % elms
+        flags, type_name, member_name = self._get_common_elms()
+        code = f"    DISPMETHOD({flags!r}, {type_name}, '{member_name}'),"
         if len(code) > 80:
             code = (
                 "    DISPMETHOD(\n"
-                "        %r,\n"
-                "        %s,\n"
-                "        '%s',\n"
+                f"        {flags!r},\n"
+                f"        {type_name},\n"
+                f"        '{member_name}',\n"
                 "    ),"
-            ) % elms
-        print(code, file=self._stream)
+            )
+        self.data.append(code)
 
     def _make_withargs(self) -> None:
+        flags, type_name, member_name = self._get_common_elms()
         code = (
-            "    DISPMETHOD(\n" "        %r,\n" "        %s,\n" "        '%s',"
-        ) % self._get_common_elms()
-        print(code, file=self._stream)
+            "    DISPMETHOD(\n"
+            f"        {flags!r},\n"
+            f"        {type_name},\n"
+            f"        '{member_name}',"
+        )
+        self.data.append(code)
         arglist = [_to_arg_definition(*i) for i in self._iter_args()]
-        print(",\n".join(arglist), file=self._stream)
-        print("    ),", file=self._stream)
+        self.data.append(",\n".join(arglist))
+        self.data.append("    ),")
 
     def _iter_args(self) -> Iterator[Tuple[str, str, List[str], _DefValType]]:
         for typ, arg_name, idlflags, default in self._m.arguments:
@@ -394,19 +398,18 @@ class DispPropertyGenerator(object):
         self._m = m
         self._to_type_name = TypeNamer()
 
-    def generate(self):
-        # () -> str
-        elms = self._get_common_elms()
-        code = "    DISPPROPERTY(%r, %s, '%s')," % elms
+    def generate(self) -> str:
+        flags, type_name, member_name = self._get_common_elms()
+        code = f"    DISPPROPERTY({flags!r}, {type_name}, '{member_name}'),"
         if len(code) > 80:
             code = (
                 "    DISPPROPERTY(\n"
-                "        %r,\n"
-                "        %s,\n"
-                "        '%s'\n"
+                f"        {flags!r},\n"
+                f"        {type_name},\n"
+                f"        '{member_name}'\n"
                 "    ),"
-            ) % elms
-        return code + "\n"
+            )
+        return code
 
     def _get_common_elms(self) -> Tuple[List[_IdlFlagType], str, str]:
         idlflags: List[_IdlFlagType] = []
@@ -418,14 +421,26 @@ class DispPropertyGenerator(object):
         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.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
@@ -436,13 +451,15 @@ class CodeGenerator(object):
     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 +589,12 @@ 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)
+        print(self.enums.to_constants(), file=output)
         print(self.stream.getvalue(), file=output)
         print(self._make_dunder_all_part(), file=output)
         print(file=output)
@@ -596,7 +619,7 @@ 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(self.enums.to_intflags(), file=output)
         print(file=output)
         print(file=output)
         enum_aliases = self.enum_aliases
@@ -669,21 +692,17 @@ class CodeGenerator(object):
             if __warn_on_munge__:
                 print("# Fixing keyword as EnumValue for %s" % 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)
+            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:
@@ -1066,11 +1085,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 +1153,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")
@@ -1130,11 +1198,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)
@@ -1258,11 +1326,11 @@ class CodeGenerator(object):
         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 +1372,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 +1390,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,7 +1402,7 @@ 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
 
 
@@ -1546,28 +1614,38 @@ class DeclaredNamespaces(object):
 
 class EnumerationNamespaces(object):
     def __init__(self):
-        self.data: Dict[str, List[str]] = {}
+        self.data: Dict[str, List[Tuple[str, int]]] = {}
 
-    def add(self, enum_name: str, member_name: str) -> None:
+    def add(self, enum_name: str, member_name: str, value: int) -> None:
         """Adds a namespace will be enumeration and its member.
 
         Examples:
+            <BLANKLINE> is necessary for doctest
             >>> enums = EnumerationNamespaces()
-            >>> enums.add('Foo', 'ham')
-            >>> enums.add('Foo', 'spam')
-            >>> enums.add('Bar', 'bacon')
+            >>> 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
+            >>> print(enums.to_intflags())
             class Foo(IntFlag):
-                ham = __wrapper_module__.ham
-                spam = __wrapper_module__.spam
+                ham = 1
+                spam = 2
             <BLANKLINE>
             <BLANKLINE>
             class Bar(IntFlag):
-                bacon = __wrapper_module__.bacon
+                bacon = 3
+            >>> print(enums.to_constants())
+            # values for enumeration 'Foo'
+            ham = 1
+            spam = 2
+            Foo = c_int  # enum
+            <BLANKLINE>
+            # values for enumeration 'Bar'
+            bacon = 3
+            Bar = c_int  # enum
         """
-        self.data.setdefault(enum_name, []).append(member_name)
+        self.data.setdefault(enum_name, []).append((member_name, value))
 
     def __contains__(self, item: str) -> bool:
         return item in self.data
@@ -1575,12 +1653,23 @@ class EnumerationNamespaces(object):
     def get_symbols(self) -> Set[str]:
         return set(self.data)
 
-    def getvalue(self) -> str:
+    def to_constants(self) -> str:
+        blocks = []
+        for enum_name, enum_members in self.data.items():
+            lines = []
+            lines.append(f"# values for enumeration '{enum_name}'")
+            for n, v in enum_members:
+                lines.append(f"{n} = {v}")
+            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():
             lines = []
             lines.append(f"class {enum_name}(IntFlag):")
-            for member_name in enum_members:
-                lines.append(f"    {member_name} = __wrapper_module__.{member_name}")
+            for member_name, value in enum_members:
+                lines.append(f"    {member_name} = {value}")
             blocks.append("\n".join(lines))
         return "\n\n\n".join(blocks)

{comtypes-1.4.0 → comtypes-1.4.2}/comtypes/tools/typeannotator.py

@@ -1,5 +1,4 @@
 import abc
-import io
 import keyword
 from typing import (
     Any,
@@ -55,7 +54,7 @@ _CatMths = Tuple[  # categorized methods
 
 class _MethodsAnnotator(abc.ABC, Generic[_T_MTD]):
     def __init__(self) -> None:
-        self.stream = io.StringIO()
+        self.data: List[str] = []
 
     @abc.abstractmethod
     def to_method_annotator(self, method: _T_MTD) -> _MethodAnnotator[_T_MTD]:
@@ -100,7 +99,7 @@ class _MethodsAnnotator(abc.ABC, Generic[_T_MTD]):
             else:
                 self._define_member(f"pass  # what does `{name}` behave?")
             self._patch_dunder(name)
-        return self.stream.getvalue()
+        return "\n".join(f"        {d}" for d in self.data)
 
     def _patch_dunder(self, name: str) -> None:
         if name == "Count":
@@ -141,7 +140,7 @@ class _MethodsAnnotator(abc.ABC, Generic[_T_MTD]):
         self._define_member(content)
 
     def _define_member(self, content: str) -> None:
-        print(f"        {content}", file=self.stream)
+        self.data.append(content)
 
     def _gen_method(self, name: str, mth: _T_MTD) -> None:
         self._define_member(self.to_method_annotator(mth).getvalue(name))
@@ -237,13 +236,13 @@ class ComMethodAnnotator(_MethodAnnotator[typedesc.ComMethod]):
                     #       should be a special callback.
                     inargs.append("**kwargs: Any")
                     break
-                inargs.append(f"{argname}: Any")
+                inargs.append(f"{argname}: hints.Incomplete")
             else:
-                inargs.append(f"{argname}: Any = ...")
+                inargs.append(f"{argname}: hints.Incomplete = ...")
                 has_optional = True
-        outargs = ["Any" for _ in self._iter_outarg_specs()]
+        outargs = ["hints.Incomplete" for _ in self._iter_outarg_specs()]
         if not outargs:
-            out = "Any"
+            out = "hints.Hresult"
         elif len(outargs) == 1:
             out = outargs[0]
         else:
@@ -280,11 +279,11 @@ class DispMethodAnnotator(_MethodAnnotator[typedesc.DispMethod]):
                     #       should be a special callback.
                     inargs.append("**kwargs: Any")
                     break
-                inargs.append(f"{argname}: Any")
+                inargs.append(f"{argname}: hints.Incomplete")
             else:
-                inargs.append(f"{argname}: Any = ...")
+                inargs.append(f"{argname}: hints.Incomplete = ...")
                 has_optional = True
-        out = "Any"
+        out = "hints.Incomplete"
         in_ = ("self, " + ", ".join(inargs)) if inargs else "self"
         return f"def {name}({in_}) -> {out}: ..."
 
@@ -297,7 +296,6 @@ class DispMethodsAnnotator(_MethodsAnnotator[typedesc.DispMethod]):
 class DispInterfaceMembersAnnotator(object):
     def __init__(self, itf: typedesc.DispInterface):
         self.itf = itf
-        self.stream = io.StringIO()
 
     def _categorize_members(
         self,
@@ -313,7 +311,11 @@ class DispInterfaceMembersAnnotator(object):
 
     def generate(self) -> str:
         props, methods = self._categorize_members()
+        property_lines: List[str] = []
         for mem in props:
-            print("        @property  # dispprop", file=self.stream)
-            print(f"        def {mem.name}(self) -> Any: ...", file=self.stream)
-        return self.stream.getvalue() + DispMethodsAnnotator().generate(methods)
+            property_lines.append("@property  # dispprop")
+            out = "hints.Incomplete"
+            property_lines.append(f"def {mem.name}(self) -> {out}: ...")
+        dispprops = "\n".join(f"        {p}" for p in property_lines)
+        dispmethods = DispMethodsAnnotator().generate(methods)
+        return "\n".join(d for d in (dispprops, dispmethods) if d)

{comtypes-1.4.0 → comtypes-1.4.2}/comtypes/tools/typedesc.py

@@ -176,7 +176,7 @@ class ComInterface(object):
         self,
         name: str,
         members: List[ComMethod],
-        base: Any,
+        base: "Optional[ComInterface]",
         iid: str,
         idlflags: List[str],
     ) -> None:

{comtypes-1.4.0 → comtypes-1.4.2/comtypes.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: comtypes
-Version: 1.4.0
+Version: 1.4.2
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases

{comtypes-1.4.0 → comtypes-1.4.2}/comtypes.egg-info/SOURCES.txt

@@ -68,6 +68,7 @@ comtypes/test/test_casesensitivity.py
 comtypes/test/test_clear_cache.py
 comtypes/test/test_client.py
 comtypes/test/test_client_dynamic.py
+comtypes/test/test_client_regenerate_modules.py
 comtypes/test/test_collections.py
 comtypes/test/test_comserver.py
 comtypes/test/test_createwrappers.py