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

visidata/pyobj.py

@@ -1,9 +1,10 @@
-from functools import singledispatch
 from typing import Mapping
 import inspect
 import math
 
-from visidata import *
+from visidata import vd, asyncthread, ENTER, deduceType
+from visidata import Sheet, Column, VisiData, ColumnItem, TableSheet, BaseSheet, Progress, ColumnAttr, SuspendCurses, TextSheet
+import visidata
 
 vd.option('visibility', 0, 'visibility level')
 vd.option('default_sample_size', 100, 'number of rows to sample for regex.split (0=all)', replay=True)
@@ -16,177 +17,6 @@ class PythonSheet(Sheet):
         return PyobjSheet("%s[%s]" % (self.name, self.keystr(row)), source=row)
 
 
-class InferColumnsSheet(Sheet):
-    _rowtype = dict
-    @asyncthread
-    def reload(self):
-        self.reloadCols()
-
-        self.rows = []
-        for r in self.iterload():
-            self.addRow(r)
-
-        # if an ordering has been specified, sort the sheet
-        if self._ordering:
-            vd.sync(self.sort())
-
-    def reloadCols(self):
-        self.columns = []
-        self._knownKeys.clear()
-        for c in type(self).columns:
-            self.addColumn(deepcopy(c))
-
-    def addColumn(self, *cols, index=None):
-        for c in cols:
-            self._knownKeys.add(c.expr or c.name)
-        return super().addColumn(*cols, index=index)
-
-    def addRow(self, row, index=None):
-        ret = super().addRow(row, index=index)
-        for k in row:
-            if k not in self._knownKeys:
-                self.addColumn(ColumnItem(k, type=deduceType(row[k])))
-
-        return ret
-
-
-InferColumnsSheet.init('_knownKeys', set, copy=True)  # set of row keys already seen
-InferColumnsSheet.init('_ordering', list, copy=True)
-
-
-@Sheet.api
-def getSampleRows(sheet):
-    'Return list of sample rows centered around the cursor.'
-    n = sheet.options.default_sample_size
-    if n == 0 or n >= sheet.nRows:
-        return sheet.rows
-
-    vd.warning(f'sampling {n} rows')
-    seq = sheet.rows
-    start = math.ceil(sheet.cursorRowIndex - n / 2) % len(seq)
-    end = (start + n) % len(seq)
-    if start < end:
-        return seq[start:end]
-    return seq[start:] + seq[:end]
-
-
-@asyncthread
-def expand_cols_deep(sheet, cols, rows=None, depth=0):  # depth == 0 means drill all the way
-    'expand all visible columns of containers to the given depth (0=fully)'
-    ret = []
-    if not rows:
-        rows = sheet.getSampleRows()
-
-    for col in cols:
-        newcols = col.expand(rows)
-        if depth != 1:  # countdown not yet complete, or negative (indefinite)
-            ret.extend(expand_cols_deep.__wrapped__(sheet, newcols, rows, depth-1))
-    return ret
-
-@singledispatch
-def _createExpandedColumns(sampleValue, col, rows):
-    '''By default, a column is not expandable. Supported container types for
-    sampleValue trigger alternate, type-specific expansions.'''
-    return []
-
-@_createExpandedColumns.register(dict)
-def _(sampleValue, col, vals):
-    '''Build a set of columns to add, using the first occurrence of each key to
-    determine column type'''
-    newcols = {}
-
-    for val in Progress(vals, 'expanding'):
-        colsToAdd = set(val).difference(newcols)
-        colsToAdd and newcols.update({
-            k: deduceType(v)
-            for k, v in val.items()
-            if k in colsToAdd
-        })
-
-    return [
-        ExpandedColumn(col.sheet.options.fmt_expand_dict % (col.name, k), type=v, origCol=col, expr=k)
-            for k, v in newcols.items()
-    ]
-
-def _createExpandedColumnsNamedTuple(col, val):
-    return [
-        ExpandedColumn(col.sheet.options.fmt_expand_dict % (col.name, k), type=colType, origCol=col, expr=i)
-            for i, (k, colType) in enumerate(zip(val._fields, (deduceType(v) for v in val)))
-    ]
-
-@_createExpandedColumns.register(list)
-@_createExpandedColumns.register(tuple)
-def _(sampleValue, col, vals):
-    '''Use the longest sequence to determine the number of columns we need to
-    create, and their presumed types'''
-    def lenNoExceptions(v):
-        try:
-            return len(v)
-        except Exception as e:
-            return 0
-
-    if hasattr(sampleValue, '_fields'):  # looks like a namedtuple
-        return _createExpandedColumnsNamedTuple(col, vals[0])
-
-    longestSeq = max(vals, key=lenNoExceptions)
-    colTypes = [deduceType(v) for v in longestSeq]
-    return [
-        ExpandedColumn(col.sheet.options.fmt_expand_list % (col.name, k), type=colType, origCol=col, expr=k)
-            for k, colType in enumerate(colTypes)
-    ]
-
-
-@Column.api
-def expand(col, rows):
-    isNull = col.sheet.isNullFunc()
-    nonNulls = [
-        col.getTypedValue(row)
-        for row in rows
-        if not isNull(col.getValue(row))
-    ]
-
-    if not nonNulls:
-        return []
-
-    # The type of the first non-null value for col determines if and how the
-    # column can be expanded.
-    expandedCols = _createExpandedColumns(nonNulls[0], col, nonNulls)
-
-    idx = col.sheet.columns.index(col)
-
-    for i, c in enumerate(expandedCols):
-        col.sheet.addColumn(c, index=idx+i+1)
-    if expandedCols:
-        col.hide()
-    return expandedCols
-
-
-def deduceType(v):
-    if isinstance(v, (float, int)):
-        return type(v)
-    else:
-        return anytype
-
-
-class ExpandedColumn(Column):
-    def calcValue(self, row):
-        return getitemdef(self.origCol.getValue(row), self.expr)
-
-    def setValue(self, row, value):
-        self.origCol.getValue(row)[self.expr] = value
-
-
-def closeColumn(sheet, col):
-    if hasattr(col, 'origCol'):
-        origCol = col.origCol
-    else:
-        vd.fail('column has not been expanded')
-    vd.addUndo(setattr, sheet, 'columns', sheet.columns)
-    origCol.width = options.default_width
-    cols = [c for c in sheet.columns if getattr(c, "origCol", None) is not origCol]
-    sheet.columns = cols
-
-
 #### generic list/dict/object browsing
 @VisiData.global_api
 def view(vd, obj):
@@ -212,10 +42,10 @@ def SheetList(*names, **kwargs):
 
     src = kwargs.get('source', None)
     if not src:
-        vd.status('no content in %s' % names)
-        return
+        vd.warning('no content in %s' % names)
+        return Sheet(*names, **kwargs)
 
-    if isinstance(src[0], dict):
+    if isinstance(src[0], Mapping):
         return ListOfDictSheet(*names, **kwargs)
     elif isinstance(src[0], tuple):
         if getattr(src[0], '_fields', None):  # looks like a namedtuple
@@ -226,7 +56,7 @@ def SheetList(*names, **kwargs):
 
 class ListOfPyobjSheet(PythonSheet):
     rowtype = 'python objects'
-    def reload(self):
+    def loader(self):
         self.rows = self.source
         self.columns = []
         self.addColumn(Column(self.name,
@@ -275,7 +105,7 @@ class SheetNamedTuple(PythonSheet):
         self.rows = list(zip(self.source._fields, self.source))
 
     def openRow(self, row):
-        return PyobjSheet(self.name, row[0], source=row[1])
+        return PyobjSheet(f'{self.name}.{row[0]}', source=row[1])
 
 
 # source is dict
@@ -291,7 +121,7 @@ class SheetDict(PythonSheet):
         self.rows = list(self.source.keys())
 
     def openRow(self, row):
-        return PyobjSheet(self.name, row, source=self.source[row])
+        return PyobjSheet(f'{self.name}.{row}', source=self.source[row])
 
 
 class ColumnSourceAttr(Column):
@@ -347,10 +177,11 @@ class PyobjSheet(PythonSheet):
                 if vislevel <= 2 and r.startswith('__'): continue
                 if vislevel <= 1 and r.startswith('_'): continue
                 if vislevel <= 0 and callable(getattr(self.source, r)): continue
-                self.addRow(r)
             except Exception:
                 pass
 
+            self.addRow(r)
+
     def openRow(self, row):
         'dive further into Python object'
         v = getattr(self.source, row)
@@ -358,9 +189,13 @@ class PyobjSheet(PythonSheet):
 
 
 @TableSheet.api
-def openRow(sheet, row):
+def openRow(sheet, row, rowidx=None):
     'Return Sheet diving into *row*.'
-    k = sheet.keystr(row) or sheet.cursorRowIndex
+    if rowidx is None:
+        k = sheet.keystr(row) or str(sheet.cursorRowIndex)
+    else:
+        k = rowidx
+
     name = f'{sheet.name}[{k}]'
     return TableSheet(name,
                       rows=sheet.visibleCols,
@@ -372,40 +207,48 @@ def openRow(sheet, row):
                       nKeys=1)
 
 @TableSheet.api
-def openCell(sheet, col, row):
+def openCell(sheet, col, row, rowidx=None):
     'Return Sheet diving into cell at *row* in *col*.'
-    k = sheet.keystr(row) or [str(sheet.cursorRowIndex)]
+    if rowidx is None:
+        k = sheet.keystr(row) or str(sheet.cursorRowIndex)
+    else:
+        k = rowidx
     name = f'{sheet.name}[{k}].{col.name}'
     return PyobjSheet(name, source=col.getTypedValue(row))
 
+@TableSheet.api
+def openRowPyobj(sheet, rowidx):
+    'Return Sheet of raw Python object of row.'
+    return PyobjSheet("%s[%s]" % (sheet.name, rowidx), source=sheet.rows[rowidx])
+
+@TableSheet.api
+def openCellPyobj(sheet, col, rowidx):
+    'Return Sheet of raw Python object of cell.'
+    name = f'{sheet.name}[{rowidx}].{col.name}'
+    return PyobjSheet(name, source=col.getValue(sheet.rows[rowidx]))
+
 
 @BaseSheet.api
-def pyobj_expr(sheet):
+def inputPythonExpr(sheet):
     def launch_repl(v, i):
         import code
         with SuspendCurses():
             code.InteractiveConsole(locals=locals()).interact()
         return v, i
-    expr = vd.input("eval: ", "expr", completer=visidata.CompleteExpr(), bindings={'^X': launch_repl})
-    vd.push(PyobjSheet(expr, source=sheet.evalExpr(expr)))
+    return vd.input("eval: ", "expr", completer=visidata.CompleteExpr(), bindings={'^X': launch_repl})
 
-BaseSheet.addCommand('^X', 'pyobj-expr', 'pyobj_expr()', 'evaluate Python expression and open result as Python object')
+BaseSheet.addCommand('^X', 'pyobj-expr', 'expr=inputPythonExpr(); vd.push(PyobjSheet(expr, source=sheet.evalExpr(expr)))', 'evaluate Python expression and open result as Python object')
 BaseSheet.addCommand('', 'exec-python', 'expr = input("exec: ", "expr", completer=CompleteExpr()); exec(expr, getGlobals(), LazyChainMap(sheet, *vd.contexts, locals=vd.getGlobals()))', 'execute Python statement with expression scope')
 BaseSheet.addCommand('g^X', 'import-python', 'modname=input("import: ", type="import_python"); exec("import "+modname, getGlobals())', 'import Python module in the global scope')
-globalCommand('z^X', 'pyobj-expr-row', 'expr = input("eval over current row: ", "expr", completer=CompleteExpr()); vd.push(PyobjSheet(expr, source=evalExpr(expr, row=cursorRow)))', 'evaluate Python expression, in context of current row, and open result as Python object')
-
-Sheet.addCommand('^Y', 'pyobj-row', 'status(type(cursorRow)); vd.push(PyobjSheet("%s[%s]" % (sheet.name, cursorRowIndex), source=cursorRow))', 'open current row as Python object')
-Sheet.addCommand('z^Y', 'pyobj-cell', 'status(type(cursorValue)); vd.push(PyobjSheet("%s[%s].%s" % (sheet.name, cursorRowIndex, cursorCol.name), source=cursorValue))', 'open current cell as Python object')
-globalCommand('g^Y', 'pyobj-sheet', 'status(type(sheet)); vd.push(PyobjSheet(sheet.name+"_sheet", source=sheet))', 'open current sheet as Python object')
+BaseSheet.addCommand('z^X', 'pyobj-expr-row', 'expr = input("eval over current row: ", "expr", completer=CompleteExpr()); vd.push(PyobjSheet(expr, source=evalExpr(expr, row=cursorRow)))', 'evaluate Python expression, in context of current row, and open result as Python object')
+BaseSheet.addCommand('', 'assert-expr', 'expr=inputPythonExpr(); assert sheet.evalExpr(expr), f"{expr} not true"', 'eval Python expression and assert result is truthy')
+BaseSheet.addCommand('', 'assert-expr-row', 'expr=inputPythonExpr(); assert sheet.evalExpr(expr, row=cursorRow), f"{expr} not true"', 'eval Python expression in context of current row, and assert result is truthy')
 
-Sheet.addCommand('(', 'expand-col', 'expand_cols_deep(sheet, [cursorCol], depth=1)', 'expand current column of containers one level')
-Sheet.addCommand('g(', 'expand-cols', 'expand_cols_deep(sheet, visibleCols, depth=1)', 'expand all visible columns of containers one level')
-Sheet.addCommand('z(', 'expand-col-depth', 'expand_cols_deep(sheet, [cursorCol], depth=int(input("expand depth=", value=1)))', 'expand current column of containers to given depth (0=fully)')
-Sheet.addCommand('gz(', 'expand-cols-depth', 'expand_cols_deep(sheet, visibleCols, depth=int(input("expand depth=", value=1)))', 'expand all visible columns of containers to given depth (0=fully)')
+Sheet.addCommand('^Y', 'pyobj-row', 'status(type(cursorRow).__name__); vd.push(openRowPyobj(cursorRowIndex))', 'open current row as Python object')
+Sheet.addCommand('z^Y', 'pyobj-cell', 'status(type(cursorValue).__name__); vd.push(openCellPyobj(cursorCol, cursorRowIndex))', 'open current cell as Python object')
+BaseSheet.addCommand('g^Y', 'pyobj-sheet', 'status(type(sheet).__name__); vd.push(PyobjSheet(sheet.name+"_sheet", source=sheet))', 'open current sheet as Python object')
 
-Sheet.addCommand(')', 'contract-col', 'closeColumn(sheet, cursorCol)', 'unexpand current column; restore original column and remove other columns at this level')
-
-Sheet.addCommand('', 'open-row-basic', 'vd.push(TableSheet.openRow(sheet, cursorRow))', 'open sheet with open sheet with copies of rows referenced in current row')
+Sheet.addCommand('', 'open-row-basic', 'vd.push(TableSheet.openRow(sheet, cursorRow))', 'dive into current row as basic table (ignoring subsheet dive)')
 Sheet.addCommand(ENTER, 'open-row', 'vd.push(openRow(cursorRow))', 'open current row with sheet-specific dive')
 Sheet.addCommand('z'+ENTER, 'open-cell', 'vd.push(openCell(cursorCol, cursorRow))', 'open sheet with copies of rows referenced in current cell')
 Sheet.addCommand('g'+ENTER, 'dive-selected', 'for r in selectedRows: vd.push(openRow(r))', 'open sheet with copies of rows referenced in selected rows')
@@ -416,14 +259,21 @@ PyobjSheet.addCommand('gv', 'show-hidden', 'sheet.options.visibility = 2; reload
 PyobjSheet.addCommand('zv', 'hide-hidden', 'sheet.options.visibility -= 1; reload()', 'hide methods and hidden properties')
 
 vd.addGlobals({
-    'ExpandedColumn': ExpandedColumn,
     'PythonSheet': PythonSheet,
-    'expand_cols_deep': expand_cols_deep,
-    'deduceType': deduceType,
-    'closeColumn': closeColumn,
     'ListOfDictSheet': ListOfDictSheet,
     'SheetDict': SheetDict,
-    'InferColumnsSheet': InferColumnsSheet,
     'PyobjSheet': PyobjSheet,
     'view': view,
 })
+
+vd.addMenuItems('''
+    View > Visibility > Methods and dunder attributes > show > show-hidden
+    View > Visibility > Methods and dunder attributes > hide > hide-hidden
+    Row > Dive into > open-row
+    System > Python > import library > import-python
+    System > Python > current sheet > pyobj-sheet
+    System > Python > current row > pyobj-row
+    System > Python > current cell > pyobj-cell
+    System > Python > expression > pyobj-expr
+    System > Python > exec() > exec-python
+''')

visidata/rename_col.py

@@ -0,0 +1,20 @@
+from visidata import vd, Sheet
+
+@Sheet.api
+def hint_rename_col(sheet):
+    if vd.cleanName(sheet.cursorCol.name) != sheet.cursorCol.name:
+        return 5, f"[:hint]The current column can't be used in an expression because [:code]{sheet.cursorCol.name}[/] is not a valid Python identifier. [:onclick rename-col]Rename the column[/] with `^`.[/]"
+
+
+Sheet.addCommand('^', 'rename-col', 'vd.addUndoColNames([cursorCol]); cursorCol.name = editCell(cursorVisibleColIndex, -1, value=cleanName(cursorCol.name))', 'rename current column')
+Sheet.addCommand('z^', 'rename-col-selected', 'updateColNames(selectedRows or [cursorRow], [sheet.cursorCol], overwrite=True)', 'rename current column to combined contents of current cell in selected rows (or current row)')
+Sheet.addCommand('g^', 'rename-cols-row', 'updateColNames(selectedRows or [cursorRow], sheet.visibleCols)', 'rename all unnamed visible columns to contents of selected rows (or current row)')
+Sheet.addCommand('gz^', 'rename-cols-selected', 'updateColNames(selectedRows or [cursorRow], sheet.visibleCols, overwrite=True)', 'rename all visible columns to combined contents of selected rows (or current row)')
+
+
+vd.addMenuItems('''
+    Column > Rename > current column > rename-col
+    Column > Rename > from selected cells > current column > rename-col-selected
+    Column > Rename > from selected cells > unnamed columns > rename-cols-row
+    Column > Rename > from selected cells > all columns > rename-cols-selected
+''')

visidata/save.py

@@ -1,17 +1,17 @@
 import collections
+import os
 from copy import copy
 
-from visidata import *
+from visidata import vd
+from visidata import Sheet, BaseSheet, VisiData, IndexSheet, Path, Progress, TypedExceptionWrapper
 
-
-vd.option('confirm_overwrite', True, 'whether to prompt for overwrite confirmation on save')
 vd.option('safe_error', '#ERR', 'error string to use while saving', replay=True)
-vd.option('disp_formatter', 'generic', 'formatter to use for display and saving', replay=True)
+vd.option('save_encoding', 'utf-8', 'encoding passed to codecs.open when saving a file', replay=True, help=vd.help_encoding)
 
 @Sheet.api
 def safe_trdict(vs):
     'returns string.translate dictionary for replacing tabs and newlines'
-    if options.safety_first:
+    if vs.options.safety_first:
         delim = vs.options.delimiter
         return {
              0: '', #  strip NUL completely
@@ -38,7 +38,7 @@ def iterdispvals(sheet, *cols, format=False):
         if trdict:
             transformers[col].append(lambda v,trdict=trdict: v.translate(trdict))
 
-    options_safe_error = options.safe_error
+    options_safe_error = sheet.options.safe_error
     for r in Progress(sheet.rows):
         dispvals = collections.OrderedDict()  # [col] -> value
         for col, transforms in transformers.items():
@@ -85,7 +85,7 @@ def getDefaultSaveName(sheet):
             return str(src.with_suffix('')) + '.' + sheet.options.save_filetype
         return str(src)
     else:
-        return sheet.name+'.'+getattr(sheet, 'filetype', options.save_filetype)
+        return sheet.name+'.'+getattr(sheet, 'filetype', sheet.options.save_filetype)
 
 
 @VisiData.api
@@ -99,28 +99,32 @@ def save_cols(vd, cols):
     else:
         savedcoltxt = '%s columns' % len(cols)
     path = vd.inputPath('save %s to: ' % savedcoltxt, value=vs.getDefaultSaveName())
-    vd.saveSheets(path, vs, confirm_overwrite=options.confirm_overwrite)
+    vd.saveSheets(path, vs)
 
 
 @VisiData.api
-def saveSheets(vd, givenpath, *vsheets, confirm_overwrite=False):
+def saveSheets(vd, givenpath, *vsheets, confirm_overwrite=True):
     'Save all *vsheets* to *givenpath*.'
 
     if not vsheets: # blank tuple
         vd.warning('no sheets to save')
         return
 
-    filetype = givenpath.ext or options.save_filetype
+    filetypes = [givenpath.ext, vd.options.save_filetype]
 
     vd.clearCaches()
 
-    savefunc = getattr(vsheets[0], 'save_' + filetype, None) or getattr(vd, 'save_' + filetype, None)
+    for ft in filetypes:
+        savefunc = getattr(vsheets[0], 'save_' + ft, None) or getattr(vd, 'save_' + ft, None)
+        if savefunc:
+            filetype = ft
+            break
 
     if savefunc is None:
         vd.fail(f'no function to save as {filetype}')
 
-    if givenpath.exists() and confirm_overwrite:
-        vd.confirm("%s already exists. overwrite? " % givenpath.given)
+    if confirm_overwrite:
+        vd.confirmOverwrite(givenpath)
 
     vd.status('saving %s sheets to %s as %s' % (len(vsheets), givenpath.given, filetype))
 
@@ -149,6 +153,9 @@ def saveSheets(vd, givenpath, *vsheets, confirm_overwrite=False):
             p = Path((givenpath / vs.name).with_suffix('.'+filetype))
             savefunc(p, vs)
             vs.hasBeenModified = False
+
+        vd.status(f'{givenpath} save finished')  #2157
+
     return vd.execAsync(_savefiles, vsheets, givenpath, savefunc, filetype)
 
 
@@ -166,19 +173,20 @@ def save_zip(vd, p, *vsheets):
                 savefunc = getattr(vs, 'save_' + filetype, None) or getattr(vd, 'save_' + filetype, None)
                 savefunc(tmpp, vs)
                 zfp.write(tmpp, f'{vs.name}.{vs.options.save_filetype}')
-    vd.status('%s save finished' % p)
 
 
 @VisiData.api
 def save_txt(vd, p, *vsheets):
-    with p.open_text(mode='w', encoding=vsheets[0].options.encoding) as fp:
+    if len(vsheets) == 1 and vsheets[0].nVisibleCols > 1:  #2173
+        return vd.save_tsv(p, vsheets[0])
+
+    with p.open(mode='w', encoding=vsheets[0].options.save_encoding) as fp:
         for vs in vsheets:
             unitsep = vs.options.delimiter
             rowsep = vs.options.row_delimiter
             for dispvals in vs.iterdispvals(*vs.visibleCols, format=True):
                 fp.write(unitsep.join(dispvals.values()))
                 fp.write(rowsep)
-    vd.status('%s save finished' % p)
 
 
 @BaseSheet.api
@@ -189,9 +197,18 @@ def rootSheet(sheet):
 
     return r
 
-BaseSheet.addCommand('^S', 'save-sheet', 'vd.saveSheets(inputPath("save to: ", value=getDefaultSaveName()), sheet, confirm_overwrite=options.confirm_overwrite)', 'save current sheet to filename in format determined by extension (default .tsv)')
-BaseSheet.addCommand('', 'save-source', 'vd.saveSheets(rootSheet().source, rootSheet(), confirm_overwrite=options.confirm_overwrite)', 'save root sheet to its source')
-BaseSheet.addCommand('g^S', 'save-all', 'vd.saveSheets(inputPath("save all sheets to: "), *vd.stackedSheets, confirm_overwrite=options.confirm_overwrite)', 'save all sheets to given file or directory)')
-IndexSheet.addCommand('g^S', 'save-selected', 'vd.saveSheets(inputPath("save %d sheets to: " % nSelectedRows, value="_".join(getattr(vs, "name", None) or "blank" for vs in selectedRows)), *selectedRows, confirm_overwrite=options.confirm_overwrite)', 'save all selected sheets to given file or directory')
+
+BaseSheet.addCommand('^S', 'save-sheet', 'vd.saveSheets(inputPath("save to: ", value=getDefaultSaveName()), sheet)', 'save current sheet to filename in format determined by extension (default .tsv)')
+BaseSheet.addCommand('', 'save-sheet-really', 'vd.saveSheets(Path(getDefaultSaveName()), sheet, confirm_overwrite=False)', 'save current sheet without asking for filename or confirmation')
+BaseSheet.addCommand('', 'save-source', 'vd.saveSheets(rootSheet().source, rootSheet())', 'save root sheet to its source')
+BaseSheet.addCommand('g^S', 'save-all', 'vd.saveSheets(inputPath("save all sheets to: "), *vd.stackedSheets)', 'save all sheets to given file or directory)')
+IndexSheet.addCommand('g^S', 'save-selected', 'vd.saveSheets(inputPath("save %d sheets to: " % nSelectedRows, value="_".join(getattr(vs, "name", None) or "blank" for vs in selectedRows)), *selectedRows)', 'save all selected sheets to given file or directory')
 Sheet.addCommand('', 'save-col', 'save_cols([cursorCol])', 'save current column only to filename in format determined by extension (default .tsv)')
 Sheet.addCommand('', 'save-col-keys', 'save_cols(keyCols + [cursorCol])', 'save key columns and current column to filename in format determined by extension (default .tsv)')
+
+vd.addMenuItems('''
+    File > Save > current sheet > save-sheet
+    File > Save > all sheets > save-all
+    File > Save > current column > save-col
+    File > Save > keys and current column > save-col-keys
+''')

visidata/search.py

@@ -3,6 +3,15 @@ from visidata import vd, VisiData, BaseSheet, Sheet, Column, Progress, asyncthre
 
 VisiData.init('searchContext', dict) # [(regex, columns, backward)] -> kwargs from previous search
 
+vd.help_regex_flags = '''# Regex Flags Help
+- `A` (ASCII) ASCII-only matching (not unicode)
+- `I` (IGNORECASE): case-insensitive matching
+- `M` (MULTILINE): `^` and `$` match after/before newlines
+- `S` (DOTALL): `.` match any character at all, including newline
+- `X` (VERBOSE): allow verbose regex
+'''
+
+
 @VisiData.api
 @asyncthread
 def moveRegex(vd, sheet, *args, **kwargs):
@@ -11,7 +20,7 @@ def moveRegex(vd, sheet, *args, **kwargs):
 
 # kwargs: regex=None, columns=None, backward=False
 @VisiData.api
-def searchRegex(vd, sheet, moveCursor=False, reverse=False, **kwargs):
+def searchRegex(vd, sheet, moveCursor=False, reverse=False, regex_flags=None, **kwargs):
         'Set row index if moveCursor, otherwise return list of row indexes.'
         def findMatchingColumn(sheet, row, columns, func):
             'Find column for which func matches the displayed value in this row'
@@ -23,7 +32,15 @@ def searchRegex(vd, sheet, moveCursor=False, reverse=False, **kwargs):
 
         regex = kwargs.get("regex")
         if regex:
-            vd.searchContext["regex"] = re.compile(regex, sheet.regex_flags()) or vd.error('invalid regex: %s' % regex)
+            if regex_flags is None:
+                regex_flags = sheet.options.regex_flags  # regex_flags defined in features.regex
+            flagbits = sum(getattr(re, f.upper()) for f in regex_flags)
+            try:
+                compiled_re = re.compile(regex, flagbits)
+                vd.searchContext["regex"] = compiled_re
+            except re.error as e:
+                vd.searchContext["regex"] = None  # make future calls to search-next fail
+                vd.error('invalid regex: %s' % e.msg)
 
         regex = vd.searchContext.get("regex") or vd.fail("no regex")
 
@@ -54,8 +71,23 @@ def searchRegex(vd, sheet, moveCursor=False, reverse=False, **kwargs):
                     matchingRowIndexes += 1
                     yield rowidx
 
-        vd.status('%s matches for /%s/' % (matchingRowIndexes, regex.pattern))
+        if kwargs.get('printStatus', True):
+            vd.status('%s matches for /%s/' % (matchingRowIndexes, regex.pattern))
+
+
+@Sheet.api
+def searchInputRegex(sheet, action:str, columns:str='cursorCol'):
+    r = vd.inputMultiple(regex=dict(prompt=f"{action} regex: ", type="regex", defaultLast=True, help=vd.help_regex),
+                         flags=dict(prompt="regex flags: ", type="regex_flags", value=sheet.options.regex_flags, help=vd.help_regex_flags))
 
+    return vd.searchRegex(sheet, regex=r['regex'], regex_flags=r['flags'], columns=columns)
+
+@Sheet.api
+def moveInputRegex(sheet, action:str, type="regex", **kwargs):
+    r = vd.inputMultiple(regex=dict(prompt=f"{action} regex: ", type=type, defaultLast=True, help=vd.help_regex),
+                         flags=dict(prompt="regex flags: ", type="regex_flags", value=sheet.options.regex_flags, help=vd.help_regex_flags))
+
+    return vd.moveRegex(sheet, regex=r['regex'], regex_flags=r['flags'], **kwargs)
 
 @Sheet.api
 @asyncthread
@@ -71,13 +103,25 @@ def search_expr(sheet, expr, reverse=False):
     vd.fail(f'no {sheet.rowtype} where {expr}')
 
 
-Sheet.addCommand('r', 'search-keys', 'tmp=cursorVisibleColIndex; vd.moveRegex(sheet, regex=input("row key regex: ", type="regex-row", defaultLast=True), columns=keyCols or [visibleCols[0]]); sheet.cursorVisibleColIndex=tmp', 'go to next row with key matching regex')
-Sheet.addCommand('/', 'search-col', 'vd.moveRegex(sheet, regex=input("/", type="regex", defaultLast=True), columns="cursorCol", backward=False)', 'search for regex forwards in current column'),
-Sheet.addCommand('?', 'searchr-col', 'vd.moveRegex(sheet, regex=input("?", type="regex", defaultLast=True), columns="cursorCol", backward=True)', 'search for regex backwards in current column'),
-Sheet.addCommand('n', 'search-next', 'vd.moveRegex(sheet, reverse=False)', 'go to next match from last regex search'),
-Sheet.addCommand('N', 'searchr-next', 'vd.moveRegex(sheet, reverse=True)', 'go to previous match from last regex search'),
+Sheet.addCommand('r', 'search-keys', 'tmp=cursorVisibleColIndex; moveInputRegex("row key", type="regex-row", columns=keyCols or [visibleCols[0]]); sheet.cursorVisibleColIndex=tmp', 'go to next row with key matching regex')
+Sheet.addCommand('/', 'search-col', 'moveInputRegex("search", columns="cursorCol", backward=False)', 'search for regex forwards in current column')
+Sheet.addCommand('?', 'searchr-col', 'moveInputRegex("reverse search", columns="cursorCol", backward=True)', 'search for regex backwards in current column')
+Sheet.addCommand('n', 'search-next', 'vd.moveRegex(sheet, reverse=False)', 'go to next match from last regex search')
+Sheet.addCommand('N', 'searchr-next', 'vd.moveRegex(sheet, reverse=True)', 'go to previous match from last regex search')
 
-Sheet.addCommand('g/', 'search-cols', 'vd.moveRegex(sheet, regex=input("g/", type="regex", defaultLast=True), backward=False, columns="visibleCols")', 'search for regex forwards over all visible columns'),
-Sheet.addCommand('g?', 'searchr-cols', 'vd.moveRegex(sheet, regex=input("g?", type="regex", defaultLast=True), backward=True, columns="visibleCols")', 'search for regex backwards over all visible columns'),
+Sheet.addCommand('g/', 'search-cols', 'moveInputRegex("g/", backward=False, columns="visibleCols")', 'search for regex forwards over all visible columns')
+Sheet.addCommand('g?', 'searchr-cols', 'moveInputRegex("g?", backward=True, columns="visibleCols")', 'search for regex backwards over all visible columns')
 Sheet.addCommand('z/', 'search-expr', 'search_expr(inputExpr("search by expr: ") or fail("no expr"))', 'search by Python expression forwards in current column (with column names as variables)')
 Sheet.addCommand('z?', 'searchr-expr', 'search_expr(inputExpr("searchr by expr: ") or fail("no expr"), reverse=True)', 'search by Python expression backwards in current column (with column names as variables)')
+
+vd.addMenuItems('''
+    View > Search > current column > search-col
+    View > Search > visible columns > search-cols
+    View > Search > key columns > search-keys
+    View > Search > by Python expr > search-expr
+    View > Search > again > search-next
+    View > Search backward > current column > searchr-col
+    View > Search backward > visible columns > searchr-cols
+    View > Search backward > by Python expr > searchr-expr
+    View > Search backward > again > searchr-next
+''')