comtypes 1.4.7__zip → 1.4.8__zip

{comtypes-1.4.7 → 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.7 → 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]]] = {}

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

@@ -231,7 +231,8 @@ class ITypeLib(IUnknown):
     def GetLibAttr(self) -> "TLIBATTR":
         """Return type library attributes"""
         return _deref_with_release(
-            self._GetLibAttr(), self.ReleaseTLibAttr  # type: ignore
+            self._GetLibAttr(),  # type: ignore
+            self.ReleaseTLibAttr,
         )
 
     def IsName(self, name: str, lHashVal: int = 0) -> Optional[str]:
@@ -269,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.
@@ -345,7 +340,8 @@ class ITypeInfo(IUnknown):
     def GetTypeAttr(self) -> "TYPEATTR":
         """Return the TYPEATTR for this type"""
         return _deref_with_release(
-            self._GetTypeAttr(), self.ReleaseTypeAttr  # type: ignore
+            self._GetTypeAttr(),  # type: ignore
+            self.ReleaseTypeAttr,
         )
 
     def GetDocumentation(
@@ -358,13 +354,15 @@ class ITypeInfo(IUnknown):
     def GetFuncDesc(self, index: int) -> "FUNCDESC":
         """Return FUNCDESC for index"""
         return _deref_with_release(
-            self._GetFuncDesc(index), self.ReleaseFuncDesc  # type: ignore
+            self._GetFuncDesc(index),  # type: ignore
+            self.ReleaseFuncDesc,
         )
 
     def GetVarDesc(self, index: int) -> "VARDESC":
         """Return VARDESC for index"""
         return _deref_with_release(
-            self._GetVarDesc(index), self.ReleaseVarDesc  # type: ignore
+            self._GetVarDesc(index),  # type: ignore
+            self.ReleaseVarDesc,
         )
 
     def GetNames(self, memid: int, count: int = 1) -> List[str]:
@@ -481,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_ = [
@@ -1125,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
 
 
@@ -1175,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.7 → 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.7 → comtypes-1.4.8/comtypes.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: comtypes
-Version: 1.4.7
+Version: 1.4.8
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases
@@ -20,8 +20,9 @@ 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)
 
 
@@ -30,6 +31,7 @@ License-File: LICENSE.txt
 `comtypes` allows you to define, call, and implement custom and dispatch-based COM interfaces in pure Python.
 
 `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.

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"]