How to implement continues sampling in a Rio GUI

[Nachsh]

Hi guys,

I want to sample a camera and update an imshow fig continuously.
I tried using threading for the sampling. But I fail to refresh the figure.
I would highly appreciate it if someone can put up an example of a continues loop generating data (simulating the camera) and how it is refreshed in a plot.

my failed attempt:

`class CameraPage(rio.Component):

sample: nptype.ArrayLike = np.random.randint(0, 100, size=(200, 6192))
fig = None
fakedata = (np.random.randint(0, 100, size=SIZE[0] * SIZE[1]) for _ in range(100))
shm = shared_memory.SharedMemory(create=True, size=SIZE[0] * SIZE[1], name=SHM_NAME)

def continuous_sample(self, size):      
    array = np.ndarray(size[0] * size[1], dtype=np.int8, buffer=self.shm.buf)
    for item in self.fakedata:
        array[:] = item
        time.sleep(2)
        print('Done sleeping')

def build(self) -> rio.Component:
    fake_thread = threading.Thread(target=self.continuous_sample, args=(SIZE,))
    fake_thread.start()

    self.fig1 = px.histogram(self.sample.flatten(),
         nbins=100, title="Histogram")

    self.fig2 = px.imshow(
        # self.sample,
        np.ndarray(SIZE, dtype=np.int8, buffer=self.shm.buf),
        height=780,
        width=619,
        )

    # Set x-axis labels to horizontal and remove labels
    self.fig2.update_xaxes(tickangle=0, title_text="")
    self.fig2.update_yaxes(title_text="")

    # Create a subplot figure
    self.fig = make_subplots(rows=1, cols=2)

    # Add traces from the individual figures to the subplot
    for trace in self.fig1.data:
        self.fig.add_trace(trace, row=1, col=1)

    for trace in self.fig2.data:
        self.fig.add_trace(trace, row=1, col=2)

    # strip down the rest of the plot
    self.fig.update_layout(
        showlegend=False,
        margin=dict(t=10, l=10, b=10, r=10),
    )
    return rio.Column(rio.Plot(
            figure = self.fig,
            min_height=20,
            min_width=10,
            background=self.session.theme.neutral_color,
        )
    )`

[mad-moo]

Easy! Use the periodic event. It will continuously fire until the component is garbage collected

class MyRoot(rio.Component):
    counter: int = 0


    @rio.event.periodic(2)
    async def _on_periodic(self) -> None:
        self.counter += 1
        await self.force_refresh()

    def build(self) -> rio.Component:
        return rio.Text(
            f"Counter: {self.counter}",
            justify="center",
        )

In general, threading is rarely needed, especially in modern codebases. All of Rio supports asynchrony, so asyncio tasks are almost always preferred over threads.

[Nachshon-d]

Thank you @mad-moo . It solves my issue!