uvloop | Ultra fast asyncio event loop | Reactive Programming library

Read the error message, where it is clearly stated you are missing a header file:

fatal error: rocksdb/slice.h: No such file or directory 705 | #include "rocksdb/slice.h" | ^~~~~~~~~~~~~~~~~ compilation terminated. error: command '/usr/bin/gcc' failed with exit code 1

Accordingly, you'll need to build and install RocksDB. This is separate from the installation of faust[rocksdb] with pip. That simply installs python-rocksdb, the Python interface to the underlying libraries.

There is even a (third-party) RocksDB docker image based on Python 3.7 Slim.

You could use that directly or take some tricks from the Dockerfile for that image.

As you said, uvloop is written in Cython (equivalent to c) on top of libuv.

Writing code in Cython is almost guaranteed to give you a noticeable speed boost which is exactly what's happening here. No need for any other difference. It's much like numpy doing operations faster than writing normally in Python.

For your other question: The difference between asyncio and asyncio-streams is that streams are built on top of the basic asyncio.

Asyncio uses transports and protocols, the first responsible for writing to the socket, and the second for handling data received by the socket.

Streams are simple constructs built on top of both, and have an easier to use interface that mimics regular files or sockets.

Why is that?

Because your docker container is configured to run /usr/local/bin/gunicorn, as defined by the ENTRYPOINT instruction.

how can I run that above command in background and go to entrypoint in docker file.

The standard way to do this is to write a wrapper script which executes all programs you need. So for this example, something like run.sh:

This import error is owing to the following process:

1. supplier_schema.py is defined
2. supplier_schema module imports Category from schemas.category_schema
3. Since schemas.category_schema hasn't yet been defined, it is now executed.
4. But wait! category_schema requires importing Supplier from supplier_schema.
5. supplier_schema cannot proceed execution without importing from category_schema and vice versa.
6. This is known as a circular import.

I'll be addressing this specific case.
For more general use cases, read: Circular import dependency in Python

Option 1: Combine everything into one module.

• This is the fastest and simplest solution.
• Can get pretty out of hand once your ORM code increases to many models.

Option 2: Import models in the initialization of the root module and change import language:

• Robust solution
• Requires more careful planning and architecting of your project
• Requires testing (additional imports create opportunity for breakage)

Here's how to execute this:
Ensure your schemas module contains an init file:

Binding to '0.0.0.0' (all NICs) seemed to solve the issue after hardcoding that to the app.start function. Before used to bind to ipv6 localhost address (::1)

After further googling, it turns out that the issue here is that newer versions of Alpine Linux (3.14+) requires Docker 20.10.0 or higher.

Downgrading Alpine to 3.13 properly builds.

Given that Ubuntu 16.04 on the build system is EOL since April 2021, I'll aim at having it upgraded rather than pinning old version of Alpine for the build.

In multithread you have shared memory but in multiprocessing, you dont have shared memory. So when you try change global variable in each process, you miss data. This problem have no solution in this way, you should choose right option attention to your project situations. If you need to manipulate shared data in each parallel function you should use thread. Although you can use Queue to pass data between each process in multiprocessing. https://docs.python.org/3/library/queue.html

Linode blocks outgoing mail by default. Refer to their docs here

Always refer to the documentation of the provider of your cloud based server if you encounter SMTP issues.

Need to ad this header to my conf