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

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

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

{winrt_runtime-2.2.0 → winrt_runtime-3.0.0}/_winrt.cpp

@@ -5,10 +5,81 @@
 #define PYWINRT_RUNTIME_MODULE
 #include "pybase.h"
 #include "pyruntime.h"
+#include "_winrt_box.h"
 #include <winrt/base.h>
 
 namespace py::cpp::_winrt
 {
+    // BEGIN: class _winrt.IInspectable_Static:
+
+    static PyObject* IInspectable_Static_instancecheck(
+        PyObject* cls, PyObject* obj) noexcept
+    {
+        try
+        {
+            py::pyobj_handle guid_method{};
+
+            auto ret = PyObject_GetOptionalAttrString(cls, "_guid_", guid_method.put());
+            if (ret == -1)
+            {
+                return nullptr;
+            }
+
+            if (ret == 0)
+            {
+                // target class doesn't have a _guid_ attribute, so fall back to
+                // base class implementation
+                return PyObject_CallMethod(
+                    reinterpret_cast<PyObject*>(&PyType_Type),
+                    "__instancecheck__",
+                    "OO",
+                    cls,
+                    obj);
+            }
+
+            py::pyobj_handle guid_obj{PyObject_CallNoArgs(guid_method.get())};
+            if (!guid_obj)
+            {
+                return nullptr;
+            }
+
+            auto guid = py::convert_to<winrt::guid>(guid_obj.get());
+            auto instance
+                = py::convert_to<winrt::Windows::Foundation::IInspectable>(obj);
+            auto interfaces = winrt::get_interfaces(instance);
+
+            return PyBool_FromLong(
+                std::find(interfaces.begin(), interfaces.end(), guid)
+                != interfaces.end());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef IInspectable_Static_methods[]
+        = {{"__instancecheck__",
+            reinterpret_cast<PyCFunction>(IInspectable_Static_instancecheck),
+            METH_O,
+            nullptr},
+           {}};
+
+    static PyType_Slot IInspectable_Static_type_slots[]
+        = {{Py_tp_base, reinterpret_cast<void*>(&PyType_Type)},
+           {Py_tp_methods, reinterpret_cast<void*>(IInspectable_Static_methods)},
+           {}};
+
+    static PyType_Spec IInspectable_Static_type_spec
+        = {"winrt._winrt.IInspectable_Static",
+           0,
+           0,
+           Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+           IInspectable_Static_type_slots};
+
+    // END: class _winrt.IInspectable_Static:
+
     // BEGIN: class _winrt.Object:
 
     static constexpr const char* const type_name_Object = "Object";
@@ -72,6 +143,25 @@ namespace py::cpp::_winrt
         }
     }
 
+    static PyObject* Object_as(PyObject* self, PyObject* arg) noexcept
+    {
+        if (reinterpret_cast<PyObject*>(Py_TYPE(self)) == arg)
+        {
+            return Py_NewRef(self);
+        }
+
+        pyobj_handle from{PyUnicode_InternFromString("_from")};
+        if (!from)
+        {
+            return nullptr;
+        }
+
+        return PyObject_CallMethodOneArg(arg, from.get(), self);
+    }
+
+    static PyMethodDef Object_methods[]
+        = {{"as_", reinterpret_cast<PyCFunction>(Object_as), METH_O, nullptr}, {}};
+
     static PyGetSetDef Object_getset[]
         = {{"_iids_",
             reinterpret_cast<getter>(Object_iids_get),
@@ -85,11 +175,69 @@ namespace py::cpp::_winrt
             nullptr},
            {}};
 
+    static PyObject* Object_richcompare(
+        py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>* self,
+        PyObject* other,
+        int op) noexcept
+    {
+        if (op == Py_EQ)
+        {
+            try
+            {
+                auto other_inspectable
+                    = py::convert_to<winrt::Windows::Foundation::IInspectable>(other);
+
+                if (other_inspectable)
+                {
+                    return PyBool_FromLong(self->obj == other_inspectable);
+                }
+            }
+            catch (python_exception)
+            {
+                PyErr_Clear();
+            }
+
+            Py_RETURN_FALSE;
+        }
+
+        if (op == Py_NE)
+        {
+            try
+            {
+                auto other_inspectable
+                    = py::convert_to<winrt::Windows::Foundation::IInspectable>(other);
+
+                if (other_inspectable)
+                {
+                    return PyBool_FromLong(self->obj != other_inspectable);
+                }
+            }
+            catch (python_exception)
+            {
+                PyErr_Clear();
+            }
+
+            Py_RETURN_TRUE;
+        }
+
+        Py_RETURN_NOTIMPLEMENTED;
+    }
+
+    static Py_hash_t Object_hash(
+        py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>* self) noexcept
+    {
+        return static_cast<Py_hash_t>(
+            std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj));
+    }
+
     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_methods, reinterpret_cast<void*>(Object_methods)},
            {Py_tp_getset, reinterpret_cast<void*>(Object_getset)},
+           {Py_tp_richcompare, reinterpret_cast<void*>(Object_richcompare)},
+           {Py_tp_hash, reinterpret_cast<void*>(Object_hash)},
            {}};
 
     static PyType_Spec Object_type_spec
@@ -150,14 +298,16 @@ namespace py::cpp::_winrt
             return -1;
         }
 
-        // borrowed ref
-        auto base_iter = PyTuple_GetItem(args, 0);
-
-        if (!base_iter)
+        auto arg_count = PyTuple_GET_SIZE(args);
+        if (arg_count != 1)
         {
+            PyErr_SetString(PyExc_TypeError, "requires a single argument");
             return -1;
         }
 
+        // borrowed ref
+        auto base_iter = PyTuple_GET_ITEM(args, 0);
+
         if (!PyIter_Check(base_iter))
         {
             PyErr_SetString(PyExc_TypeError, "expecting an iterator");
@@ -238,12 +388,14 @@ namespace py::cpp::_winrt
         .abi_version_minor = py::runtime_abi_version_minor,
         .register_python_type = py::register_python_type,
         .get_python_type = py::get_python_type,
+        .get_struct_from_tuple_func = py::get_struct_from_tuple_func,
         .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_inspectable_meta_type = py::get_inspectable_meta_type,
         .get_object_type = py::get_object_type,
         .array_new = py::cpp::_winrt::Array_New,
         .array_assign = &py::cpp::_winrt::Array_Assign,
@@ -402,6 +554,7 @@ namespace py::cpp::_winrt
     {
         auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
 
+        Py_VISIT(state->inspectable_meta_type);
         Py_VISIT(state->object_type);
         Py_VISIT(state->array_type);
         Py_VISIT(state->mapping_iter_type);
@@ -419,6 +572,7 @@ namespace py::cpp::_winrt
     {
         auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
 
+        Py_CLEAR(state->inspectable_meta_type);
         Py_CLEAR(state->object_type);
         Py_CLEAR(state->array_type);
         Py_CLEAR(state->mapping_iter_type);
@@ -438,6 +592,7 @@ namespace py::cpp::_winrt
     {
         auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
 
+        Py_XDECREF(state->inspectable_meta_type);
         Py_XDECREF(state->object_type);
         Py_XDECREF(state->array_type);
         Py_XDECREF(state->mapping_iter_type);
@@ -449,6 +604,8 @@ namespace py::cpp::_winrt
         }
 
         std::destroy_at(&state->type_cache);
+
+        std::destroy_at(&state->struct_from_tuple_cache);
     }
 
     PyDoc_STRVAR(module_doc, "_winrt");
@@ -473,6 +630,50 @@ namespace py::cpp::_winrt
          METH_O,
          PyDoc_STR(
              "Removes a directory that was added to the process DLL search path by using _add_dll_directory.")},
+        {"box_boolean", box_boolean, METH_O, PyDoc_STR("Box a Boolean value")},
+        {"box_char16", box_char16, METH_O, PyDoc_STR("Box a Char16 value")},
+        {"box_string", box_string, METH_O, PyDoc_STR("Box a string value")},
+        {"box_int8", box_int8, METH_O, PyDoc_STR("Box a Int8 value")},
+        {"box_uint8", box_uint8, METH_O, PyDoc_STR("Box a UInt8 value")},
+        {"box_int16", box_int16, METH_O, PyDoc_STR("Box a Int16 value")},
+        {"box_uint16", box_uint16, METH_O, PyDoc_STR("Box a UInt16 value")},
+        {"box_int32", box_int32, METH_O, PyDoc_STR("Box a Int32 value")},
+        {"box_uint32", box_uint32, METH_O, PyDoc_STR("Box a UInt32 value")},
+        {"box_int64", box_int64, METH_O, PyDoc_STR("Box a Int64 value")},
+        {"box_uint64", box_uint64, METH_O, PyDoc_STR("Box a UInt64 value")},
+        {"box_single", box_single, METH_O, PyDoc_STR("Box a Single value")},
+        {"box_double", box_double, METH_O, PyDoc_STR("Box a Double value")},
+        {"box_guid", box_guid, METH_O, PyDoc_STR("Box a GUID value")},
+        {"box_date_time",
+         box_date_time,
+         METH_O,
+         PyDoc_STR("Box a Windows.Foundation.DateTime value")},
+        {"box_time_span",
+         box_time_span,
+         METH_O,
+         PyDoc_STR("Box a Windows.Foundation.TimeSpan value")},
+        {"unbox_boolean", unbox_boolean, METH_O, PyDoc_STR("Unbox a Boolean value")},
+        {"unbox_char16", unbox_char16, METH_O, PyDoc_STR("Unbox a Char16 value")},
+        {"unbox_string", unbox_string, METH_O, PyDoc_STR("Unbox a string value")},
+        {"unbox_int8", unbox_int8, METH_O, PyDoc_STR("Unbox a Int8 value")},
+        {"unbox_uint8", unbox_uint8, METH_O, PyDoc_STR("Unbox a UInt8 value")},
+        {"unbox_int16", unbox_int16, METH_O, PyDoc_STR("Unbox a Int16 value")},
+        {"unbox_uint16", unbox_uint16, METH_O, PyDoc_STR("Unbox a UInt16 value")},
+        {"unbox_int32", unbox_int32, METH_O, PyDoc_STR("Unbox a Int32 value")},
+        {"unbox_uint32", unbox_uint32, METH_O, PyDoc_STR("Unbox a UInt32 value")},
+        {"unbox_int64", unbox_int64, METH_O, PyDoc_STR("Unbox a Int64 value")},
+        {"unbox_uint64", unbox_uint64, METH_O, PyDoc_STR("Unbox a UInt64 value")},
+        {"unbox_single", unbox_single, METH_O, PyDoc_STR("Unbox a Single value")},
+        {"unbox_double", unbox_double, METH_O, PyDoc_STR("Unbox a Double value")},
+        {"unbox_guid", unbox_guid, METH_O, PyDoc_STR("Unbox a GUID value")},
+        {"unbox_date_time",
+         unbox_date_time,
+         METH_O,
+         PyDoc_STR("Unbox a Windows.Foundation.DateTime value")},
+        {"unbox_time_span",
+         unbox_time_span,
+         METH_O,
+         PyDoc_STR("Unbox a Windows.Foundation.TimeSpan value")},
         {}};
 
     static PyModuleDef module_def
@@ -501,6 +702,14 @@ namespace py::cpp::_winrt
 
         auto state = reinterpret_cast<module_state*>(PyModule_GetState(module.get()));
         std::construct_at(&state->type_cache);
+        std::construct_at(&state->struct_from_tuple_cache);
+
+        py::pytype_handle inspectable_meta_type{py::register_python_type(
+            module.get(), &IInspectable_Static_type_spec, nullptr, nullptr)};
+        if (!inspectable_meta_type)
+        {
+            return nullptr;
+        }
 
         py::pytype_handle object_type{py::register_python_type(
             module.get(), &Object_type_spec, nullptr, nullptr)};
@@ -555,6 +764,7 @@ namespace py::cpp::_winrt
             return nullptr;
         }
 
+        state->inspectable_meta_type = inspectable_meta_type.detach();
         state->object_type = object_type.detach();
         state->array_type = array_type.detach();
         state->mapping_iter_type = mapping_iter_type.detach();
@@ -580,6 +790,17 @@ py::cpp::_winrt::module_state* py::cpp::_winrt::get_module_state() noexcept
     return reinterpret_cast<py::cpp::_winrt::module_state*>(PyModule_GetState(module));
 }
 
+PyTypeObject* py::get_inspectable_meta_type() noexcept
+{
+    auto state = py::cpp::_winrt::get_module_state();
+    if (!state)
+    {
+        return nullptr;
+    }
+
+    return state->inspectable_meta_type;
+}
+
 PyTypeObject* py::get_object_type() noexcept
 {
     auto state = py::cpp::_winrt::get_module_state();