comtypes 1.4.4__zip → 1.4.5__zip

{comtypes-1.4.4 → comtypes-1.4.5}/comtypes/hints.pyi

@@ -1,14 +1,17 @@
 # This stub contains...
 # - symbols those what might occur recursive imports in runtime.
 # - utilities for type hints.
+import ctypes
 import sys
 from typing import (
     Any,
     Callable,
+    ClassVar,
     Generic,
     Iterator,
     List,
     NoReturn,
+    Sequence,
     Tuple,
     Type,
     TypeVar,
@@ -37,9 +40,11 @@ else:
     from typing_extensions import Self
 
 import comtypes
+from comtypes import IUnknown as IUnknown, GUID as GUID
 from comtypes.automation import IDispatch as IDispatch, VARIANT as VARIANT
 from comtypes.server import IClassFactory as IClassFactory
 from comtypes.typeinfo import ITypeInfo as ITypeInfo
+from comtypes._safearray import tagSAFEARRAY as tagSAFEARRAY
 
 Incomplete: TypeAlias = Any
 """The type symbol is used temporarily until the COM library parsers or
@@ -51,6 +56,35 @@ Hresult: TypeAlias = int
 arguments and with `HRESULT` as its return type in its COM method definition.
 """
 
+_CT = TypeVar("_CT", bound=ctypes._CData)
+_T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
+_T_Struct = TypeVar("_T_Struct", bound=ctypes.Structure)
+
+class LP_SAFEARRAY(ctypes._Pointer[tagSAFEARRAY], Generic[_CT]):
+    contents: tagSAFEARRAY
+    _itemtype_: ClassVar[_CT]  # type: ignore
+    _vartype_: ClassVar[int]
+    _needsfree: ClassVar[bool]
+
+    @overload
+    @classmethod
+    def create(
+        cls: Type[LP_SAFEARRAY[ctypes._Pointer[_T_IUnknown]]],
+        value: Sequence[_T_IUnknown],
+        extra: ctypes._Pointer[GUID] = ...,
+    ) -> LP_SAFEARRAY[ctypes._Pointer[_T_IUnknown]]: ...
+    @overload
+    @classmethod
+    def create(cls, value: Sequence[_CT], extra: Any = ...) -> LP_SAFEARRAY[_CT]: ...
+    @overload
+    def unpack(
+        self: LP_SAFEARRAY[ctypes._Pointer[_T_IUnknown]],
+    ) -> Sequence[_T_IUnknown]: ...
+    @overload
+    def unpack(self: LP_SAFEARRAY[_T_Struct]) -> Sequence[_T_Struct]: ...
+    @overload
+    def unpack(self) -> Sequence[Any]: ...
+
 _T_coclass = TypeVar("_T_coclass", bound=comtypes.CoClass)
 
 class FirstComItfOf(Generic[_T_coclass]):

{comtypes-1.4.4 → comtypes-1.4.5}/comtypes/safearray.py

@@ -1,10 +1,17 @@
 import threading
 import array
+from typing import TYPE_CHECKING
 import comtypes
 from ctypes import POINTER, Structure, byref, cast, c_long, memmove, pointer, sizeof
 from comtypes import _safearray, IUnknown, com_interface_registry
 from comtypes.patcher import Patch
 
+if TYPE_CHECKING:
+    from typing import Type, TypeVar
+    from comtypes import hints  # type: ignore
+
+    _CT = TypeVar("_CT", bound=comtypes._CData)
+
 _safearray_type_cache = {}
 
 
@@ -49,18 +56,18 @@ safearray_as_ndarray = _SafeArrayAsNdArrayContextManager()
 
 ################################################################
 # This is THE PUBLIC function: the gateway to the SAFEARRAY functionality.
-def _midlSAFEARRAY(itemtype):
+def _midlSAFEARRAY(itemtype: "Type[_CT]") -> "Type[hints.LP_SAFEARRAY[_CT]]":
     """This function mimics the 'SAFEARRAY(aType)' IDL idiom.  It
     returns a subtype of SAFEARRAY, instances will be built with a
     typecode VT_...  corresponding to the aType, which must be one of
     the supported ctypes.
     """
     try:
-        return POINTER(_safearray_type_cache[itemtype])
+        return POINTER(_safearray_type_cache[itemtype])  # type: ignore
     except KeyError:
         sa_type = _make_safearray_type(itemtype)
         _safearray_type_cache[itemtype] = sa_type
-        return POINTER(sa_type)
+        return POINTER(sa_type)  # type: ignore
 
 
 def _make_safearray_type(itemtype):
@@ -109,7 +116,7 @@ def _make_safearray_type(itemtype):
         _needsfree = False
 
         @classmethod
-        def create(cls, value, extra=None):
+        def create(cls, value, extra=extra):
             """Create a POINTER(SAFEARRAY_...) instance of the correct
             type; value is an object containing the items to store.
 

comtypes-1.4.5/comtypes/stream.py

@@ -0,0 +1,65 @@
+from ctypes import Array, c_ubyte, c_ulong, HRESULT, POINTER, pointer
+from typing import Tuple, TYPE_CHECKING
+
+from comtypes import COMMETHOD, GUID, IUnknown
+
+
+class ISequentialStream(IUnknown):
+    """Defines methods for the stream objects in sequence."""
+
+    _iid_ = GUID("{0C733A30-2A1C-11CE-ADE5-00AA0044773D}")
+    _idlflags_ = []
+
+    _methods_ = [
+        # Note that these functions are called `Read` and `Write` in Microsoft's documentation,
+        # see https://learn.microsoft.com/en-us/windows/win32/api/objidl/nn-objidl-isequentialstream.
+        # However, the comtypes code generation detects these as `RemoteRead` and `RemoteWrite`
+        # for very subtle reasons, see e.g. https://stackoverflow.com/q/19820999/. We will not
+        # rename these in this manual import for the sake of consistency.
+        COMMETHOD(
+            [],
+            HRESULT,
+            "RemoteRead",
+            # This call only works if `pv` is pre-allocated with `cb` bytes,
+            # which cannot be done by the high level function generated by metaclasses.
+            # Therefore, we override the high level function to implement this behaviour
+            # and then delegate the call the raw COM method.
+            (["out"], POINTER(c_ubyte), "pv"),
+            (["in"], c_ulong, "cb"),
+            (["out"], POINTER(c_ulong), "pcbRead"),
+        ),
+        COMMETHOD(
+            [],
+            HRESULT,
+            "RemoteWrite",
+            (["in"], POINTER(c_ubyte), "pv"),
+            (["in"], c_ulong, "cb"),
+            (["out"], POINTER(c_ulong), "pcbWritten"),
+        ),
+    ]
+
+    def RemoteRead(self, cb: int) -> Tuple["Array[c_ubyte]", int]:
+        """Reads a specified number of bytes from the stream object into memory
+        starting at the current seek pointer.
+        """
+        # Behaves as if `pv` is pre-allocated with `cb` bytes by the high level func.
+        pv = (c_ubyte * cb)()
+        pcb_read = pointer(c_ulong(0))
+        self.__com_RemoteRead(pv, c_ulong(cb), pcb_read)  # type: ignore
+        # return both `out` parameters
+        return pv, pcb_read.contents.value
+
+    if TYPE_CHECKING:
+
+        def RemoteWrite(self, pv: "Array[c_ubyte]", cb: int) -> int:
+            """Writes a specified number of bytes into the stream object starting at
+            the current seek pointer.
+            """
+            ...
+
+
+# fmt: off
+__known_symbols__ = [
+    'ISequentialStream',
+]
+# fmt: on

{comtypes-1.4.4 → comtypes-1.4.5}/comtypes/test/test_client.py

@@ -71,6 +71,12 @@ class Test_GetModule(ut.TestCase):
         # the `_Pointer` interface, rather than importing `_Pointer` from `ctypes`.
         self.assertTrue(issubclass(mod._Pointer, comtypes.IUnknown))
 
+    def test_portabledeviceapi(self):
+        mod = comtypes.client.GetModule("portabledeviceapi.dll")
+        from comtypes.stream import ISequentialStream
+
+        self.assertTrue(issubclass(mod.IStream, ISequentialStream))
+
     def test_no_replacing_Patch_namespace(self):
         # NOTE: An object named `Patch` is defined in some dll.
         # Depending on how the namespace is defined in the static module,
@@ -117,6 +123,11 @@ class Test_KnownSymbols(ut.TestCase):
 
         self._doit(comtypes)
 
+    def test_symbols_in_comtypes_stream(self):
+        import comtypes.stream
+
+        self._doit(comtypes.stream)
+
     def test_symbols_in_comtypes_automation(self):
         import comtypes.automation
 

{comtypes-1.4.4 → comtypes-1.4.5}/comtypes/test/test_dispifc_records.py

@@ -26,7 +26,7 @@ class Test_DispMethods(unittest.TestCase):
     def _create_dispifc(self) -> "ComtypesCppTestSrvLib.IDispRecordParamTest":
         # Explicitely ask for the dispinterface of the component.
         return CreateObject(
-            "Comtypes.DispIfcParamTests",
+            "Comtypes.DispRecordParamTest",
             clsctx=CLSCTX_LOCAL_SERVER,
             interface=ComtypesCppTestSrvLib.IDispRecordParamTest,
         )

comtypes-1.4.5/comtypes/test/test_dispifc_safearrays.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+from ctypes import byref, c_double, pointer
+import unittest
+
+import comtypes
+import comtypes.safearray
+from comtypes import CLSCTX_LOCAL_SERVER
+from comtypes.client import CreateObject, GetModule
+
+ComtypesCppTestSrvLib_GUID = "{07D2AEE5-1DF8-4D2C-953A-554ADFD25F99}"
+
+try:
+    GetModule((ComtypesCppTestSrvLib_GUID, 1, 0, 0))
+    import comtypes.gen.ComtypesCppTestSrvLib as ComtypesCppTestSrvLib
+
+    IMPORT_FAILED = False
+except (ImportError, OSError):
+    IMPORT_FAILED = True
+
+
+@unittest.skipIf(IMPORT_FAILED, "This depends on the out of process COM-server.")
+class Test_DispMethods(unittest.TestCase):
+    """Test dispmethods with safearray and safearray pointer parameters."""
+
+    UNPACKED_ZERO_VALS = tuple(0.0 for _ in range(10))
+    UNPACKED_CONSECUTIVE_VALS = tuple(float(i) for i in range(10))
+
+    def _create_dispifc(self) -> "ComtypesCppTestSrvLib.IDispSafearrayParamTest":
+        # Explicitely ask for the dispinterface of the component.
+        return CreateObject(
+            "Comtypes.DispSafearrayParamTest",
+            clsctx=CLSCTX_LOCAL_SERVER,
+            interface=ComtypesCppTestSrvLib.IDispSafearrayParamTest,
+        )
+
+    def _create_zero_array(self):
+        return comtypes.safearray._midlSAFEARRAY(c_double).create(
+            [c_double() for _ in range(10)]
+        )
+
+    def _create_consecutive_array(self):
+        return comtypes.safearray._midlSAFEARRAY(c_double).create(
+            [c_double(i) for i in range(10)]
+        )
+
+    def test_inout_byref(self):
+        dispifc = self._create_dispifc()
+        # Passing a safearray by reference to a method that has declared the parameter
+        # as [in, out] we expect modifications of the safearray on the server side to
+        # also change the safearray on the client side.
+        test_array = self._create_zero_array()
+        self.assertEqual(test_array.unpack(), self.UNPACKED_ZERO_VALS)
+        dispifc.InitArray(byref(test_array))
+        self.assertEqual(test_array.unpack(), self.UNPACKED_CONSECUTIVE_VALS)
+
+    def test_inout_pointer(self):
+        dispifc = self._create_dispifc()
+        # Passing a safearray pointer to a method that has declared the parameter
+        # as [in, out] we expect modifications of the safearray on the server side to
+        # also change the safearray on the client side.
+        test_array = self._create_zero_array()
+        self.assertEqual(test_array.unpack(), self.UNPACKED_ZERO_VALS)
+        dispifc.InitArray(pointer(test_array))
+        self.assertEqual(test_array.unpack(), self.UNPACKED_CONSECUTIVE_VALS)
+
+    def test_in_safearray(self):
+        # Passing a safearray to a method that has declared the parameter just as [in]
+        # we expect modifications of the safearray on the server side NOT to change
+        # the safearray on the client side.
+        # We also need to test if the safearray gets properly passed to the method on
+        # the server side. For this, the 'VerifyArray' method returns 'True' if
+        # the safearray items have values equal to the initialization values
+        # provided by 'InitArray'.
+        for sa, expected, unpacked_content in [
+            (self._create_consecutive_array(), True, self.UNPACKED_CONSECUTIVE_VALS),
+            # Also perform the inverted test. For this, create a safearray with zeros.
+            (self._create_zero_array(), False, self.UNPACKED_ZERO_VALS),
+        ]:
+            with self.subTest(expected=expected, unpacked_content=unpacked_content):
+                # Perform the check on initialization values.
+                self.assertEqual(self._create_dispifc().VerifyArray(sa), expected)
+                # Check if the safearray is unchanged although the method
+                # modifies the safearray on the server side.
+                self.assertEqual(sa.unpack(), unpacked_content)
+
+
+if __name__ == "__main__":
+    unittest.main()

comtypes-1.4.5/comtypes/test/test_istream.py

@@ -0,0 +1,53 @@
+import unittest as ut
+
+from ctypes import POINTER, byref, c_bool, c_ubyte
+import comtypes
+import comtypes.client
+
+comtypes.client.GetModule("portabledeviceapi.dll")
+from comtypes.gen.PortableDeviceApiLib import IStream
+
+
+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(0)
+        # Move the stream back to the beginning
+        STREAM_SEEK_SET = 0
+        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)
+
+
+if __name__ == "__main__":
+    ut.main()

comtypes-1.4.5/comtypes/test/test_midl_safearray_create.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+from ctypes import c_int, pointer, POINTER
+import unittest
+
+import comtypes
+import comtypes.safearray
+from comtypes import CLSCTX_INPROC_SERVER, CLSCTX_LOCAL_SERVER
+from comtypes.client import CreateObject, GetModule
+import comtypes.typeinfo
+
+GetModule("UIAutomationCore.dll")
+from comtypes.gen.UIAutomationClient import CUIAutomation, IUIAutomation
+
+ComtypesCppTestSrvLib_GUID = "{07D2AEE5-1DF8-4D2C-953A-554ADFD25F99}"
+
+try:
+    GetModule((ComtypesCppTestSrvLib_GUID, 1, 0, 0))
+    from comtypes.gen.ComtypesCppTestSrvLib import StructRecordParamTest
+    from comtypes.gen.ComtypesCppTestSrvLib import IDispSafearrayParamTest
+
+    IMPORT_FAILED = False
+except (ImportError, OSError):
+    IMPORT_FAILED = True
+
+
+class Test_midlSAFEARRAY_create(unittest.TestCase):
+    def test_iunk(self):
+        extra = pointer(IUIAutomation._iid_)
+        iuia = CreateObject(
+            CUIAutomation().IPersist_GetClassID(),
+            interface=IUIAutomation,
+            clsctx=CLSCTX_INPROC_SERVER,
+        )
+        sa_type = comtypes.safearray._midlSAFEARRAY(POINTER(IUIAutomation))
+        for ptn, sa in [
+            ("with extra", sa_type.create([iuia], extra=extra)),
+            ("without extra", sa_type.create([iuia])),
+        ]:
+            with self.subTest(ptn=ptn):
+                (unpacked,) = sa.unpack()
+                self.assertIsInstance(unpacked, POINTER(IUIAutomation))
+
+    @unittest.skipIf(IMPORT_FAILED, "This depends on the out of process COM-server.")
+    def test_idisp(self):
+        extra = pointer(IDispSafearrayParamTest._iid_)
+        idisp = CreateObject(
+            "Comtypes.DispSafearrayParamTest",
+            clsctx=CLSCTX_LOCAL_SERVER,
+            interface=IDispSafearrayParamTest,
+        )
+        sa_type = comtypes.safearray._midlSAFEARRAY(POINTER(IDispSafearrayParamTest))
+        for ptn, sa in [
+            ("with extra", sa_type.create([idisp], extra=extra)),
+            ("without extra", sa_type.create([idisp])),
+        ]:
+            with self.subTest(ptn=ptn):
+                (unpacked,) = sa.unpack()
+                self.assertIsInstance(unpacked, POINTER(IDispSafearrayParamTest))
+
+    @unittest.skipIf(IMPORT_FAILED, "This depends on the out of process COM-server.")
+    def test_record(self):
+        extra = comtypes.typeinfo.GetRecordInfoFromGuids(
+            *StructRecordParamTest._recordinfo_
+        )
+        record = StructRecordParamTest()
+        record.question = "The meaning of life, the universe and everything?"
+        record.answer = 42
+        record.needs_clarification = True
+        sa_type = comtypes.safearray._midlSAFEARRAY(StructRecordParamTest)
+        for ptn, sa in [
+            ("with extra", sa_type.create([record], extra=extra)),
+            ("without extra", sa_type.create([record])),
+        ]:
+            with self.subTest(ptn=ptn):
+                (unpacked,) = sa.unpack()
+                self.assertIsInstance(unpacked, StructRecordParamTest)
+                self.assertEqual(
+                    unpacked.question,
+                    "The meaning of life, the universe and everything?",
+                )
+                self.assertEqual(unpacked.answer, 42)
+                self.assertEqual(unpacked.needs_clarification, True)
+
+    def test_ctype(self):
+        extra = None
+        cdata = c_int(1)
+        sa_type = comtypes.safearray._midlSAFEARRAY(c_int)
+        for ptn, sa in [
+            ("with extra", sa_type.create([cdata], extra=extra)),
+            ("without extra", sa_type.create([cdata])),
+        ]:
+            with self.subTest(ptn=ptn):
+                (unpacked,) = sa.unpack()
+                self.assertIsInstance(unpacked, int)
+                self.assertEqual(unpacked, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

{comtypes-1.4.4 → comtypes-1.4.5}/comtypes/test/test_wmi.py

@@ -1,17 +1,10 @@
-import sys
 import unittest as ut
-from ctypes import POINTER
+
 from comtypes.client import CoGetObject
 from comtypes.test import requires
 
 requires("time")
 
-if sys.version_info >= (3, 0):
-    base_text_type = str
-    text_type = str
-else:
-    base_text_type = basestring
-    text_type = unicode
 
 # WMI has dual interfaces.
 # Some methods/properties have "[out] POINTER(VARIANT)" parameters.
@@ -19,7 +12,7 @@ else:
 # that's what VARIANT.__ctypes_from_outparam__ does.
 class Test(ut.TestCase):
     def test_wmi(self):
-        wmi = CoGetObject("winmgmts:")
+        wmi: "WbemScripting.ISWbemServices" = CoGetObject("winmgmts:")
         disks = wmi.InstancesOf("Win32_LogicalDisk")
 
         # There are different typelibs installed for WMI on win2k and winXP.
@@ -28,8 +21,8 @@ class Test(ut.TestCase):
         #     import comtypes.gen._565783C6_CB41_11D1_8B02_00600806D9B6_0_1_1 as mod
         #   WinXP:
         #     import comtypes.gen._565783C6_CB41_11D1_8B02_00600806D9B6_0_1_2 as mod
-        # So, the one that's referenced onm WbemScripting will be used, whether the actual
-        # typelib is available or not.  XXX
+        # So, the one that's referenced onm WbemScripting will be used, whether the
+        # actual typelib is available or not.  XXX
         from comtypes.gen import WbemScripting
 
         WbemScripting.wbemPrivilegeCreateToken
@@ -37,25 +30,25 @@ class Test(ut.TestCase):
         for item in disks:
             # obj[index] is forwarded to obj.Item(index)
             # .Value is a property with "[out] POINTER(VARIANT)" parameter.
+            item: "WbemScripting.ISWbemObject"
             a = item.Properties_["Caption"].Value
             b = item.Properties_.Item("Caption").Value
             c = item.Properties_("Caption").Value
             self.assertEqual(a, b)
             self.assertEqual(a, c)
-            self.assertTrue(isinstance(a, base_text_type))
-            self.assertTrue(isinstance(b, base_text_type))
-            self.assertTrue(isinstance(c, base_text_type))
+            self.assertTrue(isinstance(a, str))
+            self.assertTrue(isinstance(b, str))
+            self.assertTrue(isinstance(c, str))
             result = {}
             for prop in item.Properties_:
-                self.assertTrue(isinstance(prop.Name, base_text_type))
+                prop: "WbemScripting.ISWbemProperty"
+                self.assertTrue(isinstance(prop.Name, str))
                 prop.Value
                 result[prop.Name] = prop.Value
                 # print "\t", (prop.Name, prop.Value)
             self.assertEqual(len(item.Properties_), item.Properties_.Count)
             self.assertEqual(len(item.Properties_), len(result))
-            self.assertTrue(
-                isinstance(item.Properties_["Description"].Value, text_type)
-            )
+            self.assertTrue(isinstance(item.Properties_["Description"].Value, str))
         # len(obj) is forwared to obj.Count
         self.assertEqual(len(disks), disks.Count)
 

{comtypes-1.4.4 → comtypes-1.4.5/comtypes.egg-info}/PKG-INFO

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

{comtypes-1.4.4 → comtypes-1.4.5}/comtypes.egg-info/SOURCES.txt

@@ -8,10 +8,13 @@ setup.py
 comtypes/GUID.py
 comtypes/__init__.py
 comtypes/_comobject.py
+comtypes/_idl_stuff.py
 comtypes/_memberspec.py
 comtypes/_meta.py
 comtypes/_npsupport.py
+comtypes/_py_instance_method.py
 comtypes/_safearray.py
+comtypes/_tlib_version_checker.py
 comtypes/automation.py
 comtypes/clear_cache.py
 comtypes/connectionpoints.py
@@ -25,6 +28,7 @@ comtypes/patcher.py
 comtypes/persist.py
 comtypes/safearray.py
 comtypes/shelllink.py
+comtypes/stream.py
 comtypes/typeinfo.py
 comtypes/util.py
 comtypes/viewobject.py
@@ -33,6 +37,10 @@ comtypes.egg-info/SOURCES.txt
 comtypes.egg-info/dependency_links.txt
 comtypes.egg-info/entry_points.txt
 comtypes.egg-info/top_level.txt
+comtypes/_post_coinit/__init__.py
+comtypes/_post_coinit/bstr.py
+comtypes/_post_coinit/misc.py
+comtypes/_post_coinit/unknwn.py
 comtypes/client/__init__.py
 comtypes/client/_code_cache.py
 comtypes/client/_constants.py
@@ -77,6 +85,7 @@ comtypes/test/test_comserver.py
 comtypes/test/test_createwrappers.py
 comtypes/test/test_dict.py
 comtypes/test/test_dispifc_records.py
+comtypes/test/test_dispifc_safearrays.py
 comtypes/test/test_dispinterface.py
 comtypes/test/test_dyndispatch.py
 comtypes/test/test_excel.py
@@ -86,7 +95,9 @@ comtypes/test/test_ie.py
 comtypes/test/test_ienum.py
 comtypes/test/test_imfattributes.py
 comtypes/test/test_inout_args.py
+comtypes/test/test_istream.py
 comtypes/test/test_jscript.js
+comtypes/test/test_midl_safearray_create.py
 comtypes/test/test_msscript.py
 comtypes/test/test_npsupport.py
 comtypes/test/test_outparam.py

{comtypes-1.4.4 → comtypes-1.4.5}/setup.cfg

@@ -21,6 +21,7 @@ classifiers =
 python_requires = >=3.7
 packages = 
 	comtypes
+	comtypes._post_coinit
 	comtypes.client
 	comtypes.server
 	comtypes.tools