Add warning statements; Remove many print statements

Author: schloerke

shiny/bookmark/_bookmark.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import TYPE_CHECKING, Awaitable, Callable, Literal, NoReturn
@@ -279,7 +280,6 @@ def _create_effects(self) -> None:
         if self.store == "disable":
             return
 
-        print("Creating effects")
         session = self._session_root
 
         from .. import reactive
@@ -309,7 +309,6 @@ def init_error_message():
             # the server function has been executed.
             @reactive.effect(priority=1000000)
             async def invoke_on_restore_callbacks():
-                print("Trying on restore")
                 if self._on_restore_callbacks.count() == 0:
                     return
 
@@ -322,8 +321,10 @@ async def invoke_on_restore_callbacks():
                                 restore_state = self._restore_context.as_state()
                                 await self._on_restore_callbacks.invoke(restore_state)
                     except Exception as e:
-                        raise e
-                        print(f"Error calling on_restore callback: {e}")
+                        warnings.warn(
+                            f"Error calling on_restore callback: {e}",
+                            stacklevel=2,
+                        )
                         notification_show(
                             f"Error calling on_restore callback: {e}",
                             duration=None,
@@ -337,7 +338,6 @@ async def invoke_on_restore_callbacks():
             # until the next `on_flushed` invocation.
             @session.on_flush
             async def invoke_on_restored_callbacks():
-                print("Trying on restored")
                 if self._on_restored_callbacks.count() == 0:
                     return
 
@@ -348,7 +348,10 @@ async def invoke_on_restored_callbacks():
                                 restore_state = self._restore_context.as_state()
                                 await self._on_restored_callbacks.invoke(restore_state)
                     except Exception as e:
-                        print(f"Error calling on_restored callback: {e}")
+                        warnings.warn(
+                            f"Error calling on_restored callback: {e}",
+                            stacklevel=2,
+                        )
                         notification_show(
                             f"Error calling on_restored callback: {e}",
                             duration=None,

shiny/reactive/_core.py

@@ -174,21 +174,15 @@ def on_flushed(
 
     async def flush(self) -> None:
         """Flush all pending operations"""
-        print("--Reactive flush--")
         await self._flush_sequential()
-        print("--Reactive flush callbacks--")
         await self._flushed_callbacks.invoke()
-        print("--Reactive flush done--")
 
     async def _flush_sequential(self) -> None:
         # Sequential flush: instead of storing the tasks in a list and calling gather()
         # on them later, just run each effect in sequence.
-        print("--Sequential flush--")
         while not self._pending_flush_queue.empty():
-            print("--item")
             ctx = self._pending_flush_queue.get()
             await ctx.execute_flush_callbacks()
-        print("--Sequential flush done--")
 
     def add_pending_flush(self, ctx: Context, priority: int) -> None:
         self._pending_flush_queue.put(priority, ctx)

shiny/session/_session.py

@@ -633,7 +633,6 @@ def verify_state(expected_state: ConnectionState) -> None:
                         return
 
                     async with lock():
-                        print("with lock")
                         if message_obj["method"] == "init":
                             verify_state(ConnectionState.Start)
 
@@ -959,7 +958,6 @@ async def wrap_content_sync() -> AsyncIterable[bytes]:
         return HTMLResponse("<h1>Not Found</h1>", 404)
 
     def send_input_message(self, id: str, message: dict[str, object]) -> None:
-        print("Send input message", id, message)
         self._outbound_message_queues.add_input_message(id, message)
         self._request_flush()
 
@@ -1039,9 +1037,7 @@ async def _flush(self) -> None:
         with session_context(self):
             # This is the only place in the session where the restoreContext is flushed.
             if self.bookmark._restore_context:
-                print("Flushing restore context pending")
                 self.bookmark._restore_context.flush_pending()
-                print("Flushing restore context pending - done")
             # Flush the callbacks
             await self._flush_callbacks.invoke()
 
@@ -1055,13 +1051,11 @@ async def _flush(self) -> None:
             }
 
             try:
-                print("Sending message!", message)
                 await self._send_message(message)
             finally:
                 self._outbound_message_queues.reset()
         finally:
             with session_context(self):
-                print("Invoking flushed callbacks")
                 await self._flushed_callbacks.invoke()
 
     def _increment_busy_count(self) -> None: