comtypes 1.4.6__zip → 1.4.8__zip

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

@@ -34,6 +34,7 @@ longlong_type = typedesc.FundamentalType("long long int", 64, 64)
 ulonglong_type = typedesc.FundamentalType("long long unsigned int", 64, 64)
 float_type = typedesc.FundamentalType("float", 32, 32)
 double_type = typedesc.FundamentalType("double", 64, 64)
+void_type = typedesc.FundamentalType("void", 0, 0)
 
 # basic COM data types
 BSTR_type = typedesc.Typedef("BSTR", PTR(wchar_t_type))
@@ -89,7 +90,7 @@ COMTYPES = {
     automation.VT_UI8: ulonglong_type,  # 21
     automation.VT_INT: int_type,  # 22
     automation.VT_UINT: uint_type,  # 23
-    automation.VT_VOID: typedesc.FundamentalType("void", 0, 0),  # 24
+    automation.VT_VOID: void_type,  # 24
     automation.VT_HRESULT: HRESULT_type,  # 25
     automation.VT_LPSTR: PTR(char_type),  # 30
     automation.VT_LPWSTR: PTR(wchar_t_type),  # 31
@@ -126,20 +127,18 @@ class Parser(object):
                 )
             return typ
         elif tdesc.vt == automation.VT_PTR:
-            ptrdesc: typeinfo.TYPEDESC = tdesc._.lptdesc[0]
-            typ = self.make_type(ptrdesc, tinfo)
-            return PTR(typ)
+            return PTR(self.make_type(tdesc._.lptdesc[0], tinfo))
         elif tdesc.vt == automation.VT_USERDEFINED:
             try:
                 ti = tinfo.GetRefTypeInfo(tdesc._.hreftype)
             except COMError as details:
-                type_name = "__error_hreftype_%d__" % tdesc._.hreftype
+                type_name = f"__error_hreftype_{tdesc._.hreftype:d}__"
                 tlib_name = get_tlib_filename(self.tlib)
                 if tlib_name is None:
                     tlib_name = "unknown typelib"
                 message = (
-                    "\n\tGetRefTypeInfo failed in %s: %s\n\tgenerating type '%s' instead"
-                    % (tlib_name, details, type_name)
+                    f"\n\tGetRefTypeInfo failed in {tlib_name}: {details}"
+                    f"\n\tgenerating type '{type_name}' instead"
                 )
                 import warnings
 
@@ -153,8 +152,7 @@ class Parser(object):
             return result
         elif tdesc.vt == automation.VT_SAFEARRAY:
             # SAFEARRAY(<type>), see Don Box pp.331f
-            safearraydesc: typeinfo.TYPEDESC = tdesc._.lptdesc[0]
-            return midlSAFEARRAY(self.make_type(safearraydesc, tinfo))
+            return midlSAFEARRAY(self.make_type(tdesc._.lptdesc[0], tinfo))
         raise NotImplementedError(tdesc.vt)
 
     ################################################################
@@ -271,7 +269,7 @@ class Parser(object):
             # Don't known what artefact that is - we ignore it.
             # It's an interface without methods anyway.
             if itf_name != "IOleControlTypes":
-                message = "Ignoring interface %s which has no base interface" % itf_name
+                message = f"Ignoring interface {itf_name} which has no base interface"
                 import warnings
 
                 warnings.warn(message, UserWarning)
@@ -591,33 +589,26 @@ class Parser(object):
         self, name: Optional[str], value: Any, tlib: Optional[typeinfo.ITypeLib] = None
     ) -> None:
         modname = self._typelib_module(tlib)
-        fullname = "%s.%s" % (modname, name)
+        fullname = f"{modname}.{name}"
         if fullname in self.items:
             # XXX Can we really allow this? It happens, at least.
             if isinstance(value, typedesc.External):
                 return
             # BUG: We try to register an item that's already registered.
-            raise ValueError("Bug: Multiple registered name '%s': %r" % (name, value))
+            raise ValueError(f"Bug: Multiple registered name '{name}': {value!r}")
         self.items[fullname] = value
 
     def parse_typeinfo(self, tinfo: typeinfo.ITypeInfo) -> Any:
         name = tinfo.GetDocumentation(-1)[0]
         modname = self._typelib_module()
         try:
-            return self.items["%s.%s" % (modname, name)]
+            return self.items[f"{modname}.{name}"]
         except KeyError:
             pass
 
         tlib = tinfo.GetContainingTypeLib()[0]
         if tlib != self.tlib:
-            ta = tinfo.GetTypeAttr()
-            size = ta.cbSizeInstance * 8
-            align = ta.cbAlignment * 8
-            typ = typedesc.External(
-                tlib, name, size, align, tlib.GetDocumentation(-1)[:2]
-            )
-            self._register(name, typ, tlib)
-            return typ
+            return self._parse_External(name, tlib, tinfo)
 
         ta = tinfo.GetTypeAttr()
         tkind = ta.typekind
@@ -638,10 +629,7 @@ class Parser(object):
             except COMError:
                 # no dual interface
                 return self.ParseDispatch(tinfo, ta)
-            tinfo = tinfo.GetRefTypeInfo(href)
-            ta = tinfo.GetTypeAttr()
-            assert ta.typekind == typeinfo.TKIND_INTERFACE
-            return self.ParseInterface(tinfo, ta)
+            return self._parse_DualInterface(tinfo.GetRefTypeInfo(href))
         elif tkind == typeinfo.TKIND_COCLASS:  # 5
             return self.ParseCoClass(tinfo, ta)
         elif tkind == typeinfo.TKIND_ALIAS:  # 6
@@ -652,6 +640,24 @@ class Parser(object):
             print("NYI", tkind)
             # raise "NYI", tkind
 
+    def _parse_DualInterface(
+        self, tinfo: typeinfo.ITypeInfo
+    ) -> Optional[typedesc.ComInterface]:
+        ta = tinfo.GetTypeAttr()
+        assert ta.typekind == typeinfo.TKIND_INTERFACE
+        return self.ParseInterface(tinfo, ta)
+
+    def _parse_External(
+        self, name: str, tlib: typeinfo.ITypeLib, tinfo: typeinfo.ITypeInfo
+    ) -> typedesc.External:
+        ta = tinfo.GetTypeAttr()
+        size = ta.cbSizeInstance * 8
+        align = ta.cbAlignment * 8
+        docs = tlib.GetDocumentation(-1)[:2]
+        typ = typedesc.External(tlib, name, size, align, docs)
+        self._register(name, typ, tlib)
+        return typ
+
     def parse_LibraryDescription(self):
         la = self.tlib.GetLibAttr()
         name, doc = self.tlib.GetDocumentation(-1)[:2]
@@ -731,18 +737,13 @@ class TypeLibParser(Parser):
 # path = r"c:\vc98\include\activscp.tlb"
 
 
-def get_tlib_filename(tlib):
+def get_tlib_filename(tlib: typeinfo.ITypeLib) -> Optional[str]:
     # seems if the typelib is not registered, there's no way to
     # determine the filename.
     la = tlib.GetLibAttr()
     name = BSTR()
-    try:
-        windll.oleaut32.QueryPathOfRegTypeLib
-    except AttributeError:
-        # Windows CE doesn't have this function
-        return None
     if 0 == windll.oleaut32.QueryPathOfRegTypeLib(
-        byref(la.guid), la.wMajorVerNum, la.wMinorVerNum, 0, byref(name)  # lcid
+        byref(la.guid), la.wMajorVerNum, la.wMinorVerNum, 0, byref(name)
     ):
         full_filename = name.value.split("\0")[0]
         if not os.path.isabs(full_filename):

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/tools/typedesc.py

@@ -49,7 +49,7 @@ class External(object):
         name: str,
         size: int,
         align: int,
-        docs: Optional[Tuple[str, str]] = None,
+        docs: Optional[Tuple[str, Optional[str]]] = None,
     ) -> None:
         # the type library containing the symbol
         self.tlib = tlib
@@ -238,7 +238,7 @@ _SourceInterfaces = Sequence[_Interface]
 
 
 def groupby_impltypeflags(
-    seq: Sequence[Tuple[_Interface, _ImplTypeFlags]]
+    seq: Sequence[Tuple[_Interface, _ImplTypeFlags]],
 ) -> Tuple[_ImplementedInterfaces, _SourceInterfaces]:
     implemented = []
     sources = []

{comtypes-1.4.6 → comtypes-1.4.8}/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,12 @@ 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(),  # type: ignore
+            self.ReleaseTLibAttr,
+        )
 
     def IsName(self, name: str, lHashVal: int = 0) -> Optional[str]:
         """Check if there is type information for this name.
@@ -268,15 +270,9 @@ class ITypeLib(IUnknown):
 
 
 @overload
-def fix_name(name: None) -> None:
-    pass
-
-
+def fix_name(name: None) -> None: ...
 @overload
-def fix_name(name: str) -> str:
-    pass
-
-
+def fix_name(name: str) -> str: ...
 def fix_name(name):
     # Some typelibs contain BSTR with embedded NUL characters,
     # probably the len of the BSTR is wrong.
@@ -341,27 +337,33 @@ 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(),  # type: ignore
+            self.ReleaseTypeAttr,
+        )
 
-    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),  # type: ignore
+            self.ReleaseFuncDesc,
+        )
 
-    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),  # type: ignore
+            self.ReleaseVarDesc,
+        )
 
     def GetNames(self, memid: int, count: int = 1) -> List[str]:
         """Return names for memid"""
@@ -455,13 +457,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):
@@ -478,25 +479,23 @@ class IRecordInfo(IUnknown):
         return result
 
     if TYPE_CHECKING:
-        # fmt: off
         # def RecordInit
         # def RecordClear
-        def RecordCopy(  # noqa
+        def RecordCopy(
             self, pvExisting: hints.Incomplete, pvNew: hints.Incomplete
         ) -> hints.Hresult: ...
-        def GetGuid(self) -> GUID: ...  # noqa
-        def GetName(self) -> str: ...  # noqa
-        def GetSize(self) -> int: ...  # noqa
-        def GetTypeInfo(self) -> ITypeInfo: ...  # noqa
+        def GetGuid(self) -> GUID: ...
+        def GetName(self) -> str: ...
+        def GetSize(self) -> int: ...
+        def GetTypeInfo(self) -> ITypeInfo: ...
         # def GetField
         # def GetFieldNoCopy
         # def PutField
         # def PutFieldNoCopy
-        def IsMatchingType(self, value: "IRecordInfo") -> bool: ...  # noqa
+        def IsMatchingType(self, value: "IRecordInfo") -> bool: ...
         # def RecordCreate
-        def RecordCreateCopy(self, pvSource: hints.Incomplete) -> int: ...  # noqa
-        def RecordDestroy(self, pvRecord: hints.Incomplete) -> hints.Hresult: ...  # noqa
-        # fmt: on
+        def RecordCreateCopy(self, pvSource: hints.Incomplete) -> int: ...
+        def RecordDestroy(self, pvRecord: hints.Incomplete) -> hints.Hresult: ...
 
 
 IRecordInfo._methods_ = [
@@ -1122,8 +1121,8 @@ tagTLIBATTR._fields_ = [
 class N11tagTYPEDESC5DOLLAR_203E(ctypes.Union):
     # C:/Programme/gccxml/bin/Vc71/PlatformSDK/oaidl.h 584
     if TYPE_CHECKING:
-        lptdesc: TYPEDESC
-        lpadesc: tagARRAYDESC
+        lptdesc: _Pointer[tagTYPEDESC]
+        lpadesc: _Pointer[tagARRAYDESC]
         hreftype: int
 
 
@@ -1172,7 +1171,7 @@ class N10tagVARDESC5DOLLAR_205E(ctypes.Union):
     # C:/Programme/gccxml/bin/Vc71/PlatformSDK/oaidl.h 807
     if TYPE_CHECKING:
         oInst: int
-        lpvarValue: VARIANT
+        lpvarValue: _Pointer[VARIANT]
 
 
 N10tagVARDESC5DOLLAR_205E._fields_ = [

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/util.py

@@ -1,6 +1,7 @@
 """This module defines the funtions byref_at(cobj, offset)
 and cast_field(struct, fieldname, fieldtype).
 """
+
 from ctypes import *
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: comtypes
-Version: 1.4.6
+Version: 1.4.8
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases
@@ -13,58 +13,53 @@ 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
 
 # comtypes
 
 ![Works on Windows only](https://img.shields.io/badge/-Windows-0078D6.svg?logo=windows&style=flat)  
-[![PyPI version](https://badge.fury.io/py/comtypes.svg)](https://pypi.org/project/comtypes/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - License](https://img.shields.io/pypi/l/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/comtypes)](https://pypi.org/project/comtypes/)  
-[![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)  
+[![PyPI version](https://badge.fury.io/py/comtypes.svg)](https://pypi.org/project/comtypes/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - Python Requires](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Fcomtypes%2Fjson&query=info.requires_python&label=Python Requires)](https://pypi.org/project/comtypes/)  
+[![PyPI - License](https://img.shields.io/pypi/l/comtypes)](https://pypi.org/project/comtypes/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/comtypes)](https://pypi.org/project/comtypes/)  
+[![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) [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)  
 [![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.7](https://pypi.org/project/comtypes/1.4.7/) does not work with Python 3.13 as reported in [GH-618](https://github.com/enthought/comtypes/issues/618). Version [1.4.8](https://pypi.org/project/comtypes/1.4.8/) can work with Python 3.13.
+- 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 +72,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 +97,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.8}/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.8/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=61.2"]
+build-backend = "setuptools.build_meta"
+
+[tool.ruff.lint]
+ignore = ["E402"]
+
+[tool.ruff.lint.per-file-ignores]
+# production
+"comtypes/_comobject.py" = ["E713", "E722", "F401"]
+"comtypes/_npsupport.py" = ["F401"]
+"comtypes/connectionpoints.py" = ["F401", "F403", "F405"]
+"comtypes/automation.py" = ["F401", "F403", "F405"]
+"comtypes/errorinfo.py" = ["F403", "F405"]
+"comtypes/git.py" = ["F401", "F403", "F405"]
+"comtypes/logutil.py" = ["E401"]
+"comtypes/shelllink.py" = ["F401"]
+"comtypes/util.py" = ["F403", "F405"]
+"comtypes/viewobject.py" = ["F403", "F405"]
+"comtypes/_post_coinit/unknwn.py" = ["F821"]
+"comtypes/client/__init__.py" = ["F401", "F403"]
+"comtypes/client/_code_cache.py" = ["E401", "E711"]
+"comtypes/client/_constants.py" = ["F401"]
+"comtypes/client/_events.py" = ["F841"]
+"comtypes/client/lazybind.py" = ["F821"]
+"comtypes/server/__init__.py" = ["E401"]
+"comtypes/server/automation.py" = ["F403", "F405"]
+"comtypes/server/connectionpoints.py" = ["F401", "F403", "F405"]
+"comtypes/server/inprocserver.py" = ["E713", "E722", "F403", "F405", "F841"]
+"comtypes/server/localserver.py" = ["F401", "F403", "F405"]
+"comtypes/server/register.py" = ["F403", "F405", "E713", "E731"]
+"comtypes/tools/codegenerator/codegenerator.py" = ["E713", "E721"]
+"comtypes/tools/codegenerator/helpers.py" = ["F401"]
+"comtypes/tools/codegenerator/packing.py" = ["F821", "F841"]
+"comtypes/tools/tlbparser.py" = ["F401"]
+"comtypes/tools/typedesc.py" = ["F403", "F405"]
+"comtypes/tools/typedesc_base.py" = ["F401"]
+# tests
+"comtypes/test/TestComServer.py" = ["E401", "F401", "F403", "F405"]
+"comtypes/test/TestDispServer.py" = ["E401"]
+"comtypes/test/find_memleak.py" = ["E401", "F401", "F403", "F405"]
+"comtypes/test/setup.py" = ["F401"]
+"comtypes/test/test_BSTR.py" = ["E401", "F401", "F403", "F405"]
+"comtypes/test/test_agilent.py" = ["F401", "F841"]
+"comtypes/test/test_client.py" = ["F401"]
+"comtypes/test/test_dict.py" = ["F841"]
+"comtypes/test/test_ie.py" = ["F403", "F405", "F841"]
+"comtypes/test/test_outparam.py" = ["F403", "F405", "F841"]
+"comtypes/test/test_sapi.py" = ["E401"]
+"comtypes/test/test_server.py" = ["E401", "E722", "F401", "F841"]
+"comtypes/test/test_subinterface.py" = ["E401", "F401", "F403", "F405"]
+"comtypes/test/test_typeinfo.py" = ["F401"]
+"comtypes/test/test_urlhistory.py" = ["E401", "F401", "F403", "F405", "F841"]
+"comtypes/test/test_variant.py" = ["F401", "F821", "F841"]

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

comtypes-1.4.6/comtypes/_meta.py

@@ -1,70 +0,0 @@
-# comtypes._meta helper module
-from ctypes import POINTER, c_void_p, cast
-import comtypes
-
-################################################################
-# metaclass for CoClass (in comtypes/__init__.py)
-
-
-def _wrap_coclass(self):
-    # We are an IUnknown pointer, represented as a c_void_p instance,
-    # but we really want this interface:
-    itf = self._com_interfaces_[0]
-    punk = cast(self, POINTER(itf))
-    result = punk.QueryInterface(itf)
-    result.__dict__["__clsid"] = str(self._reg_clsid_)
-    return result
-
-
-def _coclass_from_param(cls, obj):
-    if isinstance(obj, (cls._com_interfaces_[0], cls)):
-        return obj
-    raise TypeError(obj)
-
-
-#
-# The mro() of a POINTER(App) type, where class App is a subclass of CoClass:
-#
-#  POINTER(App)
-#   App
-#    CoClass
-#     c_void_p
-#      _SimpleCData
-#       _CData
-#        object
-
-
-class _coclass_meta(type):
-    # metaclass for CoClass
-    #
-    # When a CoClass subclass is created, create a POINTER(...) type
-    # for that class, with bases <coclass> and c_void_p.  Also, the
-    # POINTER(...) type gets a __ctypes_from_outparam__ method which
-    # will QueryInterface for the default interface: the first one on
-    # the coclass' _com_interfaces_ list.
-    def __new__(cls, name, bases, namespace):
-        klass = type.__new__(cls, name, bases, namespace)
-        if bases == (object,):
-            return klass
-        # XXX We should insist that a _reg_clsid_ is present.
-        if "_reg_clsid_" in namespace:
-            clsid = namespace["_reg_clsid_"]
-            comtypes.com_coclass_registry[str(clsid)] = klass
-        PTR = _coclass_pointer_meta(
-            "POINTER(%s)" % klass.__name__,
-            (klass, c_void_p),
-            {
-                "__ctypes_from_outparam__": _wrap_coclass,
-                "from_param": classmethod(_coclass_from_param),
-            },
-        )
-        from ctypes import _pointer_type_cache
-
-        _pointer_type_cache[klass] = PTR
-
-        return klass
-
-
-# will not work if we change the order of the two base classes!
-class _coclass_pointer_meta(type(c_void_p), _coclass_meta):
-    pass