Summary

When streamlit reruns a file with a class definition this class gets newly instantiated in memory. A cached instance of this class however remains an instance of the old definition of this class. A newly created instance of it therefore ends up being of a different class than a cached instance of it which can lead to hard to debug bugs.

Steps to reproduce

1. Run this code with streamlit run

from enum import Enum
import streamlit as st

class A(Enum):
    Var1 = 0

@st.cache
def get_enum_dict():
    return {A.Var1: "Hi"}

look_up_key = A.Var1
cached_value = get_enum_dict()
st.write("class id of look_up_key: {}".format(id(look_up_key.__class__)))
st.write("class id of cached key: {}".format(id(list(cached_value.keys())[0].__class__)))
st.write(cached_value[look_up_key])

1. Rerun by pressing ‘r’

Expected behavior:

Rerunning should print the same id for the class of look_up_key and the key in cached_value and the code should still print “Hi” at the end.

Actual behavior:

On the intial run the code print two times the same id and the look-up in the dictionary is successful. But on rerun the class ids differ and a KeyError: <A.Var1: 0> is raised.

Is this a regression?

no

Debug info

• Streamlit version: 0.71.0
• Python version: 3.8.3
• Using Conda
• OS version: Mac OS 10.15.7
• Browser version: Firefox 82.0.3 (64-Bit)

Additional information

This bug is not unique to Enums but happens with all user-defined classes that get reevaluated. I had the same problems with other classes but this example is more easily reducible.

Ideas on how to fix it

Pickling and unpickling the cached object causes the class id to be updated to the new definition.

A very helpful short-term band-aid would be to have a separate st.cache option that forces pickling and unpickling also for the in-memory cache. That way the user can circumevent that bug selectively for the problematic types.

Long term I have two ideas but do not know how feasible they are: Walk the object hierarchy of every cached value and

1. apply in-memory pickling only selectively to classes which definitions are in files that might be rerun during a Session
2. “Hot-Patch” the __class__ field upon retrieval from the cache. But I do not know whether that is reliable in python or whether there are unintended side-effects to that.