How can python await delay_sim and delay_app?

[quaris628]

I want to await delay_sim(duration) from python. How is this possible, or is it not?

Some ways I've tried and failed:

async def my_function():
    await delay_sim(seconds=1)

npc_cag.py has a couple uses of AWAIT(delay_sim(...)), like this

def my_function():
    AWAIT(delay_sim(seconds=1)

But when I try it, no delay happens; the function executes as if the AWAIT line was not there.
(Note that the yield keyword in python is not the same as the yield keyword in mast.)

[dougreichard]

To use delays in python they python code must be running as part of a MAST/PyMAST label. Meaning it is code scheduled and running in the MAST runtime.

The examples mentioned in npc cag are scheduled labels. They are decorated with the @Label, they are schedule to run in the MAST runtime.

task_schedule(self.tick_fighter_launch)
task_schedule(self.tick_fighter_manage)

The correct way is to yield and AWAIT that wraps the delay

yield AWAIT(delay_sim(seconds=10))

Low Level details

A PyMAST label is a python function. More importantly it is a generator function. These functions run until they yield or end. This is NOT the same as the normal python execution of a function. This is at a low level similar to the python "async" functions. Python "async" cannot be used because the cosmos system does not support multithreading or long running functions.

PyMAST python labels can jump to other labels as well. They run like MAST labels using a different runtime ticker. Much is done leveraging generator functions that progress then yield for a given slice of execution.

The Pythons script code in cosmos must NEVER block the main execution. MAST and PyMAST allow the script to 'pause' and pickup later in a non-blocking manner. So a Delay functions actual yields execution until the specified time is reached and then continues on. The engine runs, calls the script, it yields, and this repeats until the delay time is reached.

[quaris628]

When you say "running as part of a MAST/PyMAST label", does that include functions called from within the label? Or can it only be done in the label's base layer of the call stack (because it needs to yield/return what AWAIT returns to the engine code that called it)?

[dougreichard]

The label needs to handle the execution flow within the label. This is where MAST/PyMAST execution is different than standard call stack function calls.

Python functions called from a python label are just python functions. One could return a Promise that can be awaited. This is how the delay functions work. I'm not sure that is what you want either. Python calls from MAST or PyMAST are expected to return and run to completion in a non-blocking manner.

If you called a python function from a label, and yielded it would then be a generator function. Which one could manage within the label, but yes it would still need to be handled within the label. I don't recommend using a generator in this situation.

You could yield AWAIT(task_schedule(my_python_label)) another python label.

You are getting deep into somethings where if you forget a single yield, it could create a spin lock. So, be careful. MAST shields people from these types of errors.