comtypes 1.4.7__zip → 1.4.9__zip

comtypes-1.4.9/comtypes/_meta.py

@@ -0,0 +1,95 @@
+# comtypes._meta helper module
+from ctypes import POINTER, c_void_p, cast
+import comtypes
+
+################################################################
+# metaclass for CoClass (in comtypes/__init__.py)
+
+
+def _wrap_coclass(self):
+    # We are an IUnknown pointer, represented as a c_void_p instance,
+    # but we really want this interface:
+    itf = self._com_interfaces_[0]
+    punk = cast(self, POINTER(itf))
+    result = punk.QueryInterface(itf)
+    result.__dict__["__clsid"] = str(self._reg_clsid_)
+    return result
+
+
+def _coclass_from_param(cls, obj):
+    if isinstance(obj, (cls._com_interfaces_[0], cls)):
+        return obj
+    raise TypeError(obj)
+
+
+#
+# The mro() of a POINTER(App) type, where class App is a subclass of CoClass:
+#
+#  POINTER(App)
+#   App
+#    CoClass
+#     c_void_p
+#      _SimpleCData
+#       _CData
+#        object
+
+
+class _coclass_meta(type):
+    # metaclass for CoClass
+    #
+    # When a CoClass subclass is created, create a POINTER(...) type
+    # for that class, with bases <coclass> and c_void_p.  Also, the
+    # POINTER(...) type gets a __ctypes_from_outparam__ method which
+    # will QueryInterface for the default interface: the first one on
+    # the coclass' _com_interfaces_ list.
+    def __new__(cls, name, bases, namespace):
+        self = type.__new__(cls, name, bases, namespace)
+        if bases == (object,):
+            # HACK: Could this conditional branch be removed since it is never reached?
+            # Since definition is `class CoClass(COMObject, metaclass=_coclass_meta)`,
+            # the `bases` parameter passed to the `_coclass_meta.__new__` would be
+            # `(COMObject,)`.
+            # Moreover, since the `COMObject` derives from `object` and does not specify
+            # a metaclass, `(object,)` will not be passed as the `bases` parameter
+            # to the `_coclass_meta.__new__`.
+            # 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 removal could make the process flow easier to understand.
+            return self
+        # 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
+
+        # `_coclass_pointer_meta` is a subclass inherited from `_coclass_meta`.
+        # In other words, when the `__new__` method of this metaclass is called, an
+        # instance of `_coclass_pointer_meta` might be created and assigned to `self`.
+        if isinstance(self, _coclass_pointer_meta):
+            # `self` is the `_coclass_pointer_meta` type or a `POINTER(coclass)` type.
+            # Prevent creating/registering a pointer to a pointer (to a pointer...),
+            # or specifying the metaclass type instance in the `bases` parameter when
+            # instantiating it, which would lead to infinite recursion.
+            # Depending on a version or revision of Python, this may be essential.
+            return self
+
+        PTR = _coclass_pointer_meta(
+            f"POINTER({self.__name__})",
+            (self, c_void_p),
+            {
+                "__ctypes_from_outparam__": _wrap_coclass,
+                "from_param": classmethod(_coclass_from_param),
+            },
+        )
+        from ctypes import _pointer_type_cache  # type: ignore
+
+        _pointer_type_cache[self] = PTR
+
+        return self
+
+
+# will not work if we change the order of the two base classes!
+class _coclass_pointer_meta(type(c_void_p), _coclass_meta):
+    # metaclass for CoClass pointer
+
+    pass  # no functionality, but needed to avoid a metaclass conflict

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/_npsupport.py

@@ -1,4 +1,5 @@
-""" Consolidation of numpy support utilities. """
+"""Consolidation of numpy support utilities."""
+
 import sys
 
 is_64bits = sys.maxsize > 2**32

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/_post_coinit/__init__.py

@@ -12,4 +12,5 @@ This subpackage is called simultaneously with the initialization of `comtypes`.
 So it is necessary to maintain minimal settings to keep the lightweight action
 when the package is initialized.
 """
+
 from comtypes._post_coinit.unknwn import _shutdown  # noqa

comtypes-1.4.9/comtypes/_post_coinit/_cominterface_meta_patcher.py

@@ -0,0 +1,153 @@
+import types
+from _ctypes import COMError
+from typing import Type
+
+from comtypes import patcher
+
+
+_all_slice = slice(None, None, None)
+
+
+def case_insensitive(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)
+
+
+def reference_fix(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 sized(itf: Type) -> None:
+    @patcher.Patch(itf)
+    class _(object):
+        def __len__(self):
+            "Return the the 'self.Count' property."
+            return self.Count
+
+
+def callable_and_subscriptable(itf: Type) -> None:
+    @patcher.Patch(itf)
+    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 = f"{type(self)!r} object does not support item assignment"
+                raise TypeError(msg)
+
+
+def iterator(itf: Type) -> None:
+    @patcher.Patch(itf)
+    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)

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

@@ -16,9 +16,9 @@ if TYPE_CHECKING:
     from comtypes import hints as hints  # noqa  # type: ignore
 
 from comtypes import GUID
-from comtypes._idl_stuff import COMMETHOD  # noqa
 from comtypes import CLSCTX_SERVER, CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER
 from comtypes import _ole32, oledll, DWORD
+from comtypes._memberspec import COMMETHOD
 from comtypes._post_coinit.unknwn import IUnknown
 
 
@@ -88,15 +88,9 @@ class IServiceProvider(IUnknown):
 
 
 @overload
-def CoGetObject(displayname: str, interface: None) -> IUnknown:
-    ...
-
-
+def CoGetObject(displayname: str, interface: None) -> IUnknown: ...
 @overload
-def CoGetObject(displayname: str, interface: Type[_T_IUnknown]) -> _T_IUnknown:
-    ...
-
-
+def CoGetObject(displayname: str, interface: Type[_T_IUnknown]) -> _T_IUnknown: ...
 def CoGetObject(displayname: str, interface: Optional[Type[IUnknown]]) -> IUnknown:
     """Convert a displayname to a moniker, then bind and return the object
     identified by the moniker."""
@@ -117,20 +111,14 @@ def CoCreateInstance(
     interface: None = None,
     clsctx: Optional[int] = None,
     punkouter: Optional[_pUnkOuter] = None,
-) -> IUnknown:
-    ...
-
-
+) -> IUnknown: ...
 @overload
 def CoCreateInstance(
     clsid: GUID,
     interface: Type[_T_IUnknown],
     clsctx: Optional[int] = None,
     punkouter: Optional[_pUnkOuter] = None,
-) -> _T_IUnknown:
-    ...
-
-
+) -> _T_IUnknown: ...
 def CoCreateInstance(
     clsid: GUID,
     interface: Optional[Type[IUnknown]] = None,
@@ -153,14 +141,19 @@ def CoCreateInstance(
 if TYPE_CHECKING:
 
     @overload
-    def CoGetClassObject(clsid, clsctx=None, pServerInfo=None, interface=None):
-        # type: (GUID, Optional[int], Optional[COSERVERINFO], None) -> hints.IClassFactory
-        pass
-
+    def CoGetClassObject(
+        clsid: GUID,
+        clsctx: Optional[int] = None,
+        pServerInfo: "Optional[COSERVERINFO]" = None,
+        interface: None = None,
+    ) -> hints.IClassFactory: ...
     @overload
-    def CoGetClassObject(clsid, clsctx=None, pServerInfo=None, interface=None):
-        # type: (GUID, Optional[int], Optional[COSERVERINFO], Type[_T_IUnknown]) -> _T_IUnknown
-        pass
+    def CoGetClassObject(
+        clsid: GUID,
+        clsctx: Optional[int] = None,
+        pServerInfo: "Optional[COSERVERINFO]" = None,
+        interface: Type[_T_IUnknown] = hints.IClassFactory,
+    ) -> _T_IUnknown: ...
 
 
 def CoGetClassObject(clsid, clsctx=None, pServerInfo=None, interface=None):
@@ -177,15 +170,9 @@ def CoGetClassObject(clsid, clsctx=None, pServerInfo=None, interface=None):
 
 
 @overload
-def GetActiveObject(clsid: GUID, interface: None = None) -> IUnknown:
-    ...
-
-
+def GetActiveObject(clsid: GUID, interface: None = None) -> IUnknown: ...
 @overload
-def GetActiveObject(clsid: GUID, interface: Type[_T_IUnknown]) -> _T_IUnknown:
-    ...
-
-
+def GetActiveObject(clsid: GUID, interface: Type[_T_IUnknown]) -> _T_IUnknown: ...
 def GetActiveObject(
     clsid: GUID, interface: Optional[Type[IUnknown]] = None
 ) -> IUnknown:
@@ -335,10 +322,7 @@ def CoCreateInstanceEx(
     clsctx: Optional[int] = None,
     machine: Optional[str] = None,
     pServerInfo: Optional[COSERVERINFO] = None,
-) -> IUnknown:
-    ...
-
-
+) -> IUnknown: ...
 @overload
 def CoCreateInstanceEx(
     clsid: GUID,
@@ -346,10 +330,7 @@ def CoCreateInstanceEx(
     clsctx: Optional[int] = None,
     machine: Optional[str] = None,
     pServerInfo: Optional[COSERVERINFO] = None,
-) -> _T_IUnknown:
-    ...
-
-
+) -> _T_IUnknown: ...
 def CoCreateInstanceEx(
     clsid: GUID,
     interface: Optional[Type[IUnknown]] = None,