UnhashableParamError for Pydantic models when using st.cache_data()

[mmz-001]

Checklist

• I have searched the existing issues for similar issues.
• I added a very descriptive title to this issue.
• I have provided sufficient information below to help reproduce this issue.

Summary

The new st.cache_data() decorator can't hash arguments which are Pydantic models, however st.cache() seems to work fine.

Reproducible Code Example

import streamlit as st
from pydantic import BaseModel

class Person(BaseModel):
    name: str

@st.cache_data()
def identity(person: Person):
    return person


person = identity(Person(name="Lee"))

Steps To Reproduce

1. Run the code example

Expected Behavior

Streamlit should be able to cache the parameters.

Current Behavior

Error:

streamlit.runtime.caching.cache_errors.UnhashableParamError: Cannot hash argument 'person' (of type `__main__.Person`) in 'identity'

Is this a regression?

• Yes, this used to work in a previous version.

Debug info

• Streamlit version: 1.20.0
• Python version: 3.10.2
• Operating System: Windows 10
• Virtual environment: Poetry

Additional Information

No response

Are you willing to submit a PR?

• Yes, I am willing to submit a PR!

[sfc-gh-jcarroll]

Hey @mmz-001 there are a few workarounds described here

#6295

I think there's also a way to solve it by making the class pickle-able - ETA: See below

[sfc-gh-jcarroll]

So two things:

1. The code example you showed is using the pydantic class as both an input AND output of the cached function. To be clear, caching where you only return the Person object works fine.

# This totally works
@st.cache_data()
def identity(name: str):
    return Person(name=name)

2. In a case where you need to use the Pydantic model (or instance of some other custom class) as an input, there is another approach where you implement __reduce__() on the class, which allows streamlit to hash it as an input parameter. As described in the pickle documentation, this is a potentially dangerous thing to do, which can impact the serialization/deserialization of class instances in other contexts. It should be used carefully!

Disclaimer: I'm not a pickle expert, I think this approach works but not guaranteed

import streamlit as st
import pickle
import functools
from pydantic import BaseModel

class Person(BaseModel):
    name: str

    def __reduce__(self):
        return (functools.partial(Person, name=self.name), tuple())
    
    def _repr_html_(self):
        return f"I am a Person named {self.name}"

@st.cache_data()
def identity(person: Person):
    return person

person = identity(Person(name="Lee"))
st.write(person)

person = pickle.loads(pickle.dumps(person))
st.write(person)

cc @tconkling who can maybe help keep me honest

[sfc-gh-jcarroll]

Ah - Digging through some other issues, I also found a simpler solution using @dataclass

from dataclasses import dataclass
from pydantic import BaseModel

# need init=False to prevent it from overriding Pydantic's init method
@dataclass(init=False)
class Person(BaseModel):
    name: str
    
    def _repr_html_(self):
        return f"I am a Person named {self.name}"

[mmz-001]

@sfc-gh-jcarroll thanks for looking into this issue. Using dataclasses seems the best way to resolve this problem in the example I gave. However, changing the Person model isn't ideal, especially if the model comes from another library or module. Of course, we can subclass the model but this opens up a host of other issues that may require major refactoring.

It would be best if Streamlit natively supports using pydantic models as input arguments to cachable functions since it is a common use case. Alternatively, bringing back the hash_func to the new cache primitives should also work.

[lambertwx]

Count me as another vote endorsing @mmz-001 's opinion above. I just ran into the same problem.

[sfc-gh-jcarroll]

I believe this will be fixed with #6502 in the next release. Let us know if it doesn't seem to solve the issue.

[sfc-gh-jcarroll]

Fixed with 1.24.0

[TateStaples]

Fixed with 1.24.0

This is still an issue for me in 1.24.1.

UnhashableParamError: Cannot hash argument 'reporter' (of type reporting.Reporter) in 'load_data'.

Here is the basics of the reporting.Reporter class

class Reporter:
def init(self, case_board: pd.DataFrame):
self.case_board = case_board
self.df = case_board

def hash(self):
""" Hash the dataframe """
return int(pd.util.hash_pandas_object(self.df).sum())