def test_show_ngrok(unittest, builtin_pkg):
from dtale.app import show, get_instance, instances
import dtale.views as views
import dtale.global_state as global_state
orig_import = __import__
mock_flask_ngrok = mock.Mock()
mock_flask_ngrok._run_ngrok = lambda: "ngrok_host"
def import_mock(name, *args, **kwargs):
if name == "flask_ngrok":
return mock_flask_ngrok
return orig_import(name, *args, **kwargs)
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
stack.enter_context(
mock.patch("{}.__import__".format(builtin_pkg), side_effect=import_mock)
)
stack.enter_context(mock.patch("dtale.app.USE_NGROK", True))
stack.enter_context(mock.patch("dtale.app.PY3", True))
mock_run = stack.enter_context(
mock.patch("dtale.app.DtaleFlask.run", mock.Mock())
)
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False))
)
mock_requests = stack.enter_context(mock.patch("requests.get", mock.Mock()))
instance = show(
data=test_data, subprocess=False, name="foo", ignore_duplicate=True
)
assert "http://ngrok_host" == instance._url
mock_run.assert_called_once()
pdt.assert_frame_equal(instance.data, test_data)
tmp = test_data.copy()
tmp["biz"] = 2.5
instance.data = tmp
unittest.assertEqual(
global_state.DTYPES[instance._data_id],
views.build_dtypes_state(tmp),
"should update app data/dtypes",
)
instance2 = get_instance(instance._data_id)
assert instance2._url == instance._url
instances()
assert get_instance(20) is None # should return None for invalid data ids
instance.kill()
mock_requests.assert_called_once()
assert mock_requests.call_args[0][0] == "http://ngrok_host/shutdown"
assert global_state.METADATA["1"]["name"] == "foo"
with ExitStack() as stack:
stack.enter_context(mock.patch("dtale.app.USE_NGROK", True))
stack.enter_context(mock.patch("dtale.app.PY3", False))
with pytest.raises(Exception):
show(data=test_data)
def main(host, port=None, debug=False, no_reaper=False, **kwargs):
"""
Runs a local server for the D-Tale application.
This local server is recommended when you have a pandas object stored in a CSV
or retrievable from :class:`arctic.Arctic` data store.
"""
log_opts = get_log_options(kwargs)
setup_logging(log_opts.get('logfile'), log_opts.get('log_level'),
log_opts.get('verbose'))
# Setup arctic loader
arctic_opts = get_loader_options('arctic', kwargs)
if len([f for f in arctic_opts.values() if f]):
def _arctic_loader():
try:
from arctic import Arctic
from arctic.store.versioned_item import VersionedItem
except BaseException as ex:
logger.exception(
'In order to use the arctic loader you must install ahl.core!'
)
raise ex
host = Arctic(arctic_opts['host'])
lib = host.get_library(arctic_opts['library'])
read_kwargs = {}
start, end = map(arctic_opts.get, ['start', 'end'])
if start and end:
read_kwargs['chunk_range'] = pd.date_range(start, end)
data = lib.read(arctic_opts['node'], **read_kwargs)
if isinstance(data, VersionedItem):
data = data.data
return data
data_loader = _arctic_loader
# Setup csv loader
csv_opts = get_loader_options('csv', kwargs)
if len([f for f in csv_opts.values() if f]):
def _csv_loader():
csv_arg_parsers = { # TODO: add additional arg parsers
'parse_dates': lambda v: v.split(',') if v else None
}
kwargs = {
k: csv_arg_parsers.get(k, lambda v: v)(v)
for k, v in csv_opts.items() if k != 'path'
}
return pd.read_csv(csv_opts['path'], **kwargs)
data_loader = _csv_loader
show(host=host,
port=int(port or find_free_port()),
debug=debug,
subprocess=False,
data_loader=data_loader,
reaper_on=not no_reaper,
**kwargs)
def main(host=None,
port=None,
debug=False,
no_reaper=False,
open_browser=False,
name=None,
**kwargs):
"""
Runs a local server for the D-Tale application.
This local server is recommended when you have a pandas object stored in a CSV
or retrievable from :class:`arctic.Arctic` data store.
"""
log_opts = get_log_options(kwargs)
setup_logging(log_opts.get('logfile'), log_opts.get('log_level'),
log_opts.get('verbose'))
data_loader = check_loaders(kwargs)
show(host=host,
port=int(port or find_free_port()),
debug=debug,
subprocess=False,
data_loader=data_loader,
reaper_on=not no_reaper,
open_browser=open_browser,
name=name,
**kwargs)
def main(host=None,
port=None,
debug=None,
no_reaper=None,
open_browser=False,
name=None,
no_cell_edits=None,
hide_shutdown=None,
github_fork=None,
app_root=None,
hide_drop_rows=None,
**kwargs):
"""
Runs a local server for the D-Tale application.
This local server is recommended when you have a pandas object stored in a CSV
or retrievable from :class:`arctic.Arctic` data store.
"""
log_opts = get_log_options(kwargs)
setup_logging(log_opts.get("logfile"), log_opts.get("log_level"),
log_opts.get("verbose"))
data_loader = check_loaders(kwargs)
# in order to handle the hierarchy of inputs if "--no-cell-edits" is not specified
# then we'll update it to None
allow_cell_edits = False if no_cell_edits is not None else None
kwargs["show_columns"] = (kwargs["show_columns"].split(",")
if kwargs.get("show_columns") else None)
kwargs["hide_columns"] = (kwargs["hide_columns"].split(",")
if kwargs.get("hide_columns") else None)
kwargs["sort"] = ([
tuple(sort.split("|")) for sort in kwargs["sort"].split(",")
] if kwargs.get("sort") else None)
kwargs["locked"] = kwargs["locked"].split(",") if kwargs.get(
"locked") else None
show(host=host,
port=int(port or find_free_port()),
debug=debug,
subprocess=False,
data_loader=data_loader,
reaper_on=not no_reaper,
open_browser=open_browser,
name=name,
allow_cell_edits=allow_cell_edits,
hide_shutdown=hide_shutdown,
github_fork=github_fork,
app_root=app_root,
hide_drop_rows=hide_drop_rows,
**kwargs)
def test_hide_columns():
from dtale.app import show
import dtale.global_state as global_state
global_state.clear_store()
df = pd.DataFrame(dict(a=[1, 2], b=[2, 3]))
with ExitStack() as stack:
stack.enter_context(mock.patch("dtale.app.DtaleFlask", MockDtaleFlask))
stack.enter_context(mock.patch("dtale.app.DtaleFlask.run",
mock.Mock()))
stack.enter_context(
mock.patch("dtale.app.find_free_port",
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch("socket.gethostname",
mock.Mock(return_value="localhost")))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
stack.enter_context(mock.patch("requests.get", mock.Mock()))
instance = show(data=df,
ignore_duplicate=True,
hide_columns=["b"],
subprocess=False)
assert global_state.get_dtypes(instance._data_id)[0]["visible"] is True
assert not global_state.get_dtypes(
instance._data_id)[1]["visible"] is True
def test_show_columns():
from dtale.app import show
data, dtypes = {}, {}
df = pd.DataFrame(dict(a=[1, 2], b=[2, 3]))
with ExitStack() as stack:
stack.enter_context(mock.patch("dtale.app.DtaleFlask", MockDtaleFlask))
stack.enter_context(mock.patch("dtale.global_state.DATA", data))
stack.enter_context(mock.patch("dtale.global_state.DTYPES", dtypes))
stack.enter_context(mock.patch("dtale.app.DtaleFlask.run",
mock.Mock()))
stack.enter_context(
mock.patch("dtale.app.find_free_port",
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch("socket.gethostname",
mock.Mock(return_value="localhost")))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
stack.enter_context(mock.patch("requests.get", mock.Mock()))
instance = show(data=df,
ignore_duplicate=True,
show_columns=["a"],
subprocess=False)
assert dtypes[instance._data_id][0]["visible"]
assert not dtypes[instance._data_id][1]["visible"]
def test_show(unittest):
from dtale.app import show
import dtale.global_state as global_state
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
stack.enter_context(mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
stack.enter_context(mock.patch('dtale.app.find_free_port', mock.Mock(return_value=9999)))
stack.enter_context(mock.patch('socket.gethostname', mock.Mock(return_value='localhost')))
stack.enter_context(mock.patch('dtale.app.logger', mock.Mock()))
stack.enter_context(mock.patch('dtale.views.in_ipython_frontend', mock.Mock(return_value=True)))
get_calls = {'ct': 0}
getter = namedtuple('get', 'ok')
def mock_requests_get(url, verify=True):
if url.endswith('/health'):
is_ok = get_calls['ct'] > 0
get_calls['ct'] += 1
return getter(is_ok)
return getter(True)
stack.enter_context(mock.patch('requests.get', mock_requests_get))
instance = show(data=test_data, subprocess=False, name='foo')
assert instance.__repr__() == ''
assert instance.__str__() == ''
instance.adjust_cell_dimensions(height=600)
# cleanup
global_state.cleanup()
def test_show_colab(unittest, builtin_pkg):
from dtale.app import show, get_instance, instances
import dtale.views as views
import dtale.global_state as global_state
orig_import = __import__
mock_eval_js = mock.Mock()
mock_eval_js.eval_js = lambda _port: "http://colab_host"
def import_mock(name, *args, **kwargs):
if name == "google.colab.output":
return mock_eval_js
return orig_import(name, *args, **kwargs)
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
stack.enter_context(
mock.patch("{}.__import__".format(builtin_pkg),
side_effect=import_mock))
stack.enter_context(mock.patch("dtale.app.USE_COLAB", True))
stack.enter_context(mock.patch("dtale.app.ACTIVE_PORT", 40000))
stack.enter_context(mock.patch("dtale.app.ACTIVE_HOST", "localhost"))
mock_run = stack.enter_context(
mock.patch("dtale.app.DtaleFlask.run", mock.Mock()))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
mock_requests = stack.enter_context(
mock.patch("requests.get", mock.Mock()))
instance = show(data=test_data,
subprocess=False,
name="foo",
ignore_duplicate=True)
assert "http://colab_host" == instance._url
mock_run.assert_called_once()
pdt.assert_frame_equal(instance.data, test_data)
tmp = test_data.copy()
tmp["biz"] = 2.5
instance.data = tmp
unittest.assertEqual(
global_state.get_dtypes(instance._data_id),
views.build_dtypes_state(tmp),
"should update app data/dtypes",
)
instance2 = get_instance(instance._data_id)
assert instance2._url == instance._url
instances()
assert get_instance(
20) is None # should return None for invalid data ids
instance.kill()
mock_requests.assert_called_once()
assert mock_requests.call_args[0][0] == "http://colab_host/shutdown"
def test_failing_show_colab():
from dtale.app import show
with ExitStack() as stack:
stack.enter_context(mock.patch("dtale.app.USE_COLAB", True))
stack.enter_context(mock.patch("dtale.app.DtaleFlask.run",
mock.Mock()))
stack.enter_context(mock.patch("dtale.app.ACTIVE_PORT", 40000))
stack.enter_context(mock.patch("dtale.app.ACTIVE_HOST", "localhost"))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
stack.enter_context(mock.patch("requests.get", mock.Mock()))
instance = show(data=pd.DataFrame([1, 2, 3]))
assert "http://localhost:40000" == instance._url
def test_show(unittest):
from dtale.app import show
import dtale.global_state as global_state
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
stack.enter_context(mock.patch("dtale.app.DtaleFlask.run",
mock.Mock()))
stack.enter_context(
mock.patch("dtale.app.find_free_port",
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch("socket.gethostname",
mock.Mock(return_value="localhost")))
stack.enter_context(mock.patch("dtale.app.logger", mock.Mock()))
stack.enter_context(
mock.patch("dtale.views.in_ipython_frontend",
mock.Mock(return_value=True)))
get_calls = {"ct": 0}
getter = namedtuple("get", "ok")
def mock_requests_get(url, verify=True):
if url.endswith("/health"):
is_ok = get_calls["ct"] > 0
get_calls["ct"] += 1
return getter(is_ok)
return getter(True)
stack.enter_context(mock.patch("requests.get", mock_requests_get))
instance = show(data=test_data, subprocess=False, name="foo")
assert instance.__repr__() == ""
assert instance.__str__() == ""
instance.adjust_cell_dimensions(height=600)
# cleanup
global_state.cleanup()
def test_show(unittest, builtin_pkg):
from dtale.app import show, get_instance, instances
import dtale.views as views
import dtale.global_state as global_state
class MockDtaleFlask(Flask):
def __init__(self,
import_name,
reaper_on=True,
url=None,
app_root=None,
*args,
**kwargs):
kwargs.pop("instance_relative_config", None)
kwargs.pop("static_url_path", None)
super(MockDtaleFlask, self).__init__(import_name, *args, **kwargs)
def run(self, *args, **kwargs):
pass
instances()
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
mock_run = stack.enter_context(
mock.patch("dtale.app.DtaleFlask.run", mock.Mock()))
mock_find_free_port = stack.enter_context(
mock.patch("dtale.app.find_free_port",
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch("socket.gethostname",
mock.Mock(return_value="localhost")))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
mock_requests = stack.enter_context(
mock.patch("requests.get", mock.Mock()))
instance = show(data=test_data,
subprocess=False,
name="foo",
ignore_duplicate=True)
print(instance.main_url())
assert "http://localhost:9999" == instance._url
assert "http://localhost:9999/dtale/main/foo" == instance.main_url()
mock_run.assert_called_once()
mock_find_free_port.assert_called_once()
pdt.assert_frame_equal(instance.data, test_data)
tmp = test_data.copy()
tmp["biz"] = 2.5
instance.data = tmp
unittest.assertEqual(
global_state.DTYPES[instance._data_id],
views.build_dtypes_state(tmp),
"should update app data/dtypes",
)
instance2 = get_instance(instance._data_id)
assert instance2._url == instance._url
instance2 = get_instance("foo")
assert instance2._url == instance._url
pdt.assert_frame_equal(instance2.data, tmp)
instances()
assert get_instance(
20) is None # should return None for invalid data ids
instance.kill()
mock_requests.assert_called_once()
assert mock_requests.call_args[0][
0] == "http://localhost:9999/shutdown"
assert global_state.METADATA["1"]["name"] == "foo"
instance3 = show(data=test_data,
subprocess=False,
name="It's Here",
ignore_duplicate=True)
assert instance3.main_url(
) == "http://localhost:9999/dtale/main/its_here"
pdt.assert_frame_equal(instance3.data, test_data)
with ExitStack() as stack:
mock_run = stack.enter_context(
mock.patch("dtale.app.DtaleFlask.run", mock.Mock()))
mock_find_free_port = stack.enter_context(
mock.patch("dtale.app.find_free_port",
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch("socket.gethostname",
mock.Mock(return_value="localhost")))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
mock_data_loader = mock.Mock(return_value=test_data)
instance = show(
data_loader=mock_data_loader,
subprocess=False,
port=9999,
force=True,
debug=True,
ignore_duplicate=True,
)
assert "http://localhost:9999" == instance._url
mock_run.assert_called_once()
mock_find_free_port.assert_not_called()
mock_data_loader.assert_called_once()
_, kwargs = mock_run.call_args
assert "9999" in instance._url
# RangeIndex test
test_data = pd.DataFrame([1, 2, 3])
with ExitStack() as stack:
stack.enter_context(mock.patch("dtale.app.DtaleFlask", MockDtaleFlask))
stack.enter_context(
mock.patch("dtale.app.find_free_port",
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch("socket.gethostname",
mock.Mock(return_value="localhost")))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
stack.enter_context(mock.patch("dtale.app.logger", mock.Mock()))
instance = show(data=test_data,
subprocess=False,
name="foo",
ignore_duplicate=True)
assert np.array_equal(instance.data["0"].values, test_data[0].values)
with ExitStack() as stack:
stack.enter_context(mock.patch("dtale.app.DtaleFlask", MockDtaleFlask))
stack.enter_context(
mock.patch("dtale.app.find_free_port",
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch("socket.gethostname",
mock.Mock(return_value="localhost")))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
stack.enter_context(mock.patch("dtale.app.logger", mock.Mock()))
stack.enter_context(
mock.patch("dtale.views.in_ipython_frontend",
mock.Mock(return_value=False)))
get_calls = {"ct": 0}
getter = namedtuple("get", "ok")
def mock_requests_get(url, verify=True):
if url.endswith("/health"):
is_ok = get_calls["ct"] > 0
get_calls["ct"] += 1
return getter(is_ok)
return getter(True)
stack.enter_context(mock.patch("requests.get", mock_requests_get))
mock_display = stack.enter_context(
mock.patch("IPython.display.display", mock.Mock()))
mock_iframe = stack.enter_context(
mock.patch("IPython.display.IFrame", mock.Mock()))
instance = show(
data=test_data,
subprocess=True,
name="foo",
notebook=True,
ignore_duplicate=True,
)
mock_display.assert_called_once()
mock_iframe.assert_called_once()
assert mock_iframe.call_args[0][
0] == "http://localhost:9999/dtale/iframe/{}".format(
instance._data_id)
assert type(instance.__str__()).__name__ == "str"
assert type(instance.__repr__()).__name__ == "str"
class MockDtaleFlaskRunTest(Flask):
def __init__(self,
import_name,
reaper_on=True,
url=None,
app_root=None,
*args,
**kwargs):
kwargs.pop("instance_relative_config", None)
kwargs.pop("static_url_path", None)
super(MockDtaleFlaskRunTest,
self).__init__(import_name, *args, **kwargs)
def run(self, *args, **kwargs):
assert self.jinja_env.auto_reload
assert self.config["TEMPLATES_AUTO_RELOAD"]
with mock.patch("dtale.app.DtaleFlask", MockDtaleFlaskRunTest):
show(
data=test_data,
subprocess=False,
port=9999,
debug=True,
ignore_duplicate=True,
)
with mock.patch("dtale.app._thread.start_new_thread",
mock.Mock()) as mock_thread:
show(data=test_data, subprocess=True, ignore_duplicate=True)
mock_thread.assert_called()
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
mock_build_app = stack.enter_context(
mock.patch("dtale.app.build_app", mock.Mock()))
stack.enter_context(
mock.patch("dtale.app.find_free_port",
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch("socket.gethostname",
mock.Mock(return_value="localhost")))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
stack.enter_context(mock.patch("requests.get", mock.Mock()))
show(data=test_data,
subprocess=False,
name="foo",
ignore_duplicate=True)
_, kwargs = mock_build_app.call_args
unittest.assertEqual(
{
"app_root": None,
"host": "localhost",
"reaper_on": True
},
kwargs,
"build_app should be called with defaults",
)
# test adding duplicate column
with ExitStack() as stack:
stack.enter_context(mock.patch("dtale.app.DtaleFlask", MockDtaleFlask))
stack.enter_context(
mock.patch("dtale.app.find_free_port",
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch("socket.gethostname",
mock.Mock(return_value="localhost")))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
stack.enter_context(mock.patch("requests.get", mock.Mock()))
instance = show(
data=pd.DataFrame([dict(a=1, b=2)]),
subprocess=False,
name="foo",
ignore_duplicate=True,
)
with pytest.raises(Exception):
instance.data = instance.data.rename(columns={"b": "a"})
curr_instance_ct = len(global_state.DATA)
show(data=pd.DataFrame([dict(a=1, b=2)]), subprocess=False, name="foo")
assert curr_instance_ct == len(global_state.DATA)
# cleanup
global_state.cleanup()
def test_show(unittest, builtin_pkg):
from dtale.app import show, get_instance, instances
import dtale.views as views
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
mock_run = stack.enter_context(
mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
mock_find_free_port = stack.enter_context(
mock.patch('dtale.app.find_free_port',
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch('socket.gethostname',
mock.Mock(return_value='localhost')))
stack.enter_context(
mock.patch('dtale.app.is_up', mock.Mock(return_value=False)))
mock_requests = stack.enter_context(
mock.patch('requests.get', mock.Mock()))
instance = show(data=test_data, subprocess=False, name='foo')
assert 'http://localhost:9999' == instance._url
mock_run.assert_called_once()
mock_find_free_port.assert_called_once()
pdt.assert_frame_equal(instance.data, test_data)
tmp = test_data.copy()
tmp['biz'] = 2.5
instance.data = tmp
unittest.assertEqual(views.DTYPES[instance._data_id],
views.build_dtypes_state(tmp),
'should update app data/dtypes')
instance2 = get_instance(instance._data_id)
assert instance2._url == instance._url
assert instances()[instance._data_id]._url == instance._url
assert get_instance(
20) is None # should return None for invalid data ids
instance.kill()
mock_requests.assert_called_once()
mock_requests.call_args[0][0] == 'http://localhost:9999/shutdown'
assert views.METADATA['1']['name'] == 'foo'
with ExitStack() as stack:
mock_run = stack.enter_context(
mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
mock_find_free_port = stack.enter_context(
mock.patch('dtale.app.find_free_port',
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch('socket.gethostname',
mock.Mock(return_value='localhost')))
stack.enter_context(
mock.patch('dtale.app.is_up', mock.Mock(return_value=False)))
mock_data_loader = mock.Mock(return_value=test_data)
instance = show(data_loader=mock_data_loader,
subprocess=False,
port=9999,
force=True,
debug=True)
assert 'http://localhost:9999' == instance._url
mock_run.assert_called_once()
mock_find_free_port.assert_not_called()
mock_data_loader.assert_called_once()
_, kwargs = mock_run.call_args
assert '9999' in instance._url
with ExitStack() as stack:
mock_run = stack.enter_context(
mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
stack.enter_context(
mock.patch('dtale.app.find_free_port',
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch('socket.gethostname',
mock.Mock(return_value='localhost')))
stack.enter_context(
mock.patch('dtale.app.is_up', mock.Mock(return_value=True)))
mock_data_loader = mock.Mock(return_value=test_data)
mock_webbrowser = stack.enter_context(mock.patch('webbrowser.get'))
instance = show(data_loader=mock_data_loader,
subprocess=False,
port=9999,
open_browser=True)
mock_run.assert_not_called()
webbrowser_instance = mock_webbrowser.return_value
assert 'http://localhost:9999/dtale/main/3' == webbrowser_instance.open.call_args[
0][0]
instance.open_browser()
assert 'http://localhost:9999/dtale/main/3' == webbrowser_instance.open.mock_calls[
1][1][0]
# RangeIndex test
test_data = pd.DataFrame([1, 2, 3])
with ExitStack() as stack:
stack.enter_context(mock.patch('dtale.app.DtaleFlask.run',
mock.Mock()))
stack.enter_context(
mock.patch('dtale.app.find_free_port',
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch('socket.gethostname',
mock.Mock(return_value='localhost')))
stack.enter_context(
mock.patch('dtale.app.is_up', mock.Mock(return_value=False)))
stack.enter_context(mock.patch('dtale.app.logger', mock.Mock()))
instance = show(data=test_data, subprocess=False, name='foo')
assert np.array_equal(instance.data['0'].values, test_data[0].values)
with ExitStack() as stack:
stack.enter_context(mock.patch('dtale.app.DtaleFlask.run',
mock.Mock()))
stack.enter_context(
mock.patch('dtale.app.find_free_port',
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch('socket.gethostname',
mock.Mock(return_value='localhost')))
stack.enter_context(
mock.patch('dtale.app.is_up', mock.Mock(return_value=False)))
stack.enter_context(mock.patch('dtale.app.logger', mock.Mock()))
stack.enter_context(
mock.patch('dtale.views.in_ipython_frontend',
mock.Mock(return_value=False)))
get_calls = {'ct': 0}
getter = namedtuple('get', 'ok')
def mock_requests_get(url, verify=True):
if url.endswith('/health'):
is_ok = get_calls['ct'] > 0
get_calls['ct'] += 1
return getter(is_ok)
return getter(True)
stack.enter_context(mock.patch('requests.get', mock_requests_get))
mock_display = stack.enter_context(
mock.patch('IPython.display.display', mock.Mock()))
mock_iframe = stack.enter_context(
mock.patch('IPython.display.IFrame', mock.Mock()))
instance = show(data=test_data,
subprocess=True,
name='foo',
notebook=True)
mock_display.assert_called_once()
mock_iframe.assert_called_once()
assert mock_iframe.call_args[0][
0] == 'http://localhost:9999/dtale/iframe/5'
assert type(instance.__str__()).__name__ == 'str'
assert type(instance.__repr__()).__name__ == 'str'
def mock_run(self, *args, **kwargs):
assert self.jinja_env.auto_reload
assert self.config['TEMPLATES_AUTO_RELOAD']
with mock.patch('dtale.app.DtaleFlask.run', mock_run):
show(data=test_data, subprocess=False, port=9999, debug=True)
with mock.patch('dtale.app._thread.start_new_thread',
mock.Mock()) as mock_thread:
show(data=test_data, subprocess=True)
mock_thread.assert_called()
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
mock_build_app = stack.enter_context(
mock.patch('dtale.app.build_app', mock.Mock()))
stack.enter_context(
mock.patch('dtale.app.find_free_port',
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch('socket.gethostname',
mock.Mock(return_value='localhost')))
stack.enter_context(
mock.patch('dtale.app.is_up', mock.Mock(return_value=False)))
stack.enter_context(mock.patch('requests.get', mock.Mock()))
show(data=test_data, subprocess=False, name='foo')
_, kwargs = mock_build_app.call_args
unittest.assertEqual({
'host': 'localhost',
'reaper_on': True
}, kwargs, 'build_app should be called with defaults')
# test adding duplicate column
with ExitStack() as stack:
stack.enter_context(mock.patch('dtale.app.DtaleFlask.run',
mock.Mock()))
stack.enter_context(
mock.patch('dtale.app.find_free_port',
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch('socket.gethostname',
mock.Mock(return_value='localhost')))
stack.enter_context(
mock.patch('dtale.app.is_up', mock.Mock(return_value=False)))
stack.enter_context(mock.patch('requests.get', mock.Mock()))
instance = show(data=pd.DataFrame([dict(a=1, b=2)]),
subprocess=False,
name='foo')
with pytest.raises(Exception):
instance.data = instance.data.rename(columns={'b': 'a'})
# cleanup
views.DATA = {}
views.DTYPES = {}
views.SETTINGS = {}
views.METADATA = {}
def show_loader(**kwargs):
return show(data_loader=lambda: loader_func(**kwargs), **kwargs)
def test_show(unittest):
from dtale.app import show
import dtale.views as views
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
mock_run = stack.enter_context(mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
mock_find_free_port = stack.enter_context(mock.patch('dtale.app.find_free_port', mock.Mock(return_value=9999)))
stack.enter_context(mock.patch('socket.gethostname', mock.Mock(return_value='localhost')))
mock_logger = stack.enter_context(mock.patch('dtale.app.logger', mock.Mock()))
mock_requests = stack.enter_context(mock.patch('requests.get', mock.Mock()))
instance = show(data=test_data, subprocess=False, name='foo')
mock_run.assert_called_once()
mock_find_free_port.assert_called_once()
assert mock_logger.info.call_args[0][0] == 'D-Tale started at: http://localhost:9999'
pdt.assert_frame_equal(instance.data, test_data)
tmp = test_data.copy()
tmp['biz'] = 2.5
instance.data = tmp
unittest.assertEqual(
views.DTYPES[instance._port],
views.build_dtypes_state(tmp),
'should update app data/dtypes'
)
instance.kill()
mock_requests.assert_called_once()
mock_requests.call_args[0][0] == 'http://localhost:9999/shutdown'
assert views.METADATA['9999']['name'] == 'foo'
with ExitStack() as stack:
mock_run = stack.enter_context(mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
mock_find_free_port = stack.enter_context(mock.patch('dtale.app.find_free_port', mock.Mock(return_value=9999)))
mock_data_loader = mock.Mock(return_value=test_data)
instance = show(data_loader=mock_data_loader, subprocess=False, port=9999, debug=True)
mock_run.assert_called_once()
mock_find_free_port.assert_not_called()
mock_data_loader.assert_called_once()
_, kwargs = mock_run.call_args
assert instance._port == '9999'
with ExitStack() as stack:
mock_run = stack.enter_context(mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
stack.enter_context(mock.patch('dtale.app.find_free_port', mock.Mock(return_value=9999)))
stack.enter_context(mock.patch('socket.gethostname', mock.Mock(return_value='localhost')))
mock_data_loader = mock.Mock(return_value=test_data)
mock_webbrowser = stack.enter_context(mock.patch('webbrowser.get'))
instance = show(data_loader=mock_data_loader, subprocess=False, port=9999, open_browser=True)
mock_run.assert_called_once()
webbrowser_instance = mock_webbrowser.return_value
assert 'http://localhost:9999' == webbrowser_instance.open.call_args[0][0]
instance.open_browser()
assert 'http://localhost:9999' == webbrowser_instance.open.mock_calls[1][1][0]
# RangeIndex test
test_data = pd.DataFrame([1, 2, 3])
with ExitStack() as stack:
mock_run = stack.enter_context(mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
mock_find_free_port = stack.enter_context(mock.patch('dtale.app.find_free_port', mock.Mock(return_value=9999)))
stack.enter_context(mock.patch('socket.gethostname', mock.Mock(return_value='localhost')))
mock_logger = stack.enter_context(mock.patch('dtale.app.logger', mock.Mock()))
instance = show(data=test_data, subprocess=False, name='foo')
assert np.array_equal(instance.data['0'].values, test_data[0].values)
with ExitStack() as stack:
stack.enter_context(mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
stack.enter_context(mock.patch('dtale.app.find_free_port', mock.Mock(return_value=9999)))
stack.enter_context(mock.patch('socket.gethostname', mock.Mock(return_value='localhost')))
stack.enter_context(mock.patch('dtale.app.logger', mock.Mock()))
stack.enter_context(mock.patch('dtale.views.in_ipython_frontend', mock.Mock(return_value=False)))
get_calls = {'ct': 0}
getter = namedtuple('get', 'ok')
def mock_requests_get(url):
if url.endswith('/health'):
is_ok = get_calls['ct'] > 0
get_calls['ct'] += 1
return getter(is_ok)
return getter(True)
stack.enter_context(mock.patch('requests.get', mock_requests_get))
mock_display = stack.enter_context(mock.patch('IPython.display.display', mock.Mock()))
mock_iframe = stack.enter_context(mock.patch('IPython.display.IFrame', mock.Mock()))
instance = show(data=test_data, subprocess=False, name='foo')
instance.notebook()
mock_display.assert_called_once()
mock_iframe.assert_called_once()
assert mock_iframe.call_args[0][0] == 'http://localhost:9999/dtale/iframe'
assert type(instance.__str__()).__name__ == 'str'
assert type(instance.__repr__()).__name__ == 'str'
def mock_run(self, *args, **kwargs):
assert self.jinja_env.auto_reload
assert self.config['TEMPLATES_AUTO_RELOAD']
with mock.patch('dtale.app.DtaleFlask.run', mock_run):
show(data=test_data, subprocess=False, port=9999, debug=True)
with mock.patch('dtale.app._thread.start_new_thread', mock.Mock()) as mock_thread:
show(data=test_data, subprocess=True)
mock_thread.assert_called()
# cleanup
views.DATA = {}
views.DTYPES = {}
views.SETTINGS = {}
views.METADATA = {}
from dtale import app app.show(name="Hello", host='localhost', port=5001, debug=True)
def test_open_browser():
from dtale.app import show
import dtale.global_state as global_state
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
mock_run = stack.enter_context(
mock.patch("dtale.app.DtaleFlask.run", mock.Mock()))
stack.enter_context(
mock.patch("dtale.app.find_free_port",
mock.Mock(return_value=9999)))
stack.enter_context(
mock.patch("socket.gethostname",
mock.Mock(return_value="localhost")))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=True)))
mock_data_loader = mock.Mock(return_value=test_data)
mock_browser_proc = stack.enter_context(mock.patch("subprocess.Popen"))
mock_webbrowser = stack.enter_context(mock.patch("webbrowser.open"))
stack.enter_context(
mock.patch("distutils.spawn.find_executable",
mock.Mock(return_value=None)))
stack.enter_context(mock.patch("dtale.env_util.IS_WINDOWS", False))
stack.enter_context(mock.patch("dtale.env_util.IS_LINUX_OR_BSD", True))
stack.enter_context(mock.patch("dtale.env_util.IS_DARWIN", False))
instance = show(
data_loader=mock_data_loader,
subprocess=False,
port=9999,
open_browser=True,
ignore_duplicate=True,
)
mock_run.assert_not_called()
mock_webbrowser.assert_called()
assert mock_webbrowser.mock_calls[0].args[
0] == "http://localhost:9999/dtale/main/{}".format(
instance._data_id)
mock_browser_proc.reset_mock()
mock_webbrowser.reset_mock()
stack.enter_context(
mock.patch("distutils.spawn.find_executable",
mock.Mock(return_value="exists")))
instance.open_browser()
mock_browser_proc.assert_called()
assert mock_browser_proc.mock_calls[0].args[0][
1] == "http://localhost:9999/dtale/main/{}".format(
instance._data_id)
mock_browser_proc.reset_mock()
mock_webbrowser.reset_mock()
stack.enter_context(mock.patch("dtale.env_util.IS_WINDOWS", False))
stack.enter_context(mock.patch("dtale.env_util.IS_LINUX_OR_BSD",
False))
stack.enter_context(mock.patch("dtale.env_util.IS_DARWIN", True))
instance.open_browser()
mock_browser_proc.assert_called()
assert mock_browser_proc.mock_calls[0].args[0][
1] == "http://localhost:9999/dtale/main/{}".format(
instance._data_id)
mock_browser_proc.reset_mock()
mock_webbrowser.reset_mock()
stack.enter_context(mock.patch("dtale.env_util.IS_WINDOWS", True))
stack.enter_context(mock.patch("dtale.env_util.IS_LINUX_OR_BSD",
False))
stack.enter_context(mock.patch("dtale.env_util.IS_DARWIN", False))
instance.open_browser()
mock_webbrowser.assert_called()
assert mock_webbrowser.mock_calls[0].args[
0] == "http://localhost:9999/dtale/main/{}".format(
instance._data_id)
global_state.cleanup()
def test_show_jupyter_server_proxy(unittest):
from dtale.app import show, get_instance, instances
import dtale.views as views
import dtale.global_state as global_state
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
stack.enter_context(mock.patch("dtale.app.JUPYTER_SERVER_PROXY", True))
mock_run = stack.enter_context(
mock.patch("dtale.app.DtaleFlask.run", mock.Mock()))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
stack.enter_context(mock.patch("dtale.app.ACTIVE_PORT", 40000))
stack.enter_context(mock.patch("dtale.app.ACTIVE_HOST", "localhost"))
mock_requests = stack.enter_context(
mock.patch("requests.get", mock.Mock()))
instance = show(data=test_data,
subprocess=False,
name="foo",
ignore_duplicate=True)
assert "/user/{}/proxy/40000".format(
getpass.getuser()) == instance._url
mock_run.assert_called_once()
pdt.assert_frame_equal(instance.data, test_data)
tmp = test_data.copy()
tmp["biz"] = 2.5
instance.data = tmp
unittest.assertEqual(
global_state.DTYPES[instance._data_id],
views.build_dtypes_state(tmp),
"should update app data/dtypes",
)
instance2 = get_instance(instance._data_id)
assert instance2._url == instance._url
instances()
assert get_instance(
20) is None # should return None for invalid data ids
instance.kill()
mock_requests.assert_called_once()
assert mock_requests.call_args[0][
0] == "/user/{}/proxy/40000/shutdown".format(getpass.getuser())
assert global_state.METADATA["1"]["name"] == "foo"
with ExitStack() as stack:
stack.enter_context(mock.patch("dtale.app.JUPYTER_SERVER_PROXY", True))
stack.enter_context(mock.patch("dtale.app.ACTIVE_PORT", 40000))
stack.enter_context(mock.patch("dtale.app.ACTIVE_HOST", "localhost"))
mock_run = stack.enter_context(
mock.patch("dtale.app.DtaleFlask.run", mock.Mock()))
stack.enter_context(
mock.patch("dtale.app.is_up", mock.Mock(return_value=False)))
mock_requests = stack.enter_context(
mock.patch("requests.get", mock.Mock()))
instance = show(
data=test_data,
subprocess=False,
ignore_duplicate=True,
app_root="/custom_root/",
)
assert "/custom_root/40000" == instance._url
mock_run.assert_called_once()
instance2 = get_instance(instance._data_id)
# this is a known bug where get_instance will not work if you've specified an `app_root' in show()
assert not instance2._url == instance._url
instances()
instance.kill()
mock_requests.assert_called_once()
assert mock_requests.call_args[0][0] == "/custom_root/40000/shutdown"
def test_show_jupyter_server_proxy(unittest):
from dtale.app import show, get_instance, instances
import dtale.app as dtale_app
import dtale.views as views
import dtale.global_state as global_state
test_data = pd.DataFrame([dict(a=1, b=2)])
with ExitStack() as stack:
stack.enter_context(mock.patch('dtale.app.JUPYTER_SERVER_PROXY', True))
mock_run = stack.enter_context(
mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
stack.enter_context(
mock.patch('dtale.app.is_up', mock.Mock(return_value=False)))
mock_requests = stack.enter_context(
mock.patch('requests.get', mock.Mock()))
instance = show(data=test_data,
subprocess=False,
name='foo',
ignore_duplicate=True)
assert '/user/{}/proxy/{}'.format(
getpass.getuser(), dtale_app.ACTIVE_PORT) == instance._url
mock_run.assert_called_once()
pdt.assert_frame_equal(instance.data, test_data)
tmp = test_data.copy()
tmp['biz'] = 2.5
instance.data = tmp
unittest.assertEqual(global_state.DTYPES[instance._data_id],
views.build_dtypes_state(tmp),
'should update app data/dtypes')
instance2 = get_instance(instance._data_id)
assert instance2._url == instance._url
instances()
assert get_instance(
20) is None # should return None for invalid data ids
instance.kill()
mock_requests.assert_called_once()
assert mock_requests.call_args[0][
0] == '/user/{}/proxy/{}/shutdown'.format(getpass.getuser(),
dtale_app.ACTIVE_PORT)
assert global_state.METADATA['1']['name'] == 'foo'
with ExitStack() as stack:
stack.enter_context(mock.patch('dtale.app.JUPYTER_SERVER_PROXY', True))
mock_run = stack.enter_context(
mock.patch('dtale.app.DtaleFlask.run', mock.Mock()))
stack.enter_context(
mock.patch('dtale.app.is_up', mock.Mock(return_value=False)))
mock_requests = stack.enter_context(
mock.patch('requests.get', mock.Mock()))
instance = show(data=test_data,
subprocess=False,
ignore_duplicate=True,
app_root='/custom_root/')
assert '/custom_root/{}'.format(dtale_app.ACTIVE_PORT) == instance._url
mock_run.assert_called_once()
instance2 = get_instance(instance._data_id)
# this is a known bug where get_instance will not work if you've specified an `app_root' in show()
assert not instance2._url == instance._url
instances()
instance.kill()
mock_requests.assert_called_once()
assert mock_requests.call_args[0][
0] == '/custom_root/{}/shutdown'.format(dtale_app.ACTIVE_PORT)
