comtypes 1.4.9__zip → 1.4.11__zip

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

@@ -1,32 +1,59 @@
 import ctypes
-from typing import Any, Literal, NamedTuple
-from typing import Dict, List, Tuple, Type
-from typing import Optional, Union as _UnionT
-from typing import Callable, Iterator
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Literal,
+    NamedTuple,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+)
+from typing import Union as _UnionT
 
-from comtypes import _CData
 import comtypes
 
+if TYPE_CHECKING:
+    from _ctypes import _PyCSimpleType
+    from ctypes import _CArgObject, _CDataType
 
-_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]
+    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])
 
 
@@ -35,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
 
@@ -75,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:
@@ -94,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:
@@ -189,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`.
 
@@ -209,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.
@@ -223,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
@@ -241,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
@@ -313,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]] = {}
@@ -464,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
 
@@ -502,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)
@@ -521,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
@@ -548,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)
@@ -556,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.9 → comtypes-1.4.11}/comtypes/_meta.py

@@ -1,5 +1,6 @@
 # comtypes._meta helper module
 from ctypes import POINTER, c_void_p, cast
+
 import comtypes
 
 ################################################################
@@ -60,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.9 → comtypes-1.4.11}/comtypes/_post_coinit/_cominterface_meta_patcher.py

@@ -2,8 +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)
 
@@ -97,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
@@ -116,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

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/_post_coinit/bstr.py

@@ -1,10 +1,15 @@
-from ctypes import _SimpleCData, windll
-from typing import Any, Callable, TYPE_CHECKING
+from ctypes import WinDLL, _SimpleCData
+from typing import TYPE_CHECKING, Any, Callable
 
 if TYPE_CHECKING:
     from comtypes import hints  # type: ignore
 
 
+_oleaut32 = WinDLL("oleaut32")
+
+_SysFreeString = _oleaut32.SysFreeString
+
+
 class BSTR(_SimpleCData):
     """The windows BSTR data type"""
 
@@ -18,9 +23,7 @@ class BSTR(_SimpleCData):
         self._needsfree = True
         return self.value
 
-    def __del__(
-        self, _free: Callable[["BSTR"], Any] = windll.oleaut32.SysFreeString
-    ) -> None:
+    def __del__(self, _free: Callable[["BSTR"], Any] = _SysFreeString) -> None:
         # Free the string if self owns the memory
         # or if instructed by __ctypes_from_outparam__.
         if self._b_base_ is None or self._needsfree:
@@ -35,3 +38,7 @@ class BSTR(_SimpleCData):
         # right thing, it doesn't ensure that SysFreeString is called
         # on destruction.
         return cls(value)
+
+
+_SysFreeString.argtypes = [BSTR]
+_SysFreeString.restype = None

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/_post_coinit/instancemethod.py

@@ -1,5 +1,4 @@
-from ctypes import pythonapi, py_object
-
+from ctypes import py_object, pythonapi
 
 pythonapi.PyInstanceMethod_New.argtypes = [py_object]
 pythonapi.PyInstanceMethod_New.restype = py_object

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/_post_coinit/misc.py

@@ -1,26 +1,28 @@
-from ctypes import c_ulong, c_ushort, c_void_p, c_wchar_p, HRESULT, Structure
-from ctypes import byref, cast, _Pointer, POINTER, pointer
-
-# fmt: off
-from typing import (  # noqa
-    Any, overload, TYPE_CHECKING, TypeVar,
-    # instead of `builtins`. see PEP585
-    Type,
-    # instead of `collections.abc`. see PEP585
-    Callable,
-    # instead of `A | B` and `None | A`. see PEP604
-    Optional,
+from ctypes import (
+    HRESULT,
+    POINTER,
+    OleDLL,
+    Structure,
+    byref,
+    c_ulong,
+    c_ushort,
+    c_void_p,
+    c_wchar_p,
+    cast,
+    pointer,
 )
-# fmt: on
-if TYPE_CHECKING:
-    from comtypes import hints as hints  # noqa  # type: ignore
+from ctypes.wintypes import DWORD, LPCWSTR, LPVOID
+from typing import TYPE_CHECKING, Any, Callable, Optional, Type, TypeVar, overload
 
-from comtypes import GUID
-from comtypes import CLSCTX_SERVER, CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER
-from comtypes import _ole32, oledll, DWORD
+from comtypes import CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER, CLSCTX_SERVER, GUID
 from comtypes._memberspec import COMMETHOD
 from comtypes._post_coinit.unknwn import IUnknown
 
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+
+    from comtypes import hints as hints  # noqa  # type: ignore
+
 
 def _is_object(obj):
     """This function determines if the argument is a COM object.  It
@@ -98,7 +100,7 @@ def CoGetObject(displayname: str, interface: Optional[Type[IUnknown]]) -> IUnkno
         interface = IUnknown
     punk = POINTER(interface)()
     # Do we need a way to specify the BIND_OPTS parameter?
-    _ole32.CoGetObject(str(displayname), None, byref(interface._iid_), byref(punk))
+    _CoGetObject(str(displayname), None, byref(interface._iid_), byref(punk))
     return punk  # type: ignore
 
 
@@ -134,7 +136,7 @@ def CoCreateInstance(
         interface = IUnknown
     p = POINTER(interface)()
     iid = interface._iid_
-    _ole32.CoCreateInstance(byref(clsid), punkouter, clsctx, byref(iid), byref(p))
+    _CoCreateInstance(byref(clsid), punkouter, clsctx, byref(iid), byref(p))
     return p  # type: ignore
 
 
@@ -178,7 +180,7 @@ def GetActiveObject(
 ) -> IUnknown:
     """Retrieves a pointer to a running object"""
     p = POINTER(IUnknown)()
-    oledll.oleaut32.GetActiveObject(byref(clsid), None, byref(p))
+    _GetActiveObject(byref(clsid), None, byref(p))
     if interface is not None:
         p = p.QueryInterface(interface)  # type: ignore
     return p  # type: ignore
@@ -236,6 +238,16 @@ class _COSERVERINFO(Structure):
         dwReserved2: int
 
 
+_oleaut32 = OleDLL("oleaut32")
+
+REFCLSID = POINTER(GUID)
+_GetActiveObject = _oleaut32.GetActiveObject
+_GetActiveObject.argtypes = [REFCLSID, LPVOID, POINTER(POINTER(IUnknown))]
+_GetActiveObject.restype = HRESULT
+
+
+_ole32 = OleDLL("ole32")
+
 COSERVERINFO = _COSERVERINFO
 _CoGetClassObject = _ole32.CoGetClassObject
 _CoGetClassObject.argtypes = [
@@ -245,6 +257,28 @@ _CoGetClassObject.argtypes = [
     POINTER(GUID),
     POINTER(c_void_p),
 ]
+_CoGetClassObject.restype = HRESULT
+
+_CoCreateInstance = _ole32.CoCreateInstance
+_CoCreateInstance.argtypes = [
+    REFCLSID,
+    POINTER(IUnknown),
+    DWORD,
+    POINTER(GUID),
+    POINTER(LPVOID),
+]
+_CoCreateInstance.restype = HRESULT
+
+_CoCreateInstanceEx = _ole32.CoCreateInstanceEx
+_CoCreateInstanceEx.argtypes = [
+    REFCLSID,
+    POINTER(IUnknown),
+    DWORD,
+    POINTER(COSERVERINFO),
+    DWORD,
+    POINTER(MULTI_QI),
+]
+_CoCreateInstanceEx.restype = HRESULT
 
 
 class tagBIND_OPTS(Structure):
@@ -258,6 +292,9 @@ class tagBIND_OPTS(Structure):
 
 # XXX Add __init__ which sets cbStruct?
 BIND_OPTS = tagBIND_OPTS
+_CoGetObject = _ole32.CoGetObject
+_CoGetObject.argtypes = [LPCWSTR, POINTER(BIND_OPTS), POINTER(GUID), POINTER(LPVOID)]
+_CoGetObject.restype = HRESULT
 
 
 class tagBIND_OPTS2(Structure):
@@ -360,7 +397,5 @@ def CoCreateInstanceEx(
         interface = IUnknown
     multiqi = MULTI_QI()
     multiqi.pIID = pointer(interface._iid_)  # type: ignore
-    _ole32.CoCreateInstanceEx(
-        byref(clsid), None, clsctx, pServerInfo, 1, byref(multiqi)
-    )
+    _CoCreateInstanceEx(byref(clsid), None, clsctx, pServerInfo, 1, byref(multiqi))
     return cast(multiqi.pItf, POINTER(interface))  # type: ignore