comtypes 1.4.8__zip → 1.4.10__zip

comtypes-1.4.10/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.10/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.8 → comtypes-1.4.10}/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
 
@@ -22,7 +19,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 +27,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,25 +296,25 @@ 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)
+            return f"{self(t.typ)}"
         elif isinstance(t, typedesc.FundamentalType):
             return ctypes_names[t.name]
         elif isinstance(t, typedesc.Structure):
@@ -328,13 +325,13 @@ 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
             # t.tlib - the ITypeLib pointer to the typelibrary containing the symbols definition
             modname = name_wrapper_module(t.tlib)
-            return "%s.%s" % (modname, t.symbol_name)
+            return f"{modname}.{t.symbol_name}"
         return t.name
 
     def _inspect_PointerType(

{comtypes-1.4.8 → comtypes-1.4.10}/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.8 → comtypes-1.4.10}/comtypes/tools/codegenerator/packing.py

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

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

@@ -1,19 +1,29 @@
 import abc
 import keyword
-from typing import Any, Generic, TypeVar, TYPE_CHECKING
-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
 
-if TYPE_CHECKING:
-    from comtypes import hints
 
+class _MethodTypeDesc(Protocol):
+    arguments: List[Tuple[Any, str, List[str], Optional[Any]]]
+    idlflags: List[str]
+    name: str
 
-if TYPE_CHECKING:
-    _T_MTD = TypeVar("_T_MTD", bound=hints._MethodTypeDesc)
-else:
-    _T_MTD = TypeVar("_T_MTD")
+
+_T_MTD = TypeVar("_T_MTD", bound=_MethodTypeDesc)
 
 
 class _MethodAnnotator(abc.ABC, Generic[_T_MTD]):

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/tools/tlbparser.py

@@ -1,13 +1,11 @@
 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 alignment, c_void_p, sizeof, windll
+from typing import Any, Dict, List, Optional, Tuple
 
-from comtypes import automation, BSTR, COMError, typeinfo
-from comtypes.tools import typedesc
+from comtypes import BSTR, COMError, automation, typeinfo
 from comtypes.client._code_cache import _get_module_filename
-
+from comtypes.tools import typedesc
 
 # Is the process 64-bit?
 is_64bits = sys.maxsize > 2**32
@@ -237,7 +235,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 +739,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 = _get_module_filename(dll._handle)
+            del dll
+        except OSError:
+            return None
+    return full_filename
 
 
 def _py2exe_hint():
     # If the tlbparser is frozen, we need to include these
+    import comtypes.automation
     import comtypes.persist
     import comtypes.typeinfo
-    import comtypes.automation
 
 
 # -eof-

{comtypes-1.4.8 → comtypes-1.4.10}/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):
@@ -20,12 +21,7 @@ class TypeLib(object):
         self.doc = doc
 
     def __repr__(self):
-        return "<TypeLib(%s: %s, %s, %s)>" % (
-            self.name,
-            self.guid,
-            self.major,
-            self.minor,
-        )
+        return f"<TypeLib({self.name}: {self.guid}, {self.major}, {self.minor})>"
 
 
 class Constant(object):

{comtypes-1.4.8 → comtypes-1.4.10}/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