winrt-runtime 3.1.0__tar.gz → 3.2.0__tar.gz

{winrt_runtime-3.1.0 → winrt_runtime-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winrt-runtime
-Version: 3.1.0
+Version: 3.2.0
 Summary: Python projection of Windows Runtime (WinRT) APIs
 License-Expression: MIT
 Project-URL: Documentation, https://pywinrt.readthedocs.io

{winrt_runtime-3.1.0 → winrt_runtime-3.2.0}/_winrt.cpp

@@ -398,6 +398,8 @@ namespace py::cpp::_winrt
         .get_object_type = py::get_object_type,
         .array_new = py::cpp::_winrt::Array_New,
         .array_assign = &py::cpp::_winrt::Array_Assign,
+        .await_async = py::await_async,
+        .convert_to_ibuffer = py::convert_to_ibuffer,
     };
 
     static PyObject* init_apartment(PyObject* /*unused*/, PyObject* type_obj) noexcept
@@ -558,6 +560,7 @@ namespace py::cpp::_winrt
         Py_VISIT(state->array_type);
         Py_VISIT(state->mapping_iter_type);
         Py_VISIT(state->to_uuid_func);
+        Py_VISIT(state->wrap_async_func);
 
         for (const auto& [key, value] : state->type_cache)
         {
@@ -576,6 +579,7 @@ namespace py::cpp::_winrt
         Py_CLEAR(state->array_type);
         Py_CLEAR(state->mapping_iter_type);
         Py_CLEAR(state->to_uuid_func);
+        Py_CLEAR(state->wrap_async_func);
 
         auto type_cache = std::move(state->type_cache);
 
@@ -596,6 +600,7 @@ namespace py::cpp::_winrt
         Py_XDECREF(state->array_type);
         Py_XDECREF(state->mapping_iter_type);
         Py_XDECREF(state->to_uuid_func);
+        Py_XDECREF(state->wrap_async_func);
 
         for (auto& [key, value] : state->type_cache)
         {
@@ -653,15 +658,15 @@ namespace py::cpp::_winrt
          METH_VARARGS,
          PyDoc_STR(
              "interop function to invoke IInitializeWithWindow::Initialize on an object")},
-        {"_add_dll_directory",
+        {"add_dll_directory",
          add_dll_directory,
          METH_O,
          PyDoc_STR("Adds a directory to the DLL search path.")},
-        {"_remove_dll_directory",
+        {"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.")},
+             "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")},
@@ -803,6 +808,7 @@ namespace py::cpp::_winrt
         state->array_type = array_type.detach();
         state->mapping_iter_type = mapping_iter_type.detach();
         state->to_uuid_func = to_uuid_func.detach();
+        state->wrap_async_func = nullptr; // lazy-initialized
 
         return module.detach();
     }

winrt_runtime-3.2.0/_winrt_buffer.cpp

@@ -0,0 +1,59 @@
+#define PYWINRT_RUNTIME_MODULE
+#include <Python.h>
+#include <Robuffer.h>
+#include "pybase.h"
+#include <winrt/base.h>
+
+namespace py::cpp::_winrt
+{
+    struct PyWinRTBuffer : winrt::implements<
+                               PyWinRTBuffer,
+                               winrt::Windows::Storage::Streams::IBuffer,
+                               Windows::Storage::Streams::IBufferByteAccess>
+    {
+      private:
+        Py_buffer buffer;
+
+      public:
+        PyWinRTBuffer(PyObject* obj)
+        {
+            if (PyObject_GetBuffer(obj, &buffer, PyBUF_SIMPLE) == -1)
+            {
+                throw python_exception();
+            };
+        }
+
+        ~PyWinRTBuffer()
+        {
+            PyBuffer_Release(&buffer);
+        }
+
+        uint32_t Capacity() const
+        {
+            return static_cast<uint32_t>(buffer.len);
+        }
+
+        uint32_t Length() const
+        {
+            return static_cast<uint32_t>(buffer.len);
+        }
+
+        void Length(uint32_t /*unused*/)
+        {
+            // can't resize Python buffers.
+            throw winrt::hresult_not_implemented{};
+        }
+
+        HRESULT __stdcall Buffer(uint8_t** value)
+        {
+            *value = reinterpret_cast<uint8_t*>(buffer.buf);
+            return S_OK;
+        }
+    };
+
+} // namespace py::cpp::_winrt
+
+winrt::Windows::Storage::Streams::IBuffer py::convert_to_ibuffer(PyObject* obj)
+{
+    return winrt::make<py::cpp::_winrt::PyWinRTBuffer>(obj);
+}

winrt_runtime-3.2.0/pywinrt-version.txt

@@ -0,0 +1 @@
+3.2.0

{winrt_runtime-3.1.0 → winrt_runtime-3.2.0}/runtime.cpp

@@ -605,3 +605,46 @@ winrt::guid py::convert_to_guid(PyObject* obj)
         throw python_exception();
     }
 }
+
+PyObject* py::await_async(PyObject* obj) noexcept
+{
+    auto state = py::cpp::_winrt::get_module_state();
+    if (!state)
+    {
+        return nullptr;
+    }
+
+    // lazy import to avoid circular import issues
+    if (!state->wrap_async_func)
+    {
+        pyobj_handle winrt_system{PyImport_ImportModule("winrt.runtime._internals")};
+        if (!winrt_system)
+        {
+            return nullptr;
+        }
+
+        pyobj_handle wrap_async_func{
+            PyObject_GetAttrString(winrt_system.get(), "wrap_async")};
+        if (!wrap_async_func)
+        {
+            return nullptr;
+        }
+
+        state->wrap_async_func = wrap_async_func.detach();
+    }
+
+    pyobj_handle awaitable{PyObject_CallOneArg(state->wrap_async_func, obj)};
+    if (!awaitable)
+    {
+        return nullptr;
+    }
+
+    py::pyobj_handle await_str{PyUnicode_InternFromString("__await__")};
+    if (!await_str)
+    {
+        return nullptr;
+    }
+
+    // __await__() expects an iterable to be returned
+    return PyObject_CallMethodNoArgs(awaitable.get(), await_str.get());
+}

{winrt_runtime-3.1.0 → winrt_runtime-3.2.0}/setup.py

@@ -11,6 +11,8 @@ class build_ext_ex(build_ext):
             ext.extra_compile_args = ["/std:c++20", "/permissive-"]
         elif self.compiler.compiler_type == "mingw32":
             ext.extra_compile_args = ["-std=c++20", "-D_WIN32_WINNT=_WIN32_WINNT_WIN10"]
+            # GCC 15 complains about some things that it didn't in the past
+            ext.extra_compile_args += ["-Wno-strict-aliasing", "-Wno-template-body"]
             ext.extra_link_args = ["-loleaut32"]
         else:
             raise ValueError(f"Unsupported compiler: {self.compiler.compiler_type}")
@@ -23,7 +25,7 @@ setup(
     ext_modules=[
         Extension(
             "winrt._winrt",
-            sources=["_winrt.cpp", "_winrt_array.cpp", "_winrt_box.cpp", "runtime.cpp"],
+            sources=["_winrt.cpp", "_winrt_array.cpp", "_winrt_box.cpp", "_winrt_buffer.cpp", "runtime.cpp"],
             include_dirs=get_include_dirs(),
             libraries=["windowsapp"],
         )

{winrt_runtime-3.1.0 → winrt_runtime-3.2.0}/src/winrt/_winrt.pyi

@@ -30,8 +30,8 @@ STA: int
 def init_apartment(apartment_type: ApartmentType) -> 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: ...
+def add_dll_directory(path: str) -> int: ...
+def remove_dll_directory(cookie: int) -> None: ...
 def box_boolean(value: bool) -> Object: ...
 def box_int8(value: int) -> Object: ...
 def box_uint8(value: int) -> Object: ...

winrt_runtime-3.2.0/src/winrt/runtime/_internals.py

@@ -0,0 +1,247 @@
+import asyncio
+import os
+from collections.abc import (
+    Awaitable,
+    Callable,
+    Mapping,
+    MutableMapping,
+    MutableSequence,
+    Sequence,
+)
+from pathlib import Path
+import sys
+from typing import Any, TypeVar, Protocol, TYPE_CHECKING
+
+from typing_extensions import Self
+
+from winrt._winrt import add_dll_directory, remove_dll_directory
+from winrt.system import Object
+
+# Unfortunately, we can't import at runtime because of circular imports.
+if TYPE_CHECKING:
+    from winrt.windows.foundation import HResult, AsyncStatus
+
+
+class _DllCookie:
+    def __init__(self, cookie: int) -> None:
+        self.cookie = cookie
+
+    def close(self):
+        if self.cookie:
+            remove_dll_directory(self.cookie)
+            self.cookie = None
+
+    def __del__(self):
+        self.close()
+
+
+def register_dll_search_path(module_path: str) -> _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(add_dll_directory(os.fspath(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
+
+
+def mixin_sequence(typ: type) -> None:
+    """
+    Adds missing Python mapping methods to types that implement IVectorView and
+    registers the type as a Sequence.
+    """
+    # mixin methods
+    if not hasattr(typ, "index"):
+        typ.index = Sequence.index  # type: ignore
+
+    if not hasattr(typ, "count"):
+        typ.count = Sequence.count  # type: ignore
+
+    if not hasattr(typ, "__contains__"):
+        typ.__contains__ = Sequence.__contains__  # type: ignore
+
+    if not hasattr(typ, "__iter__"):
+        typ.__iter__ = Sequence.__iter__  # type: ignore
+
+    if not hasattr(typ, "__reversed__"):
+        typ.__reversed__ = Sequence.__reversed__  # type: ignore
+
+    Sequence.register(typ)
+
+
+def mixin_mutable_sequence(typ: type) -> None:
+    """
+    Adds missing Python mapping methods to types that implement IVector and
+    registers the type as a MutableSequence.
+    """
+    mixin_sequence(typ)
+
+    if not hasattr(typ, "insert") and hasattr(typ, "insert_at"):
+
+        def insert(self: Any, index: int, value: object) -> None:
+            """
+            Alias for ``insert_at`` for compatibility with Python Sequence protocol.
+            """
+            self.insert_at(index, value)
+
+        typ.insert = insert  # type: ignore
+
+    # mixin methods
+    if not hasattr(typ, "append"):
+        typ.append = MutableSequence.append  # type: ignore
+
+    if not hasattr(typ, "clear"):
+        typ.clear = MutableSequence.clear  # type: ignore
+
+    if not hasattr(typ, "extend"):
+        typ.extend = MutableSequence.extend  # type: ignore
+
+    if not hasattr(typ, "reverse"):
+        typ.reverse = MutableSequence.reverse  # type: ignore
+
+    if not hasattr(typ, "pop"):
+        typ.pop = MutableSequence.pop  # type: ignore
+
+    if not hasattr(typ, "remove"):
+        typ.remove = MutableSequence.remove  # type: ignore
+
+    if not hasattr(typ, "__iadd__"):
+        typ.__iadd__ = MutableSequence.__iadd__  # type: ignore
+
+    MutableSequence.register(typ)
+
+
+def mixin_mapping(typ: type) -> None:
+    """
+    Adds missing Python mapping methods to types that implement IMapView and
+    registers the type as a Mapping.
+    """
+    # mixin methods
+    if not hasattr(typ, "keys"):
+        typ.keys = Mapping.keys  # type: ignore
+
+    if not hasattr(typ, "items"):
+        typ.items = Mapping.items  # type: ignore
+
+    if not hasattr(typ, "values"):
+        typ.values = Mapping.values  # type: ignore
+
+    if not hasattr(typ, "get"):
+        typ.get = Mapping.get  # type: ignore
+
+    if not hasattr(typ, "__contains__"):
+        typ.__contains__ = Mapping.__contains__  # type: ignore
+
+    # HACK: Version check works around inheritance anomaly caused by hacky
+    # metaclass inheritance implementation in runtime.cpp. This works as long
+    # as we don't change the projection to implement rich comparison methods
+    # on mapping types.
+
+    if (
+        typ.__eq__ == object.__eq__
+        or typ.__eq__ == Object.__eq__
+        or sys.version_info < (3, 12)
+    ):
+        typ.__eq__ = Mapping.__eq__  # type: ignore
+
+    if (
+        typ.__ne__ == object.__ne__
+        or typ.__ne__ == Object.__ne__
+        or sys.version_info < (3, 12)
+    ):
+        typ.__ne__ = Mapping.__ne__  # type: ignore
+
+    Mapping.register(typ)
+
+
+def mixin_mutable_mapping(typ: type) -> None:
+    """
+    Adds missing Python mapping methods to types that implement IMap and
+    registers the type as a MutableMapping.
+    """
+    mixin_mapping(typ)
+
+    # mixin methods
+    if not hasattr(typ, "clear"):
+        typ.clear = MutableMapping.clear  # type: ignore
+
+    if not hasattr(typ, "pop"):
+        typ.pop = MutableMapping.pop  # type: ignore
+        # private-name-mangled attribute :-(
+        typ._MutableMapping__marker = MutableMapping._MutableMapping__marker  # type: ignore
+
+    if not hasattr(typ, "popitem"):
+        typ.popitem = MutableMapping.popitem  # type: ignore
+
+    if not hasattr(typ, "setdefault"):
+        typ.setdefault = MutableMapping.setdefault  # type: ignore
+
+    if not hasattr(typ, "update"):
+        typ.update = MutableMapping.update  # type: ignore
+
+    MutableMapping.register(typ)
+
+
+T = TypeVar("T")
+
+
+# MyPy wants covariant T but Pylance wants invariant. Invariant seems correct.
+class AsyncOp(Protocol[T]):  # type: ignore [misc]
+    """
+    Protocol that matches both IAsyncAction and IAsyncOperation.
+    """
+
+    def cancel(self) -> None: ...
+    @property
+    def error_code(self) -> "HResult": ...
+    @property
+    def status(self) -> "AsyncStatus": ...
+    def get_results(self) -> T: ...
+    @property
+    def completed(self) -> Callable[[Self, "AsyncStatus"], None]: ...
+    @completed.setter
+    def completed(self, value: Callable[[Self, "AsyncStatus"], None]) -> None: ...
+
+
+def wrap_async(op: AsyncOp[T]) -> Awaitable[T]:
+    """
+    Wraps a WinRT async operation in a Python Awaitable.
+
+    This is used by the runtime to implement ``__await__`` on async operations.
+
+    Args:
+        op: The WinRT async operation to wrap.
+
+    Returns:
+        An asyncio Awaitable that will be completed when the WinRT operation
+        completes.
+    """
+
+    async def wait() -> T:
+        loop = asyncio.get_running_loop()
+        event = asyncio.Event()
+
+        def on_complete(op: AsyncOp[T], status: "AsyncStatus") -> None:
+            loop.call_soon_threadsafe(event.set)
+
+        op.completed = on_complete
+
+        try:
+            await event.wait()
+        except asyncio.CancelledError:
+            op.cancel()
+            # REVISIT: what if it is cancelled again?
+            await event.wait()
+            raise
+
+        return op.get_results()
+
+    return wait()

winrt_runtime-3.2.0/src/winrt/system/__init__.py

@@ -0,0 +1,113 @@
+from typing import Annotated
+
+from typing_extensions import Buffer, TypeAlias
+
+from winrt._winrt import (
+    Array,
+    Object,
+    box_boolean,
+    box_char16,
+    box_date_time,
+    box_double,
+    box_guid,
+    box_int8,
+    box_int16,
+    box_int32,
+    box_int64,
+    box_single,
+    box_string,
+    box_time_span,
+    box_uint8,
+    box_uint16,
+    box_uint32,
+    box_uint64,
+    unbox_boolean,
+    unbox_char16,
+    unbox_date_time,
+    unbox_double,
+    unbox_guid,
+    unbox_int8,
+    unbox_int16,
+    unbox_int32,
+    unbox_int64,
+    unbox_single,
+    unbox_string,
+    unbox_time_span,
+    unbox_uint8,
+    unbox_uint16,
+    unbox_uint32,
+    unbox_uint64,
+)
+import winrt.runtime._internals
+
+
+# type aliases with struct format string annotation
+Int8 = Annotated[int, "b"]
+UInt8 = Annotated[int, "B"]
+Int16 = Annotated[int, "h"]
+UInt16 = Annotated[int, "H"]
+Int32 = Annotated[int, "i"]
+UInt32 = Annotated[int, "I"]
+Int64 = Annotated[int, "q"]
+UInt64 = Annotated[int, "Q"]
+Single = Annotated[float, "f"]
+Double = Annotated[float, "d"]
+Char16 = Annotated[str, "u"]
+
+winrt.runtime._internals.mixin_mutable_sequence(Array)
+
+# Type hints for Python buffer protocol - can use standard Python types in
+# addition to the WinRT Array.
+ReadableBuffer: TypeAlias = Buffer  # WinRT PassArray
+WriteableBuffer: TypeAlias = Buffer  # WinRT FillArray
+
+
+__all__ = [
+    "Int8",
+    "UInt8",
+    "Int16",
+    "UInt16",
+    "Int32",
+    "UInt32",
+    "Int64",
+    "UInt64",
+    "Single",
+    "Double",
+    "Char16",
+    "Object",
+    "Array",
+    "ReadableBuffer",
+    "WriteableBuffer",
+    "box_boolean",
+    "box_int8",
+    "box_uint8",
+    "box_int16",
+    "box_uint16",
+    "box_int32",
+    "box_uint32",
+    "box_int64",
+    "box_uint64",
+    "box_single",
+    "box_double",
+    "box_char16",
+    "box_string",
+    "box_guid",
+    "box_date_time",
+    "box_time_span",
+    "unbox_boolean",
+    "unbox_int8",
+    "unbox_uint8",
+    "unbox_int16",
+    "unbox_uint16",
+    "unbox_int32",
+    "unbox_uint32",
+    "unbox_int64",
+    "unbox_uint64",
+    "unbox_single",
+    "unbox_double",
+    "unbox_char16",
+    "unbox_string",
+    "unbox_guid",
+    "unbox_date_time",
+    "unbox_time_span",
+]

winrt_runtime-3.2.0/src/winrt/system/hresult.py

@@ -0,0 +1,48 @@
+from ctypes import HRESULT as _HRESULT
+
+"""Common HRESULT error codes."""
+
+# NB: have to use ctypes.HRESULT to convert unsigned values to signed int
+
+
+# https://learn.microsoft.com/en-us/windows/win32/debug/system-error-codes--0-499-
+_ERROR_FILE_NOT_FOUND = 2
+
+# https://learn.microsoft.com/en-us/windows/win32/debug/system-error-codes--1000-1299-
+_ERROR_CANCELLED = 1223
+
+
+# https://learn.microsoft.com/en-us/windows/win32/api/winerror/nf-winerror-hresult_facility
+_FACILITY_WIN32 = 7
+
+
+# https://learn.microsoft.com/en-us/windows/win32/api/winerror/nf-winerror-hresult_from_win32
+def _HRESULT_FROM_WIN32(error_code: int) -> _HRESULT:
+    x = _HRESULT(error_code).value
+    return _HRESULT(
+        x if x <= 0 else ((x & 0x0000FFFF) | (_FACILITY_WIN32 << 16) | 0x80000000)
+    )
+
+
+# common errors from CppWinRT
+S_OK = 0
+E_FAIL = _HRESULT(0x80004005).value
+E_ACCESSDENIED = _HRESULT(0x80070005).value
+E_NOTIMPL = _HRESULT(0x80004001).value
+E_INVALIDARG = _HRESULT(0x80070057).value
+E_BOUNDS = _HRESULT(0x8000000B).value
+E_NOINTERFACE = _HRESULT(0x80004002).value
+E_CHANGED_STATE = _HRESULT(0x8000000C).value
+E_ILLEGAL_METHOD_CALL = _HRESULT(0x8000000E).value
+E_ILLEGAL_STATE_CHANGE = _HRESULT(0x8000000D).value
+E_ILLEGAL_DELEGATE_ASSIGNMENT = _HRESULT(0x80000018).value
+E_OUTOFMEMORY = _HRESULT(0x8007000E).value
+CLASS_E_CLASSNOTAVAILABLE = _HRESULT(0x80040111).value
+CO_E_NOTINITIALIZED = _HRESULT(0x800401F0).value
+REGDB_E_CLASSNOTREG = _HRESULT(0x80040154).value
+RPC_E_WRONG_THREAD = _HRESULT(0x8001010E).value
+WIN32_ERROR_FILE_NOT_FOUND = _HRESULT_FROM_WIN32(_ERROR_FILE_NOT_FOUND).value
+WIN32_ERROR_CANCELLED = _HRESULT_FROM_WIN32(_ERROR_CANCELLED).value
+
+# Errors defined by PyWinRT
+PYWINRT_E_UNRAISABLE_PYTHON_EXCEPTION = _HRESULT(0xA0EE4005).value

{winrt_runtime-3.1.0 → winrt_runtime-3.2.0}/src/winrt_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winrt-runtime
-Version: 3.1.0
+Version: 3.2.0
 Summary: Python projection of Windows Runtime (WinRT) APIs
 License-Expression: MIT
 Project-URL: Documentation, https://pywinrt.readthedocs.io

{winrt_runtime-3.1.0 → winrt_runtime-3.2.0}/src/winrt_runtime.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 _winrt.cpp
 _winrt_array.cpp
 _winrt_box.cpp
+_winrt_buffer.cpp
 pyproject.toml
 pywinrt-version.txt
 requirements.txt
@@ -10,8 +11,12 @@ setup.py
 src/winrt/_winrt.pyi
 src/winrt/py.typed
 src/winrt/runtime/__init__.py
+src/winrt/runtime/_internals.py
 src/winrt/runtime/interop.py
+src/winrt/runtime/py.typed
 src/winrt/system/__init__.py
+src/winrt/system/hresult.py
+src/winrt/system/py.typed
 src/winrt_runtime.egg-info/PKG-INFO
 src/winrt_runtime.egg-info/SOURCES.txt
 src/winrt_runtime.egg-info/dependency_links.txt

winrt_runtime-3.1.0/pywinrt-version.txt

@@ -1 +0,0 @@
-3.1.0

winrt_runtime-3.1.0/src/winrt/system/__init__.py

@@ -1,285 +0,0 @@
-import os
-import sys
-from collections.abc import Mapping, MutableMapping, MutableSequence, Sequence
-from pathlib import Path
-from typing import Annotated
-
-from typing_extensions import Buffer, TypeAlias
-
-from .._winrt import (
-    Array,
-    Object,
-    _add_dll_directory,
-    _remove_dll_directory,
-    box_boolean,
-    box_char16,
-    box_date_time,
-    box_double,
-    box_guid,
-    box_int8,
-    box_int16,
-    box_int32,
-    box_int64,
-    box_single,
-    box_string,
-    box_time_span,
-    box_uint8,
-    box_uint16,
-    box_uint32,
-    box_uint64,
-    unbox_boolean,
-    unbox_char16,
-    unbox_date_time,
-    unbox_double,
-    unbox_guid,
-    unbox_int8,
-    unbox_int16,
-    unbox_int32,
-    unbox_int64,
-    unbox_single,
-    unbox_string,
-    unbox_time_span,
-    unbox_uint8,
-    unbox_uint16,
-    unbox_uint32,
-    unbox_uint64,
-)
-
-
-class _DllCookie:
-    def __init__(self, cookie: int) -> None:
-        self.cookie = cookie
-
-    def close(self):
-        if self.cookie:
-            _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(_add_dll_directory(os.fspath(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
-
-
-def _mixin_sequence(typ) -> None:
-    """
-    Adds missing Python mapping methods to types that implement IVectorView and
-    registers the type as a Sequence.
-    """
-    # mixin methods
-    if not hasattr(typ, "index"):
-        typ.index = Sequence.index
-
-    if not hasattr(typ, "count"):
-        typ.count = Sequence.count
-
-    if not hasattr(typ, "__contains__"):
-        typ.__contains__ = Sequence.__contains__
-
-    if not hasattr(typ, "__iter__"):
-        typ.__iter__ = Sequence.__iter__
-
-    if not hasattr(typ, "__reversed__"):
-        typ.__reversed__ = Sequence.__reversed__
-
-    Sequence.register(typ)
-
-
-def _mixin_mutable_sequence(typ) -> None:
-    """
-    Adds missing Python mapping methods to types that implement IVector and
-    registers the type as a MutableSequence.
-    """
-    _mixin_sequence(typ)
-
-    if not hasattr(typ, "insert") and hasattr(typ, "insert_at"):
-
-        def insert(self, index: int, value: object) -> None:
-            """
-            Alias for ``insert_at`` for compatibility with Python Sequence protocol.
-            """
-            self.insert_at(index, value)
-
-        typ.insert = insert
-
-    # mixin methods
-    if not hasattr(typ, "append"):
-        typ.append = MutableSequence.append
-
-    if not hasattr(typ, "clear"):
-        typ.clear = MutableSequence.clear
-
-    if not hasattr(typ, "extend"):
-        typ.extend = MutableSequence.extend
-
-    if not hasattr(typ, "reverse"):
-        typ.reverse = MutableSequence.reverse
-
-    if not hasattr(typ, "pop"):
-        typ.pop = MutableSequence.pop
-
-    if not hasattr(typ, "remove"):
-        typ.remove = MutableSequence.remove
-
-    if not hasattr(typ, "__iadd__"):
-        typ.__iadd__ = MutableSequence.__iadd__
-
-    MutableSequence.register(typ)
-
-
-def _mixin_mapping(typ) -> None:
-    """
-    Adds missing Python mapping methods to types that implement IMapView and
-    registers the type as a Mapping.
-    """
-    # mixin methods
-    if not hasattr(typ, "keys"):
-        typ.keys = Mapping.keys
-
-    if not hasattr(typ, "items"):
-        typ.items = Mapping.items
-
-    if not hasattr(typ, "values"):
-        typ.values = Mapping.values
-
-    if not hasattr(typ, "get"):
-        typ.get = Mapping.get
-
-    if not hasattr(typ, "__contains__"):
-        typ.__contains__ = Mapping.__contains__
-
-    # HACK: Version check works around inheritance anomaly caused by hacky
-    # metaclass inheritance implementation in runtime.cpp. This works as long
-    # as we don't change the projection to implement rich comparison methods
-    # on mapping types.
-
-    if (
-        typ.__eq__ == object.__eq__
-        or typ.__eq__ == Object.__eq__
-        or sys.version_info < (3, 12)
-    ):
-        typ.__eq__ = Mapping.__eq__
-
-    if (
-        typ.__ne__ == object.__ne__
-        or typ.__ne__ == Object.__ne__
-        or sys.version_info < (3, 12)
-    ):
-        typ.__ne__ = Mapping.__ne__
-
-    Mapping.register(typ)
-
-
-def _mixin_mutable_mapping(typ) -> None:
-    """
-    Adds missing Python mapping methods to types that implement IMap and
-    registers the type as a MutableMapping.
-    """
-    _mixin_mapping(typ)
-
-    # mixin methods
-    if not hasattr(typ, "clear"):
-        typ.clear = MutableMapping.clear
-
-    if not hasattr(typ, "pop"):
-        typ.pop = MutableMapping.pop
-        # private-name-mangled attribute :-(
-        typ._MutableMapping__marker = MutableMapping._MutableMapping__marker  # type: ignore
-
-    if not hasattr(typ, "popitem"):
-        typ.popitem = MutableMapping.popitem
-
-    if not hasattr(typ, "setdefault"):
-        typ.setdefault = MutableMapping.setdefault
-
-    if not hasattr(typ, "update"):
-        typ.update = MutableMapping.update
-
-    MutableMapping.register(typ)
-
-
-# type aliases with struct format string annotation
-Int8 = Annotated[int, "b"]
-UInt8 = Annotated[int, "B"]
-Int16 = Annotated[int, "h"]
-UInt16 = Annotated[int, "H"]
-Int32 = Annotated[int, "i"]
-UInt32 = Annotated[int, "I"]
-Int64 = Annotated[int, "q"]
-UInt64 = Annotated[int, "Q"]
-Single = Annotated[float, "f"]
-Double = Annotated[float, "d"]
-Char16 = Annotated[str, "u"]
-
-_mixin_mutable_sequence(Array)
-
-# Type hints for Python buffer protocol - can use standard Python types in
-# addition to the WinRT Array.
-ReadableBuffer: TypeAlias = Buffer  # WinRT PassArray
-WriteableBuffer: TypeAlias = Buffer  # WinRT FillArray
-
-__all__ = [
-    "Int8",
-    "UInt8",
-    "Int16",
-    "UInt16",
-    "Int32",
-    "UInt32",
-    "Int64",
-    "UInt64",
-    "Single",
-    "Double",
-    "Char16",
-    "Object",
-    "Array",
-    "ReadableBuffer",
-    "WriteableBuffer",
-    "box_boolean",
-    "box_int8",
-    "box_uint8",
-    "box_int16",
-    "box_uint16",
-    "box_int32",
-    "box_uint32",
-    "box_int64",
-    "box_uint64",
-    "box_single",
-    "box_double",
-    "box_char16",
-    "box_string",
-    "box_guid",
-    "box_date_time",
-    "box_time_span",
-    "unbox_boolean",
-    "unbox_int8",
-    "unbox_uint8",
-    "unbox_int16",
-    "unbox_uint16",
-    "unbox_int32",
-    "unbox_uint32",
-    "unbox_int64",
-    "unbox_uint64",
-    "unbox_single",
-    "unbox_double",
-    "unbox_char16",
-    "unbox_string",
-    "unbox_guid",
-    "unbox_date_time",
-    "unbox_time_span",
-]