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

visidata/experimental/liveupdate.py

@@ -0,0 +1,45 @@
+from visidata import Column, vd, ColumnExpr, CompleteExpr, EscapeException, Sheet
+
+
+@Column.api
+def updateExpr(col, val):
+    col.name = val
+    try:
+        col.expr = val
+    except SyntaxError:
+        col.expr = None
+
+    col.sheet.draw(col.sheet._scr)
+
+
+@Column.api  # expr.setter
+def expr(self, expr):
+    try:
+        self.compiledExpr = compile(expr, '<expr>', 'eval') if expr else None
+        self._expr = expr
+    except SyntaxError as e:
+        self._expr = None
+
+
+@Sheet.api
+def addcol_expr(sheet):
+    try:
+        c = sheet.addColumnAtCursor(ColumnExpr("", width=sheet.options.default_width))
+        oldidx = sheet.cursorVisibleColIndex
+        sheet.cursorVisibleColIndex = sheet.visibleCols.index(c)
+
+        expr = sheet.editCell(sheet.cursorVisibleColIndex, -1,
+                                completer=CompleteExpr(sheet),
+                                updater=lambda val,col=c: col.updateExpr(val))
+
+        c.expr = expr or vd.fail("no expr")
+        c.name = expr
+        c.width = None
+    except (Exception, EscapeException):
+        sheet.columns.remove(c)
+        sheet.cursorVisibleColIndex = oldidx
+        raise
+
+
+Sheet.addCommand(None, 'addcol-expr', 'sheet.addcol_expr()', "create new column from Python expression, updating the column's calculated values live")
+Sheet.addCommand(None, 'addcol-new', 'c=addColumnAtIndex(SettableColumn(width=options.default_width)); draw(sheet._scr); cursorVisibleColIndex=visibleCols.index(c); c.name=editCell(cursorVisibleColIndex, -1); c.width=None', 'append new column, updating the column name live')

visidata/experimental/mark.py

@@ -0,0 +1,133 @@
+'''
+Marking selected rows with a keystroke, selecting marked rows,
+and viewing lists of marks and their rows.
+'''
+
+from copy import copy
+from visidata import vd, asyncthread, vlen, VisiData, TableSheet, ColumnItem, RowColorizer
+
+@VisiData.lazy_property
+def marks(vd):
+    return MarksSheet('marks')
+
+
+class MarkSheet(TableSheet):
+    pass
+
+
+class MarksSheet(TableSheet):
+    '''
+    The Marks Sheet shows all marks in use (on all sheets) and how many rows have each mark.
+    '''
+    rowtype = "marks"  # rowdef: [mark, color, [rows]]
+    columns = [
+        ColumnItem('mark', 0),
+        ColumnItem('color', 1),
+        ColumnItem('rows', 2, type=vlen),
+    ]
+    colorizers = [
+        RowColorizer(2, None, lambda s,c,r,v: r and r[1])
+    ]
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.marknotes = list('0123456789')
+        self.marks = []  #
+        self.markedRows = {}  # rowid(row): [row, set(marks)]
+        self.rows = []
+
+    def getColor(self, sheet, row):
+        mark = self.getMark(sheet, row)
+        if not mark:
+            return ''
+        return self.getMarkRow(sheet, mark)[1]
+
+    def getMark(self, sheet, row):
+        mrow = self.markedRows.get(sheet.rowid(row), None)
+        if not mrow:
+            return ''
+        if mrow[1]:
+            return next(iter(mrow[1]))  # first item in set
+
+    def getMarks(self, row):
+        'Return set of all marks for given row'
+        return self.markedRows[self.rowid(row)][1]
+
+    def isMarked(self, row, mark):
+        'Return True if given row has given mark'
+        return mark in self.getMarks(row)
+
+    def getMarkRow(self, sheet, mark):
+        for r in self.rows:
+            if r[0] == mark:
+                return r
+        r = [mark, 'color_note_type', MarkSheet('mark_', rows=[], columns=copy(sheet.columns))]
+        self.addRow(r)
+        return r
+
+    def setMark(self, sheet, row, mark):
+        rowid = self.rowid(row)
+        if rowid not in self.markedRows:
+            self.markedRows[rowid] = [row, set(mark)]
+        else:
+            self.markedRows[rowid][1].add(mark)
+
+        vd.marks.getMarkRow(sheet, mark)[2].addRow(row)
+
+    def unsetMark(self, sheet, row, mark):
+        rowid = self.rowid(row)
+        if rowid in self.markedRows:
+            self.markedRows[rowid][1].remove(mark)
+        vd.marks.getMarkRow(sheet, mark)[2].deleteBy(lambda r,x=row: r is x)
+
+    def inputmark(self):
+        return vd.inputsingle('mark: ') or self.marknotes.pop(0)
+
+    def openRow(self, row):
+        return row[2]
+
+
+@VisiData.api
+@asyncthread
+def mark(vd, sheet, rows, m):
+    for r in rows:
+        vd.marks.setMark(sheet, r, m)
+
+@VisiData.api
+@asyncthread
+def unmark(vd, sheet, rows, m):
+    for r in rows:
+        vd.marks.unsetMark(sheet, r, m)
+
+
+vd.rowNoters.insert(0, lambda sheet, row: vd.marks.getMark(sheet, row))
+
+TableSheet.colorizers.append(RowColorizer(2, None, lambda s,c,r,v: not c and r and vd.marks.getColor(s, r)))
+
+TableSheet.addCommand('', 'mark-row', 'vd.mark(sheet, [cursorRow], vd.marks.inputmark())', '')
+TableSheet.addCommand('', 'unmark-row', 'vd.unmark(sheet, [cursorRow], vd.marks.inputmark())', '')
+TableSheet.addCommand('', 'mark-selected', 'vd.mark(sheet, selectedRows, vd.marks.inputmark())', '')
+TableSheet.addCommand('', 'unmark-selected', 'vd.unmark(sheet, selectedRows, vd.marks.inputmark())', '')
+
+TableSheet.addCommand('', 'select-marks', 'select(gatherBy(lambda r,mark=vd.marks.inputmark(): vd.marks.isMarked(r, mark)), progress=False)', '')
+TableSheet.addCommand('', 'stoggle-marks', 'toggle(gatherBy(lambda r,mark=vd.marks.inputmark(): vd.marks.isMarked(r, mark)), progress=False)', '')
+TableSheet.addCommand('', 'unselect-marks', 'unselect(gatherBy(lambda r,mark=vd.marks.inputmark(): vd.marks.isMarked(r, mark)), progress=False)', '')
+
+TableSheet.addCommand('', 'open-marks', 'vd.push(vd.marks)', '')
+
+TableSheet.addCommand('', 'go-prev-mark', 'moveToNextRow(lambda row,mark=vd.marks.inputmark(): vd.marks.isMarked(row, mark), reverse=True, msg="no previous marked row")', 'go up current column to previous row with given mark')
+TableSheet.addCommand('', 'go-next-mark', 'moveToNextRow(lambda row,mark=vd.marks.inputmark(): vd.marks.isMarked(row, mark), msg="no next marked row")', 'go down current column to next row with given mark')
+
+
+vd.addMenuItems('''
+    View > Marks > open-marks
+    Row > Mark > open Marks Sheet > open-marks
+    Row > Mark > current row > mark-row
+    Row > Mark > selected rows > mark-selected
+    Row > Unmark > current row > unmark-row
+    Row > Unmark > selected rows > unmark-selected
+    Row > Select > marked rows > select-marks
+    Row > Unselect > marked rows > unselect-marks
+    Row > Toggle select > marked rows > stoggle-marks
+    Row > Goto > next marked row > go-next-mark
+    Row > Goto > previous marked row > go-prev-mark
+''')

visidata/experimental/noahs_tapestry/__init__.py

@@ -0,0 +1 @@
+from . import tapestry

visidata/experimental/noahs_tapestry/tapestry.py

@@ -0,0 +1,147 @@
+import json
+import time
+import collections
+import random
+from functools import cached_property
+from base64 import b64encode
+
+from visidata import vd, VisiData, Canvas, Animation, Path, asyncthread, clipdraw, colors, ItemColumn, Sheet, wraptext
+
+vd.theme_option('color_hint', 'black on yellow', '')
+
+@VisiData.api
+def getNoahsPath(vd, name):
+    return Path(vd.pkg_resources_files('visidata')/f'experimental/noahs_tapestry/{name}')
+
+@VisiData.api
+def openNoahsText(vd, name):
+    return vd.getNoahsPath(name).open(encoding='utf-8')
+
+@VisiData.cached_property
+def noahsDatabase(vd):
+    return vd.open_sqlite(vd.getNoahsPath('noahs.sqlite'))
+
+class NoahsPuzzle(Sheet):
+    guide = '''
+        # Puzzle {sheet.puznum}
+        - `Shift+A` to input a solution to the puzzle
+        - `Shift+Y` to attempt the current cell as the solution
+        - `Shift+B` to open Noah's Database Backup
+        - `Shift+V` to view Noah's Tapestry
+    '''
+    rowtype = 'lines'  # rowdef: [linenum, text]
+    filetype = 'txt'
+    columns = [
+        ItemColumn('linenum', 0, type=int, width=0),
+        ItemColumn('text', 1, width=80, displayer='full'),
+    ]
+    precious = False
+
+    def iterload(self):
+        clues = json.loads(vd.getNoahsPath(f'clues.json').read_text())
+        source = vd.getNoahsPath(f'puzzle{self.puznum}.md')
+        winWidth = 78
+        formatted_text = source.open(encoding='utf-8').read().format(**clues)
+        for startingLine, text in enumerate(formatted_text.splitlines()):
+            text = text.strip()
+            if text:
+                for i, (L, _) in enumerate(wraptext(str(text), width=winWidth)):
+                    yield [startingLine+i+1, L]
+            else:
+                yield [startingLine+1, text]
+
+@VisiData.cached_property
+def noahsSolutions(vd):
+    return json.loads(vd.getNoahsPath(f'solutions.json').read_text())
+
+@VisiData.api
+def solve_puzzle(vd, answer):
+    puznum = vd.noahsCurrentPuznum
+    if b64encode(answer.encode()).decode() != vd.noahsSolutions[f'p{puznum}']:
+        vd.fail("Hmmm, that doesn't seem right. Try again?")
+
+    vd.noahsTapestry.solved.add(puznum)
+    vd.status(f'Correct! The candle is now lit.')
+    vd.push(vd.noahsTapestry)
+
+
+class Tapestry(Canvas):
+    @property
+    def guide(self):
+        ret = ''
+        if vd.screenWidth < 120 or vd.screenHeight < 50:
+            ret = f'''
+            # [:black on yellow]WARNING: TERMINAL TOO SMALL[/]
+            Please expand your terminal to at least 120x50 (currently {vd.screenWidth}x{vd.screenHeight})
+        '''
+
+        ret += '''
+            # Noah's Tapestry
+            An interactive data game
+
+            - `Shift+N` to open the next puzzle
+        '''
+
+        return ret
+
+    solved = set()
+    def reload(self):
+        self.noahs_menorah = Animation(vd.openNoahsText('menorah.ddw'))
+        self.noahs_tapestry = Animation(vd.openNoahsText('tapestry.ddw'))
+        self.noahs_flame = Animation(vd.openNoahsText('flame.ddw'))
+        self.solved = set()
+
+#        self.keep_running()
+
+    @asyncthread
+    def keep_running(self):
+        while True:
+            time.sleep(1)
+
+    def draw(self, scr):
+        solvedays = ['menorah']+[f'day{i}' for i in self.solved]
+        t = time.time()
+        self.noahs_menorah.draw(scr, t=0, y=30, x=19)
+        if not self.solved:
+            clipdraw(scr, 22, 52, "Light the [:italic]shamash[/]", colors['255'])
+            return
+
+        self.noahs_menorah.draw(scr, t=0.1, y=30, x=19, tags=solvedays)
+        self.noahs_tapestry.draw(scr, t=t, tags=solvedays)
+
+        for i in self.solved:
+            xs = [58, 22+9*8, 22+9*7, 22+9*6, 22+9*5, 22+27, 22+18, 22+9, 22, 22]
+            ys = [28, 32, 32, 32, 32, 32, 32, 32, 32, 32]
+            x = xs[i]
+            y = ys[i]
+
+            self.noahs_flame.draw(scr, t=t+(i+random.random())*0.2, y=y, x=x)
+
+    def open_puzzle(self, puznum=None):
+        if puznum is None:
+            puznum = 0
+            if self.solved:
+                puznum = max(self.solved)+1
+
+        vs = NoahsPuzzle('puzzle', str(puznum), source=self, puznum=puznum)
+        vs.ensureLoaded()
+        vd.noahsCurrentPuznum = puznum
+        return vs
+
+
+@VisiData.lazy_property
+def noahsTapestry(vd):
+    vd.curses_timeout = 50
+    return Tapestry('noahs', 'tapestry')
+
+
+NoahsPuzzle.options.color_default = '178 yellow on 232 black'
+
+vd.addCommand('Shift+B', 'open-noahs-database', 'vd.push(noahsDatabase)', "open database for Noah's Tapestry")
+vd.addCommand('Shift+V', 'open-noahs-tapestry', 'vd.push(noahsTapestry)', "open Noah's Tapestry")
+Tapestry.addCommand('Shift+N', 'open-puzzle-next', 'vd.push(open_puzzle())', 'open next unsolved puzzle')
+NoahsPuzzle.addCommand('Shift+A', 'solve-puzzle-input', 'solve_puzzle(input("Answer: "))', 'input an answer to the current puzzle')
+Sheet.addCommand('Shift+Y', 'solve-puzzle-cell', 'solve_puzzle(cursorValue)', 'input an answer to the current puzzle')
+for i in range(9):
+    Tapestry.addCommand(f'{i}', f'open-puzzle-{i}', f'vd.push(open_puzzle({i}))')
+    Tapestry.addCommand(f'Alt+{i}', f'solve-puzzle-force-{i}', f'sheet.solved.add({i})')

visidata/experimental/rownum.py

@@ -0,0 +1,73 @@
+from visidata import *
+from functools import wraps, partial
+
+
+@asyncthread
+@Sheet.api
+def calcRowIndex(sheet, indexes):
+    for rownum, r in enumerate(sheet.rows):
+        indexes[sheet.rowid(r)] = rownum
+
+
+@Sheet.lazy_property
+def _rowindex(sheet):
+    ret = {}
+    sheet.calcRowIndex(ret)
+    return ret
+
+
+@Sheet.api
+def rowindex(sheet, row):
+    'Returns the rowindex given the row.  May spawn a thread to compute underlying _rowindex.'
+    return sheet._rowindex.get(sheet.rowid(row))
+
+
+@Sheet.api
+def prev(sheet, row):
+    'Return the row previous to the given row.'
+    rownum = max(sheet.rowindex(row)-1, 0)
+    return LazyComputeRow(sheet, sheet.rows[rownum])
+
+
+@Sheet.api
+def addcol_rowindex(sheet, newcol):
+    oldAddRow = sheet.addRow
+    def rownum_addRow(sheet, col, row, index=None):
+        if index is None:
+            index = len(sheet.rows)
+
+        col._rowindex[sheet.rowid(row)] = index
+        return oldAddRow(row, index)
+
+    # wrapper addRow to keep the index up to date
+    sheet.addRow = wraps(oldAddRow)(partial(rownum_addRow, sheet, newcol))
+    sheet.addColumnAtCursor(newcol)
+
+    # spawn a little thread to calc the rowindex
+    sheet.calcRowIndex(newcol._rowindex)
+
+
+@Sheet.api
+def addcol_delta(sheet, vcolidx):
+    col = sheet.visibleCols[vcolidx]
+
+    newcol = ColumnExpr("delta_"+col.name,
+                   type=col.type,
+                   _rowindex={},    # [rowid(row)] -> rowidx
+                   expr="{0}-prev(row).{0}".format(col.name))
+
+    sheet.addcol_rowindex(newcol)
+    return newcol
+
+@Sheet.api
+def addcol_rownum(sheet):
+    newcol = Column("rownum",
+               type=int,
+               _rowindex={},    # [rowid(row)] -> rowidx
+               getter=lambda col,row: col._rowindex.get(col.sheet.rowid(row)))
+
+    sheet.addcol_rowindex(newcol)
+    return newcol
+
+Sheet.addCommand(None, 'addcol-rownum', 'addcol_rownum()', helpstr='add column with original row ordering')
+Sheet.addCommand(None, 'addcol-delta', 'addcol_delta(cursorVisibleColIndex)', helpstr='add column with delta of current column')

visidata/experimental/slide_cells.py

@@ -0,0 +1,26 @@
+'''
+# TODO:
+- slide-cells-left
+- slide-cells-<dir>-n
+- slide-cells-selected-<dir>-n
+- rename "slide" to "shift"?
+'''
+
+from visidata import vd, TableSheet
+
+
+@TableSheet.api
+def slide_cells_right(sheet, row, vcolidx):
+    for oldcol, newcol in reversed(list(zip(sheet.visibleCols[vcolidx:], sheet.visibleCols[vcolidx+1:]))):
+        newcol.setValue(row, oldcol.getValue(row))
+
+    sheet.visibleCols[vcolidx].setValue(row, None)
+
+
+TableSheet.addCommand('', 'slide-cells-right', 'slide_cells_right(cursorRow, cursorVisibleColIndex)', '''
+Shift individual values in current row one visible column to the right, with leftmost cell set to null.
+''')
+
+vd.addMenuItems('''
+    Edit > Slide > cells > right > slide-cells-right
+''')

visidata/expr.py

@@ -38,10 +38,8 @@ def setValuesFromExpr(self, rows, expr):
     for row in Progress(rows, 'setting'):
         # Note: expressions that are only calculated once, do not need to pass column identity
         # they can reference their "previous selves" once without causing a recursive problem
-        try:
-            self.setValueSafe(row, self.sheet.evalExpr(compiledExpr, row))
-        except Exception as e:
-            vd.exceptionCaught(e)
+        v = vd.callNoExceptions(self.sheet.evalExpr, compiledExpr, row)
+        vd.callNoExceptions(self.setValue, row, v)
     self.recalc()
     vd.status('set %d values = %s' % (len(rows), expr))
 
@@ -59,3 +57,9 @@ Sheet.addCommand('gz=', 'setcol-iter', 'cursorCol.setValues(someSelectedRows, *l
 Sheet.addCommand(None, 'show-expr', 'status(evalExpr(inputExpr("show expr="), cursorRow))', 'evaluate Python expression on current row and show result on status line')
 
 vd.addGlobals({'CompleteExpr': CompleteExpr})
+
+vd.addMenuItems('''
+    Edit > Modify > current cell > Python expression > setcell-expr
+    Edit > Modify > selected cells > Python sequence > setcol-expr
+    Column > Add column > Python expr > addcol-expr
+''')

visidata/extensible.py

@@ -8,7 +8,7 @@ class Extensible:
 
     @classmethod
     def init(cls, membername, initfunc=lambda: None, copy=False):
-        'Append equivalent of ``self.<membername> = initfunc()`` to ``<cls>.__init__``.  If *copy* is True, <membername> will be copied when object is copied.'
+        'Prepend equivalent of ``self.<membername> = initfunc()`` to ``<cls>.__init__``.  If *copy* is True, <membername> will be copied when object is copied.'
 
         def thisclass_hasattr(cls, k):
             return getattr(cls, k, None) is not getattr(cls.__bases__[0], k, None)
@@ -16,12 +16,12 @@ class Extensible:
         # must check hasattr first or else this might be parent's __init__
         oldinit = thisclass_hasattr(cls, '__init__') and getattr(cls, '__init__')
         def newinit(self, *args, **kwargs):
+            if not hasattr(self, membername):  # can be overridden by a subclass
+                setattr(self, membername, initfunc())
             if oldinit:
                 oldinit(self, *args, **kwargs)
             else:
                 super(cls, self).__init__(*args, **kwargs)
-            if not hasattr(self, membername):  # can be overridden by a subclass
-                setattr(self, membername, initfunc())
         cls.__init__ = wraps(oldinit)(newinit) if oldinit else newinit
 
         oldcopy = thisclass_hasattr(cls, '__copy__') and getattr(cls, '__copy__')
@@ -30,15 +30,32 @@ class Extensible:
                 ret = oldcopy(self, *args, **kwargs)
             else:
                 ret = super(cls, self).__copy__(*args, **kwargs)
-            setattr(ret, membername, getattr(self, membername) if copy and hasattr(self, membername) else initfunc())
+
+            if not hasattr(ret, membername):
+                if copy and hasattr(self, membername):
+                    v = getattr(self, membername)
+                else:
+                    v = initfunc()
+                setattr(ret, membername, v)
+
             return ret
         cls.__copy__ = wraps(oldcopy)(newcopy) if oldcopy else newcopy
 
+    @classmethod
+    def superclasses(cls):
+        yield cls
+        yield from cls.__bases__
+        for b in cls.__bases__:
+            if hasattr(b, 'superclasses'):
+                yield from b.superclasses()
+
     @classmethod
     def api(cls, func):
         oldfunc = getattr(cls, func.__name__, None)
         if oldfunc:
             func = wraps(oldfunc)(func)
+        from visidata import vd
+        func.importingModule = vd.importingModule
         setattr(cls, func.__name__, func)
         return func
 
@@ -75,6 +92,14 @@ class Extensible:
 
     @classmethod
     def class_api(cls, func):
+        '''`@Class.class_api` works much like `@Class.api`, but for class methods. This method is used internally but may not be all that useful for plugin and module authors. Note that `@classmethod` must still be provided, and **the order of multiple decorators is crucial**, in that `@<class>.class_api` must come before `@classmethod`:
+
+::
+        @Sheet.class_api
+        @classmethod
+        def addCommand(cls, ...):
+        '''
+
         name = func.__get__(None, dict).__func__.__name__
         oldfunc = getattr(cls, name, None)
         if oldfunc:
@@ -99,7 +124,7 @@ class Extensible:
         @property
         @wraps(func)
         def get_if_not(self):
-            if getattr(self, name) is None:
+            if getattr(self, name, None) is None:
                 setattr(self, name, func(self))
             return getattr(self, name)
         setattr(cls, func.__name__, get_if_not)

visidata/features/addcol_audiometadata.py

@@ -0,0 +1,42 @@
+# requirements: mutagen
+
+import functools
+
+from visidata import vd, Column, AttrColumn, DirSheet
+
+
+@functools.lru_cache(None)
+def get_mutagen_info(path):
+    mutagen = vd.importExternal('mutagen')
+    m = mutagen.File(path)
+    return m.info
+
+
+class MutagenColumn(AttrColumn):
+    def calcValue(self, r):
+        md = get_mutagen_info(r)
+        return getattr(md, self.expr, None)
+
+
+@DirSheet.api
+def audiometadata_columns(sheet):
+    return [
+        Column('audio_info', width=0, getter=lambda c,r: get_mutagen_info(r)),
+        MutagenColumn('bitrate'),
+        MutagenColumn('channels'),
+        MutagenColumn('encoder_info'),
+        MutagenColumn('encoder_settings'),
+        MutagenColumn('frame_offset'),
+        MutagenColumn('length'),
+        MutagenColumn('mode'),
+        MutagenColumn('padding'),
+        MutagenColumn('protected'),
+        MutagenColumn('sample_rate'),
+        MutagenColumn('track_gain'),
+    ]
+
+
+DirSheet.addCommand('', 'addcol-audiometadata', 'addColumn(*audiometadata_columns())', 'add metadata columns for audio files (MP3, FLAC, Ogg, etc)')
+
+
+vd.addMenuItems('Column > Add column > audio metadata > addcol-audiometadata')

visidata/features/addcol_histogram.py

@@ -0,0 +1,34 @@
+from visidata import vd, Column, Sheet, asyncthread, Progress
+
+
+class HistogramColumn(Column):
+    def calcValue(col, row):
+        histogram = col.sheet.options.disp_histogram
+        histolen = (col.width-2)*col.sourceCol.getTypedValue(row)//(col.sourceCol.largest-col.sourceCol.smallest)
+        return histogram*histolen
+
+
+@Sheet.api
+def addcol_histogram(sheet, col):  #2052
+    newcol = HistogramColumn(col.name+'_histogram', sourceCol=col)
+    col.smallest = None
+    col.largest = None
+    sheet.calc_histogram_bounds(col)
+    return newcol
+
+
+@Sheet.api
+@asyncthread
+def calc_histogram_bounds(sheet, col):
+    for row in Progress(sheet.rows):
+        v = col.getTypedValue(row)
+        if col.smallest is None or v < col.smallest:
+            col.smallest = v
+        if col.largest is None or v > col.largest:
+            col.largest = v
+
+
+Sheet.addCommand('', 'addcol-histogram', 'addColumnAtCursor(addcol_histogram(cursorCol))', 'add column with histogram of current column')
+
+
+vd.addMenuItems('Column > Add column > histogram > addcol-histogram')

visidata/features/canvas_save_svg.py

@@ -0,0 +1,69 @@
+'''
+Add svg saver to Canvas.
+
+Requires matplotlib.pyplot
+'''
+
+
+import collections
+
+from visidata import VisiData, Canvas, vd, Progress
+
+vd.option('plt_marker', '.', 'matplotlib.markers')
+
+
+@Canvas.api
+def plot_sheet(self, ax):
+    plt = vd.importExternal('matplotlib.pyplot', 'matplotlib')
+    nerrors = 0
+    nplotted = 0
+
+    self.reset()
+
+    vd.status('loading data points')
+    catcols = [c for c in self.xcols if not vd.isNumeric(c)]
+    numcols = [c for c in self.xcols if vd.isNumeric(c)]
+    for ycol in self.ycols:
+        xpts = collections.defaultdict(list)
+        ypts = collections.defaultdict(list)
+        for rownum, row in enumerate(Progress(self.sourceRows, 'plotting')):  # rows being plotted from source
+            try:
+                k = tuple(c.getValue(row) for c in catcols) if catcols else (ycol.name,)
+
+                # convert deliberately to float (to e.g. linearize date)
+                graph_x = numcols[0].type(numcols[0].getValue(row)) if numcols else rownum
+                graph_y = ycol.type(ycol.getValue(row))
+
+                xpts[k].append(graph_x)
+                ypts[k].append(graph_y)
+
+                nplotted += 1
+            except Exception:
+                nerrors += 1
+                if vd.options.debug:
+                    raise
+        lines = []
+        for k in xpts:
+            line = ax.scatter(xpts[k], ypts[k], label=' '.join(str(x) for x in k), **vd.options.getall('plt_'))
+            lines.append(line)
+
+        ax.legend(handles=lines)
+        ax.set_xlabel(','.join(xcol.name for xcol in self.xcols if vd.isNumeric(xcol)) or 'row#')
+        ax.xaxis.set_major_locator(plt.MaxNLocator(4))
+        ax.yaxis.set_major_locator(plt.MaxNLocator(4))
+
+
+@VisiData.api
+def save_svg(vd, p, *sheets):
+    plt = vd.importExternal('matplotlib.pyplot', 'matplotlib')
+    fig_, ax = plt.subplots()
+    for vs in sheets:
+        if not isinstance(vs, Canvas):
+            vd.warning(f'{vs.name} not a Canvas')
+            continue
+        vs.plot_sheet(ax)
+
+    ax.grid()
+    ax.set_title('\n'.join(vs.name for vs in sheets))
+    plt.xticks()
+    plt.savefig(p, format='svg')