Immediate UI Rehydration from Background Task Updates

[hantran7]

Hi everyone,

I'm encountering an issue where my background task updates the state correctly but the UI doesn’t immediately rehydrate with the new state until another reactive event (like a button click for new file upload) is triggered. My use case involves processing file uploads in one microservice, with a RabbitMQ message updating the status in my Reflex state.

I have an UploadState where file statuses are stored in a dictionary (file_statuses). A background task (via RabbitMQ) calls an event handler update_file_status that updates the status for each file and, if a file is complete, sets a processing_complete flag. I’m using a bare yield at the end of the event in hopes it forces a state flush to the UI. Here’s a simplified version of the code:

`@rx.event
async def update_file_status(self, filename, status):
logger.info(f"Received status update for {filename}: {status}")
# Update the file_statuses dictionary to reflect the new status
new_statuses = {**self.file_statuses, filename: status}
self.file_statuses = new_statuses
logger.info(f"Updated statuses: {new_statuses}")

if status == "COMPLETED":
    self.processing_complete = True

yield  # Intended to flush the update immediately`

What I've Tried:
Normal (Non-background) Event with a Bare Yield:
As shown above, using a bare yield in a standard event still defers the state flush until another reactive event occurs.

Setting the Event to background=True:
I also tried setting the decorator to @rx.event(background=True) on the update_file_status event so it would run as a background task with an async with self block. However, this approach produced the same result—the state on the server updated correctly, but the UI did not immediately rehydrate.

Forcing a Flush with a Periodic Dummy Event:
I experimented with a dummy flush event scheduled on a timer (e.g., using a background coroutine to call a flush event at regular intervals) so that state diffs would be forced. However, even with this approach, the UI still shows stale statuses until another user-initiated event occurs.

Example flush event:
`@rx.event
async def flush_state(self):
yield

async def periodic_flush(self, interval: float = 0.1):
while True:
await asyncio.sleep(interval)
async for _ in self.flush_state():
pass

@rx.event
async def initialize_flush(self):
asyncio.create_task(self.periodic_flush())
yield
`

Given that background tasks in Reflex—whether using a bare yield or running with the background=True decorator—update state correctly but do not force immediate UI rehydration, is there a recommended workaround to force a reactive flush without a user-triggered event?

Specifically, I'm interested in solutions or design recommendations to ensure that state changes coming from a message queue (from another microservice) are immediately reflected in the UI. Are there alternative approaches to scheduling a dummy reactive event or any configuration options in Reflex that can force the flush?

Any guidance or suggestions would be greatly appreciated!

Thanks in advance!