run_method with return type

[WolfgangFahl]

See #1446

For a start a string value return type would be helpful. Having more datatypes such as int/float/string/date and so on would be useful but i think it would then suffice to return a json string with the intended content that can be deserialized on the python side.

[falkoschindler]

Thanks for the feature request, @WolfgangFahl!

This would indeed be a useful extension to the existing API. It's probably a bit tricky, because run_method is currently synchronous, but would need to await the result from a websocket message that is sent independently from the method call. Thus we would either need to introduce a different async method (like "run_and_await_method") or introduce a breaking change by making run_method async.

[WolfgangFahl]

@falkoschindler - i think a new run_and_await_method is just fine and the original would be the "fire and forget" version.

[rodja]

I think await run_and_await_method() is not "nice". The duplicity of "await", the length, and general low "speakability" are just too ugly.

[WolfgangFahl]

@rodja

Here are ChatGPT's suggestions for alternative names:

• runAsync()
• executeAsync()
• invokeAsync()
• performAsync()
• launchAsync()
• startAsync()
• asyncRun()
• triggerAsync()
• processAsync()
• initiateAsync()

[falkoschindler]

I just experimented with an implementation for run_method that can be awaited but doesn't have to:

import asyncio
from nicegui import background_tasks, ui

def run_method(command: str) -> asyncio.Task:
    print(f'Send method call "{command}" to client...')
    async def wait_for_response():
        print('Wait for response...')
        await asyncio.sleep(0.5)
        return f'Response to "{command}"'
    return background_tasks.create(wait_for_response())

def fire_and_forget():
    run_method('fire_and_forget')

async def wait_for_response():
    result = await run_method('wait_for_response')
    ui.notify(result)

ui.button('Fire and forget', on_click=fire_and_forget)
ui.button('Wait for response', on_click=wait_for_response)

ui.run()

The synchronous function returns a Task which can be ignored or awaited, which looks very clean to me. Maybe way we can also improve the run_javascript implementation this way and remove its respond parameter.

However, there is a downside: At the moment of sending the method call to the client, we don't know whether the function will be awaited. Therefore we can't tell the client whether a response is expected and the client needs to always send the response back to the server. But in most cases this should be negligible.

[falkoschindler]

Similar but different:

class AwaitableResponse:

    def __init__(self, command):
        self.command = command

    def __await__(self):
        print('This object is being awaited!')
        return self._actual_coroutine().__await__()

    async def _actual_coroutine(self):
        print(f'Wait for response to "{self.command}"...')
        await asyncio.sleep(0.5)
        return f'Response to "{self.command}"'

def run_method(command: str) -> AwaitableResponse:
    print(f'Send method call "{command}" to client...')
    return AwaitableResponse(command)

[falkoschindler]

I finally found a solution to tell the client whether a response is expected or not. This is done by creating a background task for sending the "fire-and-forget" message to the client, which is immediately canceled and replaced with a new message if the response is awaited:

class AwaitableResponse:

    def __init__(self, command):
        self.command = command
        self.fire_and_forget = background_tasks.create(self.send_command())

    async def send_command(self):
        print(f'Sending command "{self.command}" to client...')

    def __await__(self):
        self.fire_and_forget.cancel()
        print(f'Sending command "{self.command}" to client and wait for result...')
        return self._actual_coroutine().__await__()

    async def _actual_coroutine(self):
        print(f'Waiting for response to "{self.command}"...')
        await asyncio.sleep(0.5)
        return f'Response to "{self.command}"'

def run_method(command: str) -> AwaitableResponse:
    return AwaitableResponse(command)

[rodja]

Nice!!!

[falkoschindler]

Implemented in PR #1797.