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

{winrt_runtime-4.0.2/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.2
+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.2 → 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.2
+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.2 → 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.2 → 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.2 → 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;
             }
 
@@ -505,7 +503,7 @@ namespace py::cpp::_winrt
 
         // 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)
+        if (!py::interp::held_abi(reinterpret_cast<PyObject*>(self)))
         {
             Py_RETURN_NOTIMPLEMENTED;
         }
@@ -522,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.2 → winrt_runtime-4.0.3}/src/compose.cpp

@@ -923,15 +923,14 @@ namespace py::interp
     }
 
     /**
-     * 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.
+     * 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 @c true, or @c false with a Python error set and @p self left
-     * holding nothing.
+     * @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.
      */
-    bool compose_into(
+    bool compose_claimed(
         PyObject* self,
         type_entry& entry,
         member_desc const& constructor,
@@ -1103,4 +1102,42 @@ namespace py::interp
 
         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 true;
+    }
 } // namespace py::interp

{winrt_runtime-4.0.2 → 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.2 → 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.2 → 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.2 → winrt_runtime-4.0.3}/src/objects.cpp

@@ -228,6 +228,19 @@ namespace py::interp
             Py_TYPE(self)->tp_name);
     }
 
+    /**
+     * Says that @p self is composed already, or is being composed on another
+     * thread, so cannot be composed again.
+     */
+    void set_already_composed_error(PyObject* self) noexcept
+    {
+        PyErr_Format(
+            PyExc_TypeError,
+            "'%s' object is already composed into a WinRT object, so it cannot "
+            "be initialized again",
+            Py_TYPE(self)->tp_name);
+    }
+
     namespace
     {
         void release_interface_capsule(PyObject* capsule) noexcept
@@ -424,11 +437,7 @@ namespace py::interp
 
             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);
+                set_already_composed_error(self);
                 return -1;
             }
 

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

@@ -29,17 +29,37 @@ namespace py::interp
         return *reinterpret_cast<void**>(reinterpret_cast<uint8_t*>(self) + abi_offset);
     }
 
+    /**
+     * What abi_of() holds while compose_into() is composing the object, which
+     * is a call into WinRT that another thread can run during: not a pointer,
+     * so that the thread that holds it is the only one composing, and the
+     * object holds nothing yet to every other.
+     */
+    inline void* const composing_abi = reinterpret_cast<void*>(1);
+
+    /**
+     * The ABI pointer @p self holds, or @c nullptr 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, and while that call is
+     * under way.
+     */
+    inline void* held_abi(PyObject* self) noexcept
+    {
+        auto const abi = abi_of(self);
+        return abi == composing_abi ? nullptr : abi;
+    }
+
     void set_not_composed_error(PyObject* self) noexcept;
 
+    void set_already_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.
+     * @c nullptr with a Python error set when it holds none.
      */
     inline void* instance_abi(PyObject* self) noexcept
     {
-        auto const abi = abi_of(self);
+        auto const abi = held_abi(self);
         if (!abi)
         {
             set_not_composed_error(self);

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

@@ -807,13 +807,19 @@ namespace py::interp
                 return nullptr;
             }
 
+            auto const abi = instance_abi(self);
+            if (!abi)
+            {
+                return nullptr;
+            }
+
             // The three members take nothing and hand back one value each, so
             // where the table describes them the way IIterator<T> always does
             // they are called in one crossing rather than three. A table that
             // describes them some other way is answered below.
             bool fused{};
 
-            auto* const item = call_iterator_step(*info, abi_of(self), fused);
+            auto* const item = call_iterator_step(*info, abi, fused);
 
             if (fused)
             {
@@ -1013,7 +1019,11 @@ namespace py::interp
                 return false;
             }
 
-            auto const abi = abi_of(self);
+            auto const abi = instance_abi(self);
+            if (!abi)
+            {
+                return false;
+            }
 
             {
                 auto _gil = release_gil();

winrt_runtime-4.0.3/version.txt

@@ -0,0 +1 @@
+4.0.3

winrt_runtime-4.0.2/version.txt

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