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

visidata/clean_names.py

@@ -0,0 +1,29 @@
+import re
+from visidata import vd, VisiData, Sheet
+
+
+vd.option('clean_names', False, 'clean column/sheet names to be valid Python identifiers', replay=True)
+
+
+@VisiData.global_api
+def cleanName(vd, s):
+    #[Nas Banov] https://stackoverflow.com/a/3305731
+    #    return re.sub(r'\W|^(?=\d)', '_', str(s)).strip('_')
+    s = re.sub(r'[^\w\d_]', '_', s)  # replace non-alphanum chars with _
+    s = re.sub(r'_+', '_', s)  # replace runs of _ with a single _
+    s = s.strip('_')
+    return s
+
+
+@Sheet.api
+def maybeClean(sheet, s):
+    if sheet.options.clean_names:
+        s = vd.cleanName(s)
+    return s
+
+
+Sheet.addCommand('', 'clean-names', '''
+options.clean_names = True;
+for c in visibleCols:
+    c.name = cleanName(c.name)
+''', 'set options.clean_names on sheet and clean visible column names')

visidata/clipboard.py

@@ -5,19 +5,24 @@ import io
 import sys
 import tempfile
 import functools
+import os
 
-from visidata import VisiData, vd, asyncthread
-from visidata import Sheet, Path
+from visidata import VisiData, vd, asyncthread, SettableColumn
+from visidata import Sheet, Path, Column
 
 if sys.platform == 'win32':
-    syscopy_cmd_default = 'clip'
-    syspaste_cmd_default = 'clip'
+    syscopy_cmd_default = 'clip.exe'
+    syspaste_cmd_default = 'powershell -command Get-Clipboard'
 elif sys.platform == 'darwin':
     syscopy_cmd_default = 'pbcopy w'
     syspaste_cmd_default = 'pbpaste'
 else:
-    syscopy_cmd_default = 'xclip -selection clipboard -filter'  # xsel --clipboard --input
-    syspaste_cmd_default = 'xclip -selection clipboard -o'  # xsel --clipboard
+    if 'WAYLAND_DISPLAY' in os.environ:
+        syscopy_cmd_default = 'wl-copy'
+        syspaste_cmd_default = 'wl-paste'
+    else:
+        syscopy_cmd_default = 'xclip -selection clipboard -filter'  # xsel --clipboard --input
+        syspaste_cmd_default = 'xclip -selection clipboard -o'  # xsel --clipboard
 
 vd.option('clipboard_copy_cmd', syscopy_cmd_default, 'command to copy stdin to system clipboard', sheettype=None)
 vd.option('clipboard_paste_cmd', syspaste_cmd_default, 'command to send contents of system clipboard to stdout', sheettype=None)
@@ -48,7 +53,7 @@ def syscopyValue(sheet, val):
     p = subprocess.run(
         sheet.options.clipboard_copy_cmd.split(),
         input=val,
-        encoding=sheet.options.encoding,
+        encoding='utf-8',
         stdout=subprocess.DEVNULL)
 
     vd.status('copied value to system clipboard')
@@ -70,16 +75,19 @@ def syscopyCells_async(sheet, cols, rows, filetype):
     vd.status(f'copying {vs.nRows} {vs.rowtype} to system clipboard as {filetype}')
 
     with io.StringIO() as buf:
-        vd.sync(vd.saveSheets(Path(sheet.name+'.'+filetype, fptext=buf), vs))
-        subprocess.run(
-            sheet.options.clipboard_copy_cmd.split(),
-            input=buf.getvalue(),
-            encoding=sheet.options.encoding,
-            stdout=subprocess.DEVNULL)
+        with tempfile.NamedTemporaryFile() as temp:
+            temp.close()  #2118
+
+            vd.sync(vd.saveSheets(Path(f'{temp.name}.{filetype}', fptext=buf), vs, confirm_overwrite=False))
+            subprocess.run(
+                sheet.options.clipboard_copy_cmd.split(),
+                input=buf.getvalue(),
+                encoding='utf-8',
+                stdout=subprocess.DEVNULL)
 
 
 @VisiData.api
-def sysclip_value(vd):
+def sysclipValue(vd):
     cmd = vd.options.clipboard_paste_cmd
     return subprocess.check_output(vd.options.clipboard_paste_cmd.split()).decode('utf-8')
 
@@ -87,17 +95,29 @@ def sysclip_value(vd):
 @VisiData.api
 @asyncthread
 def pasteFromClipboard(vd, cols, rows):
-    text = vd.getLastArgs() or vd.sysclip_value().strip() or vd.fail('system clipboard is empty')
+    text = vd.getLastArgs() or vd.sysclipValue().strip() or vd.fail('system clipboard is empty')
 
     vd.addUndoSetValues(cols, rows)
+    lines = text.split('\n')
+    if not lines:
+        vd.warning('nothing to paste')
+        return
 
-    for line, r in zip(text.split('\n'), rows):
+    vs = cols[0].sheet
+    newrows = [vs.newRow() for i in range(len(lines)-len(rows))]
+    if newrows:
+        rows.extend(newrows)
+        vs.addRows(newrows)
+
+    for line, r in zip(lines, rows):
         for v, c in zip(line.split('\t'), cols):
             c.setValue(r, v)
 
 
 @Sheet.api
 def delete_row(sheet, rowidx):
+    if not sheet.rows:
+        vd.fail("no row to delete")
     if not sheet.defer:
         oldrow = sheet.rows.pop(rowidx)
         vd.addUndo(sheet.rows.insert, rowidx, oldrow)
@@ -112,11 +132,33 @@ def delete_row(sheet, rowidx):
     sheet.setModified()
     return oldrow
 
+
 @Sheet.api
+@asyncthread
 def paste_after(sheet, rowidx):
-    to_paste = list(deepcopy(r) for r in reversed(vd.memory.cliprows))
-    sheet.addRows(to_paste, index=rowidx)
+    'Paste rows from *vd.cliprows* at *rowidx*.'
+    if not vd.memory.cliprows:  #1793
+        vd.warning('nothing to paste')
+        return
+
+    for col in vd.memory.clipcols[sheet.nVisibleCols:]:
+        newcol = SettableColumn()
+        newcol.__setstate__(col.__getstate__())
+        sheet.addColumn(newcol)
+
+    addedRows = []
 
+    for extrow in vd.memory.cliprows:
+        if isinstance(extrow, Column):
+            newrow = copy(extrow)
+        else:
+            newrow = sheet.newRow()
+            for col, extcol in zip(sheet.visibleCols, vd.memory.clipcols):
+                col.setValue(newrow, extcol.getTypedValue(extrow))
+
+        addedRows.append(newrow)
+
+    sheet.addRows(addedRows, index=rowidx)
 
 
 Sheet.addCommand('y', 'copy-row', 'copyRows([cursorRow])', 'yank (copy) current row to clipboard')
@@ -157,3 +199,27 @@ Sheet.addCommand('gzx', 'cut-cells', 'copyCells(cursorCol, onlySelectedRows); cu
 
 Sheet.bindkey('KEY_DC', 'delete-cell'),
 Sheet.bindkey('gKEY_DC', 'delete-cells'),
+
+vd.addMenuItems('''
+    Edit > Delete > current row > delete-row
+    Edit > Delete > current cell > delete-cell
+    Edit > Delete > selected rows > delete-selected
+    Edit > Delete > selected cells > delete-cells
+    Edit > Copy > current cell > copy-cell
+    Edit > Copy > current row > copy-row
+    Edit > Copy > selected cells > copy-cells
+    Edit > Copy > selected rows > copy-selected
+    Edit > Copy > to system clipboard > current cell > syscopy-cell
+    Edit > Copy > to system clipboard > current row > syscopy-row
+    Edit > Copy > to system clipboard > selected cells > syscopy-cells
+    Edit > Copy > to system clipboard > selected rows > syscopy-selected
+    Edit > Cut > current row > cut-row
+    Edit > Cut > selected cells > cut-selected
+    Edit > Cut > current cell > cut-cell
+    Edit > Paste > row after > paste-after
+    Edit > Paste > row before > paste-before
+    Edit > Paste > into selected cells > setcol-clipboard
+    Edit > Paste > into current cell > paste-cell
+    Edit > Paste > from system clipboard > cells at cursor > syspaste-cells
+    Edit > Paste > from system clipboard > selected cells > syspaste-cells-selected
+''')

visidata/cliptext.py

@@ -1,12 +1,13 @@
 import unicodedata
 import sys
+import re
 import functools
+import textwrap
 
-from visidata import options, drawcache
-
-__all__ = ['clipstr', 'clipdraw', 'clipbox', 'dispwidth', 'iterchars']
+from visidata import options, drawcache, vd, update_attr, colors, ColorAttr
 
 disp_column_fill = ' '
+internal_markup_re = r'(\[[:/][^\]]*?\])'  # [:whatever until the closing bracket] or [/whatever] or [:]
 
 ### Curses helpers
 
@@ -52,16 +53,56 @@ def wcwidth(cc, ambig=1):
         return 0
 
 
+def is_vdcode(s:str) -> bool:
+    return (s.startswith('[:') and s.endswith(']')) or \
+           (s.startswith('[/') and s.endswith(']'))
+
+
+def iterchunks(s, literal=False):
+    attrstack = [dict(link='', cattr=ColorAttr())]
+    legitopens = 0
+    chunks = re.split(internal_markup_re, s)
+    for chunk in chunks:
+        if not chunk:
+            continue
+
+        if not literal and is_vdcode(chunk):
+            cattr = attrstack[-1]['cattr']
+            link = attrstack[-1]['link']
+
+            if chunk.startswith('[:onclick '):
+                attrstack.append(dict(link=chunk[10:-1], cattr=cattr.update(colors.clickable)))
+                continue
+            elif chunk == '[:]':  # clear stack, keep origattr
+                if len(attrstack) > 1:
+                    del attrstack[1:]
+                    continue
+            elif chunk.startswith('[/'):  # pop last attr off stack
+                if len(attrstack) > 1:
+                    attrstack.pop()
+                continue  # don't display trailing [/foo] ever
+            else:  # push updated color on stack
+                newcolor = colors.get_color(chunk[2:-1])
+                if newcolor:
+                    cattr = update_attr(cattr, newcolor, len(attrstack))
+                    attrstack.append(dict(link=link, cattr=cattr))
+                    continue
+
+        yield attrstack[-1], chunk
+
+
 @functools.lru_cache(maxsize=100000)
-def dispwidth(ss, maxwidth=None):
+def dispwidth(ss, maxwidth=None, literal=False):
     'Return display width of string, according to unicodedata width and options.disp_ambig_width.'
     disp_ambig_width = options.disp_ambig_width
     w = 0
 
-    for cc in ss:
-        w += wcwidth(cc, disp_ambig_width)
-        if maxwidth and w > maxwidth:
-            break
+    for _, s in iterchunks(ss, literal=literal):
+        for cc in s:
+            if cc:
+                w += wcwidth(cc, disp_ambig_width)
+                if maxwidth and w > maxwidth:
+                    return maxwidth
     return w
 
 
@@ -76,7 +117,7 @@ def _dispch(c, oddspacech=None, combch=None, modch=None):
     elif c in ZERO_WIDTH_CF:
         return combch, 1
 
-    return c, dispwidth(c)
+    return c, dispwidth(c, literal=True)
 
 
 def iterchars(x):
@@ -103,24 +144,35 @@ def iterchars(x):
 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:
+        return '', 0
+
+    if dispw == 1:
+        return s[0], 1
+
     w = 0
     ret = ''
 
     trunchlen = dispwidth(trunch)
     for c in s:
         newc, chlen = _dispch(c, oddspacech=oddspacech, combch=combch, modch=modch)
-        if newc:
-            ret += newc
-            w += chlen
-        else:
-            ret += c
-            w += dispwidth(c)
-
-        if dispw and w > dispw-trunchlen+1:
-            ret = ret[:-2] + trunch # replace final char with ellipsis
-            w += trunchlen
+        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
+
     return ret, w
 
 
@@ -139,38 +191,149 @@ def clipstr(s, dispw, truncator=None, oddspace=None):
                 modch='',
                 combch='')
 
-def clipdraw(scr, y, x, s, attr, w=None, clear=True, rtl=False, **kwargs):
-    'Draw string `s` at (y,x)-(y,x+w) with curses attr, clipping with ellipsis char.  if rtl, draw inside (x-w, x).  If *clear*, clear whole editing area before displaying. Returns width drawn (max of w).'
+
+def clipdraw(scr, y, x, s, attr, w=None, clear=True, literal=False, **kwargs):
+    '''Draw `s`  at (y,x)-(y,x+w) with curses `attr`, clipping with ellipsis char.
+       If `clear`, clear whole editing area before displaying.
+       If `literal`, do not interpret internal color code markup.
+       Return width drawn (max of w).
+    '''
+    if not literal:
+        chunks = iterchunks(s, literal=literal)
+    else:
+        chunks = [(dict(link='', cattr=ColorAttr()), s)]
+
+    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)
+
+
+def clipdraw_chunks(scr, y, x, chunks, cattr:ColorAttr=ColorAttr(), w=None, clear=True, literal=False, **kwargs):
+    '''Draw `chunks` (sequence of (color:str, text:str) as from iterchunks) at (y,x)-(y,x+w) with curses `attr`, clipping with ellipsis char.
+       If `clear`, clear whole editing area before displaying.
+       Return width drawn (max of w).
+    '''
     if scr:
-        _, windowWidth = scr.getmaxyx()
+        windowHeight, windowWidth = scr.getmaxyx()
     else:
-        windowWidth = 80
-    dispw = 0
+        windowHeight, windowWidth = 25, 80
+    totaldispw = 0
+
+    assert isinstance(cattr, ColorAttr), cattr
+    origattr = cattr
+    origw = w
+    clipped = ''
+    link = ''
+
+    if w and clear:
+        actualw = min(w, windowWidth-x-1)
+        if scr:
+            scr.addstr(y, x, disp_column_fill*actualw, cattr.attr)  # clear whole area before displaying
+
     try:
-        if w is None:
-            w = dispwidth(s, maxwidth=windowWidth)
-        w = min(w, (x-1) if rtl else (windowWidth-x-1))
-        if w <= 0:  # no room anyway
-            return 0
-        if not scr:
-            return w
-
-        # convert to string just before drawing
-        clipped, dispw = clipstr(s, w, **kwargs)
-        if rtl:
-            # clearing whole area (w) has negative display effects; clearing just dispw area is useless
-#            scr.addstr(y, x-dispw-1, disp_column_fill*dispw, attr)
-            scr.addstr(y, x-dispw-1, clipped, attr)
-        else:
-            if clear:
-                scr.addstr(y, x, disp_column_fill*w, attr)  # clear whole area before displaying
-            scr.addstr(y, x, clipped, attr)
+        for colorstate, chunk in chunks:
+            if isinstance(colorstate, str):
+                cattr = cattr.update(colors.get_color(colorstate))
+            else:
+                cattr = origattr.update(colorstate['cattr'])
+                link = colorstate['link']
+
+            if not chunk:
+                continue
+
+            if origw is None:
+                chunkw = dispwidth(chunk, maxwidth=windowWidth-totaldispw)
+            else:
+                chunkw = origw-totaldispw
+
+            chunkw = min(chunkw, windowWidth-x-1)
+            if chunkw <= 0:  # no room anyway
+                return totaldispw
+            if not scr:
+                return totaldispw
+
+            # convert to string just before drawing
+            clipped, dispw = clipstr(chunk, chunkw, **kwargs)
+
+            if y >= 0 and y < windowHeight:
+                scr.addstr(y, x, clipped, cattr.attr)
+            else:
+                if vd.options.debug:
+                    raise Exception(f'addstr(y={y} x={x}) out of bounds')
+
+            if link:
+                vd.onMouse(scr, x, y, dispw, 1, BUTTON1_RELEASED=link)
+
+            x += dispw
+            totaldispw += dispw
+
+            if chunkw < dispw:
+                break
     except Exception as e:
-        pass
-#        raise type(e)('%s [clip_draw y=%s x=%s dispw=%s w=%s clippedlen=%s]' % (e, y, x, dispw, w, len(clipped))
+        if vd.options.debug:
+            raise
+#        raise type(e)('%s [clip_draw y=%s x=%s dispw=%s w=%s clippedlen=%s]' % (e, y, x, totaldispw, w, len(clipped))
 #                ).with_traceback(sys.exc_info()[2])
 
-    return dispw
+    return totaldispw
+
+
+def _markdown_to_internal(text):
+    'Return markdown-formatted `text` converted to internal formatting (like `[:color]text[/]`).'
+    text = re.sub(r'`(.*?)`', r'[:code]\1[/]', text)
+    text = re.sub(r'(^#.*?)$', r'[:heading]\1[/]', text)
+    text = re.sub(r'\*\*(.*?)\*\*', r'[:bold]\1[/]', text)
+    text = re.sub(r'\*(.*?)\*', r'[:italic]\1[/]', text)
+    text = re.sub(r'\b_(.*?)_\b', r'[:underline]\1[/]', text)
+    return text
+
+
+def wraptext(text, width=80, indent=''):
+    '''
+    Word-wrap `text` and yield (formatted_line, textonly_line) for each line of at most `width` characters.
+    Formatting like `[:color]text[/]` is ignored for purposes of computing width, and not included in `textonly_line`.
+    '''
+    import re
+
+    if width <= 0:
+        return
+
+    for line in text.splitlines():
+        if not line:
+            yield '', ''
+            continue
+
+        line = _markdown_to_internal(line)
+        chunks = re.split(internal_markup_re, line)
+        textchunks = [x for x in chunks if not is_vdcode(x)]
+        for linenum, textline in enumerate(textwrap.wrap(''.join(textchunks), width=width, drop_whitespace=False)):
+            txt = textline
+            r = ''
+            while chunks:
+                c = chunks[0]
+                if len(c) > len(txt):
+                    r += txt
+                    chunks[0] = c[len(txt):]
+                    break
+
+                if len(chunks) == 1:
+                    r += chunks.pop(0)
+                else:
+                    chunks.pop(0)
+                    r += txt[:len(c)] + chunks.pop(0)
+
+                txt = txt[len(c):]
+
+            r = r.strip()
+            if linenum > 0:
+                r = indent + r
+            yield r, textline
+
+        for c in chunks:
+            yield c, ''
 
 
 def clipbox(scr, lines, attr, title=''):
@@ -178,6 +341,17 @@ def clipbox(scr, lines, attr, title=''):
     scr.bkgd(attr)
     scr.box()
     h, w = scr.getmaxyx()
-    clipdraw(scr, 0, w-len(title)-6, f"| {title} |", attr)
     for i, line in enumerate(lines):
         clipdraw(scr, i+1, 2, line, attr)
+
+    clipdraw(scr, 0, w-len(title)-6, f"| {title} |", attr)
+
+
+vd.addGlobals(clipstr=clipstr,
+              clipdraw=clipdraw,
+              clipdraw_chunks=clipdraw_chunks,
+              clipbox=clipbox,
+              dispwidth=dispwidth,
+              iterchars=iterchars,
+              iterchunks=iterchunks,
+              wraptext=wraptext)