Cython VS falcon

The approach that I favour is to use Cython. The nice thing with this approach is that your code is still written as (almost) Python, but so long as you define all required types correctly it will automatically create the C extension for you. Early versions of Cython required using Cython specific typing (Python didn't have type hints when Cython was created), but it can now use Python's type hints.

and again, everything that was released after using an older version of cython.

Just for reference,

* Nuitka[0] "is a Python compiler written in Python. It's fully compatible with Python 2.6, 2.7, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 3.10, and 3.11."

* Pypy[1] "is a replacement for CPython" with builtin optimizations such as on the fly JIT compiles.

* Cython[2] "is an optimising static compiler for both the Python programming language and the extended Cython programming language... makes writing C extensions for Python as easy as Python itself."

* Numba[3] "is an open source JIT compiler that translates a subset of Python and NumPy code into fast machine code."

* Pyston[4] "is a performance-optimizing JIT for Python, and is drop-in compatible with ... CPython 3.8.12"

[0] https://github.com/Nuitka/Nuitka

[1] https://www.pypy.org/

[2] https://cython.org/

[3] https://numba.pydata.org/

[4] https://github.com/pyston/pyston

Profile and optimize the hotspots with cython (or whatever the cool kids are using these days... It's been a while.)

JIT essentially means generating machine code for the language on the fly, either during loading of the interpreter (method JIT), or by profiling and optimizing hotspots (tracing JIT). The language itself can be statically or dynamically typed. You could also compile a dynamic language ahead of time, for example, cython.

Cython - - embed demo

Falcon FastAPI Sanic Starlite (disclosure: I do work here)

Sanic is very very popular with 16.6k stars, 1.5k forks, opencollective sponsors and a very active github. Falcon is more popular than japronto with 8.9k stars, 898 forks, opencollective sponsors and a very active github too. Despite Japronto been keeped as first place by TechEmPower, Falcon is a way better solution in general with performance similar to fastify an very fast node.js framework that hits 575k requests per second in this benchmark.

I prefer Falcon for kicking up an API.

Falcon

And here's a project that's mostly Python, and optionally uses Cython https://github.com/falconry/falcon

To help with the above two cases I would consider using a microframework, and the Python community provides many solutions. In my professional career I’ve had the opportunity to work with three very good alternatives to Django: Flask, Falcon, and Fast API. Flask is designed to be easy to use and extend. It follows the principles of minimalism and gives more control over the app. Choosing it, developers can use multiple types of databases, which is not easy to do in Django. We can also plug in our favorite ORM and use it without any risk of unpredictable app behavior. In contrast to Django, it’s easy to integrate NoSQL databases with Flask.

This may not be exactly what you asked for but I found contributing to open source projects really exposed me to different approaches I never would have considered and may not have fully grasped had I not had to actually dive into the code to solve an issue. Falcon is a great place to start and the guys are super friendly there.

https://falcon.readthedocs.io/en/stable/ https://fastapi.tiangolo.com/