dashlab 0.2.2__tar.gz → 0.3.1__tar.gz

{dashlab-0.2.2 → dashlab-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dashlab
-Version: 0.2.2
+Version: 0.3.1
 Summary: A Python package for dashboard and data visualization tools.
 Author-email: Abdul Saboor <asaboor.my@outlook.com>
 License-Expression: MIT

{dashlab-0.2.2 → dashlab-0.3.1}/dashlab/_internal.py

@@ -279,13 +279,14 @@ _general_css = {
         "75%": { "content": "'●●●●●'" }, "100%": { "content": "''" },
     },
     '< .dl-dashboard > .other-area:not(:empty)': { # to distinguish other area when not empty
-        'border-top': '1px inset var(--jp-border-color2, #8988)',
+        'border-top': '0.2px inset var(--jp-border-color2, #8988)',
     },
     '.widget-vslider, .jupyter-widget-vslider': {'width': 'auto'}, # otherwise it spans too much area
     '.content-width-button.jupyter-button, .content-width-button .jupyter-button': {
             'width':'max-content',
             'padding-left': '8px', 'padding-right': '8px',
     },
+    '.widget-gridbox, .jupyter-widget-gridbox': {'overflow': 'unset'}, # unexpected scrollbars in gridbox
     '> * .widget-box': {'flex-shrink': 0}, # avoid collapse of boxes,
     '.js-plotly-plot': {'flex-grow': 1}, # stretch parent, rest is autosize stuff
     '.columns':{

{dashlab-0.2.2 → dashlab-0.3.1}/dashlab/_version.py

@@ -1,4 +1,4 @@
 # This  is automatically updated at build time, do not edit manually.
 # Double qoites are checked here
 
-__version__ = "0.2.2" 
+__version__ = "0.3.1" 

{dashlab-0.2.2 → dashlab-0.3.1}/dashlab/base.py

@@ -109,7 +109,7 @@ _useful_traits =  [
 ]
 # for validation
 _pmethods = ['set_css','set_layout','update','gather','_handle_callbacks']
-_pattrs = ['_groups','groups','outputs','params', 'changed','isfullscreen', 'children', 'layout','comm']
+_pattrs = ['params','changed','isfullscreen', 'children', 'layout','comm']
 _omethods = ["_interactive_params"]
 
 class _DashMeta(type):
@@ -184,7 +184,15 @@ _docs = {
     - Dynamic widget property updates
     - Built-in fullscreen support
     """,
-    "css_info": re.sub(r'\bcode(\[.*?\])?\`', '`', _build_css.__doc__, flags=re.DOTALL) # inline code` or code['css']` not supported is dashlab itself
+    "css_info": re.sub(r'\bcode(\[.*?\])?\`', '`', _build_css.__doc__, flags=re.DOTALL), # inline code` or code['css']` not supported is dashlab itself
+    "gather": """        
+        - Name of widgets from params or output widgets from callbacks by their CSS class names (e.g. 'out-stats').
+        - Special group names: `*all`, `*out`, `*ctrl`, `*repr` for all widgets, outputs, controls, representation widgets respectively.
+          - Special groups support exclusion patterns with '!' suffix (e.g. '*all!debug.*', '*ctrl!btn.*' to exclude specific widgets or regex patterns from the group).
+          - Exclusion patterns can be exact names or regex patterns and are applied only to the widgets in the specified group.
+        - Regex patterns to match full widget names (e.g. 'fig.*' to match 'fig1', 'fig2' etc.). Only raises error if regex is invalid, not if no matches found.
+        - Direct DOMWidget instances can also be passed inside list in any order to include external widgets not in params/outputs.
+    """,
 }
 
 def _expose_widget(v):
@@ -194,6 +202,15 @@ def _expose_widget(v):
         return v.value
     return v
 
+def _used_widgets(box): # recursively find used widget names in layout
+    used_names = {box._kwarg} if hasattr(box, '_kwarg') else set() # box itself can be a widget with _kwarg
+    for w in box.children:
+        if isinstance(w, ipw.Box):
+            used_names.update(_used_widgets(w))
+        elif hasattr(w, '_kwarg') and w._kwarg not in used_names:
+            used_names.add(w._kwarg)
+    return used_names
+
 @_add_traits
 @_fix_init_sig
 @_format_docs(**_docs)
@@ -234,7 +251,7 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
     # Create and layout
     dash = MyDashboard()
     dash.set_layout(
-        left_sidebar=dash.groups.controls,  # controls on left
+        left_sidebar=['*ctrl'],  # control widgets on left
         center= ipw.VBox(dash.gather('fig', ipw.HTML('Showing Stats'), # plot and stats in a VBox explicitly
     )
     
@@ -281,7 +298,6 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
         self.__app.layout.position = 'relative' # contain absolute items inside
         self.__app._size_to_css = _size_to_css # enables em, rem
         self.__app._user_layout = {} # store user layout for dynamic updates
-        self.__app._used_names = set() # store used names to avoid duplicates, handled in set_layout and gather functions
         self.__other = ipw.VBox().add_class('other-area') # this should be empty to enable CSS perfectly, unless filled below
         self.update = self.__update # needs avoid checking in metaclass, but restric in subclasses, need before setup
         self.__setup()
@@ -308,7 +324,11 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
         for child in self.children:
             if hasattr(child, '_kwarg') and child._kwarg in wparams: # keep only in params, not all, like button, and outputs
                 wparams[child._kwarg] = child # Exposes widgets in params for setting options inside callbacks to trigger updates in chain
-        
+
+        # Make sure widgets are not used from any other instance, which can cause side effects
+        for k, w in wparams.items():
+            self.__mark_instance(k, w, check=True)
+            
         self.set_trait('params', namedtuple('InteractiveParams', wparams.keys())(**wparams))
         
         # Need to fix kwargs_widgets too
@@ -324,6 +344,8 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
         self.children += (*extras, self.__style_html) # add extra widgets to box children
         self.out.add_class("out-main")
         self.out._kwarg = "out-main" # needs to be in all widgets
+        self.__mark_instance("out-main", self.out)
+        self.__out_main = self.out # keep a reference, so if user changes self.out, we still have it     
 
         for w in self.kwargs_widgets:
             c = getattr(w, '_kwarg','')
@@ -331,6 +353,13 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
             getattr(w, 'add_class', lambda v: None)(c) # for grid area
             
         self._handle_callbacks() # collects callbacks and run updates
+        self.set_css() # apply default CSS
+    
+    def __mark_instance(self, name, widget, check=False):
+        if isinstance(widget,DOMWidget): # check used only for params widgets
+            if check and hasattr(widget, '_dl_instance_id') and widget._dl_instance_id != self.__css_class:
+                raise ValueError(f"Widget {name!r} is already used in another Dashboard instance, use a unique widget for each instance to avoid side effects!")
+            widget._dl_instance_id = self.__css_class # mark as used in this instance
         
     def __order_widgets(self, outputs):
         kw_map = {w._kwarg: w for w in self.params if hasattr(w, '_kwarg') and isinstance(w, DOMWidget)}
@@ -343,7 +372,7 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
         # 2) outputs in registration order and shoould have _kwarg internally
         ordered.update({out._kwarg: out for out in outputs})
         # 3) main output
-        ordered["out-main"] = self.out
+        ordered["out-main"] = self.__out_main
         # 4) anything else with _kwarg not yet included
         ordered.update({name: w for name, w in kw_map.items() if name not in ordered})
         return ordered 
@@ -355,7 +384,7 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
         
         outputs = self.__func2widgets() # build stuff, before actual interact
         self.__all_widgets = self.__order_widgets(outputs) # save it once for sending to app layout set afterwards
-        self._groups = self.__create_groups(self.__all_widgets) # create groups of widgets
+        self.__groups = self.__create_groups(self.__all_widgets) # create groups of widgets
         if self.__app._user_layout:
             self.set_layout(**self.__app._user_layout) # this will reset new and old outputs in layout
         else:
@@ -391,48 +420,113 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
                     raise type(e)(f"In {key!r} of layout: {e}") from e # better error message     
         return layout_widgets
     
-    def gather(self, *widgets: 'str | DOMWidget') -> 'tuple[DOMWidget]':
+    def __unpack_group(self, pattern, groups):
+        group, excp = pattern.split('!',1) if '!' in pattern else (pattern, '')
+        exclude = []
+        if excp.strip(): # only try to exclude if excp is not empty or just whitespace
+            try:
+                exclude = [name for name in self.__all_widgets if re.fullmatch(excp, name)]
+            except re.error as e:
+                raise ValueError(f"Invalid exclusion regex pattern {excp!r} in {pattern!r}.\n{e}") from e
+        
+        if group == '*all':
+            return [k for k in self.__all_widgets if k not in exclude]
+        elif group == '*out':
+            return [n for n in self.__groups.outputs if n not in exclude]
+        elif group == '*ctrl':
+            return [n for n in self.__groups.controls if n not in exclude]
+        elif group == '*repr':
+            return [n for n in self.__groups.others if n not in exclude]
+        else:
+            raise ValueError(f"Invalid special group name {group!r}, valid names are: {groups} followed by optional '!name|regex...' exclusion")
+    
+    @_format_docs(**_docs)
+    def gather(self, *widgets: 'str | DOMWidget', verbose: bool=False) -> tuple[DOMWidget]:
         """Get list of widgets by names or general widgets for layout configuration.
         This can be used to collect widgets to embed at any nesting level in layout.
         
-        **Parameters**:         
+        **Parameters** (str | DOMWidget):         
+        {gather}
+        Use `verbose=True` to print matched widgets for each pattern to ensure correct matching.
+        
+        **Returns**: List of DOMWidget instances corresponding to the provided names or instances.      
 
-        - widgets (str | DOMWidget): Widget names as strings or widget instances.
+        **Example**:       
 
-        **Returns**:         
+        ```python
+        # Basic usage
+        widgets = dash.gather('fig1', 'fig2', 'out-stats')
 
-        - List of DOMWidget instances corresponding to the provided names or instances.
+        # Special groups
+        all_controls = dash.gather('*ctrl')
+        all_outputs = dash.gather('*out')
 
-        **Example**:       
+        # Groups with exclusions
+        controls_no_buttons = dash.gather('*ctrl!btn.*')
+        all_except_debug = dash.gather('*all!.*debug.*')
 
-        ```python
-        # fig is a FigureWidget param, out-stats is a callback output
-        app.set_layout(
-            left_sidebar = ['x','y'], # or dash.gather('x','y') is same
-            center = app.TabsWidget(
-                app.gether('fig', ipw.HTML('Showing Stats'), 'out-stats')
-            ) # Not possible to pass names list directly inside a nested widget container, so use gather in nesting levels
-        ) # app is instance of DashboardBase
-        # Placed (FigureWidget, HTML, Output) at, can be used in set_layout
+        # Regex patterns
+        fig_widgets = dash.gather('fig.*')  # fig1, fig2, fig_debug
+        numbered = dash.gather('.*[0-9].*')  # any widget with numbers at end
+
+        # Mixed patterns
+        result = dash.gather('fig1', '*ctrl!btn.*', external_widget)
+
+        # Verbose output with colors
+        widgets = dash.gather('*all!debug.*', verbose=True)
+        # Shows: [gather (group)]: *all!debug.* → fig1,fig2,x,y,out-stats
         ```
-        
-        **⚠️ Important**: Widgets gathered but not actually used in `set_layout()` will be marked as "used" 
-        and will NOT appear in the layout. Only call `gather()` when you intend to pass the result to `set_layout()`.
         """
-        collected = []
+        specials = ['*all','*out','*ctrl','*repr']
+        Ws, LC = self.__all_widgets, [name.lower() for name in self.__all_widgets] # all widgets by name and lower case for case insensitive search
+    
+        collected = [] # And collect included names keeping exluded out
         for name in widgets:
             if isinstance(name, str):
-                if name in self.__all_widgets:
-                    collected.append(self.__all_widgets[name])
-                    self.__app._used_names.add(name) # mark as used
+                if not name.strip():  # Handle empty strings and whitespace
+                    raise ValueError(f"Invalid widget name {name!r} - empty strings not allowed")
+                
+                if name in Ws: # catch all names without regex first and exlcuded above
+                    collected.append(Ws[name])
+                    if verbose:
+                        print(f"\033[92m[gather (exact)]\033[0m: {name} → {name}")
+                elif name.lower() in LC: # case insensitive match
+                    raise ValueError(f"Widget name {name!r} not found, did you mean {list(Ws)[LC.index(name.lower())]!r}? Widget names are case-sensitive.")
+                elif name.startswith('*'): # special groups
+                    names = []
+                    try:
+                        names = self.__unpack_group(name, specials)
+                        collected.extend([Ws[n] for n in names]) # already filtered above
+                    finally:
+                        if verbose:
+                            print(f"\033[94m[gather (group)]\033[0m: {name} → {','.join(names) if names else 'No matches'}")
                 else:
-                    raise ValueError(f"Invalid widget name {name!r}. Valid names are: {list(self.__all_widgets.keys())}")
+                    matches = []
+                    try:
+                        matches = [wname for wname in Ws.keys() if re.fullmatch(name, wname)]
+                        if matches:
+                            collected.extend([Ws[wname] for wname in matches])
+                        elif name.isidentifier(): # if simple name, raise error
+                            raise ValueError(f"Invalid widget name {name!r}. Valid names: {list(Ws.keys())}, specials: {specials}")
+                    except re.error as e: # only raise error if regex is invalid, not if no matches found
+                        raise ValueError(
+                            f"Invalid widget name {name!r}.\n"
+                            f"Valid names: {list(Ws.keys())}\n"
+                            f"Special groups: {specials}, optionally followed by exclusion '!name|regex...'\n"
+                            f"regex patterns to match full name in params/outputs are also supported.\n{e}")
+                    finally:
+                        if verbose:
+                            print(f"\033[93m[gather (regex)]\033[0m: {name} → {','.join(matches) if matches else 'No matches'}")
+                        
             elif isinstance(name, ipw.DOMWidget):
                 collected.append(name)
+                if verbose:
+                    print(f"\033[95m[gather (widget)]\033[0m: {type(name).__name__} → Direct widget")
             else:
                 raise TypeError(f"Each item must be a string or DOMWidget, got {type(name).__name__}")
         return tuple(collected)
     
+    @_format_docs(gather = textwrap.indent(_docs['gather'], '    '))
     def set_layout(self, 
         header: 'list[str, DOMWidget] | DOMWidget' = None, 
         center: 'list[str, DOMWidget] | DOMWidget' = None, 
@@ -452,15 +546,19 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
 
         **Parameters**:  
 
-        - Content Areas (list/tuple of widget names):
+        - Content Areas (list[str, DOMWidget] | DOMWidget):
             - header: Widgets at top
             - center: Main content area (uses CSS Grid)
             - left_sidebar: Left side widgets
             - right_sidebar: Right side widgets  
             - footer: Bottom widgets
-            - Each of above must be of type `list[str, DOMWidget] | DOMWidget` of widgets/ params names if given. 
-                - To get params/outputs by names at a nesting level, use `gather()` method, e.g. `center = TabsWidget(dash.gather('fig', 'out-stats'))`
-                - If a single widget is passed, it will be used directly, if a list/tuple is passed, it will be wrapped in a VBox (except center which uses GridBox).
+        
+        Each of content areas expect `list[str, DOMWidget] | DOMWidget` of widgets/ params names if given. See details below:
+        
+        - If a single widget is passed, it will be used directly. If None, the area will be hidden.
+        - To get params/outputs by names at a nesting level, use `gather()` method, e.g. `center = TabsWidget(dash.gather('fig', 'out-stats'))`
+        - If a list/tuple is passed, it will be wrapped in a VBox (except center which uses GridBox).{gather}
+        
         - Grid Properties:
             - pane_widths: list[str] - Widths for [left, center, right]
             - pane_heights: list[str] - Heights for [header, center, footer]
@@ -476,8 +574,8 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
 
         ```python
         dash.set_layout( # dash is an instance of DashboardBase
-            left_sidebar=dash.groups.controls,
-            center=['fig', *dash.groups.outputs],
+            left_sidebar=['*ctrl'],  # control widgets on left
+            center=['fig', '*out'], # fig and other outputs in center
             pane_widths=['200px', '1fr', 'auto'],
             pane_heights=['auto', '1fr', 'auto'],
             grid_gap='1rem'
@@ -505,11 +603,11 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
                 self.__app.set_trait(key, value.add_class(key.replace('_','-'))) # for user CSS
             elif value: # class own traits and Layout properties are linked here
                 self.__app.set_trait(key, value)
-               
-        self.__other.children += tuple([v for k,v in self.__all_widgets.items() if k not in self.__app._used_names])
+                
         del layout_widgets # release references
-        self.__app._used_names.clear() # reset used names, will be filled again via gather internally
-
+        if names := _used_widgets(self.__app):
+            self.__other.children += tuple([v for k,v in self.__all_widgets.items() if k not in names])
+        
         # We are adding a reaonly isfullscreen trait set through button on parent class
         fs_btn = FullscreenButton()
         fs_btn.observe(lambda c: self.set_trait('isfullscreen',c.new), names='isfullscreen') # setting readonly property
@@ -573,11 +671,9 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
         cent_sl = f"{main_sl} > .center"
         _css = _build_css(('.dl-dashboard > .dl-DashApp',),_general_css)
 
-        fs_css = main.pop(':fullscreen',{}) or main.pop('^:fullscreen',{}) # both valid
-        if fs_css: # fullscreen css given by user, full screen is top interact, not inside one as button is there
-            _css += ('\n' + _build_css((f".{self.__css_class}.widget-interact.dl-dashboard:fullscreen > .dl-DashApp",), fs_css))
-        
         if main:
+            if fs_css := main.pop(':fullscreen',{}) or main.pop('^:fullscreen',{}): # both valid
+                _css += ('\n' + _build_css((f".{self.__css_class}.widget-interact.dl-dashboard:fullscreen > .dl-DashApp",), fs_css))
             _css += ("\n" + _build_css((main_sl,), main))
         if center:
             _css += ("\n" + _build_css((cent_sl,), center))
@@ -731,6 +827,7 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
             callbacks.append(new_func) 
             
             if out is not None:
+                self.__mark_instance(out._kwarg, out) 
                 outputs.append(out)
         
         self.__icallbacks = tuple(callbacks) # set back
@@ -793,15 +890,10 @@ class DashboardBase(ipw.interactive, metaclass = _metaclass):
                 w._hinting_btn_update = update_hint # keep reference to clean up before adding next time
                
     @property
-    def outputs(self) -> tuple: 
-        return tuple([w for _, w in self.__all_widgets.items() if isinstance(w, ipw.Output)])
+    def outputs(self) -> tuple: raise DeprecationWarning("outputs property is deprecated, use gather('*out') instead.")
 
     @property
-    def groups(self) -> namedtuple: 
-        """NamedTuple of widget groups: controls, outputs, others."""
-        if not hasattr(self, '_groups'):
-            self._groups = self.__create_groups(self.__all_widgets)
-        return self._groups
+    def groups(self) -> namedtuple: raise DeprecationWarning("groups property is deprecated, use gather('*ctrl'), gather('*out'), gather('*repr') instead to pick a group of widgets.")
     
     def __run_updates(self, **kwargs):
         with self.__user_ctx(), print_error():

{dashlab-0.2.2 → dashlab-0.3.1}/dashlab/core.py

@@ -138,7 +138,7 @@ class Dashboard(DashboardBase):
         print(x+5,y)
     
     # after adding callbacks, we can set CSS and layout to include all output widgets created
-    app.set_layout(left_sidebar=app.groups.controls,center=app.groups.outputs)
+    app.set_layout(left_sidebar=['*ctrl'],center=['*out'])
     
     app # at end of cell to display the app
     ```

{dashlab-0.2.2 → dashlab-0.3.1}/dashlab/static/listw.css

@@ -2,10 +2,10 @@
     display: flex;
     flex-direction: column;
     overflow-y: auto; /* user can set max height, so allow this */
+    border-radius: 4px;
 }
 
 .list-widget:not(.tabs) {
-    border-radius: 4px;
     margin-block: 0.5em 0.5em;
 }
 
@@ -13,8 +13,6 @@
 .list-widget.tabs {
     flex-direction: row;
     margin-bottom: 0;
-    border-radius: 4px 4px 0 0;
-    border-bottom: 1px inset #8884;
     box-sizing: border-box;
 }
 
@@ -28,7 +26,6 @@
 .list-widget.tabs .list-item {
     flex: 0 1 auto;  /* don't grow, but shrink, and base of auto like browser tabs */
     min-width: 60px;  /* Minimum tab width for usability */
-    border-radius: 4px 4px 0 0;
     margin: 0 1px 0 0;  /* Reduced margin for tighter spacing */
     white-space: nowrap;
     text-align: center;  /* Center text in each tab */
@@ -44,7 +41,6 @@
 /* Selected tab styling */
 .list-widget.tabs .list-item.selected {
     border-bottom: 1px inset var(--accent-color, #8884);
-    border-radius: 4px 4px 0 0;
     border-left: none;
     font-weight: bold;
 }
@@ -98,9 +94,29 @@
     box-shadow: 0 0 1px inset #8884;
     font-weight: bold;
     border-radius: 4px;
-    border-left: 2px solid var(--accent-color, #8884);
+    border-left: 1px solid var(--accent-color, #8884);
 }
 
 .list-item:active {
     transform: scale(0.99);
+}
+
+/* Since TabsWidget does not inherit from AnyWidget, but has ListWidget there, we can use it for CSS */
+
+.tabs-widget .list-widget.tabs {
+    border-radius: 4px 4px 0 0;
+    border-bottom: 1px inset #8884;
+}
+
+.tabs-widget .list-widget.tabs .list-item:hover {
+    border-radius: 4px 4px 0 0;
+}
+
+.tabs-widget .list-item.selected {
+    border-radius: 4px 4px 0 0;
+}
+
+.tabs-widget .tabs-stack {
+    border-radius: 4px;
+    padding: 4px;
 }

{dashlab-0.2.2 → dashlab-0.3.1}/dashlab/static/listw.js

@@ -8,8 +8,8 @@ function render({model, el}) {
     }
 
     function updateTabs() {
-        const tabs = model.get('tabs');
-        el.classList.toggle('tabs', Boolean(tabs));
+        const vert = model.get('vertical');
+        el.classList.toggle('tabs', Boolean(!vert));
     }
     
     function createItem(opt) {
@@ -62,7 +62,7 @@ function render({model, el}) {
     
     model.on('change:description', updateDescription);
     model.on('change:_options', updateList);
-    model.on('change:tabs', updateTabs);
+    model.on('change:vertical', updateTabs);
 
      // Intercept custom messages from the backend
     model.on('msg:custom', (msg) => {

{dashlab-0.2.2 → dashlab-0.3.1}/dashlab/widgets.py

@@ -34,7 +34,7 @@ class ListWidget(AnyWidget,ValueWidget):
     - `value`: Any, currently selected value. 
     - `transform`: Callable, function such that transform(item) -> str, for each item in options. Default is `repr`.
     - `html`: str, HTML representation of the currently selected item through transform.
-    - `tabs`: bool, if True, display as tabs instead of list. This alongwith `ipywidgets.Stack` can be used to create tabbed views like `dashlab.widgets.TabsWidget`.
+    - `vertical`: bool, if False, display as tabs instead of list. If you want to use as tabs, consider using `TabsWidget` instead.
 
     You can set `ListWidget.layout.max_height` to limit the maximum height (default 400px) of the list. The list will scroll if it exceeds this height.
     """
@@ -45,7 +45,7 @@ class ListWidget(AnyWidget,ValueWidget):
     options     = traitlets.List() # only on backend
     value       = traitlets.Any(None, allow_none=True,read_only=True) # only backend
     html        = traitlets.Unicode('',read_only=True, help="html = transform(value)")  # This is only python side
-    tabs        = traitlets.Bool(False,help="If True, display as tabs instead of list").tag(sync=True)
+    vertical    = traitlets.Bool(True,help="If False, display as tabs instead of list").tag(sync=True)
     
     _esm = Path(__file__).with_name('static') / 'listw.js'
     _css = Path(__file__).with_name('static') / 'listw.css'
@@ -136,13 +136,13 @@ class TabsWidget(GridBox):
     """
     titles = traitlets.List([], help="List of tab titles")
     selected_index = traitlets.Int(0, allow_none=True, help="Index of currently selected tab")
-    vertical = traitlets.Bool(False, help="If True, display tabs vertically on left")
     tabs_width = traitlets.Unicode('auto', help="width of tabs when vertical") # can be any valid css width
     tabs_height = traitlets.Unicode('2em', help="height of tabs when horizontal") # can be any valid css height
+    vertical = traitlets.Bool(False, help="If True, display tabs vertically on the left side")
     
     def __init__(self, children=None, titles=None, vertical=False, tabs_width='auto', tabs_height='2em', **kwargs):
-        self._lw = ListWidget(description=None)
-        self._stack = Stack()
+        self._lw = ListWidget(description=None, vertical=vertical)
+        self._stack = Stack().add_class('tabs-stack')
         self._init_titles = titles or [] # store initial titles as list even if no children yet
         super().__init__(**kwargs)
         self.add_class('tabs-widget') # for custom styling
@@ -152,11 +152,9 @@ class TabsWidget(GridBox):
         self.children = children or [] # set children to stack
         self.tabs_width = tabs_width
         self.tabs_height = tabs_height
-        self.vertical = vertical
         self._update_layout(None) # initial layout update
-        
-        traitlets.link((self,'vertical'),(self._lw,'tabs'), transform=(lambda v: not v, lambda v: not v)) 
         traitlets.link((self._lw,'index'),(self,'selected_index')) # on click, it should update selected_index
+        traitlets.link((self._lw,'vertical'),(self,'vertical')) # link vertical to listwidget
     
     @traitlets.observe('selected_index')
     def _validate_selected(self, change):

{dashlab-0.2.2 → dashlab-0.3.1}/dashlab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dashlab
-Version: 0.2.2
+Version: 0.3.1
 Summary: A Python package for dashboard and data visualization tools.
 Author-email: Abdul Saboor <asaboor.my@outlook.com>
 License-Expression: MIT