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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winrt-runtime
-Version: 4.0.1
+Version: 4.0.3
 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.3/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.3
 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.3}/python/winrt_runtime.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ src/enums.h
 src/errors.cpp
 src/generics.cpp
 src/generics.h
+src/handles.cpp
 src/implements.cpp
 src/implements.h
 src/interp.cpp

{winrt_runtime-4.0.1 → winrt_runtime-4.0.3}/setup.py

@@ -56,6 +56,7 @@ setup(
                 "src/enums.cpp",
                 "src/errors.cpp",
                 "src/generics.cpp",
+                "src/handles.cpp",
                 "src/implements.cpp",
                 "src/interp.cpp",
                 "src/members.cpp",

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

@@ -184,11 +184,8 @@ namespace py::cpp::_winrt
             }
 
             auto const& guid = *static_cast<winrt::guid const*>(info->guid);
-            auto const& instance
-                = reinterpret_cast<
-                      py::winrt_wrapper<winrt::Windows::Foundation::IUnknown>*>(obj)
-                      ->obj;
-            if (!instance)
+            auto const abi = py::interp::held_abi(obj);
+            if (!abi)
             {
                 Py_RETURN_FALSE;
             }
@@ -201,7 +198,8 @@ namespace py::cpp::_winrt
 
             {
                 auto _gil = py::release_gil();
-                hr = instance.as(guid, queried.put_void());
+                hr = static_cast<::IUnknown*>(abi)->QueryInterface(
+                    guid, queried.put_void());
                 queried = nullptr;
             }
 
@@ -322,9 +320,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 +398,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 +414,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 +501,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 (!py::interp::held_abi(reinterpret_cast<PyObject*>(self)))
+        {
+            Py_RETURN_NOTIMPLEMENTED;
+        }
+
         auto const equal
             = self->obj
               == reinterpret_cast<
@@ -482,6 +520,14 @@ namespace py::cpp::_winrt
     static Py_hash_t Object_hash(
         py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>* self) noexcept
     {
+        // A Python object derived from a composable class holds nothing until
+        // its __init__() has composed it, and hashing it then would give a
+        // hash that changes when it is composed.
+        if (!py::interp::instance_abi(reinterpret_cast<PyObject*>(self)))
+        {
+            return -1;
+        }
+
         return static_cast<Py_hash_t>(
             std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj));
     }

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

@@ -923,21 +923,23 @@ 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, which this thread has claimed by storing composing_abi
+     * in it, 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 with @p self holding the WinRT object, or @c false with
+     * a Python error set and @p self still holding composing_abi.
      */
-    PyObject* make_composed_object(
-        PyTypeObject* type,
+    bool compose_claimed(
+        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 +948,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 +965,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 +1005,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 +1028,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 +1043,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 +1052,7 @@ namespace py::interp
         catch (...)
         {
             to_PyErr();
-            return nullptr;
+            return false;
         }
 
         make_tearoffs(interfaces, outer->head, outer->calls, outer->tearoffs);
@@ -1074,7 +1070,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 +1094,50 @@ namespace py::interp
             catch (...)
             {
                 to_PyErr();
-                return nullptr;
+                return false;
             }
         }
 
-        abi_of(self.get()) = abi;
+        abi_of(self) = abi;
+
+        return true;
+    }
+
+    /**
+     * 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 constructor is a call into WinRT, which another thread can run
+     * during, so the thread that composes claims @p self first, by storing
+     * composing_abi in it, and a second thread's claim fails as a composition
+     * of an object that is composed already.
+     *
+     * @returns @c true, or @c false with a Python error set and @p self left
+     * holding nothing.
+     */
+    bool compose_into(
+        PyObject* self,
+        type_entry& entry,
+        member_desc const& constructor,
+        overload_desc& overload,
+        PyObject* const* args,
+        Py_ssize_t nargs) noexcept
+    {
+        void* expected{};
+
+        if (!std::atomic_ref<void*>{abi_of(self)}.compare_exchange_strong(
+                expected, composing_abi))
+        {
+            set_already_composed_error(self);
+            return false;
+        }
+
+        if (!compose_claimed(self, entry, constructor, overload, args, nargs))
+        {
+            abi_of(self) = nullptr;
+            return false;
+        }
 
-        return self.detach();
+        return true;
     }
 } // namespace py::interp

{winrt_runtime-4.0.1 → winrt_runtime-4.0.3}/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.3}/src/delegates.cpp

@@ -142,10 +142,16 @@ namespace py::interp
                 return nullptr;
             }
 
+            auto const abi = instance_abi(self);
+            if (!abi)
+            {
+                return nullptr;
+            }
+
             return call_member(
                 info->members[0],
                 *overload,
-                abi_of(self),
+                abi,
                 nargs == 0 ? nullptr : &PyTuple_GET_ITEM(args, 0),
                 nargs);
         }

winrt_runtime-4.0.3/src/handles.cpp

@@ -0,0 +1,159 @@
+// The part of handles.h that is not inline: the thread states of threads
+// Python has not seen.
+//
+// WinRT calls back on threads of its own: the thread pool, the thread of a
+// DispatcherQueue made with CreateOnDedicatedThread(), an AudioGraph's audio
+// thread. Attaching from such a thread creates a thread state for it, and the
+// matching release deletes it again, so on its own whatever Python keeps per
+// thread state would last for one callback: a threading.local, the running
+// asyncio loop, the contextvars context. It would also cost a thread state
+// made and cleared on every callback.
+//
+// So the first attach on such a thread makes the thread state with
+// PyGILState_Ensure() and keeps that count of it, and every attach after finds
+// it and reuses it. The count is given back when the thread exits, from a
+// fiber-local storage callback, and the last release clears and deletes the
+// thread state as it would have: nothing is left behind. Unlike a C++
+// thread_local destructor or DLL_THREAD_DETACH, Windows calls FLS callbacks on
+// the exiting thread before it takes the loader lock, so clearing the thread
+// state there, which can run any finalizer, is safe.
+//
+// The thread state is made by PyGILState_Ensure() rather than by
+// PyThreadState_Ensure*() even from 3.15, because a thread state made that way
+// is deleted when its count runs out, and PyThreadState_EnsureFromView()
+// would hold an interpreter guard for as long as the count stayed up, which
+// keeps the interpreter from ever finalizing. PyThreadState_Ensure*() reuses
+// the thread state PyGILState_Ensure() bound to the thread, and lets go of
+// its guard each time.
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#include <Windows.h>
+
+#include <pywinrt/handles.h>
+
+namespace
+{
+    /**
+     * Gives back the count keep_thread_state() kept, on the thread that is
+     * exiting; the release that takes the count to zero clears and deletes
+     * the thread state.
+     */
+    void NTAPI on_thread_exit(void*) noexcept
+    {
+#if PY_VERSION_HEX >= 0x030F0000
+        PyInterpreterView* const view = py::main_interpreter_view();
+        PyInterpreterGuard* const guard
+            = view ? PyInterpreterGuard_FromView(view) : nullptr;
+
+        // Without a guard, the interpreter is finalizing or gone, and deletes
+        // the thread states of all its threads itself.
+        if (!guard)
+        {
+            return;
+        }
+#else
+        if (!Py_IsInitialized() || Py_IsFinalizing())
+        {
+            return;
+        }
+#endif
+
+        // An interpreter initialized again since is not the one the thread
+        // state was kept in, and this thread has none in it.
+        if (PyGILState_GetThisThreadState())
+        {
+            PyGILState_STATE const state = PyGILState_Ensure();
+            // The kept count; the GIL stays held for the release below.
+            PyGILState_Release(PyGILState_LOCKED);
+            PyGILState_Release(state);
+        }
+
+#if PY_VERSION_HEX >= 0x030F0000
+        PyInterpreterGuard_Close(guard);
+#endif
+    }
+
+    /**
+     * The FLS slot whose callback gives the thread state back, or
+     * FLS_OUT_OF_INDEXES. It is never freed: FlsFree() would call the callback
+     * for every thread at once, on the thread that frees it, and the module is
+     * never unloaded.
+     */
+    DWORD fls_index() noexcept
+    {
+        static DWORD const index = FlsAlloc(on_thread_exit);
+        return index;
+    }
+
+    /**
+     * Any value but null, which FLS takes to mean "nothing to clean up".
+     */
+    void* const kept = reinterpret_cast<void*>(1);
+} // namespace
+
+namespace py
+{
+#if PY_VERSION_HEX >= 0x030F0000
+    /**
+     * The main interpreter, for attaching to it from a thread Python has not
+     * seen; @c nullptr if out of memory.
+     */
+    PyInterpreterView* main_interpreter_view() noexcept
+    {
+        // A view does not keep the interpreter from finalizing, so the one
+        // taken on first use serves for as long as the process runs.
+        static PyInterpreterView* const view = PyInterpreterView_FromMain();
+        return view;
+    }
+#endif
+
+    /**
+     * Gives the calling thread, which has no Python thread state, one that
+     * lasts until the thread exits, so that what Python keeps per thread -
+     * threading.local, the running asyncio loop, the contextvars context -
+     * carries over from one WinRT callback to the next. Without it, the thread
+     * state that attaching creates is deleted again when the callback returns.
+     * Call it without the GIL and before attaching.
+     */
+    void keep_thread_state() noexcept
+    {
+        DWORD const index = fls_index();
+
+        if (index == FLS_OUT_OF_INDEXES)
+        {
+            return; // each callback makes its own thread state
+        }
+
+#if PY_VERSION_HEX >= 0x030F0000
+        PyInterpreterView* const view = main_interpreter_view();
+        PyInterpreterGuard* const guard
+            = view ? PyInterpreterGuard_FromView(view) : nullptr;
+
+        if (!guard)
+        {
+            return; // finalizing: the attach that follows fails too
+        }
+#endif
+
+        // Makes the thread state, binds it to the thread and attaches it.
+        PyGILState_STATE const state = PyGILState_Ensure();
+
+        if (FlsSetValue(index, kept))
+        {
+            // Detaches, keeping the count.
+            PyEval_SaveThread();
+        }
+        else
+        {
+            // Deletes the thread state again.
+            PyGILState_Release(state);
+        }
+
+#if PY_VERSION_HEX >= 0x030F0000
+        PyInterpreterGuard_Close(guard);
+#endif
+    }
+} // namespace py

{winrt_runtime-4.0.1 → winrt_runtime-4.0.3}/src/include/pywinrt/handles.h

@@ -10,6 +10,12 @@
 
 namespace py
 {
+#if PY_VERSION_HEX >= 0x030F0000
+    PyInterpreterView* main_interpreter_view() noexcept;
+#endif
+
+    void keep_thread_state() noexcept;
+
     /**
      * Holds the Python GIL for as long as it is in scope, unless the
      * interpreter is being finalized or already has been, in which case it
@@ -27,7 +33,15 @@ namespace py
      * From Python 3.15, PyThreadState_EnsureFromView() (PEP 788) makes the
      * check and the attach one step. Before that they are two, so a thread
      * that passes the check just as another starts finalizing still attaches
-     * to an interpreter that is going away.
+     * to an interpreter that is going away. on_thread_exit() in handles.cpp
+     * takes the same two steps on a thread that is exiting, inside
+     * LdrShutdownThread(), where the attach then hangs the thread (3.14) or
+     * re-enters thread exit (3.12, 3.13). That needs finalization to start
+     * during the thread's exit, a window of milliseconds.
+     *
+     * On a thread Python has not seen, which is most threads WinRT calls back
+     * on, the guard first gives the thread a thread state of its own: see
+     * keep_thread_state().
      */
     struct gil_guard
     {
@@ -55,15 +69,18 @@ namespace py
       private:
         static PyThreadStateToken* attach() noexcept
         {
-            // A view does not keep the interpreter from finalizing, so the one
-            // taken on first use serves for as long as the process runs.
-            static PyInterpreterView* const view = PyInterpreterView_FromMain();
+            PyInterpreterView* const view = main_interpreter_view();
 
             if (!view)
             {
                 return nullptr;
             }
 
+            if (!PyGILState_GetThisThreadState())
+            {
+                keep_thread_state();
+            }
+
             return PyThreadState_EnsureFromView(view);
         }
 
@@ -80,6 +97,11 @@ namespace py
         {
             if (m_held)
             {
+                if (!PyGILState_GetThisThreadState())
+                {
+                    keep_thread_state();
+                }
+
                 m_state = PyGILState_Ensure();
             }
         }

{winrt_runtime-4.0.1 → winrt_runtime-4.0.3}/src/interp.cpp

@@ -352,7 +352,7 @@ namespace py::interp
             }
 
             winrt::Windows::Foundation::IUnknown object;
-            winrt::copy_from_abi(object, abi_of(value));
+            winrt::copy_from_abi(object, held_abi(value));
             if (!object)
             {
                 // The conversion says the object holds nothing.

{winrt_runtime-4.0.1 → winrt_runtime-4.0.3}/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;
         }