Enhance the ui.notification

[Yuerchu]

I think we could add a context manager-like method to ui.notification to better show the progress of some time-consuming tasks to the user.

For example, in the past, we had to manipulate ui.notification like this:

from nicegui import ui
import random
import asyncio

@ui.page('/')
async def index():
    async def exec_task():
        notify = ui.notification(timeout=None)
        notify.spinner = True
        notify.message = "Please wait..."

        try:
            await asyncio.sleep(3)    # Assuming this is a task with an uncertain success rate
            number = random.randint(0, 1)

            if number == 0:
                raise Exception("The task failed.")
        except Exception as e:
            notify.type = 'negative'
            notify.spinner = False
            notify.message = f'Failed: {e}'
        else:
            notify.type = 'positive'
            notify.spinner = False
            notify.message = 'Done!'
        finally:
            await asyncio.sleep(3)
            notify.dismiss()
    
    ui.button('Run task', on_click=exec_task)

ui.run()

But if we define a context manager like this beforehand:

from typing import Optional, Callable, List, Union
from contextlib import asynccontextmanager
import asyncio
import logging
from nicegui import ui

@asynccontextmanager
async def loading_process(
        content: str = 'Please wait...',
        success_content: str = 'Done!',
        error_content: str = 'Failed',
        on_success: Optional[Union[Callable, List[Callable]]] = None,
        on_error: Optional[Union[Callable, List[Callable]]] = None,
        on_finally: Optional[Union[Callable, List[Callable]]] = None
):
    # Create notification
    notify = ui.notification(
        message=content,
        timeout=None
    )
    notify.spinner = True
    
    async def execute_callbacks(callbacks: Optional[Union[Callable, List[Callable]]]):
        """Execute callbacks."""
        if not callbacks:
            return
            
        funcs = callbacks if isinstance(callbacks, list) else [callbacks]
        for func in funcs:
            try:
                if asyncio.iscoroutinefunction(func):
                    await func()
                else:
                    func()
            except Exception as callback_error:
                logging.error(f"Callback execution error: {callback_error}")

    try:
        yield
    except Exception as e:
        notify.spinner = False
        notify.type = 'negative'
        notify.message = f'{error_content}: {e}'
        await execute_callbacks(on_error)
    else:
        notify.spinner = False
        notify.type = 'positive'
        notify.message = success_content
        await execute_callbacks(on_success)
    finally:
        await execute_callbacks(on_finally)
        await asyncio.sleep(3)
        notify.dismiss()

This way, the user's code becomes much simpler:

from nicegui import ui
import loading_process
import asyncio
import random

@ui.page('/')
async def index():
    async def exec_task():
        async with loading_process():
            await asyncio.sleep(3)    # Assuming this is a task with an uncertain success rate
            number = random.randint(0, 1)

            if number == 0:
                raise Exception("The task failed.")
    
    ui.button('Run task', on_click=exec_task)

ui.run()

[rodja]

Interesting idea, but a bit special. Could also work as an example. To make it more generic it would be cool to somehow be able to incorporate progress bar.