async-io | Concurrent wrappers for native Ruby IO & Sockets | Socket library

Directly, no, you'll block the event loop and won't get concurrency. However, you can use multithreading with asyncio, wrapping sync calls in a thread with asyncio's to_thread coroutine. This delegates a blocking function to run in a separate thread backed by a ThreadPoolExecutor and returns an awaitable, so you can use it in await expressions just like it was non-blocking. Here is an example with the requests library to make 20 web requests, comparing synchronous with threads:

While create_task() doesn't start executing the coroutine immediately, it schedules execution in the background at the first possible opportunity, i.e. at the first await that suspends to the event loop.

gather() is just a helper function that waits for the given awaitables to complete. It doesn't prevent previously scheduled coroutines (such as those started with create_task, but also start_server etc.) from executing.

i want to know at what exact moment does the consumers() coroutine get called?

Since consumers is a coroutine, while it's called once, it can suspend and resume many times, each await serving as a point of suspension/resumption. When you call create_task() it is placed in a queue of runnable coroutines. In each iteration of the event loop asyncio goes through runnable coroutines and executes a "step" of each, where the step executes it until the first await that chooses to suspend. In your code the step happens when your main coroutine suspends in order to wait for gather() to complete.

So one of the issues here is that you are creating 500+ tasks one after another in quick succession with a timeout set outside the task creation.

Just because you ask to run 500+ tasks, doesn't mean 500+ tasks are all going to run at the same time. They get queued up and run when the scheduler deems it's possible.

You set a timeout at the time of creation of 10 seconds. But they could sit in the scheduler for 10 seconds before they even get executed.

You want to have your Http requests to timeout organically, you can do that like this when you create the HttpClient:

I would have expected makeitem to be called after await randsleep(caller=f"Producer {name}") is completed because it is simply the next part to be executed in the function.

The point of using await rather than an ordinary function call is that it allows the current coroutine to be suspended while waiting for the awaitable to provide the requested value. While suspended, the coroutine temporarily relinquishes control to the event loop, which will run other coroutines or callbacks, or go back to sleep, as appropriate.

You are using the socketio.Client() class which is the standard Python client. If you want to write an asyncio application, you must use socketio.AsyncClient().