Update *.py and _post_coinit/*.py files for PEP585 compliance. (#880)

* Update `comtypes/_post_coinit/_cominterface_meta_patcher.py` for PEP585 compliance.

* Update `comtypes/_post_coinit/activeobj.py` for PEP585 compliance.

* Update `comtypes/_post_coinit/bstr.py` for PEP585 compliance.

* Update `comtypes/_post_coinit/misc.py` for PEP585 compliance.

* Update `comtypes/_post_coinit/unknwn.py` for PEP585 compliance.

* Update `comtypes/__init__.py` for PEP585 compliance.

* Update `comtypes/_comobject.py` for PEP585 compliance.

* Update `comtypes/_memberspec.py` for PEP585 compliance.

* Update `comtypes/_vtbl.py` for PEP585 compliance.

* Update `comtypes/automation.py` for PEP585 compliance.

* Update `comtypes/connectionpoints.py` for PEP585 compliance.

* Update `comtypes/messageloop.py` for PEP585 compliance.

* Update `comtypes/safearray.py` for PEP585 compliance.

* Update `comtypes/shelllink.py` for PEP585 compliance.

* Update `comtypes/stream.py` for PEP585 compliance.

* Update `comtypes/typeinfo.py` for PEP585 compliance.

* Update `comtypes/util.py` for PEP585 compliance.

Author: junkmd

comtypes/__init__.py

@@ -26,7 +26,7 @@
 from ctypes import *  # noqa  # type: ignore
 from ctypes import HRESULT, OleDLL, WinDLL, _SimpleCData, c_int, c_ulong
 from ctypes.wintypes import DWORD, LPVOID
-from typing import TYPE_CHECKING, Dict, Type
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ctypes import _CData  # only in `typeshed`, private in runtime
@@ -172,10 +172,10 @@ def CoUninitialize():
 # global registries.
 
 # allows to find interface classes by guid strings (iid)
-com_interface_registry: Dict[str, Type["IUnknown"]] = {}
+com_interface_registry: dict[str, type["IUnknown"]] = {}
 
 # allows to find coclasses by guid strings (clsid)
-com_coclass_registry: Dict[str, Type["CoClass"]] = {}
+com_coclass_registry: dict[str, type["CoClass"]] = {}
 
 
 ################################################################

comtypes/_comobject.py

@@ -1,6 +1,7 @@
 import logging
 import queue
 from _ctypes import COMError, CopyComPointer
+from collections.abc import Callable, Sequence
 from ctypes import (
     POINTER,
     FormatError,
@@ -13,19 +14,7 @@
     pointer,
 )
 from ctypes.wintypes import INT, LONG, LPVOID, UINT, ULONG, WORD
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    ClassVar,
-    Dict,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TypeVar,
-)
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar
 from typing import Union as _UnionT
 
 import comtypes
@@ -208,14 +197,14 @@ def DllCanUnloadNow(self) -> int:
 
 
 class COMObject:
-    _com_interfaces_: ClassVar[List[Type[IUnknown]]]
-    _outgoing_interfaces_: ClassVar[List[Type["hints.IDispatch"]]]
-    _instances_: ClassVar[Dict["COMObject", None]] = {}
+    _com_interfaces_: ClassVar[list[type[IUnknown]]]
+    _outgoing_interfaces_: ClassVar[list[type["hints.IDispatch"]]]
+    _instances_: ClassVar[dict["COMObject", None]] = {}
     _reg_clsid_: ClassVar[GUID]
-    _reg_typelib_: ClassVar[Tuple[str, int, int]]
+    _reg_typelib_: ClassVar[tuple[str, int, int]]
     __typelib: "hints.ITypeLib"
-    _com_pointers_: Dict[GUID, "hints.LP_LP_Vtbl"]
-    _dispimpl_: Dict[Tuple[comtypes.dispid, int], Callable[..., Any]]
+    _com_pointers_: dict[GUID, "hints.LP_LP_Vtbl"]
+    _dispimpl_: dict[tuple[comtypes.dispid, int], Callable[..., Any]]
 
     def __new__(cls, *args: Any, **kw: Any) -> "hints.Self":
         self = super().__new__(cls)
@@ -268,15 +257,15 @@ def __prepare_comobject(self) -> None:
         for itf in interfaces[::-1]:
             self.__make_interface_pointer(itf)
 
-    def __make_interface_pointer(self, itf: Type[IUnknown]) -> None:
+    def __make_interface_pointer(self, itf: type[IUnknown]) -> None:
         finder = self._get_method_finder_(itf)
         iids, vtbl = create_vtbl_mapping(itf, finder)
         for iid in iids:
             self._com_pointers_[iid] = pointer(pointer(vtbl))
         if hasattr(itf, "_disp_methods_"):
             self._dispimpl_ = create_dispimpl(itf, finder)
 
-    def _get_method_finder_(self, itf: Type[IUnknown]) -> _MethodFinder:
+    def _get_method_finder_(self, itf: type[IUnknown]) -> _MethodFinder:
         # This method can be overridden to customize how methods are found.
         return _MethodFinder(self)
 
@@ -381,7 +370,7 @@ def IUnknown_QueryInterface(
         _debug("%r.QueryInterface(%s) -> E_NOINTERFACE", self, iid)
         return hresult.E_NOINTERFACE
 
-    def QueryInterface(self, interface: Type[_T_IUnknown]) -> _T_IUnknown:
+    def QueryInterface(self, interface: type[_T_IUnknown]) -> _T_IUnknown:
         "Query the object for an interface pointer"
         # This method is NOT the implementation of
         # IUnknown::QueryInterface, instead it is supposed to be

comtypes/_memberspec.py

@@ -1,18 +1,6 @@
 import ctypes
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    Literal,
-    NamedTuple,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-)
+from collections.abc import Callable, Iterator, Sequence
+from typing import TYPE_CHECKING, Any, Literal, NamedTuple, Optional
 from typing import Union as _UnionT
 
 import comtypes
@@ -61,17 +49,17 @@ def _encode_idl(names: Sequence[str]) -> int:
 
 
 def _unpack_argspec(
-    idl: List[str],
-    typ: Type["_CDataType"],
+    idl: list[str],
+    typ: type["_CDataType"],
     name: Optional[str] = None,
     defval: Any = _NOTHING,
-) -> Tuple[List[str], Type["_CDataType"], Optional[str], Any]:
+) -> tuple[list[str], type["_CDataType"], Optional[str], Any]:
     return idl, typ, name, defval
 
 
 def _resolve_argspec(
-    items: Tuple["hints.ArgSpecElmType", ...],
-) -> Tuple[Tuple["hints.ParamFlagType", ...], Tuple[Type["_CDataType"], ...]]:
+    items: tuple["hints.ArgSpecElmType", ...],
+) -> tuple[tuple["hints.ParamFlagType", ...], tuple[type["_CDataType"], ...]]:
     """Unpacks and converts from argspec to paramflags and argtypes.
 
     - paramflags is a sequence of `(pflags: int, argname: str, | None[, defval: Any])`.
@@ -103,21 +91,21 @@ def _resolve_argspec(
 
 
 if TYPE_CHECKING:
-    _VarFlags = Tuple[str, ...]
-    _VarFlagsWithDispIdHelpstr = Tuple["dispid", "helpstring", hints.Unpack[_VarFlags]]
-    _VarFlagsWithDispId = Tuple["dispid", hints.Unpack[_VarFlags]]
-    _VarFlagsWithHelpstr = Tuple["helpstring", hints.Unpack[_VarFlags]]
+    _VarFlags = tuple[str, ...]
+    _VarFlagsWithDispIdHelpstr = tuple["dispid", "helpstring", hints.Unpack[_VarFlags]]
+    _VarFlagsWithDispId = tuple["dispid", hints.Unpack[_VarFlags]]
+    _VarFlagsWithHelpstr = tuple["helpstring", hints.Unpack[_VarFlags]]
     _DispIdlFlags = _UnionT[_VarFlagsWithDispIdHelpstr, _VarFlagsWithDispId]
     _ComIdlFlags = _UnionT[_VarFlags, _VarFlagsWithHelpstr]
 
 
 class _ComMemberSpec(NamedTuple):
     """Specifier for a slot of COM method or property."""
 
-    restype: Optional[Type["_CDataType"]]
+    restype: Optional[type["_CDataType"]]
     name: str
-    argtypes: Tuple[Type["_CDataType"], ...]
-    paramflags: Optional[Tuple["hints.ParamFlagType", ...]]
+    argtypes: tuple[type["_CDataType"], ...]
+    paramflags: Optional[tuple["hints.ParamFlagType", ...]]
     idlflags: _UnionT["_ComIdlFlags", "_DispIdlFlags"]
     doc: Optional[str]
 
@@ -131,8 +119,8 @@ class _DispMemberSpec(NamedTuple):
     what: Literal["DISPMETHOD", "DISPPROPERTY"]
     name: str
     idlflags: "_DispIdlFlags"
-    restype: Optional[Type["_CDataType"]]
-    argspec: Tuple["hints.ArgSpecElmType", ...]
+    restype: Optional[type["_CDataType"]]
+    argspec: tuple["hints.ArgSpecElmType", ...]
 
     @property
     def memid(self) -> int:
@@ -228,7 +216,7 @@ def COMMETHOD(idlflags, restype, methodname, *argspec) -> _ComMemberSpec:
 # workarounds for ctypes functions and parameters
 
 
-def _prepare_parameter(value: Any, atyp: Type["_CDataType"]) -> "_CDataType":
+def _prepare_parameter(value: Any, atyp: type["_CDataType"]) -> "_CDataType":
     # parameter was passed, call `from_param()` to
     # convert it to a `ctypes` type.
     if getattr(value, "_type_", None) is atyp:
@@ -249,8 +237,8 @@ def _prepare_parameter(value: Any, atyp: Type["_CDataType"]) -> "_CDataType":
 
 def _fix_inout_args(
     func: Callable[..., Any],
-    argtypes: Tuple[Type["_CDataType"], ...],
-    paramflags: Tuple["hints.ParamFlagType", ...],
+    argtypes: tuple[type["_CDataType"], ...],
+    paramflags: tuple["hints.ParamFlagType", ...],
 ) -> Callable[..., Any]:
     """This function provides a workaround for a bug in `ctypes`.
 
@@ -266,7 +254,7 @@ def _fix_inout_args(
     def call_with_inout(self, *args, **kw):
         args = list(args)
         # Indexed by order in the output
-        outargs: Dict[int, "_CDataType"] = {}
+        outargs: dict[int, "_CDataType"] = {}
         outnum = 0
         param_index = 0
         # Go through all expected arguments and match them to the provided arguments.
@@ -292,7 +280,7 @@ def call_with_inout(self, *args, **kw):
                 name = info[1]
                 # [in, out] parameters are passed as pointers,
                 # this is the pointed-to type:
-                atyp: Type["_CDataType"] = getattr(argtypes[i], "_type_")
+                atyp: type["_CDataType"] = getattr(argtypes[i], "_type_")
 
                 # Get the actual parameter, either as positional or
                 # keyword arg.
@@ -355,7 +343,7 @@ def call_with_inout(self, *args, **kw):
 
 class PropertyMapping:
     def __init__(self):
-        self._data: Dict[Tuple[str, _DocType, int], List[_PropFunc]] = {}
+        self._data: dict[tuple[str, _DocType, int], list[_PropFunc]] = {}
 
     def add_propget(
         self, name: str, doc: _DocType, nargs: int, func: Callable[..., Any]
@@ -372,7 +360,7 @@ def add_propputref(
     ) -> None:
         self._data.setdefault((name, doc, nargs), [None, None, None])[2] = func
 
-    def __iter__(self) -> Iterator[Tuple[str, _DocType, int, _PropFunc, _PropFunc]]:
+    def __iter__(self) -> Iterator[tuple[str, _DocType, int, _PropFunc, _PropFunc]]:
         for (name, doc, nargs), (fget, propput, propputref) in self._data.items():
             if propput is not None and propputref is not None:
                 # Create a setter method that examines the argument type
@@ -414,7 +402,7 @@ def add(self, m: _MemberSpec, func: Callable[..., Any]) -> None:
 
     # The following code assumes that the docstrings for
     # propget and propput are identical.
-    def __iter__(self) -> Iterator[Tuple[str, _UnionT[property, "named_property"]]]:
+    def __iter__(self) -> Iterator[tuple[str, _UnionT[property, "named_property"]]]:
         for name, doc, nargs, fget, fset in self._mapping:
             if nargs == 0:
                 prop = property(fget, fset, None, doc)
@@ -425,49 +413,49 @@ def __iter__(self) -> Iterator[Tuple[str, _UnionT[property, "named_property"]]]:
                 prop = named_property(f"{self._cls_name}.{name}", fget, fset, doc)
             yield (name, prop)
 
-    def to_propget_keys(self, m: _MemberSpec) -> Tuple[str, _DocType, int]:
+    def to_propget_keys(self, m: _MemberSpec) -> tuple[str, _DocType, int]:
         raise NotImplementedError
 
-    def to_propput_keys(self, m: _MemberSpec) -> Tuple[str, _DocType, int]:
+    def to_propput_keys(self, m: _MemberSpec) -> tuple[str, _DocType, int]:
         raise NotImplementedError
 
-    def to_propputref_keys(self, m: _MemberSpec) -> Tuple[str, _DocType, int]:
+    def to_propputref_keys(self, m: _MemberSpec) -> tuple[str, _DocType, int]:
         raise NotImplementedError
 
 
 class ComPropertyGenerator(PropertyGenerator):
     # XXX Hm.  What, when paramflags is None?
     # Or does have '0' values?
     # Seems we loose then, at least for properties...
-    def to_propget_keys(self, m: _ComMemberSpec) -> Tuple[str, _DocType, int]:
+    def to_propget_keys(self, m: _ComMemberSpec) -> tuple[str, _DocType, int]:
         assert m.name.startswith("_get_")
         assert m.paramflags is not None
         nargs = len([f for f in m.paramflags if f[0] & 7 in (0, 1)])
         # XXX or should we do this?
         # nargs = len([f for f in paramflags if (f[0] & 1) or (f[0] == 0)])
         return m.name[len("_get_") :], m.doc, nargs
 
-    def to_propput_keys(self, m: _ComMemberSpec) -> Tuple[str, _DocType, int]:
+    def to_propput_keys(self, m: _ComMemberSpec) -> tuple[str, _DocType, int]:
         assert m.name.startswith("_set_")
         assert m.paramflags is not None
         nargs = len([f for f in m.paramflags if f[0] & 7 in (0, 1)]) - 1
         return m.name[len("_set_") :], m.doc, nargs
 
-    def to_propputref_keys(self, m: _ComMemberSpec) -> Tuple[str, _DocType, int]:
+    def to_propputref_keys(self, m: _ComMemberSpec) -> tuple[str, _DocType, int]:
         assert m.name.startswith("_setref_")
         assert m.paramflags is not None
         nargs = len([f for f in m.paramflags if f[0] & 7 in (0, 1)]) - 1
         return m.name[len("_setref_") :], m.doc, nargs
 
 
 class DispPropertyGenerator(PropertyGenerator):
-    def to_propget_keys(self, m: _DispMemberSpec) -> Tuple[str, _DocType, int]:
+    def to_propget_keys(self, m: _DispMemberSpec) -> tuple[str, _DocType, int]:
         return m.name, None, len(m.argspec)
 
-    def to_propput_keys(self, m: _DispMemberSpec) -> Tuple[str, _DocType, int]:
+    def to_propput_keys(self, m: _DispMemberSpec) -> tuple[str, _DocType, int]:
         return m.name, None, len(m.argspec) - 1
 
-    def to_propputref_keys(self, m: _DispMemberSpec) -> Tuple[str, _DocType, int]:
+    def to_propputref_keys(self, m: _DispMemberSpec) -> tuple[str, _DocType, int]:
         return m.name, None, len(m.argspec) - 1
 
 
@@ -477,7 +465,7 @@ def __init__(self, cls_name: str, vtbl_offset: int, iid: "comtypes.GUID") -> Non
         self._iid = iid
         self._props = ComPropertyGenerator(cls_name)
         # sequence of (name: str, func: Callable, raw_func: Callable, is_prop: bool)
-        self._mths: List[Tuple[str, Callable[..., Any], Callable[..., Any], bool]] = []
+        self._mths: list[tuple[str, Callable[..., Any], Callable[..., Any], bool]] = []
         self._member_index = 0
 
     def add(self, m: _ComMemberSpec) -> None:
@@ -520,7 +508,7 @@ class DispMemberGenerator:
     def __init__(self, cls_name: str) -> None:
         self._props = DispPropertyGenerator(cls_name)
         # sequence of (name: str, func_or_prop: Callable | property, is_prop: bool)
-        self._items: List[Tuple[str, _UnionT[Callable[..., Any], property], bool]] = []
+        self._items: list[tuple[str, _UnionT[Callable[..., Any], property], bool]] = []
 
     def add(self, m: _DispMemberSpec) -> None:
         if m.what == "DISPPROPERTY":  # DISPPROPERTY

comtypes/_post_coinit/_cominterface_meta_patcher.py

@@ -1,13 +1,12 @@
 import types
 from _ctypes import COMError
-from typing import Type
 
 from comtypes import hresult, patcher
 
 _all_slice = slice(None, None, None)
 
 
-def case_insensitive(p: Type) -> None:
+def case_insensitive(p: type) -> None:
     @patcher.Patch(p)
     class CaseInsensitive:
         # case insensitive attributes for COM methods and properties
@@ -32,7 +31,7 @@ def __setattr__(self, name, value):
             object.__setattr__(self, self.__map_case__.get(name.lower(), name), value)
 
 
-def reference_fix(pp: Type) -> None:
+def reference_fix(pp: type) -> None:
     @patcher.Patch(pp)
     class ReferenceFix:
         def __setitem__(self, index, value):
@@ -62,15 +61,15 @@ def __setitem__(self, index, value):
             CopyComPointer(value, self)  # type: ignore
 
 
-def sized(itf: Type) -> None:
+def sized(itf: type) -> None:
     @patcher.Patch(itf)
     class _:
         def __len__(self):
             "Return the the 'self.Count' property."
             return self.Count
 
 
-def callable_and_subscriptable(itf: Type) -> None:
+def callable_and_subscriptable(itf: type) -> None:
     @patcher.Patch(itf)
     class _:
         # 'Item' is the 'default' value.  Make it available by
@@ -123,7 +122,7 @@ def __setitem__(self, index, value):
                 raise TypeError(msg)
 
 
-def iterator(itf: Type) -> None:
+def iterator(itf: type) -> None:
     @patcher.Patch(itf)
     class _:
         def __iter__(self):

comtypes/_post_coinit/activeobj.py

@@ -1,6 +1,6 @@
 from ctypes import HRESULT, POINTER, OleDLL, byref, c_ulong, c_void_p
 from ctypes.wintypes import DWORD, LPVOID
-from typing import TYPE_CHECKING, Optional, Type, TypeVar, overload
+from typing import TYPE_CHECKING, Optional, TypeVar, overload
 from typing import Union as _UnionT
 
 from comtypes import GUID
@@ -34,9 +34,9 @@ def RevokeActiveObject(handle: int) -> None:
 @overload
 def GetActiveObject(clsid: GUID, interface: None = None) -> IUnknown: ...
 @overload
-def GetActiveObject(clsid: GUID, interface: Type[_T_IUnknown]) -> _T_IUnknown: ...
+def GetActiveObject(clsid: GUID, interface: type[_T_IUnknown]) -> _T_IUnknown: ...
 def GetActiveObject(
-    clsid: GUID, interface: Optional[Type[IUnknown]] = None
+    clsid: GUID, interface: Optional[type[IUnknown]] = None
 ) -> IUnknown:
     """Retrieves a pointer to a running object"""
     p = POINTER(IUnknown)()