def test_str_in_container_display():
"""Test that strings are displayed correctly inside lists or dicts."""
# Assert that both bytes and unicode return the right display
assert value_to_display([b'a', u'b']) == "['a', 'b']"
# Encoded unicode gives bytes and it can't be transformed to
# unicode again. So this test the except part of
# is_binary_string(value) in value_to_display
if PY2:
assert value_to_display([u'Э'.encode('cp1251')]) == "['\xdd']"
def test_str_in_container_display():
"""Test that strings are displayed correctly inside lists or dicts."""
# Assert that both bytes and unicode return the right display
assert value_to_display([b'a', u'b']) == "['a', 'b']"
# Encoded unicode gives bytes and it can't be transformed to
# unicode again. So this test the except part of
# is_binary_string(value) in value_to_display
if PY2:
assert value_to_display([u'Э'.encode('cp1251')]) == "['\xdd']"
def test_list_display():
"""Tests for display of lists."""
long_list = list(range(100))
# Simple list
assert value_to_display([1, 2, 3]) == '[1, 2, 3]'
# Long list
assert (value_to_display(long_list) ==
'[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...]')
# Short list of lists
assert (value_to_display([long_list] * 3) ==
'[[0, 1, 2, 3, 4, ...], [0, 1, 2, 3, 4, ...], [0, 1, 2, 3, 4, ...]]')
# Long list of lists
result = '[' + ''.join('[0, 1, 2, 3, 4, ...], '*10)[:-2] + ']'
assert value_to_display([long_list] * 10) == result[:70] + ' ...'
# Multiple level lists
assert (value_to_display([[1, 2, 3, [4], 5]] + long_list) ==
'[[1, 2, 3, [...], 5], 0, 1, 2, 3, 4, 5, 6, 7, 8, ...]')
assert value_to_display([1, 2, [DF]]) == '[1, 2, [Dataframe]]'
assert value_to_display([1, 2, [[DF], PANEL]]) == '[1, 2, [[...], Panel]]'
# List of complex object
assert value_to_display([COMPLEX_OBJECT]) == '[defaultdict]'
# List of composed objects
li = [COMPLEX_OBJECT, PANEL, 1, {1:2, 3:4}, DF]
result = '[defaultdict, Panel, 1, {1:2, 3:4}, Dataframe]'
assert value_to_display(li) == result
def test_dict_display():
"""Tests for display of dicts."""
long_list = list(range(100))
long_dict = dict(zip(list(range(100)), list(range(100))))
# Simple dict
assert value_to_display({0: 0, 'a': 'b'}) == "{0:0, 'a':'b'}"
# Long dict
assert (value_to_display(long_dict) ==
'{0:0, 1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8, 9:9, ...}')
# Short list of lists
assert (
value_to_display({
1: long_dict,
2: long_dict
}) ==
'{1:{0:0, 1:1, 2:2, 3:3, 4:4, ...}, 2:{0:0, 1:1, 2:2, 3:3, 4:4, ...}}')
# Long dict of dicts
result = ('{(0, 0, 0, 0, 0, ...):[0, 1, 2, 3, 4, ...], '
'(1, 1, 1, 1, 1, ...):[0, 1, 2, 3, 4, ...]}')
assert value_to_display({
(0, ) * 100: long_list,
(1, ) * 100: long_list
}) == result[:70] + ' ...'
# Multiple level dicts
assert (value_to_display({
0: {
1: 1,
2: 2,
3: 3,
4: {
0: 0
},
5: 5
},
1: 1
}) == '{0:{1:1, 2:2, 3:3, 4:{...}, 5:5}, 1:1}')
assert value_to_display({
0: 0,
1: 1,
2: 2,
3: DF
}) == '{0:0, 1:1, 2:2, 3:Dataframe}'
assert value_to_display({
0: 0,
1: 1,
2: [[DF], PANEL]
}) == '{0:0, 1:1, 2:[[...], Panel]}'
# Dict of complex object
assert value_to_display({0: COMPLEX_OBJECT}) == '{0:defaultdict}'
# Dict of composed objects
li = {0: COMPLEX_OBJECT, 1: PANEL, 2: 2, 3: {0: 0, 1: 1}, 4: DF}
result = '{0:defaultdict, 1:Panel, 2:2, 3:{0:0, 1:1}, 4:Dataframe}'
assert value_to_display(li) == result
def test_dict_display():
"""Tests for display of dicts."""
long_list = list(range(100))
long_dict = dict(zip(list(range(100)), list(range(100))))
# Simple dict
assert value_to_display({0:0, 'a':'b'}) == "{0:0, 'a':'b'}"
# Long dict
assert (value_to_display(long_dict) ==
'{0:0, 1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8, 9:9, ...}')
# Short list of lists
assert (value_to_display({1:long_dict, 2:long_dict}) ==
'{1:{0:0, 1:1, 2:2, 3:3, 4:4, ...}, 2:{0:0, 1:1, 2:2, 3:3, 4:4, ...}}')
# Long dict of dicts
result = ('{(0, 0, 0, 0, 0, ...):[0, 1, 2, 3, 4, ...], '
'(1, 1, 1, 1, 1, ...):[0, 1, 2, 3, 4, ...]}')
assert value_to_display({(0,)*100:long_list, (1,)*100:long_list}) == result[:70] + ' ...'
# Multiple level dicts
assert (value_to_display({0: {1:1, 2:2, 3:3, 4:{0:0}, 5:5}, 1:1}) ==
'{0:{1:1, 2:2, 3:3, 4:{...}, 5:5}, 1:1}')
assert value_to_display({0:0, 1:1, 2:2, 3:DF}) == '{0:0, 1:1, 2:2, 3:Dataframe}'
assert value_to_display({0:0, 1:1, 2:[[DF], PANEL]}) == '{0:0, 1:1, 2:[[...], Panel]}'
# Dict of complex object
assert value_to_display({0:COMPLEX_OBJECT}) == '{0:defaultdict}'
# Dict of composed objects
li = {0:COMPLEX_OBJECT, 1:PANEL, 2:2, 3:{0:0, 1:1}, 4:DF}
result = '{0:defaultdict, 1:Panel, 2:2, 3:{0:0, 1:1}, 4:Dataframe}'
assert value_to_display(li) == result
def test_list_display():
"""Tests for display of lists."""
long_list = list(range(100))
# Simple list
assert value_to_display([1, 2, 3]) == '[1, 2, 3]'
# Long list
assert (
value_to_display(long_list) == '[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...]')
# Short list of lists
assert (value_to_display(
[long_list] * 3
) == '[[0, 1, 2, 3, 4, ...], [0, 1, 2, 3, 4, ...], [0, 1, 2, 3, 4, ...]]')
# Long list of lists
result = '[' + ''.join('[0, 1, 2, 3, 4, ...], ' * 10)[:-2] + ']'
assert value_to_display([long_list] * 10) == result[:70] + ' ...'
# Multiple level lists
assert (value_to_display([[1, 2, 3, [4], 5]] + long_list) ==
'[[1, 2, 3, [...], 5], 0, 1, 2, 3, 4, 5, 6, 7, 8, ...]')
assert value_to_display([1, 2, [DF]]) == '[1, 2, [Dataframe]]'
assert value_to_display([1, 2, [[DF], PANEL]]) == '[1, 2, [[...], Panel]]'
# List of complex object
assert value_to_display([COMPLEX_OBJECT]) == '[defaultdict]'
# List of composed objects
li = [COMPLEX_OBJECT, PANEL, 1, {1: 2, 3: 4}, DF]
result = '[defaultdict, Panel, 1, {1:2, 3:4}, Dataframe]'
assert value_to_display(li) == result
def test_default_display():
"""Tests for default_display."""
# Display of defaultdict
assert (value_to_display(COMPLEX_OBJECT) ==
'defaultdict object of collections module')
# Display of array of COMPLEX_OBJECT
assert (value_to_display(np.array(COMPLEX_OBJECT)) ==
'ndarray object of numpy module')
# Display of Panel
assert (value_to_display(PANEL) ==
'Panel object of pandas.core.panel module')
def test_default_display():
"""Tests for default_display."""
# Display of defaultdict
assert (value_to_display(COMPLEX_OBJECT) ==
'defaultdict object of collections module')
# Display of array of COMPLEX_OBJECT
assert (value_to_display(
np.array(COMPLEX_OBJECT)) == 'ndarray object of numpy module')
# Display of Panel
assert (
value_to_display(PANEL) == 'Panel object of pandas.core.panel module')
def test_datetime_display():
"""Simple tests that dates, datetimes and timedeltas display correctly."""
test_date = datetime.date(2017, 12, 18)
test_date_2 = datetime.date(2017, 2, 2)
test_datetime = datetime.datetime(2017, 12, 18, 13, 43, 2)
test_datetime_2 = datetime.datetime(2017, 8, 18, 0, 41, 27)
test_timedelta = datetime.timedelta(-1, 2000)
test_timedelta_2 = datetime.timedelta(0, 3600)
# Simple dates/datetimes/timedeltas
assert value_to_display(test_date) == '2017-12-18'
assert value_to_display(test_datetime) == '2017-12-18 13:43:02'
assert value_to_display(test_timedelta) == '-1 day, 0:33:20'
# Lists of dates/datetimes/timedeltas
assert (value_to_display([test_date, test_date_2]) ==
'[2017-12-18, 2017-02-02]')
assert (value_to_display([test_datetime, test_datetime_2]) ==
'[2017-12-18 13:43:02, 2017-08-18 00:41:27]')
assert (value_to_display([test_timedelta, test_timedelta_2]) ==
'[-1 day, 0:33:20, 1:00:00]')
# Tuple of dates/datetimes/timedeltas
assert (value_to_display((test_date, test_datetime, test_timedelta)) ==
'(2017-12-18, 2017-12-18 13:43:02, -1 day, 0:33:20)')
# Dict of dates/datetimes/timedeltas
assert (value_to_display({0: test_date,
1: test_datetime,
2: test_timedelta_2}) ==
("{0:2017-12-18, 1:2017-12-18 13:43:02, 2:1:00:00}"))
def test_datetime_display():
"""Simple tests that dates, datetimes and timedeltas display correctly."""
test_date = datetime.date(2017, 12, 18)
test_date_2 = datetime.date(2017, 2, 2)
test_datetime = datetime.datetime(2017, 12, 18, 13, 43, 2)
test_datetime_2 = datetime.datetime(2017, 8, 18, 0, 41, 27)
test_timedelta = datetime.timedelta(-1, 2000)
test_timedelta_2 = datetime.timedelta(0, 3600)
# Simple dates/datetimes/timedeltas
assert value_to_display(test_date) == '2017-12-18'
assert value_to_display(test_datetime) == '2017-12-18 13:43:02'
assert value_to_display(test_timedelta) == '-1 day, 0:33:20'
# Lists of dates/datetimes/timedeltas
assert (value_to_display([test_date, test_date_2]) ==
'[2017-12-18, 2017-02-02]')
assert (value_to_display([test_datetime, test_datetime_2]) ==
'[2017-12-18 13:43:02, 2017-08-18 00:41:27]')
assert (value_to_display([test_timedelta, test_timedelta_2]) ==
'[-1 day, 0:33:20, 1:00:00]')
# Tuple of dates/datetimes/timedeltas
assert (value_to_display((test_date, test_datetime, test_timedelta)) ==
'(2017-12-18, 2017-12-18 13:43:02, -1 day, 0:33:20)')
# Dict of dates/datetimes/timedeltas
assert (value_to_display({0: test_date,
1: test_datetime,
2: test_timedelta_2}) ==
("{0:2017-12-18, 1:2017-12-18 13:43:02, 2:1:00:00}"))
def make_remote_view(data, settings, more_excluded_names=None):
"""
Make a remote view of dictionary *data*
-> globals explorer
"""
from spyder.widgets.variableexplorer.utils import (get_human_readable_type,
get_size,
get_color_name,
value_to_display)
assert all([name in REMOTE_SETTINGS for name in settings])
data = get_remote_data(data,
settings,
mode='editable',
more_excluded_names=more_excluded_names)
remote = {}
for key, value in list(data.items()):
view = value_to_display(value,
truncate=settings['truncate'],
minmax=settings['minmax'])
remote[key] = {
'type': get_human_readable_type(value),
'size': get_size(value),
'color': get_color_name(value),
'view': view
}
return remote
def test_str_subclass_display():
"""Test for value_to_display of subclasses of str/basestring."""
class Test(str):
def __repr__(self):
return 'test'
value = Test()
value_display = value_to_display(value)
assert 'Test object' in value_display
def test_str_subclass_display():
"""Test for value_to_display of subclasses of str/basestring."""
class Test(str):
def __repr__(self):
return 'test'
value = Test()
value_display = value_to_display(value)
assert 'Test object' in value_display
def test_set_display():
"""Tests for display of sets."""
long_set = {i for i in range(100)}
# Simple set
assert value_to_display({1, 2, 3}) == '{1, 2, 3}'
# Long set
disp = '{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...}'
assert value_to_display(long_set) == disp
# Short list of sets
disp = '[{0, 1, 2, 3, 4, ...}, {0, 1, 2, 3, 4, ...}, {0, 1, 2, 3, 4, ...}]'
assert value_to_display([long_set] * 3) == disp
# Long list of sets
disp = '[' + ''.join('{0, 1, 2, 3, 4, ...}, '*10)[:-2] + ']'
assert value_to_display([long_set] * 10) == disp[:70] + ' ...'
def test_set_display():
"""Tests for display of sets."""
long_set = {i for i in range(100)}
# Simple set
assert value_to_display({1, 2, 3}) == '{1, 2, 3}'
# Long set
disp = '{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...}'
assert value_to_display(long_set) == disp
# Short list of sets
disp = '[{0, 1, 2, 3, 4, ...}, {0, 1, 2, 3, 4, ...}, {0, 1, 2, 3, 4, ...}]'
assert value_to_display([long_set] * 3) == disp
# Long list of sets
disp = '[' + ''.join('{0, 1, 2, 3, 4, ...}, '*10)[:-2] + ']'
assert value_to_display([long_set] * 10) == disp[:70] + ' ...'
def test_dict_display():
"""Tests for display of dicts."""
long_list = list(range(100))
long_dict = dict(zip(list(range(100)), list(range(100))))
# Simple dict
assert value_to_display({0:0, 'a':'b'}) == "{0:0, 'a':'b'}"
# Long dict
assert (value_to_display(long_dict) ==
'{0:0, 1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8, 9:9, ...}')
# Short list of lists
assert (value_to_display({1:long_dict, 2:long_dict}) ==
'{1:{0:0, 1:1, 2:2, 3:3, 4:4, ...}, 2:{0:0, 1:1, 2:2, 3:3, 4:4, ...}}')
# Long dict of dicts
result = ('{(0, 0, 0, 0, 0, ...):[0, 1, 2, 3, 4, ...], '
'(1, 1, 1, 1, 1, ...):[0, 1, 2, 3, 4, ...]}')
assert value_to_display({(0,)*100:long_list, (1,)*100:long_list}) == result[:70] + ' ...'
# Multiple level dicts
assert (value_to_display({0: {1:1, 2:2, 3:3, 4:{0:0}, 5:5}, 1:1}) ==
'{0:{1:1, 2:2, 3:3, 4:{...}, 5:5}, 1:1}')
assert value_to_display({0:0, 1:1, 2:2, 3:DF}) == '{0:0, 1:1, 2:2, 3:Dataframe}'
assert value_to_display({0:0, 1:1, 2:[[DF], PANEL]}) == '{0:0, 1:1, 2:[[...], Panel]}'
# Dict of complex object
assert value_to_display({0:COMPLEX_OBJECT}) == '{0:defaultdict}'
# Dict of composed objects
li = {0:COMPLEX_OBJECT, 1:PANEL, 2:2, 3:{0:0, 1:1}, 4:DF}
result = '{0:defaultdict, 1:Panel, 2:2, 3:{0:0, 1:1}, 4:Dataframe}'
assert value_to_display(li) == result
# Dict starting with a non-supported object (#5313)
supported_types = tuple(get_supported_types()['editable'])
di = {max: len, 1: 1}
assert value_to_display(di) in (
'{builtin_function_or_method:builtin_function_or_method, 1:1}',
'{1:1, builtin_function_or_method:builtin_function_or_method}')
assert is_supported(di, filters=supported_types)
def test_dict_display():
"""Tests for display of dicts."""
long_list = list(range(100))
long_dict = dict(zip(list(range(100)), list(range(100))))
# Simple dict
assert value_to_display({0:0, 'a':'b'}) == "{0:0, 'a':'b'}"
# Long dict
assert (value_to_display(long_dict) ==
'{0:0, 1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8, 9:9, ...}')
# Short list of lists
assert (value_to_display({1:long_dict, 2:long_dict}) ==
'{1:{0:0, 1:1, 2:2, 3:3, 4:4, ...}, 2:{0:0, 1:1, 2:2, 3:3, 4:4, ...}}')
# Long dict of dicts
result = ('{(0, 0, 0, 0, 0, ...):[0, 1, 2, 3, 4, ...], '
'(1, 1, 1, 1, 1, ...):[0, 1, 2, 3, 4, ...]}')
assert value_to_display({(0,)*100:long_list, (1,)*100:long_list}) == result[:70] + ' ...'
# Multiple level dicts
assert (value_to_display({0: {1:1, 2:2, 3:3, 4:{0:0}, 5:5}, 1:1}) ==
'{0:{1:1, 2:2, 3:3, 4:{...}, 5:5}, 1:1}')
assert value_to_display({0:0, 1:1, 2:2, 3:DF}) == '{0:0, 1:1, 2:2, 3:Dataframe}'
assert value_to_display({0:0, 1:1, 2:[[DF], PANEL]}) == '{0:0, 1:1, 2:[[...], Panel]}'
# Dict of complex object
assert value_to_display({0:COMPLEX_OBJECT}) == '{0:defaultdict}'
# Dict of composed objects
li = {0:COMPLEX_OBJECT, 1:PANEL, 2:2, 3:{0:0, 1:1}, 4:DF}
result = '{0:defaultdict, 1:Panel, 2:2, 3:{0:0, 1:1}, 4:Dataframe}'
assert value_to_display(li) == result
# Dict starting with a non-supported object (#5313)
supported_types = tuple(get_supported_types()['editable'])
di = {max: len, 1: 1}
assert value_to_display(di) in (
'{builtin_function_or_method:builtin_function_or_method, 1:1}',
'{1:1, builtin_function_or_method:builtin_function_or_method}')
assert is_supported(di, filters=supported_types)
def test_list_display():
"""Tests for display of lists."""
long_list = list(range(100))
# Simple list
assert value_to_display([1, 2, 3]) == '[1, 2, 3]'
# Long list
assert (
value_to_display(long_list) == '[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...]')
# Short list of lists
assert (value_to_display(
[long_list] * 3
) == '[[0, 1, 2, 3, 4, ...], [0, 1, 2, 3, 4, ...], [0, 1, 2, 3, 4, ...]]')
# Long list of lists
result = '[' + ''.join('[0, 1, 2, 3, 4, ...], ' * 10)[:-2] + ']'
assert value_to_display([long_list] * 10) == result[:70] + ' ...'
# Multiple level lists
assert (value_to_display([[1, 2, 3, [4], 5]] + long_list) ==
'[[1, 2, 3, [...], 5], 0, 1, 2, 3, 4, 5, 6, 7, 8, ...]')
assert value_to_display([1, 2, [DF]]) == '[1, 2, [Dataframe]]'
assert value_to_display([1, 2, [[DF], PANEL]]) == '[1, 2, [[...], Panel]]'
# List of complex object
assert value_to_display([COMPLEX_OBJECT]) == '[defaultdict]'
# List of composed objects
li = [COMPLEX_OBJECT, PANEL, 1, {1: 2, 3: 4}, DF]
result = '[defaultdict, Panel, 1, {1:2, 3:4}, Dataframe]'
assert value_to_display(li) == result
# List starting with a non-supported object (#5313)
supported_types = tuple(get_supported_types()['editable'])
li = [len, 1]
assert value_to_display(li) == '[builtin_function_or_method, 1]'
assert is_supported(li, filters=supported_types)
def test_list_display():
"""Tests for display of lists."""
long_list = list(range(100))
# Simple list
assert value_to_display([1, 2, 3]) == '[1, 2, 3]'
# Long list
assert (value_to_display(long_list) ==
'[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...]')
# Short list of lists
assert (value_to_display([long_list] * 3) ==
'[[0, 1, 2, 3, 4, ...], [0, 1, 2, 3, 4, ...], [0, 1, 2, 3, 4, ...]]')
# Long list of lists
result = '[' + ''.join('[0, 1, 2, 3, 4, ...], '*10)[:-2] + ']'
assert value_to_display([long_list] * 10) == result[:70] + ' ...'
# Multiple level lists
assert (value_to_display([[1, 2, 3, [4], 5]] + long_list) ==
'[[1, 2, 3, [...], 5], 0, 1, 2, 3, 4, 5, 6, 7, 8, ...]')
assert value_to_display([1, 2, [DF]]) == '[1, 2, [Dataframe]]'
assert value_to_display([1, 2, [[DF], PANEL]]) == '[1, 2, [[...], Panel]]'
# List of complex object
assert value_to_display([COMPLEX_OBJECT]) == '[defaultdict]'
# List of composed objects
li = [COMPLEX_OBJECT, PANEL, 1, {1:2, 3:4}, DF]
result = '[defaultdict, Panel, 1, {1:2, 3:4}, Dataframe]'
assert value_to_display(li) == result
# List starting with a non-supported object (#5313)
supported_types = tuple(get_supported_types()['editable'])
li = [len, 1]
assert value_to_display(li) == '[builtin_function_or_method, 1]'
assert is_supported(li, filters=supported_types)
def test_ellipses(tmpdir):
"""
Test that we're adding a binary ellipses when value_to_display of
a collection is too long and binary.
For issue 6942
"""
# Create binary file with all bytes
file = tmpdir.new(basename='bytes.txt')
file.write_binary(bytearray(list(range(255))))
# Read bytes back
buffer = file.read(mode='rb')
# Assert that there's a binary ellipses in the representation
assert b' ...' in value_to_display(buffer)
def make_remote_view(data, settings, more_excluded_names=None):
"""
Make a remote view of dictionary *data*
-> globals explorer
"""
from spyder.widgets.variableexplorer.utils import (get_human_readable_type,
get_size, get_color_name, value_to_display)
assert all([name in REMOTE_SETTINGS for name in settings])
data = get_remote_data(data, settings, mode='editable',
more_excluded_names=more_excluded_names)
remote = {}
for key, value in list(data.items()):
view = value_to_display(value, truncate=settings['truncate'],
minmax=settings['minmax'])
remote[key] = {'type': get_human_readable_type(value),
'size': get_size(value),
'color': get_color_name(value),
'view': view}
return remote
