visidata 3.1.1__py3-none-any.whl → 3.3__py3-none-any.whl

visidata/sheets.py

@@ -8,6 +8,7 @@ from visidata import (options, Column, namedlist, SettableColumn, AttrDict, Disp
 TypedExceptionWrapper, BaseSheet, UNLOADED, wrapply,
 clipdraw, clipdraw_chunks, ColorAttr, update_attr, colors, undoAttrFunc, vlen, dispwidth)
 import visidata
+from visidata.utils import colname_letters
 
 
 vd.activePane = 1   # pane numbering starts at 1; pane 0 means active pane
@@ -22,6 +23,7 @@ vd.option('disp_wrap_break_long_words', False, 'break words longer than column w
 vd.option('disp_wrap_replace_whitespace', False, 'replace whitespace with spaces in multiline')
 vd.option('disp_wrap_placeholder', '…', 'multiline string to indicate truncation')
 vd.option('disp_multiline_focus', True, 'only multiline cursor row')
+vd.option('color_multiline_bottom', '', 'color of bottom line of multiline rows')  #2715
 vd.option('color_aggregator', 'bold 255 white on 234 black', 'color of aggregator summary on bottom row')
 
 
@@ -189,6 +191,7 @@ class TableSheet(BaseSheet):
 
         # list of all columns in display order
         self.initialCols = kwargs.pop('columns', None) or type(self).columns
+        self.colname_ctr = 0
         self.resetCols()
 
         self._ordering = list(type(self)._ordering)  #2254
@@ -289,34 +292,53 @@ class TableSheet(BaseSheet):
         pass
 
     def resetCols(self):
-        'Reset columns to class settings'
+        'Reset columns to class settings or constructor settings'
         self.columns = []
         for c in self.initialCols:
             self.addColumn(deepcopy(c))
-            if self.options.disp_expert < c.disp_expert:
+            if c.disp_expert and vd.wantsHelp('nometacols'):
                 c.hide()
 
         self.setKeys(self.columns[:self.nKeys])
 
     def loader(self):
-        'Reset rows and sync load ``source`` via iterload.  Overrideable.'
-        self.rows = []
+        'Reset rows and sync load ``source`` via iterload.  Overridable.'
         try:
-            with vd.Progress(gerund='loading', total=0):
-                for i, r in enumerate(self.iterload()):
-                    if self.precious and i > self.options.max_rows:
-                        break
-                    self.addRow(r)
+            for r in self._iterloader():
+                pass
         except FileNotFoundError:
             return  # let it be a blank sheet without error
 
+    def _iterloader(self):
+        self.rows = []
+        with vd.Progress(gerund='loading', total=0):
+            max_rows = self.options.max_rows
+            for i, r in enumerate(self.iterload()):
+                if self.precious and i >= max_rows:
+                    break
+                self.addRow(r)
+                yield r
+
     def iterload(self):
         'Generate rows from ``self.source``.  Override in subclass.'
         if False:
             yield vd.fail('no iterload for this loader yet')
 
+    def loadStart(self):
+        self.loaditer = self._iterloader()
+
+    def loadSome(self):
+        if not self.loaditer:
+            return False
+        try:
+            next(self.loaditer)
+            return True
+        except StopIteration:
+            self.loaditer = None
+            return False
+
     def afterLoad(self):
-        'hook for after loading has finished.  Overrideable (be sure to call super).'
+        'hook for after loading has finished.  Overridable (be sure to call super).'
         # if an ordering has been specified, sort the sheet
         if self._ordering:
             vd.sync(self.sort())
@@ -508,6 +530,9 @@ class TableSheet(BaseSheet):
         'Raw value at current row and column.'
         return self.cursorCol.getValue(self.cursorRow)
 
+    def getTypedRow(self, rownum):
+        return [c.getTypedValue(self.rows[rownum]) for c in self.availCols]
+
     @property
     def statusLine(self):
         'Position of cursor and bounds of current sheet.'
@@ -537,7 +562,6 @@ class TableSheet(BaseSheet):
     def cursorRight(self, n=1):
         'Move cursor right `n` visible columns (or left if `n` is negative).'
         self.cursorVisibleColIndex += n
-        self.calcColLayout()
 
     def addColumn(self, *cols, index=None):
         '''Insert all *cols* into columns at *index*, or append to end of columns if *index* is None.
@@ -576,7 +600,10 @@ class TableSheet(BaseSheet):
         index = 0
         ccol = self.cursorCol
         if ccol and not ccol.keycol:
-            index = self.columns.index(ccol)+1
+            try:
+                index = self.columns.index(ccol)+1
+            except ValueError: # when all columns are hidden, the one column shown is not in self.columns
+                index = 0
 
         self.addColumn(*cols, index=index)
         firstnewcol = [c for c in cols if not c.hidden][0]
@@ -604,13 +631,6 @@ class TableSheet(BaseSheet):
         for col in cols:
             col.keycol = 0
 
-    def toggleKeys(self, cols):
-        for col in cols:
-            if col.keycol:
-                self.unsetKeys([col])
-            else:
-                self.setKeys([col])
-
     def rowkey(self, row):
         'Return tuple of the key for *row*.'
         return tuple(c.getTypedValue(row) for c in self.keyCols)
@@ -637,39 +657,57 @@ class TableSheet(BaseSheet):
         elif self.topRowIndex > self.nRows-1:
             self.topRowIndex = self.nRows-1
 
+        self.adjustColLayout()
+
+        # calculations that rely on nScreenRows, like bottomRowIndex, need to be done after
+        # col layout has been adjusted. nScreenRows requires an accurate count of
+        # allAggregators, which requires knowing col visibility.
         # check bounds, scroll if necessary
         if self.topRowIndex > self.cursorRowIndex:
             self.topRowIndex = self.cursorRowIndex
         elif self.bottomRowIndex < self.cursorRowIndex:
             self.bottomRowIndex = self.cursorRowIndex
 
-        if self.cursorCol and self.cursorCol.keycol:
-            return
-
-        if self.leftVisibleColIndex >= self.cursorVisibleColIndex:
+    def adjustColLayout(self):
+        '''Move the left visible column to try to keep the cursorCol visible.
+        though the cursorCol cannot be visible when screen is totally filled by keycols.
+        Run calcColLayout() at least once.'''
+        # jumping to a column left of the previously on-screen columns:   put cursorCol as leftmost col
+        # jumping to a column right of the previously on-screen columns:  put cursorCol as far right as possible
+        if self.leftVisibleColIndex > self.cursorVisibleColIndex:        # e.g. when jumping/moving left
             self.leftVisibleColIndex = self.cursorVisibleColIndex
-        else:
-            while True:
-                if self.leftVisibleColIndex == self.cursorVisibleColIndex:  # not much more we can do
-                    break
+        elif self.leftVisibleColIndex < self.cursorVisibleColIndex:      # e.g. when jumping/moving right
+            #move leftVisibleCol until the cursor column fits fully on screen
+            while self.leftVisibleColIndex < self.cursorVisibleColIndex:  #ensures termination even if screen is completely filled by keycols
                 self.calcColLayout()
                 if not self._visibleColLayout:
                     break
+
+                # If the cursor is outside the visible columns currently laid out (1 window wide).
+                # One way to trigger this is with zc, jump to a column never seen yet.
                 mincolidx, maxcolidx = min(self._visibleColLayout.keys()), max(self._visibleColLayout.keys())
                 if self.cursorVisibleColIndex < mincolidx:
-                    self.leftVisibleColIndex -= max((self.cursorVisibleColIndex - mincolidx)//2, 1)
-                    continue
+                    # This case is expected never to occur. _visibleColLayout keys are enumerated from 0,
+                    # so mincolidx is always 0. and cursorVisibleColIndex is kept >= 0 (by checkCursor).
+                    self.leftVisibleColIndex = self.cursorVisibleColIndex
+                    break
                 elif self.cursorVisibleColIndex > maxcolidx:
-                    self.leftVisibleColIndex += max((maxcolidx - self.cursorVisibleColIndex)//2, 1)
+                    # some cases:  1) jumping rightward, so cursor has just moved to a column that is offscreen to the right
+                    #              2) when keycols fill entire screen
+                    self.leftVisibleColIndex += 1
                     continue
 
                 cur_x, cur_w = self._visibleColLayout[self.cursorVisibleColIndex]
-                if cur_x+cur_w < self.windowWidth:  # current columns fit entirely on screen
+                if cur_x+cur_w < self.windowWidth-1:  # current columns fit entirely on screen
                     break
                 self.leftVisibleColIndex += 1  # once within the bounds, walk over one column at a time
 
+        if self.leftVisibleColIndex == self.cursorVisibleColIndex:  #will happen after cursor: jumped left, jumped right, or stayed in place
+            self.calcColLayout()
+
     def calcColLayout(self):
-        'Set right-most visible column, based on calculation.'
+        '''Set right-most visible column, based on calculation.
+        Assign x coordinates and width to every column that fits on screen, visible or hidden.'''
         minColWidth = dispwidth(self.options.disp_more_left)+dispwidth(self.options.disp_more_right)+2
         sepColWidth = dispwidth(self.options.disp_column_sep)
         winWidth = self.windowWidth
@@ -678,18 +716,28 @@ class TableSheet(BaseSheet):
         vcolidx = 0
         for vcolidx, col in enumerate(self.availCols):
             width = self.calcSingleColLayout(col, vcolidx, x, minColWidth)
-            if width:
-                x += width+sepColWidth
-            if x > winWidth-1:
+            if width is not None:
+                if x < winWidth-1:
+                    self._visibleColLayout[vcolidx] = [x, width]
+                    x += width+sepColWidth
+            if x >= winWidth-1:
                 break
 
         self.rightVisibleColIndex = vcolidx
 
     def calcSingleColLayout(self, col:Column, vcolidx:int, x:int=0, minColWidth:int=4):
-            if col.width is None and len(self.visibleRows) > 0:
-                vrows = self.visibleRows if self.nRows > 1000 else self.rows[:1000]  #1964
+            '''Return the width, for key columns, or for columns that are rightward of
+            the leftmost visibleCol, even if they are offscreen or hidden. Return
+            None for columns left of cursorVisibleColIndex, if they are not key columns.'''
+            # We use a slice of rows that is similar to self.visibleRows but simpler,
+            # and larger. The goal is to avoid using nFooterRows. Because nFooterRows
+            # cannot in general be calculated properly until after calcColLayout() has
+            # determined which columns are visible.
+            vrows = self.rows[self.topRowIndex:self.topRowIndex+self.windowHeight]
+            if col.width is None and len(vrows) > 0:
+                measure_rows = vrows if self.nRows > 1000 else self.rows[:1000]  #1964
                 # handle delayed column width-finding
-                col.width = max(col.getMaxWidth(vrows), minColWidth)
+                col.width = max(col.getMaxWidth(measure_rows), minColWidth)
                 if vcolidx < self.nVisibleCols-1:  # let last column fill up the max width
                     col.width = min(col.width, self.options.default_width)
 
@@ -699,9 +747,10 @@ class TableSheet(BaseSheet):
             if vcolidx >= self.nVisibleCols and vcolidx == self.cursorVisibleColIndex:
                 width = self.options.default_width
 
+            #subtract 1 character of empty space from windowWidth, for the margin to the right of the sheet
+            width = min(width, self.windowWidth-x-1)
             width = max(width, 1)
             if col in self.keyCols or vcolidx >= self.leftVisibleColIndex:  # visible columns
-                self._visibleColLayout[vcolidx] = [x, min(width, self.windowWidth-x)]
                 return width
 
 
@@ -744,7 +793,7 @@ class TableSheet(BaseSheet):
                 clipdraw(scr, y+i, x, name, hdrcattr, w=colwidth)
             vd.onMouse(scr, x, y+i, colwidth, 1, BUTTON3_RELEASED='rename-col')
 
-            if C and x+colwidth+len(C) < self.windowWidth and y+i < self.windowHeight:
+            if C and x+colwidth+dispwidth(C) < self.windowWidth and y+i < self.windowHeight:
                 scr.addstr(y+i, x+colwidth, C, sepcattr.attr)
 
         clipdraw(scr, y+h-1, min(x+colwidth, self.windowWidth-1)-dispwidth(T), T, hdrcattr)
@@ -935,10 +984,12 @@ class TableSheet(BaseSheet):
                 colseps = [topsep] + [midsep]*(height-2) + [botsep]
                 endseps = [endtopsep] + [endmidsep]*(height-2) + [endbotsep]
                 keyseps = [keytopsep] + [keymidsep]*(height-2) + [keybotsep]
+                color_multiline_bottom = colors.get_color('color_multiline_bottom', 2)
             else:
                 colseps = [colsep]
                 endseps = [endsep]
                 keyseps = [keysep]
+                color_multiline_bottom = 0
 
             for vcolidx, (col, cellval, lines) in displines.items():
                     if vcolidx not in self._visibleColLayout:
@@ -957,6 +1008,7 @@ class TableSheet(BaseSheet):
 
                     cattr = self._colorize(col, row, cellval)
                     cattr = update_attr(cattr, basecellcattr)
+                    bottomcattr = update_attr(cattr, color_multiline_bottom) if height > 1 else cattr
 
                     note = getattr(cellval, 'note', None)
                     notewidth = 1 if note else 0
@@ -984,10 +1036,10 @@ class TableSheet(BaseSheet):
                         for attr, text in chunks:
                             prechunks.append((attr, text[hoffset:]))
 
-                        clipdraw_chunks(scr, y, x, prechunks, cattr, w=colwidth-notewidth)
+                        clipdraw_chunks(scr, y, x, prechunks, cattr if i < height-1 else bottomcattr, w=colwidth-notewidth)
                         vd.onMouse(scr, x, y, colwidth, 1, BUTTON3_RELEASED='edit-cell')
 
-                        if sepchars and x+colwidth+dispwidth(sepchars) <= self.windowWidth:
+                        if sepchars and x+colwidth+dispwidth(sepchars) <= self.windowWidth-1:
                             scr.addstr(y, x+colwidth, sepchars, sepcattr.attr)
 
             for notefunc in vd.rowNoters:
@@ -998,6 +1050,11 @@ class TableSheet(BaseSheet):
 
             return height
 
+    def incremented_colname(self):
+        vd.addUndo(setattr, self, 'colname_ctr', self.colname_ctr)
+        self.colname_ctr += 1
+        return colname_letters(self.colname_ctr)
+
 vd.rowNoters = [
     # f(sheet, row) -> character to be displayed on the left side of row
 ]
@@ -1048,8 +1105,9 @@ class SequenceSheet(Sheet):
 
         self.rows = []
         # add the rest of the rows
+        max_rows = self.options.max_rows
         for i, r in enumerate(vd.Progress(itsource, gerund='loading', total=0)):
-            if self.precious and i > self.options.max_rows:
+            if self.precious and i >= max_rows:
                 break
             self.addRow(r)
 
@@ -1142,8 +1200,10 @@ def preloadHook(sheet):
 
 @VisiData.api
 def newSheet(vd, name, ncols, **kwargs):
-    return Sheet(name, columns=[SettableColumn(width=vd.options.default_width) for i in range(ncols)], **kwargs)
-
+    cols = [SettableColumn(width=vd.options.default_width, name=f'{colname_letters(i+1)}') for i in range(ncols)]
+    vs = Sheet(name, columns=cols, **kwargs)
+    vs.colname_ctr = ncols
+    return vs
 
 @BaseSheet.api
 def quitAndReleaseMemory(vs):
@@ -1181,15 +1241,31 @@ def async_deepcopy(sheet, rowlist):
     _async_deepcopy(ret, rowlist)
     return ret
 
+@Sheet.api
+def reload_or_replace(sheet):
+    sheet.preloadHook()
+    if isinstance(sheet.source, visidata.Path) and \
+       sheet.source.is_url() and sheet.source.scheme != 'file':  #2825
+        #retrieve data again, because the earlier data saved in sheet.source may be outdated
+        vs = vd.openSource(visidata.Path(sheet.source.given))
+        if type(vs) != type(sheet):  #new data may have a different filetype
+            vd.push(vs)
+            vd.remove(sheet)
+            #user needs feedback that sheet changed, since the new sheet has a different shortcut
+            vd.status('replaced sheet due to changed filetype')
+            return
+        sheet.source = vs.source
+    sheet.reload()
 
 
 BaseSheet.init('pane', lambda: 1)
 
 
-BaseSheet.addCommand('^R', 'reload-sheet', 'preloadHook(); reload()', 'Reload current sheet')
+BaseSheet.addCommand('^R', 'reload-sheet', 'reload_or_replace()', 'Reload current sheet')
 Sheet.addCommand('', 'show-cursor', 'status(statusLine)', 'show cursor position and bounds of current sheet on status line')
 
-Sheet.addCommand('!', 'key-col', 'toggleKeys([cursorCol])', 'toggle current column as a key column')
+Sheet.addCommand('!', 'key-col', 'exec_longname("key-col-off") if cursorCol.keycol else exec_longname("key-col-on")', 'toggle current column as a key column', replay=False)
+Sheet.addCommand('', 'key-col-on', 'setKeys([cursorCol])', 'set current column as a key column')
 Sheet.addCommand('z!', 'key-col-off', 'unsetKeys([cursorCol])', 'unset current column as a key column')
 
 Sheet.addCommand('e', 'edit-cell', 'cursorCol.setValues([cursorRow], editCell(cursorVisibleColIndex)) if not (cursorRow is None) else fail("no rows to edit")', 'edit contents of current cell')
@@ -1217,7 +1293,7 @@ BaseSheet.addCommand('^I', 'splitwin-swap', 'vd.activePane = 1 if sheet.pane ==
 BaseSheet.addCommand('g^I', 'splitwin-swap-pane', 'vd.options.disp_splitwin_pct=-vd.options.disp_splitwin_pct', 'swap panes onscreen')
 BaseSheet.addCommand('zZ', 'splitwin-input', 'vd.options.disp_splitwin_pct = input("% height for split window: ", value=vd.options.disp_splitwin_pct)', 'set split pane to specific size')
 
-BaseSheet.addCommand('^L', 'redraw', 'sheet.refresh(); vd.redraw()', 'Refresh screen')
+BaseSheet.addCommand('^L', 'redraw', 'sheet.refresh(); vd.redraw(); vd.draw_all()', 'Refresh screen')
 BaseSheet.addCommand(None, 'guard-sheet', 'options.set("quitguard", True, sheet); status("guarded")', 'Set quitguard on current sheet to confirm before quit')
 BaseSheet.addCommand(None, 'guard-sheet-off', 'options.set("quitguard", False, sheet); status("unguarded")', 'Unset quitguard on current sheet to not confirm before quit')
 BaseSheet.addCommand(None, 'open-source', 'vd.replace(source)', 'jump to the source of this sheet')

visidata/shell.py

@@ -22,7 +22,7 @@ vd.option('dir_hidden', False, 'load hidden files on DirSheet')
 @VisiData.api
 def guess_dir(vd, p):
     if p.is_dir():
-        return dict(filetype='dir')
+        return dict(filetype='dir', _likelihood=10)
 
 
 @VisiData.lazy_property
@@ -133,7 +133,7 @@ class DirSheet(Sheet):
         Column('filetype', width=0, cache='async', getter=lambda col,row: subprocess.Popen(['file', '--brief', row], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[0].strip()),
     ]
     nKeys = 2
-    _ordering = [('modtime', True)]  # sort by reverse modtime initially
+    _ordering = [('modtime', True), ('filename', False)]  # sort by reverse modtime initially
 
     @staticmethod
     def colorOwner(sheet, col, row, val):

visidata/sidebar.py

@@ -15,11 +15,12 @@ vd.theme_option('color_sidebar_title', 'black on yellow', 'color of sidebar titl
 @VisiData.api
 class AddedHelp:
     '''Context manager to add help text/screen to list of available sidebars.'''
-    def __init__(self, text:Union[str,'HelpPane'], title=''):
+    def __init__(self, text:Union[str,'HelpPane'], title='', help_flag=''):
+        self.helpfunc = None
         if text:
+            if not vd.wantsHelp(help_flag):
+                return
             self.helpfunc = lambda: (text, title)
-        else:
-            self.helpfunc = None
 
     def __enter__(self):
         if self.helpfunc:
@@ -33,7 +34,7 @@ class AddedHelp:
             vd.clearCaches()
 
 
-@BaseSheet.property
+@BaseSheet.lazy_property
 def formatter_helpstr(sheet):
     return AttrDict(commands=CommandHelpGetter(type(sheet)),
                     options=OptionHelpGetter())
@@ -73,7 +74,7 @@ def help_sidebars(sheet) -> 'list[Callable[[], tuple[str,str]]]':
 @VisiData.cached_property
 def sidebarStatus(vd) -> str:
     if vd.sheet.help_sidebars:
-        if vd.options.disp_sidebar and vd.disp_help >= 0:
+        if vd.wantsHelp('sidebar') and vd.disp_help >= 0:
             n = vd.disp_help+1
             return f'[:onclick sidebar-toggle][:sidebar][{n}/{len(vd.sheet.help_sidebars)}][/]'
         else:
@@ -111,7 +112,7 @@ def drawSidebar(vd, scr, sheet):
     bottommsg = ''
     overflowmsg = '[:reverse] Ctrl+P to view all status messages [/]'
     try:
-        if not sidebar and vd.options.disp_sidebar and vd.disp_help >= 0:
+        if not sidebar and vd.options.disp_sidebar and vd.wantsHelp('guides') and sheet.help_sidebars:
             sidebar, title = sheet.help_sidebars[vd.disp_help%len(sheet.help_sidebars)]()
 
 #            bottommsg = sheet.formatString('[:onclick sidebar-toggle][:reverse] {help.commands.sidebar_toggle} [:]', help=sheet.formatter_helpstr)
@@ -130,7 +131,7 @@ def drawSidebar(vd, scr, sheet):
 def drawSidebarText(sheet, scr, text:Union[None,str,'HelpPane'], title:str='', overflowmsg:str='', bottommsg:str=''):
     scrh, scrw = scr.getmaxyx()
     maxw = sheet.options.disp_sidebar_width or scrw//2
-    maxh = sheet.options.disp_sidebar_height or scrh-2
+    maxh = sheet.options.disp_sidebar_height or max(scrh-2, 1)
 
     cattr = colors.get_color('color_sidebar')
 
@@ -158,6 +159,7 @@ def drawSidebarText(sheet, scr, text:Union[None,str,'HelpPane'], title:str='', o
         if lines:
             maxlinew = max(maxlinew, max(dispwidth(textonly, maxwidth=maxw) for line, textonly in lines))
         winh = min(maxh, len(lines)+2)
+    winh = max(winh, 1)
 
     titlew = dispwidth(title)
 
@@ -166,6 +168,7 @@ def drawSidebarText(sheet, scr, text:Union[None,str,'HelpPane'], title:str='', o
     maxlinew = max(maxlinew, titlew)
     winw = min(maxw, maxlinew+4)
     x, y, w, h = scrw-winw-1, scrh-winh-1, winw, winh
+    y = max(y, 0)
 
     sidebarscr = vd.subwindow(scr, x, y, w, h)
 
@@ -191,7 +194,7 @@ def drawSidebarText(sheet, scr, text:Union[None,str,'HelpPane'], title:str='', o
     if bottommsg:
         clipdraw(sidebarscr, h-1, winw-dispwidth(bottommsg)-4, '|'+bottommsg+'|', cattr)
 
-    sidebarscr.refresh()
+    sidebarscr.noutrefresh()
 
 
 @VisiData.api

visidata/sort.py

@@ -1,15 +1,32 @@
 from copy import copy
-from visidata import vd, asyncthread, Progress, Sheet, options, UNLOADED
+from visidata import vd, asyncthread, Progress, Sheet, Column, options, UNLOADED, ColumnsSheet
+import re
+
+cmdlog_col_prefix='\u241f'  #string ␟ to mark the start of column info in an ordering string
 
 @Sheet.api
-def orderBy(sheet, *cols, reverse=False):
-    'Add *cols* to internal ordering and re-sort the rows accordingly.  Pass *reverse* as True to order these *cols* descending.  Pass empty *cols* (or cols[0] of None) to clear internal ordering.'
+def orderBy(sheet, *cols, reverse=False, change_column=False, save_cmd_input=True):
+    '''Add *cols* to internal ordering and re-sort the rows accordingly.
+    Pass *reverse* as True to order these *cols* descending.
+    Pass empty *cols* (or cols[0] of None) to clear internal ordering.
+    Set *change_column* to True to change the sort status of a single column: add/remove/invert it.
+    When changing a column, *cols* must have length 1. Sort columns that had higher priority are unchanged. Lower-priority columns are removed.
+    If *change_column* is False, *cols* will be added to the existing ordering.
+    If *save_cmd_input* is True, the full ordering that results will be saved in the cmdlog for future replay in the 'input' parameter.
+    '''
+
     if options.undo:
         vd.addUndo(setattr, sheet, '_ordering', copy(sheet._ordering))
-        if sheet._ordering:
-            vd.addUndo(sheet.sort)
-        else:
-            vd.addUndo(setattr, sheet, 'rows', copy(sheet.rows))
+        vd.addUndo(setattr, sheet, 'rows', copy(sheet.rows))
+
+    # for replay, read the full column ordering from the cmdlog input parameter  #2688
+    input = vd.getLastArgs()
+    if input:
+        sheet._ordering = order_from_string(sheet, input)
+        sheet.sort()
+        if save_cmd_input:
+            vd.activeCommand.input = order_string(sheet)
+        return
 
     do_sort = False
     if not cols or cols[0] is None:
@@ -17,12 +34,21 @@ def orderBy(sheet, *cols, reverse=False):
         cols = cols[1:]
         do_sort = True
 
-    for c in cols:
-        sheet._ordering.append((c, reverse))
+    if change_column:
+        if len(cols) > 1:
+            vd.fail('sort order edit must only be applied to a single column')
+        new_ordering = edit_ordering(sheet._ordering, cols[0], reverse)
+        sheet._ordering = new_ordering
         do_sort = True
+    else:
+        for c in cols:
+            sheet._ordering.append((c, reverse))
+            do_sort = True
 
     if do_sort:
         sheet.sort()
+    if save_cmd_input:
+        vd.activeCommand.input = order_string(sheet)
 
 class Reversor:
     def __init__(self, obj):
@@ -34,7 +60,43 @@ class Reversor:
     def __lt__(self, other):
         return other.obj < self.obj
 
+def order_string(sheet):
+    sheet._ordering = sheet.ordering  #converts any ambiguous colname strings to unambiguous Column objects
+    ret = ''.join([cmdlog_col_prefix+('>' if reverse else '<') + str(col.name) for col, reverse in sheet._ordering])
+    return ret
 
+def order_from_string(sheet, s):
+    instructions = re.split(cmdlog_col_prefix + '(?=[<>])', s)[1:]
+    ordering = []
+    for instr in instructions:
+        c = sheet.column(instr[1:])
+        if instr[0] == '<':
+            reverse = False
+        elif instr[0] == '>':
+            reverse = True
+        ordering.append((c, reverse))
+    return ordering
+
+def edit_ordering(ordering, col, reverse):
+    '''Return a modified ordering based on editing a single column *col*:   add it, remove it, or flip its direction.
+    Columns after *col* in the ordering (with lower sort priority) are also removed from the ordering.
+    *ordering* is a list of tuples:  (Column, boolean), where the boolean defines the sort direction.
+    '''
+    new_ordering = []
+    # handle changes to status of columns that are already in the ordering:  add/remove/flip
+    changed = False
+    for c, old_reverse in ordering:
+        if c is col:
+            if reverse != old_reverse: # reverse the column's sort direction
+                new_ordering.append((c, reverse))
+            # if the sort direction is unchanged, remove the column from the ordering
+            changed = True
+            # columns after the edited column will be dropped from the ordering
+            break
+        new_ordering.append((c, old_reverse))
+    if not changed:
+        new_ordering.append((col, reverse))
+    return new_ordering
 
 @Sheet.cached_property
 def ordering(sheet) -> 'list[tuple[Column, bool]]':
@@ -76,6 +138,20 @@ def sort(self):
         vd.warning('sort incomplete due to TypeError; change column type')
         vd.exceptionCaught(e, status=False)
 
+ColumnsSheet.columns += [
+        Column('sortorder',
+            type=int,
+            getter=lambda c,r: _sort_order(c, r),
+            help='sort priority and direction in source sheet')
+]
+
+def _sort_order(col, srccol):
+    sort_cols = [(n+1, reverse) for n, (c, reverse) in enumerate(srccol.sheet.ordering) if c is srccol]
+    if not sort_cols:
+        return None
+    n, reverse = sort_cols[0]
+    return -n if reverse else n
+
 
 # replace existing sort criteria
 Sheet.addCommand('[', 'sort-asc', 'orderBy(None, cursorCol)', 'sort ascending by current column; replace any existing sort criteria')
@@ -84,8 +160,10 @@ Sheet.addCommand('g[', 'sort-keys-asc', 'orderBy(None, *keyCols)', 'sort ascendi
 Sheet.addCommand('g]', 'sort-keys-desc', 'orderBy(None, *keyCols, reverse=True)', 'sort descending by all key columns; replace any existing sort criteria')
 
 # add to existing sort criteria
-Sheet.addCommand('z[', 'sort-asc-add', 'orderBy(cursorCol)', 'sort ascending by current column; add to existing sort criteria')
-Sheet.addCommand('z]', 'sort-desc-add', 'orderBy(cursorCol, reverse=True)', 'sort descending by current column; add to existing sort criteria')
+Sheet.addCommand('', 'sort-asc-add', 'orderBy(cursorCol)', 'sort ascending by current column; add to existing sort criteria')
+Sheet.addCommand('', 'sort-desc-add', 'orderBy(cursorCol, reverse=True)', 'sort descending by current column; add to existing sort criteria')
+Sheet.addCommand('z[', 'sort-asc-change', 'orderBy(cursorCol, change_column=True)', 'sort ascending by current column; keep higher priority sort criteria')
+Sheet.addCommand('z]', 'sort-desc-change', 'orderBy(cursorCol, reverse=True, change_column=True)', 'sort descending by current column; keep higher priority sort criteria')
 Sheet.addCommand('gz[', 'sort-keys-asc-add', 'orderBy(*keyCols)', 'sort ascending by all key columns; add to existing sort criteria')
 Sheet.addCommand('gz]', 'sort-keys-desc-add', 'orderBy(*keyCols, reverse=True)', 'sort descending by all key columns; add to existing sort criteria')
 

visidata/statusbar.py

@@ -8,7 +8,7 @@ import curses
 import sys
 
 import visidata
-from visidata import vd, VisiData, BaseSheet, Sheet, ColumnItem, Column, RowColorizer, options, colors, wrmap, clipdraw, ExpectedException, update_attr, dispwidth, ColorAttr
+from visidata import vd, VisiData, BaseSheet, Sheet, ColumnItem, Column, RowColorizer, options, colors, wrmap, clipdraw, ExpectedException, update_attr, dispwidth, ColorAttr, clipstr_middle
 
 
 
@@ -31,11 +31,6 @@ vd.theme_option('color_highlight_status', 'black on green', 'color of highlighte
 
 BaseSheet.init('longname', lambda: '')
 
-def fitWithin(s, n=10):
-    if len(s) > n:
-        return s[:n//2-1] + '…' + s[-n//2+1:]
-    return s
-
 @BaseSheet.property
 def ancestors(sheet):
     if isinstance(sheet.source, BaseSheet):
@@ -53,14 +48,16 @@ def sheetlist(sheet):
 
     sheetnames = []
     for vs in sheets:
+        if not vs.precious:  #2573
+            continue
         if isinstance(vs, BaseSheet):
             shortcut = ' '
             if vs.shortcut in '1 2 3 4 5 6 7 8 9 10'.split():
-                shortcut = vs.shortcut[-1] + '›'
+                shortcut = vs.shortcut[-1] + vs.icon
             if vs is vd.sheet:
                 sheetnames.append(f'[:menu_active]{shortcut}{vs.name}[:]')
             else:
-                sheetnames.append(f'[:onclick jump-sheet-{vs.shortcut}]' + fitWithin(f'{shortcut}{vs.name}', 20) + '[:]')
+                sheetnames.append(f'[:onclick jump-sheet-{vs.shortcut}]' + clipstr_middle(f'{shortcut}{vs.name}', 20)[0] + '[:]')
         else:
             sheetnames.append(vs)
 
@@ -226,12 +223,16 @@ def modifiedStatus(sheet):
     return ret
 
 
+@BaseSheet.property
+def selectedStatus(sheet):
+    return ''
+
+
 @Sheet.property
 def selectedStatus(sheet):
     if sheet.nSelectedRows:
         return f' [:selected_row][:onclick dup-selected]{sheet.options.disp_selected_note}{sheet.nSelectedRows}[/][/] '
 
-
 @VisiData.api
 def drawRightStatus(vd, scr, vs):
     'Draw right side of status bar.  Return length displayed.'