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

visidata/experimental/gdrive.py

@@ -0,0 +1,89 @@
+import visidata
+from visidata import vd, VisiData, Sheet, IndexSheet, SequenceSheet, ColumnItem, Path, AttrDict, ColumnAttr, asyncthread, Progress, ColumnExpr, date
+
+from .gsheets import GSheetsIndex
+
+@VisiData.api
+def open_gdrive(vd, p):
+    return GDriveSheet(p.base_stem)
+
+
+FILES_FIELDS_VISIBLE='''name size modifiedTime mimeType description'''.split()
+
+FILES_FIELDS='''
+id name size modifiedTime mimeType description owners
+starred properties spaces version webContentLink webViewLink sharingUser lastModifyingUser shared
+ownedByMe originalFilename md5Checksum size quotaBytesUsed headRevisionId imageMediaMetadata videoMediaMetadata parents
+exportLinks contentRestrictions contentHints trashed
+'''.split()
+
+
+@VisiData.cached_property
+def _drivebuild(vd):
+    return vd.google_discovery.build("drive", "v3", credentials=vd.google_auth('drive.readonly'))
+
+@VisiData.cached_property
+def _gdrive(self):
+    return vd.google_discovery.build("drive", "v3", credentials=vd.google_auth('drive.readonly')).files()
+
+@VisiData.cached_property
+def _gdrive_rw(self):
+    return vd.google_discovery.build("drive", "v3", credentials=vd.google_auth('drive')).files()
+
+
+class GDriveSheet(Sheet):
+    rowtype='files'  # rowdef: AttrDict of result from Google Drive files.list API
+    defer=True
+    columns = [
+        ColumnItem('name'),
+        ColumnItem('size', type=int),
+        ColumnItem('modifiedTime', type=date),
+        ColumnItem('mimeType'),
+        ColumnItem('name'),
+        ColumnExpr('owner', expr='owners[0]["displayName"]')
+    ] + [
+        ColumnItem(x, width=0) for x in FILES_FIELDS if x not in FILES_FIELDS_VISIBLE
+    ]
+
+    def iterload(self):
+        self.results = []
+        page_token = None
+        while True:
+            ret = vd._gdrive.list(
+                    pageSize=1000,
+                    pageToken=page_token,
+                    fields="nextPageToken, files(%s)" % ','.join(FILES_FIELDS)
+                    ).execute()
+
+            self.results.append(ret)
+
+            for r in ret.get('files', []):
+                yield AttrDict(r)
+
+            page_token = ret.get('nextPageToken', None)
+            if not page_token:
+                break
+
+    def openRow(self, r):
+        if r.mimeType == 'application/vnd.google-apps.spreadsheet':
+            return GSheetsIndex(r.name, source=r.id)
+        if r.mimeType.startswith('image'):
+            return vd.launchBrowser(r.webViewLink)
+        return vd.openSource(r.webContentLink)
+
+    @asyncthread
+    def deleteFile(self, **kwargs):
+        with Progress(total=1) as prog:
+            vd._gdrive_rw.delete(**kwargs).execute()
+            prog.addProgress(1)
+
+    @asyncthread
+    def putChanges(self):
+        adds, mods, dels = self.getDeferredChanges()
+
+        for row in Progress(dels.values()):
+            self.deleteFile(fileId=row.id)
+
+        vd.sync()
+        self.preloadHook()
+        self.reload()

visidata/experimental/google.py

@@ -0,0 +1,37 @@
+'''
+# Using VisiData with Google Sheets and Google Drive
+
+## Setup and Authentication
+
+Add to .visidatarc:
+
+    import visidata.experimental.google
+
+When VisiData attempts to use the Google API, it uses the "web authentication flow", which causes a web page to open asking for permissions to read and/or write your Google Sheets.
+After granting permissions, VisiData caches the auth token in the .visidata directory.  Remove `.visidata/google-*.pickle` to unauthenticate.
+
+## Load a Google Sheet into VisiData
+
+Use VisiData to open the URL or spreadsheet id, with filetype `g` (or `gsheets`):
+
+    vd https://docs.google.com/spreadsheets/d/1WV0JI_SsGfmoocXWJILK2nhfcxU1H7roqL1HE7zBdsY/ -f g
+
+VisiData assumes the first row is the header row with column names.
+
+## Save one or more sheets in VisiData as a Google Sheet
+
+Save to `<sheetname>.g` using either `Ctrl+S` (current sheet only) or `g Ctrl+S` (all sheets on the sheet stack).
+<sheetname> will be the visible name of the Spreadsheet in Google Drive; each sheet tab within the Spreadsheet will be named according to the sheet name within VisiData.
+
+## List files in Google Drive
+
+Use the `gdrive` filetype (the path doesn't matter):
+
+    vd . -f gdrive
+
+- Files can be marked for deletion with `d` and execute those deletions with `z Ctrl+S` (same as on the DirSheet for the local filesystem).
+- Images can be viewed with `Enter` (in browser).
+'''
+
+import visidata.experimental.gdrive
+import visidata.experimental.gsheets

visidata/experimental/gsheets.py

@@ -0,0 +1,79 @@
+import re
+from visidata import vd, VisiData, Sheet, IndexSheet, SequenceSheet, ColumnItem, Path, AttrDict, ColumnAttr, asyncthread
+
+SPREADSHEET_FIELDS='properties sheets namedRanges spreadsheetUrl developerMetadata dataSources dataSourceSchedules'.split()
+SHEET_FIELDS='merges conditionalFormats filterViews protectedRanges basicFilter charts bandedRanges developerMetadata rowGroups columnGroups slicers'.split()
+
+@VisiData.api
+def open_gsheets(vd, p):
+    m = re.search(r'([A-z0-9_]{44})', p.given)
+    if m:
+        return GSheetsIndex(p.base_stem, source=m.groups()[0])
+
+vd.open_g = vd.open_gsheets
+
+@VisiData.lazy_property
+def google_discovery(self):
+    googleapiclient = vd.importExternal('googleapiclient', 'google-api-python-client')
+    from googleapiclient import discovery
+    return discovery
+
+
+@VisiData.cached_property
+def _gsheets(vd):
+    return vd.google_discovery.build("sheets", "v4", credentials=vd.google_auth('spreadsheets.readonly')).spreadsheets()
+
+
+@VisiData.cached_property
+def _gsheets_rw(vd):
+    return vd.google_discovery.build("sheets", "v4", credentials=vd.google_auth('spreadsheets')).spreadsheets()
+
+
+class GSheetsIndex(Sheet):
+    columns = [
+        ColumnAttr('title', 'properties.title'),
+        ColumnAttr('type', 'properties.sheetType', width=0),
+        ColumnAttr('nRows', 'properties.gridProperties.rowCount', type=int),
+        ColumnAttr('nCols', 'properties.gridProperties.columnCount', type=int),
+    ]
+    def iterload(self):
+        googlesheet = vd._gsheets.get(spreadsheetId=self.source, fields=','.join(SPREADSHEET_FIELDS)).execute()
+        vd.status(googlesheet['properties']['title'])
+
+        for gsheet in googlesheet['sheets']:
+            yield AttrDict(gsheet)
+
+    def openRow(self, r):
+        return GSheet(r.properties.title, source=self.source)
+
+
+class GSheet(SequenceSheet):
+    '.source is gsheet id; .name is sheet name'
+    def iterload(self):
+        result = vd._gsheets.values().get(spreadsheetId=self.source, range=self.name).execute()
+        yield from result.get('values', [])
+
+
+@VisiData.api
+def save_gsheets(vd, p, *sheets):
+    gsheet = vd._gsheets_rw.create(body={
+        'properties': { 'title': p.base_stem },
+        'sheets': list({'properties': { 'title': vs.name }} for vs in sheets),
+    }, fields='spreadsheetId').execute()
+
+    gsheetId = gsheet.get('spreadsheetId')
+    vd.status(f'https://docs.google.com/spreadsheets/d/{gsheetId}/')
+
+    for vs in sheets:
+        rows = [list(c.name for c in vs.visibleCols)]
+        rows += list(list(val for col, val in row.items())
+                        for row in vs.iterdispvals(*vs.visibleCols, format=True))
+
+        vd._gsheets_rw.values().append(
+            spreadsheetId=gsheetId,
+            valueInputOption='RAW',
+            range=vs.name,
+            body=dict(values=rows)
+        ).execute()
+
+vd.save_g = vd.save_gsheets

visidata/experimental/live_search.py

@@ -0,0 +1,37 @@
+from copy import copy
+
+from visidata import Sheet, vd, asyncsingle
+
+@Sheet.api
+def dup_search(sheet, cols='cursorCol'):
+    vs = copy(sheet)
+    vs.name += "_search"
+    vs.rows = sheet.rows
+    vs.source = sheet
+    vs.search = ''
+
+    @asyncsingle
+    def live_search_async(val, status=False):
+        if not val:
+            vs.rows = vs.source.rows
+        else:
+            vs.rows = []
+            for i in vd.searchRegex(vs.source, regex=val, columns=cols, printStatus=status):
+                vs.addRow(vs.source.rows[i])
+
+    def live_search(val):
+        vs.draw(vs._scr)
+        vd.drawRightStatus(vs._scr, vs)
+        val = val.rstrip('\n')
+        if val == vs.search:
+            return
+        vs.search = val
+        live_search_async(val, sheet=vs, status=False)
+
+    vd.input("search regex: ", updater=live_search)
+    vd.push(vs)
+    vs.name = vs.source.name+'_'+vs.search
+
+
+Sheet.addCommand('^[s', 'dup-search', 'dup_search("cursorCol")', 'search for regex forwards in current column, creating duplicate sheet with matching rows live')
+Sheet.addCommand('g^[s', 'dup-search-cols', 'dup_search("visibleCols")', 'search for regex forwards in all columns, creating duplicate sheet with matching rows live')

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
+''')