visidata 3.0.1__py3-none-any.whl → 3.1__py3-none-any.whl

visidata/clipboard.py

@@ -6,6 +6,7 @@ import sys
 import tempfile
 import functools
 import os
+import itertools
 
 from visidata import VisiData, vd, asyncthread, SettableColumn
 from visidata import Sheet, Path, Column
@@ -58,6 +59,12 @@ def syscopyValue(sheet, val):
 
     vd.status('copied value to system clipboard')
 
+@Sheet.api
+def setColClipboard(sheet):
+    if not vd.memory.clipcells:
+        vd.warning("nothing to paste from clipcells")
+        return
+    sheet.cursorCol.setValuesTyped(sheet.onlySelectedRows, *vd.memory.clipcells)
 
 @Sheet.api
 def syscopyCells(sheet, cols, rows, filetype=None):
@@ -95,12 +102,12 @@ def sysclipValue(vd):
 @VisiData.api
 @asyncthread
 def pasteFromClipboard(vd, cols, rows):
-    text = vd.getLastArgs() or vd.sysclipValue().strip() or vd.fail('system clipboard is empty')
+    text = vd.getLastArgs() or vd.sysclipValue().strip() or vd.fail('nothing to paste from system clipboard')
 
     vd.addUndoSetValues(cols, rows)
     lines = text.split('\n')
     if not lines:
-        vd.warning('nothing to paste')
+        vd.warning('nothing to paste from system clipboard')
         return
 
     vs = cols[0].sheet
@@ -138,7 +145,7 @@ def delete_row(sheet, rowidx):
 def paste_after(sheet, rowidx):
     'Paste rows from *vd.cliprows* at *rowidx*.'
     if not vd.memory.cliprows:  #1793
-        vd.warning('nothing to paste')
+        vd.warning('nothing to paste from cliprows')
         return
 
     for col in vd.memory.clipcols[sheet.nVisibleCols:]:
@@ -168,8 +175,8 @@ Sheet.addCommand('P', 'paste-before', 'paste_after(cursorRowIndex-1)', 'paste cl
 
 Sheet.addCommand('gy', 'copy-selected', 'copyRows(onlySelectedRows)', 'yank (copy) selected rows to clipboard')
 
-Sheet.addCommand('zy', 'copy-cell', 'copyCells(cursorCol, [cursorRow]); vd.memo("clipval", cursorCol, cursorRow)', 'yank (copy) current cell to clipboard')
-Sheet.addCommand('zp', 'paste-cell', 'cursorCol.setValuesTyped([cursorRow], vd.memory.clipval)', 'set contents of current cell to last clipboard value')
+Sheet.addCommand('zy', 'copy-cell', 'copyCells(cursorCol, [cursorRow]); vd.memoValue("clipval", cursorTypedValue, cursorDisplay)', 'yank (copy) current cell to clipboard')
+Sheet.addCommand('zp', 'paste-cell', 'cursorCol.setValuesTyped([cursorRow], vd.memory.clipval) if vd.memory.clipval else vd.warning("nothing to paste from clipval")', 'set contents of current cell to last clipboard value')
 
 Sheet.addCommand('d', 'delete-row', 'delete_row(cursorRowIndex); defer and cursorDown(1)', 'delete current row')
 Sheet.addCommand('gd', 'delete-selected', 'deleteSelected()', 'delete selected rows')
@@ -183,7 +190,7 @@ Sheet.bindkey('zP', 'syspaste-cells')
 Sheet.addCommand('gzP', 'syspaste-cells-selected', 'pasteFromClipboard(visibleCols[cursorVisibleColIndex:], someSelectedRows)', 'paste from system clipboard to selected cells')
 
 Sheet.addCommand('gzy', 'copy-cells', 'copyCells(cursorCol, onlySelectedRows)', 'yank (copy) contents of current column for selected rows to clipboard')
-Sheet.addCommand('gzp', 'setcol-clipboard', 'for r, v in zip(onlySelectedRows, itertools.cycle(vd.memory.clipcells or [None])): cursorCol.setValuesTyped([r], v)', 'set cells of current column for selected rows to last clipboard value')
+Sheet.addCommand('gzp', 'setcol-clipboard', 'setColClipboard()', 'set cells of current column for selected rows to last clipboard value')
 
 Sheet.addCommand('Y', 'syscopy-row', 'syscopyCells(visibleCols, [cursorRow])', 'yank (copy) current row to system clipboard (using options.clipboard_copy_cmd)')
 

visidata/cliptext.py

@@ -71,7 +71,7 @@ def iterchunks(s, literal=False):
             link = attrstack[-1]['link']
 
             if chunk.startswith('[:onclick '):
-                attrstack.append(dict(link=chunk[10:-1], cattr=cattr.update(colors.clickable)))
+                attrstack.append(dict(link=chunk[2:-1], cattr=cattr.update(colors.clickable)))
                 continue
             elif chunk == '[:]':  # clear stack, keep origattr
                 if len(attrstack) > 1:
@@ -235,11 +235,12 @@ def clipdraw_chunks(scr, y, x, chunks, cattr:ColorAttr=ColorAttr(), w=None, clea
 
     try:
         for colorstate, chunk in chunks:
-            if isinstance(colorstate, str):
-                cattr = cattr.update(colors.get_color(colorstate))
-            else:
-                cattr = origattr.update(colorstate['cattr'])
-                link = colorstate['link']
+            if colorstate:
+                if isinstance(colorstate, str):
+                    cattr = cattr.update(colors.get_color(colorstate), 100)
+                else:
+                    cattr = origattr.update(colorstate['cattr'], 100)
+                    link = colorstate['link']
 
             if not chunk:
                 continue

visidata/cmdlog.py

@@ -6,18 +6,18 @@ import visidata
 
 vd.option('replay_wait', 0.0, 'time to wait between replayed commands, in seconds', sheettype=None)
 vd.theme_option('disp_replay_play', '▶', 'status indicator for active replay')
+vd.theme_option('disp_replay_record', '⏺', 'status indicator for macro record')
 vd.theme_option('color_status_replay', 'green', 'color of replay status indicator')
 
 # prefixes which should not be logged
 nonLogged = '''forget exec-longname undo redo quit
 show error errors statuses options threads jump
 replay cancel save-cmdlog macro cmdlog-sheet menu repeat reload-every
-go- search scroll prev next page start end zoom resize visibility sidebar
+search scroll prev next page start end zoom visibility sidebar
 mouse suspend redraw no-op help syscopy sysopen profile toggle'''.split()
 
 vd.option('rowkey_prefix', 'キ', 'string prefix for rowkey in the cmdlog', sheettype=None)
 
-vd.activeCommand = UNLOADED
 vd._nextCommands = []  # list[str|CommandLogRow] for vd.queueCommand
 
 CommandLogRow = namedlist('CommandLogRow', 'sheet col row longname input keystrokes comment undofuncs'.split())
@@ -68,13 +68,14 @@ def indexMatch(L, func):
         if func(x):
             return i
 
-def keystr(k):
-    return  vd.options.rowkey_prefix+','.join(map(str, k))
-
 @VisiData.api
-def isLoggableCommand(vd, longname):
+def isLoggableCommand(vd, cmd):
+    'Return whether command should be logged to the cmdlog, depending if it has a prefix in nonLogged, or was defined with replay=False.'
+    if not cmd.replayable:
+        return False
+
     for n in nonLogged:
-        if longname.startswith(n):
+        if cmd.longname.startswith(n):
             return False
     return True
 
@@ -94,15 +95,22 @@ def moveToRow(vs, rowstr):
     return True
 
 @Sheet.api
-def getRowIndexFromStr(vs, rowstr):
-    index = indexMatch(vs.rows, lambda r,vs=vs,rowstr=rowstr: keystr(vs.rowkey(r)) == rowstr)
-    if index is not None:
-        return index
+def getRowIndexFromStr(vs, row):
+    prefix = vd.options.rowkey_prefix
+    index = None
+    if isinstance(row, int):
+        index = row
+    elif isinstance(row, str) and row.startswith(prefix):
+        rowk = row[len(prefix):]
+        index = indexMatch(vs.rows, lambda r,vs=vs,rowk=rowk: rowk == ','.join(map(str, vs.rowkey(r))))
+    else:
+        try:
+            index = int(row)
+        except ValueError:
+            vd.warning('invalid type for row index')
+
+    return index
 
-    try:
-        return int(rowstr)
-    except ValueError:
-        return None
 
 @Sheet.api
 def moveToCol(vs, col):
@@ -126,8 +134,7 @@ def commandCursor(sheet, execstr):
     colname, rowname = '', ''
     contains = lambda s, *substrs: any((a in s) for a in substrs)
     if contains(execstr, 'cursorTypedValue', 'cursorDisplay', 'cursorValue', 'cursorCell', 'cursorRow') and sheet.nRows > 0:
-        k = sheet.rowkey(sheet.cursorRow)
-        rowname = keystr(k) if k else sheet.cursorRowIndex
+        rowname = sheet.cursorRowIndex
 
     if contains(execstr, 'cursorTypedValue', 'cursorDisplay', 'cursorValue', 'cursorCell', 'cursorCol', 'cursorVisibleCol', 'ColumnAtCursor'):
         if sheet.cursorCol:
@@ -177,11 +184,12 @@ class CommandLogBase:
         comment = vd.currentReplayRow.comment if vd.currentReplayRow else cmd.helpstr
         vd.activeCommand = self.newRow(sheet=sheetname,
                                             col=colname,
-                                            row=str(rowname),
+                                            row=rowname,
                                             keystrokes=keystrokes,
                                             input=args,
                                             longname=cmd.longname,
                                             comment=comment,
+                                            replayable=cmd.replayable,
                                             undofuncs=[])
 
     def afterExecSheet(self, sheet, escaped, err):
@@ -189,15 +197,12 @@ class CommandLogBase:
         if not vd.activeCommand:  # nothing to record
             return
 
-        if err:
-            vd.activeCommand[-1] += ' [%s]' % err
-
         if escaped:
             vd.activeCommand = None
             return
 
         # remove user-aborted commands and simple movements (unless first command on the sheet, which created the sheet)
-        if not sheet.cmdlog_sheet.rows or vd.isLoggableCommand(vd.activeCommand.longname):
+        if not sheet.cmdlog_sheet.rows or vd.isLoggableCommand(vd.activeCommand):
             if isLoggableSheet(sheet):      # don't record actions from cmdlog or other internal sheets on global cmdlog
                 self.addRow(vd.activeCommand)  # add to global cmdlog
             sheet.cmdlog_sheet.addRow(vd.activeCommand)  # add to sheet-specific cmdlog
@@ -207,7 +212,7 @@ class CommandLogBase:
     def openHook(self, vs, src):
         while isinstance(src, BaseSheet):
             src = src.source
-        r = self.newRow(keystrokes='o', input=str(src), longname='open-file')
+        r = self.newRow(keystrokes='o', input=str(src), longname='open-file', replayable=True)
         vs.cmdlog_sheet.addRow(r)
         self.addRow(r)
 
@@ -262,6 +267,8 @@ def replayOne(vd, r):
         'Replay the command in one given row.'
         vd.currentReplayRow = r
         longname = getattr(r, 'longname', None)
+        if longname is None and getattr(r, 'keystrokes', None) is None:
+            vd.fail('failed to find command to replay')
 
         if r.sheet and longname not in ['set-option', 'unset-option']:
             vs = vd.getSheet(r.sheet) or vd.error('no sheet named %s' % r.sheet)
@@ -321,6 +328,7 @@ class DisableAsync:
 def replay_sync(vd, cmdlog):
     'Replay all commands in *cmdlog*.'
     with vd.DisableAsync():
+        vd.sync()  #2352 let cmdlog finish loading
         cmdlog.cursorRowIndex = 0
         vd.currentReplay = cmdlog
 
@@ -370,15 +378,19 @@ def getLastArgs(vd):
 def setLastArgs(vd, args):
         'Set user input on last command, if not already set.'
         # only set if not already set (second input usually confirmation)
-        if (vd.activeCommand is not None) and (vd.activeCommand is not UNLOADED):
+        if vd.activeCommand:
             if not vd.activeCommand.input:
                 vd.activeCommand.input = args
 
 
 @VisiData.property
 def replayStatus(vd):
+    if vd.macroMode:
+        return f'|[:error] {len(vd.macroMode)} {vd.options.disp_replay_record} [:]'
+
     if vd._nextCommands:
-        return f' | [:status_replay] {len(vd._nextCommands)} {vd.options.disp_replay_play}[:]'
+        return f'|[:status_replay] {len(vd._nextCommands)} {vd.options.disp_replay_play} [:]'
+
     return ''
 
 
@@ -412,7 +424,7 @@ def shortcut(self):
         pass
 
     try:
-        return self.cmdlog_sheet.rows[0].keystrokes
+        return self.cmdlog_sheet.rows[0].keystrokes or ''  #2293
     except Exception:
         pass
 
@@ -429,7 +441,7 @@ def cmdlog(vd):
 
 @VisiData.property
 def modifyCommand(vd):
-    if vd.activeCommand is not None and vd.isLoggableCommand(vd.activeCommand.longname):
+    if vd.activeCommand and vd.isLoggableCommand(vd.activeCommand):
         return vd.activeCommand
     if not vd.cmdlog.rows:
         return None
@@ -477,6 +489,7 @@ CommandLogJsonl.addCommand('gx', 'replay-all', 'vd.replay(sheet)', 'replay conte
 CommandLog.options.json_sort_keys = False
 CommandLog.options.encoding = 'utf-8'
 CommandLogJsonl.options.json_sort_keys = False
+CommandLogJsonl.options.regex_skip = r'^(//|#).*'
 
 vd.addGlobals(CommandLogBase=CommandLogBase, CommandLogRow=CommandLogRow)
 

visidata/column.py

@@ -20,13 +20,13 @@ class InProgress(Exception):
 
 INPROGRESS = TypedExceptionWrapper(None, exception=InProgress())  # sentinel
 
-vd.option('col_cache_size', 0, 'max number of cache entries in each cached column', max_help=-1)
-vd.option('disp_formatter', 'generic', 'formatter to create the text in each cell (also used by text savers)', replay=True, max_help=0)
-vd.option('disp_displayer', 'generic', 'displayer to render the text in each cell', replay=False, max_help=0)
+vd.option('col_cache_size', 0, 'max number of cache entries in each cached column')
+vd.option('disp_formatter', 'generic', 'formatter to create the text in each cell (also used by text savers)', replay=True)
+vd.option('disp_displayer', 'generic', 'displayer to render the text in each cell', replay=False)
 
 
 class DisplayWrapper:
-    def __init__(self, value=None, *, typedval=None, text=None, note=None, notecolor=None, error=None):
+    def __init__(self, value=None, *, typedval=None, text='', note=None, notecolor=None, error=None):
         self.value = value      # actual value (any type)
         self.typedval = typedval  # consistently typed value (or None)
         self.text = text  # displayed string
@@ -86,7 +86,7 @@ class Column(Extensible):
         self.formatter = ''
         self.displayer = ''
         self.defer = False
-        self.max_help = 10    # auto-hide above this disp_help level
+        self.disp_expert = 0    # auto-hide if options.disp_expert less than col.disp_expert
 
         self.setCache(cache)
         for k, v in kwargs.items():
@@ -276,7 +276,7 @@ class Column(Extensible):
            The 'full' displayer allows formatting like [:color].
         '''
         if width is not None and width > 1 and vd.isNumeric(self):
-            yield from iterchunks(text.rjust(width-2))
+            yield from iterchunks(dw.text.rjust(width-2))
         else:
             yield from iterchunks(dw.text)
 
@@ -368,7 +368,7 @@ class Column(Extensible):
                     dispval = options.disp_error_val
                 return DisplayWrapper(cellval.val, error=exc.stacktrace,
                                         text=dispval,
-                                        note=options.note_getter_exc,
+                                        note=f'[:onclick error-cell]{options.disp_note_getexc}[:]',
                                         notecolor='color_error')
             elif typedval.val is None:  # early out for strict None
                 return DisplayWrapper(None, text='',  # force empty display for None
@@ -377,18 +377,17 @@ class Column(Extensible):
             elif isinstance(typedval, TypedExceptionWrapper):  # calc succeeded, type failed
                 return DisplayWrapper(typedval.val, text=str(cellval),
                                             error=typedval.stacktrace,
-                                            note=options.note_type_exc,
+                                            note=f'[:onclick error-cell]{options.disp_note_typeexc}[:]',
                                             notecolor='color_warning')
             else:
                 return DisplayWrapper(typedval.val, text=str(typedval.val),
-                                            error='unknown',
-                                            note=options.note_type_exc,
+                                            error=['unknown'],
+                                            note=f'[:onclick error-cell]{options.disp_note_typeexc}[:]',
                                             notecolor='color_warning')
-
         elif isinstance(typedval, threading.Thread):
             return DisplayWrapper(None,
                                 text=options.disp_pending,
-                                note=options.note_pending,
+                                note=options.disp_note_pending,
                                 notecolor='color_note_pending')
 
         dw = DisplayWrapper(cellval)
@@ -411,10 +410,10 @@ class Column(Extensible):
                 dw.text = str(cellval)
             except Exception as e:
                 dw.text = str(e)
-            dw.note = options.note_format_exc
+            dw.note = options.disp_note_fmtexc
             dw.notecolor = 'color_warning'
 
-#        dw.display = self.display(dw)   # set during draw() when colwidth is known
+#        dw.display = self.display(dw)   # set during draw() once colwidth is known
         return dw
 
     def getDisplayValue(self, row):
@@ -446,6 +445,7 @@ class Column(Extensible):
         self.recalc()
         return vd.status('set %d cells to %d values' % (len(rows), len(values)))
 
+    @asyncthread
     def setValuesTyped(self, rows, *values):
         'Set values on this column for *rows* to *values*, coerced to column type, recycling values as needed to fill *rows*.  Abort on type exception.'
         vd.addUndoSetValues([self], rows)
@@ -537,39 +537,6 @@ def SubColumnItem(idx, c, **kwargs):
         kwargs['name'] = c.name
     return SubColumnFunc(origcol=c, subfunc=getitemdef, expr=idx, **kwargs)
 
-class ExprColumn(Column):
-    'Column using *expr* to derive the value from each row.'
-    def __init__(self, name, expr=None, **kwargs):
-        super().__init__(name, **kwargs)
-        self.expr = expr or name
-        self.ncalcs = 0
-        self.totaltime = 0
-        self.maxtime = 0
-
-    def calcValue(self, row):
-        t0 = time.perf_counter()
-        r = self.sheet.evalExpr(self.compiledExpr, row, col=self)
-        t1 = time.perf_counter()
-        self.ncalcs += 1
-        self.maxtime = max(self.maxtime, t1-t0)
-        self.totaltime += (t1-t0)
-        return r
-
-    def putValue(self, row, val):
-        a = self.getDisplayValue(row)
-        b = self.format(self.type(val))
-        if a != b:
-            vd.warning("Cannot change value of calculated column.  Use `'` to freeze column.")
-
-    @property
-    def expr(self):
-        return self._expr
-
-    @expr.setter
-    def expr(self, expr):
-        self.compiledExpr = compile(expr, '<expr>', 'eval') if expr else None
-        self._expr = expr
-
 
 class SettableColumn(Column):
     'Column using rowid to store and retrieve values internally.'
@@ -592,7 +559,6 @@ vd.addGlobals(
     getitemdef=getitemdef,
     AttrColumn=AttrColumn,
     ItemColumn=ItemColumn,
-    ExprColumn=ExprColumn,
     SettableColumn=SettableColumn,
     SubColumnFunc=SubColumnFunc,
     SubColumnItem=SubColumnItem,
@@ -601,6 +567,5 @@ vd.addGlobals(
 # synonyms
     ColumnItem=ItemColumn,
     ColumnAttr=AttrColumn,
-    ColumnExpr=ExprColumn,
     DisplayWrapper=DisplayWrapper
 )

visidata/ddw/regex.ddw

@@ -53,5 +53,6 @@
 {"x": 42, "y": 4, "text": "exactly m", "color": "", "tags": [], "group": ""}
 {"x": 4, "y": 0, "text": "Character classes", "color": "bold underline", "tags": [], "group": ""}
 {"x": 35, "y": 0, "text": "Repetition", "color": "bold underline", "tags": [], "group": ""}
-{"x": 2, "y": 14, "text": "For full documentation on Python regular expressions, see", "color": "", "tags": [], "group": ""}
-{"x": 6, "y": 15, "text": "https://docs.python.org/3/library/re.html", "color": "underline", "tags": [], "group": "", "href": "https://docs.python.org/3/library/re.html"}
+{"x": 2, "y": 15, "text": "For full documentation on Python regular expressions, see", "color": "", "tags": [], "group": ""}
+{"x": 6, "y": 16, "text": "https://docs.python.org/3/library/re.html", "color": "underline", "tags": [], "group": "", "href": "https://docs.python.org/3/library/re.html"}
+{"x": 2, "y": 14, "text": "Note: regex operations apply to the displayed value in a cell", "color": "", "tags": [], "group": ""}

visidata/deprecated.py

@@ -165,7 +165,7 @@ exceptionCaught = deprecated('2.6', 'vd.exceptionCaught')(vd.exceptionCaught)
 openSource = deprecated('2.6', 'vd.openSource')(vd.openSource)
 globalCommand = visidata.BaseSheet.addCommand
 visidata.Sheet.StaticColumn = deprecated('2.11', 'Sheet.freeze_col')(visidata.Sheet.freeze_col)
-visidata.Path.open_text = deprecated('3.0', 'visidata.Path.open')(visidata.Path.open)
+#visidata.Path.open_text = deprecated('3.0', 'visidata.Path.open')(visidata.Path.open)  # undeprecated in 3.1
 
 vd.sysclip_value = deprecated('3.0', 'vd.sysclipValue')(vd.sysclipValue)
 
@@ -237,4 +237,16 @@ def setValueSafe(self, row, value):
 def checkCursorNoExceptions(sheet):
     return vd.callNoExceptions(sheet.checkCursor)
 
-vd.addGlobals(globals())
+@deprecated('3.1', 'vd.memoValue(name, value, displayvalue)')
+@VisiData.api
+def memo(vd, name, col, row):
+    return vd.memoValue(name, col.getTypedValue(row), col.getDisplayValue(row))
+
+alias('view-cell', 'pyobj-cell')
+
+vd.optalias('textwrap_cells', 'disp_wrap_max_lines', 3) # wordwrap text for multiline rows
+
+@deprecated('3.1', 'sheet.rowname(row)')
+@visidata.TableSheet.api
+def keystr(sheet, row):
+    return sheet.rowname(row)

visidata/desktop/visidata.desktop

@@ -3,5 +3,5 @@ Type=Application
 Terminal=true
 Name=VisiData
 Icon=utilities-terminal
-Exec=bash -i -c 'vd %f'
-Categories=Application;
+Exec=vd %F
+Categories=Utility;TextTools

visidata/editor.py

@@ -37,6 +37,7 @@ def launchEditor(vd, *args):
 def launchBrowser(vd, *args):
     'Launch $BROWSER with *args* as arguments.'
     browser = os.environ.get('BROWSER') or vd.fail('no $BROWSER for %s' % args[0])
+    vd.status('opening ' + args[0])
     args = [browser] + list(args)
     subprocess.call(args)
 

visidata/errors.py

@@ -2,7 +2,7 @@ import traceback
 
 from visidata import vd, VisiData
 
-vd.option('debug', False, 'exit on error and display stacktrace', max_help=0)
+vd.option('debug', False, 'exit on error and display stacktrace')
 
 
 class ExpectedException(Exception):

visidata/experimental/sort_selected.py

@@ -0,0 +1,54 @@
+from copy import copy
+from visidata import vd, Sheet, Progress, asyncthread, options, UNLOADED
+
+@Sheet.api
+@asyncthread
+def sortSelected(self, ordering):
+    """sort the rows that are selected, in place so that each originally-selected row takes the place of another.
+    *ordering* is a list of tuples: (col_name_str, reverse_sort_bool) (string and bool)"""
+    if self.rows is UNLOADED or not self.rows:
+        return
+    if self.nSelectedRows == 0:
+        vd.fail('no rows selected')
+        return
+
+    if options.undo:
+        vd.status('undo added')
+        vd.addUndo(setattr, self, 'rows', copy(self.rows))
+
+# temporary:  save data to test integrity after the sort
+    rows_initial = { self.rowid(r) for r in self.rows }
+    selected_initial = set(self._selectedRows.keys())
+
+    with Progress(gerund='sorting', total=self.nSelectedRows) as prog:
+        selected = list(self._selectedRows.values())
+        selected_rowids = set(self._selectedRows.keys())
+
+        selected_indices = []
+        for i, r in enumerate(self.rows):
+            rowid = self.rowid(r)
+            if rowid in selected_rowids:
+                selected_indices.append(i)
+                selected_rowids.remove(rowid)
+            if len(selected_rowids) == 0:
+                break
+        try:
+            def _sortkey(r):
+                prog.addProgress(1)
+                return self.sortkey(r, ordering=ordering)
+            sorted_selected = sorted(selected, key=_sortkey)
+        except TypeError as e:
+            vd.warning('sort incomplete due to TypeError; change column type')
+            vd.exceptionCaught(e, status=False)
+            return
+        for selected_idx, r in zip(selected_indices, sorted_selected, strict=True):
+            self.rows[selected_idx] = r
+
+# temporary:  make sure we haven't lost any rows in the sheet or the selection
+    rows_final = { self.rowid(r) for r in self.rows }
+    selected_final = set(self._selectedRows.keys())
+    assert(rows_initial == rows_final)
+    assert(selected_initial == selected_final)
+
+Sheet.addCommand(None, 'sort-selected-asc', 'sortSelected([(cursorCol, False)])', 'sort selected rows by the current column, in ascending order')
+Sheet.addCommand(None, 'sort-selected-desc', 'sortSelected([(cursorCol, True)])', 'sort selected rows by the current column, in descending order')

visidata/expr.py

@@ -1,9 +1,50 @@
-from visidata import Progress, Sheet, Column, asyncthread, vd, ExprColumn
+import time
+
+from visidata import Progress, Sheet, Column, asyncthread, vd, Column
+
+
+class ExprColumn(Column):
+    'Column using *expr* to derive the value from each row.'
+    def __init__(self, name, expr=None, **kwargs):
+        super().__init__(name, **kwargs)
+        self.expr = expr or name
+        self.ncalcs = 0
+        self.totaltime = 0
+        self.maxtime = 0
+
+    def calcValue(self, row):
+        t0 = time.perf_counter()
+        r = self.sheet.evalExpr(self.compiledExpr, row, col=self, curcol=self)
+        t1 = time.perf_counter()
+        self.ncalcs += 1
+        self.maxtime = max(self.maxtime, t1-t0)
+        self.totaltime += (t1-t0)
+        return r
+
+    def putValue(self, row, val):
+        a = self.getDisplayValue(row)
+        b = self.format(self.type(val))
+        if a != b:
+            vd.warning("Cannot change value of calculated column.  Use `'` to freeze column.")
+
+    @property
+    def expr(self):
+        return self._expr
+
+    @expr.setter
+    def expr(self, expr):
+        self.compiledExpr = compile(expr, '<expr>', 'eval') if expr else None
+        self._expr = expr
 
 
 class CompleteExpr:
     def __init__(self, sheet=None):
-        self.sheet = sheet
+        self.varnames = []
+        if sheet:
+            self.varnames.extend(sorted(col.name for col in sheet.columns))
+        self.varnames.extend(sorted(x for x in vd.getGlobals()))
+        for c in vd.contexts:
+            self.varnames.extend(sorted(x for x in dir(c)))
 
     def __call__(self, val, state):
         i = len(val)-1
@@ -19,29 +60,35 @@ class CompleteExpr:
             base = val[:i+1]
             partial = val[i+1:]
 
-        varnames = []
-        varnames.extend(sorted((base+col.name) for col in self.sheet.columns if col.name.startswith(partial)))
-        varnames.extend(sorted((base+x) for x in vd.getGlobals() if x.startswith(partial)))
-
-        # Remove duplicate tabbing suggestions
-        varnames_dict = {var:None for var in varnames}
+        # Remove unmatching and duplicate completions
+        varnames_dict = {x:None for x in self.varnames if x.startswith(partial)}
         varnames = list(varnames_dict.keys())
-        return varnames[state%len(varnames)]
+
+        if not varnames:
+            return val
+
+        return base + varnames[state%len(varnames)]
 
 
 @Column.api
 @asyncthread
-def setValuesFromExpr(self, rows, expr):
+def setValuesFromExpr(self, rows, expr, **kwargs):
     'Set values in this column for *rows* to the result of the Python expression *expr* applied to each row.'
     compiledExpr = compile(expr, '<expr>', 'eval')
     vd.addUndoSetValues([self], rows)
+    nset = 0
     for row in Progress(rows, 'setting'):
         # Note: expressions that are only calculated once, do not need to pass column identity
         # they can reference their "previous selves" once without causing a recursive problem
-        v = vd.callNoExceptions(self.sheet.evalExpr, compiledExpr, row)
-        vd.callNoExceptions(self.setValue, row, v)
+        try:
+            v = self.sheet.evalExpr(compiledExpr, row, **kwargs)
+            self.setValue(row, v)
+            nset += 1
+        except Exception as e:
+            vd.exceptionCaught(e)
+
     self.recalc()
-    vd.status('set %d values = %s' % (len(rows), expr))
+    vd.status(f'set {nset} values = {expr}')
 
 
 @Sheet.api
@@ -49,14 +96,18 @@ def inputExpr(self, prompt, *args, **kwargs):
     return vd.input(prompt, "expr", *args, completer=CompleteExpr(self), **kwargs)
 
 
-Sheet.addCommand('=', 'addcol-expr', 'addColumnAtCursor(ExprColumn(inputExpr("new column expr="), curcol=cursorCol))', 'create new column from Python expression, with column names as variables')
-Sheet.addCommand('g=', 'setcol-expr', 'cursorCol.setValuesFromExpr(someSelectedRows, inputExpr("set selected="))', 'set current column for selected rows to result of Python expression')
-Sheet.addCommand('z=', 'setcell-expr', 'cursorCol.setValues([cursorRow], evalExpr(inputExpr("set expr="), cursorRow,))', 'evaluate Python expression on current row and set current cell with result of Python expression')
+Sheet.addCommand('=', 'addcol-expr', 'addColumnAtCursor(ExprColumn(inputExpr("new column expr="), col=cursorCol, curcol=cursorCol))', 'create new column from Python expression, with column names as variables')
+Sheet.addCommand('g=', 'setcol-expr', 'cursorCol.setValuesFromExpr(someSelectedRows, inputExpr("set selected="), curcol=cursorCol)', 'set current column for selected rows to result of Python expression')
+Sheet.addCommand('z=', 'setcell-expr', 'cursorCol.setValues([cursorRow], evalExpr(inputExpr("set expr="), row=cursorRow, curcol=cursorCol))', 'evaluate Python expression on current row and set current cell with result of Python expression')
 Sheet.addCommand('gz=', 'setcol-iter', 'cursorCol.setValues(someSelectedRows, *list(itertools.islice(eval(input("set column= ", "expr", completer=CompleteExpr())), len(someSelectedRows))))', 'set current column for selected rows to the items in result of Python sequence expression')
 
-Sheet.addCommand(None, 'show-expr', 'status(evalExpr(inputExpr("show expr="), cursorRow))', 'evaluate Python expression on current row and show result on status line')
+Sheet.addCommand(None, 'show-expr', 'status(evalExpr(inputExpr("show expr="), row=cursorRow, curcol=cursorCol))', 'evaluate Python expression on current row and show result on status line')
 
-vd.addGlobals({'CompleteExpr': CompleteExpr})
+vd.addGlobals(
+    ExprColumn=ExprColumn,
+    ColumnExpr=ExprColumn,
+    CompleteExpr=CompleteExpr,
+)
 
 vd.addMenuItems('''
     Edit > Modify > current cell > Python expression > setcell-expr