comtypes 1.4.8__zip → 1.4.10__zip

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

@@ -1,34 +1,24 @@
 # https://learn.microsoft.com/en-us/windows/win32/api/unknwn/
 
-from ctypes import byref, c_ulong, c_void_p, HRESULT, POINTER
-from _ctypes import COMError
-
 import logging
-import sys
-import types
-from typing import ClassVar, TYPE_CHECKING, TypeVar
-from typing import Optional
-from typing import List, Type
-
-from comtypes import GUID, patcher, _ole32_nohresult, com_interface_registry
-from comtypes._idl_stuff import STDMETHOD
-from comtypes._memberspec import ComMemberGenerator, DispMemberGenerator
-from comtypes._memberspec import _ComMemberSpec, _DispMemberSpec
-from comtypes._py_instance_method import instancemethod
+from ctypes import HRESULT, POINTER, byref, c_ulong, c_void_p
+from typing import TYPE_CHECKING, ClassVar, List, Optional, Type, TypeVar
 
+from comtypes import GUID, _CoUninitialize, com_interface_registry
+from comtypes._memberspec import STDMETHOD, ComMemberGenerator, DispMemberGenerator
+from comtypes._post_coinit import _cominterface_meta_patcher as _meta_patch
+from comtypes._post_coinit.instancemethod import instancemethod
 
-_all_slice = slice(None, None, None)
+if TYPE_CHECKING:
+    from comtypes._memberspec import _ComMemberSpec, _DispMemberSpec
 
 logger = logging.getLogger(__name__)
 
 
 def _shutdown(
-    func=_ole32_nohresult.CoUninitialize,
+    func=_CoUninitialize,
     _debug=logger.debug,
-    _exc_clear=getattr(sys, "exc_clear", lambda: None),
 ):
-    # Make sure no COM pointers stay in exception frames.
-    _exc_clear()
     # Sometimes, CoUninitialize, running at Python shutdown,
     # raises an exception.  We suppress this when __debug__ is
     # False.
@@ -58,8 +48,8 @@ class _cominterface_meta(type):
 
     _case_insensitive_: bool
     _iid_: GUID
-    _methods_: List[_ComMemberSpec]
-    _disp_methods_: List[_DispMemberSpec]
+    _methods_: List["_ComMemberSpec"]
+    _disp_methods_: List["_DispMemberSpec"]
 
     # This flag is set to True by the atexit handler which calls
     # CoUninitialize.
@@ -136,68 +126,11 @@ class _cominterface_meta(type):
         _pointer_type_cache[self] = p
 
         if self._case_insensitive_:
-            self._patch_case_insensitive_to_ptr_type(p)
-        self._patch_reference_fix_to_ptrptr_type(POINTER(p))  # type: ignore
+            _meta_patch.case_insensitive(p)
+        _meta_patch.reference_fix(POINTER(p))  # type: ignore
 
         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
-                # POINTER(POINTER(interface)) type, so that the COM
-                # reference count is managed correctly.
-                #
-                # This is so that we can implement COM methods that have to
-                # return COM pointers more easily and consistent.  Instead of
-                # using CopyComPointer in the method implementation, we can
-                # simply do:
-                #
-                # def GetTypeInfo(self, this, ..., pptinfo):
-                #     if not pptinfo: return E_POINTER
-                #     pptinfo[0] = a_com_interface_pointer
-                #     return S_OK
-                if index != 0:
-                    # CopyComPointer, which is in _ctypes, does only
-                    # handle an index of 0.  This code does what
-                    # CopyComPointer should do if index != 0.
-                    if bool(value):
-                        value.AddRef()
-                    super(pp, self).__setitem__(index, value)  # type: ignore
-                    return
-                from _ctypes import CopyComPointer
-
-                CopyComPointer(value, self)  # type: ignore
-
     def __setattr__(self, name, value):
         if name == "_methods_":
             # XXX I'm no longer sure why the code generator generates
@@ -225,94 +158,11 @@ class _cominterface_meta(type):
 
         # XXX These special methods should be generated by the code generator.
         if has_name("Count"):
-
-            @patcher.Patch(self)
-            class _(object):
-                def __len__(self):
-                    "Return the the 'self.Count' property."
-                    return self.Count
-
+            _meta_patch.sized(self)
         if has_name("Item"):
-
-            @patcher.Patch(self)
-            class _(object):
-                # 'Item' is the 'default' value.  Make it available by
-                # calling the instance (Not sure this makes sense, but
-                # win32com does this also).
-                def __call__(self, *args, **kw):
-                    "Return 'self.Item(*args, **kw)'"
-                    return self.Item(*args, **kw)
-
-                # does this make sense? It seems that all standard typelibs I've
-                # seen so far that support .Item also support ._NewEnum
-                @patcher.no_replace
-                def __getitem__(self, index):
-                    "Return 'self.Item(index)'"
-                    # Handle tuples and all-slice
-                    if isinstance(index, tuple):
-                        args = index
-                    elif index == _all_slice:
-                        args = ()
-                    else:
-                        args = (index,)
-
-                    try:
-                        result = self.Item(*args)
-                    except COMError as err:
-                        (hresult, text, details) = err.args
-                        if hresult == -2147352565:  # DISP_E_BADINDEX
-                            raise IndexError("invalid index")
-                        else:
-                            raise
-
-                    # Note that result may be NULL COM pointer. There is no way
-                    # to interpret this properly, so it is returned as-is.
-
-                    # Hm, should we call __ctypes_from_outparam__ on the
-                    # result?
-                    return result
-
-                @patcher.no_replace
-                def __setitem__(self, index, value):
-                    "Attempt 'self.Item[index] = value'"
-                    try:
-                        self.Item[index] = value
-                    except COMError as err:
-                        (hresult, text, details) = err.args
-                        if hresult == -2147352565:  # DISP_E_BADINDEX
-                            raise IndexError("invalid index")
-                        else:
-                            raise
-                    except TypeError:
-                        msg = "%r object does not support item assignment"
-                        raise TypeError(msg % type(self))
-
+            _meta_patch.callable_and_subscriptable(self)
         if has_name("_NewEnum"):
-
-            @patcher.Patch(self)
-            class _(object):
-                def __iter__(self):
-                    "Return an iterator over the _NewEnum collection."
-                    # This method returns a pointer to _some_ _NewEnum interface.
-                    # It relies on the fact that the code generator creates next()
-                    # methods for them automatically.
-                    #
-                    # Better would maybe to return an object that
-                    # implements the Python iterator protocol, and
-                    # forwards the calls to the COM interface.
-                    enum = self._NewEnum
-                    if isinstance(enum, types.MethodType):
-                        # _NewEnum should be a propget property, with dispid -4.
-                        #
-                        # Sometimes, however, it is a method.
-                        enum = enum()
-                    if hasattr(enum, "Next"):
-                        return enum
-                    # _NewEnum returns an IUnknown pointer, QueryInterface() it to
-                    # IEnumVARIANT
-                    from comtypes.automation import IEnumVARIANT
-
-                    return enum.QueryInterface(IEnumVARIANT)
+            _meta_patch.iterator(self)
 
     def _make_case_insensitive(self):
         # The __map_case__ dictionary maps lower case names to the
@@ -325,7 +175,7 @@ class _cominterface_meta(type):
             d.update(getattr(self, "__map_case__", {}))
             self.__map_case__ = d
 
-    def _make_dispmethods(self, methods: List[_DispMemberSpec]) -> None:
+    def _make_dispmethods(self, methods: List["_DispMemberSpec"]) -> None:
         if self._case_insensitive_:
             self._make_case_insensitive()
         # create dispinterface methods and properties on the interface 'self'
@@ -357,7 +207,7 @@ class _cominterface_meta(type):
                 raise TypeError(f"baseinterface '{itf.__name__}' has no _methods_")
         return result
 
-    def _make_methods(self, methods: List[_ComMemberSpec]) -> None:
+    def _make_methods(self, methods: List["_ComMemberSpec"]) -> None:
         if self._case_insensitive_:
             self._make_case_insensitive()
         # register com interface. we insist on an _iid_ in THIS class!
@@ -375,12 +225,12 @@ class _cominterface_meta(type):
             member_gen.add(m)
         for name, func, raw_func, is_prop in member_gen.methods():
             raw_mth = instancemethod(raw_func, None, self)
-            setattr(self, "_%s__com_%s" % (self.__name__, name), raw_mth)
+            setattr(self, f"_{self.__name__}__com_{name}", raw_mth)
             mth = instancemethod(func, None, self)
             if not is_prop:
                 # We install the method in the class, except when it's a property.
                 # And we make sure we don't overwrite a property that's already present.
-                mthname = name if not hasattr(self, name) else ("_%s" % name)
+                mthname = name if not hasattr(self, name) else f"_{name}"
                 setattr(self, mthname, mth)
             # For a method, this is the real name.
             # For a property, this is the name WITHOUT the _set_ or _get_ prefix.
@@ -391,7 +241,7 @@ class _cominterface_meta(type):
         # create public properties / attribute accessors
         for name, accessor in member_gen.properties():
             # Again, we should not overwrite class attributes that are already present.
-            propname = name if not hasattr(self, name) else ("_%s" % name)
+            propname = name if not hasattr(self, name) else f"_{name}"
             setattr(self, propname, accessor)
             # COM is case insensitive
             if self._case_insensitive_:
@@ -423,7 +273,7 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
             #
             if not type(self)._com_shutting_down:
                 _debug("Release %s", self)
-                self.Release()
+                self.Release()  # type: ignore
 
     def __eq__(self, other):
         if not isinstance(other, _compointer_base):
@@ -446,7 +296,7 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
 
     def __repr__(self):
         ptr = super(_compointer_base, self).value
-        return "<%s ptr=0x%x at %x>" % (self.__class__.__name__, ptr or 0, id(self))
+        return f"<{self.__class__.__name__} ptr=0x{ptr or 0:x} at {id(self):x}>"
 
     # This fixes the problem when there are multiple python interface types
     # wrapping the same COM interface.  This could happen because some interfaces
@@ -482,8 +332,8 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
                 # a kind of QueryInterface
                 return table[cls._iid_]
             except KeyError:
-                raise TypeError("Interface %s not supported" % cls._iid_)
-        return value.QueryInterface(cls.__com_interface__)
+                raise TypeError(f"Interface {cls._iid_} not supported")
+        return value.QueryInterface(cls.__com_interface__)  # type: ignore
 
 
 ################################################################
@@ -524,7 +374,7 @@ class IUnknown(_IUnknown_Base, metaclass=_cominterface_meta):
 
     _case_insensitive_: ClassVar[bool] = False
     _iid_: ClassVar[GUID] = GUID("{00000000-0000-0000-C000-000000000046}")
-    _methods_: ClassVar[List[_ComMemberSpec]] = [
+    _methods_: ClassVar[List["_ComMemberSpec"]] = [
         STDMETHOD(HRESULT, "QueryInterface", [POINTER(GUID), POINTER(c_void_p)]),
         STDMETHOD(c_ulong, "AddRef"),
         STDMETHOD(c_ulong, "Release"),

{comtypes-1.4.8 → comtypes-1.4.10}/comtypes/_safearray.py

@@ -1,9 +1,9 @@
 """SAFEARRAY api functions, data types, and constants."""
 
-from ctypes import c_uint, c_ushort, c_void_p, POINTER, Structure, WinDLL
-from ctypes.wintypes import DWORD, LONG, UINT
+from ctypes import POINTER, Structure, WinDLL, c_uint, c_ushort, c_void_p
+from ctypes.wintypes import DWORD, LONG, UINT, USHORT
 
-from comtypes import HRESULT, GUID
+from comtypes import GUID, HRESULT
 
 ################################################################
 # if __debug__:
@@ -19,7 +19,6 @@ from comtypes import HRESULT, GUID
 
 VARTYPE = c_ushort
 PVOID = c_void_p
-USHORT = c_ushort
 
 _oleaut32 = WinDLL("oleaut32")