Merge pull request #71 from rstudio/value-silent-exception

Author: wch

shiny/reactive/_reactives.py

@@ -12,6 +12,7 @@
     Union,
     Generic,
     cast,
+    overload,
 )
 import warnings
 
@@ -28,18 +29,40 @@
 # Value
 # ==============================================================================
 class Value(Generic[T]):
-    def __init__(self, value: T, *, _read_only: bool = False) -> None:
+    # These overloads are necessary so that the following hold:
+    # - Value() is marked by the type checker as an error, because the type T is
+    #   unknown. (It is not a run-time error.)
+    # - Value[int]() works.
+    # - Value[int](1) works.
+    # - Value(1) works, with T is inferred to be int.
+    @overload
+    def __init__(
+        self, value: MISSING_TYPE = MISSING, *, read_only: bool = False
+    ) -> None:
+        ...
+
+    @overload
+    def __init__(self, value: T, *, read_only: bool = False) -> None:
+        ...
+
+    # If `value` is MISSING, then `get()` will raise a SilentException, until a new
+    # value is set. Calling `unset()` will set the value to MISSING.
+    def __init__(
+        self, value: Union[T, MISSING_TYPE] = MISSING, *, read_only: bool = False
+    ) -> None:
         self._value: T = value
-        self._read_only: bool = _read_only
+        self._read_only: bool = read_only
         self._dependents: Dependents = Dependents()
 
-    # Calling the object is equivalent to `.get()`
     def __call__(self) -> T:
-        self._dependents.register()
-        return self._value
+        return self.get()
 
     def get(self) -> T:
         self._dependents.register()
+
+        if isinstance(self._value, MISSING_TYPE):
+            raise SilentException
+
         return self._value
 
     def set(self, value: T) -> bool:
@@ -59,6 +82,17 @@ def _set(self, value: T) -> bool:
         self._dependents.invalidate()
         return True
 
+    def unset(self) -> None:
+        self.set(MISSING)  # type: ignore
+
+    def is_set(self) -> bool:
+        self._dependents.register()
+        return not isinstance(self._value, MISSING_TYPE)
+
+    # Like unset(), except that this does not invalidate dependents.
+    def freeze(self) -> None:
+        self._value = MISSING
+
 
 # ==============================================================================
 # Calc

shiny/session/_session.py

@@ -53,7 +53,7 @@
 from .. import _utils
 from .._fileupload import FileInfo, FileUploadManager
 from ..input_handler import input_handlers
-from ..types import SafeException, SilentCancelOutputException, SilentException
+from ..types import MISSING, SafeException, SilentCancelOutputException, SilentException
 from ._utils import RenderedDeps, read_thunk_opt, session_context
 
 # This cast is necessary because if the type checker thinks that if
@@ -543,7 +543,7 @@ class Inputs:
     def __init__(self, **kwargs: object) -> None:
         self._map: dict[str, Value[Any]] = {}
         for key, value in kwargs.items():
-            self._map[key] = Value(value, _read_only=True)
+            self._map[key] = Value(value, read_only=True)
 
     def __setitem__(self, key: str, value: Value[Any]) -> None:
         if not isinstance(value, Value):
@@ -556,7 +556,7 @@ def __getitem__(self, key: str) -> Value[Any]:
         # dependencies on input values that haven't been received from client
         # yet.
         if key not in self._map:
-            self._map[key] = Value(None, _read_only=True)
+            self._map[key] = Value(read_only=True)
 
         return self._map[key]
 
@@ -677,12 +677,10 @@ def _should_suspend(self, name: str) -> bool:
 
     def _is_hidden(self, name: str) -> bool:
         with isolate():
-            hidden = cast(
-                Optional[bool],
-                self._session.input[f".clientdata_output_{name}_hidden"](),
+            hidden_value_obj = cast(
+                Value[bool], self._session.input[f".clientdata_output_{name}_hidden"]
             )
+            if not hidden_value_obj.is_set():
+                return True
 
-        if hidden is None:
-            return True
-        else:
-            return hidden
+            return hidden_value_obj()

tests/test_modules.py

@@ -48,9 +48,9 @@ async def test_inputs_proxy():
     with isolate():
         assert input.a() == 1
         # Different ways of accessing "a" from the input proxy.
-        assert input_proxy.a() is None
-        assert input_proxy["a"]() is None
-        assert input["mod1-a"]() is None
+        assert input_proxy.a.is_set() is False
+        assert input_proxy["a"].is_set() is False
+        assert input["mod1-a"].is_set() is False
 
     input_proxy.a._set(2)
 
@@ -66,9 +66,9 @@ async def test_inputs_proxy():
         assert input.a() == 1
         assert input_proxy.a() == 2
         # Different ways of accessing "a" from the input proxy.
-        assert input_proxy_proxy.a() is None
-        assert input_proxy_proxy["a"]() is None
-        assert input["mod1-mod2-a"]() is None
+        assert input_proxy_proxy.a.is_set() is False
+        assert input_proxy_proxy["a"].is_set() is False
+        assert input_proxy["mod1-a"].is_set() is False
 
     input_proxy_proxy.a._set(3)
 

tests/test_reactives.py

@@ -8,7 +8,8 @@
 from shiny.reactive._core import ReactiveWarning
 from shiny._decorators import *
 from shiny.reactive import *
-from shiny._validation import req
+from shiny.types import MISSING
+from shiny._validation import SilentException, req
 
 from .mocktime import MockTime
 
@@ -90,6 +91,65 @@ def o():
     assert o._exec_count == 1
 
 
+# ======================================================================
+# Intializing reactive.Value to MISSING, and unsetting
+# ======================================================================
+@pytest.mark.asyncio
+async def test_reactive_value_unset():
+    v = Value[int](MISSING)
+
+    with isolate():
+        assert v.is_set() is False
+        with pytest.raises(SilentException):
+            v()
+
+    val: int = 0
+
+    @effect()
+    def o():
+        nonlocal val
+        val = v()
+
+    await flush()
+    assert o._exec_count == 1
+    assert val == 0
+
+    v.set(1)
+    await flush()
+    assert o._exec_count == 2
+    assert val == 1
+
+    v.unset()
+    await flush()
+    assert o._exec_count == 3
+    assert val == 1
+
+    with isolate():
+        assert v.is_set() is False
+        with pytest.raises(SilentException):
+            v()
+
+    # Check that dependency is taken when is_set() is called.
+    v = Value[int](MISSING)
+    val2: Union[bool, None] = None
+
+    @effect()
+    def o2():
+        nonlocal val2
+        val2 = v.is_set()
+
+    await flush()
+    assert val2 is False
+
+    v.set(1)
+    await flush()
+    assert val2 is True
+
+    v.unset()
+    await flush()
+    assert val2 is False
+
+
 # ======================================================================
 # Recursive calls to calcs
 # ======================================================================
@@ -941,6 +1001,72 @@ async def _():
     assert n_times == 7
 
 
+# ------------------------------------------------------------
+# @event() handles silent exceptions in event function, async
+# ------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_event_silent_exception_async():
+    n_times = 0
+    x = Value[bool]()
+
+    async def req_fn() -> int:
+        await asyncio.sleep(0)
+        x()
+        return 1234
+
+    @effect()
+    @event(req_fn)
+    async def _():
+        await asyncio.sleep(0)
+        nonlocal n_times
+        n_times += 1
+
+    await flush()
+    assert n_times == 0
+
+    x.set(True)
+    await flush()
+    assert n_times == 1
+
+    x.unset()
+    await flush()
+    assert n_times == 1
+
+    x.set(True)
+    await flush()
+    assert n_times == 2
+
+
+# ------------------------------------------------------------
+# @event() handles silent exceptions in async event function
+# ------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_event_silent_exception():
+    n_times = 0
+    x = Value[bool]()
+
+    @effect()
+    @event(x)
+    def _():
+        nonlocal n_times
+        n_times += 1
+
+    await flush()
+    assert n_times == 0
+
+    x.set(True)
+    await flush()
+    assert n_times == 1
+
+    x.unset()
+    await flush()
+    assert n_times == 1
+
+    x.set(True)
+    await flush()
+    assert n_times == 2
+
+
 # ------------------------------------------------------------
 # @effect()'s .suspend()/.resume() works as expected
 # ------------------------------------------------------------