winrt-runtime 2.0.1__tar.gz → 2.2.0__tar.gz

{winrt_runtime-2.0.1 → winrt_runtime-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: winrt-runtime
-Version: 2.0.1
+Version: 2.2.0
 Summary: Python projection of Windows Runtime (WinRT) APIs
 License: MIT
 Project-URL: Documentation, https://pywinrt.readthedocs.io
@@ -10,7 +10,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Intended Audience :: Developers
-Requires-Python: <3.13,>=3.9
+Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 
 # winrt-runtime

winrt_runtime-2.2.0/_winrt.cpp

@@ -0,0 +1,592 @@
+// must be included before winrt to avoid compile errors
+#include <Shobjidl.h>
+#include <libloaderapi.h>
+
+#define PYWINRT_RUNTIME_MODULE
+#include "pybase.h"
+#include "pyruntime.h"
+#include <winrt/base.h>
+
+namespace py::cpp::_winrt
+{
+    // BEGIN: class _winrt.Object:
+
+    static constexpr const char* const type_name_Object = "Object";
+
+    PyDoc_STRVAR(Object_doc, "base class for wrapped WinRT object instances.");
+
+    static PyObject* Object_new(
+        PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
+    {
+        py::set_invalid_activation_error(type_name_Object);
+        return nullptr;
+    }
+
+    static void Object_dealloc(
+        py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    PyDoc_STRVAR(
+        Object_iids_doc,
+        "Gets the interfaces that are implemented by the current Windows Runtime class.");
+
+    static PyObject* Object_iids_get(
+        py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>* self,
+        void* /*unused*/) noexcept
+    {
+        try
+        {
+            auto name = winrt::get_interfaces(self->obj);
+            return convert(name);
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    PyDoc_STRVAR(
+        Object_runtime_class_name_doc,
+        "Gets the fully qualified name of the current Windows Runtime object.");
+
+    static PyObject* Object_runtime_class_name_get(
+        py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>* self,
+        void* /*unused*/) noexcept
+    {
+        try
+        {
+            auto name = winrt::get_class_name(self->obj);
+            return convert(name);
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyGetSetDef Object_getset[]
+        = {{"_iids_",
+            reinterpret_cast<getter>(Object_iids_get),
+            nullptr,
+            Object_iids_doc,
+            nullptr},
+           {"_runtime_class_name_",
+            reinterpret_cast<getter>(Object_runtime_class_name_get),
+            nullptr,
+            Object_runtime_class_name_doc,
+            nullptr},
+           {}};
+
+    static PyType_Slot Object_type_slots[]
+        = {{Py_tp_doc, const_cast<char*>(Object_doc)},
+           {Py_tp_new, reinterpret_cast<void*>(Object_new)},
+           {Py_tp_dealloc, reinterpret_cast<void*>(Object_dealloc)},
+           {Py_tp_getset, reinterpret_cast<void*>(Object_getset)},
+           {}};
+
+    static PyType_Spec Object_type_spec
+        = {"_winrt.Object",
+           sizeof(py::winrt_wrapper<winrt::Windows::Foundation::IUnknown>),
+           0,
+           Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+           Object_type_slots};
+
+    // END: class _winrt.Object:
+
+    // BEGIN: class _winrt.Array:
+
+    extern PyType_Spec Array_type_spec;
+
+    // END: class _winrt.Array:
+
+    // BEGIN: class _winrt.MappingIter:
+
+    // This class is used to wrap the iterator returned by IMap/IMapView so
+    // that it returns only the key instead of a KeyValuePair. This is done
+    // to be consistent with the Python mapping protocol.
+    //
+    // In Python it would look something like this:
+    //
+    //  class MappingIter:
+    //      def  __init__(self, base_iter):
+    //          self._iter = iter(base_iter)
+    //
+    //      def __iter__(self):
+    //          return self
+    //
+    //      def __next__(self):
+    //          return next(self._iter).key
+    //
+
+    struct MappingIter_object
+    {
+        PyObject_HEAD;
+        PyObject* _iter;
+        PyObject* _key;
+    };
+
+    static PyMemberDef MappingIter_members[]
+        = {{"_iter",
+            T_OBJECT_EX,
+            offsetof(MappingIter_object, _iter),
+            0,
+            PyDoc_STR("base KeyValuePair iterator")},
+           {"_key", T_OBJECT, offsetof(MappingIter_object, _key), 0, nullptr},
+           {}};
+
+    static int MappingIter_init(PyObject* self, PyObject* args, PyObject* kwds) noexcept
+    {
+        if (kwds)
+        {
+            PyErr_SetString(PyExc_TypeError, "keyword arguments are not supported");
+            return -1;
+        }
+
+        // borrowed ref
+        auto base_iter = PyTuple_GetItem(args, 0);
+
+        if (!base_iter)
+        {
+            return -1;
+        }
+
+        if (!PyIter_Check(base_iter))
+        {
+            PyErr_SetString(PyExc_TypeError, "expecting an iterator");
+            return -1;
+        }
+
+        if (PyObject_SetAttrString(self, "_iter", base_iter) == -1)
+        {
+            return -1;
+        }
+
+        py::pyobj_handle key{PyUnicode_FromString("key")};
+        if (!key)
+        {
+            return -1;
+        }
+
+        if (PyObject_SetAttrString(self, "_key", key.get()) == -1)
+        {
+            return -1;
+        }
+
+        return 0;
+    }
+
+    static PyObject* MappingIter_iternext(MappingIter_object* self) noexcept
+    {
+        if (!self->_iter)
+        {
+            PyErr_SetString(PyExc_RuntimeError, "_iter was deleted");
+            return nullptr;
+        }
+
+        py::pyobj_handle next{PyIter_Next(self->_iter)};
+        if (!next)
+        {
+            return nullptr;
+        }
+
+        if (!self->_key)
+        {
+            PyErr_SetString(PyExc_RuntimeError, "_key was deleted");
+            return nullptr;
+        }
+
+        py::pyobj_handle key{PyObject_GetAttr(next.get(), self->_key)};
+        if (!key)
+        {
+            return nullptr;
+        }
+
+        return key.detach();
+    }
+
+    PyDoc_STRVAR(MappingIter_doc, "Utility class for wrapping KeyValuePair iterators.");
+
+    static PyType_Slot MappingIter_type_slots[] = {
+        {Py_tp_members, reinterpret_cast<void*>(MappingIter_members)},
+        {Py_tp_init, reinterpret_cast<void*>(MappingIter_init)},
+        {Py_tp_iter, reinterpret_cast<void*>(PyObject_SelfIter)},
+        {Py_tp_iternext, reinterpret_cast<void*>(MappingIter_iternext)},
+        {Py_tp_doc, const_cast<char*>(MappingIter_doc)},
+        {},
+    };
+
+    static PyType_Spec MappingIter_type_spec
+        = {"_winrt.MappingIter",
+           sizeof(MappingIter_object),
+           0,
+           Py_TPFLAGS_DEFAULT,
+           MappingIter_type_slots};
+
+    // END: class _winrt.MappingIter:
+
+    static const py::runtime_api runtime_api{
+        .runtime_api_guid = py::runtime_api_guid,
+        .abi_version_major = py::runtime_abi_version_major,
+        .abi_version_minor = py::runtime_abi_version_minor,
+        .register_python_type = py::register_python_type,
+        .get_python_type = py::get_python_type,
+        .wrap_mapping_iter = py::wrap_mapping_iter,
+        .is_buffer_compatible = py::is_buffer_compatible,
+        .convert_datetime = py::convert_datetime,
+        .convert_to_datetime = py::convert_to_datetime,
+        .convert_guid = py::convert_guid,
+        .convert_to_guid = py::convert_to_guid,
+        .get_object_type = py::get_object_type,
+        .array_new = py::cpp::_winrt::Array_New,
+        .array_assign = &py::cpp::_winrt::Array_Assign,
+    };
+
+    static PyObject* init_apartment(PyObject* /*unused*/, PyObject* type_obj) noexcept
+    {
+        auto type = PyLong_AsLong(type_obj);
+
+        if (type == -1 && PyErr_Occurred())
+        {
+            return nullptr;
+        }
+
+        try
+        {
+            winrt::init_apartment(static_cast<winrt::apartment_type>(type));
+            Py_RETURN_NONE;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* uninit_apartment(
+        PyObject* /*unused*/, PyObject* /*unused*/) noexcept
+    {
+        winrt::uninit_apartment();
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* initialize_with_window(
+        PyObject* /*unused*/, PyObject* args) noexcept
+    {
+        PyObject* obj;
+        Py_ssize_t hwnd;
+
+        if (!PyArg_ParseTuple(args, "On", &obj, &hwnd))
+        {
+            return nullptr;
+        }
+
+        try
+        {
+            auto winrt_obj
+                = py::convert_to<winrt::Windows::Foundation::IInspectable>(obj);
+            auto result = winrt_obj.as<IInitializeWithWindow>()->Initialize(
+                reinterpret_cast<HWND>(hwnd));
+
+            if (result != S_OK)
+            {
+                winrt::throw_hresult(result);
+            }
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* add_dll_directory(PyObject* /*unused*/, PyObject* obj) noexcept
+    {
+        std::unique_ptr<wchar_t, decltype(&PyMem_Free)> path{
+            PyUnicode_AsWideCharString(obj, nullptr), &PyMem_Free};
+
+        if (!path)
+        {
+            return nullptr;
+        }
+
+        auto cookie = AddDllDirectory(path.get());
+
+        if (!cookie)
+        {
+            PyErr_SetFromWindowsErr(GetLastError());
+            return nullptr;
+        }
+
+        return PyLong_FromVoidPtr(cookie);
+    }
+
+    static PyObject* remove_dll_directory(PyObject* /*unused*/, PyObject* obj) noexcept
+    {
+        auto cookie = PyLong_AsVoidPtr(obj);
+        if (!cookie && PyErr_Occurred())
+        {
+            return nullptr;
+        }
+
+        if (!RemoveDllDirectory(cookie))
+        {
+            PyErr_SetFromWindowsErr(GetLastError());
+            return nullptr;
+        }
+
+        Py_RETURN_NONE;
+    }
+
+    /**
+     * Equivalent to functools.cache(functools.partial(uuid.UUID, None))
+     *
+     * This is a performance optimization since the UUID constructor is expensive.
+     */
+    static PyObject* wrap_uuid_constructor() noexcept
+    {
+        pyobj_handle uuid_module{PyImport_ImportModule("uuid")};
+        if (!uuid_module)
+        {
+            return nullptr;
+        }
+
+        pyobj_handle uuid_type{PyObject_GetAttrString(uuid_module.get(), "UUID")};
+        if (!uuid_type)
+        {
+            return nullptr;
+        }
+
+        pyobj_handle functools_module{PyImport_ImportModule("functools")};
+        if (!functools_module)
+        {
+            return nullptr;
+        }
+
+        pyobj_handle partial_func{
+            PyObject_GetAttrString(functools_module.get(), "partial")};
+        if (!partial_func)
+        {
+            return nullptr;
+        }
+
+        pyobj_handle partial_uuid_func{PyObject_CallFunctionObjArgs(
+            partial_func.get(), uuid_type.get(), Py_None, nullptr)};
+        if (!partial_uuid_func)
+        {
+            return nullptr;
+        }
+
+        // REVISIT: we could probably implement a cache function in C++ that
+        // would even more performant
+        pyobj_handle cache_func{
+            PyObject_GetAttrString(functools_module.get(), "cache")};
+        if (!cache_func)
+        {
+            return nullptr;
+        }
+
+        return PyObject_CallOneArg(cache_func.get(), partial_uuid_func.get());
+    }
+
+    static int module_traverse(PyObject* module, visitproc visit, void* arg) noexcept
+    {
+        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
+
+        Py_VISIT(state->object_type);
+        Py_VISIT(state->array_type);
+        Py_VISIT(state->mapping_iter_type);
+        Py_VISIT(state->to_uuid_func);
+
+        for (const auto& [key, value] : state->type_cache)
+        {
+            Py_VISIT(value);
+        }
+
+        return 0;
+    }
+
+    static int module_clear(PyObject* module) noexcept
+    {
+        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
+
+        Py_CLEAR(state->object_type);
+        Py_CLEAR(state->array_type);
+        Py_CLEAR(state->mapping_iter_type);
+        Py_CLEAR(state->to_uuid_func);
+
+        auto type_cache = std::move(state->type_cache);
+
+        for (auto& [key, value] : type_cache)
+        {
+            Py_XDECREF(value);
+        }
+
+        return 0;
+    }
+
+    static void module_free(PyObject* module) noexcept
+    {
+        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
+
+        Py_XDECREF(state->object_type);
+        Py_XDECREF(state->array_type);
+        Py_XDECREF(state->mapping_iter_type);
+        Py_XDECREF(state->to_uuid_func);
+
+        for (auto& [key, value] : state->type_cache)
+        {
+            Py_XDECREF(value);
+        }
+
+        std::destroy_at(&state->type_cache);
+    }
+
+    PyDoc_STRVAR(module_doc, "_winrt");
+
+    static PyMethodDef module_methods[]{
+        {"init_apartment", init_apartment, METH_O, "initialize the apartment"},
+        {"uninit_apartment",
+         uninit_apartment,
+         METH_NOARGS,
+         PyDoc_STR("uninitialize the apartment")},
+        {"initialize_with_window",
+         initialize_with_window,
+         METH_VARARGS,
+         PyDoc_STR(
+             "interop function to invoke IInitializeWithWindow::Initialize on an object")},
+        {"_add_dll_directory",
+         add_dll_directory,
+         METH_O,
+         PyDoc_STR("Adds a directory to the DLL search path.")},
+        {"_remove_dll_directory",
+         remove_dll_directory,
+         METH_O,
+         PyDoc_STR(
+             "Removes a directory that was added to the process DLL search path by using _add_dll_directory.")},
+        {}};
+
+    static PyModuleDef module_def
+        = {PyModuleDef_HEAD_INIT,
+           "_winrt",
+           module_doc,
+           sizeof(module_state),
+           module_methods,
+           nullptr,
+           module_traverse,
+           module_clear,
+           reinterpret_cast<freefunc>(module_free)};
+
+    static PyObject* module_init() noexcept
+    {
+        static const auto kMTA
+            = static_cast<long>(winrt::apartment_type::multi_threaded);
+        static const auto kSTA
+            = static_cast<long>(winrt::apartment_type::single_threaded);
+
+        py::pyobj_handle module{PyModule_Create(&module_def)};
+        if (!module)
+        {
+            return nullptr;
+        }
+
+        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module.get()));
+        std::construct_at(&state->type_cache);
+
+        py::pytype_handle object_type{py::register_python_type(
+            module.get(), &Object_type_spec, nullptr, nullptr)};
+        if (!object_type)
+        {
+            return nullptr;
+        }
+
+        py::pytype_handle array_type{
+            py::register_python_type(module.get(), &Array_type_spec, nullptr, nullptr)};
+        if (!array_type)
+        {
+            return nullptr;
+        }
+
+        py::pytype_handle mapping_iter_type{py::register_python_type(
+            module.get(), &MappingIter_type_spec, nullptr, nullptr)};
+        if (!mapping_iter_type)
+        {
+            return nullptr;
+        }
+
+        pyobj_handle runtime_api_capsule{PyCapsule_New(
+            const_cast<py::runtime_api*>(&runtime_api),
+            "winrt._winrt._C_API",
+            nullptr)};
+
+        if (!runtime_api_capsule)
+        {
+            return nullptr;
+        }
+
+        if (PyModule_AddObjectRef(module.get(), "_C_API", runtime_api_capsule.get())
+            == -1)
+        {
+            return nullptr;
+        }
+
+        if (PyModule_AddIntConstant(module.get(), "MTA", kMTA) == -1)
+        {
+            return nullptr;
+        }
+
+        if (PyModule_AddIntConstant(module.get(), "STA", kSTA) == -1)
+        {
+            return nullptr;
+        }
+
+        pyobj_handle to_uuid_func{wrap_uuid_constructor()};
+        if (!to_uuid_func)
+        {
+            return nullptr;
+        }
+
+        state->object_type = object_type.detach();
+        state->array_type = array_type.detach();
+        state->mapping_iter_type = mapping_iter_type.detach();
+        state->to_uuid_func = to_uuid_func.detach();
+
+        return module.detach();
+    }
+} // namespace py::cpp::_winrt
+
+PyMODINIT_FUNC PyInit__winrt(void) noexcept
+{
+    return py::cpp::_winrt::module_init();
+}
+
+py::cpp::_winrt::module_state* py::cpp::_winrt::get_module_state() noexcept
+{
+    auto module = PyState_FindModule(&py::cpp::_winrt::module_def);
+    if (!module)
+    {
+        return nullptr;
+    }
+
+    return reinterpret_cast<py::cpp::_winrt::module_state*>(PyModule_GetState(module));
+}
+
+PyTypeObject* py::get_object_type() noexcept
+{
+    auto state = py::cpp::_winrt::get_module_state();
+    if (!state)
+    {
+        return nullptr;
+    }
+
+    return state->object_type;
+}

{winrt_runtime-2.0.1 → winrt_runtime-2.2.0}/_winrt_array.cpp

@@ -1,5 +1,6 @@
 #define PYWINRT_RUNTIME_MODULE
 #include "pybase.h"
+#include "pyruntime.h"
 #include "py.Windows.Foundation.h"
 #include <winrt/base.h>
 
@@ -538,36 +539,13 @@ namespace py::cpp::_winrt
 
     static PyTypeObject* get_array_type() noexcept
     {
-        py::pyobj_handle system_module{PyImport_ImportModule("winrt.system")};
-
-        if (!system_module)
-        {
-            return nullptr;
-        }
-
-        py::pyobj_handle array_type{
-            PyObject_GetAttrString(system_module.get(), "Array")};
-
-        if (!array_type)
-        {
-            return nullptr;
-        }
-
-        if (!PyType_Check(array_type.get()))
-        {
-            PyErr_SetString(
-                PyExc_TypeError, "winrt.system.Array is not a type object!");
-            return nullptr;
-        }
-
-        if (reinterpret_cast<PyTypeObject*>(array_type.get())->tp_new != Array_tp_new)
+        auto state = py::cpp::_winrt::get_module_state();
+        if (!state)
         {
-            PyErr_SetString(
-                PyExc_TypeError, "winrt.system.Array is not the expected type!");
             return nullptr;
         }
 
-        return reinterpret_cast<PyTypeObject*>(array_type.get());
+        return state->array_type;
     }
 
 } // namespace py::cpp::_winrt

{winrt_runtime-2.0.1 → winrt_runtime-2.2.0}/pyproject.toml

@@ -16,7 +16,7 @@ classifiers = [
     "Intended Audience :: Developers",
 ]
 dynamic = ["version"]
-requires-python = ">=3.9,<3.13"
+requires-python = ">=3.9,<3.14"
 
 [project.urls]
 # Homepage = "https://github.com/pywinrt/pywinrt"
@@ -37,7 +37,8 @@ where = ["src"]
 # use local winrt-sdk build dependency
 environment = { PYTHONPATH="../winrt-sdk/src" }
 # don't install winrt-sdk from PyPI
-build-frontend = { name = "build", args = ["--skip-dependency-check", "--no-isolation"] }
+build-frontend = { name = "build[uv]", args = ["--skip-dependency-check", "--no-isolation"] }
+before-build = "uv pip install setuptools"
 # don't build for PyPy
 skip = "pp*"
 # suppress warnings about ARM64 testing
@@ -45,4 +46,4 @@ test-skip = "*-win_arm64"
 
 [tool.cibuildwheel.windows]
 archs = ["x86", "AMD64", "ARM64"]
-repair-wheel-command = "python scripts/add_dlls.py {wheel} {dest_dir}"
+repair-wheel-command = "python scripts/add_msvcp140_dll.py {wheel} {dest_dir}"

winrt_runtime-2.2.0/pywinrt-version.txt

@@ -0,0 +1 @@
+2.2.0

{winrt_runtime-2.0.1 → winrt_runtime-2.2.0}/runtime.cpp

@@ -6,6 +6,7 @@
 
 #define PYWINRT_RUNTIME_MODULE
 #include "pybase.h"
+#include "pyruntime.h"
 
 // "backport" of Python 3.12 function.
 #if PY_VERSION_HEX < 0x030C0000
@@ -168,30 +169,93 @@ static PyObject* PyType_FromMetaclass(
  * @param base_type The base type, a tuple of base types or nullptr to use the base
  * slot.
  * @param metaclass Optional metaclass for the type.
- * @returns 0 on success or -1 on error.
+ * @returns New reference on success or nullptr on error.
  */
 
-int py::register_python_type(
+PyTypeObject* py::register_python_type(
     PyObject* module,
     PyType_Spec* type_spec,
     PyObject* base_type,
     PyTypeObject* metaclass) noexcept
 {
-    py::pyobj_handle type_object{
-        PyType_FromMetaclass(metaclass, module, type_spec, base_type)};
+    py::pytype_handle type_object{reinterpret_cast<PyTypeObject*>(
+        PyType_FromMetaclass(metaclass, module, type_spec, base_type))};
 
     if (!type_object)
     {
-        return -1;
+        return nullptr;
+    }
+
+    if (PyModule_AddType(module, type_object.get()) == -1)
+    {
+        return nullptr;
+    }
+
+    return type_object.detach();
+}
+
+PyTypeObject* py::get_python_type(std::string_view qualified_name) noexcept
+{
+    auto state = py::cpp::_winrt::get_module_state();
+    if (!state)
+    {
+        return nullptr;
+    }
+
+    auto it = state->type_cache.find(qualified_name);
+    if (it != state->type_cache.end())
+    {
+        return it->second;
+    }
+
+    auto pos = qualified_name.find_last_of('.');
+    if (pos == std::string_view::npos)
+    {
+        PyErr_Format(
+            PyExc_ValueError, "invalid qualified name: %s", qualified_name.data());
+        return nullptr;
+    }
+
+    std::string module_name{qualified_name.substr(0, pos)};
+    std::string type_name{qualified_name.substr(pos + 1)};
+
+    pyobj_handle module{PyImport_ImportModule(module_name.c_str())};
+    if (!module)
+    {
+        return nullptr;
+    }
+
+    pyobj_handle type{PyObject_GetAttrString(module.get(), type_name.c_str())};
+    if (!type)
+    {
+        return nullptr;
     }
 
-    if (PyModule_AddType(module, reinterpret_cast<PyTypeObject*>(type_object.get()))
-        == -1)
+    if (!PyType_Check(type.get()))
+    {
+        PyErr_Format(
+            PyExc_TypeError,
+            "'%s.%s' is not a type",
+            module_name.c_str(),
+            type_name.c_str());
+        return nullptr;
+    }
+
+    // TODO: verify that the Python type is compatible with the winrt
+    // runtime module version and that it actually matches the C++ type
+
+    try
+    {
+        state->type_cache[qualified_name]
+            = reinterpret_cast<PyTypeObject*>(Py_NewRef(type.get()));
+    }
+    catch (...)
     {
-        return -1;
+        to_PyErr();
+        return nullptr;
     }
 
-    return 0;
+    return reinterpret_cast<PyTypeObject*>(type.get());
 }
 
 /**
@@ -202,22 +266,14 @@ int py::register_python_type(
  */
 PyObject* py::wrap_mapping_iter(PyObject* iter) noexcept
 {
-    py::pyobj_handle winrt_module{PyImport_ImportModule("winrt._winrt")};
-
-    if (!winrt_module)
-    {
-        return nullptr;
-    }
-
-    py::pyobj_handle mapping_iter_type{
-        PyObject_GetAttrString(winrt_module.get(), "MappingIter")};
-
-    if (!mapping_iter_type)
+    auto state = py::cpp::_winrt::get_module_state();
+    if (!state)
     {
         return nullptr;
     }
 
-    py::pyobj_handle wrapper{PyObject_CallOneArg(mapping_iter_type.get(), iter)};
+    py::pyobj_handle wrapper{PyObject_CallOneArg(
+        reinterpret_cast<PyObject*>(state->mapping_iter_type), iter)};
 
     if (!wrapper)
     {
@@ -393,3 +449,62 @@ winrt::Windows::Foundation::DateTime py::convert_to_datetime(PyObject* obj)
 
     return value;
 }
+
+PyObject* py::convert_guid(winrt::guid value) noexcept
+{
+    auto state = py::cpp::_winrt::get_module_state();
+    if (!state)
+    {
+        return nullptr;
+    }
+
+    // It is faster to swap in C++ rather than using bytes_le in Python since
+    // Python stores the bytes in a different order.
+    alignas(4) char buffer[sizeof(winrt::guid)];
+    *reinterpret_cast<uint32_t*>(buffer) = _byteswap_ulong(value.Data1);
+    *reinterpret_cast<uint16_t*>(buffer + 4) = _byteswap_ushort(value.Data2);
+    *reinterpret_cast<uint16_t*>(buffer + 6) = _byteswap_ushort(value.Data3);
+    std::memcpy(buffer + 8, value.Data4, sizeof(value.Data4));
+
+    pyobj_handle value_as_bytes{PyBytes_FromStringAndSize(buffer, sizeof(buffer))};
+    if (!value_as_bytes)
+    {
+        return nullptr;
+    }
+
+    return PyObject_CallOneArg(state->to_uuid_func, value_as_bytes.get());
+}
+
+winrt::guid py::convert_to_guid(PyObject* obj)
+{
+    throw_if_pyobj_null(obj);
+
+    pyobj_handle bytes{PyObject_GetAttrString(obj, "bytes")};
+    if (!bytes)
+    {
+        throw python_exception();
+    }
+
+    char* buffer;
+    Py_ssize_t size;
+    if (PyBytes_AsStringAndSize(bytes.get(), &buffer, &size) == -1)
+    {
+        throw python_exception();
+    }
+
+    if (size != sizeof(winrt::guid))
+    {
+        PyErr_SetString(PyExc_ValueError, "bytes is wrong size");
+        throw python_exception();
+    }
+
+    // It is faster to swap in C++ rather than using bytes_le in Python since
+    // Python stores the bytes in a different order.
+    winrt::guid result;
+    result.Data1 = _byteswap_ulong(*reinterpret_cast<uint32_t*>(buffer));
+    result.Data2 = _byteswap_ushort(*reinterpret_cast<uint16_t*>(buffer + 4));
+    result.Data3 = _byteswap_ushort(*reinterpret_cast<uint16_t*>(buffer + 6));
+    std::memcpy(result.Data4, buffer + 8, sizeof(result.Data4));
+
+    return result;
+}

{winrt_runtime-2.0.1 → winrt_runtime-2.2.0}/src/winrt/_winrt.pyi

@@ -16,6 +16,7 @@ from typing import (
     ValuesView,
     overload,
 )
+from uuid import UUID
 
 MTA: int
 STA: int
@@ -23,6 +24,8 @@ STA: int
 def init_apartment(apartment_type: int) -> None: ...
 def uninit_apartment() -> None: ...
 def initialize_with_window(obj: Object, hwnd: int) -> None: ...
+def _add_dll_directory(path: str) -> int: ...
+def _remove_dll_directory(cookie: int) -> None: ...
 
 _Self = TypeVar("_Self")
 _T = TypeVar("_T")
@@ -82,7 +85,11 @@ class MutableMapping(Mapping[_KT, _VT]):
 
 # actual runtime classes
 
-class Object: ...
+class Object:
+    @property
+    def _iids_(self) -> Array[UUID]: ...
+    @property
+    def _runtime_class_name_(self) -> str: ...
 
 class Array(MutableSequence[_T]):
     _winrt_element_type_name_: str

{winrt_runtime-2.0.1 → winrt_runtime-2.2.0}/src/winrt/system/__init__.py

@@ -1,8 +1,38 @@
 from collections.abc import Mapping, MutableMapping, MutableSequence, Sequence
+from pathlib import Path
 from typing import Annotated
 
 from .. import _winrt
 
+
+class _DllCookie:
+    def __init__(self, cookie: int) -> None:
+        self.cookie = cookie
+
+    def close(self):
+        if self.cookie:
+            _winrt._remove_dll_directory(self.cookie)
+            self.cookie = None
+
+    def __del__(self):
+        self.close()
+
+
+def _register_dll_search_path(module_path) -> _DllCookie:
+    """
+    Register a module's directory as a DLL search path.
+
+    Args:
+        module_path: The path to a module file (i.e. ``__file__``)
+
+    Returns:
+        An cookie object that will remove the search path when closed.
+    """
+    return _DllCookie(
+        _winrt._add_dll_directory(str(Path(module_path).parent.resolve()))
+    )
+
+
 # NB: The types implemented in C cannot inherit from abc.ABC since Python 3.12
 # so we have to implement the protocols like this instead.
 # https://github.com/python/cpython/issues/103968#issuecomment-1589928055

{winrt_runtime-2.0.1 → winrt_runtime-2.2.0}/src/winrt_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: winrt-runtime
-Version: 2.0.1
+Version: 2.2.0
 Summary: Python projection of Windows Runtime (WinRT) APIs
 License: MIT
 Project-URL: Documentation, https://pywinrt.readthedocs.io
@@ -10,7 +10,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Intended Audience :: Developers
-Requires-Python: <3.13,>=3.9
+Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 
 # winrt-runtime

winrt_runtime-2.0.1/_winrt.cpp

@@ -1,365 +0,0 @@
-// must be included before winrt to avoid compile errors
-#include <Shobjidl.h>
-
-#define PYWINRT_RUNTIME_MODULE
-#include "pybase.h"
-#include <winrt/base.h>
-
-namespace py::cpp::_winrt
-{
-    // BEGIN: class _winrt.Object:
-
-    static constexpr const char* const type_name_Object = "Object";
-
-    PyDoc_STRVAR(Object_doc, "base class for wrapped WinRT object instances.");
-
-    static PyObject* Object_new(
-        PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
-    {
-        py::set_invalid_activation_error(type_name_Object);
-        return nullptr;
-    }
-
-    static void Object_dealloc(
-        py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>* self)
-    {
-        auto tp = Py_TYPE(self);
-
-        std::destroy_at(&self->obj);
-        tp->tp_free(self);
-        Py_DECREF(tp);
-    }
-
-    static PyType_Slot Object_type_slots[] = {
-        {Py_tp_new, reinterpret_cast<void*>(Object_new)},
-        {Py_tp_dealloc, reinterpret_cast<void*>(Object_dealloc)},
-        {Py_tp_doc, const_cast<char*>(Object_doc)},
-        {},
-    };
-
-    static PyType_Spec Object_type_spec
-        = {"_winrt.Object",
-           sizeof(py::winrt_wrapper<winrt::Windows::Foundation::IUnknown>),
-           0,
-           Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
-           Object_type_slots};
-
-    // END: class _winrt.Object:
-
-    // BEGIN: class _winrt.Array:
-
-    extern PyType_Spec Array_type_spec;
-
-    // END: class _winrt.Array:
-
-    // BEGIN: class _winrt.MappingIter:
-
-    // This class is used to wrap the iterator returned by IMap/IMapView so
-    // that it returns only the key instead of a KeyValuePair. This is done
-    // to be consistent with the Python mapping protocol.
-    //
-    // In Python it would look something like this:
-    //
-    //  class MappingIter:
-    //      def  __init__(self, base_iter):
-    //          self._iter = iter(base_iter)
-    //
-    //      def __iter__(self):
-    //          return self
-    //
-    //      def __next__(self):
-    //          return next(self._iter).key
-    //
-
-    struct MappingIter_object
-    {
-        PyObject_HEAD;
-        PyObject* _iter;
-    };
-
-    static PyMemberDef MappingIter_members[]
-        = {{"_iter",
-            T_OBJECT_EX,
-            offsetof(MappingIter_object, _iter),
-            0,
-            PyDoc_STR("base KeyValuePair iterator")},
-           {}};
-
-    static int MappingIter_init(PyObject* self, PyObject* args, PyObject* kwds) noexcept
-    {
-        if (kwds)
-        {
-            PyErr_SetString(PyExc_TypeError, "keyword arguments are not supported");
-            return -1;
-        }
-
-        // borrowed ref
-        auto base_iter = PyTuple_GetItem(args, 0);
-
-        if (!base_iter)
-        {
-            return -1;
-        }
-
-        if (!PyIter_Check(base_iter))
-        {
-            PyErr_SetString(PyExc_TypeError, "expecting an iterator");
-            return -1;
-        }
-
-        if (PyObject_SetAttrString(self, "_iter", base_iter) == -1)
-        {
-            return -1;
-        }
-
-        return 0;
-    }
-
-    static PyObject* MappingIter_iternext(PyObject* self) noexcept
-    {
-        // new reference
-        py::pyobj_handle base_iter{PyObject_GetAttrString(self, "_iter")};
-
-        if (!base_iter)
-        {
-            return nullptr;
-        }
-
-        // new reference
-        py::pyobj_handle next{PyIter_Next(base_iter.get())};
-
-        if (!next)
-        {
-            return nullptr;
-        }
-
-        // new reference
-        py::pyobj_handle key{PyObject_GetAttrString(next.get(), "key")};
-
-        if (!key)
-        {
-            return nullptr;
-        }
-
-        return key.detach();
-    }
-
-    PyDoc_STRVAR(MappingIter_doc, "Utility class for wrapping KeyValuePair iterators.");
-
-    static PyType_Slot MappingIter_type_slots[] = {
-        {Py_tp_members, reinterpret_cast<void*>(MappingIter_members)},
-        {Py_tp_init, reinterpret_cast<void*>(MappingIter_init)},
-        {Py_tp_iter, reinterpret_cast<void*>(PyObject_SelfIter)},
-        {Py_tp_iternext, reinterpret_cast<void*>(MappingIter_iternext)},
-        {Py_tp_doc, const_cast<char*>(MappingIter_doc)},
-        {},
-    };
-
-    static PyType_Spec MappingIter_type_spec
-        = {"_winrt.MappingIter",
-           sizeof(MappingIter_object),
-           0,
-           Py_TPFLAGS_DEFAULT,
-           MappingIter_type_slots};
-
-    // END: class _winrt.MappingIter:
-
-    static const py::runtime_api runtime_api{
-        .runtime_api_guid = py::runtime_api_guid,
-        .abi_version_major = py::runtime_abi_version_major,
-        .abi_version_minor = py::runtime_abi_version_minor,
-        .register_python_type = py::register_python_type,
-        .wrap_mapping_iter = py::wrap_mapping_iter,
-        .is_buffer_compatible = py::is_buffer_compatible,
-        .convert_datetime = py::convert_datetime,
-        .convert_to_datetime = py::convert_to_datetime,
-        .get_object_type = py::get_object_type,
-        .array_new = py::cpp::_winrt::Array_New,
-        .array_assign = &py::cpp::_winrt::Array_Assign,
-    };
-
-    static PyObject* init_apartment(PyObject* /*unused*/, PyObject* type_obj) noexcept
-    {
-        auto type = PyLong_AsLong(type_obj);
-
-        if (type == -1 && PyErr_Occurred())
-        {
-            return nullptr;
-        }
-
-        try
-        {
-            winrt::init_apartment(static_cast<winrt::apartment_type>(type));
-            Py_RETURN_NONE;
-        }
-        catch (...)
-        {
-            py::to_PyErr();
-            return nullptr;
-        }
-    }
-
-    static PyObject* uninit_apartment(
-        PyObject* /*unused*/, PyObject* /*unused*/) noexcept
-    {
-        winrt::uninit_apartment();
-        Py_RETURN_NONE;
-    }
-
-    static PyObject* initialize_with_window(
-        PyObject* /*unused*/, PyObject* args) noexcept
-    {
-        PyObject* obj;
-        Py_ssize_t hwnd;
-
-        if (!PyArg_ParseTuple(args, "On", &obj, &hwnd))
-        {
-            return nullptr;
-        }
-
-        try
-        {
-            auto winrt_obj
-                = py::convert_to<winrt::Windows::Foundation::IInspectable>(obj);
-            auto result = winrt_obj.as<IInitializeWithWindow>()->Initialize(
-                reinterpret_cast<HWND>(hwnd));
-
-            if (result != S_OK)
-            {
-                winrt::throw_hresult(result);
-            }
-        }
-        catch (...)
-        {
-            py::to_PyErr();
-            return nullptr;
-        }
-
-        Py_RETURN_NONE;
-    }
-
-    PyDoc_STRVAR(module_doc, "_winrt");
-
-    static PyMethodDef module_methods[]{
-        {"init_apartment", init_apartment, METH_O, "initialize the apartment"},
-        {"uninit_apartment",
-         uninit_apartment,
-         METH_NOARGS,
-         "uninitialize the apartment"},
-        {"initialize_with_window",
-         initialize_with_window,
-         METH_VARARGS,
-         "interop function to invoke IInitializeWithWindow::Initialize on an object"},
-        {}};
-
-    static PyModuleDef module_def
-        = {PyModuleDef_HEAD_INIT,
-           "_winrt",
-           module_doc,
-           0,
-           module_methods,
-           nullptr,
-           nullptr,
-           nullptr,
-           nullptr};
-
-    static PyObject* module_init() noexcept
-    {
-        static const auto kMTA
-            = static_cast<long>(winrt::apartment_type::multi_threaded);
-        static const auto kSTA
-            = static_cast<long>(winrt::apartment_type::single_threaded);
-
-        py::pyobj_handle module{PyModule_Create(&module_def)};
-
-        if (!module)
-        {
-            return nullptr;
-        }
-
-        if (py::register_python_type(module.get(), &Object_type_spec, nullptr, nullptr)
-            == -1)
-        {
-            return nullptr;
-        }
-
-        if (py::register_python_type(module.get(), &Array_type_spec, nullptr, nullptr)
-            == -1)
-        {
-            return nullptr;
-        }
-
-        if (py::register_python_type(
-                module.get(), &MappingIter_type_spec, nullptr, nullptr)
-            == -1)
-        {
-            return nullptr;
-        }
-
-        pyobj_handle runtime_api_capsule{PyCapsule_New(
-            const_cast<py::runtime_api*>(&runtime_api),
-            "winrt._winrt._C_API",
-            nullptr)};
-
-        if (!runtime_api_capsule)
-        {
-            return nullptr;
-        }
-
-        if (PyModule_AddObjectRef(module.get(), "_C_API", runtime_api_capsule.get())
-            == -1)
-        {
-            return nullptr;
-        }
-
-        if (PyModule_AddIntConstant(module.get(), "MTA", kMTA) == -1)
-        {
-            return nullptr;
-        }
-
-        if (PyModule_AddIntConstant(module.get(), "STA", kSTA) == -1)
-        {
-            return nullptr;
-        }
-
-        return module.detach();
-    }
-} // namespace py::cpp::_winrt
-
-PyMODINIT_FUNC PyInit__winrt(void) noexcept
-{
-    return py::cpp::_winrt::module_init();
-}
-
-PyTypeObject* py::get_object_type() noexcept
-{
-    py::pyobj_handle system_module{PyImport_ImportModule("winrt.system")};
-
-    if (!system_module)
-    {
-        return nullptr;
-    }
-
-    py::pyobj_handle object_type{PyObject_GetAttrString(system_module.get(), "Object")};
-
-    if (!object_type)
-    {
-        return nullptr;
-    }
-
-    if (!PyType_Check(object_type.get()))
-    {
-        PyErr_SetString(PyExc_TypeError, "winrt.system.Object is not a type object!");
-        return nullptr;
-    }
-
-    if (reinterpret_cast<PyTypeObject*>(object_type.get())->tp_new
-        != py::cpp::_winrt::Object_new)
-    {
-        PyErr_SetString(
-            PyExc_TypeError, "winrt.system.Object is not the expected type!");
-        return nullptr;
-    }
-
-    return reinterpret_cast<PyTypeObject*>(object_type.get());
-}

winrt_runtime-2.0.1/pywinrt-version.txt

@@ -1 +0,0 @@
-2.0.1