winrt-runtime 3.2.1__tar.gz → 4.0.1__tar.gz

winrt_runtime-4.0.1/LICENSE

@@ -0,0 +1,22 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Copyright (c) 2021-2026 David Lechner <david@pybricks.com>
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

winrt_runtime-4.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+# the headers are not installed, but building from the sdist needs them
+recursive-include src *.h

winrt_runtime-4.0.1/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: winrt-runtime
+Version: 4.0.1
+Summary: The runtime that every PyWinRT projection package runs on
+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/runtime/CHANGELOG.md
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing_extensions>=4.12.2
+Dynamic: license-file
+
+# winrt-runtime
+
+This package provides the PyWinRT runtime including the `winrt.system` module.
+
+Every PyWinRT package requires it, so pip installs it with any of them. Each
+WinRT namespace is a package of its own, so install the package of each
+namespace your code imports from, such as `winrt-Windows.Foundation`.
+
+## For interop modules
+
+Compiled code outside the runtime, such as the interop packages, exchanges
+WinRT objects with it through the Python functions of `winrt.runtime.interop`
+rather than a C ABI: `as_interface()` gives an interface of a projected object
+as an interface pointer capsule, `wrap_interface()` makes a projected object of
+one, and `hresult_error()` builds the exception that a failed call raises. An interface pointer capsule is named `"winrt.interface"`
+and holds one reference, which its destructor releases.

winrt_runtime-4.0.1/README.md

@@ -0,0 +1,16 @@
+# winrt-runtime
+
+This package provides the PyWinRT runtime including the `winrt.system` module.
+
+Every PyWinRT package requires it, so pip installs it with any of them. Each
+WinRT namespace is a package of its own, so install the package of each
+namespace your code imports from, such as `winrt-Windows.Foundation`.
+
+## For interop modules
+
+Compiled code outside the runtime, such as the interop packages, exchanges
+WinRT objects with it through the Python functions of `winrt.runtime.interop`
+rather than a C ABI: `as_interface()` gives an interface of a projected object
+as an interface pointer capsule, `wrap_interface()` makes a projected object of
+one, and `hresult_error()` builds the exception that a failed call raises. An interface pointer capsule is named `"winrt.interface"`
+and holds one reference, which its destructor releases.

winrt_runtime-4.0.1/pyproject.toml

@@ -0,0 +1,62 @@
+# WARNING: Please don't edit this file. It was automatically generated.
+
+[build-system]
+requires = ["setuptools>=78"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "winrt-runtime"
+description = "The runtime that every PyWinRT projection package runs on"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: Free Threading :: 2 - Beta",
+    "Typing :: Typed",
+]
+dynamic = ["version", "dependencies"]
+requires-python = ">=3.11"
+
+[project.urls]
+Documentation = "https://pywinrt.readthedocs.io"
+Repository = "https://github.com/pywinrt/pywinrt"
+Changelog = "https://github.com/pywinrt/pywinrt/blob/main/runtime/CHANGELOG.md"
+
+[tool.setuptools.dynamic]
+version = { file = "version.txt" }
+dependencies = { file = "requirements.txt" }
+
+[tool.setuptools.packages.find]
+where = ["python"]
+
+# A projection package is a table beside an __init__.py, and the type a call
+# hands back is resolved by importing the module that owns it while the
+# program runs. A freezer sees neither, so winrt-runtime ships the hook that
+# tells PyInstaller about both, and this is how PyInstaller finds it without
+# the application being frozen having to configure anything.
+[project.entry-points.pyinstaller40]
+hook-dirs = "winrt.__pyinstaller:get_hook_dirs"
+
+[tool.setuptools.package-data]
+"*" = ["*.pyi", "py.typed"]
+
+[tool.cibuildwheel]
+# don't build for PyPy
+skip = "pp*"
+# suppress warnings about ARM64 testing
+test-skip = "*-win_arm64"
+test-command = "python -c \"import winrt._winrt\""
+
+[tool.cibuildwheel.windows]
+archs = ["x86", "AMD64", "ARM64"]
+# nothing here is copied in after the build, so there is no repair step
+repair-wheel-command = ""

winrt_runtime-4.0.1/python/winrt/__pyinstaller/__init__.py

@@ -0,0 +1,13 @@
+"""
+Where PyInstaller finds PyWinRT's hook.
+
+``winrt-runtime`` declares this module in the ``pyinstaller40`` entry point
+group, so PyInstaller asks it for the directory the hook is in and needs no
+configuration from the application being frozen.
+"""
+
+import os
+
+
+def get_hook_dirs() -> list[str]:
+    return [os.path.dirname(__file__)]

winrt_runtime-4.0.1/python/winrt/__pyinstaller/hook-winrt.py

@@ -0,0 +1,85 @@
+"""
+What a frozen application needs from PyWinRT that PyInstaller cannot see.
+
+Two things are invisible to an import graph.
+
+A projected namespace is a data file. ``winrt.windows.storage`` is an
+``__init__.py`` that asks the runtime to read the ``_table.pywinrt`` sitting
+beside it, so freezing the module without the table produces an executable
+that fails at import. PyInstaller collects the module and not the table.
+
+A projected type is resolved by importing the module that owns it, by name,
+while the program runs (``py::get_python_type()`` in the runtime). A call
+that hands back an ``IAsyncOperation`` imports ``winrt.windows.foundation``
+whether or not the application ever names it, and nothing in the source says
+so. So every projection package that is installed is collected rather than
+only the ones the graph reached: what an application imports says little
+about which namespaces its calls return types from.
+
+Nothing here names a Windows SDK, a Windows App SDK or any other family. What
+is collected is what the installed distributions say they ship, so a
+projection somebody else generated is collected on the same terms as the ones
+published from this repository.
+"""
+
+from importlib.metadata import distributions
+
+# the data file a projection package carries, which
+# winrt.runtime._internals.load_projection() reads from beside the module
+TABLE_NAME = "_table.pywinrt"
+
+binaries: list[tuple[str, str]] = []
+datas: list[tuple[str, str]] = []
+hiddenimports: list[str] = []
+
+
+def _installed_files() -> list[tuple[str, str, str]]:
+    """
+    Every file of every installed distribution, as (name, package, source).
+
+    ``package`` is the dotted package the file sits in and ``source`` is where
+    it is now. A distribution installed from a wheel records what it put where;
+    one that did not record it is something this can say nothing about.
+    """
+    files: list[tuple[str, str, str]] = []
+
+    for distribution in distributions():
+        for file in distribution.files or []:
+            directory = str(file).replace("\\", "/").rpartition("/")[0]
+
+            if directory:
+                files.append(
+                    (file.name, directory, str(distribution.locate_file(file)))
+                )
+
+    return files
+
+
+def _collect() -> None:
+    installed = _installed_files()
+
+    # The namespace roots PyWinRT projects into are whichever ones hold a
+    # table, rather than a list of names kept here: the runtime has no
+    # business knowing which families exist.
+    roots = {
+        package.partition("/")[0]
+        for name, package, _ in installed
+        if name == TABLE_NAME
+    }
+
+    for name, package, source in installed:
+        if package.partition("/")[0] not in roots:
+            continue
+
+        if name == TABLE_NAME:
+            datas.append((source, package))
+            hiddenimports.append(package.replace("/", "."))
+
+        # A package that redistributes a component .dll loads it by bare name
+        # after putting its own directory on the DLL search path, so no import
+        # table mentions it and nothing else would collect it.
+        if name.lower().endswith(".dll"):
+            binaries.append((source, package))
+
+
+_collect()

winrt_runtime-4.0.1/python/winrt/_winrt.pyi

@@ -0,0 +1,169 @@
+import abc
+import collections.abc
+from datetime import datetime, timedelta
+import types
+from typing import (
+    Any,
+    ClassVar,
+    Protocol,
+    Self,
+    SupportsIndex,
+    TypeVar,
+    final,
+    overload,
+)
+from collections.abc import Iterable, Iterator
+from uuid import UUID
+
+from typing_extensions import Buffer, TypeForm, deprecated
+
+from winrt.runtime import ApartmentType
+from winrt.runtime.interop import InterfaceCapsule
+
+MTA: int
+STA: int
+
+def init_apartment(apartment_type: ApartmentType, /) -> None: ...
+def uninit_apartment() -> None: ...
+def initialize_with_window(obj: Object, hwnd: SupportsIndex, /) -> None: ...
+def load_projection(module: types.ModuleType, table_path: str, /) -> None: ...
+@overload
+def as_interface(obj: Object, iid: UUID | type[Object], /) -> InterfaceCapsule: ...
+@overload
+def as_interface(obj: None, iid: UUID | type[Object], /) -> None: ...
+def get_activation_factory(
+    cls: type[Object], iid: UUID | type[Object], /
+) -> InterfaceCapsule: ...
+@overload
+def wrap_interface(
+    capsule: InterfaceCapsule, type: TypeForm[_TObject], /
+) -> _TObject: ...
+@overload
+def wrap_interface(capsule: InterfaceCapsule, qualified_name: str, /) -> Any: ...
+@overload
+def wrap_interface(capsule: None, type: type[Object] | str, /) -> None: ...
+def hresult_error(
+    hresult: SupportsIndex, error_info: InterfaceCapsule | None = None, /
+) -> OSError: ...
+def box_boolean(value: bool, /) -> Object: ...
+def box_int8(value: SupportsIndex, /) -> Object: ...
+def box_uint8(value: SupportsIndex, /) -> Object: ...
+def box_int16(value: SupportsIndex, /) -> Object: ...
+def box_uint16(value: SupportsIndex, /) -> Object: ...
+def box_int32(value: SupportsIndex, /) -> Object: ...
+def box_uint32(value: SupportsIndex, /) -> Object: ...
+def box_int64(value: SupportsIndex, /) -> Object: ...
+def box_uint64(value: SupportsIndex, /) -> 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: ...
+
+# Reads a projection table and returns its contents as plain Python objects, so
+# that test/test_table.py can check that the generator's writer and this
+# module's reader agree on the format. The shape of the result follows
+# runtime/src/table-format.md rather than a type of its own.
+def read_table(data: Buffer, /) -> dict[str, Any]: ...
+
+_T = TypeVar("_T")
+_TObject = TypeVar("_TObject", bound=Object)
+
+# What as_() asks of the type it is given, a projected one or an interop
+# interface alike: as_(type) is type._query_interface_(obj).
+class _SupportsQueryInterface(Protocol):
+    @classmethod
+    def _query_interface_(cls, obj: Object, /) -> Self: ...
+
+_TQueryInterface = TypeVar("_TQueryInterface", bound=_SupportsQueryInterface)
+
+# Declared as an ABCMeta although at run time it derives from type: a type
+# checker requires an abstract member to be implemented only under ABCMeta, and
+# the members of an interface are abstract.
+class Object_Static(abc.ABCMeta):
+    def __instancecheck__(self, instance: Any) -> bool: ...
+    def __subclasscheck__(self, subclass: type) -> bool: ...
+
+# The type of everything WinRT can hold. A Python class that implements a WinRT
+# interface derives from the projected name of that interface, and therefore
+# from this, without being a wrapper around a WinRT object (at run time it does
+# not derive from Object, and isinstance() says it is one all the same): the
+# runtime gives it the three members below as it gives a wrapper. The members
+# of the interface itself are abstract, because implementing them is what
+# deriving from it means.
+class Object(metaclass=Object_Static):
+    def as_(self, type: TypeForm[_TQueryInterface], /) -> _TQueryInterface: ...
+    @property
+    def _iids_(self) -> Array[UUID]: ...
+    @property
+    def _runtime_class_name_(self) -> str: ...
+    # what as_() calls, which the runtime gives the projected name of an
+    # interface as well as the wrapper
+    @classmethod
+    def _query_interface_(cls, obj: Object, /) -> Self: ...
+
+@final
+class Array(collections.abc.Sequence[_T]):
+    _winrt_element_type_name_: str
+    def __class_getitem__(cls, key: Any) -> types.GenericAlias: ...
+    @overload
+    def __init__(self, type: TypeForm[_T], /) -> None: ...
+    @overload
+    def __init__(
+        self,
+        type: TypeForm[_T],
+        size: SupportsIndex,
+        /,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        type: TypeForm[_T],
+        initializer: Buffer,
+        /,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        type: TypeForm[_T],
+        initializer: Iterable[_T],
+        /,
+    ) -> None: ...
+    @overload
+    @deprecated("Passing a format string to Array is deprecated: pass the type instead")
+    def __init__(
+        self,
+        type: str,
+        initializer: SupportsIndex | Buffer | Iterable[Any],
+        /,
+    ) -> 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) -> Array[_T]: ...
+    def __setitem__(self, index: SupportsIndex, value: _T) -> None: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __eq__(self, other: object, /) -> bool: ...
+    def __ne__(self, other: object, /) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]

{winrt_runtime-3.2.1/src → winrt_runtime-4.0.1/python}/winrt/runtime/__init__.py

@@ -1,5 +1,12 @@
 from enum import IntEnum
 
+# winrt._winrt imports uuid when it loads, from compiled code, where a freezer
+# that follows a program's imports cannot see it. Everything that loads the
+# runtime imports this package, so saying it here puts uuid in the bundle.
+import uuid
+
+del uuid
+
 from winrt._winrt import init_apartment, uninit_apartment, STA, MTA