cmd2 usage within asyncio.get_event_loop().run_until_complete

[adriansev]

Hi! I would like to use cmd2 to create a shell for interactivity with a websocket based service.
For persistence a websocket must be created within asyncio.get_event_loop().run_until_complete()
see websockets
How can i adapt cmd2 to such usage? (note that i am interested only in a shell, not sending commands, as that it is covered) for reference my application is here

[tleonhardt]

Hi @adriansev, we have info in the cmd2 documentation about integrating with Alternate Event Loops

Please see if that answers your question about how you can adapt cmd2 for use with ayncio.

[adriansev]

yes, i seen the documentation but it is not clear to me what part from example i am supposed to run within the asyncio.get_event_loop().run_until_complete(). the websocket and related operations are supposed to run within the loop, and my goal is to have a shell like interface where commands are sent to websocket server, and i get back the messages from that server.
moreover :

python3
Python 3.7.4 (default, Jul  9 2019, 16:32:37)
[GCC 9.1.1 20190503 (Red Hat 9.1.1-1)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import cmd2
>>> app = Cmd2EventBased()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'Cmd2EventBased' is not defined
>>>

[tleonhardt]

The documentation previously linked shows how a user can create a custom Cmd2EventBased class which inherits from cmd2.Cmd; thus Cmd2EventBased is NOT built into `cmd2 - it is just an example of how you can create your own custom class.

That same example code shows how you can call a method such as runcmds_plus_hooks() in your own event loop to get most of the functionality out of cmd2 but in your own event loop.

The 95% use case for people using cmd2 is to use the built-in event loop. I've never used asyncio and I don't have time to learn it now, so I really can't help you much further.

@kotfu Are you familiar enough with asyncio to give any additional help?

[NekoShinobi]

I've used asyncio in the context of inside cmd2, but not the other way around.

This might be a stupid question, but...
Are you trying to make cmd2 run asynchronously from the rest of your application? or are you trying to simply have cmd2 call your asynchronous functions?

[adriansev]

yes, i am just trying to call async functions from cmd2. the "commands" are websocket send messages (async) that then await for recv answer to the server. Is there any way to accommodate this?
The alternative is to create a global variable (eventually in a namespace to not clash with anything else) were an send_command function would deposit the awaited answer.

[NekoShinobi]

The way I do it is by creating a cmd2 object as you normally would according to documentation, then within the do_* commands, you call loop.run_until_complete() on the functions you want to await.

Since if you have a lot of async stuff, it's a little annoying to write a separate async function for every do_* function, so I also had my own wrapper that would allow me to use async def do_* functions that be wrapped with run_until_complete() at runtime, so that cmd2 would work with async functions.

However, this is all assuming that your workflow is to execute command -> await something -> return back to cmd2 prompt and wait for the next input.

If you're goal is to send a command -> return back to prompt -> then alert the cmd prompt when the answer is received, you will probably have to probably mess with the cmd2loop to make it compatible with asyncio.

[adriansev]

However, this is all assuming that your workflow is to execute command -> await something -> return back to cmd2 prompt and wait for the next input.

It's exactly like that! Thanks a lot!! i will try it out to see how it goes

[tiolan]

Hi @tleonhardt, following this guide and the documentation, I was able to run cmd2 on the asyncio event queue with help of aioconsole.
It is basically this:

    async def run(self):
        while not self.onecmd_plus_hooks(await aic.ainput()):
            pass

I can run all my commands.
But what now is lost is the prompt and the welcome message, that I set like this:

class Program(cmd2.Cmd):
    def __init__(self):
        cmd2.Cmd.__init__(self)
        self.prompt = "(>>) "
        self.intro = "Welcome"

I only have an empty console, that I can use for input.

Here is how I instantiate it:

if __name__ == "__main__":
    prog = Program()
    prog.preloop()
    aio.run(prog.run())
    prog.postloop()

Any idea what causes this?
When using the built in event loop, it works as expected.

[THEGOLDENPRO]

The way I do it is by creating a cmd2 object as you normally would according to documentation, then within the do_* commands, you call loop.run_until_complete() on the functions you want to await.

Since if you have a lot of async stuff, it's a little annoying to write a separate async function for every do_* function, so I also had my own wrapper that would allow me to use async def do_* functions that be wrapped with run_until_complete() at runtime, so that cmd2 would work with async functions.

However, this is all assuming that your workflow is to execute command -> await something -> return back to cmd2 prompt and wait for the next input.

If you're goal is to send a command -> return back to prompt -> then alert the cmd prompt when the answer is received, you will probably have to probably mess with the cmd2loop to make it compatible with asyncio.

How did you go about creating your own wrapper to allow for async def functions.

[asokolsky]

Here is a sample cmd2 app with commands calling an async function:

import asyncio
import concurrent.futures
import sys
import threading

import cmd2

_event_loop = None
_event_lock = threading.Lock()


def run_async(coro) -> concurrent.futures.Future:
    """Await a coroutine from a synchronous function/method."""

    global _event_loop

    if _event_loop is None:
        with _event_lock:
            if _event_loop is None:
                _event_loop = asyncio.new_event_loop()
                thread = threading.Thread(
                    target=_event_loop.run_forever,
                    name='Async Runner',
                    daemon=True,
                )
                thread.start()

    return asyncio.run_coroutine_threadsafe(coro, _event_loop)


class HelloWorldApp(cmd2.Cmd):
    """
    A simple cmd2 application.
    Demonstrates how to run an async function from a cmd2 command.
    """

    def do_async_wait(self, _: str) -> None:
        """Waits asynchronously."""

        async def async_wait(duration: float) -> float:
            await asyncio.sleep(duration)
            return duration

        waitable = run_async(async_wait(0.1))
        # Wait for coroutine to complete and get its return value:
        res = waitable.result()
        self.poutput(f'Done waiting: {res}')
        return

    def do_hello_world(self, _: str) -> None:
        """Prints a simple greeting."""
        self.poutput('Hello World')


async def main() -> int:
    """
    Having this async ensures presence of the top level event loop.
    """
    c = HelloWorldApp()
    return c.cmdloop()


if __name__ == '__main__':
    sys.exit(asyncio.run(main(), debug=True))

[tleonhardt]

@asokolsky Thanks for providing an example! Please feel free to submit a PR to add this underneath the examples directory.