visidata 3.1.1__py3-none-any.whl → 3.3__py3-none-any.whl

visidata/basesheet.py

@@ -76,6 +76,8 @@ class DrawablePane(Extensible):
 
         try:
             self.sheet = self
+            if cmd.deprecated:
+                vd.deprecated_warn(cmd.longname, cmd.deprecated, 'a different command')
             code = compile(cmd.execstr, cmd.longname, 'exec')
             exec(code, vdglobals, LazyChainMap(vd, self))
             return False
@@ -105,6 +107,7 @@ class BaseSheet(DrawablePane):
     precious = True      # False for a few discardable metasheets
     defer = False        # False for not deferring changes until save
     guide = ''           # default to show in sidebar
+    icon = '›'
 
     def _obj_options(self):
         return vd.OptionsObject(vd._options, obj=self)
@@ -212,7 +215,7 @@ class BaseSheet(DrawablePane):
         try:
             for hookfunc in vd.beforeExecHooks:
                 hookfunc(self, cmd, '', keystrokes)
-            escaped = super().execCommand2(cmd, vdglobals=vdglobals)
+            escaped = self.execCommand2(cmd, vdglobals=vdglobals)
         except Exception as e:
             vd.debug(cmd.execstr)
             err = vd.exceptionCaught(e)
@@ -299,8 +302,6 @@ class BaseSheet(DrawablePane):
         'Return formatted string with *sheet* and *vd* accessible to expressions.  Missing expressions return empty strings instead of error.'
         return MissingAttrFormatter().format(fmt, sheet=self, vd=vd, **kwargs)
 
-
-
 @VisiData.api
 def redraw(vd):
     'Clear the terminal screen and let the next draw cycle recreate the windows and redraw everything.'

visidata/canvas.py

@@ -11,7 +11,7 @@ from visidata.bezier import bezier
 vd.theme_option('disp_graph_labels', True, 'show axes and legend on graph')
 vd.theme_option('plot_colors', 'green red yellow cyan magenta white 38 136 168', 'list of distinct colors to use for plotting distinct objects')
 vd.theme_option('disp_canvas_charset', ''.join(chr(0x2800+i) for i in range(256)), 'charset to render 2x4 blocks on canvas')
-vd.theme_option('disp_pixel_random', False, 'randomly choose attr from set of pixels instead of most common')
+vd.theme_option('disp_graph_pixel_random', False, 'randomly choose attr from set of pixels instead of most common')
 vd.theme_option('disp_zoom_incr', 2.0, 'amount to multiply current zoomlevel when zooming')
 vd.theme_option('color_graph_hidden', '238 blue', 'color of legend for hidden attribute')
 vd.theme_option('color_graph_selected', 'bold', 'color of selected graph points')
@@ -258,7 +258,7 @@ class Plotter(BaseSheet):
         disp_canvas_charset += (256 - len(disp_canvas_charset)) * disp_canvas_charset[-1]
         if self.pixels:
             cursorBBox = self.plotterCursorBox
-            getPixelAttr = self.getPixelAttrRandom if self.options.disp_pixel_random else self.getPixelAttrMost
+            getPixelAttr = self.getPixelAttrRandom if self.options.disp_graph_pixel_random else self.getPixelAttrMost
 
             for char_y in range(0, self.plotheight//4):
                 for char_x in range(0, self.plotwidth//2):
@@ -304,8 +304,8 @@ class Plotter(BaseSheet):
             def _overlaps(a, b):
                 a_x1, _, a_txt, _, _ = a
                 b_x1, _, b_txt, _, _ = b
-                a_x2 = a_x1 + len(a_txt)
-                b_x2 = b_x1 + len(b_txt)
+                a_x2 = a_x1 + dispwidth(a_txt)
+                b_x2 = b_x1 + dispwidth(b_txt)
                 if a_x1 < b_x1 < a_x2 or a_x1 < b_x2 < a_x2 or \
                    b_x1 < a_x1 < b_x2 or b_x1 < a_x2 < b_x2:
                    return True
@@ -325,10 +325,10 @@ class Plotter(BaseSheet):
             for pix_x, pix_y, txt, attr, row in self.labels:
                 if attr in self.hiddenAttrs:
                     continue
-                if row is not None:
-                    pix_x -= len(txt)/2*2
                 char_y = int(pix_y/4)
                 char_x = int(pix_x/2)
+                if row is not None:
+                    char_x -= math.ceil(dispwidth(txt)/2)*2
                 o = (char_x, char_y, txt, attr, row)
                 _mark_overlap_text(labels_by_line[char_y], o)
 
@@ -356,6 +356,7 @@ class Canvas(Plotter):
     rightMarginPixels = 4*2
     topMarginPixels = 0*4
     bottomMarginPixels = 1*4  # reserve bottom line for x axis
+    guide = '# Canvas\n'
 
     def __init__(self, *names, **kwargs):
         self.left_margin = self.leftMarginPixels
@@ -384,6 +385,9 @@ class Canvas(Plotter):
     def reset(self):
         'clear everything in preparation for a fresh reload()'
         self.polylines.clear()
+        self.canvasBox = None
+        self.visibleBox = None
+        self.cursorBox = None
         self.left_margin = self.leftMarginPixels
         self.legends.clear()
         self.legendwidth = 0
@@ -727,7 +731,7 @@ class Canvas(Plotter):
     def plot_elements(self, invert_y=False):
         'plots points and lines and text onto the plotter'
 
-        self.resetBounds()
+        self.resetBounds(refresh=False)
 
         bb = self.visibleBox
         xmin, ymin, xmax, ymax = bb.xmin, bb.ymin, bb.xmax, bb.ymax

visidata/clipboard.py

@@ -7,13 +7,21 @@ import tempfile
 import functools
 import os
 import itertools
+import platform
 
 from visidata import VisiData, vd, asyncthread, SettableColumn
 from visidata import Sheet, Path, Column
 
-if sys.platform == 'win32':
+if (
+    # Windows
+    sys.platform == 'win32'
+    # WSL 2
+    or "microsoft-standard-WSL2" in platform.uname().release
+    # WSL 1
+    or sys.platform == 'linux' and platform.uname().release.endswith("-Microsoft")
+):
     syscopy_cmd_default = 'clip.exe'
-    syspaste_cmd_default = 'powershell -command Get-Clipboard'
+    syspaste_cmd_default = 'powershell.exe -noprofile -command Get-Clipboard'
 elif sys.platform == 'darwin':
     syscopy_cmd_default = 'pbcopy w'
     syspaste_cmd_default = 'pbpaste'
@@ -196,6 +204,7 @@ Sheet.addCommand('Y', 'syscopy-row', 'syscopyCells(visibleCols, [cursorRow])', '
 
 Sheet.addCommand('gY', 'syscopy-selected', 'syscopyCells(visibleCols, onlySelectedRows)', 'yank (copy) selected rows to system clipboard (using options.clipboard_copy_cmd)')
 Sheet.addCommand('zY', 'syscopy-cell', 'syscopyValue(cursorDisplay)', 'yank (copy) current cell to system clipboard (using options.clipboard_copy_cmd)')
+Sheet.addCommand('', 'syscopy-colname', 'syscopyValue(cursorCol.name)', 'yank (copy) current column header to system clipboard (using options.clipboard_copy_cmd)')
 Sheet.addCommand('gzY', 'syscopy-cells', 'syscopyCells([cursorCol], onlySelectedRows, filetype="txt")', 'yank (copy) contents of current column from selected rows to system clipboard (using options.clipboard_copy_cmd')
 
 Sheet.addCommand('x', 'cut-row', 'copyRows([sheet.delete_row(cursorRowIndex)]); defer and cursorDown(1)', 'delete (cut) current row and move it to clipboard')

visidata/cliptext.py

@@ -142,42 +142,52 @@ def iterchars(x):
 
 @functools.lru_cache(maxsize=100000)
 def _clipstr(s, dispw, trunch='', oddspacech='', combch='', modch=''):
-    '''Return clipped string and width in terminal display characters.
-    Note: width may differ from len(s) if East Asian chars are 'fullwidth'.'''
-    if not s:
+    ''' *s* is a string or an iterator that contains characters.
+    *dispw* is the integer screen width that the clipped string will fit inside, or None.
+    Return clipped string and width in terminal display characters.
+    Note: width may differ from len(s) if chars are 'fullwidth'.
+    If *dispw* is None, no clipping occurs.
+    If *trunch* has a width greater than *dispw*, the empty string
+    will be used as a truncator instead.'''
+    if not s or (dispw is not None and dispw < 1): #iterator s would be truthy
         return '', 0
 
-    if dispw == 1:
-        return s[0], 1
-
     w = 0
     ret = ''
+    trunc_i = 0
+    w_truncated = 0
 
     trunchlen = dispwidth(trunch)
+    if dispw is None:
+        s = ''.join(s)
+        return s, dispwidth(s)
+    if trunchlen > dispw: #if the truncator cannot fit, use a truncator of ''
+        return _clipstr(s, dispw, trunch='', oddspacech=oddspacech, combch=combch, modch=modch)
     for c in s:
         newc, chlen = _dispch(c, oddspacech=oddspacech, combch=combch, modch=modch)
         if not newc:
             newc = c
             chlen = dispwidth(c)
 
-        if dispw and w+chlen > dispw:
-            if trunchlen and dispw > trunchlen:
-                lastchlen = _dispch(ret[-1])[1]
-                if w+trunchlen > dispw:
-                    ret = ret[:-1]
-                    w -= lastchlen
-                ret += trunch  # replace final char with ellipsis
-                w += trunchlen
-            break
-
-        w += chlen
-        ret += newc
+        #if the next character will fit
+        if w+chlen <= dispw:
+            ret += newc
+            w += chlen
+            #move the truncation spot forward only when the truncation character can fit
+            if w+trunchlen <= dispw:
+                trunc_i += 1
+                w_truncated += chlen
+            continue
+        # if we reach this line, a character did not fit, and the result needs truncation
+        return ret[:trunc_i] + trunch, w_truncated+trunchlen
 
     return ret, w
 
 
 @drawcache
 def clipstr(s, dispw, truncator=None, oddspace=None):
+    ''' *s* is a string or an iterator that contains characters.
+    *dispw* is the integer screen width that the clipped string will fit inside, or None.'''
     if options.visibility:
         return _clipstr(s, dispw,
                         trunch=options.disp_truncator if truncator is None else truncator,
@@ -205,8 +215,6 @@ def clipdraw(scr, y, x, s, attr, w=None, clear=True, literal=False, **kwargs):
 
     x = max(0, x)
     y = max(0, y)
-    assert x >= 0, x
-    assert y >= 0, y
 
     return clipdraw_chunks(scr, y, x, chunks, attr, w=w, clear=clear, **kwargs)
 
@@ -310,6 +318,10 @@ def wraptext(text, width=80, indent=''):
         line = _markdown_to_internal(line)
         chunks = re.split(internal_markup_re, line)
         textchunks = [x for x in chunks if not is_vdcode(x)]
+        if ''.join(textchunks) == '':  #for markup with no contents, like '[:tag][/]' or '[:]' or '[/]'
+            yield '', ''
+            continue
+        # textwrap.wrap does not handle variable-width characters  #2416
         for linenum, textline in enumerate(textwrap.wrap(''.join(textchunks), width=width, drop_whitespace=False)):
             txt = textline
             r = ''
@@ -345,8 +357,39 @@ def clipbox(scr, lines, attr, title=''):
     for i, line in enumerate(lines):
         clipdraw(scr, i+1, 2, line, attr)
 
-    clipdraw(scr, 0, w-len(title)-6, f"| {title} |", attr)
-
+    clipdraw(scr, 0, w-dispwidth(title)-6, f"| {title} |", attr)
+
+def clipstr_start(dispval, w, truncator=''):
+    '''Return a tuple (frag, dw), where *frag* is the longest ending substring
+    of *dispval* that will fit in a space *w* terminal display characters wide,
+    and *dw* is the substring's display width as an int.'''
+    # Note: this implementation is likely incorrect for unusual Unicode
+    # strings or encodings, where trimming an initial character produces
+    # an invalid string or does not make the string shorter.
+    if w <= 0: return '', 0
+    j = len(dispval)
+    while j >= 1:
+        if dispwidth((truncator if j > 1 else '') + dispval[j-1:]) <= w:
+            j -= 1
+        else:
+            break
+    frag = (truncator if j > 0 else '') + dispval[j:]
+    return frag, dispwidth(frag)
+
+def clipstr_middle(s, n=10, truncator='…'):
+    '''Return a string having a display width <= *n*. Excess characters are
+    trimmed from the middle of the string, and replaced by a single
+    instance of *truncator*.'''
+    if n == 0: return '', 0
+    if dispwidth(s) > n:
+        #for even widths, give the leftover 1 space to the right fragment
+        l_space = n//2 if n%2 == 1 else max(n//2-1, 0)
+        l_frag, l_w = _clipstr(s, l_space)
+        #if left fragment did not fill its space, give the unused space to the right fragment
+        r_frag = clipstr_start(s, n//2+(l_space-l_w))[0]
+        res = l_frag + truncator + r_frag
+        return res, dispwidth(res)
+    return s, dispwidth(s)
 
 vd.addGlobals(clipstr=clipstr,
               clipdraw=clipdraw,
@@ -355,4 +398,6 @@ vd.addGlobals(clipstr=clipstr,
               dispwidth=dispwidth,
               iterchars=iterchars,
               iterchunks=iterchunks,
-              wraptext=wraptext)
+              wraptext=wraptext,
+              clipstr_start=clipstr_start,
+              clipstr_middle=clipstr_middle)

visidata/cmdlog.py

@@ -330,6 +330,9 @@ def replay_sync(vd, cmdlog):
     with vd.DisableAsync():
         vd.sync()  #2352 let cmdlog finish loading
         cmdlog.cursorRowIndex = 0
+        # save current replay, for cmdlogs that replay other cmdlogs, such as a macro executing another macro
+        prev_replay = vd.currentReplay
+        prev_replay_row = vd.currentReplayRow
         vd.currentReplay = cmdlog
 
         with Progress(total=len(cmdlog.rows)) as prog:
@@ -356,7 +359,8 @@ def replay_sync(vd, cmdlog):
                     vd.activeSheet.ensureLoaded()
 
         vd.status('replay complete')
-        vd.currentReplay = None
+        vd.currentReplay = prev_replay
+        vd.currentReplayRow = prev_replay_row
 
 
 @VisiData.api

visidata/column.py

@@ -40,21 +40,11 @@ class DisplayWrapper:
     def __eq__(self, other):
         return self.value == other
 
-def _default_colnames():
-    'A B C .. Z AA AB .. ZZ AAA .. to infinity'
-    i=0
-    while True:
-        i += 1
-        for x in itertools.product(string.ascii_uppercase, repeat=i):
-            yield ''.join(x)
-
-default_colnames = _default_colnames()
-
 
 class Column(Extensible):
     '''Base class for all column types.
 
-        - *name*: name of this column.
+        - *name*: name of this column; if None, current sheet will assign a name
         - *type*: ``anytype str int float date`` or other type-like conversion function.
         - *cache*: cache behavior
 
@@ -71,7 +61,10 @@ class Column(Extensible):
     def __init__(self, name=None, *, type=anytype, cache=False, **kwargs):
         self.sheet = ExplodingMock('use addColumn() on all columns')  # owning Sheet, set in .recalc() via Sheet.addColumn
         if name is None:
-            name = next(default_colnames)
+            if vd.sheet: # get a column name from the current sheet
+                name = vd.sheet.incremented_colname()
+            else:
+                name = ''
         self.name = str(name) # display visible name
         self.fmtstr = ''      # by default, use str()
         self._type = type     # anytype/str/int/float/date/func
@@ -86,7 +79,7 @@ class Column(Extensible):
         self.formatter = ''
         self.displayer = ''
         self.defer = False
-        self.disp_expert = 0    # auto-hide if options.disp_expert less than col.disp_expert
+        self.disp_expert = 0    # do not show if 'nometacols' in options.disp_help_flags
 
         self.setCache(cache)
         for k, v in kwargs.items():
@@ -243,12 +236,16 @@ class Column(Extensible):
         return self.make_formatter()(*args, **kwargs)
 
     def formatValue(self, typedval, width=None):
-        'Return displayable string of *typedval* according to ``Column.fmtstr``.'
+        '''Return displayable string of *typedval* according to ``Column.fmtstr``.
+        If *width* is not None, values are clipped to that width when *typedval*
+        is a dict/list/tuple, but not for other types.'''
         if typedval is None:
             return None
 
         if self.type is anytype:
             if isinstance(typedval, (dict, list, tuple)):
+                if width is None:
+                    return ''.join(iterchars(typedval))
                 dispval, dispw = clipstr(iterchars(typedval), width)
                 return dispval
 
@@ -264,7 +261,9 @@ class Column(Extensible):
 
            The 'generic' displayer does not do any formatting.
         '''
-        if width is not None and width > 1 and vd.isNumeric(self):
+        if width is not None and width > 1 and \
+                vd.isNumeric(self) and \
+                isinstance(dw.typedval, (int, float)):
             yield ('', dw.text.rjust(width-2))
         else:
             yield ('', dw.text)
@@ -355,7 +354,8 @@ class Column(Extensible):
         return ret
 
     def getCell(self, row):
-        'Return DisplayWrapper for displayable cell value.'
+        '''Return DisplayWrapper for displayable cell value.
+        For dict/list/tuple cells, the width of the value returned is capped at the column width.'''
         cellval = wrapply(self.getValue, row)
         typedval = wrapply(self.type, cellval)
 
@@ -394,7 +394,7 @@ class Column(Extensible):
         dw.typedval = typedval
 
         try:
-            dw.text = self.format(typedval, width=(self.width or 0)*2) or ''
+            dw.text = self.format(typedval, width=self.width) or ''
 
             # annotate cells with raw value type in anytype columns, except for strings
             if self.type is anytype and type(cellval) is not str:
@@ -417,7 +417,8 @@ class Column(Extensible):
         return dw
 
     def getDisplayValue(self, row):
-        'Return string displayed in this column for given *row*.'
+        '''Return string displayed in this column for given *row*.
+        For dict/list/tuple cells, the width of the display value returned is capped at the column width.'''
         return self.getCell(row).text
 
     def putValue(self, row, val):
@@ -457,22 +458,36 @@ class Column(Extensible):
         return vd.status('set %d cells to %d values' % (len(rows), len(values)))
 
     def getMaxWidth(self, rows):
-        'Return the maximum length of any cell in column or its header (up to window width).'
-        w = 0
+        'Return the maximum length of any cell in column or its header (up to drawable window width).'
+        drawable_width = self.sheet.windowWidth-1
         nlen = dispwidth(self.name)
-        if len(rows) > 0:
-            w_max = 0
-            for r in rows:
-                row_w = dispwidth(self.getDisplayValue(r), maxwidth=self.sheet.windowWidth)
-                if w_max < row_w:
-                    w_max = row_w
-                if w_max >= self.sheet.windowWidth:
-                    break  #1747  early out to speed up wide columns
-            w = w_max
-        w = max(w, nlen)+2
-        w = min(w, self.sheet.windowWidth)
-        return w
-
+        w_max = nlen
+        for r in rows:
+            row_w = self.measureValueWidthCapped(r, maxwidth=drawable_width)
+            if w_max < row_w:
+                w_max = row_w
+            if w_max >= self.sheet.windowWidth:
+                break  #1747  early out to speed up wide columns
+        return min(w_max+2, drawable_width)
+
+    def measureValueWidthCapped(self, row, maxwidth=None):
+        '''Measure the width of the contents of a cell. Stop measuring at *maxwidth*,
+           to save time iterating over very long dict/list/tuple values.
+           If *maxwidth* is None, return the full width.'''
+        # The value classification logic here is taken from getCell,
+        # modified to cap the width examined for any dict/list/tuple
+        cellval = wrapply(self.getValue, row)
+        typedval = wrapply(self.type, cellval)
+        if isinstance(typedval, (TypedWrapper, threading.Thread)):
+            return dispwidth(self.getCell(row).text, maxwidth=maxwidth)
+        try:
+            text = self.format(typedval, width=maxwidth) or ''
+        except Exception as e:  # formatting failure
+            try:
+                text = str(cellval)
+            except Exception as e:
+                text = str(e)
+        return dispwidth(text, maxwidth=maxwidth)
 
 
 # ---- basic Columns

visidata/ddwplay.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
 import json
 import time
-from visidata import colors, vd, clipdraw, ColorAttr
+from visidata import colors, vd, clipdraw, ColorAttr, dispwidth
 
 __all__ = ['Animation', 'AnimationMgr']
 
@@ -77,7 +77,7 @@ class Animation:
             self.total_ms = sum(f.duration_ms or 0 for f in self.frames.values())
             for f in self.frames.values():
                 for r, x, y, _ in self.iterdeep(f.rows):
-                    self.width = max(self.width, x+len(r.text))
+                    self.width = max(self.width, x+dispwidth(r.text))
                     self.height = max(self.height, y)
 
     def draw(self, scr, *, t=0, x=0, y=0, loop=False, attr=ColorAttr(), **kwargs):