awesomeness | HTTP based federated protocol for real time | Architecture library

Try this out, it should work for both a YouTube song name and a YouTube URL:

you do not need to have quotes around the from-address and you must encode the lt/gt symbols:

Add /messages to the end of your domain so it's

curl -s --user 'api:dfjkdjksan-api-keyasdfjkj' \ sandbox33380083kdsomedomain39dks.mailgun.org/messages

Also if you're using GoDaddy, make the domain for most of you mx and txt records to be just the subdomain like mg instead of mg.yourdomain.com

I suspect that, since the .send() method is asynchronous, your handler does not wait long enough and finishes running before the message is done.

Return a promise (the API of mailgun-js is already producing promises, you just need to return them):

To build the array of posts, you need to append elements to the array of posts. Currently, you are just assigning a single element to the array over and over, which overwrites the previous value of the entire array.

The code to append posts:

A second read on this reveals that you're actually looking for gRPC support. This is actually possible right now - you just need to provide a custom binder config:

Trio won't directly parallelize CPU-bound code like this. Being an "async framework" means that it just uses a single CPU thread, while parallelizing I/O and networking operations. If you insert some calls to await trio.sleep(0) then that will let Trio interleave the image searching with other tasks, but it won't make the image searching any faster.

What you might want to do, though, is use a separate thread. I guess your code is probably spending most of its time in opencv, and opencv probably drops the GIL? So using threads will probably let you run your code across multiple CPUs at once, while also letting other async tasks run at the same time. To manage threads like this, Trio lets you do await trio.to_thread.run_sync(some_sync_function, *args), which runs some_sync_function(*args) in a thread. If you run multiple calls like this simultaneously in a nursery, then you'll use multiple threads.

There is one major gotcha to watch out for with threads, though: once a trio.to_thread.run_sync call starts, it can't be cancelled, so timeouts etc. won't take effect until after the call finishes. To work around this you might want to make sure that individual calls don't block for too long.

Also, a side note on style: functions made for Trio usually don't take timeout= arguments like that, because if the user wants to add a timeout, they can write the with block themselves around your function just as easily as passing an argument. So this way you don't have to clutter up APIs with timeout arguments everywhere.

Just call validateForm again after the reset:

Looking a bit more closely at ncw's gist, I noticed that one key difference was the setting of the InsecureSkipVerify option in the client's TLS config to true. I added this, so