Correct pattern for async calls

[dieterrosch]

Hi,

I have a Trame project, where I am using SimpleITK to load some medical images, and then feed them into a processing pipeline. I have a VProgressLinear bar that I want to update as the images load. I am struggling to find the correct way to call the SimpleITK function, which loads the image, and updates the progress using an sitk.Command.

My code is something these lines:

VProgressLinear(
    color="deep-purple",
    height="10",
    v_model=(
        f"{SourceImageWidgetState.SOURCE_IMAGE_LOADING_PROGRESS}",
    ),
)

and

VBtn(
    "Load source image",
    color="deep-purple lighten-2",
    text=True,
    click=(self.ctrl.load_dicom_series,),
    rounded=True,
    outlined=True,
)

My load_dicom_series function looks something like :

@asynchronous.task
@ctrl.set("load_dicom_series")
async def load_dicom_series():
        filter = sitk.ImageSeriesReader()
        filter.SetFileNames(dicom_names)
        filter.AddCommand(sitk.sitkProgressEvent, progress_cmd)
        filter.Execute()

In my progress_cmd, I update the state using

state[SourceImageWidgetState.SOURCE_IMAGE_LOADING_PROGRESS] = int(progress)

As the image loads, the progress variable increments as expected, and I can see the state variable incrementing as well. The issue is that the state doesn't get sent to the front-end, until after the filter.Execute() in load_dicom_series() is completed.

Obviously the SimpleITK filter is a non-awaitable function, so I expect it needs to be wrapped somehow. So I understand that there is something incorrect in how I am trying to kicj off task in a different thread, but I've tried a number of approaches like wrapping the filter.Execute() in a run_in_executor() i.e.

loaded_dicom_image_series = await asyncio.get_running_loop().run_in_executor(
    None, filter.Execute
)

or

loaded_dicom_image_series = await asynchronous.create_task(
    None, filter.Execute
)

and some combinations of the above. None seem to work.

I THINK the idea or solution is to have the back-end task run on a thread that is not the main thread, and update the state object, and to have the main thread update the front-end state. Unfortunately, the Python async-await implementation leaves a lot to be desired in terms of documentation and interface, so I am somewhat at a loss.

The TLDR of my question is "What is the correct pattern to have a button on the web front-end, trigger a task on the back-end, which will update the state, so that the Trame server will send that state back to the Front-End?"

[jourdain]

When you have async update of the state, you need to be explicit when you want that state to be updated.

The easier approach is to do state change in the state context like below:

async do_something():
    while True:
          await asyncio.sleep(0.5)
          with state:
               state.progress += 1

Otherwise you can call state.flush()