comtypes 1.4.6__zip → 1.4.8__zip

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/_post_coinit/unknwn.py

@@ -69,12 +69,37 @@ class _cominterface_meta(type):
     def __new__(cls, name, bases, namespace):
         methods = namespace.pop("_methods_", None)
         dispmethods = namespace.pop("_disp_methods_", None)
-        new_cls = type.__new__(cls, name, bases, namespace)
+        self = type.__new__(cls, name, bases, namespace)
 
         if methods is not None:
-            new_cls._methods_ = methods
+            self._methods_ = methods
         if dispmethods is not None:
-            new_cls._disp_methods_ = dispmethods
+            self._disp_methods_ = dispmethods
+
+        # ` _compointer_meta` is a subclass inherited from `_cominterface_meta`.
+        # `_compointer_base` uses `_compointer_meta` as its metaclass.
+        # In other words, when the `__new__` method of this metaclass is called,
+        # `_compointer_base` type or an subclass of it might be created and assigned
+        # to `self`.
+        if bases == (c_void_p,):
+            # `self` is the `_compointer_base` type.
+            # On some versions of Python, `_compointer_base` is not yet available in
+            # the accessible namespace at this point in its initialization, and
+            # referencing it could raise a `NameError`.
+            # This metaclass is intended to be used only as a base class for defining
+            # the `_compointer_meta` or as the metaclass for the `IUnknown`, so the
+            # situation where the `bases` parameter is `(c_void_p,)` is limited to when
+            # the `_compointer_meta` is specified as the metaclass of the
+            # `_compointer_base`.
+            # Prevent specifying the metaclass type instance in the `bases` parameter
+            # when instantiating it, as this would lead to infinite recursion.
+            return self
+        if issubclass(self, _compointer_base):
+            # `self` is a `POINTER(interface)` type.
+            # Prevent creating/registering a pointer to a pointer (to a pointer...),
+            # which would lead to infinite recursion.
+            # Depending on a version or revision of Python, this may be essential.
+            return self
 
         # If we sublass a COM interface, for example:
         #
@@ -85,49 +110,67 @@ class _cominterface_meta(type):
         # subclass of POINTER(IUnknown) because of the way ctypes
         # typechecks work.
         if bases == (object,):
-            _ptr_bases = (new_cls, _compointer_base)
+            # `self` is the `IUnknown` type.
+            _ptr_bases = (self, _compointer_base)
         else:
-            _ptr_bases = (new_cls, POINTER(bases[0]))
-
-        # The interface 'new_cls' is used as a mixin.
+            # `self` is an interface type derived from `IUnknown`.
+            _ptr_bases = (self, POINTER(bases[0]))
+
+        # The interface 'self' is used as a mixin.
+        # HACK: Could `type(_compointer_base)` be replaced with `_compointer_meta`?
+        # `type(klass)` returns its metaclass.
+        # Since this specification, `type(_compointer_base)` will return the
+        # `_compointer_meta` type as per the class definition.
+        # The reason for this implementation might be a remnant of the differences in
+        # how metaclasses work between Python 3.x and Python 2.x.
+        # If there are no problems with the versions of Python that `comtypes`
+        # supports, this replacement could make the process flow easier to understand.
         p = type(_compointer_base)(
-            "POINTER(%s)" % new_cls.__name__,
+            f"POINTER({self.__name__})",
             _ptr_bases,
-            {"__com_interface__": new_cls, "_needs_com_addref_": None},
+            {"__com_interface__": self, "_needs_com_addref_": None},
         )
 
-        from ctypes import _pointer_type_cache
+        from ctypes import _pointer_type_cache  # type: ignore
 
-        _pointer_type_cache[new_cls] = p
+        _pointer_type_cache[self] = p
 
-        if new_cls._case_insensitive_:
+        if self._case_insensitive_:
+            self._patch_case_insensitive_to_ptr_type(p)
+        self._patch_reference_fix_to_ptrptr_type(POINTER(p))  # type: ignore
 
-            @patcher.Patch(p)
-            class CaseInsensitive(object):
-                # case insensitive attributes for COM methods and properties
-                def __getattr__(self, name):
-                    """Implement case insensitive access to methods and properties"""
-                    try:
-                        fixed_name = self.__map_case__[name.lower()]
-                    except KeyError:
-                        raise AttributeError(name)
-                    if fixed_name != name:  # prevent unbounded recursion
-                        return getattr(self, fixed_name)
-                    raise AttributeError(name)
-
-                # __setattr__ is pretty heavy-weight, because it is called for
-                # EVERY attribute assignment.  Settings a non-com attribute
-                # through this function takes 8.6 usec, while without this
-                # function it takes 0.7 sec - 12 times slower.
-                #
-                # How much faster would this be if implemented in C?
-                def __setattr__(self, name, value):
-                    """Implement case insensitive access to methods and properties"""
-                    object.__setattr__(
-                        self, self.__map_case__.get(name.lower(), name), value
-                    )
-
-        @patcher.Patch(POINTER(p))
+        return self
+
+    @staticmethod
+    def _patch_case_insensitive_to_ptr_type(p: Type) -> None:
+        @patcher.Patch(p)
+        class CaseInsensitive(object):
+            # case insensitive attributes for COM methods and properties
+            def __getattr__(self, name):
+                """Implement case insensitive access to methods and properties"""
+                try:
+                    fixed_name = self.__map_case__[name.lower()]
+                except KeyError:
+                    raise AttributeError(name)  # Should we use exception-chaining?
+                if fixed_name != name:  # prevent unbounded recursion
+                    return getattr(self, fixed_name)
+                raise AttributeError(name)
+
+            # __setattr__ is pretty heavy-weight, because it is called for
+            # EVERY attribute assignment.  Settings a non-com attribute
+            # through this function takes 8.6 usec, while without this
+            # function it takes 0.7 sec - 12 times slower.
+            #
+            # How much faster would this be if implemented in C?
+            def __setattr__(self, name, value):
+                """Implement case insensitive access to methods and properties"""
+                object.__setattr__(
+                    self, self.__map_case__.get(name.lower(), name), value
+                )
+
+    @staticmethod
+    def _patch_reference_fix_to_ptrptr_type(pp: Type) -> None:
+        @patcher.Patch(pp)
         class ReferenceFix(object):
             def __setitem__(self, index, value):
                 # We override the __setitem__ method of the
@@ -149,13 +192,11 @@ class _cominterface_meta(type):
                     # CopyComPointer should do if index != 0.
                     if bool(value):
                         value.AddRef()
-                    super(POINTER(p), self).__setitem__(index, value)
+                    super(pp, self).__setitem__(index, value)  # type: ignore
                     return
                 from _ctypes import CopyComPointer
 
-                CopyComPointer(value, self)
-
-        return new_cls
+                CopyComPointer(value, self)  # type: ignore
 
     def __setattr__(self, name, value):
         if name == "_methods_":
@@ -308,16 +349,13 @@ class _cominterface_meta(type):
 
     def __get_baseinterface_methodcount(self):
         "Return the number of com methods in the base interfaces"
-        try:
-            result = 0
-            for itf in self.mro()[1:-1]:
-                result += len(itf.__dict__["_methods_"])
-            return result
-        except KeyError as err:
-            (name,) = err.args
-            if name == "_methods_":
-                raise TypeError("baseinterface '%s' has no _methods_" % itf.__name__)
-            raise
+        result = 0
+        for itf in self.mro()[1:-1]:
+            if "_methods_" in vars(itf):
+                result += len(vars(itf)["_methods_"])
+            else:
+                raise TypeError(f"baseinterface '{itf.__name__}' has no _methods_")
+        return result
 
     def _make_methods(self, methods: List[_ComMemberSpec]) -> None:
         if self._case_insensitive_:
@@ -363,9 +401,11 @@ class _cominterface_meta(type):
 ################################################################
 
 
+# will not work if we change the order of the two base classes!
 class _compointer_meta(type(c_void_p), _cominterface_meta):
-    "metaclass for COM interface pointer classes"
-    # no functionality, but needed to avoid a metaclass conflict
+    """metaclass for COM interface pointer classes"""
+
+    pass  # no functionality, but needed to avoid a metaclass conflict
 
 
 class _compointer_base(c_void_p, metaclass=_compointer_meta):
@@ -385,21 +425,6 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
                 _debug("Release %s", self)
                 self.Release()
 
-    def __cmp__(self, other):
-        """Compare pointers to COM interfaces."""
-        # COM identity rule
-        #
-        # XXX To compare COM interface pointers, should we
-        # automatically QueryInterface for IUnknown on both items, and
-        # compare the pointer values?
-        if not isinstance(other, _compointer_base):
-            return 1
-
-        # get the value property of the c_void_p baseclass, this is the pointer value
-        return cmp(
-            super(_compointer_base, self).value, super(_compointer_base, other).value
-        )
-
     def __eq__(self, other):
         if not isinstance(other, _compointer_base):
             return False

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/automation.py

@@ -4,7 +4,7 @@ import datetime
 import decimal
 import sys
 from ctypes import *
-from ctypes import _Pointer
+from ctypes import _Pointer, Array as _CArrayType
 from _ctypes import CopyComPointer
 from ctypes.wintypes import DWORD, LONG, UINT, VARIANT_BOOL, WCHAR, WORD
 from typing import Any, ClassVar, Dict, List, Optional, TYPE_CHECKING, Type
@@ -16,9 +16,11 @@ import comtypes.patcher
 import comtypes
 
 if TYPE_CHECKING:
+    from ctypes import _CArgObject
     from comtypes import hints  # type: ignore
     from comtypes import _safearray
 else:
+    _CArgObject = type(byref(c_int()))
     try:
         from comtypes import _safearray
     except (ImportError, AttributeError):
@@ -50,7 +52,6 @@ INVOKEKIND = tagINVOKEKIND
 # helpers
 IID_NULL = GUID()
 riid_null = byref(IID_NULL)
-_byref_type = type(byref(c_int()))
 
 # 30. December 1899, midnight.  For VT_DATE.
 _com_null_date = datetime.datetime(1899, 12, 30, 0, 0, 0)
@@ -129,7 +130,7 @@ class tagDEC(Structure):
         ("Lo64", c_ulonglong),
     ]
 
-    def as_decimal(self):
+    def as_decimal(self) -> decimal.Decimal:
         """Convert a tagDEC struct to Decimal.
 
         See http://msdn.microsoft.com/en-us/library/cc234586.aspx for the tagDEC
@@ -137,12 +138,8 @@ class tagDEC(Structure):
 
         """
         digits = (self.Hi32 << 64) + self.Lo64
-        decimal_str = "{0}{1}e-{2}".format(
-            "-" if self.sign else "",
-            digits,
-            self.scale,
-        )
-        return decimal.Decimal(decimal_str)
+        sign = "-" if self.sign else ""
+        return decimal.Decimal(f"{sign}{digits}e-{self.scale}")
 
 
 DECIMAL = tagDEC
@@ -382,7 +379,7 @@ class tagVARIANT(Structure):
         elif isinstance(value, c_uint64):
             self.vt = VT_UI8
             self._.VT_UI8 = value
-        elif isinstance(value, _byref_type):
+        elif isinstance(value, _CArgObject):
             ref = value._obj
             self._.c_void_p = addressof(ref)
             self.__keepref = value
@@ -609,9 +606,6 @@ v.vt = VT_ERROR
 v._.VT_I4 = 0x80020004
 del v
 
-_carg_obj = type(byref(c_int()))
-from ctypes import Array as _CArrayType
-
 
 @comtypes.patcher.Patch(POINTER(VARIANT))
 class _(object):
@@ -626,7 +620,7 @@ class _(object):
         if isinstance(arg, POINTER(VARIANT)):
             return arg
         # accept byref(VARIANT) instance
-        if isinstance(arg, _carg_obj) and isinstance(arg._obj, VARIANT):
+        if isinstance(arg, _CArgObject) and isinstance(arg._obj, VARIANT):
             return arg
         # accept VARIANT instance
         if isinstance(arg, VARIANT):
@@ -750,7 +744,7 @@ EXCEPINFO = tagEXCEPINFO
 
 class tagDISPPARAMS(Structure):
     if TYPE_CHECKING:
-        rgvarg: Array[VARIANT]
+        rgvarg: _CArrayType[VARIANT]
         rgdispidNamedArgs: _Pointer[DISPID]
         cArgs: int
         cNamedArgs: int

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/client/__init__.py

@@ -138,22 +138,17 @@ wrap = GetBestInterface
 # Should we do this for POINTER(IUnknown) also?
 ctypes.POINTER(automation.IDispatch).__ctypes_from_outparam__ = wrap_outparam  # type: ignore
 
+
 ################################################################
 #
 # Object creation
 #
 @overload
-def GetActiveObject(progid: _UnionT[str, CoClass, GUID]) -> Any:
-    ...
-
-
+def GetActiveObject(progid: _UnionT[str, CoClass, GUID]) -> Any: ...
 @overload
 def GetActiveObject(
     progid: _UnionT[str, CoClass, GUID], interface: Type[_T_IUnknown]
-) -> _T_IUnknown:
-    ...
-
-
+) -> _T_IUnknown: ...
 def GetActiveObject(
     progid: _UnionT[str, CoClass, GUID],
     interface: Optional[Type[IUnknown]] = None,
@@ -193,14 +188,19 @@ def _manage(
 if TYPE_CHECKING:
 
     @overload
-    def GetClassObject(progid, clsctx=None, pServerInfo=None):
-        # type: (_UnionT[str, CoClass, GUID], Optional[int], Optional[comtypes.COSERVERINFO]) -> hints.IClassFactory
-        pass
-
+    def GetClassObject(
+        progid: _UnionT[str, CoClass, GUID],
+        clsctx: Optional[int] = None,
+        pServerInfo: Optional[comtypes.COSERVERINFO] = None,
+        interface: None = None,
+    ) -> hints.IClassFactory: ...
     @overload
-    def GetClassObject(progid, clsctx=None, pServerInfo=None, interface=None):
-        # type: (_UnionT[str, CoClass, GUID], Optional[int], Optional[comtypes.COSERVERINFO], Optional[Type[_T_IUnknown]]) -> _T_IUnknown
-        pass
+    def GetClassObject(
+        progid: _UnionT[str, CoClass, GUID],
+        clsctx: Optional[int] = None,
+        pServerInfo: Optional[comtypes.COSERVERINFO] = None,
+        interface: Type[_T_IUnknown] = hints.IClassFactory,
+    ) -> _T_IUnknown: ...
 
 
 def GetClassObject(progid, clsctx=None, pServerInfo=None, interface=None):
@@ -216,10 +216,7 @@ def GetClassObject(progid, clsctx=None, pServerInfo=None, interface=None):
 
 
 @overload
-def CreateObject(progid: _UnionT[str, Type[CoClass], GUID]) -> Any:
-    ...
-
-
+def CreateObject(progid: _UnionT[str, Type[CoClass], GUID]) -> Any: ...
 @overload
 def CreateObject(
     progid: _UnionT[str, Type[CoClass], GUID],
@@ -228,10 +225,7 @@ def CreateObject(
     interface: Optional[Type[_T_IUnknown]] = None,
     dynamic: bool = ...,
     pServerInfo: Optional[comtypes.COSERVERINFO] = None,
-) -> _T_IUnknown:
-    ...
-
-
+) -> _T_IUnknown: ...
 def CreateObject(
     progid: _UnionT[str, Type[CoClass], GUID],  # which object to create
     clsctx: Optional[int] = None,  # how to create the object
@@ -297,15 +291,11 @@ def CreateObject(
 
 
 @overload
-def CoGetObject(displayname: str, interface: Type[_T_IUnknown]) -> _T_IUnknown:
-    ...
-
-
+def CoGetObject(displayname: str, interface: Type[_T_IUnknown]) -> _T_IUnknown: ...
 @overload
-def CoGetObject(displayname: str, interface: None = None, dynamic: bool = False) -> Any:
-    ...
-
-
+def CoGetObject(
+    displayname: str, interface: None = None, dynamic: bool = False
+) -> Any: ...
 def CoGetObject(
     displayname: str,
     interface: Optional[Type[comtypes.IUnknown]] = None,

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/client/_code_cache.py

@@ -4,6 +4,7 @@ The main function is _find_gen_dir(), which on-demand creates the
 comtypes.gen package and returns a directory where generated code can
 be written to.
 """
+
 import ctypes, logging, os, sys, tempfile, types
 from ctypes import wintypes
 

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/client/_events.py

@@ -1,4 +1,3 @@
-from __future__ import print_function
 import ctypes
 import traceback
 import comtypes

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/client/_generate.py

@@ -1,4 +1,3 @@
-from __future__ import print_function
 import ctypes
 import importlib
 import inspect
@@ -106,7 +105,8 @@ def GetModule(tlib: _UnionT[Any, typeinfo.ITypeLib]) -> types.ModuleType:
         frame = sys._getframe(1)
         _file_: Optional[str] = frame.f_globals.get("__file__", None)
         pathname, is_abs = _resolve_filename(
-            tlib_string, _file_ and os.path.dirname(_file_)  # type: ignore
+            tlib_string,
+            _file_ and os.path.dirname(_file_),  # type: ignore
         )
         logger.debug("GetModule(%s), resolved: %s", pathname, is_abs)
         tlib = _load_tlib(pathname)  # don't register
@@ -251,9 +251,9 @@ _ItfName = str
 _ItfIid = str
 
 
-def _get_known_namespaces() -> Tuple[
-    Mapping[_SymbolName, _ModuleName], Mapping[_ItfName, _ItfIid]
-]:
+def _get_known_namespaces() -> (
+    Tuple[Mapping[_SymbolName, _ModuleName], Mapping[_ItfName, _ItfIid]]
+):
     """Returns symbols and interfaces that are already statically defined in `ctypes`
     and `comtypes`.
     From `ctypes`, all the names are obtained.

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/client/lazybind.py

@@ -126,11 +126,6 @@ class Dispatch(object):
         "QueryInterface is forwarded to the real com object."
         return self._comobj.QueryInterface(*args)
 
-    def __cmp__(self, other):
-        if not isinstance(other, Dispatch):
-            return 1
-        return cmp(self._comobj, other._comobj)
-
     def __eq__(self, other):
         return isinstance(other, Dispatch) and self._comobj == other._comobj
 

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/git.py

@@ -3,6 +3,7 @@
 The global interface table provides a way to marshal interface pointers
 between different threading appartments.
 """
+
 from ctypes import *
 from comtypes import (
     IUnknown,

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/hints.pyi

@@ -10,8 +10,10 @@ from typing import Callable, Iterator, Sequence
 
 if sys.version_info >= (3, 8):
     from typing import Protocol
+    from typing import Literal as Literal
 else:
     from typing_extensions import Protocol
+    from typing_extensions import Literal as Literal
 if sys.version_info >= (3, 9):
     from typing import Annotated as Annotated
 else:
@@ -251,7 +253,7 @@ _T_E = TypeVar("_T_E")
 def to_dunder_iter(
     newenum: _UnionT[
         _Descriptor[_T_Inst, Iterator[_T_E]], Callable[[_T_Inst], Iterator[_T_E]]
-    ]
+    ],
 ) -> Callable[[_T_Inst], Iterator[_T_E]]: ...
 @overload
 def to_dunder_iter(newenum: Any) -> Callable[..., NoReturn]: ...
@@ -264,7 +266,7 @@ def to_dunder_call(
         _GetSetNamedProperty[_T_Inst, _P_Get, _R_Get, ...],
         _GetOnlyNamedProperty[_T_Inst, _P_Get, _R_Get],
         Callable[Concatenate[_T_Inst, _P_Get], _R_Get],
-    ]
+    ],
 ) -> Callable[Concatenate[_T_Inst, _P_Get], _R_Get]: ...
 @overload
 def to_dunder_call(item: Any) -> Callable[..., NoReturn]: ...
@@ -276,7 +278,7 @@ def to_dunder_getitem(
         _GetSetNamedProperty[_T_Inst, _P_Get, _R_Get, ...],
         _GetOnlyNamedProperty[_T_Inst, _P_Get, _R_Get],
         Callable[Concatenate[_T_Inst, _P_Get], _R_Get],
-    ]
+    ],
 ) -> Callable[Concatenate[_T_Inst, _P_Get], _R_Get]: ...
 @overload
 def to_dunder_getitem(item: Any) -> Callable[..., NoReturn]: ...
@@ -287,7 +289,7 @@ def to_dunder_setitem(
     item: _UnionT[
         _GetSetNamedProperty[_T_Inst, ..., Any, _P_Set],
         _SetOnlyNamedProperty[_T_Inst, _P_Set],
-    ]
+    ],
 ) -> Callable[Concatenate[_T_Inst, _P_Set], Any]: ...
 @overload
 def to_dunder_setitem(item: Any) -> Callable[..., NoReturn]: ...

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/persist.py

@@ -9,12 +9,20 @@
 The 'DictPropertyBag' class is a class implementing the IPropertyBag
 interface, useful in client code.
 """
-from ctypes import *
+
+from ctypes import c_int, c_ulong, c_ushort, c_wchar_p
+from ctypes import POINTER, Structure
 from ctypes.wintypes import WORD, DWORD, BOOL
-from comtypes import GUID, IUnknown, COMMETHOD, HRESULT, dispid
+from typing import TYPE_CHECKING
+
+from comtypes import GUID, IUnknown, COMMETHOD, HRESULT
 from comtypes import IPersist
 from comtypes.automation import VARIANT, tagEXCEPINFO
 
+if TYPE_CHECKING:
+    from comtypes import hints  # type: ignore
+
+
 # XXX Replace by canonical solution!!!
 WSTRING = c_wchar_p
 
@@ -236,9 +244,17 @@ class IPersistFile(IPersist):
         ),
     ]
 
+    if TYPE_CHECKING:
+
+        def IsDirty(self) -> hints.Hresult: ...
+        def Load(self, pszFileName: str, dwMode: int) -> hints.Hresult: ...
+        def Save(self, pszFileName: str, fRemember: bool) -> hints.Hresult: ...
+        def SaveCompleted(self, pszFileName: str) -> hints.Hresult: ...
+        def GetCurFile(self) -> str: ...
+
 
 from comtypes import COMObject
-from comtypes.hresult import *
+from comtypes.hresult import E_INVALIDARG, S_OK
 
 
 class DictPropertyBag(COMObject):

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/safearray.py

@@ -81,9 +81,7 @@ def _make_safearray_type(itemtype):
     )
 
     meta = type(_safearray.tagSAFEARRAY)
-    sa_type = meta.__new__(
-        meta, "SAFEARRAY_%s" % itemtype.__name__, (_safearray.tagSAFEARRAY,), {}
-    )
+    sa_type = meta(f"SAFEARRAY_{itemtype.__name__}", (_safearray.tagSAFEARRAY,), {})
 
     try:
         vartype = _ctype_to_vartype[itemtype]
@@ -192,9 +190,7 @@ def _make_safearray_type(itemtype):
                 nitems *= d
                 rgsa[i].cElements = d
                 rgsa[i].lBound = lBound
-            pa = _safearray.SafeArrayCreateEx(
-                cls._vartype_, value.ndim, rgsa, extra  # cDims  # rgsaBound
-            )  # pvExtra
+            pa = _safearray.SafeArrayCreateEx(cls._vartype_, value.ndim, rgsa, extra)
             if not pa:
                 if cls._vartype_ == VT_RECORD and extra is None:
                     raise TypeError(

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/server/__init__.py

@@ -1,5 +1,6 @@
 import comtypes.client, ctypes
 
+
 ################################################################
 # Interfaces
 class IClassFactory(comtypes.IUnknown):

{comtypes-1.4.6 → comtypes-1.4.8}/comtypes/server/register.py

@@ -35,6 +35,7 @@ Now, debug the object, and when done delete logging info:
 
   python mycomobj.py /nodebug
 """
+
 import sys
 import os
 import winreg