comtypes 1.4.6__zip → 1.4.7__zip

comtypes-1.4.7/comtypes/test/test_monikers.py

@@ -0,0 +1,70 @@
+from _ctypes import COMError
+from ctypes import byref, POINTER
+import contextlib
+import unittest
+
+import comtypes
+from comtypes.client import GetModule, CreateObject
+from comtypes import hresult, GUID
+
+with contextlib.redirect_stdout(None):  # supress warnings
+    GetModule("msvidctl.dll")
+from comtypes.gen import MSVidCtlLib as msvidctl
+from comtypes.gen.MSVidCtlLib import IBindCtx, IMoniker, IRunningObjectTable
+
+
+MKSYS_ITEMMONIKER = 4
+ROTFLAGS_ALLOWANYCLIENT = 1
+
+
+def _create_item_moniker(delim: str, item: str) -> IMoniker:
+    mon = POINTER(IMoniker)()
+    comtypes._ole32.CreateItemMoniker(delim, item, byref(mon))
+    return mon  # type: ignore
+
+
+def _create_bctx() -> IBindCtx:
+    bctx = POINTER(IBindCtx)()
+    # The first parameter is reserved and must be 0.
+    comtypes._ole32.CreateBindCtx(0, byref(bctx))
+    return bctx  # type: ignore
+
+
+def _create_rot() -> IRunningObjectTable:
+    rot = POINTER(IRunningObjectTable)()
+    # The first parameter is reserved and must be 0.
+    comtypes._ole32.GetRunningObjectTable(0, byref(rot))
+    return rot  # type: ignore
+
+
+class Test_IMoniker(unittest.TestCase):
+    def test_IsSystemMoniker(self):
+        item_id = str(GUID.create_new())
+        mon = _create_item_moniker("!", item_id)
+        self.assertEqual(mon.IsSystemMoniker(), MKSYS_ITEMMONIKER)
+
+
+class Test_IBindCtx(unittest.TestCase):
+    def test_EnumObjectParam(self):
+        bctx = _create_bctx()
+        with self.assertRaises(COMError) as err_ctx:
+            # calling `EnumObjectParam` results in a return value of E_NOTIMPL.
+            # https://learn.microsoft.com/en-us/windows/win32/api/objidl/nf-objidl-ibindctx-enumobjectparam#notes-to-callers
+            bctx.EnumObjectParam()
+        self.assertEqual(err_ctx.exception.hresult, hresult.E_NOTIMPL)
+
+
+class Test_IRunningObjectTable(unittest.TestCase):
+    def test_register_and_revoke_item_moniker(self):
+        vidctl = CreateObject(msvidctl.MSVidCtl, interface=msvidctl.IMSVidCtl)
+        item_id = str(GUID.create_new())
+        mon = _create_item_moniker("!", item_id)
+        rot = _create_rot()
+        bctx = _create_bctx()
+        self.assertEqual(mon.IsRunning(bctx, None, None), hresult.S_FALSE)
+        dw_reg = rot.Register(ROTFLAGS_ALLOWANYCLIENT, vidctl, mon)
+        self.assertEqual(mon.IsRunning(bctx, None, None), hresult.S_OK)
+        self.assertEqual(f"!{item_id}", mon.GetDisplayName(bctx, None))
+        self.assertEqual(rot.GetObject(mon).QueryInterface(msvidctl.IMSVidCtl), vidctl)
+        rot.Revoke(dw_reg)
+        self.assertEqual(mon.IsRunning(bctx, None, None), hresult.S_FALSE)

comtypes-1.4.7/comtypes/test/test_persist.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+import tempfile
+import unittest as ut
+
+from comtypes import CoCreateInstance, GUID, IPersist
+from comtypes import persist
+
+
+CLSID_ShellLink = GUID("{00021401-0000-0000-C000-000000000046}")
+
+
+class Test_IPersist(ut.TestCase):
+    def test_GetClassID(self):
+        p = CoCreateInstance(CLSID_ShellLink).QueryInterface(IPersist)
+        self.assertEqual(p.GetClassID(), CLSID_ShellLink)
+
+
+class Test_IPersistFile(ut.TestCase):
+    def setUp(self):
+        td = tempfile.TemporaryDirectory()
+        self.addCleanup(td.cleanup)
+        self.tmp_dir = Path(td.name)
+
+    def _create_pf(self) -> persist.IPersistFile:
+        return CoCreateInstance(CLSID_ShellLink).QueryInterface(persist.IPersistFile)
+
+    def test_load(self):
+        pf = self._create_pf()
+        tgt_file = (self.tmp_dir / "tgt.txt").resolve()
+        tgt_file.touch()
+        pf.Load(str(tgt_file), persist.STGM_DIRECT)
+        self.assertEqual(pf.GetCurFile(), str(tgt_file))
+
+    def test_save(self):
+        pf = self._create_pf()
+        tgt_file = self.tmp_dir / "tgt.txt"
+        self.assertFalse(tgt_file.exists())
+        pf.Save(str(tgt_file), True)
+        self.assertEqual(pf.GetCurFile(), str(tgt_file))
+        self.assertTrue(tgt_file.exists())

comtypes-1.4.7/comtypes/test/test_shelllink.py

@@ -0,0 +1,133 @@
+from pathlib import Path
+import tempfile
+import unittest as ut
+
+from comtypes import CoCreateInstance, GUID, shelllink
+import comtypes.hresult
+from comtypes.persist import IPersistFile
+
+
+CLSID_ShellLink = GUID("{00021401-0000-0000-C000-000000000046}")
+
+
+class Test_IShellLinkA(ut.TestCase):
+    def setUp(self):
+        td = tempfile.TemporaryDirectory()
+        self.addCleanup(td.cleanup)
+        self.tmp_dir = Path(td.name)
+        self.src_file = (self.tmp_dir / "src.txt").resolve()
+        self.src_file.touch()
+
+    def _create_shortcut(self) -> shelllink.IShellLinkA:
+        return CoCreateInstance(CLSID_ShellLink, interface=shelllink.IShellLinkA)
+
+    def test_set_and_get_path(self):
+        shortcut = self._create_shortcut()
+        pf = shortcut.QueryInterface(IPersistFile)
+        self.assertEqual(pf.IsDirty(), comtypes.hresult.S_FALSE)
+        shortcut.SetPath(str(self.src_file).encode("utf-8"))
+        self.assertEqual(pf.IsDirty(), comtypes.hresult.S_OK)
+        self.assertEqual(
+            shortcut.GetPath(shelllink.SLGP_UNCPRIORITY),
+            str(self.src_file).encode("utf-8"),
+        )
+        lnk_file = (self.tmp_dir / "new.lnk").resolve()
+        self.assertFalse(lnk_file.exists())
+        pf.Save(str(lnk_file), True)
+        self.assertTrue(lnk_file.exists())
+        self.assertEqual(pf.GetCurFile(), str(lnk_file))
+
+    def test_set_and_get_working_directory(self):
+        shortcut = self._create_shortcut()
+        shortcut.SetWorkingDirectory(str(self.tmp_dir).encode("utf-8"))
+        self.assertEqual(
+            shortcut.GetWorkingDirectory(), str(self.tmp_dir).encode("utf-8")
+        )
+
+    def test_set_and_get_arguments(self):
+        shortcut = self._create_shortcut()
+        shortcut.SetArguments(b"-f")
+        self.assertEqual(shortcut.GetArguments(), b"-f")
+
+    def test_set_and_get_hotkey(self):
+        HOTKEYF_ALT = 0x04
+        HOTKEYF_CONTROL = 0x02
+        shortcut = self._create_shortcut()
+        shortcut.Hotkey = HOTKEYF_ALT | HOTKEYF_CONTROL
+        self.assertEqual(shortcut.Hotkey, HOTKEYF_ALT | HOTKEYF_CONTROL)
+
+    def test_set_and_get_showcmd(self):
+        SW_SHOWMAXIMIZED = 0x03
+        shortcut = self._create_shortcut()
+        shortcut.ShowCmd = SW_SHOWMAXIMIZED
+        self.assertEqual(shortcut.ShowCmd, SW_SHOWMAXIMIZED)
+
+    def test_set_and_get_icon_location(self):
+        shortcut = self._create_shortcut()
+        shortcut.SetIconLocation(str(self.src_file).encode("utf-8"), 1)
+        icon_path, index = shortcut.GetIconLocation()
+        self.assertEqual(icon_path, str(self.src_file).encode("utf-8"))
+        self.assertEqual(index, 1)
+
+
+class Test_IShellLinkW(ut.TestCase):
+    def setUp(self):
+        td = tempfile.TemporaryDirectory()
+        self.addCleanup(td.cleanup)
+        self.tmp_dir = Path(td.name)
+        self.src_file = (self.tmp_dir / "src.txt").resolve()
+        self.src_file.touch()
+
+    def _create_shortcut(self) -> shelllink.IShellLinkW:
+        return CoCreateInstance(CLSID_ShellLink, interface=shelllink.IShellLinkW)
+
+    def test_set_and_get_path(self):
+        shortcut = self._create_shortcut()
+        pf = shortcut.QueryInterface(IPersistFile)
+        self.assertEqual(pf.IsDirty(), comtypes.hresult.S_FALSE)
+        shortcut.SetPath(str(self.src_file))
+        self.assertEqual(pf.IsDirty(), comtypes.hresult.S_OK)
+        self.assertEqual(
+            shortcut.GetPath(shelllink.SLGP_UNCPRIORITY),
+            str(self.src_file),
+        )
+        lnk_file = (self.tmp_dir / "new.lnk").resolve()
+        self.assertFalse(lnk_file.exists())
+        pf.Save(str(lnk_file), True)
+        self.assertTrue(lnk_file.exists())
+        self.assertEqual(pf.GetCurFile(), str(lnk_file))
+
+    def test_set_and_get_description(self):
+        shortcut = self._create_shortcut()
+        shortcut.SetDescription("sample")
+        self.assertEqual(shortcut.GetDescription(), "sample")
+
+    def test_set_and_get_working_directory(self):
+        shortcut = self._create_shortcut()
+        shortcut.SetWorkingDirectory(str(self.tmp_dir))
+        self.assertEqual(shortcut.GetWorkingDirectory(), str(self.tmp_dir))
+
+    def test_set_and_get_arguments(self):
+        shortcut = self._create_shortcut()
+        shortcut.SetArguments("-f")
+        self.assertEqual(shortcut.GetArguments(), "-f")
+
+    def test_set_and_get_hotkey(self):
+        HOTKEYF_ALT = 0x04
+        HOTKEYF_CONTROL = 0x02
+        shortcut = self._create_shortcut()
+        shortcut.Hotkey = HOTKEYF_ALT | HOTKEYF_CONTROL
+        self.assertEqual(shortcut.Hotkey, HOTKEYF_ALT | HOTKEYF_CONTROL)
+
+    def test_set_and_get_showcmd(self):
+        SW_SHOWMAXIMIZED = 0x03
+        shortcut = self._create_shortcut()
+        shortcut.ShowCmd = SW_SHOWMAXIMIZED
+        self.assertEqual(shortcut.ShowCmd, SW_SHOWMAXIMIZED)
+
+    def test_set_and_get_icon_location(self):
+        shortcut = self._create_shortcut()
+        shortcut.SetIconLocation(str(self.src_file), 1)
+        icon_path, index = shortcut.GetIconLocation()
+        self.assertEqual(icon_path, str(self.src_file))
+        self.assertEqual(index, 1)

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.6 → comtypes-1.4.7}/comtypes/typeinfo.py

@@ -3,7 +3,6 @@
 # generated by 'xml2py'
 # flags '..\tools\windows.xml -m comtypes -m comtypes.automation -w -r .*TypeLibEx -r .*TypeLib -o typeinfo.py'
 # then hacked manually
-import os
 import sys
 from typing import Any, overload, TypeVar, TYPE_CHECKING
 from typing import List, Type, Tuple
@@ -14,7 +13,7 @@ import weakref
 import ctypes
 from ctypes import HRESULT, POINTER, _Pointer, byref, c_int, c_void_p, c_wchar_p
 from ctypes.wintypes import DWORD, LONG, UINT, ULONG, WCHAR, WORD
-from comtypes import BSTR, _CData, COMMETHOD, _GUID, GUID, IID, IUnknown, STDMETHOD
+from comtypes import BSTR, _CData, COMMETHOD, GUID, IID, IUnknown, STDMETHOD
 from comtypes.automation import DISPID, LCID, SCODE
 from comtypes.automation import DISPPARAMS, EXCEPINFO, VARIANT, VARIANTARG, VARTYPE
 
@@ -219,7 +218,9 @@ class ITypeLib(IUnknown):
             """Return an ITypeComp pointer."""
             ...
 
-        def GetDocumentation(self, index: int) -> Tuple[str, str, int, Optional[str]]:
+        def GetDocumentation(
+            self, index: int
+        ) -> Tuple[str, Optional[str], int, Optional[str]]:
             """Return documentation for a type description."""
             ...
 
@@ -227,11 +228,11 @@ class ITypeLib(IUnknown):
             """Release TLIBATTR"""
             ...
 
-    _GetLibAttr: Callable[[], "_Pointer[TLIBATTR]"]
-
     def GetLibAttr(self) -> "TLIBATTR":
         """Return type library attributes"""
-        return _deref_with_release(self._GetLibAttr(), self.ReleaseTLibAttr)
+        return _deref_with_release(
+            self._GetLibAttr(), self.ReleaseTLibAttr  # type: ignore
+        )
 
     def IsName(self, name: str, lHashVal: int = 0) -> Optional[str]:
         """Check if there is type information for this name.
@@ -341,27 +342,30 @@ class ITypeInfo(IUnknown):
             """Releases a VARDESC previously returned by VarDesc"""
             ...
 
-    _GetTypeAttr: Callable[[], "_Pointer[TYPEATTR]"]
-    _GetFuncDesc: Callable[[int], "_Pointer[FUNCDESC]"]
-    _GetVarDesc: Callable[[int], "_Pointer[VARDESC]"]
-    _GetDocumentation: Callable[[int], Tuple[str, str, int, Optional[str]]]
-
-    def GetTypeAttr(self):
+    def GetTypeAttr(self) -> "TYPEATTR":
         """Return the TYPEATTR for this type"""
-        return _deref_with_release(self._GetTypeAttr(), self.ReleaseTypeAttr)
+        return _deref_with_release(
+            self._GetTypeAttr(), self.ReleaseTypeAttr  # type: ignore
+        )
 
-    def GetDocumentation(self, memid):
+    def GetDocumentation(
+        self, memid: int
+    ) -> Tuple[str, Optional[str], int, Optional[str]]:
         """Return name, docstring, helpcontext, and helpfile for 'memid'."""
-        name, doc, helpcontext, helpfile = self._GetDocumentation(memid)
-        return fix_name(name), fix_name(doc), helpcontext, fix_name(helpfile)
+        name, doc, helpctx, helpfile = self._GetDocumentation(memid)  # type: ignore
+        return fix_name(name), fix_name(doc), helpctx, fix_name(helpfile)
 
-    def GetFuncDesc(self, index):
+    def GetFuncDesc(self, index: int) -> "FUNCDESC":
         """Return FUNCDESC for index"""
-        return _deref_with_release(self._GetFuncDesc(index), self.ReleaseFuncDesc)
+        return _deref_with_release(
+            self._GetFuncDesc(index), self.ReleaseFuncDesc  # type: ignore
+        )
 
-    def GetVarDesc(self, index):
+    def GetVarDesc(self, index: int) -> "VARDESC":
         """Return VARDESC for index"""
-        return _deref_with_release(self._GetVarDesc(index), self.ReleaseVarDesc)
+        return _deref_with_release(
+            self._GetVarDesc(index), self.ReleaseVarDesc  # type: ignore
+        )
 
     def GetNames(self, memid: int, count: int = 1) -> List[str]:
         """Return names for memid"""
@@ -455,13 +459,12 @@ class ICreateTypeLib2(ICreateTypeLib):
 class ICreateTypeInfo(IUnknown):
     _iid_ = GUID("{00020405-0000-0000-C000-000000000046}")
     # C:/Programme/gccxml/bin/Vc71/PlatformSDK/oaidl.h 915
-    _SetFuncAndParamNames: Callable[[int, "ctypes.Array[c_wchar_p]", int], int]
 
     def SetFuncAndParamNames(self, index: int, *names: str) -> int:
         rgszNames = (c_wchar_p * len(names))()
         for i, n in enumerate(names):
             rgszNames[i] = n
-        return self._SetFuncAndParamNames(index, rgszNames, len(names))
+        return self._SetFuncAndParamNames(index, rgszNames, len(names))  # type: ignore
 
 
 class IRecordInfo(IUnknown):

{comtypes-1.4.6 → comtypes-1.4.7/comtypes.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: comtypes
-Version: 1.4.6
+Version: 1.4.7
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases
@@ -13,7 +13,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 
@@ -24,47 +24,40 @@ License-File: LICENSE.txt
 [![GitHub Repo stars](https://img.shields.io/github/stars/enthought/comtypes?style=social)](https://github.com/enthought/comtypes/stargazers) [![GitHub forks](https://img.shields.io/github/forks/enthought/comtypes?style=social)](https://github.com/enthought/comtypes/network/members)  
 [![Tidelift Subscription](https://tidelift.com/badges/package/pypi/comtypes)](https://tidelift.com/subscription/pkg/pypi-comtypes?utm_source=pypi-comtypes&utm_medium=readme)
 
-## About
 
-`comtypes` is a lightweight `Python` [COM](https://learn.microsoft.com/en-us/windows/win32/com/component-object-model--com--portal) package, based on the [`ctypes`](https://docs.python.org/library/ctypes.html) FFI library.
+`comtypes` is a lightweight pure Python [COM](https://learn.microsoft.com/en-us/windows/win32/com/component-object-model--com--portal) package based on the [`ctypes`](https://docs.python.org/library/ctypes.html) foreign function interface library.
 
-`comtypes` allows to define, call, and implement custom and dispatch-based COM interfaces in pure `Python`.
+`comtypes` allows you to define, call, and implement custom and dispatch-based COM interfaces in pure Python.
 
-This package works on Windows only.
+`comtypes` requires Windows and Python 3.8 or later.
+- Version [1.4.6](https://pypi.org/project/comtypes/1.4.6/) is the last version to support Python 3.7.
+- Version [1.2.1](https://pypi.org/project/comtypes/1.2.1/) is the last version to support Python 2.7 and 3.3–3.6.
+- `comtypes` does not work with Python 3.8.1 as reported in [GH-202](https://github.com/enthought/comtypes/issues/202). This bug has been fixed in Python >= 3.8.2.
+- Certain `comtypes` functions may not work correctly in Python 3.8 and 3.9 as reported in [GH-212](https://github.com/enthought/comtypes/issues/212). This bug has been fixed in Python >= 3.10.10 and >= 3.11.2.
 
-Available on `Python` 3.7-3.12.
-- [`comtypes==1.2.1`](https://pypi.org/project/comtypes/1.2.1/) is the last version supporting `Python` 2.7 and 3.3-3.6.
-- In `Python` 3.7.6 and 3.8.1, `comtypes` would not work as reported in [GH-202](https://github.com/enthought/comtypes/issues/202).  
-This bug has been fixed in `Python` >= 3.7.7 and >= 3.8.2.
-- In `Python` 3.8 and 3.9, some of `comtypes` functionalities may not work correctly as reported in [GH-212](https://github.com/enthought/comtypes/issues/212).  
-This bug has been fixed in `Python` >= 3.10.10 and >= 3.11.2.
-
-## Where to get it
-
-The source code is currently hosted on GitHub at:
-https://github.com/enthought/comtypes
-
-An installer for the latest released version is available at the [Python Package Index (PyPI)](https://pypi.org/project/comtypes).
+## Installation
 
+`comtypes` is available on [PyPI](https://pypi.org/project/comtypes) and can be installed with `pip`:
 ```sh
 # PyPI
 pip install comtypes
 ```
 
-## Dependencies
+The source code is currently hosted [here](https://github.com/enthought/comtypes) on GitHub.
+
+### Dependencies
 
-`comtypes` requires no third-party packages to run - this is truly **pure** `Python` package.
+`comtypes` is a pure Python package — it has no additional required dependencies.
 
-Optional features include the follows...
-- to process arrays as `numpy`'s `ndarray`
-- type hints be interpreted by `mypy` or several static type checkers
+Optional functionalities can be enabled by installing:
+- `numpy`, in order to process arrays as `numpy`'s `ndarray`.
+- `mypy` or other static type checkers, in order to interpret type hints.
 
-But these third-parties are not required as a prerequisite for runtime.
+None of these packages, however, are required in order to run `comtypes`.
 
-## Community of the developers
+## Community
 
-Tracking issues, reporting bugs and contributing to the codebase and documentation are on GitHub at:
-https://github.com/enthought/comtypes
+The [GitHub repository](https://github.com/enthought/comtypes) is used for tracking issues, reporting bugs, and contributing to the codebase and documentation.
 
 ## For Enterprise
 
@@ -77,17 +70,17 @@ This project and the maintainers of thousands of other packages are working with
 ## Frequently Asked Questions
 
 ### Q: Why does this package not support platforms other than Windows?
-**A:** [The Microsoft Component Object Model (COM)](https://learn.microsoft.com/en-us/windows/win32/com/com-technical-overview) is a technology that is unique to Windows and is not supported on other platforms.
+**A:** The [Microsoft Component Object Model (COM)](https://learn.microsoft.com/en-us/windows/win32/com/com-technical-overview) is a technology that is unique to Windows and is not supported on other platforms.
 
 [The phrase _"COM is a platform-independent"_ in the MS documentation](https://learn.microsoft.com/en-us/windows/win32/com/component-object-model--com--portal) means that COM maintains compatibility across different versions of Windows, and does NOT imply that it is supported on Linux or Mac.
 
-As long as COM is not supported outside of Windows, this project does not plan to port to other platforms.
+For as long as COM is not supported outside of Windows, there is no plan to port `comtypes` to other platforms.
 
 ### Q: Why does `cannot import name 'COMError' from '_ctypes'` error occur when using this package on platforms other than Windows?
-**A:** The [`_ctypes`](https://github.com/python/cpython/blob/main/Modules/_ctypes/_ctypes.c) is part of the internal implementation of the [`ctypes`](https://github.com/python/cpython/blob/main/Lib/ctypes/) standard library that exists for Python on all platforms.  
-However, `COMError` and COM-related features are implemented only in Python for Windows.
+**A:** The [`_ctypes`](https://github.com/python/cpython/blob/main/Modules/_ctypes/_ctypes.c) is part of the internal implementation of the [`ctypes`](https://github.com/python/cpython/blob/main/Lib/ctypes/) standard library that exists for Python on all platforms.
+However, `COMError` and COM-related features are only implemented in Python for Windows.
 
-In cross-platform software development, care must be taken to ensure that codebase dependent on `comtypes` does not execute in environments other than Windows.
+In cross-platform software development, care must be taken to ensure that codebases that depend on `comtypes` do not execute in environments other than Windows.
 
 ### Q: Despite a script that depends on `comtypes` having run successfully before, a error (`ImportError`, `NameError`, or `SyntaxError`) is raised now, and the same error occurs again and again.
 
@@ -102,7 +95,6 @@ After deleting these partial modules and running the script again, `comtypes.cli
 
 However, if the script implementation does not use `comtypes.client.GetModule` or processes generated files, it may not be a solution.
 
-## Documentation:
+## Documentation
 
-The documentation is currently hosted on pythonhosted at:
-https://pythonhosted.org/comtypes
+The documentation is currently hosted [here](https://pythonhosted.org/comtypes) on PythonHosted.

{comtypes-1.4.6 → comtypes-1.4.7}/comtypes.egg-info/SOURCES.txt

@@ -95,19 +95,23 @@ 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_monikers.py
 comtypes/test/test_msscript.py
 comtypes/test/test_npsupport.py
 comtypes/test/test_outparam.py
+comtypes/test/test_persist.py
 comtypes/test/test_propputref.py
 comtypes/test/test_pump_events.py
 comtypes/test/test_recordinfo.py
 comtypes/test/test_safearray.py
 comtypes/test/test_sapi.py
 comtypes/test/test_server.py
+comtypes/test/test_shelllink.py
 comtypes/test/test_showevents.py
+comtypes/test/test_storage.py
+comtypes/test/test_stream.py
 comtypes/test/test_subinterface.py
 comtypes/test/test_typeannotator.py
 comtypes/test/test_typeinfo.py

{comtypes-1.4.6 → comtypes-1.4.7}/setup.cfg

@@ -18,7 +18,7 @@ classifiers =
 	Topic :: Software Development :: Libraries :: Python Modules
 
 [options]
-python_requires = >=3.7
+python_requires = >=3.8
 packages = 
 	comtypes
 	comtypes._post_coinit