Merge pull request #77 from rstudio/calc-effect-capitalize

Author: wch

examples/bind_event/app.py

@@ -29,19 +29,19 @@
 def server(input: Inputs, output: Outputs, session: Session):
 
     # i.e., observeEvent(once=False)
-    @reactive.effect()
+    @reactive.Effect()
     @event(input.btn)
     def _():
         print("@effect() event: ", str(input.btn()))
 
     # i.e., eventReactive()
-    @reactive.calc()
+    @reactive.Calc()
     @event(input.btn)
-    def btn() -> int:
-        return input.btn()
+    async def btn() -> int:
+        return input.btn() + 2
 
-    @reactive.effect()
-    def _():
+    @reactive.Effect()
+    async def _():
         print("@calc() event: ", str(btn()))
 
     @output()
@@ -53,19 +53,19 @@ def btn_value():
     # -----------------------------------------------------------------------------
     # Async
     # -----------------------------------------------------------------------------
-    @reactive.effect()
+    @reactive.Effect()
     @event(input.btn_async)
     async def _():
         await asyncio.sleep(0)
         print("async @effect() event: ", str(input.btn_async()))
 
-    @reactive.calc()
+    @reactive.Calc()
     @event(input.btn_async)
     async def btn_async_r() -> int:
         await asyncio.sleep(0)
         return input.btn_async()
 
-    @reactive.effect()
+    @reactive.Effect()
     async def _():
         val = await btn_async_r()
         print("async @calc() event: ", str(val))

examples/inputs-update/app.py

@@ -89,7 +89,7 @@
 
 
 def server(input: Inputs, output: Outputs, session: Session):
-    @reactive.effect()
+    @reactive.Effect()
     def _():
         # We'll use these multiple times, so use short var names for
         # convenience.

examples/inputs/app.py

@@ -132,7 +132,7 @@ def image():
         img: ImgData = {"src": str(dir / "rstudio-logo.png"), "width": "150px"}
         return img
 
-    @reactive.effect()
+    @reactive.Effect()
     def _():
         btn = input.btn()
         if btn and btn > 0:
@@ -144,7 +144,7 @@ def _():
                 )
             )
 
-    @reactive.effect()
+    @reactive.Effect()
     def _():
         link = input.link()
         if link and link > 0:

examples/insert_ui/app.py

@@ -21,7 +21,7 @@
 
 
 def server(input: Inputs, output: Outputs, session: Session):
-    @reactive.calc()
+    @reactive.Calc()
     def r():
         if input.n() is None:
             return
@@ -50,7 +50,7 @@ def _():
             "This slider is rendered via @render_ui()", "N", 0, 100, 20
         )
 
-    @reactive.effect()
+    @reactive.Effect()
     def _():
         btn = input.btn()
         if btn % 2 == 1:

examples/moduleapp/app.py

@@ -20,7 +20,7 @@ def counter_ui(
 def counter_server(input: ModuleInputs, output: ModuleOutputs, session: ModuleSession):
     count: reactive.Value[int] = reactive.Value(0)
 
-    @reactive.effect()
+    @reactive.Effect()
     @event(input.button)
     def _():
         count.set(count() + 1)

examples/myapp/app.py

@@ -23,7 +23,7 @@
 
 
 def server(input: Inputs, output: Outputs, session: Session):
-    @reactive.calc()
+    @reactive.Calc()
     def r():
         if input.n() is None:
             return
@@ -37,7 +37,7 @@ async def txt():
 
     # This observer watches n, and changes shared_val, which is shared across
     # all running sessions.
-    @reactive.effect()
+    @reactive.Effect()
     def _():
         if input.n() is None:
             return

examples/req/app.py

@@ -15,7 +15,7 @@
 
 
 def server(input: Inputs, output: Outputs, session: Session):
-    @reactive.calc()
+    @reactive.Calc()
     def safe_click():
         req(input.safe())
         return input.safe()
@@ -31,7 +31,7 @@ def unsafe():
         req(input.unsafe())
         raise Exception(f"Super secret number of clicks: {str(input.unsafe())}")
 
-    @reactive.effect()
+    @reactive.Effect()
     def _():
         req(input.unsafe())
         print("unsafe clicks:", input.unsafe())

examples/simple/app.py

@@ -10,7 +10,7 @@
 
 
 def server(input: Inputs, output: Outputs, session: Session):
-    @reactive.calc()
+    @reactive.Calc()
     def r():
         if input.n() is None:
             return

shiny/reactive/__init__.py

@@ -5,8 +5,8 @@
     "flush",
     "on_flushed",
     "Value",
-    "calc",
-    "effect",
+    "Calc",
+    "Effect",
     "isolate",
     "invalidate_later",
 )

shiny/reactive/_reactives.py

@@ -1,6 +1,6 @@
 """Reactive components"""
 
-__all__ = ("Value", "Calc", "CalcAsync", "calc", "Effect", "EffectAsync", "effect")
+__all__ = ("Value", "Calc", "Calc_", "CalcAsync_", "Effect", "Effect_")
 
 import traceback
 from typing import (
@@ -68,7 +68,7 @@ def _set(self, value: T) -> bool:
 CalcFunctionAsync = Callable[[], Awaitable[T]]
 
 
-class Calc(Generic[T]):
+class Calc_(Generic[T]):
     def __init__(
         self,
         fn: CalcFunction[T],
@@ -82,7 +82,7 @@ def __init__(
         # static type checker that it's synchronous. wrap_async() is smart -- if is
         # passed an async function, it will not change it.
         self._fn: CalcFunctionAsync[T] = _utils.wrap_async(fn)
-        self._is_async: bool = False
+        self._is_async: bool = _utils.is_async_callable(fn)
 
         self._dependents: Dependents = Dependents()
         self._invalidated: bool = True
@@ -96,11 +96,11 @@ def __init__(
         # the type checker doesn't know that MISSING is the only instance of
         # MISSING_TYPE; this saves us from casting later on.
         if isinstance(session, MISSING_TYPE):
-            import shiny.session
+            from ..session import get_current_session
 
             # If no session is provided, autodetect the current session (this
             # could be None if outside of a session).
-            session = shiny.session.get_current_session()
+            session = get_current_session()
         self._session = session
 
         # Use lists to hold (optional) value and error, instead of Optional[T],
@@ -139,9 +139,9 @@ async def update_value(self) -> None:
         was_running = self._running
         self._running = True
 
-        import shiny.session
+        from ..session import session_context
 
-        with shiny.session.session_context(self._session):
+        with session_context(self._session):
             try:
                 with self._ctx():
                     await self._run_func()
@@ -162,7 +162,7 @@ async def _run_func(self) -> None:
             self._error.append(err)
 
 
-class CalcAsync(Calc[T]):
+class CalcAsync_(Calc_[T]):
     def __init__(
         self,
         fn: CalcFunctionAsync[T],
@@ -173,7 +173,6 @@ def __init__(
             raise TypeError(self.__class__.__name__ + " requires an async function")
 
         super().__init__(cast(CalcFunction[T], fn), session=session)
-        self._is_async = True
 
     async def __call__(self) -> T:
         return await self.get_value()
@@ -198,15 +197,15 @@ async def __call__(self) -> T:
 # twice: once here, and once when we return a Calc object (which has a synchronous
 # __call__ method) or CalcAsync object (which has an async __call__ method), and it
 # works out.
-def calc(
+def Calc(
     *, session: Union[MISSING_TYPE, "Session", None] = MISSING
-) -> Callable[[CalcFunction[T]], Calc[T]]:
-    def create_calc(fn: Union[CalcFunction[T], CalcFunctionAsync[T]]) -> Calc[T]:
+) -> Callable[[CalcFunction[T]], Calc_[T]]:
+    def create_calc(fn: Union[CalcFunction[T], CalcFunctionAsync[T]]) -> Calc_[T]:
         if _utils.is_async_callable(fn):
-            return CalcAsync(fn, session=session)
+            return CalcAsync_(fn, session=session)
         else:
             fn = cast(CalcFunction[T], fn)
-            return Calc(fn, session=session)
+            return Calc_(fn, session=session)
 
     return create_calc
 
@@ -219,10 +218,10 @@ def create_calc(fn: Union[CalcFunction[T], CalcFunctionAsync[T]]) -> Calc[T]:
 EffectFunctionAsync = Callable[[], Awaitable[None]]
 
 
-class Effect:
+class Effect_:
     def __init__(
         self,
-        fn: EffectFunction,
+        fn: Union[EffectFunction, EffectFunctionAsync],
         *,
         suspended: bool = False,
         priority: int = 0,
@@ -235,7 +234,8 @@ def __init__(
         # static type checker that it's synchronous. wrap_async() is smart -- if is
         # passed an async function, it will not change it.
         self._fn: EffectFunctionAsync = _utils.wrap_async(fn)
-        self._is_async: bool = False
+        # This indicates whether the user's effect function (before wrapping) is async.
+        self._is_async: bool = _utils.is_async_callable(fn)
 
         self._priority: int = priority
         self._suspended = suspended
@@ -251,11 +251,11 @@ def __init__(
         # the type checker doesn't know that MISSING is the only instance of
         # MISSING_TYPE; this saves us from casting later on.
         if isinstance(session, MISSING_TYPE):
-            import shiny.session
+            from ..session import get_current_session
 
             # If no session is provided, autodetect the current session (this
             # could be None if outside of a session).
-            session = shiny.session.get_current_session()
+            session = get_current_session()
         self._session = session
 
         if self._session is not None:
@@ -302,9 +302,10 @@ async def on_flush_cb() -> None:
     async def run(self) -> None:
         ctx = self._create_context()
         self._exec_count += 1
-        import shiny.session
 
-        with shiny.session.session_context(self._session):
+        from ..session import session_context
+
+        with session_context(self._session):
             try:
                 with ctx():
                     await self._fn()
@@ -360,51 +361,14 @@ def _on_session_ended_cb(self) -> None:
         self.destroy()
 
 
-class EffectAsync(Effect):
-    def __init__(
-        self,
-        fn: EffectFunctionAsync,
-        *,
-        suspended: bool = False,
-        priority: int = 0,
-        session: Union[MISSING_TYPE, "Session", None] = MISSING,
-    ) -> None:
-        if not _utils.is_async_callable(fn):
-            raise TypeError(self.__class__.__name__ + " requires an async function")
-
-        super().__init__(
-            cast(EffectFunction, fn),
-            suspended=suspended,
-            session=session,
-            priority=priority,
-        )
-        self._is_async = True
-
-
-def effect(
+def Effect(
     *,
     suspended: bool = False,
     priority: int = 0,
     session: Union[MISSING_TYPE, "Session", None] = MISSING,
-) -> Callable[[Union[EffectFunction, EffectFunctionAsync]], Effect]:
-    """[summary]
-
-    Args:
-        priority : [description]. Defaults to 0.
-        session : [description]. Defaults to MISSING.
-
-    Returns:
-        [description]
-    """
-
-    def create_effect(fn: Union[EffectFunction, EffectFunctionAsync]) -> Effect:
-        if _utils.is_async_callable(fn):
-            fn = cast(EffectFunctionAsync, fn)
-            return EffectAsync(
-                fn, suspended=suspended, priority=priority, session=session
-            )
-        else:
-            fn = cast(EffectFunction, fn)
-            return Effect(fn, suspended=suspended, priority=priority, session=session)
+) -> Callable[[Union[EffectFunction, EffectFunctionAsync]], Effect_]:
+    def create_effect(fn: Union[EffectFunction, EffectFunctionAsync]) -> Effect_:
+        fn = cast(EffectFunction, fn)
+        return Effect_(fn, suspended=suspended, priority=priority, session=session)
 
     return create_effect