raise error when output after page close

Author: wang0618

docs/spec.rst

@@ -461,4 +461,10 @@ js_yield
 ^^^^^^^^^^^^^^^
 submit data from js. It's a common event to submit data to backend.
 
-The ``data`` of the event is the data need to submit
+The ``data`` of the event is the data need to submit
+
+page_close
+^^^^^^^^^^^^^^^
+Triggered when the user close the page
+
+The ``data`` of the event is the page id that is closed

pywebio/exceptions.py

@@ -10,6 +10,10 @@ class SessionException(Exception):
     """Base class for PyWebIO session related exceptions"""
 
 
+class PageClosedException(Exception):
+    """The page has been closed abnormally"""
+
+
 class SessionClosedException(SessionException):
     """The session has been closed abnormally"""
 

pywebio/io_ctrl.py

@@ -63,12 +63,11 @@ def safely_destruct(cls, obj):
             pass
 
     def __init__(self, spec, on_embed=None):
-        self.processed = False
+        self.processed = True  # avoid `__del__` is invoked accidentally when exception occurs in `__init__`
         self.on_embed = on_embed or (lambda d: d)
         try:
             self.spec = type(self).dump_dict(spec)  # this may raise TypeError
         except TypeError:
-            self.processed = True
             type(self).safely_destruct(spec)
             raise
 
@@ -84,7 +83,12 @@ def __init__(self, spec, on_embed=None):
         # the Exception raised from there will be ignored by python interpreter,
         # thus we can't end some session in some cases.
         # See also: https://github.com/pywebio/PyWebIO/issues/243
-        get_current_session()
+        s = get_current_session()
+
+        # Try to make sure current page is active.
+        # Session.get_page_id will raise PageClosedException when the page is not activate
+        s.get_page_id()
+        self.processed = False
 
     def enable_context_manager(self, container_selector=None, container_dom_id=None, custom_enter=None,
                                custom_exit=None):

pywebio/output.py

@@ -220,6 +220,7 @@
 from .io_ctrl import output_register_callback, send_msg, Output, safely_destruct_output_when_exp, OutputList, scope2dom
 from .session import get_current_session, download
 from .utils import random_str, iscoroutinefunction, check_dom_name_value
+from .exceptions import PageClosedException
 
 try:
     from PIL.Image import Image as PILImage
@@ -1813,10 +1814,12 @@ async def coro_wrapper(*args, **kwargs):
             return wrapper
 
 
-def page(func=None):
+def page(silent_quit=False):
     """
     Open a page. Can be used as context manager and decorator.
 
+    :param bool silent_quit: whether to quit silently when the page is closed accidentally by app user
+
     :Usage:
 
     ::
@@ -1825,19 +1828,19 @@ def page(func=None):
             input()
             put_xxx()
 
-        @page()  # or @page
+        @page()
         def content():
             input()
             put_xxx()
     """
-
-    if func is None:
-        return page_()
-    return page_()(func)
+    p = page_()
+    p.silent_quit = silent_quit
+    return p
 
 
 class page_:
     page_id: str
+    silent_quit: bool
 
     def __enter__(self):
         self.page_id = random_str(10)
@@ -1850,29 +1853,27 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         so that the with statement terminates the propagation of the exception
         """
         get_current_session().pop_page()
-        send_msg('close_page', dict(page_id=self.page_id))
+        if isinstance(exc_val, PageClosedException):  # page is close by app user
+            if self.silent_quit:
+                # supress PageClosedException Exception
+                return True
+        else:
+            send_msg('close_page', dict(page_id=self.page_id))
 
-        # todo: catch Page Close Exception
-        return False  # Propagate Exception
+        return False  # propagate Exception
 
     def __call__(self, func):
         """decorator implement"""
 
         @wraps(func)
         def wrapper(*args, **kwargs):
-            self.__enter__()
-            try:
+            with self:
                 return func(*args, **kwargs)
-            finally:
-                self.__exit__(None, None, None)
 
         @wraps(func)
         async def coro_wrapper(*args, **kwargs):
-            self.__enter__()
-            try:
+            with self:
                 return await func(*args, **kwargs)
-            finally:
-                self.__exit__(None, None, None)
 
         if iscoroutinefunction(func):
             return coro_wrapper

pywebio/session/base.py

@@ -6,6 +6,7 @@
 import user_agents
 
 from ..utils import catch_exp_call
+from ..exceptions import PageClosedException
 
 logger = logging.getLogger(__name__)
 
@@ -62,7 +63,8 @@ def __init__(self, session_info):
         self.internal_save = dict(info=session_info)  # some session related info, just for internal used
         self.save = {}  # underlying implement of `pywebio.session.data`
         self.scope_stack = defaultdict(lambda: ['ROOT'])  # task_id -> scope栈
-        self.page_stack = defaultdict(lambda: [])  # task_id -> page id
+        self.page_stack = defaultdict(lambda: [])  # task_id -> page id stack
+        self.active_page = defaultdict(set)  # task_id -> activate page set
 
         self.deferred_functions = []  # 会话结束时运行的函数
         self._closed = False
@@ -96,24 +98,49 @@ def push_scope(self, name):
         self.scope_stack[task_id].append(name)
 
     def get_page_id(self):
+        """
+        get the if of current page in task, return `None` when it's master page, 
+        raise PageClosedException when current page is closed
+        """
         task_id = type(self).get_current_task_id()
-        if task_id not in self.page_stack:
-            return None
-        try:
-            return self.page_stack[task_id][-1]
-        except IndexError:
+        if task_id not in self.page_stack or not self.page_stack[task_id]:
+            # current in master page
             return None
 
+        page_id = self.page_stack[task_id][-1]
+        if page_id not in self.active_page[task_id]:
+            raise PageClosedException(
+                "The page is closed by app user, "
+                "you see this exception mostly because you set `silent_quit=False` in `pywebio.output.page()`"
+            )
+
+        return page_id
+
     def pop_page(self):
+        """exit the current page in task"""
         task_id = type(self).get_current_task_id()
         try:
-            return self.page_stack[task_id].pop()
+            page_id = self.page_stack[task_id].pop()
         except IndexError:
             raise ValueError("Internal Error: No page to exit") from None
 
+        try:
+            self.active_page[task_id].remove(page_id)
+        except KeyError:
+            pass
+        return page_id
+
     def push_page(self, page_id):
         task_id = type(self).get_current_task_id()
         self.page_stack[task_id].append(page_id)
+        self.active_page[task_id].add(page_id)
+
+    def notify_page_lost(self, task_id, page_id):
+        """update page status when there is page lost"""
+        try:
+            self.active_page[task_id].remove(page_id)
+        except KeyError:
+            pass
 
     def send_task_command(self, command):
         raise NotImplementedError
@@ -123,7 +150,13 @@ def next_client_event(self) -> dict:
         raise NotImplementedError
 
     def send_client_event(self, event):
-        raise NotImplementedError
+        """send event from client to session,
+        return True when this event is handled by this method, which means the subclass must ignore this event.
+        """
+        if event['event'] == 'page_close':
+            self.notify_page_lost(event['task_id'], event['data'])
+            return True
+        return False
 
     def get_task_commands(self) -> list:
         raise NotImplementedError
@@ -185,6 +218,10 @@ def defer_call(self, func):
         self.deferred_functions.append(func)
 
     def need_keep_alive(self) -> bool:
+        """
+        return whether to need to hold this session if it runs over now.
+        if the session maintains some event callbacks, it needs to hold session unit user close the session
+        """
         raise NotImplementedError
 
 

pywebio/session/coroutinebased.py

@@ -138,6 +138,10 @@ def send_client_event(self, event):
 
         :param dict event: 事件️消息
         """
+        handled = super(CoroutineBasedSession, self).send_client_event(event)
+        if handled:
+            return
+
         coro_id = event['task_id']
         coro = self.coros.get(coro_id)
         if not coro:

pywebio/session/threadbased.py

@@ -146,6 +146,10 @@ def send_client_event(self, event):
 
         :param dict event: 事件️消息
         """
+        handled = super(ThreadBasedSession, self).send_client_event(event)
+        if handled:
+            return
+
         task_id = event['task_id']
         mq = self.task_mqs.get(task_id)
         if not mq and task_id in self.callbacks:

webiojs/src/handlers/page.ts

@@ -10,7 +10,7 @@ export class PageHandler implements CommandHandler {
 
     handle_message(msg: Command) {
         if (msg.command === 'open_page') {
-            OpenPage(msg.spec.page_id);
+            OpenPage(msg.spec.page_id, msg.task_id);
         } else if (msg.command === 'close_page') {
             ClosePage(msg.spec.page_id);
         }

webiojs/src/models/page.ts

@@ -1,31 +1,81 @@
 // page id to page window reference
 import {Command, SubPageSession} from "../session";
 import {LazyPromise} from "../utils";
+import {state} from "../state";
 
-let subpages: { [page_id: string]: Window } = {};
+let subpages: {
+    [page_id: string]: {
+        page: Window,
+        task_id: string
+    }
+} = {};
 
+function start_clean_up_task() {
+    return setInterval(() => {
+        let page;
+        for (let page_id in subpages) {
+            page = subpages[page_id].page;
+            if (page.closed || !SubPageSession.is_sub_page(page)) {
+                on_page_lost(page_id);
+            }
+        }
+    }, 1000)
+}
+
+// page is closed accidentally
+function on_page_lost(page_id: string) {
+    console.log(`page ${page_id} exit`);
+    if (!(page_id in subpages))  // it's a duplicated call
+        return;
+
+    let task_id = subpages[page_id].task_id;
+    delete subpages[page_id];
+    state.CurrentSession.send_message({
+        event: "page_close",
+        task_id: task_id,
+        data: page_id
+    });
+}
 
-export function OpenPage(page_id: string) {
+let clean_up_task_id: number = null;
+
+export function OpenPage(page_id: string, task_id: string) {
     if (page_id in subpages)
         throw `Can't open page, the page id "${page_id}" is duplicated`;
-    subpages[page_id] = window.open(window.location.href);
+
+    if (!clean_up_task_id)
+        clean_up_task_id = start_clean_up_task()
+
+    let page = window.open(window.location.href);
+    subpages[page_id] = {page: page, task_id: task_id}
 
     // the `_pywebio_page` will be resolved in new opened page in `SubPageSession.start_session()`
     // @ts-ignore
-    subpages[page_id]._pywebio_page = new LazyPromise()
+    page._pywebio_page = new LazyPromise()
+
+    // this event is not reliably fired by browsers
+    // https://developer.mozilla.org/en-US/docs/Web/API/Window/pagehide_event#usage_notes
+    page.addEventListener('pagehide', event => {
+        // wait some time to for `page.closed`
+        setTimeout(() => {
+            if (page.closed || !SubPageSession.is_sub_page(page))
+                on_page_lost(page_id)
+        }, 100)
+    });
 }
 
 export function ClosePage(page_id: string) {
     if (!(page_id in subpages))
         throw `Can't close page, the page (id "${page_id}") is not found`;
-    subpages[page_id].close()
+    subpages[page_id].page.close();
+    delete subpages[page_id];
 }
 
 export function DeliverMessage(msg: Command) {
     if (!(msg.page in subpages))
         throw `Can't deliver message, the page (id "${msg.page}") is not found`;
     // @ts-ignore
-    subpages[msg.page]._pywebio_page.promise.then((page: SubPageSession) => {
+    subpages[msg.page].page._pywebio_page.promise.then((page: SubPageSession) => {
         msg.page = undefined;
         page.server_message(msg);
     });

webiojs/src/session.ts

@@ -65,12 +65,17 @@ export class SubPageSession implements Session {
     private _on_server_message: (msg: Command) => any = () => {
     };
 
-    // check if it's a pywebio subpage
-    static is_sub_page(): boolean {
+    // check if the window is a pywebio subpage
+    static is_sub_page(window_obj: Window = window): boolean {
         //  - `window._pywebio_page` lazy promise is not undefined
         //  - window.opener is not null and window.opener.WebIO is not undefined
-        // @ts-ignore
-        return window._pywebio_page !== undefined && window.opener !== null && window.opener.WebIO !== undefined;
+
+        try {
+            // @ts-ignore
+            return window_obj._pywebio_page !== undefined && window_obj.opener !== null && window_obj.opener.WebIO !== undefined;
+        }catch (e) {
+            return false;
+        }
     }
 
     on_session_create(callback: () => any): void {