comtypes 1.4.6__zip → 1.4.8__zip

comtypes-1.4.8/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.8/comtypes/test/test_stream.py

@@ -0,0 +1,131 @@
+import unittest as ut
+
+from ctypes import POINTER, byref, c_bool, c_ubyte, c_ulonglong, oledll, pointer
+import comtypes
+import comtypes.client
+
+comtypes.client.GetModule("portabledeviceapi.dll")
+from comtypes.gen.PortableDeviceApiLib import IStream
+
+
+STGC_DEFAULT = 0
+STREAM_SEEK_SET = 0
+STREAM_SEEK_CUR = 1
+STREAM_SEEK_END = 2
+
+
+def _create_stream() -> IStream:
+    # Create an IStream
+    stream = POINTER(IStream)()  # type: ignore
+    comtypes._ole32.CreateStreamOnHGlobal(None, c_bool(True), byref(stream))
+    return stream  # type: ignore
+
+
+class Test_RemoteWrite(ut.TestCase):
+    def test_RemoteWrite(self):
+        stream = _create_stream()
+        test_data = "Some data".encode("utf-8")
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+
+        written = stream.RemoteWrite(pv, len(test_data))
+
+        # Verification
+        self.assertEqual(written, len(test_data))
+
+
+class Test_RemoteRead(ut.TestCase):
+    def test_RemoteRead(self):
+        stream = _create_stream()
+        test_data = "Some data".encode("utf-8")
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+        stream.RemoteWrite(pv, len(test_data))
+
+        # Make sure the data actually gets written before trying to read back
+        stream.Commit(STGC_DEFAULT)
+        # Move the stream back to the beginning
+        stream.RemoteSeek(0, STREAM_SEEK_SET)
+
+        buffer_size = 1024
+
+        read_buffer, data_read = stream.RemoteRead(buffer_size)
+
+        # Verification
+        self.assertEqual(data_read, len(test_data))
+        self.assertEqual(bytearray(read_buffer)[0:data_read], test_data)
+
+
+class Test_RemoteSeek(ut.TestCase):
+    def _create_sample_stream(self) -> IStream:
+        stream = _create_stream()
+        test_data = b"spam egg bacon ham"
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+        stream.RemoteWrite(pv, len(test_data))
+        stream.Commit(STGC_DEFAULT)
+        return stream
+
+    def test_takes_STREAM_SEEK_SET_as_origin(self):
+        stream = self._create_sample_stream()
+        newpos = stream.RemoteSeek(9, STREAM_SEEK_SET)
+        self.assertEqual(newpos, 9)
+        buf, read = stream.RemoteRead(1024)
+        self.assertEqual(bytearray(buf)[0:read], b"bacon ham")
+
+    def test_takes_STREAM_SEEK_CUR_as_origin(self):
+        stream = self._create_sample_stream()
+        stream.RemoteSeek(8, STREAM_SEEK_SET)
+        newpos = stream.RemoteSeek(7, STREAM_SEEK_CUR)
+        self.assertEqual(newpos, 15)
+        buf, read = stream.RemoteRead(1024)
+        self.assertEqual(bytearray(buf)[0:read], b"ham")
+
+    def test_takes_STREAM_SEEK_END_as_origin(self):
+        stream = self._create_sample_stream()
+        stream.RemoteSeek(8, STREAM_SEEK_SET)
+        newpos = stream.RemoteSeek(-13, STREAM_SEEK_END)
+        self.assertEqual(newpos, 5)
+        buf, read = stream.RemoteRead(1024)
+        self.assertEqual(bytearray(buf)[0:read], b"egg bacon ham")
+
+
+class Test_SetSize(ut.TestCase):
+    def test_SetSize(self):
+        stream = _create_stream()
+        stream.SetSize(42)
+        pui = pointer(c_ulonglong())
+        oledll.shlwapi.IStream_Size(stream, pui)
+        self.assertEqual(pui.contents.value, 42)
+
+
+class Test_RemoteCopyTo(ut.TestCase):
+    def test_RemoteCopyTo(self):
+        src = _create_stream()
+        dst = _create_stream()
+        test_data = b"parrot"
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+        src_written = src.RemoteWrite(pv, len(test_data))
+        src.Commit(STGC_DEFAULT)
+        src.RemoteSeek(0, STREAM_SEEK_SET)
+        cpy_read, cpy_written = src.RemoteCopyTo(dst, src_written)
+        self.assertEqual(cpy_read, len(test_data))
+        self.assertEqual(cpy_written, len(test_data))
+        dst.Commit(STGC_DEFAULT)
+        dst.RemoteSeek(0, STREAM_SEEK_SET)
+        dst_buf, dst_read = dst.RemoteRead(1024)
+        self.assertEqual(bytearray(dst_buf)[0:dst_read], test_data)
+
+
+class Test_Clone(ut.TestCase):
+    def test_Clone(self):
+        orig = _create_stream()
+        test_data = b"spam egg bacon ham"
+        pv = (c_ubyte * len(test_data)).from_buffer(bytearray(test_data))
+        orig.RemoteWrite(pv, len(test_data))
+        orig.Commit(STGC_DEFAULT)
+        orig.RemoteSeek(0, STREAM_SEEK_SET)
+        new_stm = orig.Clone()
+        buf, read = new_stm.RemoteRead(1024)
+        self.assertEqual(bytearray(buf)[0:read], test_data)
+
+
+if __name__ == "__main__":
+    ut.main()

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/test/test_typeannotator.py

@@ -7,6 +7,7 @@ from comtypes.tools.tlbparser import (
     HRESULT_type,
     VARIANT_type,
     VARIANT_BOOL_type,
+    void_type,
 )
 
 
@@ -20,7 +21,6 @@ idispatch_type = typedesc.ComInterface(
     ["restricted"],
     None,
 )
-void_type = typedesc.FundamentalType("void", 0, 0)
 
 
 class Test_AvoidUsingKeywords(unittest.TestCase):

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/test/test_urlhistory.py

@@ -9,6 +9,7 @@ from comtypes.patcher import Patch
 GetModule(os.path.join(os.path.dirname(__file__), "urlhist.tlb"))
 from comtypes.gen import urlhistLib
 
+
 # The pwcsTitle and pwcsUrl fields of the _STATURL structure must be
 # freed by the caller.  The only way to do this without patching the
 # generated code directly is to monkey-patch the

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/test/test_variant.py

@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 import datetime
 import decimal
 import sys

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/tools/codegenerator/namespaces.py

@@ -1,12 +1,28 @@
+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
 
 
 class ImportedNamespaces(object):
-    def __init__(self):
-        self.data = {}
+    def __init__(self) -> None:
+        self.data: Dict[str, Optional[str]] = {}
 
-    def add(self, name1, name2=None, symbols=None):
+    @overload
+    def add(self, modulename: str, /) -> None: ...
+    @overload
+    def add(self, modulename: str, symbolname: str, /) -> None: ...
+    @overload
+    def add(self, symbolname: str, /, *, symbols: Mapping[str, str]) -> None: ...
+    def add(
+        self,
+        name1: str,
+        name2: Optional[str] = None,
+        symbols: Optional[Mapping[str, str]] = None,
+    ) -> None:
         """Adds a namespace will be imported.
 
         Examples:
@@ -43,7 +59,7 @@ class ImportedNamespaces(object):
             from_, import_ = name1, name2
         self.data[import_] = from_
 
-    def __contains__(self, item):
+    def __contains__(self, item: _UnionT[str, Tuple[str, str]]) -> bool:
         """Returns item has already added.
 
         Examples:
@@ -77,31 +93,31 @@ class ImportedNamespaces(object):
             names.add(key)
         return names
 
-    def _make_line(self, from_, imports):
+    def _make_line(self, from_: str, imports: Sequence[str]) -> str:
         import_ = ", ".join(imports)
-        code = "from %s import %s" % (from_, import_)
+        code = f"from {from_} import {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_)
+        code = f"from {from_} import (\n{import_}\n)"
         return code
 
-    def getvalue(self):
-        ns = {}
-        lines = []
+    def getvalue(self) -> str:
+        ns: Dict[str, Optional[Set[str]]] = {}
+        lines: List[str] = []
         for key, val in self.data.items():
             if val is None:
                 ns[key] = val
             elif key == "*":
-                lines.append("from %s import *" % val)
+                lines.append(f"from {val} import *")
             else:
-                ns.setdefault(val, set()).add(key)
+                ns.setdefault(val, set()).add(key)  # type: ignore
         for key, val in ns.items():
             if val is None:
-                lines.append("import %s" % key)
+                lines.append(f"import {key}")
             else:
                 names = sorted(val, key=lambda s: s.lower())
                 lines.append(self._make_line(key, names))
@@ -109,10 +125,10 @@ class ImportedNamespaces(object):
 
 
 class DeclaredNamespaces(object):
-    def __init__(self):
-        self.data = {}
+    def __init__(self) -> None:
+        self.data: Dict[Tuple[str, str], Optional[str]] = {}
 
-    def add(self, alias, definition, comment=None):
+    def add(self, alias: str, definition: str, comment: Optional[str] = None) -> None:
         """Adds a namespace will be declared.
 
         Examples:
@@ -134,18 +150,18 @@ class DeclaredNamespaces(object):
             names.add(alias)
         return names
 
-    def getvalue(self):
+    def getvalue(self) -> str:
         lines = []
         for (alias, definition), comment in self.data.items():
-            code = "%s = %s" % (alias, definition)
+            code = f"{alias} = {definition}"
             if comment:
-                code = code + "  # %s" % comment
+                code = code + f"  # {comment}"
             lines.append(code)
         return "\n".join(lines)
 
 
 class EnumerationNamespaces(object):
-    def __init__(self):
+    def __init__(self) -> None:
         self.data: Dict[str, List[Tuple[str, int]]] = {}
 
     def add(self, enum_name: str, member_name: str, value: int) -> None:
@@ -159,6 +175,14 @@ class EnumerationNamespaces(object):
             >>> assert enums
             >>> enums.add('Foo', 'spam', 2)
             >>> enums.add('Bar', 'bacon', 3)
+            >>> enums.add('Bar', 'egg', 4)
+            >>> import warnings
+            >>> with warnings.catch_warnings(record=True) as w:
+            ...     enums.add('Bar', 'egg', 5)
+            ...     print(w[-1].message.args[0].replace(', ', ',\\n'))
+            The 'egg' member of the 'Bar' enumeration is already assigned 4,
+            but it will be overwritten with 5,
+            based on the type information.
             >>> assert 'Foo' in enums
             >>> assert 'Baz' not in enums
             >>> print(enums.to_intflags())
@@ -169,6 +193,8 @@ class EnumerationNamespaces(object):
             <BLANKLINE>
             class Bar(IntFlag):
                 bacon = 3
+                # egg = 4  # duplicated. Perhaps there is a bug in the type library?
+                egg = 5  # duplicated. Perhaps there is a bug in the type library?
             >>> print(enums.to_constants())
             # values for enumeration 'Foo'
             ham = 1
@@ -177,9 +203,24 @@ class EnumerationNamespaces(object):
             <BLANKLINE>
             # values for enumeration 'Bar'
             bacon = 3
+            egg = 4  # duplicated within the 'Bar'. Perhaps there is a bug?
+            egg = 5  # duplicated within the 'Bar'. Perhaps there is a bug?
             Bar = c_int  # enum
         """
-        self.data.setdefault(enum_name, []).append((member_name, value))
+        members = self.data.setdefault(enum_name, [])
+        if members:
+            mapping = dict(members)
+            if member_name in mapping:
+                # This may be a bug in the COM type library.
+                # See also https://github.com/enthought/comtypes/issues/550
+                warnings.warn(
+                    f"The '{member_name}' member of the '{enum_name}' enumeration "
+                    f"is already assigned {mapping[member_name]}, "
+                    f"but it will be overwritten with {value}, "
+                    "based on the type information.",
+                    UserWarning,
+                )
+        members.append((member_name, value))
 
     def __contains__(self, item: str) -> bool:
         return item in self.data
@@ -190,23 +231,52 @@ class EnumerationNamespaces(object):
     def get_symbols(self) -> Set[str]:
         return set(self.data)
 
+    def _iter_members(
+        self, members: Sequence[Tuple[str, int]]
+    ) -> Iterator[Tuple[str, bool, int]]:
+        key_counter = Counter(m for m, _ in members)
+        decrementee = dict(key_counter)  # shallow copy
+        for name, value in members:
+            decrementee[name] -= 1
+            # definition, is_dupl, rest_dupl_count
+            yield f"{name} = {value}", key_counter[name] > 1, decrementee[name]
+
+    def _iter_items(self) -> Iterator[Tuple[str, Iterator[Tuple[str, bool, int]]]]:
+        for name, members in self.data.items():
+            yield name, self._iter_members(members)
+
     def to_constants(self) -> str:
         blocks = []
-        for enum_name, enum_members in self.data.items():
+        for enum_name, members in self._iter_items():
             lines = []
             lines.append(f"# values for enumeration '{enum_name}'")
-            for n, v in enum_members:
-                lines.append(f"{n} = {v}")
+            for definition, is_dupl, _ in members:
+                if is_dupl:
+                    msg1 = f"duplicated within the '{enum_name}'."
+                    msg2 = "Perhaps there is a bug?"
+                    lines.append(f"{definition}  # {msg1} {msg2}")
+                else:
+                    lines.append(definition)
             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():
+        for enum_name, members in self._iter_items():
             lines = []
             lines.append(f"class {enum_name}(IntFlag):")
-            for member_name, value in enum_members:
-                lines.append(f"    {member_name} = {value}")
+            for definition, is_dupl, rest_dupl_count in members:
+                if is_dupl:
+                    msg = "duplicated. Perhaps there is a bug in the type library?"
+                    base_line = f"{definition}  # {msg}"
+                    if rest_dupl_count > 0:
+                        # Prevent raising `TypeError: Attempted to reuse key:`.
+                        # See https://github.com/enthought/comtypes/issues/550
+                        lines.append(f"    # {base_line}")
+                    else:
+                        lines.append(f"    {base_line}")
+                else:
+                    lines.append(f"    {definition}")
             blocks.append("\n".join(lines))
         return "\n\n\n".join(blocks)

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

@@ -33,8 +33,7 @@ class _MethodAnnotator(abc.ABC, Generic[_T_MTD]):
         return result
 
     @abc.abstractmethod
-    def getvalue(self, name: str) -> str:
-        ...
+    def getvalue(self, name: str) -> str: ...
 
 
 _CatMths = Tuple[  # categorized methods
@@ -47,8 +46,7 @@ class _MethodsAnnotator(abc.ABC, Generic[_T_MTD]):
         self.data: List[str] = []
 
     @abc.abstractmethod
-    def to_method_annotator(self, method: _T_MTD) -> _MethodAnnotator[_T_MTD]:
-        ...
+    def to_method_annotator(self, method: _T_MTD) -> _MethodAnnotator[_T_MTD]: ...
 
     def _iter_methods(self, members: Iterable[_T_MTD]) -> Iterator[_CatMths[_T_MTD]]:
         methods: Dict[str, List[Optional[_T_MTD]]] = {}