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

visidata/ddw/regex.ddw

@@ -0,0 +1,57 @@
+{"id": null, "type": null, "x": 5, "y": 1, "text": ".", "color": "keystrokes", "tags": [], "group": "", "frame": null, "rows": null, "duration_ms": null, "ref": null, "href": null}
+{"x": 5, "y": 2, "text": "^", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 5, "y": 3, "text": "$", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 38, "y": 1, "text": "*", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 38, "y": 2, "text": "+", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 38, "y": 3, "text": "?", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 34, "y": 5, "text": "{m,n}", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 8, "y": 1, "text": "any char except newline", "color": "", "tags": [], "group": ""}
+{"x": 8, "y": 2, "text": "start of string", "color": "", "tags": [], "group": ""}
+{"x": 8, "y": 3, "text": "end of string", "color": "", "tags": [], "group": ""}
+{"x": 42, "y": 1, "text": "0 or more", "color": "", "tags": [], "group": ""}
+{"x": 42, "y": 2, "text": "1 or more", "color": "", "tags": [], "group": ""}
+{"x": 42, "y": 3, "text": "0 or 1", "color": "", "tags": [], "group": ""}
+{"x": 42, "y": 5, "text": "between m and n", "color": "", "tags": [], "group": ""}
+{"x": 1, "y": 11, "text": "[abc]", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 0, "y": 12, "text": "[^abc]", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 4, "y": 4, "text": "\\d", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 4, "y": 6, "text": "\\s", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 4, "y": 8, "text": "\\w", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 8, "y": 4, "text": "digit char", "color": "", "tags": [], "group": ""}
+{"x": 8, "y": 6, "text": "whitespace char", "color": "", "tags": [], "group": ""}
+{"x": 4, "y": 10, "text": "\\b", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 8, "y": 10, "text": "word boundary", "color": "", "tags": [], "group": ""}
+{"x": 8, "y": 8, "text": "word char", "color": "", "tags": [], "group": ""}
+{"x": 18, "y": 8, "text": "[a-zA-Z0-9_]", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 36, "y": 7, "text": "(\u2026)", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 34, "y": 8, "text": "(?:\u2026)", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 8, "y": 11, "text": "any of", "color": "", "tags": [], "group": ""}
+{"x": 15, "y": 11, "text": "a", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 17, "y": 11, "text": "or", "color": "", "tags": [], "group": ""}
+{"x": 20, "y": 11, "text": "b", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 22, "y": 11, "text": "or", "color": "", "tags": [], "group": ""}
+{"x": 25, "y": 11, "text": "c", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 19, "y": 4, "text": "[0-9]", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 42, "y": 7, "text": "capturing group", "color": "", "tags": [], "group": ""}
+{"x": 42, "y": 8, "text": "non-capturing group", "color": "", "tags": [], "group": ""}
+{"x": 9, "y": 12, "text": "", "color": "", "tags": [], "group": ""}
+{"x": 8, "y": 12, "text": "not", "color": "", "tags": [], "group": ""}
+{"x": 12, "y": 12, "text": "a", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 14, "y": 12, "text": "or", "color": "", "tags": [], "group": ""}
+{"x": 17, "y": 12, "text": "b", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 19, "y": 12, "text": "or", "color": "", "tags": [], "group": ""}
+{"x": 22, "y": 12, "text": "c", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 38, "y": 10, "text": "|", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 42, "y": 10, "text": "logical OR", "color": "", "tags": [], "group": ""}
+{"x": 4, "y": 5, "text": "\\D", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 4, "y": 7, "text": "\\S", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 4, "y": 9, "text": "\\W", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 8, "y": 5, "text": "non-digit char", "color": "", "tags": [], "group": ""}
+{"x": 8, "y": 7, "text": "non-whitespace char", "color": "", "tags": [], "group": ""}
+{"x": 8, "y": 9, "text": "non-word char", "color": "", "tags": [], "group": ""}
+{"x": 36, "y": 4, "text": "{m}", "color": "keystrokes", "tags": [], "group": ""}
+{"x": 42, "y": 4, "text": "exactly m", "color": "", "tags": [], "group": ""}
+{"x": 4, "y": 0, "text": "Character classes", "color": "bold underline", "tags": [], "group": ""}
+{"x": 35, "y": 0, "text": "Repetition", "color": "bold underline", "tags": [], "group": ""}
+{"x": 2, "y": 14, "text": "For full documentation on Python regular expressions, see", "color": "", "tags": [], "group": ""}
+{"x": 6, "y": 15, "text": "https://docs.python.org/3/library/re.html", "color": "underline", "tags": [], "group": "", "href": "https://docs.python.org/3/library/re.html"}

visidata/ddwplay.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
 import json
 import time
-from visidata import colors, vd
+from visidata import colors, vd, clipdraw, ColorAttr
 
 __all__ = ['Animation', 'AnimationMgr']
 
@@ -31,24 +31,38 @@ class Animation:
         self.width = 0
         self.load_from(fp)
 
-    def iterdeep(self, rows, x=0, y=0, parents=None):
-        'Walk rows deeply and generate (row, x, y, [ancestors]) for each row.'
+    def iterdeep(self, rows, x=0, y=0, parents=None, **kwargs):
+        'Walk rows deeply and generate (row, x, y, [ancestors]) for each row, filtering on kwargs.'
         for r in rows:
             newparents = (parents or []) + [r]
             if r.type == 'frame': continue
             if r.ref:
                 assert r.type == 'ref'
                 g = self.groups[r.ref]
-                yield from self.iterdeep(map(AttrDict, g.rows or []), x+r.x, y+r.y, newparents)
+                if self.matches(r, kwargs):
+                    yield from self.iterdeep(map(AttrDict, g.rows or []), x+r.x, y+r.y, newparents)
             else:
-                yield r, x+r.x, y+r.y, newparents
-                yield from self.iterdeep(map(AttrDict, r.rows or []), x+r.x, x+r.y, newparents)
+                if self.matches(r, kwargs):
+                    yield r, x+r.x, y+r.y, newparents
+                    yield from self.iterdeep(map(AttrDict, r.rows or []), x+r.x, x+r.y, newparents)
+
+    def matches(self, row, values):
+        for k, v in values.items():
+            actualv = getattr(row, k, None)
+            if isinstance(actualv, (list, tuple)) and isinstance(v, (list, tuple)):
+                if not any(x in actualv for x in v):
+                    return False
+            elif v != actualv:
+                return False
+        return True
 
     def load_from(self, fp):
         for line in fp.readlines():
             r = AttrDict(json.loads(line))
             if r.type == 'frame':
-                self.frames[r.id].update(r)
+                f = self.frames[r.id]
+                f.update(r)
+                f.rows = []
             elif r.type == 'group':
                 self.groups[r.id].update(r)
 
@@ -66,9 +80,12 @@ class Animation:
                     self.width = max(self.width, x+len(r.text))
                     self.height = max(self.height, y)
 
-    def draw(self, scr, *, t=0, x=0, y=0, loop=False, **kwargs):
-        for r, dx, dy, _ in self.iterdeep(self.frames[''].rows):
-            scr.addstr(y+dy, x+dx, r.text, colors[r.color])
+    def draw(self, scr, *, t=0, x=0, y=0, loop=False, attr=ColorAttr(), **kwargs):
+        windowHeight, windowWidth = scr.getmaxyx()
+        for r, dx, dy, _ in self.iterdeep(self.frames[''].rows, **kwargs):
+            text = f'[:onclick {r.href}]{r.text}[/]' if r.href else r.text
+            if y+dy < windowHeight:
+                clipdraw(scr, y+dy, x+dx, text, attr.update(colors[r.color], 2))
 
         if not self.total_ms:
             return None
@@ -77,8 +94,10 @@ class Animation:
         for f in self.frames.values():
             ms -= int(f.duration_ms or 0)
             if ms < 0:
-                for r, dx, dy, _ in self.iterdeep(f.rows):
-                    scr.addstr(y+dy, x+dx, r.text, colors[r.color])
+                for r, dx, dy, _ in self.iterdeep(f.rows, **kwargs):
+                    text = f'[:onclick {r.href}]{r.text}[/]' if r.href else r.text
+                    if y+dy < windowHeight:
+                        clipdraw(scr, y+dy, x+dx, text, colors[r.color])
 
                 return -ms/1000
 
@@ -117,9 +136,9 @@ class AnimationMgr:
         for row in self.active:
             startt, anim, akwargs = row
             kwargs.update(akwargs)
-            nextt = anim.draw(scr, t=t-startt, **kwargs)
+            nextt = anim.draw(scr, t=t+startt, **kwargs)
             if nextt is None:
-                if not akwargs.get('loop'):
+                if not akwargs.get('loop', True):
                     done.append(row)
             else:
                 times.append(t+nextt)

visidata/deprecated.py

@@ -73,7 +73,7 @@ visidata.Sheet.exec_command = deprecated('2.0')(visidata.Sheet.execCommand)
 @VisiData.api
 def filetype(vd, ext, constructor):
     'Add constructor to handle the given file type/extension.'
-    globals().setdefault('open_'+ext, lambda p,ext=ext: constructor(p.name, source=p, filetype=ext))
+    globals().setdefault('open_'+ext, lambda p,ext=ext: constructor(p.base_stem, source=p, filetype=ext))
 
 @deprecated('2.0', 'Sheet(namepart1, namepart2, ...)')
 @VisiData.global_api
@@ -135,11 +135,12 @@ alias('show-aggregate', 'memo-aggregate')
 
 # 2.6
 
-clean_name = visidata.cleanName
+def clean_name(s):
+    return visidata.vd.cleanName(s)
 
 def maybe_clean(s, vs):
     if (vs or visidata.vd).options.clean_names:
-        s = visidata.cleanName(s)
+        s = visidata.vd.cleanName(s)
     return s
 
 def load_tsv(fn):
@@ -164,3 +165,76 @@ exceptionCaught = deprecated('2.6', 'vd.exceptionCaught')(vd.exceptionCaught)
 openSource = deprecated('2.6', 'vd.openSource')(vd.openSource)
 globalCommand = visidata.BaseSheet.addCommand
 visidata.Sheet.StaticColumn = deprecated('2.11', 'Sheet.freeze_col')(visidata.Sheet.freeze_col)
+visidata.Path.open_text = deprecated('3.0', 'visidata.Path.open')(visidata.Path.open)
+
+vd.sysclip_value = deprecated('3.0', 'vd.sysclipValue')(vd.sysclipValue)
+
+def itemsetter(i):
+    def g(obj, v):
+        obj[i] = v
+    return g
+
+
+vd.optalias('force_valid_colnames', 'clean_names')
+vd.optalias('dir_recurse', 'dir_depth', 100000)
+vd.optalias('confirm_overwrite', 'overwrite', 'confirm')
+vd.optalias('show_graph_labels', 'disp_graph_labels')
+vd.optalias('zoom_incr', 'disp_zoom_incr')
+
+alias('visibility-sheet', 'toggle-multiline')
+alias('visibility-col', 'toggle-multiline')
+
+def clean_to_id(s):
+    return visidata.vd.cleanName(s)
+
+@deprecated('3.0', 'use try/finally')
+class OnExit:
+    '"with OnExit(func, ...):" calls func(...) when the context is exited'
+    def __init__(self, func, *args, **kwargs):
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        try:
+            self.func(*self.args, **self.kwargs)
+        except Exception as e:
+            vd.exceptionCaught(e)
+
+alias('open-inputs', 'open-input-history')
+
+#vd.option('plugins_url', 'https://visidata.org/plugins/plugins.jsonl', 'source of plugins sheet')
+
+@visidata.VisiData.api
+def inputRegexSubstOld(vd, prompt):
+    'Input regex transform via oneliner (separated with `/`).  Return parsed transformer as dict(before=, after=).'
+    rex = vd.inputRegex(prompt, type='regex-subst')
+    before, after = vd.parse_sed_transform(rex)
+    return dict(before=before, after=after)
+
+
+visidata.Sheet.addCommand('', 'addcol-subst', 'addColumnAtCursor(Column(cursorCol.name + "_re", getter=regexTransform(cursorCol, **inputRegexSubstOld("transform column by regex: "))))', 'add column derived from current column, replacing regex with subst (may include \1 backrefs)', deprecated=True)
+visidata.Sheet.addCommand('', 'setcol-subst', 'setValuesFromRegex([cursorCol], someSelectedRows, **inputRegexSubstOld("transform column by regex: "))', 'regex/subst - modify selected rows in current column, replacing regex with subst, (may include backreferences \\1 etc)', deprecated=True)
+visidata.Sheet.addCommand('', 'setcol-subst-all', 'setValuesFromRegex(visibleCols, someSelectedRows, **inputRegexSubstOld(f"transform {nVisibleCols} columns by regex: "))', 'modify selected rows in all visible columns, replacing regex with subst (may include \\1 backrefs)', deprecated=True)
+
+visidata.Sheet.addCommand('', 'split-col', 'addRegexColumns(makeRegexSplitter, cursorCol, inputRegex("split regex: ", type="regex-split"))', 'Add new columns from regex split', deprecated=True)
+visidata.Sheet.addCommand('', 'capture-col', 'addRegexColumns(makeRegexMatcher, cursorCol, inputRegex("capture regex: ", type="regex-capture"))', 'add new column from capture groups of regex; requires example row', deprecated=True)
+
+#vd.option('cmdlog_histfile', '', 'file to autorecord each cmdlog action to', sheettype=None)
+#BaseSheet.bindkey('KEY_BACKSPACE', 'menu-help')
+
+@deprecated('3.0', 'vd.callNoExceptions(col.setValue, row, value)')
+@visidata.Column.api
+def setValueSafe(self, row, value):
+    'setValue and ignore exceptions.'
+    return vd.callNoExceptions(self.setValue, row, value)
+
+@deprecated('3.0', 'vd.callNoExceptions(sheet.checkCursor)')
+@visidata.BaseSheet.api
+def checkCursorNoExceptions(sheet):
+    return vd.callNoExceptions(sheet.checkCursor)
+
+vd.addGlobals(globals())

visidata/desktop/visidata.desktop

@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Application
+Terminal=true
+Name=VisiData
+Icon=utilities-terminal
+Exec=bash -i -c 'vd %f'
+Categories=Application;

visidata/editor.py

@@ -12,14 +12,16 @@ visidata.vd.tstp_signal = None
 class SuspendCurses:
     'Context manager to leave windowed mode on enter and restore it on exit.'
     def __enter__(self):
-        curses.endwin()
+        if visidata.vd.scrFull:
+            curses.endwin()
         if visidata.vd.tstp_signal:
             signal.signal(signal.SIGTSTP, visidata.vd.tstp_signal)
 
     def __exit__(self, exc_type, exc_val, tb):
-        curses.reset_prog_mode()
-        visidata.vd.scrFull.refresh()
-        curses.doupdate()
+        if visidata.vd.scrFull:
+            curses.reset_prog_mode()
+            visidata.vd.scrFull.refresh()
+            curses.doupdate()
 
 
 @visidata.VisiData.api
@@ -34,7 +36,7 @@ def launchEditor(vd, *args):
 @visidata.VisiData.api
 def launchBrowser(vd, *args):
     'Launch $BROWSER with *args* as arguments.'
-    browser = os.environ.get('BROWSER') or vd.fail('(no $BROWSER) for %s' % args[0])
+    browser = os.environ.get('BROWSER') or vd.fail('no $BROWSER for %s' % args[0])
     args = [browser] + list(args)
     subprocess.call(args)
 
@@ -44,6 +46,7 @@ def launchExternalEditor(vd, v, linenum=0):
     'Launch $EDITOR to edit string *v* starting on line *linenum*.'
     import tempfile
     with tempfile.NamedTemporaryFile() as temp:
+        temp.close()  #2118 must close before re-opening on windows
         with open(temp.name, 'w') as fp:
             fp.write(v)
         return vd.launchExternalEditorPath(visidata.Path(temp.name), linenum)
@@ -65,7 +68,8 @@ def launchExternalEditorPath(vd, path, linenum=0):
                 return ''
 
 
-def suspend():
+@visidata.VisiData.api
+def suspend(vd):
     import signal
     with SuspendCurses():
         os.kill(os.getpid(), signal.SIGSTOP)
@@ -94,3 +98,5 @@ sys.breakpointhook = _breakpoint
 
 visidata.BaseSheet.addCommand('^Z', 'suspend', 'suspend()', 'suspend VisiData process')
 visidata.BaseSheet.addCommand('', 'breakpoint', 'breakpoint()', 'drop into pdb REPL')
+
+visidata.vd.addGlobals(SuspendCurses=SuspendCurses)

visidata/errors.py

@@ -1,8 +1,9 @@
 import traceback
 
-from visidata import vd, VisiData, options
+from visidata import vd, VisiData
+
+vd.option('debug', False, 'exit on error and display stacktrace', max_help=0)
 
-__all__ = ['stacktrace', 'ExpectedException']
 
 class ExpectedException(Exception):
     'Controlled Exception from fail() or confirm().  Status or other interface update is done by raiser.'
@@ -28,4 +29,7 @@ def exceptionCaught(vd, exc=None, status=True, **kwargs):
     if vd.options.debug:
         raise
 
+
+vd.addGlobals(stacktrace=stacktrace, ExpectedException=ExpectedException)
+
 # see textsheet.py for ErrorSheet and associated commands

visidata/experimental/diff_sheet.py

@@ -0,0 +1,29 @@
+# command setdiff-sheet adds a diff colorizer for all sheets against current sheet
+
+from visidata import Sheet, CellColorizer, vd
+
+vd.theme_option('color_diff', 'red', 'color of values different from --diff source')
+vd.theme_option('color_diff_add', 'yellow', 'color of rows/columns added to --diff source')
+
+
+def makeDiffColorizer(othersheet):
+    def colorizeDiffs(sheet, col, row, cellval):
+        if row is None or col is None:
+            return None
+        vcolidx = sheet.visibleCols.index(col)
+        rowidx = sheet.rows.index(row)
+        if vcolidx < len(othersheet.visibleCols) and rowidx < len(othersheet.rows):
+            otherval = othersheet.visibleCols[vcolidx].getDisplayValue(othersheet.rows[rowidx])
+            if cellval.display != otherval:
+                return 'color_diff'
+        else:
+            return 'color_diff_add'
+    return colorizeDiffs
+
+
+@Sheet.api
+def setDiffSheet(vs):
+    Sheet.colorizers.append(CellColorizer(8, None, makeDiffColorizer(vs)))
+
+
+Sheet.addCommand(None, 'setdiff-sheet', 'setDiffSheet()', 'set this sheet as diff sheet for all new sheets')

visidata/experimental/digit_autoedit.py

@@ -0,0 +1,6 @@
+'Enter edit mode automatically when typing numeric digits.'
+
+from visidata import Sheet
+
+for i in range(0, 10):
+    Sheet.addCommand(str(i), 'autoedit-%s' % i, 'cursorCol.setValues([cursorRow], editCell(cursorVisibleColIndex, value="%s", i=1))' % i, 'replace cell value with input starting with %s' % i)

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