Rename ._parent to ._root_session in SessionProxy

Related: #1924 (comment)

Author: schloerke

shiny/express/_stub_session.py

@@ -66,7 +66,7 @@ def on_ended(
 
     def make_scope(self, id: Id) -> Session:
         ns = self.ns(id)
-        return SessionProxy(parent=self, ns=ns)
+        return SessionProxy(root_session=self, ns=ns)
 
     def root_scope(self) -> ExpressStubSession:
         return self

shiny/session/_session.py

@@ -1165,7 +1165,7 @@ def _process_ui(self, ui: TagChild) -> RenderedDeps:
 
     def make_scope(self, id: Id) -> Session:
         ns = self.ns(id)
-        return SessionProxy(parent=self, ns=ns)
+        return SessionProxy(root_session=self, ns=ns)
 
     def root_scope(self) -> AppSession:
         return self
@@ -1200,73 +1200,70 @@ class UpdateProgressMessage(TypedDict):
 
 
 class SessionProxy(Session):
-    def __init__(self, parent: Session, ns: ResolvedId) -> None:
+    def __init__(self, root_session: Session, ns: ResolvedId) -> None:
         super().__init__()
 
-        self._parent = parent
-        self.app = parent.app
-        self.id = parent.id
+        self._root_session = root_session
+        self.app = root_session.app
+        self.id = root_session.id
         self.ns = ns
-        self.input = Inputs(values=parent.input._map, ns=ns)
+        self.input = Inputs(values=root_session.input._map, ns=ns)
         self.output = Outputs(
             self,
             ns=ns,
-            outputs=parent.output._outputs,
+            outputs=root_session.output._outputs,
         )
-        self._outbound_message_queues = parent._outbound_message_queues
-        self._downloads = parent._downloads
+        self._outbound_message_queues = root_session._outbound_message_queues
+        self._downloads = root_session._downloads
 
         self.bookmark = BookmarkProxy(self)
 
     def _is_hidden(self, name: str) -> bool:
-        return self._parent._is_hidden(name)
+        return self._root_session._is_hidden(name)
 
     def on_ended(
         self,
         fn: Callable[[], None] | Callable[[], Awaitable[None]],
     ) -> Callable[[], None]:
-        return self._parent.on_ended(fn)
+        return self._root_session.on_ended(fn)
 
     def is_stub_session(self) -> bool:
-        return self._parent.is_stub_session()
+        return self._root_session.is_stub_session()
 
     async def close(self, code: int = 1001) -> None:
-        await self._parent.close(code)
+        await self._root_session.close(code)
 
     def make_scope(self, id: str) -> Session:
-        return self._parent.make_scope(self.ns(id))
+        return self._root_session.make_scope(self.ns(id))
 
     def root_scope(self) -> Session:
-        res = self
-        while isinstance(res, SessionProxy):
-            res = res._parent
-        return res
+        return self._root_session
 
     def _process_ui(self, ui: TagChild) -> RenderedDeps:
-        return self._parent._process_ui(ui)
+        return self._root_session._process_ui(ui)
 
     def send_input_message(self, id: str, message: dict[str, object]) -> None:
-        self._parent.send_input_message(self.ns(id), message)
+        self._root_session.send_input_message(self.ns(id), message)
 
     def _send_insert_ui(
         self, selector: str, multiple: bool, where: str, content: RenderedDeps
     ) -> None:
-        self._parent._send_insert_ui(selector, multiple, where, content)
+        self._root_session._send_insert_ui(selector, multiple, where, content)
 
     def _send_remove_ui(self, selector: str, multiple: bool) -> None:
-        self._parent._send_remove_ui(selector, multiple)
+        self._root_session._send_remove_ui(selector, multiple)
 
     def _send_progress(self, type: str, message: object) -> None:
-        self._parent._send_progress(type, message)  # pyright: ignore
+        self._root_session._send_progress(type, message)  # pyright: ignore
 
     async def send_custom_message(self, type: str, message: dict[str, object]) -> None:
-        await self._parent.send_custom_message(type, message)
+        await self._root_session.send_custom_message(type, message)
 
     def _increment_busy_count(self) -> None:
-        self._parent._increment_busy_count()
+        self._root_session._increment_busy_count()
 
     def _decrement_busy_count(self) -> None:
-        self._parent._decrement_busy_count()
+        self._root_session._decrement_busy_count()
 
     def set_message_handler(
         self,
@@ -1283,7 +1280,7 @@ def set_message_handler(
         if _handler_session is None:
             _handler_session = self
 
-        return self._parent.set_message_handler(
+        return self._root_session.set_message_handler(
             self.ns(name),
             handler,
             _handler_session=_handler_session,
@@ -1294,26 +1291,26 @@ def on_flush(
         fn: Callable[[], None] | Callable[[], Awaitable[None]],
         once: bool = True,
     ) -> Callable[[], None]:
-        return self._parent.on_flush(fn, once)
+        return self._root_session.on_flush(fn, once)
 
     async def _send_message(self, message: dict[str, object]) -> None:
-        await self._parent._send_message(message)
+        await self._root_session._send_message(message)
 
     def _send_message_sync(self, message: dict[str, object]) -> None:
-        self._parent._send_message_sync(message)
+        self._root_session._send_message_sync(message)
 
     def on_flushed(
         self,
         fn: Callable[[], None] | Callable[[], Awaitable[None]],
         once: bool = True,
     ) -> Callable[[], None]:
-        return self._parent.on_flushed(fn, once)
+        return self._root_session.on_flushed(fn, once)
 
     def dynamic_route(self, name: str, handler: DynamicRouteHandler) -> str:
-        return self._parent.dynamic_route(self.ns(name), handler)
+        return self._root_session.dynamic_route(self.ns(name), handler)
 
     async def _unhandled_error(self, e: Exception) -> None:
-        await self._parent._unhandled_error(e)
+        await self._root_session._unhandled_error(e)
 
     def download(
         self,
@@ -1324,7 +1321,7 @@ def download(
     ) -> Callable[[DownloadHandler], None]:
         def wrapper(fn: DownloadHandler):
             id_ = self.ns(id or fn.__name__)
-            return self._parent.download(
+            return self._root_session.download(
                 id=id_,
                 filename=filename,
                 media_type=media_type,