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

visidata/metasheets.py

@@ -29,10 +29,9 @@ Some new commands on this sheet operate on all selected columns on the source sh
 - {help.commands.type_int_selected}
 - or `g` with any standard type to set type of selected source columns to that type
 
-## As usual
+Other commands (not specific to Columns Sheet):
 
 - {help.commands.setcol_input}
-{sheet.help_columns}
 '''
 
     class ValueColumn(Column):
@@ -47,15 +46,15 @@ Some new commands on this sheet operate on all selected columns on the source sh
             ColumnAttr('name', help='rename the column on the source sheet'),
             ColumnAttr('keycol', type=int, width=0),
             ColumnAttr('width', type=int, help='set the column width (`0` to hide completely)'),
-            ColumnAttr('height', type=int, max_help=1, help='set a maximum height for the row, if this column will fill it'),
+            ColumnAttr('height', type=int, disp_expert=1, help='set a maximum height for the row, if this column will fill it'),
             ColumnAttr('hoffset', type=int, width=0),
             ColumnAttr('voffset', type=int, width=0),
             ColumnAttr('type', 'typestr', help='convert all values to a specific type'),
             ColumnAttr('fmtstr', help='use a custom format string, either C-style (`%0.4f`) or Python-style (`{{:0.4f}}`)'),
-            ColumnAttr('formatter', max_help=1, help='use a custom format function (**{col.help_formatters}**)'),
-            ColumnAttr('displayer', max_help=1, help='use a custom display function (**{col.help_displayers}**)'),
+            ColumnAttr('formatter', disp_expert=1, help='use a custom format function (**{col.help_formatters}**)'),
+            ColumnAttr('displayer', disp_expert=1, help='use a custom display function (**{col.help_displayers}**)'),
             ValueColumn('value', help='change the value of this cell on the source sheet'),
-            ColumnAttr('expr', max_help=1, help='change the main column parameter'),
+            ColumnAttr('expr', disp_expert=1, help='change the main column parameter'),
             ColumnAttr('ncalcs', type=int, width=0, cache=False),
             ColumnAttr('maxtime', type=float, width=0, cache=False),
             ColumnAttr('totaltime', type=float, width=0, cache=False),

visidata/modify.py

@@ -65,7 +65,7 @@ def rowAdded(self, row):
     self._deferredAdds[self.rowid(row)] = row
     def _undoRowAdded(sheet, row):
         if sheet.rowid(row) not in sheet._deferredAdds:
-            vd.warning('cannot undo to before commit')
+            vd.warning('cannot undo row addition after a commit')
             return
         del sheet._deferredAdds[sheet.rowid(row)]
     vd.addUndo(_undoRowAdded, self, row)
@@ -87,7 +87,7 @@ def cellChanged(col, row, val):
             if oldval == col.getSourceValue(row):
                 # if we have reached the original value, remove from defermods entirely
                 if col.sheet.rowid(row) not in col.sheet._deferredMods:
-                    vd.warning('cannot undo to before commit')
+                    vd.warning('cannot undo cell change after a commit')
                     return
                 del col.sheet._deferredMods[col.sheet.rowid(row)]
             else:
@@ -105,7 +105,7 @@ def rowDeleted(self, row):
     self.unselectRow(row)
     def _undoRowDeleted(sheet, row):
         if sheet.rowid(row) not in sheet._deferredDels:
-            vd.warning('cannot undo to before commit')
+            vd.warning('cannot undo row deletion after a commit')
             return
         del sheet._deferredDels[sheet.rowid(row)]
     vd.addUndo(_undoRowDeleted, self, row)
@@ -330,7 +330,7 @@ def new_rows(sheet, n):
     return [sheet.newRow() for i in range(n)]
 
 Sheet.addCommand('a', 'add-row', 'addRows([newRow()], index=cursorRowIndex); cursorDown(1)', 'append a blank row')
-Sheet.addCommand('ga', 'add-rows', 'n=int(input("add rows: ", value=1)); addRows(new_rows(n), index=cursorRowIndex); cursorDown(1)', 'append N blank rows')
+Sheet.addCommand('ga', 'add-rows', 'n=int(input("add # rows: ", value=1)); addRows(new_rows(n), index=cursorRowIndex); cursorDown(1)', 'append N blank rows')
 Sheet.addCommand('za', 'addcol-new', 'addColumnAtCursor(SettableColumn(input("column name: ")))', 'append an empty column')
 Sheet.addCommand('gza', 'addcol-bulk', 'addColumnAtCursor(*(SettableColumn() for c in range(int(input("add columns: ")))))', 'append N empty columns')
 

visidata/mouse.py

@@ -62,6 +62,8 @@ def parseMouse(vd, **kwargs):
     keystroke = clicktype + curses.mouseEvents.get(bstate, str(bstate))
     ret = AttrDict(keystroke=keystroke, y=y, x=x, found=[])
     for winname, winscr in kwargs.items():
+        if not winscr:
+            continue
         px, py = vd.getrootxy(winscr)
         mh, mw = winscr.getmaxyx()
         if py <= y < py+mh and px <= x < px+mw:

visidata/movement.py

@@ -1,11 +1,10 @@
 import itertools
-import re
 
-from visidata import vd, VisiData, BaseSheet, Sheet, Column, Progress, ALT, asyncthread
+from visidata import vd, BaseSheet, Sheet, Column, Progress, ALT, asyncthread
 
 
 def rotateRange(n, idx, reverse=False):
-    'Wraps an iter starting from idx. Yields indices from idx to n and then 0 to idx.'
+    'Wraps an iter starting from idx. Yields indices from idx+1 to n and then 0 to idx, or from idx-1 to 0 and n-1 to idx.'
     if n == 0: return []
     if reverse:
         rng = range(idx-1, -1, -1)
@@ -81,18 +80,6 @@ def moveToNextRow(vs, func, reverse=False, msg='no different value up this colum
         vd.status(msg)
 
 
-@Sheet.api
-def nextColRegex(sheet, colregex):
-    'Go to first visible column after the cursor matching `colregex`.'
-    pivot = sheet.cursorVisibleColIndex
-    for i in itertools.chain(range(pivot+1, len(sheet.visibleCols)), range(0, pivot+1)):
-        c = sheet.visibleCols[i]
-        if re.search(colregex, c.name, sheet.regex_flags()):
-            return i
-
-    vd.fail('no column name matches /%s/' % colregex)
-
-
 @Column.property
 def visibleWidth(self):
     'Width of column as is displayed in terminal'
@@ -102,20 +89,18 @@ def visibleWidth(self):
     return self.sheet._visibleColLayout[vcolidx][1]
 
 
-Sheet.addCommand(None, 'go-left',  'cursorRight(-1)', 'go left')
-Sheet.addCommand(None, 'go-down',  'cursorDown(+1)', 'go down')
-Sheet.addCommand(None, 'go-up',    'cursorDown(-1)', 'go up')
-Sheet.addCommand(None, 'go-right', 'cursorRight(+1)', 'go right')
-Sheet.addCommand(None, 'go-pagedown', 'cursorDown(nScreenRows-1); sheet.topRowIndex = bottomRowIndex', 'scroll one page forward')
-Sheet.addCommand(None, 'go-pageup', 'cursorDown(-nScreenRows+1); sheet.bottomRowIndex = topRowIndex', 'scroll one page backward')
+Sheet.addCommand(None, 'go-left',  'cursorRight(-1)', 'go left', replay=False)
+Sheet.addCommand(None, 'go-down',  'cursorDown(+1)', 'go down', replay=False)
+Sheet.addCommand(None, 'go-up',    'cursorDown(-1)', 'go up', replay=False)
+Sheet.addCommand(None, 'go-right', 'cursorRight(+1)', 'go right', replay=False)
+Sheet.addCommand(None, 'go-pagedown', 'cursorDown(nScreenRows-1); sheet.topRowIndex = bottomRowIndex', 'scroll one page forward', replay=False)
+Sheet.addCommand(None, 'go-pageup', 'cursorDown(-nScreenRows+1); sheet.bottomRowIndex = topRowIndex', 'scroll one page backward', replay=False)
 
 Sheet.addCommand(None, 'go-leftmost', 'sheet.cursorVisibleColIndex = sheet.leftVisibleColIndex = 0', 'go all the way to the left of sheet')
 Sheet.addCommand(None, 'go-top', 'sheet.cursorRowIndex = sheet.topRowIndex = 0', 'go all the way to the top of sheet')
-Sheet.addCommand(None, 'go-bottom', 'sheet.cursorRowIndex = len(rows); sheet.topRowIndex = cursorRowIndex-nScreenRows', 'go all the way to the bottom of sheet')
+Sheet.addCommand(None, 'go-bottom', 'sheet.cursorRowIndex = sheet.bottomRowIndex = len(rows)-1', 'go all the way to the bottom of sheet')
 Sheet.addCommand(None, 'go-rightmost', 'sheet.leftVisibleColIndex = len(visibleCols)-1; pageLeft(); sheet.cursorVisibleColIndex = len(visibleCols)-1', 'go all the way to the right of sheet')
 
-Sheet.addCommand('c', 'go-col-regex', 'sheet.cursorVisibleColIndex=nextColRegex(inputRegex("column name regex: ", type="regex-col", defaultLast=True))', 'go to next column with name matching regex')
-Sheet.addCommand('zc', 'go-col-number', 'sheet.cursorVisibleColIndex = int(input("move to column number: "))', 'go to given column number (0-based)')
 Sheet.addCommand('zr', 'go-row-number', 'sheet.cursorRowIndex = int(input("move to row number: "))', 'go to the given row number (0-based)')
 
 
@@ -130,6 +115,9 @@ Sheet.addCommand('z>', 'go-next-null', 'moveToNextRow(lambda row,col=cursorCol,i
 for i in range(1, 11):
     BaseSheet.addCommand(ALT+str(i)[-1], 'jump-sheet-'+str(i), f'vd.push(*(list(s for s in allSheets if s.shortcut==str({i})) or fail("no sheet")))', f'jump to sheet {i}')
 
+for i in range(11, 21):
+    BaseSheet.addCommand('', 'jump-sheet-'+str(i), f'vd.push(*(list(s for s in allSheets if s.shortcut==str({i})) or fail("no sheet")))', f'jump to sheet {i}')
+
 BaseSheet.bindkey('KEY_LEFT', 'go-left')
 BaseSheet.bindkey('KEY_DOWN', 'go-down')
 BaseSheet.bindkey('KEY_UP', 'go-up')
@@ -150,8 +138,8 @@ Sheet.bindkey('BUTTON3_PRESSED', 'go-mouse')
 # vim-style scrolling with the 'z' prefix
 Sheet.addCommand('zz', 'scroll-middle', 'sheet.topRowIndex = cursorRowIndex-int(nScreenRows/2)', 'scroll current row to center of screen')
 
-Sheet.addCommand('kRIT5', 'go-right-page', 'sheet.cursorVisibleColIndex = sheet.leftVisibleColIndex = rightVisibleColIndex', 'scroll cursor one page right')
-Sheet.addCommand('kLFT5', 'go-left-page', 'pageLeft()', 'scroll cursor one page left')
+Sheet.addCommand('kRIT5', 'go-right-page', 'sheet.cursorVisibleColIndex = sheet.leftVisibleColIndex = rightVisibleColIndex', 'scroll cursor one page right', replay=False)
+Sheet.addCommand('kLFT5', 'go-left-page', 'pageLeft()', 'scroll cursor one page left', replay=False)
 Sheet.addCommand(None, 'scroll-left', 'sheet.cursorVisibleColIndex -= options.scroll_incr', 'scroll one column left')
 Sheet.addCommand(None, 'scroll-right', 'sheet.cursorVisibleColIndex += options.scroll_incr', 'scroll one column right')
 Sheet.addCommand(None, 'scroll-leftmost', 'sheet.leftVisibleColIndex = cursorVisibleColIndex', 'scroll sheet to leftmost column')
@@ -207,8 +195,6 @@ vd.addGlobals({'rotateRange': rotateRange})
 vd.addMenuItems('''
     View > Other sheet > previous sheet > jump-prev
     View > Other sheet > first sheet > jump-first
-    Column > Goto > by number > go-col-number
-    Column > Goto > by name > go-col-regex
     Row > Goto > top > go-top
     Row > Goto > bottom > go-bottom
     Row > Goto > previous > page > go-pageup

visidata/optionssheet.py

@@ -17,14 +17,14 @@ class OptionsSheet(Sheet):
     precious = False
     columns = (
         Column('option', getter=lambda col,row: row.name),
-        Column('module', getter=lambda col,row: row.module, max_help=1),
+        Column('module', getter=lambda col,row: row.module, disp_expert=1),
         Column('value',
             getter=lambda col,row: col.sheet.diffOption(row.name),
-            setter=lambda col,row,val: col.sheet.source.options.set(row.name, val)
+            setter=lambda col,row,val: vd.options.set(row.name, val, col.sheet.source)
             ),
         Column('default', getter=lambda col,row: vd.options.getdefault(row.name)),
         Column('description', width=40, getter=lambda col,row: vd.options._get(row.name, 'default').helpstr),
-        AttrColumn('replayable', max_help=1),
+        AttrColumn('replayable', disp_expert=1),
     )
     colorizers = [
         CellColorizer(3, None, lambda s,c,r,v: v.value if r and c in s.columns[2:4] and r.name.startswith('color_') else None),
@@ -73,8 +73,6 @@ class OptionsSheet(Sheet):
     def iterload(self):
         for k in vd.options.keys():
             v = vd.options._get(k)
-#            if vd.options.disp_help > v.max_help:
-#                continue
             if v.sheettype in [None, BaseSheet]:
                 yield v
             elif self.source != 'global' and v.sheettype in self.source.superclasses():

visidata/path.py

@@ -111,6 +111,7 @@ class FileProgress:
 
         # track Progress on original fp
         self.fp_orig_read = self.fp.read
+        self.fp_orig_readline = self.fp.readline
         self.fp_orig_close = self.fp.close
 
         self.fp.read = self.read
@@ -132,6 +133,12 @@ class FileProgress:
                 self.prog.addProgress(len(r))
         return r
 
+    def readline(self, size=-1):
+        r = self.fp_orig_readline(size)
+        if self.prog:
+            self.prog.addProgress(len(r))
+        return r
+
     def __getattr__(self, k):
         return getattr(self.fp, k)
 
@@ -172,10 +179,6 @@ class Path(os.PathLike):
         'Filename without any extensions.  Not the same as pathlib.Path.'
         return self.base_stem
 
-    @lru_cache()
-    def stat(self, force=False):
-        return self._path.stat()
-
     @property
     def given(self):
         'The path as given to the constructor.'
@@ -222,7 +225,7 @@ class Path(os.PathLike):
         return self._path.__fspath__()
 
     def __lt__(self, a):
-        if isinstance(a, visidata.Path):
+        if isinstance(a, Path):
             return self._path.__lt__(a._path)
         return self._path.__lt__(a)
 
@@ -234,27 +237,50 @@ class Path(os.PathLike):
         return bool(self.fp or self.fptext)
 
     def open(self, mode='rt', encoding=None, encoding_errors=None, newline=None):
-        'Open path in text or binary mode, using options.encoding and options.encoding_errors.  Return open file-pointer or file-pointer-like.'
+        if 'b' in mode:
+            return self.open_bytes(mode)
+
+        return self.open_text(mode=mode, encoding=encoding, encoding_errors=encoding_errors, newline=newline)
+
+    def open_bytes(self, mode='rb'):
+        'Open the file pointed by this path and return a file object in binary mode.'
+        if self.rfile:
+            raise ValueError('a RepeatFile holds text and cannot be reopened in binary mode')
+
+        if 'b' not in mode:
+            mode += 'b'
+
+        if self.given == '-':
+            if 'r' in mode:
+                return os.fdopen(vd._stdin.fileno(), 'rb')
+            elif 'w' in mode or 'a' in mode:
+                # convert 'a' to 'w' for stdout: https://bugs.python.org/issue27805
+                return os.dup(vd._stdout.fileno())
+            else:
+                vd.error('invalid mode "%s" for Path.open()' % mode)
+                return sys.stderr
+
+        return self._open(mode=mode)
+
+    def open_text(self, mode='rt', encoding=None, encoding_errors=None, newline=None):
+        'Open path in text mode, using options.encoding and options.encoding_errors.  Return open file-pointer or file-pointer-like.'
         # rfile makes a single-access fp reusable
 
+        if 't' not in mode:
+            mode += 't'
+
         if self.rfile:
-            if 'b' in mode:
-                raise ValueError('a RepeatFile holds text and cannot be reopened in binary mode')
             return self.rfile.reopen()
 
-        if self.fp:
-            if 'b' not in mode:
-                self.fptext = codecs.iterdecode(self.fp,
-                                                encoding=encoding or vd.options.encoding,
-                                                errors=encoding_errors or vd.options.encoding_errors)
+        if self.fp and not self.fptext:
+            self.fptext = codecs.iterdecode(self.fp,
+                                            encoding=encoding or vd.options.encoding,
+                                            errors=encoding_errors or vd.options.encoding_errors)
 
         if self.fptext:
             self.rfile = RepeatFile(self.fptext)
             return self.rfile
 
-        if 't' not in mode and 'b' not in mode:
-            mode += 't'
-
         if self.given == '-':
             if 'r' in mode:
                 return vd._stdin
@@ -265,10 +291,7 @@ class Path(os.PathLike):
                 vd.error('invalid mode "%s" for Path.open()' % mode)
                 return sys.stderr
 
-        if 'b' in mode:
-            return self._open(mode=mode)
-        else:
-            return self._open(mode=mode, encoding=encoding or vd.options.encoding, errors=vd.options.encoding_errors, newline=newline)
+        return self._open(mode=mode, encoding=encoding or vd.options.encoding, errors=vd.options.encoding_errors, newline=newline)
 
     @wraps(pathlib.Path.read_text)
     def read_text(self, *args, **kwargs):
@@ -282,6 +305,8 @@ class Path(os.PathLike):
             return RepeatFile(self.lines).read()
         elif self.fp:
             return self.fp.read()
+        elif self.fptext:
+            return self.fptext.read()
         else:
             return self._path.read_text(*args, **kwargs)
 
@@ -324,12 +349,6 @@ class Path(os.PathLike):
                     prog.addProgress(len(line))
                     yield line.rstrip('\n')
 
-    def open_bytes(self, mode='rb'):
-        'Open the file pointed by this path and return a file object in binary mode.'
-        if 'b' not in mode:
-            mode += 'b'
-        return self.open(mode=mode)  #1880
-
     def read_bytes(self):
         'Return the entire binary contents of the pointed-to file as a bytes object.'
         with self.open(mode='rb') as fp:
@@ -337,12 +356,12 @@ class Path(os.PathLike):
 
     @wraps(pathlib.Path.is_fifo)
     def is_fifo(self):
-        'Return True if the path is a file.'
+        'Return True if the path is a fifo.'
         return self._path.is_fifo()
 
     def is_local(self):
         'Return True if self.filename refers to a file on the local disk.'
-        return not bool(self.fp) and not bool(self.fptext)
+        return not bool(self.is_url()) and not bool(self.fp) and not bool(self.fptext)
 
     def is_url(self):
         'Return True if the given path appears to be a URL.'
@@ -406,21 +425,24 @@ class RepeatFile:
         return RepeatFile(self.iter_lines, lines=self.lines)
 
     def read(self, n=None):
-        r = None
+        '''Returns a string or bytes object. Unlike the standard read() function, when *n* is given, more than *n* characters/bytes can be returned, and often will.'''
         if n is None:
             n = 10**12  # some too huge number
-        while r is None or len(r) < n:
+        r = []
+        size = 0
+        output_type = str; eol = '\n'; joiner = ''
+        while not r or size < n:
             try:
                 s = next(self.iter)
-                if r is None:
-                    r = '' if isinstance(s, str) else b''
-                else:
-                    assert isinstance(r, type(s)), (r, type(s))
-
-                r += s + '\n' if isinstance(s, str) else b'\n'
+                if not r and isinstance(s, bytes):
+                    output_type = bytes; eol = b'\n'; joiner = b''
+                assert isinstance(s, output_type), (s, output_type)
+                r.append(s)
+                r.append(eol)
+                size += len(s) + len(eol)
             except StopIteration:
                 break  # end of file
-        return r or ''
+        return joiner.join(r)
 
     def write(self, s):
         return self.iter_lines.write(s)

visidata/pivot.py

@@ -53,7 +53,7 @@ class AggrColumn(Column):
     def calcValue(col, row):
         if col.sheet.loading:
             return visidata.INPROGRESS
-        return col.aggregator(col.origCol, row.sourcerows)
+        return col.aggregator.aggregate(col.origCol, row.sourcerows)
 
 
 def makeAggrColumn(aggcol, aggregator):
@@ -175,13 +175,13 @@ class PivotSheet(Sheet):
                         c = Column(colname,
                                     type=aggregator.type or aggcol.type,
                                     aggvalue=value,
-                                    getter=lambda col,row,aggcol=aggcol,agg=aggregator: agg(aggcol, row.pivotrows.get(col.aggvalue, [])))
+                                    getter=lambda col,row,aggcol=aggcol,agg=aggregator: agg.aggregate(aggcol, row.pivotrows.get(col.aggvalue, [])))
                         self.addColumn(c)
 
 #                    if aggregator.name != 'count':  # already have count above
 #                        c = Column('Total_' + aggcol.name,
 #                                    type=aggregator.type or aggcol.type,
-#                                    getter=lambda col,row,aggcol=aggcol,agg=aggregator: agg(aggcol, row.sourcerows))
+#                                    getter=lambda col,row,aggcol=aggcol,agg=aggregator: agg.aggregate(aggcol, row.sourcerows))
 #                        self.addColumn(c)
 
     @asyncthread
@@ -291,8 +291,11 @@ class PivotSheet(Sheet):
 @PivotSheet.api
 def addcol_aggr(sheet, col):
     hasattr(col, 'origCol') or vd.fail('not an aggregation column')
-    for agg in vd.chooseAggregators():
-        sheet.addColumnAtCursor(makeAggrColumn(col.origCol, vd.aggregators[agg]))
+    for agg_choice in vd.chooseAggregators():
+        agg_or_list = vd.aggregators[agg_choice]
+        aggs = agg_or_list if isinstance(agg_or_list, list) else [agg_or_list]
+        for agg in aggs:
+            sheet.addColumnAtCursor(makeAggrColumn(col.origCol, vd.aggregators[agg]))
 
 
 Sheet.addCommand('W', 'pivot', 'vd.push(makePivot(sheet, keyCols, [cursorCol]))', 'open Pivot Table: group rows by key column and summarize current column')

visidata/pyobj.py

@@ -1,9 +1,10 @@
 from typing import Mapping
 import inspect
 import math
+import numbers
 
 from visidata import vd, asyncthread, ENTER, deduceType
-from visidata import Sheet, Column, VisiData, ColumnItem, TableSheet, BaseSheet, Progress, ColumnAttr, SuspendCurses, TextSheet
+from visidata import Sheet, Column, VisiData, ColumnItem, TableSheet, BaseSheet, Progress, ColumnAttr, SuspendCurses, TextSheet, setitem
 import visidata
 
 vd.option('visibility', 0, 'visibility level')
@@ -14,8 +15,30 @@ vd.option('fmt_expand_list', '%s[%s]', 'format str to use for names of columns e
 
 class PythonSheet(Sheet):
     def openRow(self, row):
-        return PyobjSheet("%s[%s]" % (self.name, self.keystr(row)), source=row)
+        return PyobjSheet("%s[%s]" % (self.name, self.rowname(row)), source=row)
 
+class PythonAtomSheet(PythonSheet):
+    '''a sheet to display one Python object that does not offer deeper inspection,
+        like None, a bool, or an int/float'''
+    rowtype = 'object'  #singular, because it should only ever hold one
+    columns = [
+        Column('value', getter=lambda col,row: row,
+                        setter=lambda c,r,v: None)
+    ]
+    def loader(self):
+        self.rows = [self.source]
+        self.column('value').type = deduceType(self.source)
+
+    def openRow(self, row):
+        vd.fail('cannot dive deeper on this object')
+    def openCell(self, col, row, rowidx=None):
+        vd.fail('cannot dive deeper on this object')
+    def openRowPyobj(self, rowidx):
+        vd.fail('cannot dive deeper on this object')
+    def openCellPyobj(self, col, rowidx):
+        vd.fail('cannot dive deeper on this object')
+    def newRow(self):
+        vd.fail('adding rows to this sheet is not supported')
 
 #### generic list/dict/object browsing
 @VisiData.global_api
@@ -152,17 +175,23 @@ class PyobjSheet(PythonSheet):
     def __new__(cls, *names, **kwargs):
         'Return Sheet object of appropriate type for given sources in `args`.'
         pyobj=kwargs.get('source', object())
-        if isinstance(pyobj, list) or isinstance(pyobj, tuple):
+        if pyobj is None:
+            return None
+        elif isinstance(pyobj, numbers.Number):
+            return PythonAtomSheet(*names, source=pyobj)
+        elif isinstance(pyobj, (list, tuple)):
             if getattr(pyobj, '_fields', None):  # list of namedtuple
                 return SheetNamedTuple(*names, **kwargs)
             else:
                 return SheetList(*names, **kwargs)
+        elif isinstance(pyobj, set):
+            return ListOfPyobjSheet(*names, source=list(pyobj))
         elif isinstance(pyobj, Mapping):
             return SheetDict(*names, **kwargs)
         elif isinstance(pyobj, str):
             return TextSheet(*names, source=pyobj.splitlines())
         elif isinstance(pyobj, bytes):
-            return TextSheet(*names, source=pyobj.decode(options.encoding).splitlines())
+            return TextSheet(*names, source=pyobj.decode(cls.options.encoding).splitlines())
         elif isinstance(pyobj, object):
             obj = super().__new__(cls)  #, *names, **kwargs)
             return obj
@@ -173,6 +202,10 @@ class PyobjSheet(PythonSheet):
         self.rows = []
         vislevel = self.options.visibility
         for r in dir(self.source):
+            # reading these attributes can cause distracting fail() messages
+            if r in ('onlySelectedRows', 'someSelectedRows'):
+                vd.warning(f'skipping attribute: {r}')
+                continue
             try:
                 if vislevel <= 2 and r.startswith('__'): continue
                 if vislevel <= 1 and r.startswith('_'): continue
@@ -191,8 +224,9 @@ class PyobjSheet(PythonSheet):
 @TableSheet.api
 def openRow(sheet, row, rowidx=None):
     'Return Sheet diving into *row*.'
+    if row is None or sheet.nRows == 0: vd.fail('no row to dive into')
     if rowidx is None:
-        k = sheet.keystr(row) or str(sheet.cursorRowIndex)
+        k = sheet.rowname(row) or str(sheet.cursorRowIndex)
     else:
         k = rowidx
 
@@ -209,21 +243,40 @@ def openRow(sheet, row, rowidx=None):
 @TableSheet.api
 def openCell(sheet, col, row, rowidx=None):
     'Return Sheet diving into cell at *row* in *col*.'
+    if col is None or row is None or sheet.nRows == 0: vd.fail('no cell to dive into')
     if rowidx is None:
-        k = sheet.keystr(row) or str(sheet.cursorRowIndex)
+        k = sheet.rowname(row) or str(sheet.cursorRowIndex)
     else:
         k = rowidx
     name = f'{sheet.name}[{k}].{col.name}'
     return PyobjSheet(name, source=col.getTypedValue(row))
 
+@Sheet.api
+@asyncthread
+def openRows(sheet, rows):
+    for r in Progress(rows):
+        vd.push(sheet.openRow(r))
+
+    vd.sync()
+
+@Sheet.api
+@asyncthread
+def openCells(sheet, col, rows):
+    for r in Progress(rows):
+        vd.push(openCell(col, r))
+
+    vd.sync()
+
 @TableSheet.api
 def openRowPyobj(sheet, rowidx):
     'Return Sheet of raw Python object of row.'
+    if sheet.nRows == 0: vd.fail('no row to dive into')
     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.'
+    if col is None or sheet.nRows == 0: vd.fail('no cell to dive into')
     name = f'{sheet.name}[{rowidx}].{col.name}'
     return PyobjSheet(name, source=col.getValue(sheet.rows[rowidx]))
 
@@ -249,10 +302,11 @@ Sheet.addCommand('z^Y', 'pyobj-cell', 'status(type(cursorValue).__name__); vd.pu
 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('', '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(ENTER, 'open-row', 'vd.push(openRow(cursorRow)) if cursorRow else vd.fail("no row to open")', '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')
-Sheet.addCommand('gz'+ENTER, 'dive-selected-cells', 'for r in selectedRows: vd.push(openCell(cursorCol, r))', 'open sheet with copies of rows referenced in selected rows')
+openRows
+Sheet.addCommand('g'+ENTER, 'dive-selected', 'openRows(selectedRows)', 'open all selected rows')
+Sheet.addCommand('gz'+ENTER, 'dive-selected-cells', 'openCells(cursorCol, selectedRows)', 'open all selected cells')
 
 PyobjSheet.addCommand('v', 'visibility', 'sheet.options.visibility = 0 if sheet.options.visibility else 2; reload()', 'toggle show/hide for methods and hidden properties')
 PyobjSheet.addCommand('gv', 'show-hidden', 'sheet.options.visibility = 2; reload()', 'show methods and hidden properties')

visidata/save.py

@@ -3,7 +3,7 @@ import os
 from copy import copy
 
 from visidata import vd
-from visidata import Sheet, BaseSheet, VisiData, IndexSheet, Path, Progress, TypedExceptionWrapper
+from visidata import Sheet, BaseSheet, VisiData, IndexSheet, Path, Progress, TypedExceptionWrapper, TypedWrapper, UNLOADED
 
 vd.option('safe_error', '#ERR', 'error string to use while saving', replay=True)
 vd.option('save_encoding', 'utf-8', 'encoding passed to codecs.open when saving a file', replay=True, help=vd.help_encoding)
@@ -13,12 +13,15 @@ def safe_trdict(vs):
     'returns string.translate dictionary for replacing tabs and newlines'
     if vs.options.safety_first:
         delim = vs.options.delimiter
-        return {
+        trdict = {
              0: '', #  strip NUL completely
-    ord(delim): vs.options.tsv_safe_tab, # \t
             10: vs.options.tsv_safe_newline,  # \n
             13: vs.options.tsv_safe_newline,  # \r
         }
+        if not delim or ord(delim) in trdict:
+            vd.fail(f'cannot use delimiter {repr(delim)} with safety_first')
+        trdict[ord(delim)] = vs.options.tsv_safe_tab # \t
+        return trdict
     return {}
 
 
@@ -29,12 +32,12 @@ def iterdispvals(sheet, *cols, format=False):
         cols = sheet.visibleCols
 
     transformers = collections.OrderedDict()  # list of transformers for each column in order
+    trdict = sheet.safe_trdict()
     for col in cols:
         transformers[col] = [ col.type ]
         if format:
             formatMaker = getattr(col, 'formatter_'+(col.formatter or sheet.options.disp_formatter))
             transformers[col].append(formatMaker(col._formatdict))
-        trdict = sheet.safe_trdict()
         if trdict:
             transformers[col].append(lambda v,trdict=trdict: v.translate(trdict))
 
@@ -46,7 +49,6 @@ def iterdispvals(sheet, *cols, format=False):
                 dispval = col.getValue(r)
 
             except Exception as e:
-                vd.exceptionCaught(e)
                 dispval = options_safe_error or str(e)
 
             try:
@@ -56,6 +58,9 @@ def iterdispvals(sheet, *cols, format=False):
                     elif isinstance(dispval, TypedExceptionWrapper):
                         dispval = options_safe_error or str(dispval)
                         break
+                    elif isinstance(dispval, TypedWrapper):
+                        dispval = ''
+                        break
                     else:
                         dispval = t(dispval)
 
@@ -89,7 +94,7 @@ def getDefaultSaveName(sheet):
 
 
 @VisiData.api
-def save_cols(vd, cols):
+def saveCols(vd, cols):
     sheet = cols[0].sheet
     vs = copy(sheet)
     vs.columns = list(cols)
@@ -109,8 +114,10 @@ def saveSheets(vd, givenpath, *vsheets, confirm_overwrite=True):
     if not vsheets: # blank tuple
         vd.warning('no sheets to save')
         return
+    unloaded = [ vs for vs in vsheets if vs.rows is UNLOADED ]
+    vd.sync(*vd.ensureLoaded(unloaded))
 
-    filetypes = [givenpath.ext, vd.options.save_filetype]
+    filetypes = [givenpath.ext.lower(), vd.options.save_filetype.lower()]
 
     vd.clearCaches()
 
@@ -203,8 +210,8 @@ BaseSheet.addCommand('', 'save-sheet-really', 'vd.saveSheets(Path(getDefaultSave
 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)')
+Sheet.addCommand('', 'save-col', 'saveCols([cursorCol])', 'save current column only to filename in format determined by extension (default .tsv)')
+Sheet.addCommand('', 'save-col-keys', 'saveCols(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