Rename is_text and is_bytes to istext and isbytes

edschofield · edschofield · commit 8236d76392f5 · 2013-10-06T11:31:12.000+11:00
diff --git a/docs/source/isinstance.rst b/docs/source/isinstance.rst
@@ -39,29 +39,29 @@ On Python 2, (unicode) string literals ``'...'`` and byte-string literals
 the native Py2 unicode and 8-bit string types).
 
 If type-checking is necessary to distinguish unicode text from bytes
-portably across Py3 and Py2, utility functions called :func:`is_text` and
-:func:`is_bytes` are available in :mod:`future.utils`. You can use them
+portably across Py3 and Py2, utility functions called :func:`istext` and
+:func:`isbytes` are available in :mod:`future.utils`. You can use them
 as follows::
 
     >>> from __future__ import unicode_literals
     >>> from future.builtins import *
-    >>> from future.utils import is_text, is_bytes
+    >>> from future.utils import istext, isbytes
 
-    >>> assert is_text('My (unicode) string')
-    >>> assert is_text(str('My (unicode) string'))
+    >>> assert istext('My (unicode) string')
+    >>> assert istext(str('My (unicode) string'))
 
-    >>> assert is_bytes(b'My byte-string')
-    >>> assert is_bytes(bytes(b'My byte-string'))
+    >>> assert isbytes(b'My byte-string')
+    >>> assert isbytes(bytes(b'My byte-string'))
 
-``is_text(s)`` tests whether the object ``s`` is (or inherits from) a
+``istext(s)`` tests whether the object ``s`` is (or inherits from) a
 unicode string. It is equivalent to the following expression::
 
     isinstance(s, type(u''))
 
 which is ``True`` if ``s`` is a native Py3 string, Py2 unicode object, or
 :class:`future.builtins.str` object on Py2.
 
-Likewise, ``is_bytes(b)`` tests whether ``b`` is (or inherits from) an
+Likewise, ``isbytes(b)`` tests whether ``b`` is (or inherits from) an
 8-bit byte-string. It is equivalent to::
 
     isinstance(b, type(b''))
diff --git a/future/builtins/backports/newbytes.py b/future/builtins/backports/newbytes.py
@@ -18,9 +18,9 @@
 """
 
 from collections import Iterable
-from numbers import Integral
+from numbers import Number, Integral
 
-from future.utils import PY3, is_text, is_bytes
+from future.utils import PY3, istext, isbytes
 from future.builtins.backports import no, issubset
 
 
@@ -115,10 +115,10 @@ def __rmul__(self, other):
 
     def join(self, iterable_of_bytes):
         errmsg = 'sequence item {}: expected bytes, {} found'
-        if is_bytes(iterable_of_bytes) or is_text(iterable_of_bytes):
+        if isbytes(iterable_of_bytes) or istext(iterable_of_bytes):
             raise TypeError(errmsg.format(0, type(iterable_of_bytes)))
         for i, item in enumerate(iterable_of_bytes):
-            if is_text(item):
+            if istext(item):
                 raise TypeError(errmsg.format(i, type(item)))
         return newbytes(super(newbytes, self).join(iterable_of_bytes))
 
@@ -230,22 +230,22 @@ def __ne__(self, other):
     unorderable_err = 'unorderable types: bytes() and {}'
 
     def __lt__(self, other):
-        if is_text(other) or isinstance(other, Integral):
+        if istext(other) or isinstance(other, Number):
             raise TypeError(self.unorderable_err.format(type(other)))
         return super(newbytes, self).__lt__(other)
 
     def __le__(self, other):
-        if is_text(other) or isinstance(other, Integral):
+        if istext(other) or isinstance(other, Integral):
             raise TypeError(self.unorderable_err.format(type(other)))
         return super(newbytes, self).__le__(other)
 
     def __gt__(self, other):
-        if is_text(other) or isinstance(other, Integral):
+        if istext(other) or isinstance(other, Integral):
             raise TypeError(self.unorderable_err.format(type(other)))
         return super(newbytes, self).__gt__(other)
 
     def __ge__(self, other):
-        if is_text(other) or isinstance(other, Integral):
+        if istext(other) or isinstance(other, Integral):
             raise TypeError(self.unorderable_err.format(type(other)))
         return super(newbytes, self).__ge__(other)
 
diff --git a/future/tests/test_utils.py b/future/tests/test_utils.py
@@ -19,17 +19,17 @@ def setUp(self):
         self.b = b'ABCDEFG'
         self.b2 = bytes(self.b)
 
-    def test_is_text(self):
-        self.assertTrue(utils.is_text(self.s))
-        self.assertTrue(utils.is_text(self.s2))
-        self.assertFalse(utils.is_text(self.b))
-        self.assertFalse(utils.is_text(self.b2))
-
-    def test_is_bytes(self):
-        self.assertTrue(utils.is_bytes(self.b))
-        self.assertTrue(utils.is_bytes(self.b2))
-        self.assertFalse(utils.is_bytes(self.s))
-        self.assertFalse(utils.is_bytes(self.s2))
+    def test_istext(self):
+        self.assertTrue(utils.istext(self.s))
+        self.assertTrue(utils.istext(self.s2))
+        self.assertFalse(utils.istext(self.b))
+        self.assertFalse(utils.istext(self.b2))
+
+    def test_isbytes(self):
+        self.assertTrue(utils.isbytes(self.b))
+        self.assertTrue(utils.isbytes(self.b2))
+        self.assertFalse(utils.isbytes(self.s))
+        self.assertFalse(utils.isbytes(self.s2))
 
 
 if __name__ == '__main__':
diff --git a/future/utils/__init__.py b/future/utils/__init__.py
@@ -376,15 +376,15 @@ def is_new_style(cls):
 # ``from future.builtins import *``.
 native_str = str
 
-def is_text(obj):
+def istext(obj):
     return isinstance(obj, type(u''))
 
 
-def is_bytes(obj):
+def isbytes(obj):
     return isinstance(obj, type(b''))
 
 
-# def is_int(obj):
+# def isint(obj):
 #     """
 #     Don't define this. Use this idiom instead:
 #         isinstance(obj, numbers.Integral)
