wird 1.0.0__py3-none-any.whl

wird/__init__.py

@@ -0,0 +1,7 @@
+from ._future import Future
+from ._value import Value
+
+__all__ = (
+    "Future",
+    "Value",
+)

wird/_future.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Concatenate,
+    Generator,
+    Type,
+    overload,
+)
+
+__all__ = ("Future",)
+
+
+@dataclass(slots=True, frozen=True)
+class Future[T]:
+    internal: Awaitable[T]
+
+    @staticmethod
+    def from_[V](value: V) -> Future[V]:
+        async def _identity() -> V:
+            return value
+
+        return Future(_identity())
+
+    @overload
+    def unwrap(self) -> Awaitable[T]: ...
+
+    @overload
+    def unwrap[R](self, *, as_type: Type[R]) -> Awaitable[R]: ...
+
+    def unwrap(self, **_) -> Awaitable[Any]:
+        return self.internal
+
+    def map[**P, R](
+        self,
+        fn: Callable[Concatenate[T, P], R],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Future[R]:
+        return Future(_map(self.internal, fn, *args, **kwargs))
+
+    def inspect[**P](
+        self,
+        fn: Callable[Concatenate[T, P], Any],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Future[T]:
+        return Future(_inspect(self.internal, fn, *args, **kwargs))
+
+    def map_async[**P, R](
+        self,
+        fn: Callable[Concatenate[T, P], Awaitable[R]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Future[R]:
+        return Future(_map_async(self.internal, fn, *args, **kwargs))
+
+    def inspect_async[**P](
+        self,
+        fn: Callable[Concatenate[T, P], Awaitable[Any]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Future[T]:
+        return Future(_inspect_async(self.internal, fn, *args, **kwargs))
+
+    def __await__(self) -> Generator[Any, Any, T]:
+        return self.internal.__await__()
+
+
+async def _map[T, **P, R](
+    value: Awaitable[T],
+    fn: Callable[Concatenate[T, P], R],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> R:
+    return fn(await value, *args, **kwargs)
+
+
+async def _inspect[T, **P](
+    value: Awaitable[T],
+    fn: Callable[Concatenate[T, P], Any],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> T:
+    _value = await value
+    fn(_value, *args, **kwargs)
+    return _value
+
+
+async def _map_async[T, **P, R](
+    value: Awaitable[T],
+    fn: Callable[Concatenate[T, P], Awaitable[R]],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> R:
+    return await fn(await value, *args, **kwargs)
+
+
+async def _inspect_async[T, **P](
+    value: Awaitable[T],
+    fn: Callable[Concatenate[T, P], Awaitable[Any]],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> T:
+    _value = await value
+    await fn(_value, *args, **kwargs)
+    return _value

wird/_value.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Concatenate, Type, overload
+
+from . import _future as f
+
+__all__ = ("Value",)
+
+
+@dataclass(slots=True, frozen=True)
+class Value[T]:
+    internal: T
+
+    @overload
+    def unwrap(self) -> T: ...
+
+    @overload
+    def unwrap[R](self, *, as_type: Type[R]) -> R: ...
+
+    def unwrap(self, **_) -> Any:
+        return self.internal
+
+    def map[**P, R](
+        self,
+        fn: Callable[Concatenate[T, P], R],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Value[R]:
+        return Value(fn(self.internal, *args, **kwargs))
+
+    def inspect[**P](
+        self,
+        fn: Callable[Concatenate[T, P], Any],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Value[T]:
+        fn(self.internal, *args, **kwargs)
+        return self
+
+    def map_async[**P, R](
+        self,
+        fn: Callable[Concatenate[T, P], Awaitable[R]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> f.Future[R]:
+        return f.Future(fn(self.internal, *args, **kwargs))
+
+    def inspect_async[**P](
+        self,
+        fn: Callable[Concatenate[T, P], Awaitable[Any]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> f.Future[T]:
+        return f.Future(_inspect_async(self.internal, fn, *args, **kwargs))
+
+
+async def _inspect_async[T, **P](
+    value: T,
+    fn: Callable[Concatenate[T, P], Awaitable[Any]],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> T:
+    await fn(value, *args, **kwargs)
+    return value

wird-1.0.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: wird
+Version: 1.0.0
+Summary: Basic monads for implementing pipe-styled processing
+Project-URL: Repository, https://github.com/katunilya/wird
+Project-URL: Issues, https://github.com/katunilya/wird/issues
+Author-email: Ilya Katun <katun.ilya@gmail.com>
+Maintainer-email: Ilya Katun <katun.ilya@gmail.com>
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# wird

wird-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+wird/__init__.py,sha256=GtVwwTM9vUGrkdBJzxWnA0WmJHiPpP-JvRshMXWIWyo,96
+wird/_future.py,sha256=IH8_2kXlZBamfHDrI1Xid7FrUMRb6fvSzVPd94RfD-8,2545
+wird/_value.py,sha256=XfNWZrEolvGmASnmroxXtyAud-7fJLAdKjRa9t9aCRE,1553
+wird/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wird-1.0.0.dist-info/METADATA,sha256=SOV9O1pgoIn4dn24duv2xuLLOhI7GFV2lvTv23NblDA,403
+wird-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+wird-1.0.0.dist-info/RECORD,,

wird-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any