python-h11 - A pure-Python, bring-your-own-I/O implementation of HTTP/1.1

Property Value
Distribution ROSA 2016.1
Repository ROSA Contrib Updates x86_64
Package filename python-h11-0.8.1-1-rosa2016.1.noarch.rpm
Package name python-h11
Package version 0.8.1
Package release 1-rosa2016.1
Package architecture noarch
Package type rpm
Category Development/Python
License MIT
Maintainer -
Download size 53.24 KB
Installed size 172.11 KB
.. image::
:alt: Automated test status
.. image::
:alt: Test coverage
.. image::
:alt: Documentation Status
This is a little HTTP/1.1 library written from scratch in Python,
heavily inspired by `hyper-h2 <>`_.
It's a "bring-your-own-I/O" library; h11 contains no IO code
whatsoever. This means you can hook h11 up to your favorite network
API, and that could be anything you want: synchronous, threaded,
asynchronous, or your own implementation of `RFC 6214
<>`_ -- h11 won't judge you.
(Compare this to the current state of the art, where every time a `new
network API <>`_ comes along then someone
gets to start over reimplementing the entire HTTP protocol from
scratch.) Cory Benfield made an `excellent blog post describing the
benefits of this approach
<>`_, or if you like video
then here's his `PyCon 2016 talk on the same theme
This also means that h11 is not immediately useful out of the box:
it's a toolkit for building programs that speak HTTP, not something
that could directly replace ``requests`` or ``twisted.web`` or
whatever. But h11 makes it much easier to implement something like
``requests`` or ``twisted.web``.
At a high level, working with h11 goes like this:
1) First, create an ``h11.Connection`` object to track the state of a
single HTTP/1.1 connection.
2) When you read data off the network, pass it to
``conn.receive_data(...)``; you'll get back a list of objects
representing high-level HTTP "events".
3) When you want to send a high-level HTTP event, create the
corresponding "event" object and pass it to ``conn.send(...)``;
this will give you back some bytes that you can then push out
through the network.
For example, a client might instantiate and then send a
``h11.Request`` object, then zero or more ``h11.Data`` objects for the
request body (e.g., if this is a POST), and then a
``h11.EndOfMessage`` to indicate the end of the message. Then the
server would then send back a ``h11.Response``, some ``h11.Data``, and
its own ``h11.EndOfMessage``. If either side violates the protocol,
you'll get a ``h11.ProtocolError`` exception.
h11 is suitable for implementing both servers and clients, and has a
pleasantly symmetric API: the events you send as a client are exactly
the ones that you receive as a server and vice-versa.
`Here's an example of a tiny HTTP client
It also has `a fine manual <>`_.
I wanted to play with HTTP in `Curio
<>`__ and `Trio
<>`__, which at the time didn't have any
HTTP libraries. So I thought, no big deal, Python has, like, a dozen
different implementations of HTTP, surely I can find one that's
reusable. I didn't find one, but I did find Cory's call-to-arms
blog-post. So I figured, well, fine, if I have to implement HTTP from
scratch, at least I can make sure no-one *else* has to ever again.
*Should I use it?*
Maybe. You should be aware that it's a very young project. But, it's
feature complete and has an exhaustive test-suite and complete docs,
so the next step is for people to try using it and see how it goes
:-). If you do then please let us know -- if nothing else we'll want
to talk to you before making any incompatible changes!
*What are the features/limitations?*
Roughly speaking, it's trying to be a robust, complete, and non-hacky
implementation of the first "chapter" of the HTTP/1.1 spec: `RFC 7230:
HTTP/1.1 Message Syntax and Routing
<>`_. That is, it mostly focuses on
implementing HTTP at the level of taking bytes on and off the wire,
and the headers related to that, and tries to be anal about spec
conformance. It doesn't know about higher-level concerns like URL
routing, conditional GETs, cross-origin cookie policies, or content
negotiation. But it does know how to take care of framing,
cross-version differences in keep-alive handling, and the "obsolete
line folding" rule, so you can focus your energies on the hard /
interesting parts for your application, and it tries to support the
full specification in the sense that any useful HTTP/1.1 conformant
application should be able to use h11.
It's pure Python, and has no dependencies outside of the standard
It has a test suite with 100.0% coverage for both statements and
Currently it supports Python 3 (testing on 3.3-3.6), Python 2.7, and PyPy.
(Originally it had a Cython wrapper for `http-parser
<>`_ and a beautiful nested state
machine implemented with ``yield from`` to postprocess the output. But
I had to take these out -- the new *parser* needs fewer lines-of-code
than the old *parser wrapper*, is written in pure Python, uses no
exotic language syntax, and has more features. It's sad, really; that
old state machine was really slick. I just need a few sentences here
to mourn that.)
I don't know how fast it is. I haven't benchmarked or profiled it yet,
so it's probably got a few pointless hot spots, and I've been trying
to err on the side of simplicity and robustness instead of
micro-optimization. But at the architectural level I tried hard to
avoid fundamentally bad decisions, e.g., I believe that all the
parsing algorithms remain linear-time even in the face of pathological
input like slowloris, and there are no byte-by-byte loops. (I also
believe that it maintains bounded memory usage in the face of
arbitrary/pathological input.)
The whole library is ~800 lines-of-code. You can read and understand
the whole thing in less than an hour. Most of the energy invested in
this so far has been spent on trying to keep things simple by
minimizing special-cases and ad hoc state manipulation; even though it
is now quite small and simple, I'm still annoyed that I haven't
figured out how to make it even smaller and simpler. (Unfortunately,
HTTP does not lend itself to simplicity.)
The API is ~feature complete and I don't expect the general outlines
to change much, but you can't judge an API's ergonomics until you
actually document and use it, so I'd expect some changes in the
*How do I try it?*
.. code-block:: sh
$ pip install h11
$ git clone
$ cd h11/examples
$ python
and go from there.
*Code of conduct?*
Contributors are requested to follow our `code of conduct
<>`_ in
all project spaces.


Package Version Architecture Repository
python-h11-0.8.1-1-rosa2016.1.noarch.rpm 0.8.1 noarch ROSA Contrib Updates
python-h11 - - -


Name Value
python(abi) == 2.7


Name Value
python-h11 == 0.8.1-1:2016.1
pythonegg(h11) == 0.8.1


Type URL
Binary Package python-h11-0.8.1-1-rosa2016.1.noarch.rpm
Source Package python-h11-0.8.1-1.src.rpm

Install Howto

  1. Enable ROSA Contrib Updates repository on Install and Remove Software
  2. Update packages list:
    # urpmi.update -a
  3. Install python-h11 rpm package:
    # urpmi python-h11




2018-09-06 - Rosa <> 0.8.1-1
- (92962fe) Automatic import for version 0.8.1-1

See Also

Package Description
python-h2-3.0.1-1-rosa2016.1.noarch.rpm HTTP/2 State-Machine based protocol implementation
python-hacking-1.1.0-1-rosa2016.1.noarch.rpm OpenStack Hacking Guideline Enforcement
python-hidapi-0.7.99-1-rosa2016.1.x86_64.rpm A Cython interface to the hidapi
python-hpack-3.0.0-1-rosa2016.1.noarch.rpm Pure-Python HPACK header compression
python-hpilo-4.3-1-rosa2016.1.noarch.rpm ILO automation from python or shell
python-html5-parser-0.4.4-1-rosa2016.1.x86_64.rpm Fast C based HTML 5 parsing for python
python-hyperframe-5.1.0-1-rosa2016.1.noarch.rpm HTTP/2 framing layer for Python
python-imdb-5.1.1-1-rosa2016.1.x86_64.rpm Python module for the IMDb movie database
python-img2pdf-0.2.3-1-rosa2016.1.noarch.rpm Convert images to PDF via direct JPEG inclusion
python-inflect-0.2.5-1-rosa2016.1.noarch.rpm Does lots of grammar things
python-ipdb-0.10.3-1-rosa2016.1.noarch.rpm IPython-enabled pdb
python-ipdns-0.1.4-1-rosa2016.1.noarch.rpm Stateless dns server serving ip addresses based on parsing the domain
python-iptables-0.12.0-1-rosa2016.1.x86_64.rpm Python bindings for iptables
python-ipwhois-1.0.0-1-rosa2016.1.noarch.rpm Retrieve and parse whois data for IPv4 and IPv6 addresses
python-ipywidgets-7.0.0-1-rosa2016.1.noarch.rpm IPython HTML widgets for Jupyter