Issue 2471 notification

[Andre-Pestana0]

What type of PR is this? (check all applicable)

• Refactor
• Feature
• Bug Fix
• Optimization
• Documentation Update

Description

Implementation of a way to now if a notification was closed or not, including a callback function for the notification and the reason behind it.

def notify(
    state: State,
    notification_type: str = "info",
    message: str = "",
    system_notification: t.Optional[bool] = None,
    duration: t.Optional[int] = None,
    id: str = "",
    on_close: t.Optional[t.Callable[[State, str, str], None]] = None,
) -> t.Optional[str]:


def close_notification(state: State, id: str, reason:str) -> None:

Related Tickets & Documents

• Related Issue Let the application know that a notification was closed #2471
• Closes Let the application know that a notification was closed #2471

How to reproduce the issue

Please replace this line with instructions on how to reproduce the issue or test the feature.

Other branches or releases that this needs to be backported

Describe which projects this change will impact and that needs to be backported.

Checklist

We encourage you to keep the code coverage percentage at 80% and above.

• This solution meets the acceptance criteria of the related issue.
• The related issue checklist is completed.
• This PR adds unit tests for the developed code. If not, why?
• End-to-End tests have been added or updated. If not, why?
• The documentation has been updated, or a dedicated issue created. (If applicable)
• The release notes have been updated? (If applicable)

[Andre-Pestana0]

Hello there, I have some doubts that I would like to share.

First and foremost this is my work until now:

• I have added a callback to notify "on_close" and inside of it Im expecting a user to send the state, notification_id and reason for closing the notification.

def notify(
    state: State,
    notification_type: str = "info",
    message: str = "",
    system_notification: t.Optional[bool] = None,
    duration: t.Optional[int] = None,
    id: str = "",
    on_close: t.Optional[t.Callable[[State, str, str], None]] = None,
) -> t.Optional[str]:

....


    def _notify(
        self,
        notification_type: str = "I",
        message: str = "",
        system_notification: t.Optional[bool] = None,
        duration: t.Optional[int] = None,
        notification_id: t.Optional[str] = None,
        on_close: t.Optional[t.Callable[[State, str, str], None]] = None,
    ):
        if notification_id and on_close:
            self._notification_callbacks[notification_id] = on_close  # A dictonary was created in order to store the callback

• I have added the reason to on_close:

def close_notification(state: State, id: str, reason:str) -> None:
...



    def _close_notification(
        self,
        notification_id: str,
        reason: str = "forced", 
    ):
        if notification_id:
            self.__send_ws_notification(
                type="",  # Empty string indicates closing
                message="",  # No need for a message when closing
                system_notification=False,  # System notification not needed for closing
                duration=0,  # No duration since it's an immediate close
                notification_id=notification_id,
            )

            if notification_id in self._notification_callbacks:
                callback = self._notification_callbacks.pop(notification_id)  
                callback(self, notification_id, reason)

The final result can be seen by the following code and prints:

from taipy.gui import Gui, notify, close_notification

#Callback function
def on_close(state, notification_id, reason):
    print(f"Notification {notification_id} closed due to {reason}")

# Function to trigger a notification
def send_notification(state):
    notify(state, "info", "This is a test notification!", None, None, "3", on_close)

# Function to close the notification
def close_test_notification(state):
    close_notification(state, "3", "forced")

if __name__ == "__main__":
    page = """
# Notification Demo

Click the button to trigger a notification:

<|button|text=Send Notification|on_action=send_notification|>

Click the button to close the notification:

<|button|text=Close Notification|on_action=close_test_notification|>
"""
Gui(page).run()

My question

I don't understand if the changes requested are these or if the reasons"forced" and "timeout" should be something that the user never has to actually state

[FredLL-Avaiga]

please do not commit file that are not related to the PR
I suppose this PR is missing a front-end part ?
How should that part be handled ?

[FredLL-Avaiga]

this file shouldn't be committed

[FredLL-Avaiga]

this file shouldn't be committed

[Andre-Pestana0]

please do not commit file that are not related to the PR I suppose this PR is missing a front-end part ? How should that part be handled ?

Hello there @FredLL-Avaiga, thank you for the reply
Regarding the files that are not meant to be committed I will make sure that in the final version those will not be included.
I sent this PR in order to clarify this doubt:

I don't understand if the changes requested are these or if the reasons"forced" and "timeout" should be something that the user never has to actually state

For now there are no front-end modifications, I just wanted to clarify my previous question so that I am aware on what needs to be done

[Andre-Pestana0]

Hello there @FabienLelaquais,
First and foremost sorry for bothering,
I have a question regarding this issue and I was wondering if you could give some insight.

I don't understand if the changes requested are the ones that I made (the user inputs the reason whenever he closes the notification), or if the reasons "forced" and "timeout" should be something that the user never has to actually state.

You also said this:

It could make sense for the app to know about this, in order to potentially show other notifications that would be unreadable should too many notifications be visible yet.

However, when I try create multiple notifications there is a limit of 5 notifications that are displayed simultaneously, and whenever there is a sixth notification, one of the older notifications will be removed (in a First In First Out manner) .
I don't know if i am missing something, but it seems that that problem would not occur (but again, I might be missing something)

Looking forward to hearing from you

[FabienLelaquais]

Hello there

Hi @Andre-Pestana0
And thank you for your involvement in this thing. And also, don't apologize for asking questions: that's the only path to a proposal that you and us can agree on.

Now.
"I don't understand if the changes requested are the ones that I made"
Well the point of this issue is to let the application know if and when a notification was closed, and why.
When the app creates a notification, now it appears on the front-end, and the app can forget about it.
I tried to come up with a rationale as to why the application would want to know when closing a notification happens, and you pointed out that my use case makes little sense (since no more than five consecutive notifications are visible anyway).
So let's forget about that use case and imagine another one, such as a notification that a developer really wants to make sure the user acknowledges and interacts with (by closing it). That could be a notification about a severe problem that the app needs the user to know about and fix.
So when the user closes (manually) the notification (that in this case would have been created with an illimited time out period), then the application needs to be notified that this happens. The "why" is the cherry on the cake: because the front-end side 'knows' why a notification is closed (timeout vs manual close), it's easy to let the back end know as well. That is what I called the "reason": depending on the cause of the notification being closed, the "reason" is set - by the front-end code - to "timeout" or "forced" (indicating a manual interaction).
At the end of the day, it is the user interaction (click the close box, or wait for timeout) that sets the 'reason', not the programmer.

Does that makes sense?

[Andre-Pestana0]

it is the user interaction (click the close box, or wait for timeout) that sets the 'reason', not the programm

@FabienLelaquais
It makes total sense!
Thank you so much for the clarification!