erequests 0.4.0 released!

A new version of ERequests, the library that makes it easy to use Requests and Eventlet has just been released!

The API has been overhauled in order to provide 2 different ways of doing things:

  • A synchronous API, which will spawn a green thread and wait for it for every request sent this way
  • An asynchronous API, which just prepares the requests, allowing the user to throttle them with map or imap

Another important improvement is that when sending requests with map/imap, if one of them fails with an error, the exception object is returned, instead of raising it and stopping the process in the middle.

Here is an example script showing both APIs:

Last but not least, I’d like to thank Juan Riaza for his help in designing the API and adapting the tests. πŸ™‚

You can install erequests easily from PyPI:

Enjoy!

:wq

Tulip/asyncio at PyConES

It has been an intense weekend. I’ve been in Madrid for PyConES, and all I have to say is that it was amazing! Lots of great talks, old friends and new ones, I had a blast!

I gave a presentation on Tulip/asyncio in Spanish, but since code kind of speaks for itself, you may find some value in my slides here:


This is a hot topic these days, and proof of that is the fact that mine wasn’t the only Tulip/asyncio talk at PyConES. I had the pleasure to work with IΓ±aki Galarza, who also gave a presentation about Tulip so that our talks would complement each other’s. You can find his slides here:

I really hope I can make it next year, and you should too!

:wq

 

Fibers 0.2.0 released, now with PyPy support!

Hi there!

I just released python-fibers 0.2.0, which includes PyPy support! For those of you who may not know, here it what fibers are all about:

Fibers are lightweight primitives for cooperative multitasking in Python. They provide means for running pieces of code that can be paused and resumed. Unlike threads, which are preemptively scheduled, fibers are scheduled cooperatively, that is, only one fiber will be running at a given point in time, and no other fiber will run until the user explicitly decides so.

The funny thing here is that the implementation of fibers uses code (stacklet, more precisely) borrowed from PyPy, but the first version of fibers only supported CPython. On this version, a PyPy compatible version is provided, using the _continuation module. For reference, the greenlet and stackless implementations in PyPy are done using this module. It has been tested with PyPy 2.1, but let me know if you run into any issues!

You can grab it at your nearest cheese shop, get it while it’s hot!

:wq

Evergreen 0.2.0 released!

I’m very happy to announce I just released evergreen 0.2.0! From the API standpoint, not many things changed, but a number of important internal changes happened, including a change in how callbacks are scheduled in the event loop, which fixed a nasty issue inΒ Windows.

For those who may not know:

Evergreen is a cooperative multitasking and i/o library for Python. It provides equivalent primitives to those for thread programming, but uses a cooperative model instead.

Operations are driven by an event loop which will run the given tasks and i/o operations in a non-blocking manner while presenting the user a synchronous, blocking API.

Here is the full changelog:

Β – Revert “Don’t allow futures to be used more than once”
Β – Break potential cycle because we are storing the traceback
Β – Fixed passing traceback when propagating exception to MAIN parent
Β – Process all callbacks using an Idle handle
Β – Replaced use of Future in io module for Result
Β – Don’t wait for send operation to complete in UDPEndpoint
Β – Always run tests from the right directory
Β – Fix UDP test case on Windows
Β – Added flush() method to UDPEndpoint and Stream objects
Β – Cache sockname and peername properties
The code can be downloaded from GitHub, as usual. Hope you like it!
:wq

uvwsgi: a Python WSGI server

I’ve been playing with Flask and WSGI in general for a few nights… at some point I started playing with pyuv and http-parser and before I realized I had a really basic WSGI server to play with: uvwsgi.

It’s not meant for production usage (yet) but should be really simple to understand, it’s less than 400 lines of code!

Here is a list of things I’d like to implement, in no particular order:

  • Multi-process support using socket sharing
  • Multi-process support using a single acceptor and a pool of worked which get connections dispatched round-robin
  • Update http-parser to the latest and greatest version
  • Automatically restart server if modules changed
  • Tests

You can install it from the cheese shop or get the code on GitHub.

Patches are welcome, of course πŸ™‚

:wq

 

fibers: lightweight cooperative microthreads for Python

Hi all!

Today I’m really happy to share the first version of fibers, a project I’ve working on for a while.

Fibers are lightweight primitives for cooperative multitasking in Python. They provide means for running pieces of code that can be paused and resumed. Unlike threads, which are preemptively scheduled, fibers are scheduled cooperatively, that is, only one fiber will be running at a given point in time, and no other fiber will run until the user explicitly decides so.

When a fiber is created it will not run automatically. A fiber must be ‘switched’ into for it to run. Fibers can switch control to other fibers by way of the switch or throw functions, which switch control or raise and exception in the target fiber respectively.

 

This project is heavily inspired by greenlet, as you may have noticed.Β I’ve been using greenlet for a long while, but for a recent project I’ve worked on, I wanted to offer an interface similar to the Thread class from the threading module. Unfortunately the API in greenlet didn’t make it easy, so I took it as an excuse to try to build the library I wanted to use, which hopefully also helps others.

The obvious step would have been to fork greenlet itself and change the API to my needs, but I randomly ran into stacklet, a tiny library hidden in the PyPy source code, which is used as the base for the greenlet implementation in PyPy.

So, I stood on shoulders of giants and built fibers using stacklet. It solves my problems, hopefully it can help you too! In case you are interested in a more verbose version of the project rationale, I added a specific section in the documentation.

The source code is available on GitHub, with MIT license, enjoy!

:wq

pyuv 0.10.5 (stable) and 0.11.0 (unstable) released!

I’m happy to announce two new pyuv releases today: pyuv 0.10.5 (stable) and 0.11.0 (unstable). Why two releases? For those who may not know, pyuv follows the NodeJS release cycle, that is, odd numbered releases are the so called “unstable” releases, while the even numbered releases are “stable”.

The 0.10.5 release brings Β few bugfixes and embeds the latest version of libuv, so you also benefit from the bugfixes in libuv.

pyuv 0.11.0 includes some heavy refactoring of the filesystem operations, which unfortunately are not backwards compatible, but I hope it’s for the best:

In pyuv 0.10x this is the way to stat a file asynchronously:

And here is the equivalent in pyuv 0.11:

All filesystem operations now get a single argument in the callback: the FSRequest object which was returned to the caller when the function was initially called. The loop, path, result and error are now attributes of the request object. Moreover, the request object now has an instance dictionary, so you can attach any attribute to it and use it later:

There have been other big internal changes due to changes in libuv itself, but those are not visible in pyuv since it provides a class-level abstraction.

The next stable release will be pyuv 0.12.0, right when Node 0.12 is launched. Until then 0.10 will remain as the stable branch, and the one installable through PyPI, those of you interested in the latest and the greatest, go fetch master on GitHub πŸ™‚

:wq

 

Serving a WSGI app, WebSockets and static files with Twisted

Long time no post! Lets solve that now shall we?

A few days ago I started playing a bit with Flask, since I’m considering it as the framework to build some API server. I have no web development experience, and Flask looks like a great project so I went with that.

I started with a tiny little hello world, and then I wanted to add some websockets and some CSS. Oh the trouble. When I started looking for how to combine a Flask app with WebSockets I found references to gevent-socketio for the most part, but I somewhat wanted to use Twisted this time, so I kept looking. Soon enough I found AutoBahn, a great WebSocket implementation for Twisted, which can be combined with a WSGI app, brilliant! After seeing how AutoBahn manages to add the websocket route to the WSGI app, adding support for static files was kind of trivial.

Here is the result of my experiments, a really simple web app which consists of a Flask WSGI app, a WebSocket server and some static files, all served by the same process running Twisted. You may not want to do this in a production environment, but hey, I’m just playing here πŸ™‚

Since Gist does not currently allow folders, make sure you keep this layout after downloading the files:

We’ll use the twistd command line tool to launch out application, since it can take care of logging, running as a daemon, etc. To run it in the foreground:

twistd -n -l - -y app.py

This will launch the application in non-daemon mode and log to standard output.

Hope this helps someone, all feedback is more than welcome πŸ™‚

:wq