Have AsyncValueFn leverage generic WrapAsync as base class

Author: schloerke

shiny/_utils.py

@@ -21,6 +21,7 @@
     Awaitable,
     Callable,
     Generator,
+    Generic,
     Iterable,
     Optional,
     TypeVar,
@@ -279,58 +280,85 @@ async def fn_async(*args: P.args, **kwargs: P.kwargs) -> R:
     return fn_async
 
 
-# # TODO-barret-future; Q: Keep code?
-# class WrapAsync(Generic[P, R]):
-#     """
-#     Make a function asynchronous.
-
-#     Parameters
-#     ----------
-#     fn
-#         Function to make asynchronous.
-
-#     Returns
-#     -------
-#     :
-#         Asynchronous function (within the `WrapAsync` instance)
-#     """
-
-#     def __init__(self, fn: Callable[P, R] | Callable[P, Awaitable[R]]):
-#         if isinstance(fn, WrapAsync):
-#             fn = cast(WrapAsync[P, R], fn)
-#             return fn
-#         self._is_async = is_async_callable(fn)
-#         self._fn = wrap_async(fn)
-
-#     async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
-#         """
-#         Call the asynchronous function.
-#         """
-#         return await self._fn(*args, **kwargs)
-
-#     @property
-#     def is_async(self) -> bool:
-#         """
-#         Was the original function asynchronous?
-
-#         Returns
-#         -------
-#         :
-#             Whether the original function is asynchronous.
-#         """
-#         return self._is_async
-
-#     @property
-#     def fn(self) -> Callable[P, R] | Callable[P, Awaitable[R]]:
-#         """
-#         Retrieve the original function
-
-#         Returns
-#         -------
-#         :
-#             Original function supplied to the `WrapAsync` constructor.
-#         """
-#         return self._fn
+class WrapAsync(Generic[P, R]):
+    """
+    Make a function asynchronous.
+
+    Parameters
+    ----------
+    fn
+        Function to make asynchronous.
+
+    Returns
+    -------
+    :
+        Asynchronous function (within the `WrapAsync` instance)
+    """
+
+    _fn: Callable[P, Awaitable[R]]
+    _is_async: bool
+    _orig_fn: Callable[P, R] | Callable[P, Awaitable[R]]
+
+    def __init__(
+        self,
+        fn: Callable[P, R] | Callable[P, Awaitable[R]],
+    ):
+        if isinstance(fn, WrapAsync):
+            wa = cast(WrapAsync[P, R], fn)
+            self._fn = wa._fn
+            self._is_async = wa._is_async
+            self._orig_fn = wa._orig_fn
+        else:
+            self._is_async = is_async_callable(fn)
+            self._fn = wrap_async(fn)
+            self._orig_fn = fn
+
+    async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        """
+        Call the asynchronous function.
+        """
+        return await self._fn(*args, **kwargs)
+
+    def is_async(self) -> bool:
+        """
+        Was the original function asynchronous?
+
+        Returns
+        -------
+        :
+            Whether the original function is asynchronous.
+        """
+        return self._is_async
+
+    def get_async_fn(self) -> Callable[P, Awaitable[R]]:
+        """
+        Return the async value function.
+
+        Returns
+        -------
+        :
+            Async wrapped value function supplied to the `AsyncValueFn` constructor.
+        """
+        return self._fn
+
+    def get_sync_fn(self) -> Callable[P, R]:
+        """
+        Retrieve the original, synchronous value function function.
+
+        If the original function was asynchronous, a runtime error will be thrown.
+
+        Returns
+        -------
+        :
+            Original, synchronous function supplied to the `AsyncValueFn` constructor.
+        """
+        if self._is_async:
+            raise RuntimeError(
+                "The original function was asynchronous. Use `async_fn` instead."
+            )
+
+        sync_fn = cast(Callable[P, R], self._orig_fn)
+        return sync_fn
 
 
 # This function should generally be used in this code base instead of

shiny/render/renderer/_renderer.py

@@ -9,14 +9,13 @@
     Optional,
     TypeVar,
     Union,
-    cast,
 )
 
 from htmltools import MetadataNode, Tag, TagList
 
 from ..._docstring import add_example
 from ..._typing_extensions import Self
-from ..._utils import is_async_callable, wrap_async
+from ..._utils import WrapAsync
 from ...types import Jsonifiable
 
 if TYPE_CHECKING:
@@ -336,10 +335,7 @@ def _auto_register(self) -> None:
                 self._auto_registered = True
 
 
-# Not inheriting from `WrapAsync[[], IT]` as python 3.8 needs typing extensions that
-# doesn't support `[]` for a ParamSpec definition. :-( Would be minimal/clean if we
-# could do `class AsyncValueFn(WrapAsync[[], IT]):`
-class AsyncValueFn(Generic[IT]):
+class AsyncValueFn(WrapAsync[[], IT | None]):
     """
     App-supplied output value function which returns type `IT`.
     asynchronous.
@@ -355,52 +351,4 @@ def __init__(
             raise TypeError(
                 "Must not call `AsyncValueFn.__init__` with an object of class `AsyncValueFn`"
             )
-        self._is_async = is_async_callable(fn)
-        self._fn = wrap_async(fn)
-        self._orig_fn = fn
-
-    async def __call__(self) -> IT | None:
-        """
-        Call the asynchronous function.
-        """
-        return await self._fn()
-
-    def is_async(self) -> bool:
-        """
-        Was the original function asynchronous?
-
-        Returns
-        -------
-        :
-            Whether the original function is asynchronous.
-        """
-        return self._is_async
-
-    def get_async_fn(self) -> Callable[[], Awaitable[IT | None]]:
-        """
-        Return the async value function.
-
-        Returns
-        -------
-        :
-            Async wrapped value function supplied to the `AsyncValueFn` constructor.
-        """
-        return self._fn
-
-    def get_sync_fn(self) -> Callable[[], IT | None]:
-        """
-        Retrieve the original, synchronous value function function.
-
-        If the original function was asynchronous, a runtime error will be thrown.
-
-        Returns
-        -------
-        :
-            Original, synchronous function supplied to the `AsyncValueFn` constructor.
-        """
-        if self._is_async:
-            raise RuntimeError(
-                "The original function was asynchronous. Use `async_fn` instead."
-            )
-        sync_fn = cast(Callable[[], IT], self._orig_fn)
-        return sync_fn
+        super().__init__(fn)