Skip to content

Commit 11bc89c

Browse files
edschofieldedschofield
committed
Remove isinstance() implementation and replace with __instancecheck__ overrides
1 parent 9c78130 commit 11bc89c

9 files changed

Lines changed: 61 additions & 136 deletions

File tree

‎docs/source/changelog.rst‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -12,12 +12,14 @@ Looser type-checking for the backported ``str`` object?
1212

1313
This is to work around some bugs / sloppiness in the Python 2 standard library.
1414

15-
Overridden ``isinstance`` builtin deprecated?
16-
---------------------------------------------
17-
18-
``isinstance`` checks with the backported types now work correctly using
19-
``__subclasshook__``?
20-
15+
``isinstance`` checks supported natively with backported types
16+
--------------------------------------------------------------
17+
18+
The ``isinstance`` function is no longer redefined in ``future.builtins``
19+
to operate with the backported ``int``, ``bytes`` and ``str``.
20+
``isinstance`` checks with the backported types now work correctly by
21+
default; we achieve this through overriding the ``__instancecheck__``
22+
method of metaclasses of the backported types.
2123

2224
``futurize``: minimal imports by default
2325
----------------------------------------

‎docs/source/imports.rst‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@ If you prefer explicit imports, the explicit equivalent of the ``from
5050
future.builtins import *`` line is::
5151

5252
from future.builtins import (filter, map, zip,
53-
ascii, chr, hex, input, isinstance, oct, open,
53+
ascii, chr, hex, input, oct, open,
5454
bytes, int, range, round, str, super)
5555

5656

@@ -69,7 +69,7 @@ for these modules:
6969
The internal API is currently as follows::
7070

7171
from future.builtins.iterators import filter, map, zip
72-
from future.builtins.misc import ascii, chr, hex, input, isinstance, oct, open
72+
from future.builtins.misc import ascii, chr, hex, input, oct, open
7373
from future.builtins.backports import bytes, int, range, round, str, super
7474

7575
(Please note that this internal API is evolving and may not be stable

‎docs/source/isinstance.rst‎

Lines changed: 7 additions & 95 deletions
Original file line numberDiff line numberDiff line change
@@ -36,8 +36,8 @@ then the fifth test fails too::
3636
AssertionError
3737

3838

39-
After importing the builtins from ``future``, the tests pass on Python 2 as
40-
on Python 3::
39+
After importing the builtins from ``future``, all these tests pass on
40+
Python 2 as on Python 3::
4141

4242
>>> from __future__ import unicode_literals
4343
>>> from future.builtins import *
@@ -50,6 +50,11 @@ on Python 3::
5050

5151
Note that the last test requires that ``unicode_literals`` be imported to succeed.
5252

53+
This works because the backported types ``int``, ``bytes`` and ``str``
54+
have metaclasses that override ``__instancecheck__``. See `PEP 3119
55+
<http://www.python.org/dev/peps/pep-3119/#overloading-isinstance-and-issubclass>`_
56+
for details.
57+
5358

5459
Passing data to/from Python 2 libraries
5560
---------------------------------------
@@ -110,96 +115,3 @@ The objects ``native_str`` and ``native_bytes`` are available in
110115
The functions ``native_str_to_bytes`` and ``bytes_to_native_str`` are also
111116
available for more explicit conversions.
112117

113-
114-
.. ``isinstance`` checks are sometimes fragile and generally discouraged in
115-
.. Python code (in favour of duck typing). When passing ``future``'s backported
116-
.. ``int``, ``str``, or ``bytes`` types from Python 3 to standard library code
117-
.. or 3rd-party modules on Python 2 that contain checks with ``isinstance``, some
118-
.. special handling may be required to achieve portability.
119-
..
120-
.. This section explains the issues involved and describes some utility functions
121-
.. in :mod:`future.utils` that assist with writing clean code.
122-
..
123-
.. Distinguishing bytes from unicode text
124-
.. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
125-
..
126-
.. On Python 2, (unicode) string literals ``'...'`` and byte-string literals
127-
.. ``b'...'`` create instances of the superclasses of the backported
128-
.. :class:`str` and :class:`bytes` types from :mod:`future.builtins` (i.e.
129-
.. the native Py2 unicode and 8-bit string types). Therefore ``isinstance`` checks
130-
.. in standard library code or 3rd-party modules should succeed. Just keep in mind
131-
.. that with ``future``, ``str`` and ``bytes`` are like Python 3's types of the
132-
.. same names.
133-
134-
.. Old
135-
.. ~~~
136-
.. If type-checking is necessary to distinguish unicode text from bytes
137-
.. portably across Py3 and Py2, utility functions called :func:`istext` and
138-
.. :func:`isbytes` are available in :mod:`future.utils`. You can use them
139-
.. as follows::
140-
..
141-
.. >>> from __future__ import unicode_literals
142-
.. >>> from future.builtins import *
143-
.. >>> from future.utils import istext, isbytes
144-
..
145-
.. >>> assert istext('My (unicode) string')
146-
.. >>> assert istext(str('My (unicode) string'))
147-
..
148-
.. >>> assert isbytes(b'My byte-string')
149-
.. >>> assert isbytes(bytes(b'My byte-string'))
150-
..
151-
.. ``istext(s)`` tests whether the object ``s`` is (or inherits from) a
152-
.. unicode string. It is equivalent to the following expression::
153-
..
154-
.. isinstance(s, type(u''))
155-
..
156-
.. which is ``True`` if ``s`` is a native Py3 string, Py2 unicode object, or
157-
.. :class:`future.builtins.str` object on Py2.
158-
..
159-
.. Likewise, ``isbytes(b)`` tests whether ``b`` is (or inherits from) an
160-
.. 8-bit byte-string. It is equivalent to::
161-
..
162-
.. isinstance(b, type(b''))
163-
..
164-
.. which is ``True`` if ``b`` is a native Py3 bytes object, Py2 8-bit str,
165-
.. or :class:`future.builtins.bytes` object on Py2.
166-
167-
168-
.. Integers and long integers
169-
.. ~~~~~~~~~~~~~~~~~~~~~~~~~~
170-
..
171-
.. Python 3 unifies Python 2's concepts of integers (``int``) and long
172-
.. integers (``long``) into a single ``int`` type.
173-
..
174-
.. On Python 2, checks such as ``isinstance(x, int)`` are fragile because
175-
.. ``long`` does not inherit from ``int``. So when an integer gets too
176-
.. large, the check starts to fail. For example::
177-
..
178-
.. >>> x = 2**62
179-
.. >>> assert isinstance(x, int)
180-
.. >>> x *= 2
181-
.. >>> assert isinstance(x, int)
182-
.. Traceback (most recent call last):
183-
.. File "<stdin>", line 1, in <module>
184-
.. AssertionError
185-
..
186-
.. ``future``'s backported ``int`` object doesn't help with these checks;
187-
.. both of them fail. To test if a variable is an integer on Py3 or either an
188-
.. ``int`` or ``long`` on Py2, you can use the ``future.utils.isint``
189-
.. function::
190-
..
191-
.. >>> from future.utils import isint
192-
..
193-
.. >>> assert isint(10)
194-
.. >>> assert isint(10**1000)
195-
..
196-
.. An alternative is to use the abstract base class :class:`Integral`
197-
.. from the :mod:`numbers` module as follows::
198-
..
199-
.. >>> from numbers import Integral
200-
..
201-
.. >>> assert isinstance(10, Integral)
202-
.. >>> assert isinstance(10**1000, Integral)
203-
204-
205-

‎future/builtins/__init__.py‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,8 @@
1212
"""
1313

1414
from future.builtins.iterators import (filter, map, zip)
15+
# The isinstance import is unneeded. For backward-compatibility with
16+
# future v0.8 only.
1517
from future.builtins.misc import (ascii, chr, hex, input, isinstance, oct, open)
1618
from future.builtins.backports import (bytes, int, range, round, str, super)
1719
from future import utils

‎future/builtins/backports/__init__.py‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -141,7 +141,7 @@ def wrapper(*args, **kwargs):
141141
# Only restrict kw args only if they are passed:
142142
if len(args) <= argnum:
143143
break
144-
if isinstance(args[argnum], mytype):
144+
if type(args[argnum]) == mytype:
145145
raise TypeError(errmsg.format(mytype))
146146
return function(*args, **kwargs)
147147
return wrapper

‎future/builtins/backports/newbytes.py‎

Lines changed: 15 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@
2020
from collections import Iterable
2121
from numbers import Integral
2222

23-
from future.utils import istext, isbytes, PY3
23+
from future.utils import istext, isbytes, PY3, with_metaclass
2424
from future.builtins.backports import no, issubset
2525

2626

@@ -31,7 +31,12 @@
3131
unicode = str
3232

3333

34-
class newbytes(_builtin_bytes):
34+
class BaseNewBytes(type):
35+
def __instancecheck__(cls, instance):
36+
return isinstance(instance, _builtin_bytes)
37+
38+
39+
class newbytes(with_metaclass(BaseNewBytes, _builtin_bytes)):
3540
"""
3641
A backport of the Python 3 bytes object to Py2
3742
"""
@@ -54,7 +59,11 @@ def __new__(cls, *args, **kwargs):
5459

5560
if len(args) == 0:
5661
return super(newbytes, cls).__new__(cls)
57-
elif isinstance(args[0], newbytes):
62+
# Was: elif isinstance(args[0], newbytes):
63+
# We use type() instead of the above because we're redefining
64+
# this to be True for all unicode string subclasses. Warning:
65+
# This may render newstr un-subclassable.
66+
elif type(args[0]) == newbytes:
5867
return args[0]
5968
elif isinstance(args[0], _builtin_bytes):
6069
value = args[0]
@@ -106,7 +115,9 @@ def __getslice__(self, *args):
106115
def __contains__(self, key):
107116
if isinstance(key, int):
108117
newbyteskey = newbytes([key])
109-
elif isinstance(key, newbytes):
118+
# Don't use isinstance() here because we only want to catch
119+
# newbytes, not Python 2 str:
120+
elif type(key) == newbytes:
110121
newbyteskey = key
111122
else:
112123
newbyteskey = newbytes(key)

‎future/builtins/backports/newint.py‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -10,14 +10,20 @@
1010
from numbers import Integral
1111

1212
from future.builtins.backports.newbytes import newbytes
13-
from future.utils import PY3, isint, istext, isbytes
13+
from future.utils import PY3, isint, istext, isbytes, with_metaclass
1414

1515

1616
if PY3:
1717
long = int
1818

1919

20-
class newint(long):
20+
class BaseNewInt(type):
21+
def __instancecheck__(cls, instance):
22+
# Special case for Py2 short or long int
23+
return isinstance(instance, (int, long))
24+
25+
26+
class newint(with_metaclass(BaseNewInt, long)):
2127
"""
2228
A backport of the Python 3 int object to Py2
2329
"""

‎future/builtins/backports/newstr.py‎

Lines changed: 15 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,7 @@
4343
from collections import Iterable
4444

4545
from numbers import Number
46-
from future.utils import PY3, istext
46+
from future.utils import PY3, istext, with_metaclass
4747
from future.builtins.backports import no, issubset
4848
from future.builtins.backports.newbytes import newbytes
4949

@@ -53,7 +53,12 @@
5353
unicode = str
5454

5555

56-
class newstr(unicode):
56+
class BaseNewStr(type):
57+
def __instancecheck__(cls, instance):
58+
return isinstance(instance, unicode)
59+
60+
61+
class newstr(with_metaclass(BaseNewStr, unicode)):
5762
"""
5863
A backport of the Python 3 str object to Py2
5964
"""
@@ -78,7 +83,11 @@ def __new__(cls, *args, **kwargs):
7883

7984
if len(args) == 0:
8085
return super(newstr, cls).__new__(cls)
81-
elif isinstance(args[0], newstr):
86+
# Was: elif isinstance(args[0], newstr):
87+
# We use type() instead of the above because we're redefining
88+
# this to be True for all unicode string subclasses. Warning:
89+
# This may render newstr un-subclassable.
90+
elif type(args[0]) == newstr:
8291
return args[0]
8392
elif isinstance(args[0], unicode):
8493
value = args[0]
@@ -104,7 +113,9 @@ def __getitem__(self, y):
104113

105114
def __contains__(self, key):
106115
errmsg = "'in <string>' requires string as left operand, not {0}"
107-
if isinstance(key, newstr):
116+
# Don't use isinstance() here because we only want to catch
117+
# newstr, not Python 2 unicode:
118+
if type(key) == newstr:
108119
newkey = key
109120
elif isinstance(key, unicode):
110121
newkey = newstr(key)

‎future/builtins/misc.py‎

Lines changed: 3 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -54,28 +54,8 @@
5454
from __builtin__ import unichr as chr
5555
import __builtin__
5656

57-
# Is it a good idea to define this? It'll mean many fewer lines of
58-
# type-checking code need to be changed to using custom
59-
# functions (like future.utils.isint). Example: the xlwt package uses
60-
# isinstance() a lot. On the other hand, it may break some things and make
61-
# them harder to debug.
62-
def isinstance(obj, class_or_type_or_tuple):
63-
"""
64-
isinstance(object, class-or-type-or-tuple) -> bool
65-
66-
Return whether an object is an instance of a class or of a
67-
subclass thereof. With a type as second argument, return whether
68-
that is the object's type. The form using a tuple, isinstance(x,
69-
(A, B, ...)), is a shortcut for isinstance(x, A) or isinstance(x,
70-
B) or ... (etc.).
71-
"""
72-
if hasattr(class_or_type_or_tuple, '__native__'):
73-
# Special case for Py2 short int
74-
if class_or_type_or_tuple == newint and isinstance(obj, int):
75-
return True
76-
return __builtin__.isinstance(obj, class_or_type_or_tuple.__base__)
77-
else:
78-
return __builtin__.isinstance(obj, class_or_type_or_tuple)
57+
# Only for backward compatibility with future v0.8.2
58+
isinstance = __builtin__.isinstance
7959

8060
# The following seems like a good idea, but it may be a bit
8161
# paranoid and the implementation may be fragile:
@@ -100,6 +80,7 @@ def isinstance(obj, class_or_type_or_tuple):
10080
chr = builtins.chr
10181
hex = builtins.hex
10282
input = builtins.input
83+
# Only for backward compatibility with future v0.8.2:
10384
isinstance = builtins.isinstance
10485
oct = builtins.oct
10586
open = builtins.open

0 commit comments

Comments
 (0)