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

visidata/features/command_server.py

@@ -0,0 +1,105 @@
+import io
+import json
+import socket
+from unittest.mock import Mock
+
+from visidata import vd, VisiData, asyncthread, asyncignore, CommandLogRow, Sheet
+
+
+vd.option('server_addr', '127.0.0.1', 'IP address to listen for commands', sheettype=None, replay=False)
+vd.option('server_port', 0, 'port to listen for commands', sheettype=None, replay=False)
+
+
+class SocketIO(io.RawIOBase):
+    def __init__(self, sock):
+        self.sock = sock
+
+    def read(self, sz=-1):
+        if (sz == -1): sz=0x7FFFFFFF
+        return self.sock.recv(sz)
+
+    def seekable(self):
+        return False
+
+
+@VisiData.before
+def mainloop(vd, scr):
+    port = vd.options.server_port
+    if port:
+        vd.command_listener(vd.options.server_addr, port)
+
+
+@VisiData.api
+@asyncignore
+def command_listener(vd, addr, port):
+    while True:
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        s.bind((addr, port))
+        s.listen(1)
+
+        conn, (addr, inport) = s.accept()
+        vd.status(f'Connection from {addr}:{inport}')
+        vd.queueCommand('no-op')  # update screen
+        vd.command_server(conn)
+
+
+@VisiData.api
+@asyncignore
+def command_server(vd, conn):
+    for line in SocketIO(conn):
+        line = line.decode().strip()
+        if line == 'draw':
+            r = '\n'.join(json.dumps(d) for d in vd.sheet.capture_draw_object())
+            conn.send(r.encode('utf-8')+b'\n')
+        elif line.startswith('{'):
+            cmd = json.loads(line)
+            vd.queueCommand(**cmd)
+        else:
+            longname, *rest = line.split(' ', maxsplit=1)
+            cmd = dict(longname=longname, input=rest[0] if rest else '')
+            vd.queueCommand(**cmd)
+
+    conn.close()
+
+
+@Sheet.api
+def capture_draw_object(sheet, topRowIndex=0, nScreenRows=25):
+    'capture interface at the object level'
+    isNull = sheet.isNullFunc()
+    sortkeys = {col:rev for col, rev in sheet._ordering}
+    rows = sheet.rows[topRowIndex:min(topRowIndex+nScreenRows+1, sheet.nRows)]
+
+    for vcolidx, col in enumerate(sheet.visibleCols):
+        colstate = col.__getstate__()
+
+        if col in sortkeys:
+            colstate['sort'] = 'desc' if sortkeys.get(col) else 'asc'
+
+        yield dict(i=vcolidx, _type='column', **colstate)
+
+    for rowidx, row in enumerate(rows):
+        rowstate = dict()
+
+        for notefunc in vd.rowNoters:
+            ch = notefunc(sheet, row)
+            if ch:
+                rowstate['note'] = rowstate.get('note', '') + ch
+
+        for vcolidx, col in enumerate(sheet.visibleCols):
+            cellval = col.getCell(row)
+
+            disp = ''.join(x for _, x in col.display(cellval))
+            cellstate = dict(display=disp)
+            notes = getattr(cellval, 'notes', '')
+            try:
+                if isNull and isNull(cellval.value):
+                    notes += sheet.options.disp_note_none
+            except (TypeError, ValueError):
+                pass
+
+            if notes:
+                cellstate['notes'] = notes
+            rowstate[str(vcolidx)] = cellstate
+
+        yield dict(_type='row', i=rowidx, **rowstate)

visidata/features/currency_to_usd.py

@@ -0,0 +1,70 @@
+'''Provide USD(s) function to convert string like '£300' or '205 AUD' to equivalent US$ as float.
+Uses data from api.apilayer.com/fixer. Requires an API key for apilayer.com.
+'''
+
+from visidata import vd
+import functools
+import json
+
+vd.option('fixer_api_key', '', 'API Key for api.apilayer.com/fixer')
+vd.option('fixer_cache_days', 1, 'Cache days for currency conversions')
+
+currency_symbols = {
+    '$': 'USD',
+    '£': 'GBP',
+    '₩': 'KRW',
+    '€': 'EUR',
+    '₪': 'ILS',
+    'zł': 'PLN',
+    '₽': 'RUB',
+    '₫': 'VND',
+}
+
+def currency_rates_json(date='latest', base='USD'):
+    url = 'https://api.apilayer.com/fixer/%s?base=%s' % (date, base)
+    return vd.urlcache(
+        url,
+        days=vd.options.fixer_cache_days,
+        headers={
+            # First need to set some additional headers as otherwise apilayers will block it with a 403
+            # See also https://stackoverflow.com/questions/13303449/urllib2-httperror-http-error-403-forbidden
+            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
+            'Accept-Encoding': 'none',
+            'Accept-Language': 'en-US,en;q=0.8',
+            'Connection': 'keep-alive',
+
+            # Finally set Apikey
+            'apikey': vd.options.fixer_api_key
+        }
+    ).read_text()
+
+@functools.lru_cache()
+def currency_rates():
+    return json.loads(currency_rates_json())['rates']
+
+@functools.lru_cache()
+def currency_multiplier(src_currency, dest_currency):
+    'returns equivalent value in USD for an amt of currency_code'
+    if src_currency == 'USD':
+        return 1.0
+    eur_usd_mult = currency_rates()['USD']
+    eur_src_mult = currency_rates()[src_currency]
+    usd_mult = eur_usd_mult/eur_src_mult
+    if dest_currency == 'USD':
+        return usd_mult
+    
+    return usd_mult/currency_rates()[dest_currency]
+
+def USD(s):
+    for currency_symbol, currency_code in currency_symbols.items():
+        if currency_symbol in s:
+            amt = float(s.replace(currency_symbol, ''))
+            return amt*currency_multiplier(currency_code, 'USD')
+
+    amtstr, currcode = s.split(' ')
+    return float(amtstr) * currency_multiplier(currcode, 'USD')
+
+
+vd.addGlobals(USD=USD)

visidata/{customdate.py → features/customdate.py}

@@ -21,3 +21,5 @@ def customdate(sheet, fmtstr):
 
 Sheet.addCommand('z@', 'type-customdate', 'fmt=input("date format: ", type="fmtstr"); cursorCol.type=customdate(fmt); cursorCol.fmtstr=fmt', 'set type of current column to custom date format')
 ColumnsSheet.addCommand('gz@', 'type-customdate-selected', 'fmt=input("date format: ", type="fmtstr"); onlySelectedRows.type=customdate(fmt); onlySelectedRows.fmtstr=fmt', 'set type of selected columns to date')
+
+vd.addMenuItems('Column > Type as > custom date format > type-customdate')

visidata/features/dedupe.py

@@ -0,0 +1,132 @@
+"""
+# Usage
+
+Duplicates are determined by the sheet's key columns.
+
+If no key columns are specified, then a duplicate row is one where the values
+of *all non-hidden* columns are exactly the same as a row that occurs earlier
+in the sheet.
+
+If key columns *are* specified, then duplicates are detected based on the
+values in just those columns.
+
+## Commands
+
+- `select-duplicate-rows` sets the selection status in VisiData to `selected`
+  for each row in the active sheet that is a duplicate of a prior row.
+
+- `dedupe-rows` pushes a new sheet in which only non-duplicate rows in the
+  active sheet are included.
+"""
+
+
+__author__ = "Jeremy Singer-Vine <jsvine@gmail.com>"
+
+from copy import copy
+
+from visidata import Sheet, BaseSheet, asyncthread, Progress, vd
+
+
+def gen_identify_duplicates(sheet):
+    """
+    Takes a sheet, and returns a generator yielding a tuple for each row
+    encountered. The tuple's structure is `(row_object, is_dupe)`, where
+    is_dupe is True/False.
+
+    See note in Usage section above regarding how duplicates are determined.
+    """
+
+    keyCols = sheet.keyCols
+
+    cols_to_check = None
+    if len(keyCols) == 0:
+        vd.warning("No key cols specified. Using all columns.")
+        cols_to_check = sheet.visibleCols
+    else:
+        cols_to_check = sheet.keyCols
+
+    seen = set()
+    for r in sheet.rows:
+        vals = tuple(col.getValue(r) for col in cols_to_check)
+        is_dupe = vals in seen
+        if not is_dupe:
+            seen.add(vals)
+        yield (r, is_dupe)
+
+
+@Sheet.api
+@asyncthread
+def select_duplicate_rows(sheet, duplicates=True):
+    """
+    Given a sheet, sets the selection status in VisiData to `selected` for each
+    row that is a duplicate of a prior row.
+
+    If `duplicates = False`, then the behavior is reversed; sets the selection
+    status to `selected` for each row that is *not* a duplicate.
+    """
+    before = len(sheet.selectedRows)
+
+    gen = gen_identify_duplicates(sheet)
+    prog = Progress(gen, gerund="selecting", total=sheet.nRows)
+
+    for row, is_dupe in prog:
+        if is_dupe == duplicates:
+            sheet.selectRow(row)
+
+    sel_count = len(sheet.selectedRows) - before
+
+    more_str = " more" if before > 0 else ""
+
+    vd.status(f"selected {sel_count}{more_str} {sheet.rowtype}")
+
+
+@Sheet.api
+def dedupe_rows(sheet):
+    """
+    Given a sheet, pushes a new sheet in which only non-duplicate rows are
+    included.
+    """
+    vs = copy(sheet)
+    vs.name += "_deduped"
+
+    @asyncthread
+    def _reload(self=vs):
+        self.rows = []
+        gen = gen_identify_duplicates(sheet)
+        prog = Progress(gen, gerund="deduplicating", total=sheet.nRows)
+        for row, is_dupe in prog:
+            if not is_dupe:
+                self.addRow(row)
+
+    vs.reload = _reload
+    return vs
+
+
+# Add longname-commands to VisiData to execute these methods
+BaseSheet.addCommand(None, "select-duplicate-rows", "sheet.select_duplicate_rows()", "select each row that is a duplicate of a prior row")
+BaseSheet.addCommand(None, "dedupe-rows", "vd.push(sheet.dedupe_rows())", "open new sheet in which only non-duplicate rows in the active sheet are included")
+
+vd.addMenuItems('''
+    Row > Select > duplicate rows > select-duplicate-rows
+    Data > Deduplicate rows > dedupe-rows
+''')
+
+"""
+# Changelog
+
+## 0.2.0 - 2021-09-22
+
+Use `vd.warning(...)` instead of `warning(...)`
+
+## 0.1.0 - 2020-10-09
+
+Revised for compatibility with VisiData 2.x
+
+## 0.0.1 - 2019-01-01
+
+Internal change, no external effects: Migrates from ._selectedRows to .selectedRows.
+
+## 0.0.0 - 2018-12-30
+
+Initial release.
+"""

visidata/{describe.py → features/describe.py}

@@ -2,12 +2,10 @@ from copy import copy
 from statistics import mode, median, mean, stdev
 
 from visidata import vd, Column, ColumnAttr, vlen, RowColorizer, asyncthread, Progress, wrapply
-from visidata import BaseSheet, TableSheet, ColumnsSheet
+from visidata import BaseSheet, TableSheet, ColumnsSheet, SheetsSheet
 
-__all__ = ['DescribeSheet']
 
-
-vd.option('describe_aggrs', 'mean stdev', 'numeric aggregators to calculate on Describe sheet')
+vd.option('describe_aggrs', 'mean stdev', 'numeric aggregators to calculate on Describe sheet', help=vd.help_aggregators)
 
 
 @Column.api
@@ -24,12 +22,19 @@ def isError(col, row):
 
 class DescribeColumn(Column):
     def __init__(self, name, **kwargs):
+        kwargs.setdefault('width', 10)
         super().__init__(name, getter=lambda col,srccol: col.sheet.describeData[srccol].get(col.expr, ''), expr=name, **kwargs)
 
 
 # rowdef: Column from source sheet
 class DescribeSheet(ColumnsSheet):
 #    rowtype = 'columns'
+    guide = '''
+        # Describe Sheet
+        This `Describe Sheet` shows a few basic metrics over data in {sheet.displaySource}, with each column represented by a row.
+
+        For example, row {sheet.cursorRowIndex} describes the _{sheet.cursorRow.name}_ column, showing its minimum value, maximum value, mean, median, and other measures.
+    '''
     precious = True
     columns = [
             ColumnAttr('sheet', 'sheet', width=0),
@@ -49,17 +54,11 @@ class DescribeSheet(ColumnsSheet):
     ]
     nKeys = 2
 
-    @asyncthread
-    def reload(self):
-        super().reload()
+    def loader(self):
+        super().loader()
         self.rows = [c for c in self.rows if not c.hidden]
         self.describeData = { col: {} for col in self.rows }
-
-        self.columns = []
-        for c in type(self).columns:
-            self.addColumn(c)
-
-        self.setKeys(self.columns[:self.nKeys])
+        self.resetCols()
 
         for aggrname in vd.options.describe_aggrs.split():
             self.addColumn(DescribeColumn(aggrname, type=float))
@@ -94,8 +93,8 @@ class DescribeSheet(ColumnsSheet):
                 for func in [min, max, sum, median]:  # use type
                     d[func.__name__] = self.calcStatistic(d, func, vals)
                 for aggrname in vd.options.describe_aggrs.split():
-                    func = vd.getGlobals()[aggrname]
-                    d[func.__name__] = self.calcStatistic(d, func, vals)
+                    aggr = vd.aggregators[aggrname].funcValues
+                    d[aggrname] = self.calcStatistic(d, aggr, vals)
 
     def calcStatistic(self, d, func, *args, **kwargs):
         r = wrapply(func, *args, **kwargs)
@@ -115,8 +114,11 @@ class DescribeSheet(ColumnsSheet):
 
 TableSheet.addCommand('I', 'describe-sheet', 'vd.push(DescribeSheet(sheet.name+"_describe", source=[sheet]))', 'open Describe Sheet with descriptive statistics for all visible columns')
 BaseSheet.addCommand('gI', 'describe-all', 'vd.push(DescribeSheet("describe_all", source=vd.stackedSheets))', 'open Describe Sheet with description statistics for all visible columns from all sheets')
+SheetsSheet.addCommand('gI', 'describe-selected', 'vd.push(DescribeSheet("describe_all", source=selectedRows))', 'open Describe Sheet with all visible columns from selected sheets')
 
 DescribeSheet.addCommand('zs', 'select-cell', 'cursorRow.sheet.select(cursorValue)', 'select rows on source sheet which are being described in current cell')
 DescribeSheet.addCommand('zu', 'unselect-cell', 'cursorRow.sheet.unselect(cursorValue)', 'unselect rows on source sheet which are being described in current cell')
 
+vd.addMenuItems('Data > Statistics > describe-sheet')
+
 vd.addGlobals({'DescribeSheet':DescribeSheet})

visidata/features/errors_guide.py

@@ -0,0 +1,26 @@
+from visidata import GuideSheet, vd
+
+class ErrorsGuide(GuideSheet):
+    guide_text='''# What was that error?
+
+Status messages include [:warning]warnings[/] and [:error]errors[/].
+
+A command may issue a [:warning]warning[/] status and continue running.
+A command that [:warning]fails[/] or [:error]errors[/] is aborted.
+
+## Investigating errors further
+
+If a Python Exception like [:error]RuntimeError[/] appears in the sidebar:
+
+- {help.commands.error_recent}
+- {help.commands.errors_all}
+
+If [:note_type]{vd.options.note_format_exc}[/] or [:error]{vd.options.note_getter_exc}[/] appear inside a cell, it indicates an error happened during calculation, type-conversion, or formatting.  When the cursor is on an error cell:
+
+- {help.commands.error_cell}
+'''
+
+
+
+vd.addGuide('ErrorsSheet', ErrorsGuide)
+

visidata/features/expand_cols.py

@@ -0,0 +1,202 @@
+import math
+import random
+import os.path
+from functools import singledispatch
+
+from visidata import vd, Sheet, asyncthread, Progress, Column, VisiData, deduceType, anytype, getitemdef, ColumnsSheet
+
+
+@Sheet.api
+def getSampleRows(sheet):
+    'Return list of sample rows, including the cursor row as the first row.'
+
+    # do not include cursorRow in sample
+    ret = sheet.rows[:sheet.cursorRowIndex] + sheet.rows[sheet.cursorRowIndex+1:]
+
+    n = sheet.options.default_sample_size
+    if n != 0 and n < sheet.nRows:
+        vd.aside(f'sampling {n} rows')
+        ret = random.sample(ret, n)
+
+    return [sheet.cursorRow] + ret
+
+
+@Sheet.api
+def expandCols(sheet, cols, rows=None, depth=0):
+    '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(sheet.expandCols(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'):
+        if not isinstance(val, dict):  # allow mixed-use columns
+            continue
+        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.  Ignore strings and exceptions. '''
+    def lenNoExceptions(v):
+        try:
+            if isinstance(v, str):
+                return 0
+            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
+
+
+@VisiData.api
+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
+
+
+@Sheet.api
+@asyncthread
+def contract_cols(sheet, cols, depth=1):  # depth == 0 means contract all the way
+    'Remove any columns in cols with .origCol, and also remove others in sheet.columns which share those .origCol.  The inverse of expand.'
+    vd.addUndo(setattr, sheet, 'columns', sheet.columns)
+    for i in range(depth or 10000):
+        colsToClose = [c for c in cols if getattr(c, "origCol", None)]
+
+        if not colsToClose:
+            break
+
+        origCols = set(c.origCol for c in colsToClose)
+        for col in origCols:
+            col.width = sheet.options.default_width
+
+        sheet.columns = [col for col in sheet.columns if getattr(col, 'origCol', None) not in origCols]
+
+
+@Sheet.api
+@asyncthread
+def expand_cols_deep(sheet, cols, rows=None, depth=0):  # depth == 0 means drill all the way
+    return sheet.expandCols(cols, rows=rows, depth=depth)
+
+
+@ColumnsSheet.api
+def contract_source_cols(sheet, cols):
+    prefix = os.path.commonprefix([c.name for c in cols])
+    ret = ColumnGroup(prefix or 'group', prefix=prefix, sourceCols=cols)
+    for c in cols:
+        c.origCol = ret
+    for vs in sheet.source:
+        vd.addUndo(setattr, vs, 'columns', vs.columns)
+        vs.columns[:] = [c for c in vs.columns if c not in cols]
+    return ret
+
+
+class ColumnGroup(Column):
+    def calcValue(self, row):
+        return {c.name[len(self.prefix):]:c.getValue(row) for c in self.sourceCols}
+
+    def expand(self, rows):
+        idx = self.sheet.columns.index(self)
+
+        for i, c in enumerate(self.sourceCols):
+            self.sheet.addColumn(c, index=idx+i+1)
+
+        self.hide()
+
+        return self.sourceCols
+
+
+Sheet.addCommand('(', 'expand-col', 'expand_cols_deep([cursorCol], depth=1)', 'expand current column of containers one level')
+Sheet.addCommand('g(', 'expand-cols', 'expand_cols_deep(visibleCols, depth=1)', 'expand all visible columns of containers one level')
+Sheet.addCommand('z(', 'expand-col-depth', 'expand_cols_deep([cursorCol], depth=int(input("expand depth=", value=0)))', 'expand current column of containers to given depth (0=fully)')
+Sheet.addCommand('gz(', 'expand-cols-depth', 'expand_cols_deep(visibleCols, depth=int(input("expand depth=", value=0)))', 'expand all visible columns of containers to given depth (0=fully)')
+
+Sheet.addCommand(')', 'contract-col', 'contract_cols([cursorCol])', 'remove current column and siblings from sheet columns and unhide parent')
+Sheet.addCommand('g)', 'contract-cols', 'contract_cols(visibleCols)', 'remove all child columns and unhide toplevel parents')
+Sheet.addCommand('z)', 'contract-col-depth', 'contract_cols([cursorCol], depth=int(input("contract depth=", value=0)))', 'remove current column and siblings from sheet columns and unhide parent')
+Sheet.addCommand('gz)', 'contract-cols-depth', 'contract_cols(visibleCols, depth=int(input("contract depth=", value=0)))', 'remove all child columns and unhide toplevel parents')
+
+ColumnsSheet.addCommand(')', 'contract-source-cols', 'source[0].addColumn(contract_source_cols(someSelectedRows), index=cursorRowIndex)', 'contract selected columns into column group')  #1702
+
+
+vd.addMenuItems('''
+    Column > Expand > one level > expand-col
+    Column > Expand > to depth N > expand-col-depth
+    Column > Expand > all columns one level > expand-cols
+    Column > Expand > all columns to depth > expand-cols-depth
+    Column > Contract > one level > contract-col
+    Column > Contract > N levels > contract-col-depth
+    Column > Contract > all columns one level > contract-cols
+    Column > Contract > all columns N levels > contract-cols-depth
+    Column > Contract > selected columns on source sheet > contract-source-cols
+''')

visidata/{fill.py → features/fill.py}

@@ -1,4 +1,4 @@
-from visidata import *
+from visidata import vd, VisiData, asyncthread, Sheet, Progress
 
 
 @VisiData.api
@@ -34,3 +34,5 @@ def fillNullValues(vd, col, rows):
 
 
 Sheet.addCommand('f', 'setcol-fill', 'fillNullValues(cursorCol, someSelectedRows)', 'fills null cells in selected rows of current column with contents of non-null cells up the current column')
+
+vd.addMenuItems('Column > Fill > setcol-fill')

visidata/{freeze.py → features/freeze.py}

@@ -1,5 +1,6 @@
-from visidata import *
 import collections
+from visidata import Column, Sheet, VisiData, ColumnItem, Progress, TypedExceptionWrapper, SettableColumn
+from visidata import asyncthread, vd
 
 
 @Column.api
@@ -35,6 +36,7 @@ class StaticSheet(Sheet):
     def __init__(self, source):
         super().__init__(source.name + "'", source=source)
 
+    def resetCols(self):
         self.columns = []
         for i, col in enumerate(self.source.visibleCols):
             colcopy = ColumnItem(col.name)
@@ -44,12 +46,12 @@ class StaticSheet(Sheet):
             if col in self.source.keyCols:
                 self.setKeys([colcopy])
 
-    @asyncthread
-    def reload(self):
-        self.rows = []
+    def iterload(self):
         for r in Progress(self.source.rows, 'calculating'):
             row = []
-            self.addRow(row)
+            yield row
+
+            # now fill out row
             for col in self.source.visibleCols:
                 val = col.getTypedValue(r)
                 if isinstance(val, TypedExceptionWrapper):
@@ -58,7 +60,10 @@ class StaticSheet(Sheet):
                     row.append(val)
 
 
-Sheet.addCommand("'", 'freeze-col', 'sheet.addColumnAtCursor(StaticColumn(cursorCol))', 'add a frozen copy of current column with all cells evaluated')
+Sheet.addCommand("'", 'freeze-col', 'sheet.addColumnAtCursor(freeze_col(cursorCol))', 'add a frozen copy of current column with all cells evaluated')
 Sheet.addCommand("g'", 'freeze-sheet', 'vd.push(StaticSheet(sheet)); status("pushed frozen copy of "+name)', 'open a frozen copy of current sheet with all visible columns evaluated')
 Sheet.addCommand("z'", 'cache-col', 'cursorCol.resetCache()', 'add/reset cache for current column')
 Sheet.addCommand("gz'", 'cache-cols', 'for c in visibleCols: c.resetCache()', 'add/reset cache for all visible columns')
+
+vd.addMenuItem('Column', 'Freeze', 'freeze-col')
+vd.addMenuItem('File', 'Freeze', 'freeze-sheet')