winrt-runtime 2.2.0__cp313-cp313-win_amd64.whl

winrt/_winrt.pyi

@@ -0,0 +1,142 @@
+import array
+import types
+from typing import (
+    Any,
+    Generic,
+    ItemsView,
+    Iterable,
+    Iterator,
+    KeysView,
+    List,
+    SupportsIndex,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    ValuesView,
+    overload,
+)
+from uuid import UUID
+
+MTA: int
+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")
+_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.
+
+# these classes don't actually exist but are just used to simplify type checking
+
+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) -> _VT_co | None: ...
+    @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 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, _T | None], __key: _KT, __default: None = None
+    ) -> _T | None: ...
+    @overload
+    def setdefault(self, __key: _KT, __default: _VT) -> _VT: ...
+    @overload
+    def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, **kwargs: _VT) -> None: ...
+
+# actual runtime classes
+
+class Object:
+    @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 __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: ...

winrt/system/__init__.py

@@ -0,0 +1,193 @@
+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
+
+
+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__
+
+    if typ.__eq__ == object.__eq__:
+        typ.__eq__ = Mapping.__eq__
+
+    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"]
+
+Object = _winrt.Object
+Array = _winrt.Array
+_mixin_mutable_sequence(Array)
+
+__all__ = [
+    "Int8",
+    "UInt8",
+    "Int16",
+    "UInt16",
+    "Int32",
+    "UInt32",
+    "Int64",
+    "UInt64",
+    "Single",
+    "Double",
+    "Char16",
+    "Object",
+    "Array",
+]

winrt_runtime-2.2.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: winrt-runtime
+Version: 2.2.0
+Summary: Python projection of Windows Runtime (WinRT) APIs
+License: 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.14,>=3.9
+Description-Content-Type: text/markdown
+
+# winrt-runtime
+
+This package provides the PyWinRT runtime including the `winrt.system` module.
+

winrt_runtime-2.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+winrt/_winrt.cp313-win_amd64.pyd,sha256=zKetWB-FyuifsMC_DZl9yVMplo0HHghcJ2HEkPaoJSk,61952
+winrt/_winrt.pyi,sha256=UifonvgkiEsucdOnRLoaF1Pp_FHsTiyFskAeFV02_qQ,4223
+winrt/msvcp140.dll,sha256=4KIqWU4Uj6Vc7vPkmWm_p3ARqAEmegvXgFtoG1k8nQs,567328
+winrt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+winrt/system/__init__.py,sha256=1gEFHFT7ZreiH52rLaxyOtLFA16m5Zv_pbGpSnKfZhQ,4861
+winrt_runtime-2.2.0.dist-info/METADATA,sha256=INdW3VuWFG_Z3OHauRNw7q1_B8enl2MmYteuECvFR3g,733
+winrt_runtime-2.2.0.dist-info/WHEEL,sha256=CdxowNJ2RPRCxUxJWAQ4R_o8uA51cjotGywc47Ht6wA,101
+winrt_runtime-2.2.0.dist-info/top_level.txt,sha256=BzwQb4dZRt0NxCXi10ARjWsox7Asmtf_lXrw_KR-D_E,6
+winrt_runtime-2.2.0.dist-info/RECORD,,

winrt_runtime-2.2.0.dist-info/WHEEL

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

winrt_runtime-2.2.0.dist-info/top_level.txt

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