comtypes 1.4.9__zip → 1.4.11__zip

comtypes-1.4.11/comtypes/tools/codegenerator/comments.py

@@ -0,0 +1,79 @@
+import io
+
+from comtypes.tools import typedesc
+
+
+class ComInterfaceBodyImplCommentWriter(object):
+    def __init__(self, stream: io.StringIO):
+        self.stream = stream
+
+    def write(self, body: typedesc.ComInterfaceBody) -> None:
+        print(
+            "################################################################",
+            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:
+            if isinstance(m, typedesc.ComMethod):
+                # m.arguments is a sequence of tuples:
+                # (argtype, argname, idlflags, docstring)
+                # Some typelibs have unnamed method parameters!
+                inargs = [a[1] or "<unnamed>" for a in m.arguments if "out" not in a[2]]
+                outargs = [a[1] or "<unnamed>" for a in m.arguments if "out" in a[2]]
+                if "propget" in m.idlflags:
+                    methods.setdefault(m.name, [0, inargs, outargs, m.doc])[0] |= 1
+                elif "propput" in m.idlflags:
+                    methods.setdefault(m.name, [0, inargs[:-1], inargs[-1:], m.doc])[
+                        0
+                    ] |= 2
+                else:
+                    methods[m.name] = [0, inargs, outargs, m.doc]
+
+        for name, (typ, inargs, outargs, doc) in methods.items():
+            if typ == 0:  # method
+                print(
+                    f"#     def {name}({', '.join(['self'] + inargs)}):",
+                    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(
+                    f"#     def {name}({', '.join(['self'] + inargs)}):",
+                    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(
+                    f"#     def _set({', '.join(['self'] + inargs + outargs)}):",
+                    file=self.stream,
+                )
+                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
+                print(
+                    f"#     {name} = property(fset = _set, doc = _set.__doc__)",
+                    file=self.stream,
+                )
+            elif typ == 3:  # propget + propput
+                print(
+                    f"#     def _get({', '.join(['self'] + inargs)}):",
+                    file=self.stream,
+                )
+                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
+                print(f"#         #return {', '.join(outargs)}", file=self.stream)
+                print(
+                    f"#     def _set({', '.join(['self'] + inargs + outargs)}):",
+                    file=self.stream,
+                )
+                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
+                print(
+                    f"#     {name} = property(_get, _set, doc = _set.__doc__)",
+                    file=self.stream,
+                )
+            else:
+                raise RuntimeError("BUG")
+            print("#", file=self.stream)

comtypes-1.4.11/comtypes/tools/codegenerator/heads.py

@@ -0,0 +1,192 @@
+import io
+from typing import Optional, Sequence
+
+from comtypes.tools import typedesc
+from comtypes.tools.codegenerator import typeannotator
+
+
+def _to_docstring(orig: str, depth: int = 1) -> str:
+    # increasing `depth` by one increases indentation by one
+    indent = "    " * depth
+    # some chars are replaced to avoid causing a `SyntaxError`
+    repled = orig.replace("\\", r"\\").replace('"', r"'")
+    return f'{indent}"""{repled}"""'
+
+
+class StructureHeadWriter(object):
+    def __init__(self, stream: io.StringIO) -> None:
+        self.stream = stream
+
+    def write(self, head: typedesc.StructureHead, basenames: Sequence[str]) -> None:
+        if head.struct.location:
+            print(f"# {head.struct.location}", file=self.stream)
+        if basenames:
+            method_names = [
+                m.name for m in head.struct.members if type(m) is typedesc.Method
+            ]
+            print(
+                f"class {head.struct.name}({', '.join(basenames)}):",
+                file=self.stream,
+            )
+            print(
+                "    _iid_ = GUID('{}') # please look up iid and fill in!",
+                file=self.stream,
+            )
+            if "Enum" in method_names:
+                print("    def __iter__(self):", file=self.stream)
+                print("        return self.Enum()", file=self.stream)
+            elif method_names == "Next Skip Reset Clone".split():
+                print("    def __iter__(self):", file=self.stream)
+                print("        return self", file=self.stream)
+                print(file=self.stream)
+                print("    def next(self):", file=self.stream)
+                print("         arr, fetched = self.Next(1)", file=self.stream)
+                print("         if fetched == 0:", file=self.stream)
+                print("             raise StopIteration", file=self.stream)
+                print("         return arr[0]", file=self.stream)
+
+        else:
+            methods = [m for m in head.struct.members if type(m) is typedesc.Method]
+
+            if methods:
+                # Hm. We cannot generate code for IUnknown...
+                print("assert 0, 'cannot generate code for IUnknown'", file=self.stream)
+                print(f"class {head.struct.name}(_com_interface):", file=self.stream)
+                print("    pass", file=self.stream)
+            elif type(head.struct) is typedesc.Structure:
+                print(f"class {head.struct.name}(Structure):", file=self.stream)
+                if hasattr(head.struct, "_recordinfo_"):
+                    print(
+                        f"    _recordinfo_ = {head.struct._recordinfo_!r}",
+                        file=self.stream,
+                    )
+                else:
+                    print("    pass", file=self.stream)
+            elif type(head.struct) is typedesc.Union:
+                print(f"class {head.struct.name}(Union):", file=self.stream)
+                print("    pass", file=self.stream)
+
+
+class LibraryHeadWriter(object):
+    def __init__(self, stream: io.StringIO) -> None:
+        self.stream = stream
+
+    def write(self, lib: typedesc.TypeLib) -> None:
+        # Hm, in user code we have to write:
+        # class MyServer(COMObject, ...):
+        #     _com_interfaces_ = [MyTypeLib.IInterface]
+        #     _reg_typelib_ = MyTypeLib.Library._reg_typelib_
+        #                               ^^^^^^^
+        # Should the '_reg_typelib_' attribute be at top-level in the
+        # generated code, instead as being an attribute of the
+        # 'Library' symbol?
+        print("class Library(object):", file=self.stream)
+        if lib.doc:
+            print(_to_docstring(lib.doc), file=self.stream)
+
+        if lib.name:
+            print(f"    name = {lib.name!r}", file=self.stream)
+
+        print(
+            f"    _reg_typelib_ = ({lib.guid!r}, {lib.major!r}, {lib.minor!r})",
+            file=self.stream,
+        )
+
+
+class CoClassHeadWriter(object):
+    def __init__(self, stream: io.StringIO, filename: Optional[str]) -> None:
+        self.stream = stream
+        self.filename = filename
+
+    def write(self, coclass: typedesc.CoClass) -> None:
+        print(f"class {coclass.name}(CoClass):", file=self.stream)
+        if coclass.doc:
+            print(_to_docstring(coclass.doc), 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
+        # >> self.stream, "POINTER(%s).__ctypes_from_outparam__ = wrap" % coclass.name
+
+        libid = coclass.tlibattr.guid
+        wMajor, wMinor = coclass.tlibattr.wMajorVerNum, coclass.tlibattr.wMinorVerNum
+        print(
+            f"    _reg_typelib_ = ({str(libid)!r}, {wMajor}, {wMinor})",
+            file=self.stream,
+        )
+
+
+class ComInterfaceHeadWriter(object):
+    def __init__(self, stream: io.StringIO) -> None:
+        self.stream = stream
+
+    def _is_enuminterface(self, itf: typedesc.ComInterface) -> bool:
+        # Check if this is an IEnumXXX interface
+        if not itf.name.startswith("IEnum"):
+            return False
+        member_names = [mth.name for mth in itf.members]
+        for name in ("Next", "Skip", "Reset", "Clone"):
+            if name not in member_names:
+                return False
+        return True
+
+    def write(self, head: typedesc.ComInterfaceHead, basename: str) -> None:
+        if head.itf.base is None:
+            # we don't beed to generate IUnknown
+            return
+
+        print(f"class {head.itf.name}({basename}):", file=self.stream)
+        if head.itf.doc:
+            print(_to_docstring(head.itf.doc), file=self.stream)
+
+        print("    _case_insensitive_ = True", 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)
+            print("    def __iter__(self):", file=self.stream)
+            print("        return self", file=self.stream)
+            print(file=self.stream)
+
+            print("    def __next__(self):", file=self.stream)
+            print("        item, fetched = self.Next(1)", file=self.stream)
+            print("        if fetched:", file=self.stream)
+            print("            return item", file=self.stream)
+            print("        raise StopIteration", file=self.stream)
+            print(file=self.stream)
+
+            print("    def __getitem__(self, index):", file=self.stream)
+            print("        self.Reset()", file=self.stream)
+            print("        self.Skip(index)", file=self.stream)
+            print("        item, fetched = self.Next(1)", file=self.stream)
+            print("        if fetched:", file=self.stream)
+            print("            return item", file=self.stream)
+            print("        raise IndexError(index)", file=self.stream)
+
+        annotations = typeannotator.ComInterfaceMembersAnnotator(head.itf).generate()
+        if annotations:
+            print(file=self.stream)
+            print("    if TYPE_CHECKING:  # commembers", file=self.stream)
+            print(annotations, file=self.stream)
+
+
+class DispInterfaceHeadWriter(object):
+    def __init__(self, stream: io.StringIO) -> None:
+        self.stream = stream
+
+    def write(self, head: typedesc.DispInterfaceHead, basename: str) -> None:
+        print(f"class {head.itf.name}({basename}):", file=self.stream)
+        if head.itf.doc:
+            print(_to_docstring(head.itf.doc), file=self.stream)
+        print("    _case_insensitive_ = True", 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()
+        if annotations:
+            print(file=self.stream)
+            print("    if TYPE_CHECKING:  # dispmembers", file=self.stream)
+            print(annotations, file=self.stream)

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

@@ -1,10 +1,7 @@
 import keyword
-from typing import Any
-from typing import List, Tuple
-from typing import Iterator
+from typing import Any, Iterator, List, Tuple
 from typing import Union as _UnionT
 
-import comtypes
 from comtypes.tools import typedesc
 from comtypes.tools.codegenerator.modulenamer import name_wrapper_module
 
@@ -317,7 +314,7 @@ class TypeNamer(object):
                 return f"CFUNCTYPE({', '.join(args)})"
         elif isinstance(t, typedesc.CvQualifiedType):
             # const and volatile are ignored
-            return "%s" % self(t.typ)
+            return f"{self(t.typ)}"
         elif isinstance(t, typedesc.FundamentalType):
             return ctypes_names[t.name]
         elif isinstance(t, typedesc.Structure):
@@ -328,7 +325,7 @@ class TypeNamer(object):
             return "c_int"  # enums are integers
         elif isinstance(t, typedesc.EnumValue):
             if keyword.iskeyword(t.name):
-                return t.name + "_"
+                return f"{t.name}_"
             return t.name
         elif isinstance(t, typedesc.External):
             # t.symbol_name - symbol to generate

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/tools/codegenerator/namespaces.py

@@ -1,10 +1,18 @@
-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
+from collections import Counter
+from typing import (
+    Dict,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    overload,
+)
+from typing import Union as _UnionT
 
 
 class ImportedNamespaces(object):

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

@@ -1,8 +1,18 @@
 import abc
 import keyword
-from typing import Any, Generic, Protocol, TypeVar
-from typing import Dict, List, Optional, Sequence, Tuple
-from typing import Iterable, Iterator
+from typing import (
+    Any,
+    Dict,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Protocol,
+    Sequence,
+    Tuple,
+    TypeVar,
+)
 
 from comtypes.tools import typedesc
 

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/tools/tlbparser.py

@@ -1,13 +1,12 @@
 import os
 import sys
-from typing import Any
-from typing import Dict, List, Optional, Tuple
-from ctypes import alignment, byref, c_void_p, sizeof, windll
+from _ctypes import COMError
+from ctypes import alignment, c_void_p, sizeof, windll
+from ctypes.wintypes import MAX_PATH
+from typing import Any, Dict, List, Optional, Tuple
 
-from comtypes import automation, BSTR, COMError, typeinfo
+from comtypes import automation, typeinfo
 from comtypes.tools import typedesc
-from comtypes.client._code_cache import _get_module_filename
-
 
 # Is the process 64-bit?
 is_64bits = sys.maxsize > 2**32
@@ -237,7 +236,7 @@ class Parser(object):
             elif fd.callconv == typeinfo.CC_STDCALL:
                 attributes = "__stdcall__"
             else:
-                raise ValueError("calling convention %d" % fd.callconv)
+                raise ValueError(f"calling convention {fd.callconv:d}")
 
             func = typedesc.Function(func_name, returns, attributes, extern=1)
             if func_doc is not None:
@@ -741,28 +740,29 @@ def get_tlib_filename(tlib: typeinfo.ITypeLib) -> Optional[str]:
     # seems if the typelib is not registered, there's no way to
     # determine the filename.
     la = tlib.GetLibAttr()
-    name = BSTR()
-    if 0 == windll.oleaut32.QueryPathOfRegTypeLib(
-        byref(la.guid), la.wMajorVerNum, la.wMinorVerNum, 0, byref(name)
-    ):
-        full_filename = name.value.split("\0")[0]
-        if not os.path.isabs(full_filename):
-            # workaround Windows 7 bug in QueryPathOfRegTypeLib returning relative path
-            try:
-                dll = windll.LoadLibrary(full_filename)
-                full_filename = _get_module_filename(dll._handle)
-                del dll
-            except OSError:
-                return None
-        return full_filename
-    return None
+    try:
+        full_filename = typeinfo.QueryPathOfRegTypeLib(
+            str(la.guid), la.wMajorVerNum, la.wMinorVerNum
+        )
+    except OSError:
+        return None
+
+    if not os.path.isabs(full_filename):
+        # workaround Windows 7 bug in QueryPathOfRegTypeLib returning relative path
+        try:
+            dll = windll.LoadLibrary(full_filename)
+            full_filename = typeinfo.GetModuleFileName(dll._handle, MAX_PATH)
+            del dll
+        except OSError:
+            return None
+    return full_filename
 
 
 def _py2exe_hint():
     # If the tlbparser is frozen, we need to include these
-    import comtypes.persist
-    import comtypes.typeinfo
-    import comtypes.automation
+    import comtypes.automation  # noqa
+    import comtypes.persist  # noqa
+    import comtypes.typeinfo  # noqa
 
 
 # -eof-

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/tools/typedesc.py

@@ -2,11 +2,12 @@
 # in typedesc_base
 
 import ctypes
-from typing import Any, List, Optional, Sequence, Tuple, Union as _UnionT
+from typing import Any, List, Optional, Sequence, Tuple
+from typing import Union as _UnionT
 
 from comtypes import typeinfo
-from comtypes.typeinfo import ITypeLib, TLIBATTR
 from comtypes.tools.typedesc_base import *
+from comtypes.typeinfo import TLIBATTR, ITypeLib
 
 
 class TypeLib(object):

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/tools/typedesc_base.py

@@ -1,6 +1,6 @@
 # typedesc.py - classes representing C type descriptions
-from typing import Any, SupportsInt
-from typing import List, Optional, Tuple, Union as _UnionT
+from typing import Any, List, Optional, SupportsInt, Tuple
+from typing import Union as _UnionT
 
 import comtypes