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

visidata/sheets.py

@@ -4,8 +4,8 @@ from copy import copy, deepcopy
 import textwrap
 
 from visidata import VisiData, Extensible, globalCommand, ColumnAttr, ColumnItem, vd, ENTER, EscapeException, drawcache, drawcache_property, LazyChainMap, asyncthread, ExpectedException
-from visidata import (options, Column, namedlist, SettableColumn,
-TypedExceptionWrapper, BaseSheet, UNLOADED,
+from visidata import (options, Column, namedlist, SettableColumn, AttrDict, DisplayWrapper,
+TypedExceptionWrapper, BaseSheet, UNLOADED, wrapply,
 clipdraw, clipdraw_chunks, ColorAttr, update_attr, colors, undoAttrFunc, vlen, dispwidth)
 import visidata
 
@@ -13,20 +13,30 @@ import visidata
 vd.activePane = 1   # pane numbering starts at 1; pane 0 means active pane
 
 
-vd.option('name_joiner', '_', 'string to join sheet or column names', max_help=0)
-vd.option('value_joiner', ' ', 'string to join display values', max_help=0)
+vd.option('name_joiner', '_', 'string to join sheet or column names')
+vd.option('value_joiner', ' ', 'string to join display values')
+vd.option('max_rows', 1_000_000_000, 'number of rows to load from source')
+
+vd.option('disp_wrap_max_lines', 3, 'max lines for multiline view')
+vd.option('disp_wrap_break_long_words', False, 'break words longer than column width in multiline')
+vd.option('disp_wrap_replace_whitespace', False, 'replace whitespace with spaces in multiline')
+vd.option('disp_wrap_placeholder', '…', 'multiline string to indicate truncation')
+vd.option('disp_multiline_focus', True, 'only multiline cursor row')
+vd.option('color_aggregator', 'bold 255 white on 234 black', 'color of aggregator summary on bottom row')
 
 
 @drawcache
 def _splitcell(sheet, s, width=0, maxheight=1):
-    if width <= 0 or not sheet.options.textwrap_cells:
+    height = max(maxheight, sheet.options.disp_wrap_max_lines or 0)
+    if width <= 0 or height <= 0:
         return [s]
 
+    wrap_kwargs = sheet.options.getall('disp_wrap_')
+    wrap_kwargs['max_lines'] = height
+
     ret = []
     for attr, text in s:
-        for line in textwrap.wrap(
-            text, width=width, break_long_words=False, replace_whitespace=False
-            ):
+        for line in textwrap.wrap(text, width=width, **wrap_kwargs):
             if len(ret) >= maxheight:
                 ret[-1][0][1] += ' ' + line
                 break
@@ -34,26 +44,42 @@ def _splitcell(sheet, s, width=0, maxheight=1):
                 ret.append([[attr, line]])
     return ret
 
-disp_column_fill = ' ' # pad chars after column value
+disp_column_fill = ' ' # pad chars before column value
+
+class Colorizer:
+    '''higher precedence color overrides lower; all non-color attributes combine.
+       coloropt is the color option name (like 'color_error').
+       func(sheet,col,row,value) should return a true value if coloropt should be applied
+       If coloropt is None, func() should return a coloropt (or None) instead'''
+
+    def __init__(self, precedence:int, coloropt:str, func=lambda s,c,r,v: None):
+        self.precedence = precedence
+        self.coloropt = coloropt
+        self._func = func
+
+class RowColorizer(Colorizer):
+    def func(self, s, c, r, v):
+        return r is not None and self._func(s,c,r,v)
+
+class ColumnColorizer(Colorizer):
+    def func(self, s, c, r, v):
+        return c is not None and self._func(s,c,r,v)
+
+class CellColorizer(Colorizer):
+    def func(self, s, c, r, v):
+        return r is not None and c is not None and self._func(s,c,r,v)
 
-# higher precedence color overrides lower; all non-color attributes combine
-# coloropt is the color option name (like 'color_error')
-# func(sheet,col,row,value) should return a true value if coloropt should be applied
-# if coloropt is None, func() should return a coloropt (or None) instead
-Colorizer = collections.namedtuple('Colorizer', 'precedence coloropt func')
-RowColorizer = collections.namedtuple('RowColorizer', 'precedence coloropt func')
-CellColorizer = collections.namedtuple('CellColorizer', 'precedence coloropt func')
-ColumnColorizer = collections.namedtuple('ColumnColorizer', 'precedence coloropt func')
 
 class RecursiveExprException(Exception):
     pass
 
 class LazyComputeRow:
     'Calculate column values as needed.'
-    def __init__(self, sheet, row, col=None):
+    def __init__(self, sheet, row, col=None, **kwargs):
         self.row = row
         self.col = col
         self.sheet = sheet
+        self.extra = AttrDict(kwargs) # extra bindings
         self._usedcols = set()
 
         self._lcm.clear()  # reset locals on lcm
@@ -62,11 +88,11 @@ class LazyComputeRow:
     def _lcm(self):
         lcmobj = self.col or self.sheet
         if not hasattr(lcmobj, '_lcm'):
-            lcmobj._lcm = LazyChainMap(self.sheet, self.col, *vd.contexts)
+            lcmobj._lcm = LazyChainMap(self.sheet, self.col, self.extra, *vd.contexts)
         return lcmobj._lcm
 
     def __iter__(self):
-        yield from self.sheet._ordered_colnames
+        yield from self.sheet.availColnames
         yield from self._lcm.keys()
         yield 'row'
         yield 'sheet'
@@ -86,18 +112,19 @@ class LazyComputeRow:
 
     def __getitem__(self, colid):
         try:
-            i = self.sheet._ordered_colnames.index(colid)
-            c = self.sheet._ordered_cols[i]
+            i = self.sheet.availColnames.index(colid)
+            c = self.sheet.availCols[i]
             if c is self.col:  # ignore current column
-                j = self.sheet._ordered_colnames[i+1:].index(colid)
-                c = self.sheet._ordered_cols[i+j+1]
+                j = self.sheet.availColnames[i+1:].index(colid)
+                c = self.sheet.availCols[i+j+1]
 
         except ValueError:
             try:
                 c = self._lcm[colid]
             except (KeyError, AttributeError) as e:
                 if colid == 'sheet': return self.sheet
-                elif colid == 'row': c = self.row
+                elif colid == 'row': return self
+                elif colid == '_row': return self.row
                 elif colid == 'col': c = self.col
                 else:
                     raise KeyError(colid) from e
@@ -125,7 +152,7 @@ class TableSheet(BaseSheet):
     _coltype = SettableColumn
 
     rowtype = 'rows'
-    guide = '# {sheet.help_title}\n{sheet.help_columns}\n'
+    guide = '# {sheet.help_title}\n'
 
     @property
     def help_title(self):
@@ -134,13 +161,6 @@ class TableSheet(BaseSheet):
         else:
             return 'Table Sheet'
 
-    @property
-    def help_columns(self):
-        hiddenCols = [c for c in self.columns if c.hidden]
-        if hiddenCols:
-            return f'- `gv` to unhide {len(hiddenCols)} hidden columns'
-        return ''
-
     columns = []  # list of Column
     colorizers = [ # list of Colorizer
         CellColorizer(2, 'color_default_hdr', lambda s,c,r,v: r is None),
@@ -148,7 +168,8 @@ class TableSheet(BaseSheet):
         ColumnColorizer(1, 'color_key_col', lambda s,c,r,v: c and c.keycol),
         CellColorizer(0, 'color_default', lambda s,c,r,v: True),
         RowColorizer(1, 'color_error', lambda s,c,r,v: isinstance(r, (Exception, TypedExceptionWrapper))),
-        CellColorizer(3, 'color_current_cell', lambda s,c,r,v: c is s.cursorCol and r is s.cursorRow)
+        CellColorizer(3, 'color_current_cell', lambda s,c,r,v: c is s.cursorCol and r is s.cursorRow),
+        ColumnColorizer(1, 'color_hidden_col', lambda s,c,r,v: c and c.hidden),
     ]
     nKeys = 0  # columns[:nKeys] are key columns
     _ordering = []  # list of (col:Column|str, reverse:bool)
@@ -272,7 +293,7 @@ class TableSheet(BaseSheet):
         self.columns = []
         for c in self.initialCols:
             self.addColumn(deepcopy(c))
-            if self.options.disp_help > c.max_help:
+            if self.options.disp_expert < c.disp_expert:
                 c.hide()
 
         self.setKeys(self.columns[:self.nKeys])
@@ -282,7 +303,9 @@ class TableSheet(BaseSheet):
         self.rows = []
         try:
             with vd.Progress(gerund='loading', total=0):
-                for r in self.iterload():
+                for i, r in enumerate(self.iterload()):
+                    if self.precious and i > self.options.max_rows:
+                        break
                     self.addRow(r)
         except FileNotFoundError:
             return  # let it be a blank sheet without error
@@ -367,10 +390,15 @@ class TableSheet(BaseSheet):
     def __repr__(self):
         return f'<{type(self).__name__}: {self.name}>'
 
-    def evalExpr(self, expr, row=None, col=None):
+    @drawcache_property
+    def currow(self):
+        return LazyComputeRow(self, self.cursorRow, self.cursorCol)
+
+    def evalExpr(self, expr:str, row=None, col=None, **kwargs):
+        'eval() expr in the context of (row, col), with extra bindings in kwargs'
         if row is not None:
             # contexts are cached by sheet/rowid for duration of drawcycle
-            contexts = vd._evalcontexts.setdefault((self, self.rowid(row), col), LazyComputeRow(self, row, col=col))
+            contexts = vd._evalcontexts.setdefault((self, self.rowid(row), col), LazyComputeRow(self, row, col, **kwargs))
         else:
             contexts = dict(sheet=self)
 
@@ -383,22 +411,25 @@ class TableSheet(BaseSheet):
     @property
     def nScreenRows(self):
         'Number of visible rows at the current window height.'
-        return (self.windowHeight-self.nHeaderRows-self.nFooterRows)//self.rowHeight
+        n = (self.windowHeight-self.nHeaderRows-self.nFooterRows)
+        if self.options.disp_multiline_focus:  # focus multiline mode
+            return n-self.rowHeight+1
+        return n//self.rowHeight
 
     @drawcache_property
     def nHeaderRows(self):
         vcols = self.visibleCols
-        return max(len(col.name.split('\n')) for col in vcols) if vcols else 0
+        return max(0, 1, *(len(col.name.split('\n')) for col in vcols))
 
     @property
     def nFooterRows(self):
         'Number of lines reserved at the bottom, including status line.'
-        return 1
+        return len(self.allAggregators) + 1
 
     @property
     def cursorCol(self):
         'Current Column object.'
-        vcols = self.visibleCols
+        vcols = self.availCols
         return vcols[min(self.cursorVisibleColIndex, len(vcols)-1)] if vcols else None
 
     @property
@@ -415,7 +446,7 @@ class TableSheet(BaseSheet):
     @drawcache_property
     def visibleCols(self):  # non-hidden cols
         'List of non-hidden columns in display order.'
-        return self.keyCols + [c for c in self.columns if not c.hidden and not c.keycol]
+        return (self.keyCols + [c for c in self.columns if not c.hidden and not c.keycol]) or [Column('', sheet=self)]
 
     @drawcache_property
     def keyCols(self):
@@ -423,14 +454,14 @@ class TableSheet(BaseSheet):
         return sorted([c for c in self.columns if c.keycol and not c.hidden], key=lambda c:c.keycol)
 
     @drawcache_property
-    def _ordered_cols(self):
-        'List of all columns, visible columns first.'
+    def availCols(self):
+        'List of all available columns, visible columns first.'
         return self.visibleCols + [c for c in self.columns if c.hidden]
 
     @drawcache_property
-    def _ordered_colnames(self):
-        'List of all column names, visible columns first.'
-        return [c.name for c in self._ordered_cols]
+    def availColnames(self):
+        'List of all available column names, visible columns first.'
+        return [c.name for c in self.availCols]
 
     @property
     def cursorColIndex(self):
@@ -438,7 +469,7 @@ class TableSheet(BaseSheet):
         try:
             return self.columns.index(self.cursorCol)
         except ValueError:
-            return None
+            return 0
 
     @property
     def nonKeyVisibleCols(self):
@@ -530,7 +561,13 @@ class TableSheet(BaseSheet):
             idx = len(self.columns) if index is None else index
             col.recalc(self)
             self.columns.insert(idx+i, col)
-            Sheet.visibleCols.fget.cache_clear()
+
+        # statements after addColumn in the same command may want to use these cached properties
+        Sheet.keyCols.fget.cache_clear()
+        Sheet.visibleCols.fget.cache_clear()
+        Sheet.availCols.fget.cache_clear()
+        Sheet.availColnames.fget.cache_clear()
+        Sheet.colsByName.fget.cache_clear()
 
         return cols[0]
 
@@ -578,7 +615,7 @@ class TableSheet(BaseSheet):
         'Return tuple of the key for *row*.'
         return tuple(c.getTypedValue(row) for c in self.keyCols)
 
-    def keystr(self, row):
+    def rowname(self, row):
         'Return string of the key for *row*.'
         return ','.join(map(str, self.rowkey(row)))
 
@@ -592,8 +629,8 @@ class TableSheet(BaseSheet):
 
         if self.cursorVisibleColIndex <= 0:
             self.cursorVisibleColIndex = 0
-        elif self.cursorVisibleColIndex >= self.nVisibleCols:
-            self.cursorVisibleColIndex = self.nVisibleCols-1
+        elif self.cursorVisibleColIndex >= len(self.availCols):
+            self.cursorVisibleColIndex = len(self.availCols)-1
 
         if self.topRowIndex < 0:
             self.topRowIndex = 0
@@ -639,8 +676,8 @@ class TableSheet(BaseSheet):
         self._visibleColLayout = {}
         x = 0
         vcolidx = 0
-        for vcolidx in range(0, self.nVisibleCols):
-            width = self.calcSingleColLayout(vcolidx, x, minColWidth)
+        for vcolidx, col in enumerate(self.availCols):
+            width = self.calcSingleColLayout(col, vcolidx, x, minColWidth)
             if width:
                 x += width+sepColWidth
             if x > winWidth-1:
@@ -648,17 +685,21 @@ class TableSheet(BaseSheet):
 
         self.rightVisibleColIndex = vcolidx
 
-    def calcSingleColLayout(self, vcolidx:int, x:int=0, minColWidth:int=4):
-            col = self.visibleCols[vcolidx]
+    def calcSingleColLayout(self, col:Column, vcolidx:int, x:int=0, minColWidth:int=4):
             if col.width is None and len(self.visibleRows) > 0:
                 vrows = self.visibleRows if self.nRows > 1000 else self.rows[:1000]  #1964
                 # handle delayed column width-finding
                 col.width = max(col.getMaxWidth(vrows), minColWidth)
-                if vcolidx != self.nVisibleCols-1:  # let last column fill up the max width
+                if vcolidx < self.nVisibleCols-1:  # let last column fill up the max width
                     col.width = min(col.width, self.options.default_width)
+
             width = col.width if col.width is not None else self.options.default_width
-            if col in self.keyCols:
-                width = max(width, 1)  # keycols must all be visible
+
+            # when cursor showing a hidden column
+            if vcolidx >= self.nVisibleCols and vcolidx == self.cursorVisibleColIndex:
+                width = self.options.default_width
+
+            width = max(width, 1)
             if col in self.keyCols or vcolidx >= self.leftVisibleColIndex:  # visible columns
                 self._visibleColLayout[vcolidx] = [x, min(width, self.windowWidth-x)]
                 return width
@@ -666,7 +707,7 @@ class TableSheet(BaseSheet):
 
     def drawColHeader(self, scr, y, h, vcolidx):
         'Compose and draw column header for given vcolidx.'
-        col = self.visibleCols[vcolidx]
+        col = self.availCols[vcolidx]
 
         # hdrattr highlights whole column header
         # sepattr is for header separators and indicators
@@ -677,7 +718,7 @@ class TableSheet(BaseSheet):
             hdrcattr = update_attr(hdrcattr, colors.color_current_hdr, 2)
 
         C = self.options.disp_column_sep
-        if (self.keyCols and col is self.keyCols[-1]) or vcolidx == self.rightVisibleColIndex:
+        if (self.keyCols and col is self.keyCols[-1]) or vcolidx == self.nVisibleCols-1:
             C = self.options.disp_keycol_sep
 
         x, colwidth = self._visibleColLayout[vcolidx]
@@ -699,13 +740,14 @@ class TableSheet(BaseSheet):
             if i == h-1:
                 hdrcattr = update_attr(hdrcattr, colors.color_bottom_hdr, 5)
 
-            clipdraw(scr, y+i, x, name, hdrcattr, w=colwidth)
+            if y+i < self.windowHeight:
+                clipdraw(scr, y+i, x, name, hdrcattr, w=colwidth)
             vd.onMouse(scr, x, y+i, colwidth, 1, BUTTON3_RELEASED='rename-col')
 
-            if C and x+colwidth+len(C) < self.windowWidth and y+i < self.windowWidth:
+            if C and x+colwidth+len(C) < self.windowWidth and y+i < self.windowHeight:
                 scr.addstr(y+i, x+colwidth, C, sepcattr.attr)
 
-        clipdraw(scr, y+h-1, x+colwidth-len(T), T, hdrcattr)
+        clipdraw(scr, y+h-1, min(x+colwidth, self.windowWidth-1)-dispwidth(T), T, hdrcattr)
 
         try:
             if vcolidx == self.leftVisibleColIndex and col not in self.keyCols and self.nonKeyVisibleCols.index(col) > 0:
@@ -718,7 +760,7 @@ class TableSheet(BaseSheet):
             A = ''
             for j, (sortcol, sortdir) in enumerate(self._ordering):
                 if isinstance(sortcol, str):
-                    sortcol = self.column(sortcol)
+                    sortcol = self.colsByName.get(sortcol)  # self.column will fail if sortcol was renamed
                 if col is sortcol:
                     A = self.options.disp_sort_desc[j] if sortdir else self.options.disp_sort_asc[j]
                     scr.addstr(y+h-1, x, A, hdrcattr.attr)
@@ -730,6 +772,17 @@ class TableSheet(BaseSheet):
         'Return boolean: is given column index a key column?'
         return self.visibleCols[vcolidx] in self.keyCols
 
+    @drawcache_property
+    def allAggregators(self):
+        'Return dict of aggname -> list of cols with that aggregator.'
+        allaggs = collections.defaultdict(list) # aggname -> list of cols with that aggregator
+        for vcolidx, (x, colwidth) in sorted(self._visibleColLayout.items()):
+            col = self.availCols[vcolidx]
+            if not col.hidden:
+                for aggr in col.aggregators:
+                    allaggs[aggr.name].append(vcolidx)
+        return allaggs
+
     def draw(self, scr):
         'Draw entire screen onto the `scr` curses object.'
         if not self.columns:
@@ -767,7 +820,7 @@ class TableSheet(BaseSheet):
 
         y = headerRow + numHeaderRows
 
-        rows = self.rows[self.topRowIndex:min(self.topRowIndex+self.nScreenRows+1, self.nRows)]
+        rows = self.rows[self.topRowIndex:min(self.topRowIndex+self.nScreenRows, self.nRows)]
         vd.callNoExceptions(self.checkCursor)
 
         for rowidx, row in enumerate(rows):
@@ -781,15 +834,42 @@ class TableSheet(BaseSheet):
         if vcolidx+1 < self.nVisibleCols:
             scr.addstr(headerRow, self.windowWidth-2, self.options.disp_more_right, colors.color_column_sep.attr)
 
+        # draw bottom-row aggregators  #2209
+        rightx, rightw = self._visibleColLayout[self.rightVisibleColIndex]
+        rightx += rightw+1
+
+        for aggrname, colidxs in self.allAggregators.items():
+            clipdraw(scr, y, 0, ' '*rightx + f' {aggrname:9}', colors.color_aggregator, truncator='+')
+
+            for vcolidx in colidxs:
+                x, colwidth = self._visibleColLayout[vcolidx]
+                col = self.availCols[vcolidx]
+
+                if not col.hidden:
+                    dw = DisplayWrapper('')
+                    try:
+                        agg = vd.aggregators[aggrname]
+                        dw.value = col.aggregateTotal(agg)
+                        dw.typedval = wrapply(agg.type or col.type, dw.value)
+                        dw.text = col.format(dw.typedval)
+                    except Exception as e:
+                        dw.note = self.options.disp_note_typeexc
+                        dw.notecolor = 'color_warning'
+                        vd.exceptionCaught(e, status=False)
+                    disps = [('', ' ')] + list(col.display(dw, width=colwidth))
+                    clipdraw_chunks(scr, y, x, disps, colors.color_aggregator, w=colwidth)
+            y += 1
+
+
     def calc_height(self, row, displines=None, isNull=None, maxheight=1):
-            'render cell contents ifor row into displines'
+            'render cell contents for row into displines'
             if displines is None:
                 displines = {}  # [vcolidx] -> list of lines in that cell
 
             for vcolidx, (x, colwidth) in sorted(self._visibleColLayout.items()):
                 if x < self.windowWidth:  # only draw inside window
-                    vcols = self.visibleCols
-                    if vcolidx >= len(vcols):
+                    vcols = self.availCols
+                    if vcolidx >= self.nVisibleCols and vcolidx != self.cursorVisibleColIndex:
                         continue
                     col = vcols[vcolidx]
                     cellval = col.getCell(row)
@@ -842,14 +922,35 @@ class TableSheet(BaseSheet):
 
             # calc_height renders cell contents into displines
             displines = {}  # [vcolidx] -> list of lines in that cell
-            self.calc_height(row, displines, maxheight=self.rowHeight)
+            if options.disp_multiline_focus:
+                height = self.rowHeight if rowidx == self.cursorRowIndex else 1
+            else:
+                height = min(self.rowHeight, maxheight) or 1  # display even empty rows
+
+            self.calc_height(row, displines, maxheight=height)
 
-            height = min(self.rowHeight, maxheight) or 1  # display even empty rows
             self._rowLayout[rowidx] = (ybase, height)
 
+            if height > 1:
+                colseps = [topsep] + [midsep]*(height-2) + [botsep]
+                endseps = [endtopsep] + [endmidsep]*(height-2) + [endbotsep]
+                keyseps = [keytopsep] + [keymidsep]*(height-2) + [keybotsep]
+            else:
+                colseps = [colsep]
+                endseps = [endsep]
+                keyseps = [keysep]
+
             for vcolidx, (col, cellval, lines) in displines.items():
                     if vcolidx not in self._visibleColLayout:
                         continue
+
+                    if vcolidx == self.nVisibleCols-1:  # right edge of sheet
+                        seps = endseps
+                    elif (self.keyCols and col is self.keyCols[-1]): # last keycol
+                        seps = keyseps
+                    else:
+                        seps = colseps
+
                     x, colwidth = self._visibleColLayout[vcolidx]
                     hoffset = col.hoffset
                     voffset = col.voffset
@@ -861,7 +962,7 @@ class TableSheet(BaseSheet):
                     notewidth = 1 if note else 0
                     if note:
                         notecattr = update_attr(cattr, colors.get_color(cellval.notecolor), 10)
-                        scr.addstr(ybase, x+colwidth-notewidth, note, notecattr.attr)
+                        clipdraw(scr, ybase, x+colwidth-notewidth, note, notecattr)
 
                     lines = lines[voffset:]
 
@@ -873,36 +974,7 @@ class TableSheet(BaseSheet):
                     for i, chunks in enumerate(lines):
                         y = ybase+i
 
-                        if vcolidx == self.nVisibleCols-1:  # right edge of sheet
-                            if len(lines) == 1:
-                                sepchars = endsep
-                            else:
-                                if i == 0:
-                                    sepchars = endtopsep
-                                elif i == len(lines)-1:
-                                    sepchars = endbotsep
-                                else:
-                                    sepchars = endmidsep
-                        elif (self.keyCols and col is self.keyCols[-1]): # last keycol
-                            if len(lines) == 1:
-                                sepchars = keysep
-                            else:
-                                if i == 0:
-                                    sepchars = keytopsep
-                                elif i == len(lines)-1:
-                                    sepchars = keybotsep
-                                else:
-                                    sepchars = keymidsep
-                        else:
-                            if len(lines) == 1:
-                                sepchars = colsep
-                            else:
-                                if i == 0:
-                                    sepchars = topsep
-                                elif i == len(lines)-1:
-                                    sepchars = botsep
-                                else:
-                                    sepchars = midsep
+                        sepchars = seps[i]
 
                         pre = disp_truncator if hoffset != 0 else disp_column_fill
                         prechunks = []
@@ -915,7 +987,7 @@ class TableSheet(BaseSheet):
                         clipdraw_chunks(scr, y, x, prechunks, cattr, w=colwidth-notewidth)
                         vd.onMouse(scr, x, y, colwidth, 1, BUTTON3_RELEASED='edit-cell')
 
-                        if x+colwidth+len(sepchars) <= self.windowWidth:
+                        if sepchars and x+colwidth+dispwidth(sepchars) <= self.windowWidth:
                             scr.addstr(y, x+colwidth, sepchars, sepcattr.attr)
 
             for notefunc in vd.rowNoters:
@@ -976,7 +1048,9 @@ class SequenceSheet(Sheet):
 
         self.rows = []
         # add the rest of the rows
-        for r in vd.Progress(itsource, gerund='loading', total=0):
+        for i, r in enumerate(vd.Progress(itsource, gerund='loading', total=0)):
+            if self.precious and i > self.options.max_rows:
+                break
             self.addRow(r)
 
 
@@ -1032,6 +1106,8 @@ def push(vd, vs, pane=0, load=True):
 
     if load:
         vs.ensureLoaded()
+    if vd.activeCommand:
+        vs.longname = vd.activeCommand.longname
 
 
 @VisiData.api
@@ -1042,6 +1118,8 @@ def quit(vd, *sheets):
         vs.confirmQuit('quit')
         vs.pane = 0
         vd.remove(vs)
+    if vd.activeCommand:
+        vd.activeSheet.longname = vd.activeCommand.longname
 
 
 @BaseSheet.api
@@ -1064,7 +1142,7 @@ def preloadHook(sheet):
 
 @VisiData.api
 def newSheet(vd, name, ncols, **kwargs):
-    return Sheet(name, columns=[SettableColumn() for i in range(ncols)], **kwargs)
+    return Sheet(name, columns=[SettableColumn(width=vd.options.default_width) for i in range(ncols)], **kwargs)
 
 
 @BaseSheet.api
@@ -1109,7 +1187,7 @@ BaseSheet.init('pane', lambda: 1)
 
 
 BaseSheet.addCommand('^R', 'reload-sheet', 'preloadHook(); reload()', 'Reload current sheet')
-Sheet.addCommand('^G', 'show-cursor', 'status(statusLine)', 'show cursor position and bounds of current sheet on status line')
+Sheet.addCommand('', 'show-cursor', 'status(statusLine)', 'show cursor position and bounds of current sheet on status line')
 
 Sheet.addCommand('!', 'key-col', 'toggleKeys([cursorCol])', 'toggle current column as a key column')
 Sheet.addCommand('z!', 'key-col-off', 'unsetKeys([cursorCol])', 'unset current column as a key column')
@@ -1151,7 +1229,7 @@ BaseSheet.addCommand('A', 'open-new', 'vd.push(vd.newSheet("unnamed", 1))', 'Ope
 BaseSheet.addCommand('`', 'open-source', 'vd.push(source)', 'open source sheet')
 BaseSheet.addCommand(None, 'rename-sheet', 'sheet.name = input("rename sheet to: ", value=cleanName(sheet.name))', 'Rename current sheet')
 
-Sheet.addCommand('', 'addcol-source', 'source .addColumn(copy(cursorCol)) if isinstance (source, BaseSheet) else error("source must be sheet")', 'add copy of current column to source sheet')  #988  frosencrantz
+Sheet.addCommand('', 'addcol-source', 'source.addColumn(copy(cursorCol)) if isinstance (source, BaseSheet) else error("source must be sheet")', 'add copy of current column to source sheet')  #988  frosencrantz
 
 
 @Column.api