Update idna to v2.5

HISTORY.rst

@@ -44,6 +44,7 @@ Release History
 
 - Updated bundled urllib3 to v1.21.1.
 - Updated bundled chardet to v3.0.2.
+- Updated bundled idna to v2.5.
 
 2.13.0 (2017-01-24)
 +++++++++++++++++++

requests/packages/idna/core.py

@@ -156,9 +156,9 @@ def valid_contextj(label, pos):
         ok = False
         for i in range(pos-1, -1, -1):
             joining_type = idnadata.joining_types.get(ord(label[i]))
-            if joining_type == 'T':
+            if joining_type == ord('T'):
                 continue
-            if joining_type in ['L', 'D']:
+            if joining_type in [ord('L'), ord('D')]:
                 ok = True
                 break
 
@@ -168,9 +168,9 @@ def valid_contextj(label, pos):
         ok = False
         for i in range(pos+1, len(label)):
             joining_type = idnadata.joining_types.get(ord(label[i]))
-            if joining_type == 'T':
+            if joining_type == ord('T'):
                 continue
-            if joining_type in ['R', 'D']:
+            if joining_type in [ord('R'), ord('D')]:
                 ok = True
                 break
         return ok
@@ -211,9 +211,9 @@ def valid_contexto(label, pos, exception=False):
         for cp in label:
             if cp == u'\u30fb':
                 continue
-            if not _is_script(cp, 'Hiragana') and not _is_script(cp, 'Katakana') and not _is_script(cp, 'Han'):
-                return False
-        return True
+            if _is_script(cp, 'Hiragana') or _is_script(cp, 'Katakana') or _is_script(cp, 'Han'):
+                return True
+        return False
 
     elif 0x660 <= cp_value <= 0x669:
         for cp in label:
@@ -261,12 +261,12 @@ def alabel(label):
         label = label.encode('ascii')
         try:
             ulabel(label)
-        except:
+        except IDNAError:
             raise IDNAError('The label {0} is not a valid A-label'.format(label))
         if not valid_label_length(label):
             raise IDNAError('Label too long')
         return label
-    except UnicodeError:
+    except UnicodeEncodeError:
         pass
 
     if not label:
@@ -288,7 +288,7 @@ def ulabel(label):
     if not isinstance(label, (bytes, bytearray)):
         try:
             label = label.encode('ascii')
-        except UnicodeError:
+        except UnicodeEncodeError:
             check_label(label)
             return label
 

requests/packages/idna/intranges.py

@@ -11,6 +11,8 @@ def intranges_from_list(list_):
     """Represent a list of integers as a sequence of ranges:
     ((start_0, end_0), (start_1, end_1), ...), such that the original
     integers are exactly those x such that start_i <= x < end_i for some i.
+
+    Ranges are encoded as single integers (start << 32 | end), not as tuples.
     """
 
     sorted_list = sorted(list_)
@@ -21,26 +23,31 @@ def intranges_from_list(list_):
             if sorted_list[i] == sorted_list[i+1]-1:
                 continue
         current_range = sorted_list[last_write+1:i+1]
-        range_tuple = (current_range[0], current_range[-1] + 1)
-        ranges.append(range_tuple)
+        ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
         last_write = i
 
     return tuple(ranges)
 
+def _encode_range(start, end):
+    return (start << 32) | end
+
+def _decode_range(r):
+    return (r >> 32), (r & ((1 << 32) - 1))
+
 
 def intranges_contain(int_, ranges):
     """Determine if `int_` falls into one of the ranges in `ranges`."""
-    tuple_ = (int_, int_)
+    tuple_ = _encode_range(int_, 0)
     pos = bisect.bisect_left(ranges, tuple_)
     # we could be immediately ahead of a tuple (start, end)
     # with start < int_ <= end
     if pos > 0:
-        left, right = ranges[pos-1]
+        left, right = _decode_range(ranges[pos-1])
         if left <= int_ < right:
             return True
     # or we could be immediately behind a tuple (int_, end)
     if pos < len(ranges):
-        left, _ = ranges[pos]
+        left, _ = _decode_range(ranges[pos])
         if left == int_:
             return True
     return False