winrt-runtime 4.0.1__tar.gz → 4.0.2__tar.gz

{winrt_runtime-4.0.1/python/winrt_runtime.egg-info → winrt_runtime-4.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winrt-runtime
-Version: 4.0.1
+Version: 4.0.2
 Summary: The runtime that every PyWinRT projection package runs on
 License-Expression: MIT
 Project-URL: Documentation, https://pywinrt.readthedocs.io

{winrt_runtime-4.0.1 → winrt_runtime-4.0.2/python/winrt_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winrt-runtime
-Version: 4.0.1
+Version: 4.0.2
 Summary: The runtime that every PyWinRT projection package runs on
 License-Expression: MIT
 Project-URL: Documentation, https://pywinrt.readthedocs.io

{winrt_runtime-4.0.1 → winrt_runtime-4.0.2}/src/_winrt.cpp

@@ -322,9 +322,32 @@ namespace py::cpp::_winrt
             nullptr},
            {}};
 
+    /**
+     * __call__ of every projected class: what type's does, and then, for a
+     * Python class derived from a composable one whose __init__() returned
+     * without composing the instance, composing it with the call's arguments.
+     */
+    static PyObject* Object_Static_call(
+        PyObject* type, PyObject* args, PyObject* kwds) noexcept
+    {
+        py::pyobj_handle self{PyType_Type.tp_call(type, args, kwds)};
+        if (!self)
+        {
+            return nullptr;
+        }
+
+        if (!py::interp::compose_after_init(self.get(), args, kwds))
+        {
+            return nullptr;
+        }
+
+        return self.detach();
+    }
+
     static PyType_Slot Object_Static_type_slots[]
         = {{Py_tp_base, reinterpret_cast<void*>(&PyType_Type)},
            {Py_tp_methods, reinterpret_cast<void*>(Object_Static_methods)},
+           {Py_tp_call, reinterpret_cast<void*>(Object_Static_call)},
            {}};
 
     static PyType_Spec Object_Static_type_spec
@@ -377,6 +400,11 @@ namespace py::cpp::_winrt
         py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>* self,
         void* /*unused*/) noexcept
     {
+        if (!py::interp::instance_abi(reinterpret_cast<PyObject*>(self)))
+        {
+            return nullptr;
+        }
+
         return py::interp::iids_of(self->obj);
     }
 
@@ -388,6 +416,11 @@ namespace py::cpp::_winrt
         py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>* self,
         void* /*unused*/) noexcept
     {
+        if (!py::interp::instance_abi(reinterpret_cast<PyObject*>(self)))
+        {
+            return nullptr;
+        }
+
         return py::interp::runtime_class_name_of(self->obj);
     }
 
@@ -470,6 +503,13 @@ namespace py::cpp::_winrt
             Py_RETURN_NOTIMPLEMENTED;
         }
 
+        // A Python object derived from a composable class holds nothing until
+        // its __init__() has composed it, and is no other object until then.
+        if (!self->obj)
+        {
+            Py_RETURN_NOTIMPLEMENTED;
+        }
+
         auto const equal
             = self->obj
               == reinterpret_cast<

{winrt_runtime-4.0.1 → winrt_runtime-4.0.2}/src/compose.cpp

@@ -923,21 +923,24 @@ namespace py::interp
     }
 
     /**
-     * Makes an instance of @p type, which is a Python class derived from the
-     * composable class @p entry: the Python object, and the WinRT object it is
-     * composed into, each holding the other.
+     * Composes @p self, an instance of a Python class derived from the
+     * composable class @p entry that holds nothing yet, into a WinRT object:
+     * the Python object, and the WinRT object it is composed into, each
+     * holding the other.
      *
-     * @returns A new reference to the Python object, or @c nullptr with a
-     * Python error set.
+     * @returns @c true, or @c false with a Python error set and @p self left
+     * holding nothing.
      */
-    PyObject* make_composed_object(
-        PyTypeObject* type,
+    bool compose_into(
+        PyObject* self,
         type_entry& entry,
         member_desc const& constructor,
         overload_desc& overload,
         PyObject* const* args,
         Py_ssize_t nargs) noexcept
     {
+        auto* const type = Py_TYPE(self);
+
         if (!composes(overload))
         {
             PyErr_Format(
@@ -946,14 +949,14 @@ namespace py::interp
                 "instance rather than composing one",
                 entry.winrt_name,
                 overload.winrt_name);
-            return nullptr;
+            return false;
         }
 
         // init_subclass() refuses such a class already, unless a base before
         // it in the MRO does not call the next __init_subclass__().
         if (!check_composed_bases(type))
         {
-            return nullptr;
+            return false;
         }
 
         // What the outer object answers itself: every interface the Python
@@ -963,14 +966,14 @@ namespace py::interp
 
         if (!collect_interfaces(type, interfaces))
         {
-            return nullptr;
+            return false;
         }
 
         for (auto* const iface : interfaces)
         {
             if (!ensure_interface_vtable(*iface))
             {
-                return nullptr;
+                return false;
             }
         }
 
@@ -1003,14 +1006,14 @@ namespace py::interp
                 auto* const iface = ensure_named_entry(*base->owner, overridables[i]);
                 if (!iface)
                 {
-                    return nullptr;
+                    return false;
                 }
 
                 // An overridable interface is exclusive to the class, so the
                 // class's own record is where its members are written down.
                 if (!ensure_interface_vtable(*iface, *base))
                 {
-                    return nullptr;
+                    return false;
                 }
 
                 if (!named)
@@ -1026,16 +1029,10 @@ namespace py::interp
             }
         }
 
-        pyobj_handle self{type->tp_alloc(type, 0)};
-        if (!self)
-        {
-            return nullptr;
-        }
-
         // A weak reference to the pair takes the Python object from whatever
         // thread resolves it, which a free-threaded build only allows for an
         // object that has been told to expect it.
-        PyUnstable_EnableTryIncRef(self.get());
+        PyUnstable_EnableTryIncRef(self);
 
         auto outer = std::make_unique<compose_object>();
 
@@ -1047,7 +1044,7 @@ namespace py::interp
         outer->source_head.target = outer.get();
         outer->weak_head.vtable = weak_reference_vtable;
         outer->weak_head.target = outer.get();
-        outer->calls.obj = self.get();
+        outer->calls.obj = self;
 
         try
         {
@@ -1056,7 +1053,7 @@ namespace py::interp
         catch (...)
         {
             to_PyErr();
-            return nullptr;
+            return false;
         }
 
         make_tearoffs(interfaces, outer->head, outer->calls, outer->tearoffs);
@@ -1074,7 +1071,7 @@ namespace py::interp
         if (!instance)
         {
             object_release(&outer.release()->head);
-            return nullptr;
+            return false;
         }
 
         // The wrapper holds the outer object seen as the class's own default
@@ -1098,12 +1095,12 @@ namespace py::interp
             catch (...)
             {
                 to_PyErr();
-                return nullptr;
+                return false;
             }
         }
 
-        abi_of(self.get()) = abi;
+        abi_of(self) = abi;
 
-        return self.detach();
+        return true;
     }
 } // namespace py::interp

{winrt_runtime-4.0.1 → winrt_runtime-4.0.2}/src/compose.h

@@ -21,8 +21,8 @@
 
 namespace py::interp
 {
-    PyObject* make_composed_object(
-        PyTypeObject* type,
+    bool compose_into(
+        PyObject* self,
         type_entry& entry,
         member_desc const& constructor,
         overload_desc& overload,

{winrt_runtime-4.0.1 → winrt_runtime-4.0.2}/src/members.cpp

@@ -82,18 +82,19 @@ namespace py::interp
                 return nullptr;
             }
 
+            void* abi{};
+            if (!self->member->is_static && !(abi = instance_abi(instance)))
+            {
+                return nullptr;
+            }
+
             auto const overload = select_overload(*self->member, nargs - 1);
             if (!overload)
             {
                 return nullptr;
             }
 
-            return call_member(
-                *self->member,
-                *overload,
-                self->member->is_static ? nullptr : abi_of(instance),
-                args + 1,
-                nargs - 1);
+            return call_member(*self->member, *overload, abi, args + 1, nargs - 1);
         }
 
         PyObject* method_descr_get(
@@ -211,18 +212,20 @@ namespace py::interp
         PyObject* property_get(PyObject* self, void* closure) noexcept
         {
             auto const member = static_cast<member_desc*>(closure);
+
+            void* abi{};
+            if (!member->is_static && !(abi = instance_abi(self)))
+            {
+                return nullptr;
+            }
+
             auto const overload = select_overload(*member, 0);
             if (!overload)
             {
                 return nullptr;
             }
 
-            return call_member(
-                *member,
-                *overload,
-                member->is_static ? nullptr : abi_of(self),
-                nullptr,
-                0);
+            return call_member(*member, *overload, abi, nullptr, 0);
         }
 
         int property_set(PyObject* self, PyObject* value, void* closure) noexcept
@@ -236,18 +239,19 @@ namespace py::interp
                 return -1;
             }
 
+            void* abi{};
+            if (!member->is_static && !(abi = instance_abi(self)))
+            {
+                return -1;
+            }
+
             auto const overload = select_overload(*member, 1);
             if (!overload)
             {
                 return -1;
             }
 
-            pyobj_handle result{call_member(
-                *member,
-                *overload,
-                member->is_static ? nullptr : abi_of(self),
-                &value,
-                1)};
+            pyobj_handle result{call_member(*member, *overload, abi, &value, 1)};
 
             return result ? 0 : -1;
         }

{winrt_runtime-4.0.1 → winrt_runtime-4.0.2}/src/objects.cpp

@@ -179,10 +179,9 @@ namespace py::interp
             throw python_exception();
         }
 
-        auto const abi = abi_of(obj);
+        auto const abi = instance_abi(obj);
         if (!abi)
         {
-            PyErr_SetString(PyExc_RuntimeError, "the object holds nothing");
             throw python_exception();
         }
 
@@ -215,6 +214,20 @@ namespace py::interp
         return result;
     }
 
+    /**
+     * Says that @p self holds no WinRT object, as an instance of a Python
+     * class derived from a composable one does until its __init__() has
+     * composed it.
+     */
+    void set_not_composed_error(PyObject* self) noexcept
+    {
+        PyErr_Format(
+            PyExc_RuntimeError,
+            "'%s' object holds no WinRT object until its __init__() calls "
+            "super().__init__()",
+            Py_TYPE(self)->tp_name);
+    }
+
     namespace
     {
         void release_interface_capsule(PyObject* capsule) noexcept
@@ -298,21 +311,75 @@ namespace py::interp
             return nullptr;
         }
 
+        int class_init(PyObject* self, PyObject* args, PyObject* kwds) noexcept;
+
+        /**
+         * Composes @p self, an instance of a Python class derived from the
+         * composable class @p info that holds nothing yet, with the
+         * constructor overload that takes @p args.
+         */
+        bool compose_with(PyObject* self, type_entry& info, PyObject* args) noexcept
+        {
+            auto const overload
+                = select_overload(*info.constructor, PyTuple_GET_SIZE(args));
+
+            if (!overload)
+            {
+                return false;
+            }
+
+            return compose_into(
+                self,
+                info,
+                *info.constructor,
+                *overload,
+                tuple_items(args),
+                PyTuple_GET_SIZE(args));
+        }
+
         PyObject* class_new(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
         {
+            auto const info = class_entry_of(type);
+
+            // A Python class with an __init__ of its own takes the arguments
+            // that __init__ declares, as any Python class does, so it is
+            // class_init(), which its __init__ reaches through super(), that
+            // composes it, with the arguments given there, or else
+            // compose_after_init(), with the arguments of the call, once
+            // __init__ has returned without doing so.
+            if (info && type != info->py_type && type->tp_init != class_init)
+            {
+                return type->tp_alloc(type, 0);
+            }
+
             if (kwds && PyDict_GET_SIZE(kwds) != 0)
             {
                 set_invalid_kwd_args_error();
                 return nullptr;
             }
 
-            auto const info = class_entry_of(type);
             if (!info || !info->constructor)
             {
                 set_invalid_activation_error(info ? info->winrt_name : type->tp_name);
                 return nullptr;
             }
 
+            if (type != info->py_type)
+            {
+                pyobj_handle self{type->tp_alloc(type, 0)};
+                if (!self)
+                {
+                    return nullptr;
+                }
+
+                if (!compose_with(self.get(), *info, args))
+                {
+                    return nullptr;
+                }
+
+                return self.detach();
+            }
+
             auto const overload
                 = select_overload(*info->constructor, PyTuple_GET_SIZE(args));
 
@@ -321,17 +388,6 @@ namespace py::interp
                 return nullptr;
             }
 
-            if (type != info->py_type)
-            {
-                return make_composed_object(
-                    type,
-                    *info,
-                    *info->constructor,
-                    *overload,
-                    tuple_items(args),
-                    PyTuple_GET_SIZE(args));
-            }
-
             if (overload->is_protected)
             {
                 PyErr_Format(
@@ -350,6 +406,48 @@ namespace py::interp
                 PyTuple_GET_SIZE(args));
         }
 
+        /**
+         * __init__() of a composable class. The arguments of a call to the
+         * class went to the constructor already, in class_new(), unless the
+         * class called is a Python one with an __init__ of its own, which
+         * calls this one through super() with the arguments for the
+         * constructor instead.
+         */
+        int class_init(PyObject* self, PyObject* args, PyObject* kwds) noexcept
+        {
+            auto* const type = Py_TYPE(self);
+
+            if (type->tp_init == class_init)
+            {
+                return 0;
+            }
+
+            if (abi_of(self))
+            {
+                PyErr_Format(
+                    PyExc_TypeError,
+                    "'%s' object is already composed into a WinRT object, so "
+                    "it cannot be initialized again",
+                    type->tp_name);
+                return -1;
+            }
+
+            if (kwds && PyDict_GET_SIZE(kwds) != 0)
+            {
+                set_invalid_kwd_args_error();
+                return -1;
+            }
+
+            auto const info = class_entry_of(type);
+            if (!info || !info->constructor)
+            {
+                set_invalid_activation_error(info ? info->winrt_name : type->tp_name);
+                return -1;
+            }
+
+            return compose_with(self, *info, args) ? 0 : -1;
+        }
+
         /**
          * Refuses @p cls as a type a WinRT object can be seen as.
          * @returns nullptr, for the caller to return.
@@ -548,6 +646,82 @@ namespace py::interp
             {}};
     } // namespace
 
+    /**
+     * Composes @p self, an instance of a Python class derived from a
+     * composable one whose __init__() has returned without composing it, with
+     * the arguments of the call, @p args and @p kwds, as class_new() composes
+     * an instance of a class without an __init__ of its own. An object that
+     * is composed already, or that is no such instance, is left as it is.
+     *
+     * @returns @c true, or @c false with a Python error set.
+     */
+    bool compose_after_init(PyObject* self, PyObject* args, PyObject* kwds) noexcept
+    {
+        auto* const type = Py_TYPE(self);
+
+        auto const info = class_entry_of(type);
+        if (!info)
+        {
+            return true;
+        }
+
+        if (info->category != table::category::class_)
+        {
+            return true;
+        }
+
+        if (type == info->py_type)
+        {
+            return true;
+        }
+
+        if (abi_of(self))
+        {
+            return true;
+        }
+
+        if (kwds && PyDict_GET_SIZE(kwds) != 0)
+        {
+            PyErr_Format(
+                PyExc_TypeError,
+                "%s.__init__() did not call super().__init__(), and a call with "
+                "keyword arguments fits no constructor of '%s'",
+                type->tp_name,
+                info->winrt_name);
+            return false;
+        }
+
+        if (!info->constructor)
+        {
+            set_invalid_activation_error(info->winrt_name);
+            return false;
+        }
+
+        auto const overload
+            = select_overload(*info->constructor, PyTuple_GET_SIZE(args));
+
+        if (!overload)
+        {
+            PyErr_Clear();
+            PyErr_Format(
+                PyExc_TypeError,
+                "%s.__init__() did not call super().__init__(), and a call with "
+                "%zd arguments fits no constructor of '%s'",
+                type->tp_name,
+                PyTuple_GET_SIZE(args),
+                info->winrt_name);
+            return false;
+        }
+
+        return compose_into(
+            self,
+            *info,
+            *info->constructor,
+            *overload,
+            tuple_items(args),
+            PyTuple_GET_SIZE(args));
+    }
+
     /**
      * Creates the Python type of an interface, and the abstract type its public
      * name is bound to.
@@ -793,6 +967,11 @@ namespace py::interp
         }
 
         slots.push_back({Py_tp_new, reinterpret_cast<void*>(class_new)});
+
+        if (composable)
+        {
+            slots.push_back({Py_tp_init, reinterpret_cast<void*>(class_init)});
+        }
         slots.push_back(
             {Py_tp_getset,
              reinterpret_cast<void*>(keep_getsets(proj, collected.instance_getsets))});

{winrt_runtime-4.0.1 → winrt_runtime-4.0.2}/src/objects.h

@@ -29,6 +29,27 @@ namespace py::interp
         return *reinterpret_cast<void**>(reinterpret_cast<uint8_t*>(self) + abi_offset);
     }
 
+    void set_not_composed_error(PyObject* self) noexcept;
+
+    /**
+     * The ABI pointer @p self holds, to call an instance member on, or
+     * @c nullptr with a Python error set when it holds none, which an instance
+     * of a Python class derived from a composable one does until its
+     * __init__() has called the WinRT class's.
+     */
+    inline void* instance_abi(PyObject* self) noexcept
+    {
+        auto const abi = abi_of(self);
+        if (!abi)
+        {
+            set_not_composed_error(self);
+        }
+
+        return abi;
+    }
+
+    bool compose_after_init(PyObject* self, PyObject* args, PyObject* kwds) noexcept;
+
     /**
      * The name every interface pointer capsule carries. A capsule of this
      * name holds one reference to a COM interface, which its destructor

{winrt_runtime-4.0.1 → winrt_runtime-4.0.2}/src/protocols.cpp

@@ -68,13 +68,19 @@ namespace py::interp
                 return nullptr;
             }
 
+            auto const abi = instance_abi(self);
+            if (!abi)
+            {
+                return nullptr;
+            }
+
             auto const overload = select_overload(*member, nargs);
             if (!overload)
             {
                 return nullptr;
             }
 
-            return call_member(*member, *overload, abi_of(self), args, nargs);
+            return call_member(*member, *overload, abi, args, nargs);
         }
 
         /**
@@ -168,6 +174,12 @@ namespace py::interp
                 return nullptr;
             }
 
+            auto const abi = instance_abi(self);
+            if (!abi)
+            {
+                return nullptr;
+            }
+
             // A WinRT vector counts its elements in a uint32_t, so there is
             // nothing to ask it for outside that range. CPython has already
             // added the length to a negative index given to this slot, and
@@ -190,10 +202,7 @@ namespace py::interp
             bool direct{};
 
             auto* const direct_item = call_indexed(
-                info->protocol.get_at,
-                abi_of(self),
-                static_cast<uint32_t>(index),
-                direct);
+                info->protocol.get_at, abi, static_cast<uint32_t>(index), direct);
 
             if (direct)
             {
@@ -1171,8 +1180,14 @@ namespace py::interp
          */
         winrt::Windows::Foundation::IInspectable object_of(PyObject* self)
         {
+            auto const abi = instance_abi(self);
+            if (!abi)
+            {
+                throw python_exception();
+            }
+
             winrt::Windows::Foundation::IInspectable object;
-            winrt::copy_from_abi(object, abi_of(self));
+            winrt::copy_from_abi(object, abi);
             return object;
         }
 

winrt_runtime-4.0.2/version.txt

@@ -0,0 +1 @@
+4.0.2

winrt_runtime-4.0.1/version.txt

@@ -1 +0,0 @@
-4.0.1