Merge branch 'int_to_from_bytes' into v0.12.x

Author: edschofield

docs/whatsnew.rst

@@ -13,6 +13,7 @@ What's new in version 0.12.5
   (issue #81). It still converts ``obj.next()`` method calls to
   ``next(obj)`` correctly.
 - Add :ref:`compatible-idioms` from Ed Schofield's PyConAU 2014 talk.
+- Add ``int.to_bytes()`` and ``int.from_bytes()`` (issue #85)
 - Add ``future.utils.raise_from`` as an equivalent to Py3's ``raise ... from ...`` syntax (issue #86).
 
 

future/tests/test_int.py

@@ -6,10 +6,11 @@
                         print_function, unicode_literals)
 from future.builtins import *
 from future.tests.base import unittest, expectedFailurePY2
-from future.utils import PY26
+from future.utils import PY26, PY2, raise_from
 
 import sys
 import random
+import array
 
 try:
     import numpy as np
@@ -778,5 +779,249 @@ def test_unary_operators(self):
         self.assertEqual(-b, 3)
         self.assertTrue(isinstance(-a, int))
 
+    def test_to_bytes(self):
+        def check(tests, byteorder, signed=False):
+            for test, expected in tests.items():
+                try:
+                    self.assertEqual(
+                        int(test).to_bytes(len(expected), byteorder, signed=signed),
+                        expected)
+                except Exception as err:
+                    raise_from(AssertionError(
+                        "failed to convert {0} with byteorder={1} and signed={2}"
+                        .format(test, byteorder, signed)), err)
+
+        # Convert integers to signed big-endian byte arrays.
+        tests1 = {
+            0: bytes(b'\x00'),
+            1: bytes(b'\x01'),
+            -1: bytes(b'\xff'),
+            -127: bytes(b'\x81'),
+            -128: bytes(b'\x80'),
+            -129: bytes(b'\xff\x7f'),
+            127: bytes(b'\x7f'),
+            129: bytes(b'\x00\x81'),
+            -255: bytes(b'\xff\x01'),
+            -256: bytes(b'\xff\x00'),
+            255: bytes(b'\x00\xff'),
+            256: bytes(b'\x01\x00'),
+            32767: bytes(b'\x7f\xff'),
+            -32768: bytes(b'\xff\x80\x00'),
+            65535: bytes(b'\x00\xff\xff'),
+            -65536: bytes(b'\xff\x00\x00'),
+            -8388608: bytes(b'\x80\x00\x00')
+        }
+        # check(tests1, 'big', signed=True)
+
+        # Convert integers to signed little-endian byte arrays.
+        tests2 = {
+            0: bytes(b'\x00'),
+            1: bytes(b'\x01'),
+            -1: bytes(b'\xff'),
+            -127: bytes(b'\x81'),
+            -128: bytes(b'\x80'),
+            -129: bytes(b'\x7f\xff'),
+            127: bytes(b'\x7f'),
+            129: bytes(b'\x81\x00'),
+            -255: bytes(b'\x01\xff'),
+            -256: bytes(b'\x00\xff'),
+            255: bytes(b'\xff\x00'),
+            256: bytes(b'\x00\x01'),
+            32767: bytes(b'\xff\x7f'),
+            -32768: bytes(b'\x00\x80'),
+            65535: bytes(b'\xff\xff\x00'),
+            -65536: bytes(b'\x00\x00\xff'),
+            -8388608: bytes(b'\x00\x00\x80')
+        }
+        # check(tests2, 'little', signed=True)
+
+        # Convert integers to unsigned big-endian byte arrays.
+        tests3 = {
+            0: bytes(b'\x00'),
+            1: bytes(b'\x01'),
+            127: bytes(b'\x7f'),
+            128: bytes(b'\x80'),
+            255: bytes(b'\xff'),
+            256: bytes(b'\x01\x00'),
+            32767: bytes(b'\x7f\xff'),
+            32768: bytes(b'\x80\x00'),
+            65535: bytes(b'\xff\xff'),
+            65536: bytes(b'\x01\x00\x00')
+        }
+        check(tests3, 'big', signed=False)
+
+        # Convert integers to unsigned little-endian byte arrays.
+        tests4 = {
+            0: bytes(b'\x00'),
+            1: bytes(b'\x01'),
+            127: bytes(b'\x7f'),
+            128: bytes(b'\x80'),
+            255: bytes(b'\xff'),
+            256: bytes(b'\x00\x01'),
+            32767: bytes(b'\xff\x7f'),
+            32768: bytes(b'\x00\x80'),
+            65535: bytes(b'\xff\xff'),
+            65536: bytes(b'\x00\x00\x01')
+        }
+        check(tests4, 'little', signed=False)
+
+        self.assertRaises(OverflowError, int(256).to_bytes, 1, 'big', signed=False)
+        # self.assertRaises(OverflowError, int(256).to_bytes, 1, 'big', signed=True)
+        self.assertRaises(OverflowError, int(256).to_bytes, 1, 'little', signed=False)
+        # self.assertRaises(OverflowError, int(256).to_bytes, 1, 'little', signed=True)
+        self.assertRaises(OverflowError, int(-1).to_bytes, 2, 'big', signed=False),
+        self.assertRaises(OverflowError, int(-1).to_bytes, 2, 'little', signed=False)
+        self.assertEqual(int(0).to_bytes(0, 'big'), b'')
+        self.assertEqual(int(1).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x01')
+        self.assertEqual(int(0).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x00')
+        # self.assertEqual(int(-1).to_bytes(5, 'big', signed=True),
+        #                  bytes(b'\xff\xff\xff\xff\xff'))
+        self.assertRaises(OverflowError, int(1).to_bytes, 0, 'big')
+
+    def test_from_bytes(self):
+        def check(tests, byteorder, signed=False):
+            for test, expected in tests.items():
+                try:
+                    self.assertEqual(
+                        int.from_bytes(test, byteorder, signed=signed),
+                        int(expected))
+                except Exception as err:
+                    raise_from(AssertionError(
+                        "failed to convert {0} with byteorder={1!r} and signed={2}"
+                        .format(test, byteorder, signed)), err)
+
+        # Convert signed big-endian byte arrays to integers.
+        tests1 = {
+            bytes(b''): 0,
+            bytes(b'\x00'): 0,
+            bytes(b'\x00\x00'): 0,
+            bytes(b'\x01'): 1,
+            bytes(b'\x00\x01'): 1,
+            bytes(b'\xff'): -1,
+            bytes(b'\xff\xff'): -1,
+            bytes(b'\x81'): -127,
+            bytes(b'\x80'): -128,
+            bytes(b'\xff\x7f'): -129,
+            bytes(b'\x7f'): 127,
+            bytes(b'\x00\x81'): 129,
+            bytes(b'\xff\x01'): -255,
+            bytes(b'\xff\x00'): -256,
+            bytes(b'\x00\xff'): 255,
+            bytes(b'\x01\x00'): 256,
+            bytes(b'\x7f\xff'): 32767,
+            bytes(b'\x80\x00'): -32768,
+            bytes(b'\x00\xff\xff'): 65535,
+            bytes(b'\xff\x00\x00'): -65536,
+            bytes(b'\x80\x00\x00'): -8388608
+        }
+        # check(tests1, 'big', signed=True)
+
+        # Convert signed little-endian byte arrays to integers.
+        tests2 = {
+            bytes(b''): 0,
+            bytes(b'\x00'): 0,
+            bytes(b'\x00\x00'): 0,
+            bytes(b'\x01'): 1,
+            bytes(b'\x00\x01'): 256,
+            bytes(b'\xff'): -1,
+            bytes(b'\xff\xff'): -1,
+            bytes(b'\x81'): -127,
+            bytes(b'\x80'): -128,
+            bytes(b'\x7f\xff'): -129,
+            bytes(b'\x7f'): 127,
+            bytes(b'\x81\x00'): 129,
+            bytes(b'\x01\xff'): -255,
+            bytes(b'\x00\xff'): -256,
+            bytes(b'\xff\x00'): 255,
+            bytes(b'\x00\x01'): 256,
+            bytes(b'\xff\x7f'): 32767,
+            bytes(b'\x00\x80'): -32768,
+            bytes(b'\xff\xff\x00'): 65535,
+            bytes(b'\x00\x00\xff'): -65536,
+            bytes(b'\x00\x00\x80'): -8388608
+        }
+        # check(tests2, 'little', signed=True)
+
+        # Convert unsigned big-endian byte arrays to integers.
+        tests3 = {
+            bytes(b''): 0,
+            bytes(b'\x00'): 0,
+            bytes(b'\x01'): 1,
+            bytes(b'\x7f'): 127,
+            bytes(b'\x80'): 128,
+            bytes(b'\xff'): 255,
+            bytes(b'\x01\x00'): 256,
+            bytes(b'\x7f\xff'): 32767,
+            bytes(b'\x80\x00'): 32768,
+            bytes(b'\xff\xff'): 65535,
+            bytes(b'\x01\x00\x00'): 65536,
+        }
+        check(tests3, 'big', signed=False)
+
+        # Convert integers to unsigned little-endian byte arrays.
+        tests4 = {
+            bytes(b''): 0,
+            bytes(b'\x00'): 0,
+            bytes(b'\x01'): 1,
+            bytes(b'\x7f'): 127,
+            bytes(b'\x80'): 128,
+            bytes(b'\xff'): 255,
+            bytes(b'\x00\x01'): 256,
+            bytes(b'\xff\x7f'): 32767,
+            bytes(b'\x00\x80'): 32768,
+            bytes(b'\xff\xff'): 65535,
+            bytes(b'\x00\x00\x01'): 65536,
+        }
+        check(tests4, 'little', signed=False)
+
+        class myint(int):
+            pass
+
+        if PY2:
+            import __builtin__
+            oldbytes = __builtin__.bytes
+            types = (bytes, oldbytes)
+        else:
+            types = (bytes,)
+        for mytype in types:
+            self.assertIs(type(myint.from_bytes(mytype(b'\x00'), 'big')), myint)
+            self.assertEqual(myint.from_bytes(mytype(b'\x01'), 'big'), 1)
+            self.assertIs(
+                type(myint.from_bytes(mytype(b'\x00'), 'big', signed=False)), myint)
+            self.assertEqual(myint.from_bytes(mytype(b'\x01'), 'big', signed=False), 1)
+            self.assertIs(type(myint.from_bytes(mytype(b'\x00'), 'little')), myint)
+            self.assertEqual(myint.from_bytes(mytype(b'\x01'), 'little'), 1)
+            self.assertIs(type(myint.from_bytes(
+                mytype(b'\x00'), 'little', signed=False)), myint)
+            self.assertEqual(myint.from_bytes(mytype(b'\x01'), 'little', signed=False), 1)
+            # self.assertEqual(
+            #     int.from_bytes([255, 0, 0], 'big', signed=True), -65536)
+            # self.assertEqual(
+            #     int.from_bytes((255, 0, 0), 'big', signed=True), -65536)
+            # self.assertEqual(int.from_bytes(
+            #     bytearray(mytype(b'\xff\x00\x00')), 'big', signed=True), -65536)
+            # self.assertEqual(int.from_bytes(
+            #     bytearray(mytype(b'\xff\x00\x00')), 'big', signed=True), -65536)
+            # self.assertEqual(int.from_bytes(
+            #     array.array('B', mytype(b'\xff\x00\x00')), 'big', signed=True), -65536)
+            # self.assertEqual(int.from_bytes(
+            #     memoryview(mytype(b'\xff\x00\x00')), 'big', signed=True), -65536)
+
+        self.assertRaises(TypeError, int.from_bytes, u"", 'big')
+        self.assertRaises(TypeError, int.from_bytes, u"\x00", 'big')
+        self.assertRaises(TypeError, myint.from_bytes, u"", 'big')
+        self.assertRaises(TypeError, myint.from_bytes, u"\x00", 'big')
+
+        types = (int, lambda x: x) if PY2 else (lambda x: x,)
+        for mytype in types:
+            self.assertRaises(ValueError, int.from_bytes, [mytype(256)], 'big')
+            self.assertRaises(ValueError, int.from_bytes, [mytype(0)], 'big\x00')
+            self.assertRaises(ValueError, int.from_bytes, [mytype(0)], 'little\x00')
+            self.assertRaises(TypeError, int.from_bytes, mytype(0), 'big')
+            # self.assertRaises(TypeError, int.from_bytes, mytype(0), 'big', True)
+            self.assertRaises(TypeError, myint.from_bytes, mytype(0), 'big')
+            # self.assertRaises(TypeError, int.from_bytes, mytype(0), 'big', True)
+
+
 if __name__ == "__main__":
     unittest.main()

future/types/newint.py

@@ -7,8 +7,11 @@
 """
 from __future__ import division
 
+import struct
+import collections
+
 from future.types.newbytes import newbytes
-from future.utils import PY3, isint, istext, isbytes, with_metaclass
+from future.utils import PY3, isint, istext, isbytes, with_metaclass, native
 
 
 if PY3:
@@ -274,5 +277,84 @@ def __bool__(self):
     def __native__(self):
         return long(self)
 
+    def to_bytes(self, length, byteorder='big', signed=False):
+        """
+        Return an array of bytes representing an integer.
+
+        The integer is represented using length bytes.  An OverflowError is
+        raised if the integer is not representable with the given number of
+        bytes.
+
+        The byteorder argument determines the byte order used to represent the
+        integer.  If byteorder is 'big', the most significant byte is at the
+        beginning of the byte array.  If byteorder is 'little', the most
+        significant byte is at the end of the byte array.  To request the native
+        byte order of the host system, use `sys.byteorder' as the byte order value.
+
+        The signed keyword-only argument determines whether two's complement is
+        used to represent the integer.  If signed is False and a negative integer
+        is given, an OverflowError is raised.
+        """
+        if signed:
+            raise NotImplementedError("Not yet implemented. Please contribute a patch at http://python-future.org")
+        else:
+            if self < 0:
+                raise OverflowError("can't convert negative int to unsigned")
+            num = self
+        if byteorder not in ('little', 'big'):
+            raise ValueError("byteorder must be either 'little' or 'big'")
+        if length < 0:
+            raise ValueError("length argument must be non-negative")
+        if length == 0 and num == 0:
+            return newbytes()
+        h = b'%x' % num
+        s = newbytes((b'0'*(len(h) % 2) + h).zfill(length*2).decode('hex'))
+        if len(s) > length:
+            raise OverflowError("int too big to convert")
+        return s if byteorder == 'big' else s[::-1]
+
+    @classmethod
+    def from_bytes(cls, mybytes, byteorder='big', signed=False):
+        """
+        Return the integer represented by the given array of bytes.
+
+        The mybytes argument must either support the buffer protocol or be an
+        iterable object producing bytes.  Bytes and bytearray are examples of
+        built-in objects that support the buffer protocol.
+
+        The byteorder argument determines the byte order used to represent the
+        integer.  If byteorder is 'big', the most significant byte is at the
+        beginning of the byte array.  If byteorder is 'little', the most
+        significant byte is at the end of the byte array.  To request the native
+        byte order of the host system, use `sys.byteorder' as the byte order value.
+
+        The signed keyword-only argument indicates whether two's complement is
+        used to represent the integer.
+        """
+        if signed:
+            raise NotImplementedError("Not yet implemented. Please contribute a patch at http://python-future.org")
+        if byteorder not in ('little', 'big'):
+            raise ValueError("byteorder must be either 'little' or 'big'")
+        if isinstance(mybytes, unicode):
+            raise TypeError("cannot convert unicode objects to bytes")
+        # mybytes can also be passed as a sequence of integers on Py3.
+        # Test for this:
+        elif isinstance(mybytes, collections.Iterable):
+            mybytes = newbytes(mybytes)
+        b = mybytes if byteorder == 'big' else mybytes[::-1]
+        if len(b) == 0:
+            b = b'\x00'
+        # The encode() method has been disabled by newbytes, but Py2's
+        # str has it:
+        num = int(native(b).encode('hex'), 16)
+        return cls(num)
+
+
+# def _twos_comp(val, bits):
+#     """compute the 2's compliment of int value val"""
+#     if( (val&(1<<(bits-1))) != 0 ):
+#         val = val - (1<<bits)
+#     return val
+
 
 __all__ = ['newint']