comtypes 1.4.10__zip → 1.4.11__zip

{comtypes-1.4.10 → comtypes-1.4.11}/CHANGES.txt

@@ -1,6 +1,28 @@
 Comtypes CHANGELOG
 ==================
 
+Release 1.4.11
+--------------
+* Improve ``PARAMFLAG_...`` and ``DISPATCH_...`` constants definitions and imports. By @junkmd.
+* Introduce the ``_CDataType`` alias from typeshed. By @junkmd.
+* Replace ``260`` literals/constant definitions with imports from ``ctypes.wintypes.MAX_PATH``. By @junkmd.
+* Replace ``client._code_cache._get_module_filename`` with ``typeinfo.GetModuleFileName``. By @junkmd.
+* Improve ``client._code_cache.SHGetSpecialFolderPath`` definition. By @junkmd.
+* Add type annotations to many modules. By @junkmd.
+* Add constants to many modules. By @junkmd.
+* Improve import block styles to many modules. By @junkmd.
+* Add ``SupportErrorInfoTest`` to ``test_comserver``. By @junkmd.
+* Add ``test_errorinfo``. By @junkmd.
+* Improve the type safety of ``errorinfo.ReportException``. By @junkmd.
+* Change the method of retrieving the values of each field in ``_...MemberSpec`` from unpacking to dot access. By @junkmd.
+* Split ``server.connectionpoints.ConnectionPointImpl._call_sinks``. By @junkmd.
+* Refactor ``create_vtbl_mapping``, ``create_dispimpl`` and ``_encode_idl``. By @junkmd.
+* Add ``test_hresult``. By @junkmd.
+* Add ``Test_Vtbl`` to ``test_comobject.py``. By @junkmd.
+* Delint ``IUnknown_AddRef`` and ``IUnknown_Release``. By @junkmd.
+* Convert ``assertRaises`` usage to context manager for improved readability. By @junkmd.
+* Remove the unused ``PATH`` variable from ``client/_generate.py``. By @moi15moi.
+
 Release 1.4.10
 --------------
 * Replace ``GetModuleFileNameA`` with ``GetModuleFileNameW`` to prevent a ``TypeError``. By @junkmd.

{comtypes-1.4.10/comtypes.egg-info → comtypes-1.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: comtypes
-Version: 1.4.10
+Version: 1.4.11
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases
@@ -17,6 +17,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Dynamic: download-url
+Dynamic: license-file
 
 # comtypes
 

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/__init__.py

@@ -1,5 +1,5 @@
 # comtypes version numbers follow semver (http://semver.org/) and PEP 440
-__version__ = "1.4.10"
+__version__ = "1.4.11"
 
 try:
     from _ctypes import COMError  # noqa
@@ -26,7 +26,7 @@ import sys
 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
+from typing import TYPE_CHECKING, Dict, Type
 
 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 = {}
+com_interface_registry: Dict[str, Type["IUnknown"]] = {}
 
 # allows to find coclasses by guid strings (clsid)
-com_coclass_registry = {}
+com_coclass_registry: Dict[str, Type["CoClass"]] = {}
 
 
 ################################################################

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/_comobject.py

@@ -5,7 +5,6 @@ from ctypes import (
     POINTER,
     FormatError,
     OleDLL,
-    Structure,
     WinDLL,
     byref,
     c_long,
@@ -29,11 +28,21 @@ from typing import (
 )
 from typing import Union as _UnionT
 
+import comtypes
 from comtypes import GUID, IPersist, IUnknown, _CoUninitialize, hresult
+from comtypes._memberspec import DISPATCH_METHOD as DISPATCH_METHOD
+from comtypes._memberspec import DISPATCH_PROPERTYGET as DISPATCH_PROPERTYGET
+from comtypes._memberspec import DISPATCH_PROPERTYPUT as DISPATCH_PROPERTYPUT
+from comtypes._memberspec import DISPATCH_PROPERTYPUTREF as DISPATCH_PROPERTYPUTREF
 from comtypes._vtbl import _MethodFinder, create_dispimpl, create_vtbl_mapping
 from comtypes.automation import DISPID, DISPPARAMS, EXCEPINFO, VARIANT
 from comtypes.errorinfo import ISupportErrorInfo
-from comtypes.typeinfo import IProvideClassInfo, IProvideClassInfo2, ITypeInfo
+from comtypes.typeinfo import (
+    GUIDKIND_DEFAULT_SOURCE_DISP_IID,
+    IProvideClassInfo,
+    IProvideClassInfo2,
+    ITypeInfo,
+)
 
 if TYPE_CHECKING:
     from ctypes import _CArgObject, _Pointer
@@ -46,11 +55,6 @@ _debug = logger.debug
 ################################################################
 # COM object implementation
 
-# so we don't have to import comtypes.automation
-DISPATCH_METHOD = 1
-DISPATCH_PROPERTYGET = 2
-DISPATCH_PROPERTYPUT = 4
-DISPATCH_PROPERTYPUTREF = 8
 
 ################################################################
 
@@ -210,18 +214,18 @@ class COMObject(object):
     _reg_clsid_: ClassVar[GUID]
     _reg_typelib_: ClassVar[Tuple[str, int, int]]
     __typelib: "hints.ITypeLib"
-    _com_pointers_: Dict[GUID, "_Pointer[_Pointer[Structure]]"]
-    _dispimpl_: Dict[Tuple[int, int], Callable[..., Any]]
+    _com_pointers_: Dict[GUID, "hints.LP_LP_Vtbl"]
+    _dispimpl_: Dict[Tuple[comtypes.dispid, int], Callable[..., Any]]
 
-    def __new__(cls, *args, **kw):
+    def __new__(cls, *args: Any, **kw: Any) -> "hints.Self":
         self = super(COMObject, cls).__new__(cls)
         if isinstance(self, c_void_p):
             # We build the VTables only for direct instances of
             # CoClass, not for POINTERs to CoClass.
-            return self
+            return self  # type: ignore
         if hasattr(self, "_com_interfaces_"):
             self.__prepare_comobject()
-        return self
+        return self  # type: ignore
 
     def __prepare_comobject(self) -> None:
         # When a CoClass instance is created, COM pointers to all
@@ -326,10 +330,10 @@ class COMObject(object):
     def IUnknown_AddRef(
         self,
         this: Any,
-        __InterlockedIncrement: Callable[[c_long], int] = _InterlockedIncrement,
+        _increment: Callable[[c_long], int] = _InterlockedIncrement,
         _debug=_debug,
     ) -> int:
-        result = __InterlockedIncrement(self._refcnt)
+        result = _increment(self._refcnt)
         if result == 1:
             self.__keep__(self)
         _debug("%r.AddRef() -> %s", self, result)
@@ -343,14 +347,14 @@ class COMObject(object):
     def IUnknown_Release(
         self,
         this: Any,
-        __InterlockedDecrement: Callable[[c_long], int] = _InterlockedDecrement,
+        _decrement: Callable[[c_long], int] = _InterlockedDecrement,
         _debug=_debug,
     ) -> int:
         # If this is called at COM shutdown, _InterlockedDecrement()
         # must still be available, although module level variables may
         # have been deleted already - so we supply it as default
         # argument.
-        result = __InterlockedDecrement(self._refcnt)
+        result = _decrement(self._refcnt)
         _debug("%r.Release() -> %s", self, result)
         if result == 0:
             self._final_release_()
@@ -417,8 +421,7 @@ class COMObject(object):
     # IProvideClassInfo2::GetGUID implementation
 
     def IProvideClassInfo2_GetGUID(self, dwGuidKind: int) -> GUID:
-        # GUIDKIND_DEFAULT_SOURCE_DISP_IID = 1
-        if dwGuidKind != 1:
+        if dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID:
             raise WindowsError(hresult.E_INVALIDARG)
         return self._outgoing_interfaces_[0]._iid_
 
@@ -516,10 +519,7 @@ class COMObject(object):
         #
         params = pDispParams[0]
 
-        if wFlags & (4 | 8):
-            # DISPATCH_PROPERTYPUT
-            # DISPATCH_PROPERTYPUTREF
-            #
+        if wFlags & (DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF):
             # How are the parameters unpacked for propertyput
             # operations with additional parameters?  Can propput
             # have additional args?
@@ -530,9 +530,7 @@ class COMObject(object):
             # DISPATCH_PROPERTYPUTREF is specified.
             return mth(this, *args)
 
-        else:
-            # DISPATCH_METHOD
-            # DISPATCH_PROPERTYGET
+        else:  # wFlags & (DISPATCH_METHOD | DISPATCH_PROPERTYGET)
             # the positions of named arguments
             #
             # 2to3 has problems to translate 'range(...)[::-1]'

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/_memberspec.py

@@ -1,5 +1,6 @@
 import ctypes
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
@@ -8,33 +9,51 @@ from typing import (
     Literal,
     NamedTuple,
     Optional,
+    Sequence,
     Tuple,
     Type,
 )
 from typing import Union as _UnionT
 
 import comtypes
-from comtypes import _CData
 
-_PositionalParamFlagType = Tuple[int, Optional[str]]
-_OptionalParamFlagType = Tuple[int, Optional[str], Any]
-_ParamFlagType = _UnionT[_PositionalParamFlagType, _OptionalParamFlagType]
-_PositionalArgSpecElmType = Tuple[List[str], Type[_CData], str]
-_OptionalArgSpecElmType = Tuple[List[str], Type[_CData], str, Any]
-_ArgSpecElmType = _UnionT[_PositionalArgSpecElmType, _OptionalArgSpecElmType]
+if TYPE_CHECKING:
+    from _ctypes import _PyCSimpleType
+    from ctypes import _CArgObject, _CDataType
 
+    from comtypes import hints  # type: ignore
+else:
+    _PyCSimpleType = type(ctypes.c_int)
+    _CArgObject = type(ctypes.byref(ctypes.c_int()))
+
+
+DISPATCH_METHOD = 1
+DISPATCH_PROPERTYGET = 2
+DISPATCH_PROPERTYPUT = 4
+DISPATCH_PROPERTYPUTREF = 8
+
+PARAMFLAG_NONE = 0
+PARAMFLAG_FIN = 1
+PARAMFLAG_FOUT = 2
+PARAMFLAG_FLCID = 4
+PARAMFLAG_FRETVAL = 8
+PARAMFLAG_FOPT = 16
+PARAMFLAG_FHASDEFAULT = 32
+PARAMFLAG_FHASCUSTDATA = 64
 
 _PARAMFLAGS = {
-    "in": 1,
-    "out": 2,
-    "lcid": 4,
-    "retval": 8,
-    "optional": 16,
+    "in": PARAMFLAG_FIN,
+    "out": PARAMFLAG_FOUT,
+    "lcid": PARAMFLAG_FLCID,
+    "retval": PARAMFLAG_FRETVAL,
+    "optional": PARAMFLAG_FOPT,
 }
 
 
-def _encode_idl(names):
-    # sum up all values found in _PARAMFLAGS, ignoring all others.
+def _encode_idl(names: Sequence[str]) -> int:
+    """Sums up 'in', 'out', 'lcid', 'retval' and 'optional' values
+    found in _PARAMFLAGS, ignoring all other PARAMFLAG_... stuff.
+    """
     return sum([_PARAMFLAGS.get(n, 0) for n in names])
 
 
@@ -43,20 +62,20 @@ _NOTHING = object()
 
 def _unpack_argspec(
     idl: List[str],
-    typ: Type[_CData],
+    typ: Type["_CDataType"],
     name: Optional[str] = None,
     defval: Any = _NOTHING,
-) -> Tuple[List[str], Type[_CData], Optional[str], Any]:
+) -> Tuple[List[str], Type["_CDataType"], Optional[str], Any]:
     return idl, typ, name, defval
 
 
 def _resolve_argspec(
-    items: Tuple[_ArgSpecElmType, ...],
-) -> Tuple[Tuple[_ParamFlagType, ...], Tuple[Type[_CData], ...]]:
+    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])`.
-    - argtypes is a sequence of `type[_CData]`.
+    - argtypes is a sequence of `type[_CDataType]`.
     """
     from comtypes.automation import VARIANT
 
@@ -83,14 +102,23 @@ def _resolve_argspec(
     return tuple(paramflags), tuple(argtypes)
 
 
+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]]
+    _DispIdlFlags = _UnionT[_VarFlagsWithDispIdHelpstr, _VarFlagsWithDispId]
+    _ComIdlFlags = _UnionT[_VarFlags, _VarFlagsWithHelpstr]
+
+
 class _ComMemberSpec(NamedTuple):
     """Specifier for a slot of COM method or property."""
 
-    restype: Optional[Type[_CData]]
+    restype: Optional[Type["_CDataType"]]
     name: str
-    argtypes: Tuple[Type[_CData], ...]
-    paramflags: Optional[Tuple[_ParamFlagType, ...]]
-    idlflags: Tuple[_UnionT[str, int], ...]
+    argtypes: Tuple[Type["_CDataType"], ...]
+    paramflags: Optional[Tuple["hints.ParamFlagType", ...]]
+    idlflags: _UnionT["_ComIdlFlags", "_DispIdlFlags"]
     doc: Optional[str]
 
     def is_prop(self) -> bool:
@@ -102,9 +130,9 @@ class _DispMemberSpec(NamedTuple):
 
     what: Literal["DISPMETHOD", "DISPPROPERTY"]
     name: str
-    idlflags: Tuple[_UnionT[str, int], ...]
-    restype: Optional[Type[_CData]]
-    argspec: Tuple[_ArgSpecElmType, ...]
+    idlflags: "_DispIdlFlags"
+    restype: Optional[Type["_CDataType"]]
+    argspec: Tuple["hints.ArgSpecElmType", ...]
 
     @property
     def memid(self) -> int:
@@ -197,15 +225,32 @@ def COMMETHOD(idlflags, restype, methodname, *argspec) -> _ComMemberSpec:
 
 
 ################################################################
-
-_PropFunc = Optional[Callable[..., Any]]
-_DocType = Optional[str]
+# workarounds for ctypes functions and parameters
+
+
+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:
+        # Array of or pointer to type `atyp` was passed,
+        # pointer to `atyp` expected.
+        v = value
+    elif type(atyp) is _PyCSimpleType:  # type: ignore
+        # The `from_param` method of simple types
+        # (`c_int`, `c_double`, ...) returns a `byref` object which
+        # we cannot use since later it will be wrapped in a pointer.
+        # Simply call the constructor with the argument in that case.
+        v = atyp(value)
+    else:
+        v = atyp.from_param(value)
+        assert not isinstance(v, _CArgObject)  # type: ignore
+    return v
 
 
 def _fix_inout_args(
     func: Callable[..., Any],
-    argtypes: Tuple[Type[_CData], ...],
-    paramflags: Tuple[_ParamFlagType, ...],
+    argtypes: Tuple[Type["_CDataType"], ...],
+    paramflags: Tuple["hints.ParamFlagType", ...],
 ) -> Callable[..., Any]:
     """This function provides a workaround for a bug in `ctypes`.
 
@@ -217,13 +262,11 @@ def _fix_inout_args(
     #
     # TODO: The workaround should be disabled when a ctypes
     # version is used where the bug is fixed.
-    SIMPLETYPE = type(ctypes.c_int)
-    BYREFTYPE = type(ctypes.byref(ctypes.c_int()))
 
     def call_with_inout(self, *args, **kw):
         args = list(args)
         # Indexed by order in the output
-        outargs: Dict[int, _UnionT[_CData, "ctypes._CArgObject"]] = {}
+        outargs: Dict[int, "_CDataType"] = {}
         outnum = 0
         param_index = 0
         # Go through all expected arguments and match them to the provided arguments.
@@ -231,8 +274,8 @@ def _fix_inout_args(
         # through the keyword arguments.
         for i, info in enumerate(paramflags):
             direction = info[0]
-            dir_in = direction & 1 == 1
-            dir_out = direction & 2 == 2
+            dir_in = bool(direction & PARAMFLAG_FIN)
+            dir_out = bool(direction & PARAMFLAG_FOUT)
             is_positional = param_index < len(args)
             if not (dir_in or dir_out):
                 # The original code here did not check for this special case and
@@ -249,34 +292,16 @@ def _fix_inout_args(
                 name = info[1]
                 # [in, out] parameters are passed as pointers,
                 # this is the pointed-to type:
-                atyp: Type[_CData] = getattr(argtypes[i], "_type_")
+                atyp: Type["_CDataType"] = getattr(argtypes[i], "_type_")
 
                 # Get the actual parameter, either as positional or
                 # keyword arg.
 
-                def prepare_parameter(v):
-                    # parameter was passed, call `from_param()` to
-                    # convert it to a `ctypes` type.
-                    if getattr(v, "_type_", None) is atyp:
-                        # Array of or pointer to type `atyp` was passed,
-                        # pointer to `atyp` expected.
-                        pass
-                    elif type(atyp) is SIMPLETYPE:
-                        # The `from_param` method of simple types
-                        # (`c_int`, `c_double`, ...) returns a `byref` object which
-                        # we cannot use since later it will be wrapped in a pointer.
-                        # Simply call the constructor with the argument in that case.
-                        v = atyp(v)
-                    else:
-                        v = atyp.from_param(v)
-                        assert not isinstance(v, BYREFTYPE)
-                    return v
-
                 if is_positional:
-                    v = prepare_parameter(args[param_index])
+                    v = _prepare_parameter(args[param_index], atyp)
                     args[param_index] = v
                 elif name in kw:
-                    v = prepare_parameter(kw[name])
+                    v = _prepare_parameter(kw[name], atyp)
                     kw[name] = v
                 else:
                     # no parameter was passed, make an empty one of the required type
@@ -321,6 +346,13 @@ def _fix_inout_args(
     return call_with_inout
 
 
+################################################################
+
+
+_PropFunc = Optional[Callable[..., Any]]
+_DocType = Optional[str]
+
+
 class PropertyMapping(object):
     def __init__(self):
         self._data: Dict[Tuple[str, _DocType, int], List[_PropFunc]] = {}
@@ -472,8 +504,8 @@ class ComMemberGenerator(object):
     ) -> Callable[..., Any]:
         """This is a workaround. See `_fix_inout_args` docstring and comments."""
         if m.paramflags:
-            dirflags = [(p[0] & 3) for p in m.paramflags]
-            if 3 in dirflags:
+            dirflags = [(p[0] & (PARAMFLAG_FIN | PARAMFLAG_FOUT)) for p in m.paramflags]
+            if (PARAMFLAG_FIN | PARAMFLAG_FOUT) in dirflags:
                 return _fix_inout_args(func, m.argtypes, m.paramflags)
         return func
 
@@ -510,15 +542,15 @@ class DispMemberGenerator(object):
         memid = m.memid
 
         def fget(obj):
-            return obj.Invoke(memid, _invkind=2)  # DISPATCH_PROPERTYGET
+            return obj.Invoke(memid, _invkind=DISPATCH_PROPERTYGET)
 
         if "readonly" in m.idlflags:
             return property(fget)
 
         def fset(obj, value):
-            # Detect whether to use DISPATCH_PROPERTYPUT or
-            # DISPATCH_PROPERTYPUTREF
-            invkind = 8 if comtypes._is_object(value) else 4
+            # Detect whether to use PUT or PUTREF
+            is_ref = comtypes._is_object(value)
+            invkind = DISPATCH_PROPERTYPUTREF if is_ref else DISPATCH_PROPERTYPUT
             return obj.Invoke(memid, value, _invkind=invkind)
 
         return property(fget, fset)
@@ -529,25 +561,19 @@ class DispMemberGenerator(object):
         if "propget" in m.idlflags:
 
             def getfunc(obj, *args, **kw):
-                return obj.Invoke(
-                    memid, _invkind=2, *args, **kw
-                )  # DISPATCH_PROPERTYGET
+                return obj.Invoke(memid, _invkind=DISPATCH_PROPERTYGET, *args, **kw)
 
             return getfunc
         elif "propput" in m.idlflags:
 
             def putfunc(obj, *args, **kw):
-                return obj.Invoke(
-                    memid, _invkind=4, *args, **kw
-                )  # DISPATCH_PROPERTYPUT
+                return obj.Invoke(memid, _invkind=DISPATCH_PROPERTYPUT, *args, **kw)
 
             return putfunc
         elif "propputref" in m.idlflags:
 
             def putreffunc(obj, *args, **kw):
-                return obj.Invoke(
-                    memid, _invkind=8, *args, **kw
-                )  # DISPATCH_PROPERTYPUTREF
+                return obj.Invoke(memid, _invkind=DISPATCH_PROPERTYPUTREF, *args, **kw)
 
             return putreffunc
         # a first attempt to make use of the restype.  Still, support for
@@ -556,7 +582,7 @@ class DispMemberGenerator(object):
             interface = m.restype.__com_interface__  # type: ignore
 
             def comitffunc(obj, *args, **kw):
-                result = obj.Invoke(memid, _invkind=1, *args, **kw)
+                result = obj.Invoke(memid, _invkind=DISPATCH_METHOD, *args, **kw)
                 if result is None:
                     return
                 return result.QueryInterface(interface)
@@ -564,7 +590,7 @@ class DispMemberGenerator(object):
             return comitffunc
 
         def func(obj, *args, **kw):
-            return obj.Invoke(memid, _invkind=1, *args, **kw)  # DISPATCH_METHOD
+            return obj.Invoke(memid, _invkind=DISPATCH_METHOD, *args, **kw)
 
         return func
 

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/_meta.py

@@ -61,7 +61,7 @@ class _coclass_meta(type):
         # 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)] = self
+            comtypes.com_coclass_registry[str(clsid)] = self  # type: ignore
 
         # `_coclass_pointer_meta` is a subclass inherited from `_coclass_meta`.
         # In other words, when the `__new__` method of this metaclass is called, an

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/_post_coinit/_cominterface_meta_patcher.py

@@ -2,7 +2,7 @@ import types
 from _ctypes import COMError
 from typing import Type
 
-from comtypes import patcher
+from comtypes import hresult, patcher
 
 _all_slice = slice(None, None, None)
 
@@ -96,8 +96,7 @@ def callable_and_subscriptable(itf: Type) -> None:
             try:
                 result = self.Item(*args)
             except COMError as err:
-                (hresult, text, details) = err.args
-                if hresult == -2147352565:  # DISP_E_BADINDEX
+                if err.hresult == hresult.DISP_E_BADINDEX:
                     raise IndexError("invalid index")
                 else:
                     raise
@@ -115,8 +114,7 @@ def callable_and_subscriptable(itf: Type) -> None:
             try:
                 self.Item[index] = value
             except COMError as err:
-                (hresult, text, details) = err.args
-                if hresult == -2147352565:  # DISP_E_BADINDEX
+                if err.hresult == hresult.DISP_E_BADINDEX:
                     raise IndexError("invalid index")
                 else:
                     raise