Fixed issue with URL display when using ArcticDB and maintain column …

…ordering when specifying 'locked' on startup

README.md

@@ -769,6 +769,15 @@ global_state.use_arcticdb_store(uri='lmdb:///<path>', library='my_lib')
 dtale.show('my_symbol')
 ```
 
+Or you can set your library using `dtale.show` with a pipe-delimited identifier:
+```python
+import dtale.global_state as global_state
+import dtale
+
+global_state.use_arcticdb_store(uri='lmdb:///<path>')
+dtale.show('my_lib|my_symbol')
+```
+
 You can also do everything using `dtale.show_arcticdb`:
 ```python
 import dtale

dtale/app.py

@@ -35,6 +35,7 @@
 import dtale.config as dtale_config
 from dtale import dtale
 from dtale.cli.clickutils import retrieve_meta_info_and_version, setup_logging
+from dtale.dash_application import views as dash_views
 from dtale.utils import (
     DuplicateDataError,
     build_shutdown_url,
@@ -507,8 +508,6 @@ def handle_data_id(_endpoint, values):
     auth.setup_auth(app)
 
     with app.app_context():
-        from .dash_application import views as dash_views
-
         app = dash_views.add_dash(app)
         return app
 

dtale/cli/loaders/arcticdb_loader.py

@@ -78,7 +78,14 @@ def loader_func(**kwargs):
         if symbol is None:  # select symbol from the UI
             return None
 
-        startup(data=symbol)
+        if library is None and symbol is not None:
+            raise ValueError(
+                "When trying to load the symbol, {}, a library must be specified!".format(
+                    symbol
+                )
+            )
+
+        startup(data="{}|{}".format(library, symbol))
         return symbol
 
     if not library:

dtale/column_filters.py

@@ -32,7 +32,7 @@ def __init__(self, data_id, column, cfg):
         if not dtype:
             if global_state.is_arcticdb:
                 instance = global_state.store.get(data_id)
-                data, _ = format_data(instance.load_data(row_range=[0, 1]))
+                data, _ = format_data(instance.base_df)
                 s = data[column]
             else:
                 s = global_state.get_data(data_id, columns=[column])[column]

dtale/dash_application/charts.py

@@ -607,7 +607,13 @@ def build_hoverable(link, msg):
                 export_png_link,
                 export_csv_link,
             ],
-            style={"position": "absolute", "zIndex": 5, "left": 5, "top": 2},
+            style={
+                "position": "absolute",
+                "zIndex": 5,
+                "left": 5,
+                "top": 2,
+                "height": "100%",
+            },
         )
         return html.Div(
             [links] + make_list(chart), style={"position": "relative", "height": "100%"}
@@ -706,12 +712,14 @@ def cpg_chunker(charts, columns=2):
         return charts
 
     def _formatter(chart):
-        if hasattr(chart, "style"):
-            chart.style.pop("height", None)
         return html.Div(chart, className="col-md-6")
 
     return [
-        html.Div([_formatter(c) for c in chunk], className="row pb-3")
+        html.Div(
+            [_formatter(c) for c in chunk],
+            className="row pb-3",
+            style={"height": "100%"},
+        )
         for chunk in divide_chunks(charts, columns)
     ]
 

dtale/dash_application/layout/layout.py

@@ -1407,10 +1407,12 @@ def build_slider_counts(df, data_id, query_value):
         )
     )
     slider_counts = {
-        v * 20: {"label": "{}% ({:,.0f})".format(v * 20, (v * 2) / 10 * record_ct)}
+        "{}".format(v * 20): {
+            "label": "{}% ({:,.0f})".format(v * 20, (v * 2) / 10 * record_ct)
+        }
         for v in range(1, 6)
     }
-    slider_counts[100]["style"] = {"white-space": "nowrap"}
+    slider_counts["100"]["style"] = {"white-space": "nowrap"}
     return slider_counts
 
 
@@ -2645,7 +2647,8 @@ def show_map_style(show):
             id="chart-inputs",
         ),
         dcc.Loading(
-            html.Div(id="chart-content", style={"max-height": "69vh"}), type="circle"
+            html.Div(id="chart-content", style={"height": "calc(100vh - 380px"}),
+            type="circle",
         ),
         dcc.Textarea(id="copy-text", style=dict(position="absolute", left="-110%")),
     ]

dtale/dash_application/views.py

@@ -1365,7 +1365,7 @@ def display_page(pathname, search):
         settings = global_state.get_settings(params["data_id"]) or {}
         return html.Div(
             charts_layout(df, settings, **params) + saved_charts.build_layout(),
-            className="charts-body",
+            className="charts-body pb-0",
         )
 
     custom_geojson.init_callbacks(dash_app)

dtale/global_state.py

@@ -4,7 +4,7 @@
 
 from six import PY3
 
-from dtale.utils import dict_merge
+from dtale.utils import dict_merge, format_data
 
 try:
     from collections.abc import MutableMapping
@@ -55,6 +55,10 @@ def load_data(self):
     def rows(self, **kwargs):
         return self._rows
 
+    @property
+    def is_large(self):
+        return False
+
     @property
     def data(self):
         return self.load_data()
@@ -138,18 +142,29 @@ def settings(self, settings):
 
 
 class DtaleArcticDBInstance(DtaleInstance):
-    def __init__(self, data, lib, symbol, parent):
+    def __init__(self, data, data_id, parent):
         super(DtaleArcticDBInstance, self).__init__(data)
-        self.lib = lib
+        self.parent = parent
+        data_id_segs = (data_id or "").split("|")
+        symbol = data_id_segs[-1]
+        if len(data_id_segs) > 1:
+            lib_name = data_id_segs[0]
+            if not parent.lib or lib_name != parent.lib.name:
+                parent.update_library(lib_name)
+        self.lib = parent.lib
         self.symbol = symbol
         self._rows = 0
-        if self.lib and self.symbol and self.symbol in parent.symbols:
+        self._cols = 0
+        self._base_df = None
+        if self.lib and self.symbol and self.symbol in self.parent.symbols:
             self._rows = self.lib._nvs.get_num_rows(self.symbol)
+            self._base_df = self.load_data(row_range=[0, 1])
+            self._cols = len(format_data(self._base_df)[0].columns)
 
     def load_data(self, **kwargs):
         from arcticdb.version_store._store import VersionedItem
 
-        if not self.lib.has_symbol(self.symbol):
+        if self.symbol not in self.parent.symbols:
             raise ValueError(
                 "{} does not exist in {}!".format(self.symbol, self.lib.name)
             )
@@ -170,6 +185,18 @@ def rows(self, **kwargs):
             return len(read_result.frame_data.value.data[0])
         return self._rows
 
+    @property
+    def base_df(self):
+        return self._base_df
+
+    @property
+    def is_large(self):
+        if self.rows() > LARGE_ARCTICDB:
+            return True
+        if self._cols > 50:
+            return True
+        return False
+
     @property
     def data(self):
         return self.load_data()
@@ -207,22 +234,22 @@ def update_library(self, library=None):
             return
         if library in self._libraries:
             self.lib = self.conn[library]
-            self._db.clear()
-            self.load_symbols()
+            if library not in self._symbols:
+                self.load_symbols()
         elif library is not None:
             raise ValueError("Library '{}' does not exist!".format(library))
 
     def load_libraries(self):
-        self._libraries = self.conn.list_libraries()
+        self._libraries = sorted(self.conn.list_libraries())
 
     @property
     def libraries(self):
         return self._libraries
 
     def load_symbols(self, library=None):
-        self._symbols[library or self.lib.name] = (
-            self.conn[library] if library else self.lib
-        ).list_symbols()
+        self._symbols[library or self.lib.name] = sorted(
+            (self.conn[library] if library else self.lib).list_symbols()
+        )
 
     @property
     def symbols(self):
@@ -231,7 +258,7 @@ def symbols(self):
     def build_instance(self, data_id, data=None):
         if data_id is None:
             return DtaleInstance(data)
-        return DtaleArcticDBInstance(data, self.lib, data_id, self)
+        return DtaleArcticDBInstance(data, data_id, self)
 
     def get(self, key, **kwargs):
         if key is None:

dtale/utils.py

@@ -861,6 +861,9 @@ def format_data(data, inplace=False, drop_index=False):
     else:
         data = data.reset_index(drop=drop_index)
 
+    if drop_index:
+        index = []
+
     if drop:
         if inplace:
             data.drop("index", axis=1, errors="ignore", inplace=True)