Handle | Handler-based Eventbus for Android | Frontend Utils library

Instead of this:

The math module from the standard library has a sqrt function to calculate the square root of a number. It takes any type that can be converted to float (which includes int) as an argument and returns a float.

Found this issue, pytube v11.0.1. It's a little late for me, but if no one has submitted a fix tomorrow I'll check it out.

in C:\Python38\lib\site-packages\pytube\parser.py

Change this line:

152: func_regex = re.compile(r"function\([^)]+\)")

to this:

152: func_regex = re.compile(r"function\([^)]?\)")

The issue is that the regex expects a function with an argument, but I guess youtube added some src that includes non-paramterized functions.

It was a bit hacky so I simplified it, I think you should understand the logic behind it.

In order to achieve this goal we need to create permutation of all allowed paths. For example:

I think this algorithm does what you want, but it's not very efficient. It may provide others with a starting point for faster solutions.

You can protect the task with asyncio.shield to guarantee graceful shutdown of the context manager, I did changes only in main():

You can't deconstruct directly in an out parameter yet unfortunately, see this proposal.

You'll have to deconstruct it yourself:

This is because you want to be able to have a coroutine outlive its handle, a handle should be non-owning. A handle is merely a "view" much like std::string_view -> std::string. You wouldn't want the std::string to destruct itself if the std::string_view goes out of scope.

If you do want this behaviour though, creating your own wrapper around it would be trivial.

That being said, the standard specifies:

The coroutine state is destroyed when control flows off the end of the coroutine or the destroy member function ([coroutine.handle.resumption]) of a coroutine handle ([coroutine.handle]) that refers to the coroutine is invoked.

The coroutine state will clean up after itself after it has finished running and thus it won't leak unless control doesn't flow off the end.

Of course, in the generator case control typically doesn't flow off the end and thus the programmer has to destroy the coroutine manually. Coroutines have multiple uses though and the standard thus can't really unconditionally mandate the handle destructor call destroy().