Using JavaScript-style async promises in Python

Hello Miguel:

Very interesting work. Thanks for taking the time to provide the information and details.

Oh PHP/JavaScript I over-used promise for images throughout my entire application. That gave me the security of not allowing direct access to any images in the application. On the top of that, it also helped as a way to block hackers by running their patience out with so much bits-n-bytes.

I just got involved with Python and want to fast forward. I just learned a bit about Python-with-ajax (from Django Central) and believe that your library--promisio--will be of great value at some point as I learn more.

Thank you and happy thanksgiving!

Laurentino

Just a minor correction: Promises in JS don't run in parallel. They run out of order (outside of the synchronous flow (hence asynchronous). All that means is that the promise won't necessarily be evaluated in the order in which it was declared.
The only way to achieve true parallelism in JS is with the platform's implementation of a worker thread.

Just thought I'd mention it

@Jacob: yes, but to be correct, promises don't run at all, parallel or not. A promise is just an object that holds the state of a task. Tasks are what runs. I have edited out the reference to running in parallel, since you are correct in that this word is used to describe a different type of concurrency that is not what this article is about. What I meant to say is that the async task will run at the same time as the calling task. This is true for both languages.

Very cool attempt.

One minor point, while it's true that the async function returns a coroutine that won't run until you await it for result = f() you can instead do result = asyncio.create_task(f()) which convert the coroutine into a Task object. The Task object is a Future and behaves similarly to Javascript Promise, the coroutine is not a Future although it is awaitable.

Once you've wrapped the coroutine in a Task you can do pretty much anything you could with a Promise in Javascript such as awaiting the same Task multiple times (a coroutine throws an exception if you await it a second time, Task just gives back the completed value each time) or calling .then on a completed Promise (in Python that's calling .add_done_callback() on a Future or Task).

@Duncan: Of course. If you couldn't work in the style of promises in Python, it wouldn't be possible to create a library that emulates those promises! The point I'm trying to make is that the API to work in this way in Python is horrible. Promises have an elegant API (at least my opinion), unlike the Future and Task classes in Python which appear to be designed mostly to be used internally.

Hi Miguel,
Great package and post, thank you! :)
I'm newbie at the Python, I'm not familiar with dynamic programming patterns, so it's possible the answer will be easy.

How can I achive a pattern something like that (or in a another way but same result)? :

class PromiseTest {

    getResult(){

        return new Promise ( (resolve) => {

            this.commit = ( _ => {resolve(1); });
            this.rollback = ( _ => {resolve(0); });

        });

    }

}

let promiseTest = new PromiseTest();

console.log('result:',await promiseTest.getResult());

setTimeout( async () =>  promiseTest.commit(), 1000);

I tried that with your package and the asyncio but I did not find the solution.

Thanks in advance!

@adatron: I'm not sure what is the utility of your example, but in any case, here is a Python version of it:

import asyncio
from promisio import Promise

class PromiseTest:
    def __init__(self):
        self.commit = None
        self.rollback = None

    def get_result(self):
        def f(resolve, reject):
            self.commit = lambda: resolve(1)
            self.rollback = lambda: resolve(0)

        return Promise(f)

async def main():
    promise_test = PromiseTest()

    async def timer():
        await asyncio.sleep(1)
        promise_test.commit()

    asyncio.create_task(timer())
    print('result:', await promise_test.get_result())

asyncio.run(main())

Thank you very much @Miguel for a very quick solution!

Works well!

(By the way, this is a simplified snippet of code (for the sake of example).) Asynchronous tasks are handled in an array. This solution helps manage their life cycle).

P.S .: You're fantastic that you didn't want to suggest another solution right away, instead, you might have thought it might make sense. This is very rare in these technical forums. :). Your new fan is born

Super cool explanation!

Hi Miguel

I came across your package while looking how to convert the following javascript code (puppeteer context) to python, but I can't find the right way to do it . So I was wondering if you could help here ...

  const wait_for_frame = (page, frame_name) => {
    const check_frame = () => {
      const frame = page.frames().find(current_frame => current_frame.name() === frame_name);
      if (frame) {
        fulfill_promise(frame);
      } else {
        page.once('frameattached', check_frame);
      }
    };

    let fulfill_promise;
    const promise = new Promise(x => fulfill_promise = x);
    check_frame();
    return promise;
  };

let myframe = await wait_for_frame(page, 'my frame name');

@Olivier: This is a somewhat convoluted function that mixes async/await, promises and callbacks. Not sure this translates 1:1 into Python and I'm not even sure the Python version of puppeteer works in the same way. I recommend that you create a new function that waits for the frame by checking for it at regular intervals, for example, which is much simpler than this.

hi Miguel,

how to recreate this in python using promisio

let promise1 = new Promise(resolve => {
    setTimeout(() => resolve(), 2000);
});
let promise2 = new Promise(resolve => {
    setTimeout(() => resolve(), 5000);
});

async function c() {
    console.log(2);
    await promise1;
    console.log(4);
    await promise2;
    console.log(5);
}

console.log(1);
c();
console.log(3); 

key point is that "console.log(3);" runs when first promise gets awaited inside c

@Nathan: Here is one way to do it:

import asyncio
from promisio import Promise, promisify

@promisify
async def setTimeout(timeout, resolve):
    await asyncio.sleep(timeout)
    resolve(0)

@promisify
async def c():
    promise1 = Promise(lambda resolve, reject: setTimeout(2, resolve))
    promise2 = Promise(lambda resolve, reject: setTimeout(5, resolve))
    print(2)
    await promise1
    print(4)
    await promise2
    print(5)

async def main():
    print(1)
    p = c()
    print(3)
    await p

asyncio.run(main())

Miguel,

sadly that outputs "1 3 2 4 5" as compared to JS version where it's "1 2 3 4 5". That's because in JS version, when you hit the first await inside c() , it returns immediately and next line of code is executed (which is console.log(3)), and then the rest of stuff inside c() is just fired once the timeouts expire, which is pretty much like scheduling a task to be executed in future. Not sure if that's due to differences between event loop/run time in JS and PY.

@Nathan: Python and JS are not the same language. They have different schedulers so you can't expect identical behavior. I don't think the "2 3" vs "3 2" difference in your example has any significance, though.

No they are obviously not. Yes it seems due to scheduler differences the way is works in JS with example above is that just by calling the async function c() the execution progresses towards first await inside it and then immediately returns back to executor in order to continue doing other stuff (console.log(3) or possibly many other lines of code after the c() call) and then the promises kick in with their results when they are done kinda in background after the c() call.

In python it's more 'serial' in a sense that using await will keep you on that specific line of code where it's used until whatever behind that await completes, without this "jumping" as you see in JS. And just by calling the async func you just get an object (coroutine etc), with nothing done yet. You can workaround this (sort of) by creating tasks or manually scheduling Futures, well, or promises like we see here :-)

If it weren't a statement you could have called the decorator @async , so it sort of reads like "async def", too ;)
Btw: does promisify behave equivalently to JS in that it does not wrap a return value into a Promise again if it already is one? So that you can directly return an existing Promise (Future/coroutine/...) without await'ing it explicitly like you have to in Python?

@Jeronimo: Sure. As long as you return a promise from your promisified functions everything should work. No need to await it if all you need to do is return its result.