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 update_dtale_data(player_data): curr_data = get_instance("1") if curr_data is not None: # append data to pre-existing data in D-Tale curr_data = curr_data.data curr_data = curr_data[~(curr_data["name"] == player_data["name"].values[0])] player_data = pd.concat([curr_data, player_data], ignore_index=True) cleanup("1") # load data to D-Tale startup(data_id="1", data=player_data)
def test_build_data_id(): import dtale.global_state as global_state global_state.cleanup() assert global_state.build_data_id() == 1 df = pd.DataFrame([1, 2, 3, 4, 5]) data = {str(idx + 1): df for idx in range(10)} for k, v in data.items(): global_state.set_data(k, v) assert global_state.build_data_id() == 11
def initialize_store(test_data): """Helper function that sets up a default store with some data in it""" global_state.cleanup() global_state.use_default_store() for data_id in ["1", "2"]: global_state.set_data(data_id, test_data) global_state.set_dtypes(data_id, build_dtypes_state(test_data)) global_state.set_settings(data_id, dict(locked=[])) global_state.set_name(data_id, "test_name" + data_id) global_state.set_context_variables( data_id, dict(favorite_words=["foo", "bar", "baz"])) global_state.set_history(data_id, ["foo", "bar", "baz"])
def initialize_store(test_data): """Helper function that sets up a default store with some data in it""" global_state.cleanup() global_state.use_default_store() for data_id in ['1', '2']: global_state.set_data(data_id, test_data) global_state.set_dtypes(data_id, build_dtypes_state(test_data)) global_state.set_settings(data_id, dict(locked=[])) global_state.set_metadata(data_id, dict(name='test_name')) global_state.set_context_variables( data_id, dict(favorite_words=['foo', 'bar', 'baz'])) global_state.set_history(data_id, ['foo', 'bar', 'baz'])
def shutdown_server(): global ACTIVE_HOST, ACTIVE_PORT """ This function that checks if flask.request.environ['werkzeug.server.shutdown'] exists and if so, executes that function """ logger.info("Executing shutdown...") func = request.environ.get("werkzeug.server.shutdown") if func is None: raise RuntimeError("Not running with the Werkzeug Server") func() global_state.cleanup() ACTIVE_PORT = None ACTIVE_HOST = None
def test_use_shelve_store(unittest, tmpdir, test_data): initialize_store(test_data) contents_before = get_store_contents() type_before = get_store_type() directory = tmpdir.mkdir("test_use_shelve_store").dirname global_state.use_shelve_store(directory) contents_after = get_store_contents() type_after = get_store_type() unittest.assertEqual(contents_before, contents_after) unittest.assertNotEqual(type_before, type_after) global_state.cleanup(data_id="1") unittest.assertNotEqual(contents_after, get_store_contents())
def test_cleanup_data_id(): import dtale.global_state as global_state for prop in [ 'data', 'dtypes', 'settings', 'metadata', 'context_variables', 'history' ]: getattr(global_state, 'set_{}'.format(prop))('1', 'test') global_state.cleanup('1') for prop in [ 'data', 'dtypes', 'settings', 'metadata', 'context_variables', 'history' ]: assert getattr(global_state, 'get_{}'.format(prop))('1') is None
def offline_chart(df, chart_type=None, query=None, x=None, y=None, z=None, group=None, agg=None, window=None, rolling_comp=None, barmode=None, barsort=None, yaxis=None, filepath=None, **kwargs): """ Builds the HTML for a plotly chart figure to saved to a file or output to a jupyter notebook :param df: integer string identifier for a D-Tale process's data :type df: :class:`pandas:pandas.DataFrame` :param chart_type: type of chart, possible options are line|bar|pie|scatter|3d_scatter|surface|heatmap :type chart_type: str :param query: pandas dataframe query string :type query: str, optional :param x: column to use for the X-Axis :type x: str :param y: columns to use for the Y-Axes :type y: list of str :param z: column to use for the Z-Axis :type z: str, optional :param group: column(s) to use for grouping :type group: list of str or str, optional :param agg: specific aggregation that can be applied to y or z axes. Possible values are: count, first, last mean, median, min, max, std, var, mad, prod, sum. This is included in label of axis it is being applied to. :type agg: str, optional :param window: number of days to include in rolling aggregations :type window: int, optional :param rolling_comp: computation to use in rolling aggregations :type rolling_comp: str, optional :param barmode: mode to use for bar chart display. possible values are stack|group(default)|overlay|relative :type barmode: str, optional :param barsort: axis name to sort the bars in a bar chart by (default is the 'x', but other options are any of columns names used in the 'y' parameter :type barsort: str, optional :param filepath: location to save HTML output :type filepath: str, optional :param kwargs: optional keyword arguments, here in case invalid arguments are passed to this function :type kwargs: dict :return: possible outcomes are: - if run within a jupyter notebook and no 'filepath' is specified it will print the resulting HTML within a cell in your notebook - if 'filepath' is specified it will save the chart to the path specified - otherwise it will return the HTML output as a string """ instance = startup(url=None, data=df, data_id=999) output = instance.offline_chart(chart_type=chart_type, query=query, x=x, y=y, z=z, group=group, agg=agg, window=window, rolling_comp=rolling_comp, barmode=barmode, barsort=barsort, yaxis=yaxis, filepath=filepath, **kwargs) global_state.cleanup() return output
def test_use_redis_store(unittest, tmpdir, test_data): pytest.importorskip('redislite') initialize_store(test_data) contents_before = get_store_contents() type_before = get_store_type() directory = tmpdir.mkdir('test_use_redis_store').dirname global_state.use_redis_store(directory) contents_after = get_store_contents() type_after = get_store_type() unittest.assertEqual(contents_before, contents_after) unittest.assertNotEqual(type_before, type_after) global_state.cleanup(data_id='1') unittest.assertNotEqual(contents_after, get_store_contents())
def test_cleanup(unittest, test_data): initialize_store(test_data) base_contents = get_store_contents() # should just remove 1 entry, leaving one still in there global_state.cleanup(data_id="2") without_one = get_store_contents() # should remove ALL entries initialize_store(test_data) global_state.cleanup() without_any = get_store_contents() unittest.assertNotEqual(base_contents, without_one, "should have removed one") unittest.assertNotEqual(base_contents, without_any, "should have removed all") unittest.assertNotEqual( without_one, without_any, "first should still have some data" )
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 teardown_module(module): global_state.cleanup() global_state.use_default_store()
def setup_function(function): global_state.cleanup() global_state.use_default_store()
def setup_function(function): global_state.cleanup() predefined_filters.set_filters([])
def teardown_function(function): global_state.cleanup() global_state.use_default_store()
def setup_module(module): global_state.cleanup() global_state.use_default_store()
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 import dtale.global_state as global_state class MockDtaleFlask(Flask): def __init__(self, import_name, reaper_on=True, url=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) 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( 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://localhost:9999/shutdown' assert global_state.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, 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 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, ignore_duplicate=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', 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/5' 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, *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( {'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 kill_instance(data_id: str) -> None: data_id = _format_data_id(data_id) global_state.cleanup(data_id)
def teardown_function(function): global_state.cleanup() predefined_filters.set_filters([])
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 kill_instance(data_id: str) -> None: global_state.cleanup(data_id)