thecodingchicken
diff --git a/‎future/builtins/backports/__init__.py
Lines changed: 26 additions & 2 deletions b/‎future/builtins/backports/__init__.py
Lines changed: 26 additions & 2 deletions
diff --git a/‎future/builtins/backports/newbytes.py
Lines changed: 12 additions & 0 deletions b/‎future/builtins/backports/newbytes.py
Lines changed: 12 additions & 0 deletions
diff --git a/‎future/builtins/backports/newstr.py
Lines changed: 22 additions & 14 deletions b/‎future/builtins/backports/newstr.py
Lines changed: 22 additions & 14 deletions
@@ -95,8 +95,29 @@ def append(self, item):
 # bytes:
 def disallow_types(argnums, disallowed_types):
     """
-    A decorator that raises a TypeError if any of the given arguments is
-    of the given type (e.g. bytes or unicode string).
+    A decorator that raises a TypeError if any of the given numbered
+    arguments is of the corresponding given type (e.g. bytes or unicode
+    string).
+
+    For example:
+
+        @disallow_types([0, 1], [unicode, bytes])
+        def f(a, b):
+            pass
+
+    raises a TypeError when f is called if a unicode object is passed as
+    `a` or a bytes object is passed as `b`.
+
+    This also skips over keyword arguments, so 
+
+        @disallow_types([0, 1], [unicode, bytes])
+        def g(a, b=None):
+            pass
+
+    doesn't raise an exception if g is called with only one argument a,
+    e.g.:
+
+        g(b'Byte string')
 
     Example use:
 
@@ -116,6 +137,9 @@ def decorator(function):
         def wrapper(*args, **kwargs):
             errmsg = "argument can't be {}"
             for (argnum, mytype) in zip(argnums, disallowed_types):
+                # Only restrict kw args only if they are passed:
+                if len(args) <= argnum:
+                    break
                 if isinstance(args[argnum], mytype):
                     raise TypeError<
8000
/span>(errmsg.format(mytype))
             return function(*args, **kwargs)
 
@@ -204,5 +204,17 @@ def index(self, sub, *args):
         except ValueError:
             raise ValueError('substring not found')
 
+    def __eq__(self, other):
+        if isinstance(other, _builtin_bytes):
+            return super(newbytes, self).__eq__(other)
+        else:
+            return False
+
+    def __ne__(self, other):
+        if isinstance(other, _builtin_bytes):
+            return super(newbytes, self).__ne__(other)
+        else:
+            return True
+
 
 __all__ = ['newbytes']
@@ -58,6 +58,8 @@ class newstr(unicode):
     """
     A backport of the Python 3 str object to Py2
     """
+    no_convert_msg = "Can't convert '{}' object to str implicitly"
+
     def __new__(cls, *args, **kwargs):
         """
         From the Py3 str docstring:
@@ -166,29 +168,32 @@ def encode(self, encoding='utf-8', errors='strict'):
     def startswith(self, prefix, *args):
         if isinstance(prefix, Iterable):
             for thing in prefix:
-                if isinstance(thing, bytes):
-                    raise TypeError("Can't convert 'bytes' object to str implicitly")
+                if not isinstance(thing, unicode):
+                    raise TypeError(self.no_convert_msg.format(type(thing)))
         return super(newstr, self).startswith(prefix, *args)
 
     @no(bytes, 1)
     def endswith(self, prefix, *args):
         if isinstance(prefix, Iterable):
             for thing in prefix:
-                if isinstance(thing, bytes):
-                    raise TypeError("Can't convert 'bytes' object to str implicitly")
+                if not isinstance(thing, unicode):
+                    raise TypeError(self.no_convert_msg.format(type(thing)))
         return super(newstr, self).endswith(prefix, *args)
 
-    @no(bytes, 1)
     def split(self, sep=None, maxsplit=-1):
         # Py2 unicode.split() takes maxsplit as an optional parameter,
         # not as a keyword argument as in Python 3 str.
+        if sep is not None and not isinstance(sep, unicode):
+            raise TypeError(self.no_convert_msg.format(type(sep)))
         parts = super(newstr, self).split(sep, maxsplit)
         return [newstr(part) for part in parts]
 
     @no(bytes, 1)
     def rsplit(self, sep=None, maxsplit=-1):
         # Py2 unicode.rsplit() takes maxsplit as an optional parameter,
         # not as a keyword argument as in Python 3 str.
+        if sep is not None and not isinstance(sep, unicode):
+            raise TypeError(self.no_convert_msg.format(type(sep)))
         parts = super(newstr, self).rsplit(sep, maxsplit)
         return [newstr(part) for part in parts]
 
@@ -213,15 +218,18 @@ def index(self, sub, *args):
             raise ValueError('substring not found')
         return pos
 
-    # def find(self, sub, *args):
-    #     errmsg = "Can't convert '{}' object to newstr implicitly"
-    #     if not isinstance(sub, unicode):
-    #         raise TypeError(errmsg.format(type(sub)))
-    #     try:
-    #         return super(newstr, self).index(sub, *args)
-    #     except ValueError:
-    #         raise ValueError('substring not found')
+    def __eq__(self, other):
+        if isinstance(other, unicode):
+            return super(newstr, self).__eq__(other)
+        else:
+            return False
+
+    def __ne__(self, other):
+        if isinstance(other, unicode):
+            return super(newstr, self).__ne__(other)
+        else:
+            return True
 
 
-__all__ = ['newstr']
 
+__all__ = ['newstr']