winrt-runtime 3.2.1__cp314-cp314-win_amd64.whl

winrt/_winrt.pyi

@@ -0,0 +1,204 @@
+from abc import abstractmethod
+import array
+from datetime import datetime, timedelta
+import types
+from typing import (
+    Any,
+    Generic,
+    ItemsView,
+    Iterable,
+    Iterator,
+    KeysView,
+    List,
+    Optional,
+    Protocol,
+    SupportsIndex,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    ValuesView,
+    overload,
+)
+from uuid import UUID
+
+from winrt.runtime import ApartmentType
+
+MTA: int
+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 box_boolean(value: bool) -> Object: ...
+def box_int8(value: int) -> Object: ...
+def box_uint8(value: int) -> Object: ...
+def box_int16(value: int) -> Object: ...
+def box_uint16(value: int) -> Object: ...
+def box_int32(value: int) -> Object: ...
+def box_uint32(value: int) -> Object: ...
+def box_int64(value: int) -> Object: ...
+def box_uint64(value: int) -> Object: ...
+def box_single(value: float) -> Object: ...
+def box_double(value: float) -> Object: ...
+def box_char16(value: str) -> Object: ...
+def box_string(value: str) -> Object: ...
+def box_guid(value: UUID) -> Object: ...
+def box_date_time(value: datetime) -> Object: ...
+def box_time_span(value: timedelta) -> Object: ...
+def unbox_boolean(value: Object) -> bool: ...
+def unbox_int8(value: Object) -> int: ...
+def unbox_uint8(value: Object) -> int: ...
+def unbox_int16(value: Object) -> int: ...
+def unbox_uint16(value: Object) -> int: ...
+def unbox_int32(value: Object) -> int: ...
+def unbox_uint32(value: Object) -> int: ...
+def unbox_int64(value: Object) -> int: ...
+def unbox_uint64(value: Object) -> int: ...
+def unbox_single(value: Object) -> float: ...
+def unbox_double(value: Object) -> float: ...
+def unbox_char16(value: Object) -> str: ...
+def unbox_string(value: Object) -> str: ...
+def unbox_guid(value: Object) -> UUID: ...
+def unbox_date_time(value: Object) -> datetime: ...
+def unbox_time_span(value: Object) -> timedelta: ...
+
+_Self = TypeVar("_Self")
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)  # Any type covariant containers.
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+_VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
+_TObject = TypeVar("_TObject", bound=IInspectable)
+
+# these classes don't actually exist but are just used to simplify type checking
+
+class IInspectable_Static(type):
+    def __instancecheck__(self, instance: Any) -> bool: ...
+
+class IInspectable(metaclass=IInspectable_Static):
+    @abstractmethod
+    def as_(self, type: Type[_TObject], /) -> _TObject: ...
+    @property
+    @abstractmethod
+    def _iids_(self) -> Array[UUID]: ...
+    @property
+    @abstractmethod
+    def _runtime_class_name_(self) -> str: ...
+
+class Sequence(Generic[_T_co]):
+    # collections.abc.Sequence mixin methods
+    def index(self, value: Any, start: int = 0, stop: int = ...) -> int: ...
+    def count(self, value: Any) -> int: ...
+    def __reversed__(self) -> Iterator[_T_co]: ...
+
+class MutableSequence(Sequence[_T]):
+    # alias for insert_at
+    def insert(self, index: SupportsIndex, value: _T) -> None: ...
+    # collections.abc.MutableSequence mixin methods
+    def extend(self, values: Iterable[_T]) -> None: ...
+    def reverse(self) -> None: ...
+    def pop(self, index: int = -1) -> _T: ...
+    def remove(self, value: _T) -> None: ...
+    def __iadd__(self: _Self, values: Iterable[_T]) -> _Self: ...
+
+class Mapping(Generic[_KT, _VT_co]):
+    # collections.abc.Mapping mixin methods
+    @overload
+    def get(self, __key: _KT) -> Optional[_VT_co]: ...
+    @overload
+    def get(self, __key: _KT, default: _VT_co | _T) -> _VT_co | _T: ...
+    def items(self) -> ItemsView[_KT, _VT_co]: ...
+    def keys(self) -> KeysView[_KT]: ...
+    def values(self) -> ValuesView[_VT_co]: ...
+    def __eq__(self, __other: object) -> bool: ...
+
+class SupportsKeysAndGetItem(Protocol[_KT, _VT_co]):
+    def keys(self) -> Iterable[_KT]: ...
+    def __getitem__(self, key: _KT, /) -> _VT_co: ...
+
+class MutableMapping(Mapping[_KT, _VT]):
+    # collections.abc.MutableMapping mixin methods
+    @overload
+    def pop(self, __key: _KT) -> _VT: ...
+    @overload
+    def pop(self, __key: _KT, default: _VT) -> _VT: ...
+    @overload
+    def pop(self, __key: _KT, default: _T) -> _VT | _T: ...
+    def popitem(self) -> Tuple[_KT, _VT]: ...
+    @overload
+    def setdefault(
+        self: MutableMapping[_KT, Optional[_T]], __key: _KT, __default: None = None
+    ) -> Optional[_T]: ...
+    @overload
+    def setdefault(self, __key: _KT, __default: _VT) -> _VT: ...
+    @overload
+    def update(self, m: SupportsKeysAndGetItem[_KT, _VT], /, **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, m: Iterable[tuple[_KT, _VT]], /, **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, **kwargs: _VT) -> None: ...
+
+# actual runtime classes
+
+class Object(IInspectable):
+    def as_(self, type: Type[_TObject], /) -> _TObject: ...
+    @property
+    def _iids_(self) -> Array[UUID]: ...
+    @property
+    def _runtime_class_name_(self) -> str: ...
+
+class Array(MutableSequence[_T]):
+    _winrt_element_type_name_: str
+    def __class_getitem__(cls, key: Any) -> types.GenericAlias: ...
+    @overload
+    def __init__(
+        self,
+        type: Union[Type[_T], str],
+        size: int,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        type: Union[Type[_T], str],
+        initializer: memoryview,
+    ) -> None: ...
+    @overload
+    def __init__(self, type: str, initializer: array.array) -> None: ...
+    @overload
+    def __init__(
+        self,
+        type: Union[Type[_T], str],
+        initializer: Array[_T],
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        type: Union[Type[_T], str],
+        initializer: List[_T],
+        /,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        __type: Union[Type[_T], str],
+        __initializer: Tuple[_T],
+    ) -> None: ...
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __release_buffer__(self, view: memoryview, /) -> None: ...
+    def __len__(self) -> int: ...
+    @overload
+    def __getitem__(self, index: SupportsIndex) -> _T: ...
+    @overload
+    def __getitem__(self, index: slice) -> MutableSequence[_T]: ...
+    @overload
+    def __setitem__(self, index: SupportsIndex, value: _T) -> None: ...
+    @overload
+    def __setitem__(self, index: slice, value: Iterable[_T]) -> None: ...
+    @overload
+    def __delitem__(self, index: SupportsIndex) -> None: ...
+    @overload
+    def __delitem__(self, index: slice) -> None: ...
+    def __iter__(self) -> Iterator[_T]: ...

winrt/runtime/__init__.py

@@ -0,0 +1,21 @@
+from enum import IntEnum
+
+from winrt._winrt import init_apartment, uninit_apartment, STA, MTA
+
+
+__all__ = ["ApartmentType", "init_apartment", "uninit_apartment"]
+
+
+class ApartmentType(IntEnum):
+    """
+    Enumeration of COM apartment types.
+    """
+
+    SINGLE_THREADED = STA
+    """
+    Single-threaded apartment.
+    """
+    MULTI_THREADED = MTA
+    """
+    Multi-threaded apartment.
+    """

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
+
+# NB: have to import Object from here instead of winrt.system to avoid circular import issues.
+from winrt._winrt import add_dll_directory, remove_dll_directory, 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/interop.py

@@ -0,0 +1,3 @@
+from winrt._winrt import initialize_with_window
+
+__all__ = ["initialize_with_window"]

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/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.2.1.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: winrt-runtime
+Version: 3.2.1
+Summary: Python projection of Windows Runtime (WinRT) APIs
+License-Expression: MIT
+Project-URL: Documentation, https://pywinrt.readthedocs.io
+Project-URL: Repository, https://github.com/pywinrt/pywinrt
+Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typing_extensions>=4.12.2
+
+# winrt-runtime
+
+This package provides the PyWinRT runtime including the `winrt.system` module.
+

winrt_runtime-3.2.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+winrt/_winrt.cp314-win_amd64.pyd,sha256=WiCsPsLQXzNhCxE4Ri4OgaNxEDqBRtqaHKCpNYDyFXM,136192
+winrt/_winrt.pyi,sha256=VXsxaX7eY1WXXET8YAgICfSC241dPdKBIOLWQX5ZekE,6719
+winrt/msvcp140.dll,sha256=dYcsQmVVrIr1W1p_bUrqiDGvdDU7ImEoUKK_xA47Z-E,567352
+winrt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+winrt/runtime/__init__.py,sha256=wooCBSTk7sHWfJQTc0p7VtYfn5R5MCMrR1BmEd6amDc,395
+winrt/runtime/_internals.py,sha256=ridFxQhjmTg69mA5PenYbj0o75jc84pwSTKHmtGEwos,7092
+winrt/runtime/interop.py,sha256=N5os9rMKR-HeLPJiS2XTm7fJcZckL5jXr8l_cWk5D9k,86
+winrt/runtime/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+winrt/system/__init__.py,sha256=vJmG-bSJ3Z48y7PAz6th5cTYwjATIHMTpmlaBRN6qVI,2190
+winrt/system/hresult.py,sha256=hpK6pRSVRc8qk1JfRkwelnpkUDtvJ8MZrB6vfCc7c7k,1757
+winrt/system/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+winrt_runtime-3.2.1.dist-info/METADATA,sha256=AVwSmar_KVyrisTxjNlGsFLZ6pyCxYt5X7pUh3fK0K4,780
+winrt_runtime-3.2.1.dist-info/WHEEL,sha256=7k6Wcy588iJYe5lf5K095NLg-uoBTnE-T8eHJ92G4_4,101
+winrt_runtime-3.2.1.dist-info/top_level.txt,sha256=BzwQb4dZRt0NxCXi10ARjWsox7Asmtf_lXrw_KR-D_E,6
+winrt_runtime-3.2.1.dist-info/RECORD,,

winrt_runtime-3.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314-win_amd64
+

winrt_runtime-3.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+winrt