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

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:
@@ -94,11 +119,12 @@ class Extensible:
     @classmethod
     def lazy_property(cls, func):
         'Return ``func()`` on first access and cache result; return cached result thereafter.'
+        name = '_' + func.__name__
+        cls.init(name, lambda: None, copy=False)
         @property
         @wraps(func)
         def get_if_not(self):
-            name = '_' + func.__name__
-            if not hasattr(self, name):
+            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')

visidata/features/change_precision.py

@@ -0,0 +1,46 @@
+__author__ = 'Andy Craig, andycraig (https://github.com/andycraig)'
+
+
+import re
+
+from visidata import vd, Sheet, Column, floatsi, currency, date
+
+date_fmtstrs = [
+    '%Y',
+    '%Y-%m',
+#    '%Y-W%U',
+    '%Y-%m-%d',
+    '%Y-%m-%d %H',
+    '%Y-%m-%d %H:%M',
+    '%Y-%m-%d %H:%M:%S',
+    '%Y-%m-%d %H:%M:%S.%f',
+]
+
+@Column.api
+def setcol_precision(col, amount:int):
+    if col.type is date:
+        try:
+            i = date_fmtstrs.index(col.fmtstr)
+        except ValueError:
+            i = 2
+        col.fmtstr = date_fmtstrs[(i+amount)%len(date_fmtstrs)]
+    elif col.type in (float, floatsi, currency):
+        if col.fmtstr == '':
+            col.fmtstr = f'%.{2 + amount}f'
+        else:
+            precision_str = re.match(r'%.([0-9]+)f', col.fmtstr)
+            if not precision_str is None:
+                col.fmtstr = f'%.{max(0, int(precision_str[1]) + amount)}f'
+    else:
+        col.type = float
+        if col.fmtstr == '':
+            col.fmtstr = '%.2f'
+
+
+vd.addMenuItems('''
+    Column > Set precision > more > setcol-precision-more
+    Column > Set precision > less > setcol-precision-less
+''')
+
+Sheet.addCommand('Alt+-', 'setcol-precision-less', 'cursorCol.setcol_precision(-1)', 'show less precision in current column')
+Sheet.addCommand('Alt++', 'setcol-precision-more', 'cursorCol.setcol_precision(1)', 'show more precision in current column')

visidata/features/cmdpalette.py

@@ -0,0 +1,163 @@
+import collections
+from functools import partial
+from visidata import DrawablePane, BaseSheet, vd, VisiData, CompleteKey, clipdraw, HelpSheet, colors, AcceptInput, AttrDict, drawcache_property
+
+
+vd.theme_option('color_cmdpalette', 'black on 72', 'base color of command palette')
+vd.theme_option('disp_cmdpal_max', 10, 'max number of suggestions for command palette')
+
+def add_to_input(v, i, value=''):
+    items = list(v.split())
+    if not v or v.endswith(' '):
+        items.append(value)
+    else:
+        items[-1] = value
+    v = ' '.join(items) + ' '
+    return v, len(v)
+
+
+def accept_input(v, i, value=None):
+    raise AcceptInput(v if value is None else value)
+
+
+@VisiData.lazy_property
+def usedInputs(vd):
+    return collections.defaultdict(int)
+
+@DrawablePane.after
+def execCommand2(sheet, cmd, *args, **kwargs):
+    vd.usedInputs[cmd.longname] += 1
+
+@BaseSheet.api
+def inputPalette(sheet, prompt, items,
+                 value_key='key',
+                 formatter=lambda m, item, trigger_key: f'{trigger_key} {item}',
+                 multiple=False,
+                 **kwargs):
+    bindings = dict()
+
+    tabitem = -1
+
+    def tab(n, nitems):
+        nonlocal tabitem
+        tabitem = (tabitem + n) % nitems
+
+    def _draw_palette(value):
+        words = value.lower().split()
+
+        if multiple and words:
+            if value.endswith(' '):
+                finished_words = words
+                unfinished_words = []
+            else:
+                finished_words = words[:-1]
+                unfinished_words = [words[-1]]
+        else:
+            unfinished_words = words
+            finished_words = []
+
+        unuseditems = [item for item in items if item[value_key] not in finished_words]
+
+        matches = vd.fuzzymatch(unuseditems, unfinished_words)
+
+        h = sheet.windowHeight
+        w = min(100, sheet.windowWidth)
+        nitems = min(h-1, sheet.options.disp_cmdpal_max)
+
+        useditems = []
+        palrows = []
+
+        for m in matches[:nitems]:
+            useditems.append(m.match)
+            palrows.append((m, m.match))
+
+        favitems = sorted([item for item in unuseditems if item not in useditems],
+                          key=lambda item: -vd.usedInputs.get(item[value_key], 0))
+
+        for item in favitems[:nitems-len(palrows)]:
+            palrows.append((None, item))
+
+        navailitems = min(len(palrows), nitems)
+
+        bindings['^I'] = lambda *args: tab(1, navailitems) or args
+        bindings['KEY_BTAB'] = lambda *args: tab(-1, navailitems) or args
+
+        for i in range(nitems-len(palrows)):
+            palrows.append((None, None))
+
+        for i, (m, item) in enumerate(palrows):
+            trigger_key = ' '
+            if tabitem >= 0 and item:
+                trigger_key = f'{i+1}'[-1]
+                bindings[trigger_key] = partial(add_to_input if multiple else accept_input, value=item[value_key])
+
+            attr = colors.color_cmdpalette
+
+            if tabitem < 0 and palrows:
+                _ , topitem = palrows[0]
+                bindings['^J'] = partial(accept_input, value=None)
+                if multiple:
+                    bindings[' '] = partial(add_to_input, value=topitem[value_key])
+            elif item and i == tabitem:
+                bindings['^J'] = partial(accept_input, value=None)
+                if multiple:
+                    bindings[' '] = partial(add_to_input, value=item[value_key])
+                attr = colors.color_menu_spec
+
+            match_summary = formatter(m, item, trigger_key) if item else ' '
+
+            clipdraw(sheet._scr, h-nitems-1+i, 0, match_summary, attr, w=w)
+
+        return None
+
+    completer = CompleteKey(sorted(item[value_key] for item in items))
+    return vd.input(prompt,
+            completer=completer,
+            updater=_draw_palette,
+            bindings=bindings,
+            **kwargs)
+
+
+def cmdlist(sheet):
+    return [
+            AttrDict(longname=row.longname,
+                     description=sheet.cmddict[(row.sheet, row.longname)].helpstr)
+        for row in sheet.rows
+    ]
+HelpSheet.cmdlist = drawcache_property(cmdlist)
+
+
+@BaseSheet.api
+def inputLongname(sheet):
+    prompt = 'command name: '
+    # get set of commands possible in the sheet
+    this_sheets_help = HelpSheet('', source=sheet)
+    this_sheets_help.ensureLoaded()
+
+    def _fmt_cmdpal_summary(match, row, trigger_key):
+        keystrokes = this_sheets_help.revbinds.get(row.longname, [None])[0] or ' '
+        formatted_longname = match.formatted.get('longname', row.longname) if match else row.longname
+        formatted_name = f'[:onclick {row.longname}]{formatted_longname}[/]'
+        if vd.options.debug and match:
+            keystrokes = f'[{match.score}]'
+        r = f' [:keystrokes]{keystrokes.rjust(len(prompt)-5)}[/]  '
+        r += f'[:keystrokes]{trigger_key}[/] {formatted_name}'
+        if row.description:
+            formatted_desc = match.formatted.get('description', row.description) if match else row.description
+            r += f' - {formatted_desc}'
+        return r
+
+    return sheet.inputPalette(prompt, this_sheets_help.cmdlist,
+                              value_key='longname',
+                              formatter=_fmt_cmdpal_summary,
+                              type='longname')
+
+
+@BaseSheet.api
+def exec_longname(sheet, longname):
+    if not sheet.getCommand(longname):
+        vd.fail(f'no command {longname}')
+    sheet.execCommand(longname)
+
+
+vd.addCommand('Space', 'exec-longname', 'exec_longname(inputLongname())', 'execute command by its longname')