Updates and tweaks for isinstance()

* Also remove the obsolete ``int`` declaration in future/builtins/misc.py

Author: edschofield

future/builtins/backports/newbytes.py

@@ -20,12 +20,16 @@
 from collections import Iterable
 from numbers import Integral
 
-from future.utils import istext, isbytes
+from future.utils import istext, isbytes, PY3
 from future.builtins.backports import no, issubset
 
 
 _builtin_bytes = bytes
 
+if PY3:
+    # We'll probably never use newstr on Py3 anyway...
+    unicode = str
+
 
 class newbytes(_builtin_bytes):
     """

future/builtins/backports/newstr.py

@@ -2,11 +2,14 @@
 This module redefines ``str`` on Python 2.x to be a subclass of the Py2
 ``unicode`` type that behaves like the Python 3.x ``str``.
 
+The main differences between ``newstr`` and Python 2.x's ``unicode`` type are
+the stricter type-checking and absence of a `u''` prefix in the representation.
+
 It is designed to be used together with the ``unicode_literals`` import
 as follows:
 
     >>> from __future__ import unicode_literals
-    >>> from future.builtins import str
+    >>> from future.builtins import str, isinstance
 
 On Python 3.x and normally on Python 2.x, these expressions hold
 
@@ -26,10 +29,9 @@
     >>> isinstance('blah', str)
     False
 
-This module is designed to be imported together with unicode_literals on
-Python 2 to bring the meaning of ``str`` back into alignment with
-unprefixed string literals (i.e. ``unicode`` if ``unicode_literals`` has
-been imported from ``__future__``).
+This module is designed to be imported together with ``unicode_literals`` on
+Python 2 to bring the meaning of ``str`` back into alignment with unprefixed
+string literals (i.e. ``unicode``).
 
 Note that ``str()`` (and ``print()``) would then normally call the
 ``__unicode__`` method on objects in Python 2. To define string
@@ -151,7 +153,6 @@ def replace(self, old, new, *args):
     def decode(self, *args):
         raise AttributeError("decode method has been disabled in newstr")
 
-    @no(bytes, 1)
     def encode(self, encoding='utf-8', errors='strict'):
         """
         Returns bytes

future/builtins/misc.py

@@ -11,8 +11,12 @@
 - ``input`` (equivalent to ``raw_input`` on Py2)
 - ``open`` (equivalent to io.open on Py2)
 
-and:
-- ``int`` (currently unchanged)
+This function is also defined specially:
+
+- ``isinstance``
+
+to be compatible with the backported ``int``, ``str``, and ``bytes`` types of
+``future.builtins``.
 
 
 input()
@@ -41,12 +45,13 @@
     from io import open
     from future_builtins import ascii, oct, hex
     from __builtin__ import unichr as chr
-    from __builtin__ import int
     import __builtin__
 
-    # Is it a good idea to define this? It'll mean many fewer lines of code
-    # need to be changed. Example: xlwt package uses isinstance() a lot.
-    # On the other hand, it may break some things and make them harder to debug.
+    # Is it a good idea to define this? It'll mean many fewer lines of
+    # type-checking code need to be changed to using custom 
+    # functions (like future.utils.isint). Example: the xlwt package uses
+    # isinstance() a lot. On the other hand, it may break some things and make
+    # them harder to debug.
     def isinstance(obj, class_or_type_or_tuple):
         """
         isinstance(object, class-or-type-or-tuple) -> bool
@@ -80,15 +85,15 @@ def isinstance(obj, class_or_type_or_tuple):
     # In case some code wants to import 'callable' portably from Py3.0/3.1:
     callable = __builtin__.callable
 
-    __all__ = ['ascii', 'chr', 'hex', 'input', 'int', 'oct', 'open']
+    __all__ = ['ascii', 'chr', 'hex', 'input', 'isinstance', 'oct', 'open']
 
 else:
     import builtins
     ascii = builtins.ascii
     chr = builtins.chr
     hex = builtins.hex
     input = builtins.input
-    int = builtins.int
+    isinstance = builtins.isinstance
     oct = builtins.oct
     open = builtins.open
 

future/tests/test_str.py

@@ -27,10 +27,10 @@ def test_str_encode_utf8(self):
 
     def test_str_encode_decode_with_py2_str_arg(self):
         # Try passing a standard Py2 string (as if unicode_literals weren't imported)
-        b = str(TEST_UNICODE_STR).encode(utils.native_str(b'utf-8'))
+        b = str(TEST_UNICODE_STR).encode(utils.bytes_to_native_str(b'utf-8'))
         self.assertTrue(isinstance(b, bytes))
         self.assertFalse(isinstance(b, str))
-        s = b.decode(utils.native_str(b'utf-8'))
+        s = b.decode(utils.bytes_to_native_str(b'utf-8'))
         self.assertTrue(isinstance(s, str))
         self.assertEqual(s, TEST_UNICODE_STR)