Rename 'hyper-h2' to simply 'h2' (#1246)

Author: sethmlarson

CHANGELOG.rst

@@ -4,6 +4,9 @@ Release History
 dev
 ---
 
+**Note:** The GitHub repository has been renamed to ``python-hyper/h2``, previously
+was ``python-hyper/hyper-h2``. **The name of the package on PyPI is unchanged**
+
 **API Changes (Backward Incompatible)**
 
 -

README.rst

@@ -1,15 +1,15 @@
-===============================
-hyper-h2: HTTP/2 Protocol Stack
-===============================
+=========================
+h2: HTTP/2 Protocol Stack
+=========================
 
-.. image:: https://github.com/python-hyper/hyper-h2/workflows/CI/badge.svg
-    :target: https://github.com/python-hyper/hyper-h2/actions
+.. image:: https://github.com/python-hyper/h2/workflows/CI/badge.svg
+    :target: https://github.com/python-hyper/h2/actions
     :alt: Build Status
-.. image:: https://codecov.io/gh/python-hyper/hyper-h2/branch/master/graph/badge.svg
-    :target: https://codecov.io/gh/python-hyper/hyper-h2
+.. image:: https://codecov.io/gh/python-hyper/h2/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/python-hyper/h2
     :alt: Code Coverage
-.. image:: https://readthedocs.org/projects/hyper-h2/badge/?version=latest
-    :target: https://hyper-h2.readthedocs.io/en/latest/
+.. image:: https://readthedocs.org/projects/h2/badge/?version=latest
+    :target: https://h2.readthedocs.io
     :alt: Documentation Status
 .. image:: https://img.shields.io/badge/chat-join_now-brightgreen.svg
     :target: https://gitter.im/python-hyper/community
@@ -45,17 +45,17 @@ To install it, just run:
 
 .. code-block:: console
 
-    $ pip install h2
+    $ python -m pip install h2
 
 Documentation
 =============
 
-Documentation is available at https://hyper-h2.readthedocs.io/ .
+Documentation is available at https://h2.readthedocs.io .
 
 Contributing
 ============
 
-``hyper-h2`` welcomes contributions from anyone! Unlike many other projects we
+``h2`` welcomes contributions from anyone! Unlike many other projects we
 are happy to accept cosmetic contributions and small contributions, in addition
 to large feature requests and changes.
 
@@ -67,10 +67,11 @@ please `read the contribution guidelines`_.
 License
 =======
 
-``hyper-h2`` is made available under the MIT License. For more details, see the
+``h2`` is made available under the MIT License. For more details, see the
 ``LICENSE`` file in the repository.
 
 Authors
 =======
 
-``hyper-h2`` is maintained by Cory Benfield, with contributions from others.
+``h2`` was authored by Cory Benfield and is maintained
+by the members of `python-hyper <https://github.com/orgs/python-hyper/people>`_.

docs/source/advanced-usage.rst

@@ -10,7 +10,7 @@ Priority
 build a HTTP/2 priority tree, and the effect that should have on sending data
 from a server.
 
-Hyper-h2 does not enforce any priority logic by default for servers. This is
+h2 does not enforce any priority logic by default for servers. This is
 because scheduling data sends is outside the scope of this library, as it
 likely requires fairly substantial understanding of the scheduler being used.
 
@@ -26,7 +26,7 @@ Related Events
 
 .. versionadded:: 2.4.0
 
-In the 2.4.0 release hyper-h2 added support for signaling "related events".
+In the 2.4.0 release h2 added support for signaling "related events".
 These are a HTTP/2-only construct that exist because certain HTTP/2 events can
 occur simultaneously: that is, one HTTP/2 frame can cause multiple state
 transitions to occur at the same time. One example of this is a HEADERS frame
@@ -35,17 +35,17 @@ cause three events to fire (one of the various request/response received
 events, a :class:`PriorityUpdated <h2.events.PriorityUpdated>` event, and a
 :class:`StreamEnded <h2.events.StreamEnded>` event).
 
-Ordinarily hyper-h2's logic will emit those events to you one at a time. This
+Ordinarily h2's logic will emit those events to you one at a time. This
 means that you may attempt to process, for example, a
 :class:`DataReceived <h2.events.DataReceived>` event, not knowing that the next
 event out will be a :class:`StreamEnded <h2.events.StreamEnded>` event.
-hyper-h2 *does* know this, however, and so will forbid you from taking certain
+h2 *does* know this, however, and so will forbid you from taking certain
 actions that are a violation of the HTTP/2 protocol.
 
 To avoid this asymmetry of information, events that can occur simultaneously
 now carry properties for their "related events". These allow users to find the
 events that can have occurred simultaneously with each other before the event
-is emitted by hyper-h2. The following objects have "related events":
+is emitted by h2. The following objects have "related events":
 
 - :class:`RequestReceived <h2.events.RequestReceived>`:
 
@@ -96,7 +96,7 @@ is emitted by hyper-h2. The following objects have "related events":
       same time as receiving this data.
 
 
-.. warning:: hyper-h2 does not know if you are looking for related events or
+.. warning:: h2 does not know if you are looking for related events or
              expecting to find events in the event stream. Therefore, it will
              always emit "related events" in the event stream. If you are using
              the "related events" event pattern, you will want to be careful to
@@ -167,19 +167,19 @@ When To Send
 ~~~~~~~~~~~~
 
 In addition to knowing how much data to send (see :ref:`advanced-sending-data`)
-it is important to know when to send data. For hyper-h2, this amounts to
+it is important to know when to send data. For h2, this amounts to
 knowing when to call :meth:`data_to_send
 <h2.connection.H2Connection.data_to_send>`.
 
-Hyper-h2 may write data into its send buffer at two times. The first is
+h2 may write data into its send buffer at two times. The first is
 whenever :meth:`receive_data <h2.connection.H2Connection.receive_data>` is
 called. This data is sent in response to some control frames that require no
 user input: for example, responding to PING frames. The second time is in
 response to user action: whenever a user calls a method like
 :meth:`send_headers <h2.connection.H2Connection.send_headers>`, data may be
 written into the buffer.
 
-In a standard design for a hyper-h2 consumer, then, that means there are two
+In a standard design for a h2 consumer, then, that means there are two
 places where you'll potentially want to send data. The first is in your
 "receive data" loop. This is where you take the data you receive, pass it into
 :meth:`receive_data <h2.connection.H2Connection.receive_data>`, and then
@@ -240,16 +240,16 @@ Working With Flow Control
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The amount of flow control window a ``DATA`` frame consumes is the sum of both
-its contained application data *and* the amount of padding used. hyper-h2 shows
+its contained application data *and* the amount of padding used. h2 shows
 this to the user in a :class:`DataReceived <h2.events.DataReceived>` event by
 using the :data:`flow_controlled_length
 <h2.events.DataReceived.flow_controlled_length>` field. When working with flow
-control in hyper-h2, users *must* use this field: simply using
+control in h2, users *must* use this field: simply using
 ``len(datareceived.data)`` can eventually lead to deadlock.
 
 When data has been received and given to the user in a :class:`DataReceived
 <h2.events.DataReceived>`, it is the responsibility of the user to re-open the
-flow control window when the user is ready for more data. hyper-h2 does not do
+flow control window when the user is ready for more data. h2 does not do
 this automatically to avoid flooding the user with data: if we did, the remote
 peer could send unbounded amounts of data that the user would need to buffer
 before processing.
@@ -258,7 +258,7 @@ To re-open the flow control window, then, the user must call
 :meth:`increment_flow_control_window
 <h2.connection.H2Connection.increment_flow_control_window>` with the
 :data:`flow_controlled_length <h2.events.DataReceived.flow_controlled_length>`
-of the received data. hyper-h2 requires that you manage both the connection
+of the received data. h2 requires that you manage both the connection
 and the stream flow control windows separately, so you may need to increment
 both the stream the data was received on and stream ``0``.
 
@@ -269,10 +269,10 @@ flow control windows. You can find out how much data you can send on a given
 stream by using the :meth:`local_flow_control_window
 <h2.connection.H2Connection.local_flow_control_window>` method, which will do
 all of these calculations for you. If you attempt to send more than this amount
-of data on a stream, hyper-h2 will throw a :class:`ProtocolError
+of data on a stream, h2 will throw a :class:`ProtocolError
 <h2.exceptions.ProtocolError>` and refuse to send the data.
 
-In hyper-h2, receiving a ``WINDOW_UPDATE`` frame causes a :class:`WindowUpdated
+In h2, receiving a ``WINDOW_UPDATE`` frame causes a :class:`WindowUpdated
 <h2.events.WindowUpdated>` event to fire. This will notify you that there is
 potentially more room in a flow control window. Note that, just because an
 increment of a given size was received *does not* mean that that much more data
@@ -301,7 +301,7 @@ control strategies. While particular high performance or specific-use-case
 applications may gain value from directly controlling the emission of
 ``WINDOW_UPDATE`` frames, the average application can use a
 lowest-common-denominator strategy to emit those frames. As of version 2.5.0,
-hyper-h2 now provides this automatic strategy for users, if they want to use
+h2 now provides this automatic strategy for users, if they want to use
 it.
 
 This automatic strategy is built around a single method:

docs/source/api.rst

@@ -1,15 +1,15 @@
-Hyper-h2 API
-============
+h2 API
+======
 
-This document details the API of Hyper-h2.
+This document details the API of h2.
 
 Semantic Versioning
 -------------------
 
-Hyper-h2 follows semantic versioning for its public API. Please note that the
+h2 follows semantic versioning for its public API. Please note that the
 guarantees of semantic versioning apply only to the API that is *documented
 here*. Simply because a method or data field is not prefaced by an underscore
-does not make it part of Hyper-h2's public API. Anything not documented here is
+does not make it part of h2's public API. Anything not documented here is
 subject to change at any time.
 
 Connection

docs/source/basic-usage.rst

@@ -2,7 +2,7 @@ Getting Started: Writing Your Own HTTP/2 Server
 ===============================================
 
 This document explains how to get started writing fully-fledged HTTP/2
-implementations using Hyper-h2 as the underlying protocol stack. It covers the
+implementations using h2 as the underlying protocol stack. It covers the
 basic concepts you need to understand, and talks you through writing a very
 simple HTTP/2 server.
 
@@ -17,10 +17,10 @@ return to this documentation.
 Connections
 -----------
 
-Hyper-h2's core object is the
+h2's core object is the
 :class:`H2Connection <h2.connection.H2Connection>` object. This object is an
 abstract representation of the state of a single HTTP/2 connection, and holds
-all the important protocol state. When using Hyper-h2, this object will be the
+all the important protocol state. When using h2, this object will be the
 first thing you create and the object that does most of the heavy lifting.
 
 The interface to this object is relatively simple. For sending data, you
@@ -54,7 +54,7 @@ this document, we'll do just that.
 
 Some important subtleties of ``H2Connection`` objects are covered in
 :doc:`advanced-usage`: see :ref:`h2-connection-advanced` for more information.
-However, one subtlety should be covered, and that is this: Hyper-h2's
+However, one subtlety should be covered, and that is this: h2's
 ``H2Connection`` object doesn't do I/O. Let's talk briefly about why.
 
 I/O
@@ -74,19 +74,19 @@ into bytes to send. So there's no reason to have lots of different versions of
 this core protocol code: one for Twisted, one for gevent, one for threading,
 and one for synchronous code.
 
-This is why we said at the top that Hyper-h2 is a *HTTP/2 Protocol Stack*, not
-a *fully-fledged implementation*. Hyper-h2 knows how to transform bytes into
+This is why we said at the top that h2 is a *HTTP/2 Protocol Stack*, not
+a *fully-fledged implementation*. h2 knows how to transform bytes into
 events and back, but that's it. The I/O and smarts might be different, but
-the core HTTP/2 logic is the same: that's what Hyper-h2 provides.
+the core HTTP/2 logic is the same: that's what h2 provides.
 
-Not doing I/O makes Hyper-h2 general, and also relatively simple. It has an
+Not doing I/O makes h2 general, and also relatively simple. It has an
 easy-to-understand performance envelope, it's easy to test (and as a result
 easy to get correct behaviour out of), and it behaves in a reproducible way.
 These are all great traits to have in a library that is doing something quite
 complex.
 
 This document will talk you through how to build a relatively simple HTTP/2
-implementation using Hyper-h2, to give you an understanding of where it fits in
+implementation using h2, to give you an understanding of where it fits in
 your software.
 
 
@@ -99,7 +99,7 @@ When writing a HTTP/2 implementation it's important to know what the remote
 peer is doing: if you didn't care, writing networked programs would be a lot
 easier!
 
-Hyper-h2 encodes the actions of the remote peer in the form of *events*. When
+h2 encodes the actions of the remote peer in the form of *events*. When
 you receive data from the remote peer and pass it into your ``H2Connection``
 object (see :ref:`h2-connection-basic`), the ``H2Connection`` returns a list
 of objects, each one representing a single event that has occurred. Each
@@ -112,11 +112,11 @@ concept, not just a HTTP/2 one. Other events are extremely HTTP/2-specific:
 for example, :class:`PushedStreamReceived <h2.events.PushedStreamReceived>`
 refers to Server Push, a very HTTP/2-specific concept.
 
-The reason these events exist is that Hyper-h2 is intended to be very general.
-This means that, in many cases, Hyper-h2 does not know exactly what to do in
+The reason these events exist is that h2 is intended to be very general.
+This means that, in many cases, h2 does not know exactly what to do in
 response to an event. Your code will need to handle these events, and make
 decisions about what to do. That's the major role of any HTTP/2 implementation
-built on top of Hyper-h2.
+built on top of h2.
 
 A full list of events is available in :ref:`h2-events-api`. For the purposes
 of this example, we will handle only a small set of events.
@@ -129,15 +129,15 @@ Armed with the knowledge you just obtained, we're going to write a very simple
 HTTP/2 web server. The goal of this server is to write a server that can handle
 a HTTP GET, and that returns the headers sent by the client, encoded in JSON.
 Basically, something a lot like `httpbin.org/get`_. Nothing fancy, but this is
-a good way to get a handle on how you should interact with Hyper-h2.
+a good way to get a handle on how you should interact with h2.
 
 For the sake of simplicity, we're going to write this using the Python standard
 library, in Python 3. In reality, you'll probably want to use an asynchronous
 framework of some kind: see the `examples directory`_ in the repository for
 some examples of how you'd do that.
 
 Before we start, create a new file called ``h2server.py``: we'll use that as
-our workspace. Additionally, you should install Hyper-h2: follow the
+our workspace. Additionally, you should install h2: follow the
 instructions in :doc:`installation`.
 
 Step 1: Sockets
@@ -324,7 +324,7 @@ Let's do that next.
 Step 3: Sending the Preamble
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Hyper-h2 makes doing connection setup really easy. All you need to do is call
+h2 makes doing connection setup really easy. All you need to do is call
 the
 :meth:`initiate_connection <h2.connection.H2Connection.initiate_connection>`
 method, and then send the corresponding data. Let's update our ``handle``
@@ -348,7 +348,7 @@ new method in there:
 :meth:`data_to_send <h2.connection.H2Connection.data_to_send>`.
 
 When you make function calls on your ``H2Connection`` object, these will often
-want to cause HTTP/2 data to be written out to the network. But Hyper-h2
+want to cause HTTP/2 data to be written out to the network. But h2
 doesn't do any I/O, so it can't do that itself. Instead, it writes it to an
 internal buffer. You can retrieve data from this buffer using the
 ``data_to_send`` method. There are some subtleties about that method, but we
@@ -477,17 +477,17 @@ there: ``:status``. This is a HTTP/2-specific header, and it's used to hold the
 HTTP status code that used to go at the top of a HTTP response. Here, we're
 saying the response is ``200 OK``, which is successful.
 
-To send headers in Hyper-h2, you use the
+To send headers in h2, you use the
 :meth:`send_headers <h2.connection.H2Connection.send_headers>` function.
 
 Next, we want to send the body data. To do that, we use the
 :meth:`send_data <h2.connection.H2Connection.send_data>` function. This also
-takes a stream ID. Note that the data is binary: Hyper-h2 does not work with
+takes a stream ID. Note that the data is binary: h2 does not work with
 unicode strings, so you *must* pass bytestrings to the ``H2Connection``. The
-one exception is headers: Hyper-h2 will automatically encode those into UTF-8.
+one exception is headers: h2 will automatically encode those into UTF-8.
 
 The last thing to note is that on our call to ``send_data``, we set
-``end_stream`` to ``True``. This tells Hyper-h2 (and the remote peer) that
+``end_stream`` to ``True``. This tells h2 (and the remote peer) that
 we're done with sending data: the response is over. Because we know that
 ``hyper`` will have ended its side of the stream, when we end ours the stream
 will be totally done with.
@@ -703,7 +703,7 @@ see something like the following output from ``hyper``:
 Here you can see the HTTP/2 request 'special headers' that ``hyper`` sends.
 These are similar to the ``:status`` header we have to send on our response:
 they encode important parts of the HTTP request in a clearly-defined way. If
-you were writing a client stack using Hyper-h2, you'd need to make sure you
+you were writing a client stack using h2, you'd need to make sure you
 were sending those headers.
 
 Congratulations!
@@ -737,10 +737,10 @@ it, there are a few directions you could investigate:
 
 .. _event loop: https://en.wikipedia.org/wiki/Event_loop
 .. _httpbin.org/get: https://httpbin.org/get
-.. _examples directory: https://github.com/python-hyper/hyper-h2/tree/master/examples
-.. _standard library's socket module: https://docs.python.org/3.5/library/socket.html
+.. _examples directory: https://github.com/python-hyper/h2/tree/master/examples
+.. _standard library's socket module: https://docs.python.org/3/library/socket.html
 .. _Application Layer Protocol Negotiation: https://en.wikipedia.org/wiki/Application-Layer_Protocol_Negotiation
-.. _get your certificate here: https://raw.githubusercontent.com/python-hyper/hyper-h2/master/examples/twisted/server.crt
-.. _get your private key here: https://raw.githubusercontent.com/python-hyper/hyper-h2/master/examples/twisted/server.key
+.. _get your certificate here: https://raw.githubusercontent.com/python-hyper/h2/master/examples/twisted/server.crt
+.. _get your private key here: https://raw.githubusercontent.com/python-hyper/h2/master/examples/twisted/server.key
 .. _PyOpenSSL: http://pyopenssl.readthedocs.org/
-.. _Eventlet example: https://github.com/python-hyper/hyper-h2/blob/master/examples/eventlet/eventlet-server.py
+.. _Eventlet example: https://github.com/python-hyper/h2/blob/master/examples/eventlet/eventlet-server.py

docs/source/curio-example.rst

@@ -6,7 +6,7 @@ example of how to build a concurrent networking framework using Python 3.5's
 new ``async``/``await`` syntax.
 
 This example is notable for demonstrating the correct use of HTTP/2 flow
-control with Hyper-h2. It is also a good example of the brand new syntax.
+control with h2. It is also a good example of the brand new syntax.
 
 .. literalinclude:: ../../examples/curio/curio-server.py
    :language: python