comtypes 1.4.5__zip → 1.4.7__zip

comtypes-1.4.7/comtypes/test/test_storage.py

@@ -0,0 +1,127 @@
+from _ctypes import COMError
+from ctypes import byref, c_ubyte, POINTER
+import contextlib
+from pathlib import Path
+import unittest
+
+import comtypes
+import comtypes.client
+
+
+with contextlib.redirect_stdout(None):  # supress warnings
+    mod = comtypes.client.GetModule("msvidctl.dll")
+
+from comtypes.gen.MSVidCtlLib import IStorage
+
+
+STATFLAG_DEFAULT = 0
+STGC_DEFAULT = 0
+STGM_CREATE = 0x00001000
+STGM_DIRECT = 0x00000000
+STGM_DELETEONRELEASE = 0x04000000
+STGM_READ = 0x00000000
+STGM_READWRITE = 0x00000002
+STGM_SHARE_EXCLUSIVE = 0x00000010
+STGM_TRANSACTED = 0x00010000
+STGMOVE_MOVE = 0
+STREAM_SEEK_SET = 0
+
+STG_E_PATHNOTFOUND = -2147287038
+
+
+class Test_IStorage(unittest.TestCase):
+    CREATE_DOC_FLAG = (
+        STGM_DIRECT
+        | STGM_READWRITE
+        | STGM_CREATE
+        | STGM_SHARE_EXCLUSIVE
+        | STGM_DELETEONRELEASE
+    )
+    CREATE_STM_FLAG = STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE
+    OPEN_STM_FLAG = STGM_READ | STGM_SHARE_EXCLUSIVE
+    CREATE_STG_FLAG = STGM_TRANSACTED | STGM_READWRITE | STGM_SHARE_EXCLUSIVE
+    OPEN_STG_FLAG = STGM_TRANSACTED | STGM_READWRITE | STGM_SHARE_EXCLUSIVE
+
+    def _create_docfile(self) -> IStorage:
+        stg = POINTER(IStorage)()
+        comtypes._ole32.StgCreateDocfile(None, self.CREATE_DOC_FLAG, 0, byref(stg))
+        return stg  # type: ignore
+
+    def test_CreateStream(self):
+        storage = self._create_docfile()
+        filepath = Path(storage.Stat(STATFLAG_DEFAULT).pwcsName)
+        self.assertTrue(filepath.exists())
+        stream = storage.CreateStream("example", self.CREATE_STM_FLAG, 0, 0)
+        test_data = "Some data".encode("utf-8")
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+        stream.RemoteWrite(pv, len(test_data))
+        stream.Commit(STGC_DEFAULT)
+        stream.RemoteSeek(0, STREAM_SEEK_SET)
+        read_buffer, data_read = stream.RemoteRead(1024)
+        self.assertEqual(bytearray(read_buffer)[0:data_read], test_data)
+        storage.Commit(STGC_DEFAULT)
+        self.assertTrue(filepath.exists())
+        del storage
+        self.assertFalse(filepath.exists())
+
+    def test_CreateStorage(self):
+        parent = self._create_docfile()
+        child = parent.CreateStorage("child", self.CREATE_STG_FLAG, 0, 0)
+        self.assertEqual("child", child.Stat(STATFLAG_DEFAULT).pwcsName)
+
+    def test_OpenStorage(self):
+        parent = self._create_docfile()
+        created_child = parent.CreateStorage("child", self.CREATE_STG_FLAG, 0, 0)
+        del created_child
+        opened_child = parent.OpenStorage("child", None, self.OPEN_STG_FLAG, None, 0)
+        self.assertEqual("child", opened_child.Stat(STATFLAG_DEFAULT).pwcsName)
+
+    def test_RemoteCopyTo(self):
+        src_stg = self._create_docfile()
+        src_stg.CreateStorage("child", self.CREATE_STG_FLAG, 0, 0)
+        dst_stg = self._create_docfile()
+        src_stg.RemoteCopyTo(0, None, None, dst_stg)
+        src_stg.Commit(STGC_DEFAULT)
+        del src_stg
+        opened_stg = dst_stg.OpenStorage("child", None, self.OPEN_STG_FLAG, None, 0)
+        self.assertEqual("child", opened_stg.Stat(STATFLAG_DEFAULT).pwcsName)
+
+    def test_MoveElementTo(self):
+        src_stg = self._create_docfile()
+        src_stg.CreateStorage("foo", self.CREATE_STG_FLAG, 0, 0)
+        dst_stg = self._create_docfile()
+        src_stg.MoveElementTo("foo", dst_stg, "bar", STGMOVE_MOVE)
+        opened_stg = dst_stg.OpenStorage("bar", None, self.OPEN_STG_FLAG, None, 0)
+        self.assertEqual("bar", opened_stg.Stat(STATFLAG_DEFAULT).pwcsName)
+        with self.assertRaises(COMError) as ctx:
+            src_stg.OpenStorage("foo", None, self.OPEN_STG_FLAG, None, 0)
+        self.assertEqual(ctx.exception.hresult, STG_E_PATHNOTFOUND)
+
+    def test_Revert(self):
+        storage = self._create_docfile()
+        foo = storage.CreateStorage("foo", self.CREATE_STG_FLAG, 0, 0)
+        foo.CreateStorage("bar", self.CREATE_STG_FLAG, 0, 0)
+        bar = foo.OpenStorage("bar", None, self.OPEN_STG_FLAG, None, 0)
+        self.assertEqual("bar", bar.Stat(STATFLAG_DEFAULT).pwcsName)
+        foo.Revert()
+        with self.assertRaises(COMError) as ctx:
+            foo.OpenStorage("bar", None, self.OPEN_STG_FLAG, None, 0)
+        self.assertEqual(ctx.exception.hresult, STG_E_PATHNOTFOUND)
+
+    def test_DestroyElement(self):
+        storage = self._create_docfile()
+        storage.CreateStorage("example", self.CREATE_STG_FLAG, 0, 0)
+        storage.DestroyElement("example")
+        with self.assertRaises(COMError) as ctx:
+            storage.OpenStorage("example", None, self.OPEN_STG_FLAG, None, 0)
+        self.assertEqual(ctx.exception.hresult, STG_E_PATHNOTFOUND)
+
+    def test_RenameElement(self):
+        storage = self._create_docfile()
+        storage.CreateStorage("example", self.CREATE_STG_FLAG, 0, 0)
+        storage.RenameElement("example", "sample")
+        sample = storage.OpenStorage("sample", None, self.OPEN_STG_FLAG, None, 0)
+        self.assertEqual("sample", sample.Stat(STATFLAG_DEFAULT).pwcsName)
+        with self.assertRaises(COMError) as ctx:
+            storage.OpenStorage("example", None, self.OPEN_STG_FLAG, None, 0)
+        self.assertEqual(ctx.exception.hresult, STG_E_PATHNOTFOUND)

comtypes-1.4.7/comtypes/test/test_typeannotator.py

@@ -0,0 +1,127 @@
+import unittest
+
+from comtypes.tools import typedesc
+from comtypes.tools.codegenerator import typeannotator
+from comtypes.tools.tlbparser import (
+    BSTR_type,
+    HRESULT_type,
+    VARIANT_type,
+    VARIANT_BOOL_type,
+)
+
+
+iunknown_type = typedesc.ComInterface(
+    "IUnknown", None, "{00000000-0000-0000-C000-000000000046}", ["hidden"], None
+)
+idispatch_type = typedesc.ComInterface(
+    "IDispatch",
+    iunknown_type,
+    "{00020400-0000-0000-C000-000000000046}",
+    ["restricted"],
+    None,
+)
+void_type = typedesc.FundamentalType("void", 0, 0)
+
+
+class Test_AvoidUsingKeywords(unittest.TestCase):
+    def _create_typedesc_disp_interface(self) -> typedesc.DispInterface:
+        guid = "{00000000-0000-0000-0000-000000000000}"
+        itf = typedesc.DispInterface("IDispDerived", idispatch_type, guid, [], None)
+        ham = typedesc.DispProperty(0, "ham", BSTR_type, ["readonly"], None)
+        bacon = typedesc.DispMethod(
+            472, 1, "bacon", VARIANT_BOOL_type, ["hidden"], None
+        )
+        bacon.add_argument(VARIANT_type, "and", ["in"], None)
+        bacon.add_argument(VARIANT_type, "foo", ["in"], None)
+        get_spam = typedesc.DispMethod(6, 2, "spam", VARIANT_type, ["propget"], None)
+        get_spam.add_argument(VARIANT_type, "arg1", ["in", "optional"], None)
+        put_spam = typedesc.DispMethod(6, 4, "spam", void_type, ["propput"], None)
+        put_spam.add_argument(VARIANT_type, "arg1", ["in", "optional"], None)
+        put_spam.add_argument(VARIANT_type, "arg2", ["in"], None)
+        except_ = typedesc.DispProperty(1, "except", BSTR_type, ["readonly"], None)
+        raise_ = typedesc.DispMethod(
+            474, 1, "raise", VARIANT_BOOL_type, ["hidden"], None
+        )
+        raise_.add_argument(VARIANT_type, "foo", ["in"], None)
+        raise_.add_argument(VARIANT_type, "bar", ["in", "optional"], None)
+        get_def = typedesc.DispMethod(8, 2, "def", VARIANT_type, ["propget"], None)
+        get_def.add_argument(VARIANT_type, "arg1", ["in", "optional"], None)
+        put_def = typedesc.DispMethod(8, 4, "def", void_type, ["propput"], None)
+        put_def.add_argument(VARIANT_type, "arg1", ["in", "optional"], None)
+        put_def.add_argument(VARIANT_type, "arg2", ["in"], None)
+        for m in [ham, bacon, get_spam, put_spam, except_, raise_, get_def, put_def]:
+            itf.add_member(m)
+        return itf
+
+    def test_disp_interface(self):
+        itf = self._create_typedesc_disp_interface()
+        expected = (
+            "        @property  # dispprop\n"
+            "        def ham(self) -> hints.Incomplete: ...\n"
+            "        pass  # @property  # dispprop\n"
+            "        pass  # avoid using a keyword for def except(self) -> hints.Incomplete: ...\n"  # noqa
+            "        def bacon(self, *args: hints.Any, **kwargs: hints.Any) -> hints.Incomplete: ...\n"  # noqa
+            "        def _get_spam(self, arg1: hints.Incomplete = ...) -> hints.Incomplete: ...\n"  # noqa
+            "        def _set_spam(self, arg1: hints.Incomplete = ..., **kwargs: hints.Any) -> hints.Incomplete: ...\n"  # noqa
+            "        spam = hints.named_property('spam', _get_spam, _set_spam)\n"
+            "        pass  # avoid using a keyword for def raise(self, foo: hints.Incomplete, bar: hints.Incomplete = ...) -> hints.Incomplete: ...\n"  # noqa
+            "        def _get_def(self, arg1: hints.Incomplete = ...) -> hints.Incomplete: ...\n"  # noqa
+            "        def _set_def(self, arg1: hints.Incomplete = ..., **kwargs: hints.Any) -> hints.Incomplete: ...\n"  # noqa
+            "        pass  # avoid using a keyword for def = hints.named_property('def', _get_def, _set_def)"  # noqa
+        )
+        self.assertEqual(
+            expected, typeannotator.DispInterfaceMembersAnnotator(itf).generate()
+        )
+
+    def _create_typedesc_com_interface(self) -> typedesc.ComInterface:
+        guid = "{00000000-0000-0000-0000-000000000000}"
+        itf = typedesc.ComInterface(
+            "IUnkDerived", iunknown_type, guid, ["hidden"], None
+        )
+        spam = typedesc.ComMethod(
+            2, 1610678269, "spam", HRESULT_type, ["propget"], None
+        )
+        get_ham = typedesc.ComMethod(
+            2, 1610678270, "ham", HRESULT_type, ["propget"], None
+        )
+        put_ham = typedesc.ComMethod(
+            4, 1610678270, "ham", HRESULT_type, ["propput"], None
+        )
+        bacon = typedesc.ComMethod(1, 1610678271, "bacon", HRESULT_type, [], None)
+        bacon.add_argument(VARIANT_type, "foo", ["in"], None)
+        bacon.add_argument(VARIANT_type, "or", ["in"], None)
+        global_ = typedesc.ComMethod(
+            2, 1610678272, "global", HRESULT_type, ["propget"], None
+        )
+        get_class = typedesc.ComMethod(
+            2, 1610678273, "class", HRESULT_type, ["propget"], None
+        )
+        put_class = typedesc.ComMethod(
+            4, 1610678273, "class", HRESULT_type, ["propput"], None
+        )
+        pass_ = typedesc.ComMethod(1, 1610678274, "pass", HRESULT_type, [], None)
+        pass_.add_argument(VARIANT_type, "foo", ["in"], None)
+        pass_.add_argument(VARIANT_type, "bar", ["in", "optional"], None)
+        members = [spam, get_ham, put_ham, bacon, global_, get_class, put_class, pass_]
+        itf.extend_members(members)
+        return itf
+
+    def test_com_interface(self):
+        itf = self._create_typedesc_com_interface()
+        expected = (
+            "        def _get_spam(self) -> hints.Hresult: ...\n"
+            "        spam = hints.normal_property(_get_spam)\n"
+            "        def _get_ham(self) -> hints.Hresult: ...\n"
+            "        def _set_ham(self) -> hints.Hresult: ...\n"
+            "        ham = hints.normal_property(_get_ham, _set_ham)\n"
+            "        def bacon(self, *args: hints.Any, **kwargs: hints.Any) -> hints.Hresult: ...\n"  # noqa
+            "        def _get_global(self) -> hints.Hresult: ...\n"
+            "        pass  # avoid using a keyword for global = hints.normal_property(_get_global)\n"  # noqa
+            "        def _get_class(self) -> hints.Hresult: ...\n"
+            "        def _set_class(self) -> hints.Hresult: ...\n"
+            "        pass  # avoid using a keyword for class = hints.normal_property(_get_class, _set_class)\n"  # noqa
+            "        pass  # avoid using a keyword for def pass(self, foo: hints.Incomplete, bar: hints.Incomplete = ...) -> hints.Hresult: ..."  # noqa
+        )
+        self.assertEqual(
+            expected, typeannotator.ComInterfaceMembersAnnotator(itf).generate()
+        )

{comtypes-1.4.5 → comtypes-1.4.7}/comtypes/tools/codegenerator/codegenerator.py

@@ -196,7 +196,6 @@ class CodeGenerator(object):
         print("from typing import TYPE_CHECKING", file=output)
         print(file=output)
         print("if TYPE_CHECKING:", file=output)
-        print("    from typing import Any, Tuple", file=output)
         print("    from comtypes import hints", file=output)
         print(file=output)
         print(file=output)

comtypes-1.4.7/comtypes/tools/codegenerator/modulenamer.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+import comtypes
+from comtypes import typeinfo
+
+
+def name_wrapper_module(tlib: typeinfo.ITypeLib) -> str:
+    """Determine the name of a typelib wrapper module"""
+    libattr = tlib.GetLibAttr()
+    guid = str(libattr.guid)[1:-1].replace("-", "_")
+    modname = f"_{guid}_{libattr.lcid}_{libattr.wMajorVerNum}_{libattr.wMinorVerNum}"
+    return f"comtypes.gen.{modname}"
+
+
+def name_friendly_module(tlib: typeinfo.ITypeLib) -> Optional[str]:
+    """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 f"comtypes.gen.{modulename}"

{comtypes-1.4.5 → comtypes-1.4.7}/comtypes/tools/codegenerator/typeannotator.py

@@ -1,18 +1,8 @@
 import abc
 import keyword
-from typing import (
-    Any,
-    Dict,
-    Generic,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-)
+from typing import Any, Generic, TypeVar, TYPE_CHECKING
+from typing import Dict, List, Optional, Sequence, Tuple
+from typing import Iterable, Iterator
 
 from comtypes.tools import typedesc
 
@@ -124,6 +114,8 @@ class _MethodsAnnotator(abc.ABC, Generic[_T_MTD]):
             content = f"{mem_name} = hints.named_property('{mem_name}', fset={setter})"
         else:
             return
+        if keyword.iskeyword(mem_name):
+            content = f"pass  # avoid using a keyword for {content}"
         self._define_member(content)
 
     def _define_normal_prop(
@@ -137,6 +129,8 @@ class _MethodsAnnotator(abc.ABC, Generic[_T_MTD]):
             content = f"{mem_name} = hints.normal_property(fset={setter})"
         else:
             return
+        if keyword.iskeyword(mem_name):
+            content = f"pass  # avoid using a keyword for {content}"
         self._define_member(content)
 
     def _define_member(self, content: str) -> None:
@@ -242,14 +236,14 @@ class ComMethodAnnotator(_MethodAnnotator[typedesc.ComMethod]):
         has_optional = False
         for _, argname, default in self.inarg_specs:
             if keyword.iskeyword(argname):
-                inargs = ["*args: Any", "**kwargs: Any"]
+                inargs = ["*args: hints.Any", "**kwargs: hints.Any"]
                 break
             if default is None:
                 if has_optional:
                     # probably propput or propputref
                     # HACK: Something that goes into this conditional branch
                     #       should be a special callback.
-                    inargs.append("**kwargs: Any")
+                    inargs.append("**kwargs: hints.Any")
                     break
                 inargs.append(f"{argname}: hints.Incomplete")
             else:
@@ -261,9 +255,12 @@ class ComMethodAnnotator(_MethodAnnotator[typedesc.ComMethod]):
         elif len(outargs) == 1:
             out = outargs[0]
         else:
-            out = "Tuple[" + ", ".join(outargs) + "]"
+            out = "hints.Tuple[" + ", ".join(outargs) + "]"
         in_ = ("self, " + ", ".join(inargs)) if inargs else "self"
-        return f"def {name}({in_}) -> {out}: ..."
+        content = f"def {name}({in_}) -> {out}: ..."
+        if keyword.iskeyword(name):
+            content = f"pass  # avoid using a keyword for {content}"
+        return content
 
 
 class ComMethodsAnnotator(_MethodsAnnotator[typedesc.ComMethod]):
@@ -285,14 +282,14 @@ class DispMethodAnnotator(_MethodAnnotator[typedesc.DispMethod]):
         has_optional = False
         for _, argname, default in self.inarg_specs:
             if keyword.iskeyword(argname):
-                inargs = ["*args: Any", "**kwargs: Any"]
+                inargs = ["*args: hints.Any", "**kwargs: hints.Any"]
                 break
             if default is None:
                 if has_optional:
                     # probably propput or propputref
                     # HACK: Something that goes into this conditional branch
                     #       should be a special callback.
-                    inargs.append("**kwargs: Any")
+                    inargs.append("**kwargs: hints.Any")
                     break
                 inargs.append(f"{argname}: hints.Incomplete")
             else:
@@ -300,7 +297,10 @@ class DispMethodAnnotator(_MethodAnnotator[typedesc.DispMethod]):
                 has_optional = True
         out = _to_outtype(self.method.returns)
         in_ = ("self, " + ", ".join(inargs)) if inargs else "self"
-        return f"def {name}({in_}) -> {out}: ..."
+        content = f"def {name}({in_}) -> {out}: ..."
+        if keyword.iskeyword(name):
+            content = f"pass  # avoid using a keyword for {content}"
+        return content
 
 
 class DispMethodsAnnotator(_MethodsAnnotator[typedesc.DispMethod]):
@@ -328,9 +328,14 @@ class DispInterfaceMembersAnnotator(object):
         props, methods = self._categorize_members()
         property_lines: List[str] = []
         for mem in props:
-            property_lines.append("@property  # dispprop")
             out = _to_outtype(mem.typ)
-            property_lines.append(f"def {mem.name}(self) -> {out}: ...")
+            decorator = "@property  # dispprop"
+            content = f"def {mem.name}(self) -> {out}: ..."
+            if keyword.iskeyword(mem.name):
+                decorator = f"pass  # {decorator}"
+                content = f"pass  # avoid using a keyword for {content}"
+            property_lines.append(decorator)
+            property_lines.append(content)
         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.5 → comtypes-1.4.7}/comtypes/tools/tlbparser.py

@@ -298,27 +298,25 @@ class Parser(object):
             names = tinfo.GetNames(fd.memid, fd.cParams + 1)
             names.append("rhs")
             names = names[: fd.cParams + 1]
+            # function name first, then parameter names
             assert len(names) == fd.cParams + 1
             flags = self.func_flags(fd.wFuncFlags)
             flags += self.inv_kind(fd.invkind)
             mth = typedesc.ComMethod(
                 fd.invkind, fd.memid, func_name, returns, flags, func_doc
             )
-            for p in range(fd.cParams):
-                typ = self.make_type(fd.lprgelemdescParam[p].tdesc, tinfo)
-                name = names[p + 1]
-                flags = fd.lprgelemdescParam[p]._.paramdesc.wParamFlags
-                if flags & typeinfo.PARAMFLAG_FHASDEFAULT:
+            for j in range(fd.cParams):
+                elemdesc = fd.lprgelemdescParam[j]
+                typ = self.make_type(elemdesc.tdesc, tinfo)
+                name = names[j + 1]
+                paramdesc = elemdesc._.paramdesc
+                if paramdesc.wParamFlags & typeinfo.PARAMFLAG_FHASDEFAULT:
                     # XXX should be handled by VARIANT itself
-                    var = (
-                        fd.lprgelemdescParam[p]
-                        ._.paramdesc.pparamdescex[0]
-                        .varDefaultValue
-                    )
-                    default: Any = var.value
+                    default: Any = paramdesc.pparamdescex[0].varDefaultValue.value
                 else:
                     default = None
-                mth.add_argument(typ, name, self.param_flags(flags), default)
+                param_flags = self.param_flags(paramdesc.wParamFlags)
+                mth.add_argument(typ, name, param_flags, default)
             members.append((fd.oVft, mth))
         # Sort the methods by oVft (VTable offset): Some typeinfo
         # don't list methods in VTable order.
@@ -386,25 +384,25 @@ class Parser(object):
             names = tinfo.GetNames(fd.memid, fd.cParams + 1)
             names.append("rhs")
             names = names[: fd.cParams + 1]
-            assert (
-                len(names) == fd.cParams + 1
-            )  # function name first, then parameter names
+            # function name first, then parameter names
+            assert len(names) == fd.cParams + 1
             flags = self.func_flags(fd.wFuncFlags)
             flags += self.inv_kind(fd.invkind)
             mth = typedesc.DispMethod(
                 fd.memid, fd.invkind, func_name, returns, flags, func_doc
             )
-            for p in range(fd.cParams):
-                descparam = fd.lprgelemdescParam[p]
-                typ = self.make_type(descparam.tdesc, tinfo)
-                name = names[p + 1]
-                flags = descparam._.paramdesc.wParamFlags
-                if flags & typeinfo.PARAMFLAG_FHASDEFAULT:
-                    var = descparam._.paramdesc.pparamdescex[0].varDefaultValue  # type: ignore
-                    default: Any = var.value
+            for j in range(fd.cParams):
+                elemdesc = fd.lprgelemdescParam[j]
+                typ = self.make_type(elemdesc.tdesc, tinfo)
+                name = names[j + 1]
+                paramdesc = elemdesc._.paramdesc
+                if paramdesc.wParamFlags & typeinfo.PARAMFLAG_FHASDEFAULT:
+                    # XXX should be handled by VARIANT itself
+                    default: Any = paramdesc.pparamdescex[0].varDefaultValue.value
                 else:
                     default = None
-                mth.add_argument(typ, name, self.param_flags(flags), default)
+                param_flags = self.param_flags(paramdesc.wParamFlags)
+                mth.add_argument(typ, name, param_flags, default)
             itf.add_member(mth)
         return itf
 

{comtypes-1.4.5 → comtypes-1.4.7}/comtypes/tools/typedesc_base.py

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