Merge pull request #35 from python-hyper/huffman-table

Improve Huffman decoding speed using table-based implementation.

Author: Lukasa

HISTORY.rst

@@ -1,6 +1,13 @@
 Release History
 ===============
 
+dev (XXXX)
+----------
+
+**Bugfixes**
+
+- Improve Huffman decoding speed by 4x using an approach borrowed from nghttp2.
+
 2.1.1 (2016-03-16)
 ------------------
 

hpack/hpack.py

@@ -10,10 +10,11 @@
 from .table import HeaderTable
 from .compat import to_byte, to_bytes
 from .exceptions import HPACKDecodingError
-from .huffman import HuffmanDecoder, HuffmanEncoder
+from .huffman import HuffmanEncoder
 from .huffman_constants import (
     REQUEST_CODES, REQUEST_CODES_LENGTH
 )
+from .huffman_table import decode_huffman
 
 log = logging.getLogger(__name__)
 
@@ -322,9 +323,6 @@ class Decoder(object):
 
     def __init__(self):
         self.header_table = HeaderTable()
-        self.huffman_coder = HuffmanDecoder(
-            REQUEST_CODES, REQUEST_CODES_LENGTH
-        )
 
     @property
     def header_table_size(self):
@@ -461,7 +459,7 @@ def _decode_literal(self, data, should_index):
             name = data[consumed:consumed + length]
 
             if to_byte(data[0]) & 0x80:
-                name = self.huffman_coder.decode(name)
+                name = decode_huffman(name)
             total_consumed = consumed + length + 1  # Since we moved forward 1.
 
         data = data[consumed + length:]
@@ -471,7 +469,7 @@ def _decode_literal(self, data, should_index):
         value = data[consumed:consumed + length]
 
         if to_byte(data[0]) & 0x80:
-            value = self.huffman_coder.decode(value)
+            value = decode_huffman(value)
 
         # Updated the total consumed length.
         total_consumed += length + consumed

hpack/huffman.py

@@ -7,78 +7,6 @@
 Huffman-coded content where we already know the Huffman table.
 """
 from .compat import to_byte, decode_hex
-from .exceptions import HPACKDecodingError
-
-
-def _pad_binary(bin_str, req_len=8):
-    """
-    Given a binary string (returned by bin()), pad it to a full byte length.
-    """
-    bin_str = bin_str[2:]  # Strip the 0b prefix
-    return max(0, req_len - len(bin_str)) * '0' + bin_str
-
-
-def _hex_to_bin_str(hex_string):
-    """
-    Given a Python bytestring, returns a string representing those bytes in
-    unicode form.
-    """
-    unpadded_bin_string_list = (bin(to_byte(c)) for c in hex_string)
-    padded_bin_string_list = map(_pad_binary, unpadded_bin_string_list)
-    bitwise_message = "".join(padded_bin_string_list)
-    return bitwise_message
-
-
-class HuffmanDecoder(object):
-    """
-    Decodes a Huffman-coded bytestream according to the Huffman table laid out
-    in the HPACK specification.
-    """
-    class _Node(object):
-        def __init__(self, data):
-            self.data = data
-            self.mapping = {}
-
-    def __init__(self, huffman_code_list, huffman_code_list_lengths):
-        self.root = self._Node(None)
-        for index, (huffman_code, code_length) in enumerate(zip(huffman_code_list, huffman_code_list_lengths)):
-            self._insert(huffman_code, code_length, index)
-
-    def _insert(self, hex_number, hex_length, letter):
-        """
-        Inserts a Huffman code point into the tree.
-        """
-        hex_number = _pad_binary(bin(hex_number), hex_length)
-        cur_node = self.root
-        for digit in hex_number:
-            if digit not in cur_node.mapping:
-                cur_node.mapping[digit] = self._Node(None)
-            cur_node = cur_node.mapping[digit]
-        cur_node.data = letter
-
-    def decode(self, encoded_string):
-        """
-        Decode the given Huffman coded string.
-        """
-        number = _hex_to_bin_str(encoded_string)
-        cur_node = self.root
-        decoded_message = bytearray()
-
-        try:
-            for digit in number:
-                cur_node = cur_node.mapping[digit]
-                if cur_node.data is not None:
-                    # If we get EOS, everything else is padding.
-                    if cur_node.data == 256:
-                        break
-
-                    decoded_message.append(cur_node.data)
-                    cur_node = self.root
-        except KeyError:
-            # We have a Huffman-coded string that doesn't match our trie. This
-            # is pretty bad: raise a useful exception.
-            raise HPACKDecodingError("Invalid Huffman-coded string received.")
-        return bytes(decoded_message)
 
 
 class HuffmanEncoder(object):