uarray 0.9.2__cp313-cp313-win32.whl

uarray/_typing.pyi

@@ -0,0 +1,65 @@
+"""Helper module with various typing-related utilities."""
+
+import functools
+from collections.abc import Callable
+from typing import Any, Protocol, TypeVar, Iterable, type_check_only
+
+import uarray
+
+_T = TypeVar("_T")
+_TT = TypeVar("_TT", bound=type[Any])
+_T_co = TypeVar("_T_co", covariant=True)
+
+@type_check_only
+class _PySequence(Protocol[_T_co]):
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: int, /) -> _T_co: ...
+
+@type_check_only
+class _SupportsUA(Protocol):
+    @property
+    def __ua_domain__(self) -> str | _PySequence[str]: ...
+    @property
+    def __ua_cache__(self) -> dict[Any, Any]: ...
+    def __ua_convert__(
+        self,
+        dispatchables: tuple[uarray.Dispatchable[Any, Any], ...],
+        coerce: bool,
+        /,
+    ) -> Iterable[Any]: ...
+
+@type_check_only
+class _PartialDispatchable(functools.partial[uarray.Dispatchable[Any, _TT]]):
+    func: type[uarray.Dispatchable[Any, _TT]]
+    args: tuple[_TT]
+    def __call__(  # type: ignore[override]
+        self,
+        value: _T,
+        coercible: bool = ...,
+    ) -> uarray.Dispatchable[_T, _TT]: ...
+
+_ReplacerFunc = Callable[
+    [
+        tuple[Any, ...],
+        dict[str, Any],
+        tuple[uarray.Dispatchable[Any, Any], ...],
+    ],
+    tuple[tuple[Any, ...], dict[str, Any]],
+]
+
+_PyGlobalDict = dict[
+    str,
+    tuple[
+        tuple[_T | None, bool, bool],
+        list[_T],
+        bool,
+    ],
+]
+
+_PyLocalDict = dict[
+    str,
+    tuple[
+        list[_T],
+        list[tuple[_T, bool, bool]],
+    ],
+]

uarray/_uarray.pyi

@@ -0,0 +1,131 @@
+"""Annotations for the ``uarray._uarray`` extension module."""
+
+import types
+from collections.abc import Callable, Iterable
+from typing import Any, final, overload, Generic
+
+# TODO: Import from `typing` once `uarray` requires Python >= 3.10
+from typing_extensions import ParamSpec
+
+import uarray
+from uarray._typing import (
+    _PyGlobalDict,
+    _PyLocalDict,
+    _ReplacerFunc,
+    _SupportsUA,
+)
+
+_P = ParamSpec("_P")
+
+class BackendNotImplementedError(NotImplementedError): ...
+
+@final
+class _SkipBackendContext:
+    def __init__(self, backend: _SupportsUA) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: types.TracebackType | None,
+        /,
+    ) -> None: ...
+    def _pickle(self) -> tuple[_SupportsUA]: ...
+
+@final
+class _SetBackendContext:
+    def __init__(
+        self,
+        backend: _SupportsUA,
+        coerce: bool = ...,
+        only: bool = ...,
+    ) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: types.TracebackType | None,
+        /,
+    ) -> None: ...
+    def _pickle(self) -> tuple[_SupportsUA, bool, bool]: ...
+
+# NOTE: Parametrize w.r.t. `__ua_domain__` when returning, but use `Any`
+# when used as argument type. Due to lists being invariant the `__ua_domain__`
+# protocol will likelly be disruptivelly strict in the latter case, hence the
+# usage of `Any` as an escape hatch.
+@final
+class _BackendState:
+    def _pickle(self) -> tuple[
+        _PyGlobalDict[_SupportsUA],
+        _PyLocalDict[_SupportsUA],
+        bool,
+    ]: ...
+    @classmethod
+    def _unpickle(
+        cls,
+        py_global: _PyGlobalDict[Any],
+        py_locals: _PyLocalDict[Any],
+        use_thread_local_globals: bool,
+        /,
+    ) -> _BackendState: ...
+
+# TODO: Remove the `type: ignore` once python/mypy#12033 has been bug fixed
+@final  # type: ignore[arg-type]
+class _Function(Generic[_P]):
+    def __init__(
+        self,
+        extractor: Callable[_P, tuple[uarray.Dispatchable[Any, Any], ...]],
+        replacer: None | _ReplacerFunc,
+        domain: str,
+        def_args: tuple[Any, ...],
+        def_kwargs: dict[str, Any],
+        def_impl: None | Callable[..., Any],
+    ) -> None: ...
+    def __repr__(self) -> str: ...
+    def __call__(self, *args: _P.args, **kwargs: _P.kwargs) -> Any: ...
+    @overload
+    def __get__(self, obj: None, type: type[Any]) -> _Function[_P]: ...
+    @overload
+    def __get__(
+        self, obj: object, type: None | type[Any] = ...
+    ) -> types.MethodType: ...
+    @property
+    def arg_extractor(self) -> Callable[_P, tuple[uarray.Dispatchable[Any, Any], ...]]: ...
+    @property
+    def arg_replacer(self) -> None | _ReplacerFunc: ...
+    @property
+    def default(self) -> None | Callable[..., Any]: ...
+    @property
+    def domain(self) -> str: ...
+    # NOTE: These attributes are dynamically inserted by
+    # `uarray.generate_multimethod` via a `functools.update_wrapper` call
+    __module__: str
+    __name__: str
+    __qualname__: str
+    __doc__: None | str
+    __wrapped__: Callable[_P, tuple[uarray.Dispatchable[Any, Any], ...]]
+    __annotations__: dict[str, Any]
+
+def set_global_backend(
+    backend: _SupportsUA,
+    coerce: bool = ...,
+    only: bool = ...,
+    try_last: bool = ...,
+    /,
+) -> None: ...
+def clear_backends(
+    domain: None | str,
+    registered: bool = ...,
+    global_: bool = ...,
+    /,
+) -> None: ...
+def determine_backend(
+    domain_object: str,
+    dispatchables: Iterable[uarray.Dispatchable[Any, Any]],
+    coerce: bool,
+    /,
+) -> _SupportsUA: ...
+def register_backend(backend: _SupportsUA, /) -> None: ...
+def get_state() -> _BackendState: ...
+def set_state(arg: _BackendState, reset_allowed: bool = ..., /) -> None: ...

uarray/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.9.2'
+__version_tuple__ = version_tuple = (0, 9, 2)

uarray/conftest.py

@@ -0,0 +1,11 @@
+import sys
+import uarray
+import pytest  # type: ignore
+
+from .tests import example_helpers
+
+
+@pytest.fixture(autouse=True)
+def add_namespaces(doctest_namespace):
+    doctest_namespace["ua"] = uarray
+    doctest_namespace["ex"] = example_helpers

uarray/pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+addopts = --doctest-modules --junitxml=junit/test-results.xml --cov-report=xml:./coverage/coverage.xml --cov-report=term --cov . --cov-report html --cov-config .coveragerc
+doctest_optionflags= IGNORE_EXCEPTION_DETAIL

uarray/tests/example_helpers.py

@@ -0,0 +1,46 @@
+import uarray as ua
+
+
+class _TypedBackend:
+    __ua_domain__ = "ua_examples"
+
+    def __init__(self, *my_types):
+        self.my_types = my_types
+
+    def __ua_convert__(self, dispatchables, coerce):
+        if not all(type(d.value) in self.my_types for d in dispatchables):
+            return NotImplemented
+        return tuple(d.value for d in dispatchables)
+
+    def __ua_function__(self, func, args, kwargs):
+        return self.my_types[0]()
+
+
+class TypeA:
+    @classmethod
+    def __repr__(cls):
+        return cls.__name__
+
+
+class TypeB(TypeA):
+    pass
+
+
+class TypeC(TypeA):
+    pass
+
+
+BackendA = _TypedBackend(TypeA)
+BackendB = _TypedBackend(TypeB)
+BackendC = _TypedBackend(TypeC)
+BackendAB = _TypedBackend(TypeA, TypeB)
+BackendBC = _TypedBackend(TypeB, TypeC)
+
+creation_multimethod = ua.generate_multimethod(
+    lambda: (), lambda a, kw, d: (a, kw), "ua_examples"
+)
+call_multimethod = ua.generate_multimethod(
+    lambda *a: tuple(ua.Dispatchable(x, "mark") for x in a),
+    lambda a, kw, d: (a, kw),
+    "ua_examples",
+)