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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: winrt-runtime
-Version: 2.1.0
+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.1.0 → winrt_runtime-2.2.0}/_winrt.cpp

@@ -1,8 +1,10 @@
 // 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
@@ -128,6 +130,7 @@ namespace py::cpp::_winrt
     {
         PyObject_HEAD;
         PyObject* _iter;
+        PyObject* _key;
     };
 
     static PyMemberDef MappingIter_members[]
@@ -136,6 +139,7 @@ namespace py::cpp::_winrt
             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
@@ -165,30 +169,41 @@ namespace py::cpp::_winrt
             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(PyObject* self) noexcept
+    static PyObject* MappingIter_iternext(MappingIter_object* self) noexcept
     {
-        // new reference
-        py::pyobj_handle base_iter{PyObject_GetAttrString(self, "_iter")};
-
-        if (!base_iter)
+        if (!self->_iter)
         {
+            PyErr_SetString(PyExc_RuntimeError, "_iter was deleted");
             return nullptr;
         }
 
-        // new reference
-        py::pyobj_handle next{PyIter_Next(base_iter.get())};
-
+        py::pyobj_handle next{PyIter_Next(self->_iter)};
         if (!next)
         {
             return nullptr;
         }
 
-        // new reference
-        py::pyobj_handle key{PyObject_GetAttrString(next.get(), "key")};
+        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;
@@ -222,10 +237,13 @@ namespace py::cpp::_winrt
         .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,
@@ -291,6 +309,148 @@ namespace py::cpp::_winrt
         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[]{
@@ -298,23 +458,33 @@ namespace py::cpp::_winrt
         {"uninit_apartment",
          uninit_apartment,
          METH_NOARGS,
-         "uninitialize the apartment"},
+         PyDoc_STR("uninitialize the apartment")},
         {"initialize_with_window",
          initialize_with_window,
          METH_VARARGS,
-         "interop function to invoke IInitializeWithWindow::Initialize on an object"},
+         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,
-           0,
+           sizeof(module_state),
            module_methods,
            nullptr,
-           nullptr,
-           nullptr,
-           nullptr};
+           module_traverse,
+           module_clear,
+           reinterpret_cast<freefunc>(module_free)};
 
     static PyObject* module_init() noexcept
     {
@@ -324,27 +494,31 @@ namespace py::cpp::_winrt
             = 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)
+        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;
         }
 
-        if (py::register_python_type(module.get(), &Array_type_spec, nullptr, nullptr)
-            == -1)
+        py::pytype_handle array_type{
+            py::register_python_type(module.get(), &Array_type_spec, nullptr, nullptr)};
+        if (!array_type)
         {
             return nullptr;
         }
 
-        if (py::register_python_type(
-                module.get(), &MappingIter_type_spec, nullptr, nullptr)
-            == -1)
+        py::pytype_handle mapping_iter_type{py::register_python_type(
+            module.get(), &MappingIter_type_spec, nullptr, nullptr)};
+        if (!mapping_iter_type)
         {
             return nullptr;
         }
@@ -375,6 +549,17 @@ namespace py::cpp::_winrt
             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
@@ -384,35 +569,24 @@ PyMODINIT_FUNC PyInit__winrt(void) noexcept
     return py::cpp::_winrt::module_init();
 }
 
-PyTypeObject* py::get_object_type() noexcept
+py::cpp::_winrt::module_state* py::cpp::_winrt::get_module_state() noexcept
 {
-    py::pyobj_handle system_module{PyImport_ImportModule("winrt.system")};
-
-    if (!system_module)
+    auto module = PyState_FindModule(&py::cpp::_winrt::module_def);
+    if (!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;
-    }
+    return reinterpret_cast<py::cpp::_winrt::module_state*>(PyModule_GetState(module));
+}
 
-    if (reinterpret_cast<PyTypeObject*>(object_type.get())->tp_new
-        != py::cpp::_winrt::Object_new)
+PyTypeObject* py::get_object_type() noexcept
+{
+    auto state = py::cpp::_winrt::get_module_state();
+    if (!state)
     {
-        PyErr_SetString(
-            PyExc_TypeError, "winrt.system.Object is not the expected type!");
         return nullptr;
     }
 
-    return reinterpret_cast<PyTypeObject*>(object_type.get());
+    return state->object_type;
 }

{winrt_runtime-2.1.0 → 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.1.0 → 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.1.0 → 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.1.0 → winrt_runtime-2.2.0}/src/winrt/_winrt.pyi

@@ -24,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")

{winrt_runtime-2.1.0 → 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.1.0 → 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.1.0
+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.1.0/pywinrt-version.txt

@@ -1 +0,0 @@
-2.1.0