fafhrd91

Python extension doesn’t mean C. Rust works perfectly for extensions, it covers a lot of low level c-api integration and it is fast. You can write whole application in rust and use python as a glue language

https://github.com/PyO3/pyo3

Pyo3 library gives you ability to work both diractions. Call python code from rust and call rust code from python.

Good client library https://github.com/seanmonstar/reqwest Could be used as async or as sync.

Http/2 client and server https://github.com/carllerche/h2

Web framework https://github.com/actix/actix-web

All of them has good quality and performance

There is PyO3 library

https://github.com/PyO3/pyo3

I am building async web framework with http/2 and websockets support. I think rust is great! You can write high level code, but if you need to you can always access low level system

https://github.com/actix/actix-web

Pyo3 support both. You can expose rust to python, and would look to python as native functions and classes or you can call python code from rust

Pyo3 uses rust refs ownership to enforce proper Gil usage. You code won’t compile if you use Gil in wrong way

Sure, coupes is fine if do not need to write anything and ctypes is enough. But as soon as you need to make c to python bridge it safer to do in rust. Pyo3 handles ref counting and Gil management for you

why not rust? much simpler and safer with libs like https://github.com/PyO3/pyo3

you have two options: PyObject and Py<PyList>. Both has Send + Sync and all pyo3 types defines `std::convert::From<T>` for both.

not really. it is an alternative to C and cython for extension development.

this binding can be used both ways. check first example in readme. and https://github.com/PyO3/pyo3/blob/master/src/python.rs#L203

I also wrote asyncio event loop, based on tokio-rs, using this binding. So it is possible to write complex python extensions in Rust.

https://github.com/PyO3/tokio

sorry about not waiting longer. I didn't want to fork.

as for leaking refs, it maybe be fixed by introducing nested "Pool" objects. objective-c runtime has similar concepts and same problem with long running loops.

PyO3 is close to first release.

what is good about asyncio, it allows to replace default event loop. I am working on asyncio event loop based on tokio-rs (rust). it could bridge asyncio with code written in rust. so potentially, it should be possible to mix python and rust code on higher level than just simple c-extension.

https://github.com/PyO3

check Sanic code, it loads whole incoming payload into memory before processing it. event for 404, so I can write very simple script that would consume all memory. and you can not really protect sanic service with proxy (nginx)

problem with Sanic that it does not implement streaming properly. so it is very easy to kill any Sanic process, 10-20 seconds. again any.

it becomes more interesting when you start read streaming server request and then pipe into streaming client request.

`yield from` and asyncio makes everything much more simple.

Potentially it is slower than tulip, It does magic stack slicing. also it works only on X86 cpu.