State persistence on reload?

[adamfluty]

Is there a way to persist states when the user refreshes the page?
I have tried adding a secret key to the server's flask app in the source code and then make a unique session key when my user hits the main page, but on reload the id keeps changing. I could make a work around by having a user input a unique id... but I don't love that solution.

Here's what I tried to do to the click example:

from flask import session
import uuid
import os

ID_TO_STATE = {}


@me.stateclass
class State:
    clicks: int


def button_click(event: me.ClickEvent):
    state = me.state(State)
    state.clicks += 1


@me.page(path="/counter")
def main():
    session.setdefault("client_id", str(uuid.uuid4()))
    client_id = session["client_id"]
    me.text(client_id)

    if client_id in ID_TO_STATE:
        state = ID_TO_STATE[client_id]
    else:
        state = me.state(State)
    ID_TO_STATE[client_id] = state

    me.text(f"Clicks: {state.clicks}")
    me.button("Increment", on_click=button_click)

[wwwillchen]

There isn't an easy way to do this today. You could connect to a database/redis and then store the data there.

@richard-to is working on a way to eventually back the session data to a datastore like redis.

Could you tell us more about your use case?

[adamfluty]

Use case is a simple browser game where multiple users submit answers on one page and a main game page where the details are displayed. I want the submission page to remember its state when the page reloads so users don’t get confused.

I can definitely store things in a database, but l want it to reload automatically when the same browser session reconnects. So if you visit the app, state A is reloaded, but if I visit, state B is reloaded. I want to do this without the user needing to enter a unique id every time they refresh (in order to look up the state).

In the past, I’ve generated session ids and stored them in the flask session object. And this would carry over page refreshes and navigations (until cookies were cleared or new browser or whatever). This worked in flask out of the box.

Is Mesop doing something with cookies or the flask instance on load that prevents the session object from persisting (i.e resets it)?

Thanks for the response and the help! :)
Obviously I’m just toying around here but this was the first idea I wanted to recreate.

[wwwillchen]

Thanks for the response. Mesop isn't doing anything with the session object. Based on the flask docs, https://flask.palletsprojects.com/en/3.0.x/api/#flask.session.permanent, I think you need to make it explicitly set to permanent.

[adamfluty]

Unfortunately that setting just controls the lifetime of the persistence. I’m fine with either until browser closed (false) or 31 days (true). I just want persistence between refresh presses which both settings should handle.

I’ll keep digging if I have time. Hopefully someone figures this out!

[richard-to]

Yes, as Willl mentioned, we are working on a backend state persistence improvement. It's still in the design phase, but one option we have is to use the Flask session cookie to store look up key for the state. So if we take that approach for storing the look up key, I think we would be able to reload state for the user.

At the moment, I don't think there is a way for you to access the flask session object from Mesop. And there's no way to set the secret key which is required for using the flask session object.

[adamfluty]

I figured it out partially...

1. The flask app needs a secret key to be set to be able to load a session object per session. This is something each dev should put in themselves. It's as easy as:
   flask_app.secret_key = b"very_secret_key"
   and the mesop script can get the flask app instance easily with the current_app variable:
   from flask import current_app
   But note you can only use it within the context of a request for it to work. Not sure how to nicely set this in a Mesop script, such that the secret key can be set before any "real" sessions are started. Probably easy though by using an initial "dead" request just to open the app context so the script can get the instance and set the key... or like below, just check that its set for every request that comes through (don't love either but they work and the key is set for the lifetime of the app):

def set_secret_key(e):
    if current_app.secret_key is None:
        current_app.secret_key = os.urandom(24)
        print("key set", current_app.secret_key)


@me.page(path="/counter", on_load=set_secret_key)
def main():
    #do stuff

2. The crux of the session persistence issue comes from server.py in the ui_stream route/function. If I edit the session object in this function directly then that session object persists!! These changes even propagate INTO the response generating code:

   response = Response(
     stream_with_context(generate_data(ui_request)),
     content_type="text/event-stream",
   )

However, edits to the session WITHIN the generating code (i.e. within the Mesop app) do NOT propagate out. So somehow the subcontext's session object would need to be passed out with the response and then override the existing one in the global context (i.e. the ui_stream function).

I tested the session persistence within the ui_stream route and it works exactly as expected: each user has their own session until they close their browser or open a different browser altogether.

Hope this helps!