comtypes 1.4.10__zip → 1.4.12__zip

{comtypes-1.4.10 → comtypes-1.4.12}/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:
@@ -134,7 +162,7 @@ class helpstring(str):
     "Specifies the helpstring for a COM method or property."
 
 
-class defaultvalue(object):
+class defaultvalue:
     "Specifies the default value for parameters marked optional."
 
     def __init__(self, value):
@@ -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,7 +346,14 @@ def _fix_inout_args(
     return call_with_inout
 
 
-class PropertyMapping(object):
+################################################################
+
+
+_PropFunc = Optional[Callable[..., Any]]
+_DocType = Optional[str]
+
+
+class PropertyMapping:
     def __init__(self):
         self._data: Dict[Tuple[str, _DocType, int], List[_PropFunc]] = {}
 
@@ -361,7 +393,7 @@ class PropertyMapping(object):
             yield (name, doc, nargs, fget, fset)
 
 
-class PropertyGenerator(object):
+class PropertyGenerator:
     def __init__(self, cls_name: str) -> None:
         self._mapping = PropertyMapping()
         self._cls_name = cls_name
@@ -439,7 +471,7 @@ class DispPropertyGenerator(PropertyGenerator):
         return m.name, None, len(m.argspec) - 1
 
 
-class ComMemberGenerator(object):
+class ComMemberGenerator:
     def __init__(self, cls_name: str, vtbl_offset: int, iid: "comtypes.GUID") -> None:
         self._vtbl_offset = vtbl_offset
         self._iid = iid
@@ -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
 
@@ -484,7 +516,7 @@ class ComMemberGenerator(object):
         return iter(self._props)
 
 
-class DispMemberGenerator(object):
+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)
@@ -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
 
@@ -580,7 +606,7 @@ class DispMemberGenerator(object):
 # Should they be implemented in C for speed?
 
 
-class bound_named_property(object):
+class bound_named_property:
     def __init__(self, name, fget, fset, instance):
         self.name = name
         self.instance = instance
@@ -621,7 +647,7 @@ class bound_named_property(object):
         raise TypeError(msg)
 
 
-class named_property(object):
+class named_property:
     def __init__(self, name, fget=None, fset=None, doc=None):
         self.name = name
         self.fget = fget

{comtypes-1.4.10 → comtypes-1.4.12}/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.12}/comtypes/_npsupport.py

@@ -92,27 +92,21 @@ class Interop:
 
         return self.numpy.dtype(tagVARIANT_format)
 
-    def _check_ctypeslib_typecodes(self):
+    def _build_typecodes(self):
         if not self.enabled:
             return {}
         import numpy as np
-        from numpy import ctypeslib
+        from numpy.ctypeslib import as_ctypes_type
 
-        try:
-            from numpy.ctypeslib import _typecodes
-        except ImportError:
-            from numpy.ctypeslib import as_ctypes_type
+        dtypes_to_ctypes = {}
 
-            dtypes_to_ctypes = {}
-
-            for tp in set(np.sctypeDict.values()):
-                try:
-                    ctype_for = as_ctypes_type(tp)
-                    dtypes_to_ctypes[np.dtype(tp).str] = ctype_for
-                except NotImplementedError:
-                    continue
-            ctypeslib._typecodes = dtypes_to_ctypes
-        return ctypeslib._typecodes
+        for tp in set(np.sctypeDict.values()):
+            try:
+                ctype_for = as_ctypes_type(tp)
+                dtypes_to_ctypes[np.dtype(tp).str] = ctype_for
+            except NotImplementedError:
+                continue
+        return dtypes_to_ctypes
 
     def isndarray(self, value):
         """Check if a value is an ndarray.
@@ -168,7 +162,8 @@ class Interop:
         # if that succeeded we can be enabled
         self.enabled = True
         self.VARIANT_dtype = self._make_variant_dtype()
-        self.typecodes = self._check_ctypeslib_typecodes()
+        self.typecodes = self._build_typecodes()
+        self.datetime64 = self.numpy.datetime64
         self.com_null_date64 = self.numpy.datetime64("1899-12-30T00:00:00", "ns")
 
 

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

@@ -2,14 +2,14 @@ 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)
 
 
 def case_insensitive(p: Type) -> None:
     @patcher.Patch(p)
-    class CaseInsensitive(object):
+    class CaseInsensitive:
         # case insensitive attributes for COM methods and properties
         def __getattr__(self, name):
             """Implement case insensitive access to methods and properties"""
@@ -34,7 +34,7 @@ def case_insensitive(p: Type) -> None:
 
 def reference_fix(pp: Type) -> None:
     @patcher.Patch(pp)
-    class ReferenceFix(object):
+    class ReferenceFix:
         def __setitem__(self, index, value):
             # We override the __setitem__ method of the
             # POINTER(POINTER(interface)) type, so that the COM
@@ -64,7 +64,7 @@ def reference_fix(pp: Type) -> None:
 
 def sized(itf: Type) -> None:
     @patcher.Patch(itf)
-    class _(object):
+    class _:
         def __len__(self):
             "Return the the 'self.Count' property."
             return self.Count
@@ -72,7 +72,7 @@ def sized(itf: Type) -> None:
 
 def callable_and_subscriptable(itf: Type) -> None:
     @patcher.Patch(itf)
-    class _(object):
+    class _:
         # 'Item' is the 'default' value.  Make it available by
         # calling the instance (Not sure this makes sense, but
         # win32com does this also).
@@ -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
@@ -127,7 +125,7 @@ def callable_and_subscriptable(itf: Type) -> None:
 
 def iterator(itf: Type) -> None:
     @patcher.Patch(itf)
-    class _(object):
+    class _:
         def __iter__(self):
             "Return an iterator over the _NewEnum collection."
             # This method returns a pointer to _some_ _NewEnum interface.

comtypes-1.4.12/comtypes/_post_coinit/activeobj.py

@@ -0,0 +1,61 @@
+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 Union as _UnionT
+
+from comtypes import GUID
+from comtypes._post_coinit.unknwn import IUnknown
+from comtypes.GUID import REFCLSID
+
+if TYPE_CHECKING:
+    from comtypes import hints  # type: ignore
+
+
+_T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
+
+ACTIVEOBJECT_STRONG = 0x0
+ACTIVEOBJECT_WEAK = 0x1
+
+
+def RegisterActiveObject(
+    punk: "_UnionT[IUnknown, hints.LP_LP_Vtbl]", clsid: GUID, flags: int
+) -> int:
+    """Registers a pointer as the active object for its class and returns the handle."""
+    handle = c_ulong()
+    _RegisterActiveObject(punk, byref(clsid), flags, byref(handle))
+    return handle.value
+
+
+def RevokeActiveObject(handle: int) -> None:
+    """Ends a pointer's status as active."""
+    _RevokeActiveObject(handle, 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: Optional[Type[IUnknown]] = None
+) -> IUnknown:
+    """Retrieves a pointer to a running object"""
+    p = POINTER(IUnknown)()
+    _GetActiveObject(byref(clsid), None, byref(p))
+    if interface is not None:
+        p = p.QueryInterface(interface)  # type: ignore
+    return p  # type: ignore
+
+
+_oleaut32 = OleDLL("oleaut32")
+
+_RegisterActiveObject = _oleaut32.RegisterActiveObject
+_RegisterActiveObject.argtypes = [c_void_p, REFCLSID, DWORD, POINTER(DWORD)]
+_RegisterActiveObject.restype = HRESULT
+
+_RevokeActiveObject = _oleaut32.RevokeActiveObject
+_RevokeActiveObject.argtypes = [DWORD, LPVOID]
+_RevokeActiveObject.restype = HRESULT
+
+_GetActiveObject = _oleaut32.GetActiveObject
+_GetActiveObject.argtypes = [REFCLSID, LPVOID, POINTER(POINTER(IUnknown))]
+_GetActiveObject.restype = HRESULT

{comtypes-1.4.10 → comtypes-1.4.12}/comtypes/_post_coinit/misc.py

@@ -17,6 +17,7 @@ from typing import TYPE_CHECKING, Any, Callable, Optional, Type, TypeVar, overlo
 from comtypes import CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER, CLSCTX_SERVER, GUID
 from comtypes._memberspec import COMMETHOD
 from comtypes._post_coinit.unknwn import IUnknown
+from comtypes.GUID import REFCLSID
 
 if TYPE_CHECKING:
     from ctypes import _Pointer
@@ -171,21 +172,6 @@ def CoGetClassObject(clsid, clsctx=None, pServerInfo=None, interface=None):
     return p  # type: ignore
 
 
-@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: Optional[Type[IUnknown]] = None
-) -> IUnknown:
-    """Retrieves a pointer to a running object"""
-    p = POINTER(IUnknown)()
-    _GetActiveObject(byref(clsid), None, byref(p))
-    if interface is not None:
-        p = p.QueryInterface(interface)  # type: ignore
-    return p  # type: ignore
-
-
 class MULTI_QI(Structure):
     _fields_ = [("pIID", POINTER(GUID)), ("pItf", POINTER(c_void_p)), ("hr", HRESULT)]
     if TYPE_CHECKING:
@@ -238,14 +224,6 @@ 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