visidata 2.11.dev0__py3-none-any.whl → 3.0__py3-none-any.whl

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
@@ -17,7 +17,7 @@ def fillNullValues(vd, col, rows):
             val = e
 
         if isNull(val):
-            if lastval and (id(r) in rowsToFill):
+            if not isNull(lastval) and (id(r) in rowsToFill):
                 oldvals.append((col,r,val))
                 col.setValue(r, lastval)
                 n += 1
@@ -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')

visidata/features/graph_seaborn.py

@@ -0,0 +1,79 @@
+'''
+Add plot-column-ext and plot-numerics-ext to Sheet, and plot-ext to GraphSheet, to open current graph in new matplotlib window.
+'''
+
+from visidata import vd, VisiData, Sheet, GraphSheet, Progress, asyncthread
+
+@VisiData.api
+@asyncthread
+def plot_seaborn(vd, rows, xcols, ycols):
+    vd.status(f'plotting {len(rows)} rows using matplotlib')
+    import multiprocessing
+    mp = multiprocessing.Process(target=ext_plot_seaborn, args=(rows, xcols, ycols))
+    mp.start()
+
+
+def ext_plot_seaborn(rows, xcols, ycols):
+    pd = vd.importExternal('pandas')
+    plt = vd.importExternal('matplotlib.pyplot', 'matplotlib')
+    sns = vd.importExternal('seaborn')
+
+    # Set the default theme
+    sns.set()
+
+    plt.figure(figsize=(10, 6))
+    plt.title('')
+    plt.xticks(rotation=15)
+
+    nerrors = 0
+    nplotted = 0
+
+    x_array = []
+    y_array = []
+    cat_array = []
+
+    catcols = [c for c in xcols if not vd.isNumeric(c)]
+    numcols = vd.numericCols(xcols)
+    for rownum, row in enumerate(Progress(rows, 'plotting')):
+        for ycol in ycols:
+            try:
+                if catcols:
+                    k = tuple(c.getValue(row) for c in catcols)
+                    if len(catcols) == 1:
+                        k = k[0]
+                else:
+                    k = ycol.name
+
+                graph_x = numcols[0].type(numcols[0].getValue(row)) if numcols else rownum
+                graph_y = ycol.type(ycol.getValue(row))
+
+                x_array.append(graph_x)
+                y_array.append(graph_y)
+                cat_array.append(k)
+
+                nplotted += 1
+            except Exception:
+                nerrors += 1
+                if options.debug:
+                    raise
+
+    sns.scatterplot(
+        x=x_array,
+        y=y_array,
+        hue=cat_array,
+#        hue_order=df.tag.value_counts().iloc[:top].index,
+#        data=tmpdf,
+        s=5,
+        linewidth=0,
+        ).legend().set_title = (None)
+
+    plt.show()
+
+
+Sheet.addCommand('', 'plot-column-ext', 'plot_seaborn(rows, keyCols, numericCols([cursorCol]))', 'plot current numeric column on y-axis vs key columns on x-axis using matplotlib/seaborn')
+Sheet.addCommand('', 'plot-numerics-ext', 'plot_seaborn(rows, keyCols, numericCols(nonKeyVisibleCols))', 'plot a graph of all visible numeric columns using matplotlib/seaborn')
+GraphSheet.addCommand('', 'plot-ext', 'plot_seaborn(sourceRows, xcols, ycols)', 'replot current graph using matplotlib/seaborn')
+
+vd.addMenuItem('Plot', 'Graph', 'using matplotlib', 'current column', 'plot-column-ext')
+vd.addMenuItem('Plot', 'Graph', 'using matplotlib', 'all numeric columns', 'plot-numerics-ext')
+vd.addMenuItem('Plot', 'Graph', 'replot using matplotlib', 'plot-ext')

visidata/features/helloworld.py

@@ -0,0 +1,10 @@
+'''
+Hello world minimal plugin.  Press F2 to show options.hello_world on the status line.
+
+.visidatarc: `import plugins.hello`
+'''
+from visidata import vd, BaseSheet
+
+vd.option('hello_world', '¡Hola mundo!', 'shown by the hello-world command')
+
+BaseSheet.addCommand('KEY_F(2)', 'hello-world', 'status(options.hello_world)', 'print greeting to status')

visidata/features/hint_types.py

@@ -0,0 +1,17 @@
+from visidata import Sheet, anytype
+
+@Sheet.api
+def hint_type_int(sheet):
+    c = sheet.cursorCol
+    if c.type is anytype:
+        v = c.getTypedValue(sheet.cursorRow)
+        if isinstance(v, int) or int(v) is not None:
+            return 2, '[:onclick type-int]Set column type to integer[/] with `#`.'
+
+@Sheet.api
+def hint_type_float(sheet):
+    c = sheet.cursorCol
+    if c.type is anytype:
+        v = c.getTypedValue(sheet.cursorRow)
+        if isinstance(v, float) or float(v) is not None:
+            return 1, '[:onclick type-float]Set column type to floating point[/] with `%`.'

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

@@ -24,3 +24,8 @@ Sheet.addCommand('i', 'addcol-incr', 'c=SettableColumn(type=int); addColumnAtCur
 Sheet.addCommand('gi', 'setcol-incr', 'cursorCol.setValues(selectedRows, *numrange(sheet.nSelectedRows))', 'set current column for selected rows to incremental values')
 Sheet.addCommand('zi', 'addcol-incr-step', 'n=num(input("interval step: ")); c=SettableColumn(type=type(n)); addColumnAtCursor(c); c.setValues(rows, *numrange(nRows, step=n))', 'add column with incremental values times given step')
 Sheet.addCommand('gzi', 'setcol-incr-step', 'n=num(input("interval step: ")); cursorCol.setValues(selectedRows, *numrange(nSelectedRows, n))', 'set current column for selected rows to incremental values times given step')
+
+vd.addMenuItems('''
+    Column > Add column > increment > addcol-incr
+    Edit > Modify > selected cells > increment > setcol-incr
+''')