visidata 3.0.2__py3-none-any.whl → 3.1__py3-none-any.whl

visidata/loaders/msgpack.py

@@ -0,0 +1,19 @@
+from visidata import vd, VisiData, JsonSheet
+
+
+@VisiData.api
+def open_msgpack(vd, p):
+    return MsgpackSheet(p.name, source=p)
+
+
+VisiData.open_msgpackz = VisiData.open_msgpack
+
+
+class MsgpackSheet(JsonSheet):
+    def iterload(self):
+        msgpack = vd.importModule('msgpack')
+        data = self.source.read_bytes()
+        if self.options.filetype == 'msgpackz':
+            brotli = vd.importModule('brotli')
+            data = brotli.decompress(data)
+        yield from msgpack.unpackb(data, raw=False)

visidata/loaders/npy.py

@@ -73,7 +73,6 @@ def save_npy(vd, p, sheet):
             dt = 'datetime64[s]'
         elif col.type in vd.numericTypes:
             dt = 'f8'
-
         else: #  if col.type in (str, anytype):
             width = col.getMaxWidth(sheet.rows)
             dt = 'U'+str(width)

visidata/loaders/odf.py

@@ -45,9 +45,11 @@ class OdsSheet(SequenceSheet):
         text_s = S().qname
 
         cell_names = [odf.table.CoveredTableCell().qname, odf.table.TableCell().qname]
+        empty_rows = 0
         for odsrow in self.source.getElementsByType(odf.table.TableRow):
             row = []
 
+            empty_cells = 0
             for cell in odsrow.childNodes:
                 if cell.qname not in cell_names: continue
                 value = ''
@@ -66,8 +68,20 @@ class OdsSheet(SequenceSheet):
                     else:
                         value = str(cell)
 
-                for _ in range(int(cell.attributes.get((TABLENS, "number-columns-repeated"), 1))):
-                    row.append(value)
+                column_repeat = int(cell.attributes.get((TABLENS, "number-columns-repeated"), 1))
+                if value is None:
+                    empty_cells += column_repeat
+                else:
+                    row.extend([""] * empty_cells)
+                    empty_cells = 0
+                    row.extend([value]*column_repeat)
 
-            for _ in range(int(odsrow.attributes.get((TABLENS, "number-rows-repeated"), 1))):
-                yield list(row)
+            row_repeat = int(odsrow.attributes.get((TABLENS, "number-rows-repeated"), 1))
+            if len(row) == 0:
+                empty_rows += row_repeat
+            else:
+                for i in range(empty_rows):
+                    yield []
+                empty_rows = 0
+                for i in range(row_repeat):
+                    yield list(row)

visidata/loaders/orgmode.py

@@ -282,7 +282,7 @@ A list of orgmode sections from _{sheet.source}_.
         for r, _ in mods.values():
             saveset[_root(r).path] = _root(r)
 
-        for row in addset.values():
+        for row in saveset.values():
             self.save(row)
 
         self.commitAdds()

visidata/loaders/rec.py

@@ -128,14 +128,16 @@ def save_rec(vd, p, *vsheets):
             comments = getattr(vs, 'comments', [])
             if comments:
                 fp.write('# ' + '\n# '.join(comments) + '\n')
-            fp.write('%rec: ' + vs.name + '\n')
-            fp.write('\n')
+            fp.write(f'%rec: {vs.name}\n')
             for col in vs.visibleCols:
                 if col.keycol:
-                    fp.write('%key: ' + col.name + '\n')
+                    fp.write(f'%key: {col.name}\n')
             for row in Progress(vs.rows):
                 for col in vs.visibleCols:
-                    fp.write(col.name+': '+encode_multiline(col.getDisplayValue(row))+'\n')
+                    cell = col.getCell(row)
+                    if cell.value is not None:
+                        val = encode_multiline(cell.text)
+                        fp.write(f'{col.name}: {val}\n')
 
                 fp.write('\n')
             fp.write('\n')

visidata/loaders/sas.py

@@ -18,14 +18,21 @@ def open_sas7bdat(vd, p):
 class XptSheet(Sheet):
     def iterload(self):
         xport = vd.importExternal('xport')
+        xport.v56 = vd.importExternal('xport.v56', 'xport>=3')
         with open(self.source, 'rb') as fp:
-            self.rdr = xport.Reader(fp)
+            self.library = xport.v56.load(fp)
 
             self.columns = []
-            for i, var in enumerate(self.rdr._variables):
-                self.addColumn(ColumnItem(var.name, i, type=float if var.numeric else str))
+            dataset = self.library[list(self.library.keys())[0]]
 
-            yield from self.rdr
+            varnames = dataset.contents.Variable.values
+            types = dataset.contents.Type.values
+
+            for i, (varname, typestr) in enumerate(zip(varnames, types)):
+                self.addColumn(ColumnItem(varname, i, type=float if typestr == 'Numeric' else str))
+
+            for row in dataset.values:
+                yield list(row)
 
 
 class SasSheet(Sheet):

visidata/loaders/scrape.py

@@ -180,7 +180,6 @@ vd.addGlobals({
     'HtmlDocsSheet':SelectorColumn,
     'SelectorColumn':SelectorColumn,
     'DocsSelectorColumn':DocsSelectorColumn,
-    'soupstr':soupstr
 })
 
 vd.addMenuItem('Data', '+Scrape', 'selected cells', 'scrape-cells')

visidata/loaders/texttables.py

@@ -18,3 +18,5 @@ try:
             setattr(vd, 'save_'+fmt, save_table)
 except ModuleNotFoundError:
     pass
+except Exception as e:
+    vd.exceptionCaught(e)

visidata/loaders/tsv.py

@@ -23,7 +23,7 @@ def adaptive_bufferer(fp, max_buffer_size=65536):
     """Loading e.g. tsv files goes faster with a large buffer. But when the input stream
     is slow (e.g. 1 byte/second) and the buffer size is large, it can take a long time until
     the buffer is filled. Only when the buffer is filled (or the input stream is finished)
-    you can see the data visiualized in visidata. That's why we use an adaptive buffer.
+    you can see the data visualized in visidata. That's why we use an adaptive buffer.
     For fast input streams, the buffer becomes large, for slow input streams, the buffer stays
     small"""
     buffer_size = 8
@@ -42,10 +42,10 @@ def adaptive_bufferer(fp, max_buffer_size=65536):
         current_delta = current_time - previous_start_time
 
         if current_delta < 1:
-            # if it takes longer than one second to fill the buffer, double the size of the buffer
+            # if it takes less than one second to fill the buffer, double the size of the buffer
             buffer_size = min(buffer_size * 2, max_buffer_size)
         else:
-            # if it takes less than one second, increase the buffer size so it takes about
+            # if it takes longer than one second, decrease the buffer size so it takes about
             # 1 second to fill it
             previous_start_time = current_time
             buffer_size = math.ceil(min(processed_buffer_size / current_delta, max_buffer_size))
@@ -75,13 +75,24 @@ class TsvSheet(SequenceSheet):
     def iterload(self):
         delim = self.delimiter or self.options.delimiter
         rowdelim = self.row_delimiter or self.options.row_delimiter
+        if delim == '':
+            vd.warning("using '\\x00' as field delimiter")
+            delim = '\x00'  #2272
+            self.options.regex_skip = ''
+        if rowdelim == '':
+            vd.warning("using '\\x00' as row delimiter")
+            rowdelim = '\x00'
+            self.options.regex_skip = ''
+        if delim == rowdelim:
+            vd.fail('field delimiter and row delimiter cannot be the same')
 
         with self.open_text_source() as fp:
+                regex_skip = getattr(fp, '_regex_skip', None)
                 for line in splitter(adaptive_bufferer(fp), rowdelim):
-                    if not line:
+                    if not line or (regex_skip and regex_skip.match(line)):
                         continue
 
-                    row = list(line.split(delim))
+                    row = line.split(delim)
 
                     if len(row) < self.nVisibleCols:
                         # extend rows that are missing entries
@@ -95,6 +106,14 @@ def save_tsv(vd, p, vs, delimiter='', row_delimiter=''):
     'Write sheet to file `fn` as TSV.'
     unitsep = delimiter or vs.options.delimiter
     rowsep = row_delimiter or vs.options.row_delimiter
+    if unitsep == '':
+        vd.warning("saving with '\\x00' as field delimiter")
+        unitsep = '\x00'
+    if rowsep == '':
+        vd.warning("saving with '\\x00' as row delimiter")
+        rowsep = '\x00'
+    if unitsep == rowsep:
+        vd.fail('field delimiter and row delimiter cannot be the same')
     trdict = vs.safe_trdict()
 
     with p.open(mode='w', encoding=vs.options.save_encoding) as fp:
@@ -136,8 +155,6 @@ def append_tsv_row(vs, row):
         fp.write(newrow)
 
 
-TsvSheet.options.regex_skip = '^#.*'
-
 vd.addGlobals({
     'TsvSheet': TsvSheet,
 })

visidata/loaders/unzip_http.py

@@ -18,18 +18,44 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+"""
+usage: unzip_http [-h] [-l] [-f] [-o] url [files ...]
+
+Extract individual files from .zip files over http without downloading the
+entire archive. HTTP server must send `Accept-Ranges: bytes` and
+`Content-Length` in headers.
+
+positional arguments:
+  url                   URL of the remote zip file
+  files                 Files to extract. If no filenames given, displays .zip
+                        contents (filenames and sizes). Each filename can be a
+                        wildcard glob.
+
+options:
+  -h, --help            show this help message and exit
+  -l, --list            List files in the remote zip file
+  -f, --full-filepaths  Recreate folder structure from zip file when extracting
+                        (instead of extracting the files to the current
+                        directory)
+  -o, --stdout          Write files to stdout (if multiple files: concatenate
+                        them to stdout, in zipfile order)
+"""
+
 import sys
 import os
 import io
+import math
+import time
 import zlib
 import struct
 import fnmatch
+import argparse
 import pathlib
 import urllib.parse
 from visidata import vd
 
 
-__version__ = '0.5.1'
+__version__ = '0.6'
 
 
 def error(s):
@@ -130,7 +156,10 @@ class RemoteZipFile:
             warning(f"{hostname} Accept-Ranges header ('{r}') is not 'bytes'--trying anyway")
 
         self.zip_size = int(resp.headers['Content-Length'])
-        resp = self.get_range(self.zip_size-65536, 65536)
+        resp = self.get_range(
+            max(self.zip_size-65536, 0),
+            65536
+        )
 
         cdir_start = -1
         i = resp.data.rfind(self.magic_eocd64)
@@ -147,7 +176,10 @@ class RemoteZipFile:
         if cdir_start < 0 or cdir_start >= self.zip_size:
             error('cannot find central directory')
 
-        filehdr_index = len(resp.data) - (self.zip_size - cdir_start)
+        if self.zip_size <= 65536:
+            filehdr_index = cdir_start
+        else:
+            filehdr_index = 65536 - (self.zip_size - cdir_start)
 
         if filehdr_index < 0:
             resp = self.get_range(cdir_start, self.zip_size - cdir_start)
@@ -258,3 +290,95 @@ class RemoteZipStream(io.RawIOBase):
         self._buffer = self._buffer[n:]
 
         return ret
+
+
+ ### script start
+
+class StreamProgress:
+    def __init__(self, fp, name='', total=0):
+        self.name = name
+        self.fp = fp
+        self.total = total
+        self.start_time = time.time()
+        self.last_update = 0
+        self.amtread = 0
+
+    def read(self, n):
+        r = self.fp.read(n)
+        self.amtread += len(r)
+        now = time.time()
+        if now - self.last_update > 0.1:
+            self.last_update = now
+
+            elapsed_s = now - self.start_time
+            sys.stderr.write(f'\r{elapsed_s:.0f}s  {self.amtread/10**6:.02f}/{self.total/10**6:.02f}MB  ({self.amtread/10**6/elapsed_s:.02f} MB/s)  {self.name}')
+
+        if not r:
+            sys.stderr.write('\n')
+
+        return r
+
+
+def list_files(rzf):
+    def safelog(x):
+        return 1 if x == 0 else math.ceil(math.log10(x))
+
+    digits_compr = max(safelog(f.compress_size) for f in rzf.infolist())
+    digits_plain = max(safelog(f.file_size    ) for f in rzf.infolist())
+    fmtstr = f'%{digits_compr}d -> %{digits_plain}d\t%s'
+    for f in rzf.infolist():
+        print(fmtstr % (f.compress_size, f.file_size, f.filename), file=sys.stderr)
+
+
+def extract_one(outfile, rzf, f, ofname):
+    print(f'Extracting {f.filename} to {ofname}...', file=sys.stderr)
+
+    fp = StreamProgress(rzf.open(f), name=f.filename, total=f.compress_size)
+    while r := fp.read(2**18):
+        outfile.write(r)
+
+
+def download_file(f, rzf, args):
+    if not any(fnmatch.fnmatch(f.filename, g) for g in args.files):
+        return
+
+    if args.stdout:
+        extract_one(sys.stdout.buffer, rzf, f, "stdout")
+    else:
+        path = pathlib.Path(f.filename)
+        if args.full_filepaths:
+            path.parent.mkdir(parents=True, exist_ok=True)
+        else:
+            path = path.name
+
+        with open(str(path), 'wb') as of:
+            extract_one(of, rzf, f, str(path))
+
+
+def main():
+    parser = argparse.ArgumentParser(prog='unzip-http', \
+        description="Extract individual files from .zip files over http without downloading the entire archive. HTTP server must send `Accept-Ranges: bytes` and `Content-Length` in headers.")
+
+    parser.add_argument('-l', '--list', action='store_true', default=False,
+                        help="List files in the remote zip file")
+    parser.add_argument('-f', '--full-filepaths', action='store_true', default=False,
+                        help="Recreate folder structure from zip file when extracting (instead of extracting the files to the current directory)")
+    parser.add_argument('-o', '--stdout', action='store_true', default=False,
+                        help="Write files to stdout (if multiple files: concatenate them to stdout, in zipfile order)")
+
+    parser.add_argument("url", nargs=1, help="URL of the remote zip file")
+    parser.add_argument("files", nargs='*', help="Files to extract. If no filenames given, displays .zip contents (filenames and sizes). Each filename can be a wildcard glob.")
+
+    args = parser.parse_args()
+
+    rzf = RemoteZipFile(args.url[0])
+    if args.list or len(args.files) == 0:
+        list_files(rzf)
+    else:
+        for f in rzf.infolist():
+            download_file(f, rzf, args)
+
+
+
+if __name__ == '__main__':
+    main()

visidata/loaders/vds.py

@@ -34,6 +34,10 @@ def save_vds(vd, p, *sheets):
                     d['col'] = type(col).__name__
                 fp.write('#'+json.dumps(d)+NL)
 
+            if not vs.rows:
+                fp.write(NL)  #2342  blank line to separate sheets without rows
+                continue
+
             with Progress(gerund='saving'):
                 for row in vs.iterdispvals(*vs.columns, format=False):
                     d = {col.name:val for col, val in row.items()}

visidata/loaders/vdx.py

@@ -46,7 +46,7 @@ def save_vdx(vd, p, *vsheets):
 def runvdx(vd, vdx:str):
     for line in Progress(vdx.splitlines()):
         vs = vd.sheet or Sheet()
-        vs.ensureLoaded()
+        vd.sync(vs.ensureLoaded())
         line = line.strip()
         if not line or line[0] == '#':
             continue

visidata/loaders/xlsx.py

@@ -10,13 +10,16 @@ from visidata.type_date import date
 
 
 vd.option('xlsx_meta_columns', False, 'include columns for cell objects, font colors, and fill colors', replay=True)
+vd.option('xlsx_color_cells', True, 'color cells based on xlsx source')
 
 @VisiData.api
 def open_xls(vd, p):
+    p.is_local() or vd.fail('xls loader does not support remote files')
     return XlsIndexSheet(p.base_stem, source=p)
 
 @VisiData.api
 def open_xlsx(vd, p):
+    p.is_local() or vd.fail('xlsx loader does not support remote files')
     return XlsxIndexSheet(p.base_stem, source=p)
 
 class XlsxIndexSheet(IndexSheet):
@@ -203,6 +206,8 @@ HLSMAX = 240
 
 @XlsxSheet.api
 def colorize_xlsx_cell(sheet, col, row):
+    if not hasattr(col, 'column_letter') or not sheet.options.xlsx_color_cells:
+        return ''
     fg = getattrdeep(row, col.column_letter+'.font.color', None)
     bg = getattrdeep(row, col.column_letter+'.fill.start_color', None)
     fg = sheet.xlsx_color_to_xterm256(fg)

visidata/loaders/xml.py

@@ -85,8 +85,9 @@ class XmlSheet(Sheet):
 @VisiData.api
 def save_xml(vd, p, vs):
     isinstance(vs, XmlSheet) or vd.fail('must save xml from XmlSheet')
-    vs.root.write(str(p), encoding=options.encoding, standalone=False, pretty_print=True)
+    vs.root.write(str(p), encoding=vs.options.save_encoding, standalone=False, pretty_print=True)
 
+XmlSheet.options.save_encoding = 'utf-8'  #2520
 
 XmlSheet.addCommand('za', 'addcol-xmlattr', 'attr=input("add attribute: "); addColumnAtCursor(AttribColumn(attr, attr))', 'add column for xml attribute')
 XmlSheet.addCommand('v', 'visibility', 'showColumnsBasedOnRow(cursorRow)', 'show only columns in current row attributes')

visidata/macros.py

@@ -3,9 +3,9 @@ from functools import wraps
 
 from visidata.cmdlog import CommandLog, CommandLogJsonl
 from visidata import vd, UNLOADED, asyncthread, vlen
-from visidata import IndexSheet, VisiData, Sheet, Path, VisiDataMetaSheet, Column, ItemColumn, AttrColumn, BaseSheet, GuideSheet
+from visidata import IndexSheet, VisiData, Sheet, Path, VisiDataMetaSheet, Column, ItemColumn, AttrColumn, BaseSheet
 
-vd.macroMode = None
+vd.macroMode = None  # CommandLog
 vd.macrobindings = {}
 
 
@@ -70,7 +70,10 @@ def loadMacro(vd, p:Path):
 
 @VisiData.api
 def runMacro(vd, binding:str):
+    mm = vd.macroMode
+    vd.macroMode = None
     vd.replay_sync(vd.macrobindings[binding])
+    vd.macroMode = mm
 
 
 @VisiData.api
@@ -100,10 +103,13 @@ def saveMacro(self, rows, ks):
 # needs to happen before, because the original afterexecsheet resets vd.activecommand to None
 @CommandLogJsonl.before
 def afterExecSheet(cmdlog, sheet, escaped, err):
-    if vd.macroMode and (vd.activeCommand is not None) and (vd.activeCommand is not UNLOADED) and (vd.isLoggableCommand(vd.activeCommand.longname)):
-        cmd = copy(vd.activeCommand)
-        cmd.sheet = ''
-        vd.macroMode.addRow(cmd)
+    if not vd.macroMode: return
+    if not vd.activeCommand: return
+    if vd.activeCommand.longname == 'macro-record': return
+
+    cmd = copy(vd.activeCommand)
+    cmd.sheet = ''
+    vd.macroMode.addRow(cmd)
 
 
 @CommandLogJsonl.api
@@ -146,33 +152,10 @@ def reloadMacros(vd):
             vd.setMacro(r.binding, vs)
 
 
-class MacrosGuide(GuideSheet):
-    guide_text = '''# Macros
-Macros allow you to bind a command sequence to a keystroke or longname, to replay when that keystroke is pressed or the command is executed by longname.
-
-The basic usage is:
-    1. {help.commands.macro_record}.
-    2. Execute a series of commands.
-    3. `m` again to complete the recording, and prompt for the keystroke or longname to bind it to.
-
-The macro will then be executed everytime the provided keystroke or longname are used. Note: the Alt+keys and the function keys are left unbound; overriding other keys may conflict with existing bindings, now or in the future.
-
-Executing a macro will the series of commands starting on the current row and column on the current sheet.
-
-# The Macros Sheet
-
-- {help.commands.macro_sheet}
-
-- `d` (`delete-row`) to mark macros for deletion
-- {help.commands.commit_sheet}
-- `Enter` (`open-row`) to open the macro in the current row, and view the series of commands composing it'''
-
-
-Sheet.addCommand('m', 'macro-record', 'vd.cmdlog.startMacro()', 'record macro')
+Sheet.addCommand('m', 'macro-record', 'vd.cmdlog.startMacro()', 'start/stop macro recording', replay=False)
 Sheet.addCommand('gm', 'macro-sheet', 'vd.push(vd.macrosheet)', 'open an index of existing macros')
 
 vd.addMenuItems('''
+    System > Record macro > macro-record
     System > Macros sheet > macro-sheet
 ''')
-
-vd.addGuide('MacrosSheet', MacrosGuide)

visidata/main.py

@@ -2,7 +2,7 @@
 # Usage: $0 [<options>] [<input> ...]
 #        $0 [<options>] --play <cmdlog> [--batch] [-w <waitsecs>] [-o <output>] [field=value ...]
 
-__version__ = '3.0.2'
+__version__ = '3.1'
 __version_info__ = 'saul.pw/VisiData v' + __version__
 
 from copy import copy
@@ -37,16 +37,20 @@ def eval_vd(logpath, *args, **kwargs):
     'Instantiate logpath with args/kwargs replaced and replay all commands.'
     log = logpath.read_text()
     if args or kwargs:
-        if logpath.ext in ['vdj', 'json', 'jsonl']:
+        if logpath.ext in ['vdj', 'json', 'jsonl'] or logpath is vd.stdinSource:
             from string import Template
             log = Template(log).safe_substitute(**kwargs)
         else:
             log = log.format(*args, **kwargs)
 
     src = Path(logpath.given, fptext=io.StringIO(log), filesize=len(log))
-    vs = vd.openSource(src, filetype=src.ext)
+    if logpath is vd.stdinSource:
+        # replay from stdin only supports .vdj
+        vs = vd.openSource(src, filetype='vdj')
+    else:
+        vs = vd.openSource(src, filetype=src.ext)
     vs.name += '_vd'
-    vs.reload()
+    vd.sync(vs.reload())
     vs.vd = vd
     return vs
 
@@ -220,6 +224,8 @@ def main_vd():
         elif arg in ['--']:
             optsdone = True
         elif arg == '-':
+            if not flPipedInput:
+                vd.fail('to use stdin as a data source, data must be piped into it')
             inputs.append((vd.stdinSource, copy(current_args)))
         elif arg in ['-g', '--global']:
             flGlobal = True
@@ -252,10 +258,8 @@ def main_vd():
             current_args[optname] = optval
             if flGlobal:
                 global_args[optname] = optval
-
         elif arg.startswith('+'):  # position cursor at start
             after_config.append((vd.moveToPos, *vd.parsePos(arg[1:], inputs=inputs)))
-
         elif current_args.get('play', None) and '=' in arg:
             # parse 'key=value' pairs for formatting cmdlog template in replay mode
             k, v = arg.split('=', maxsplit=1)
@@ -282,9 +286,9 @@ def main_vd():
     vd.domotd()
 
     if args.batch:
-        options.undo = False
-        options.quitguard = False
-        vd.editline = lambda *args, **kwargs: ''
+        if not vd.options.interactive:
+            options.undo = False
+            options.quitguard = False
         vd.execAsync = vd.execSync  # disable async
 
     for cmd in (args.preplay or '').split():
@@ -332,7 +336,6 @@ def main_vd():
         if args.batch:
             if sources:
                 vd.push(sources[0])
-                sources[0].reload()
 
         for (f, *parms) in after_config:
             f(sources, *parms)
@@ -342,20 +345,18 @@ def main_vd():
     else:
         if args.play == '-':
             vdfile = vd.stdinSource
-            vdfile.name = 'stdin.vd'
         else:
             vdfile = Path(args.play)
 
         vs = eval_vd(vdfile, *fmtargs, **fmtkwargs)
-        vd.sync(vs.reload())
         if args.batch:
             if not args.debug:
                 vd.outputProgressThread = visidata.VisiData.execAsync(vd, vd.outputProgressEvery, vs, seconds=0.5, sheet=BaseSheet())  #1182
+            vd.reloadMacros()
             if vd.replay_sync(vs):  # error
                 return 1
 
             if vd.options.interactive:
-                vd.editline = lambda *args, vd=vd, **kwargs: visidata.VisiData.editline(vd, *args, **kwargs)
                 vd.execAsync = lambda *args, vd=vd, **kwargs: visidata.VisiData.execAsync(vd, *args, **kwargs)
                 run()
         else:

visidata/mainloop.py

@@ -165,8 +165,11 @@ def mainloop(vd, scr):
     numTimeouts = 0
     prefixWaiting = False
     vd.scrFull = scr
+    if vd.options.disp_expert >= 5:
+        vd.disp_help = -1
 
     vd.keystrokes = ''
+    vd.drawThread = threading.current_thread()
     while True:
         if not vd.stackedSheets and vd.currentReplay is None:
             return
@@ -177,11 +180,13 @@ def mainloop(vd, scr):
             continue  # waiting for replay to push sheet
 
         threading.current_thread().sheet = sheet
-        vd.drawThread = threading.current_thread()
 
         vd.setWindows(vd.scrFull)
 
-        if not vd.drainPendingKeys(scr) or time.time() - vd._lastDrawTime > vd.min_draw_ms/1000:  #1459
+        # a newly created sheet needs to be drawn once to set its _scr
+        if vd.activeSheet._scr is None or \
+           not vd.drainPendingKeys(scr) or \
+           time.time() - vd._lastDrawTime > vd.min_draw_ms/1000:  #1459
             vd.draw_all()
             vd._lastDrawTime = time.time()
 
@@ -216,10 +221,10 @@ def mainloop(vd, scr):
             pass
         elif keystroke == 'Ctrl+Q':
             return vd.lastErrors and '\n'.join(vd.lastErrors[-1])
-        elif vd.bindkeys._get(vd.keystrokes):
+        elif vd.bindkeys._get(vd.keystrokes) is not None:
             sheet.execCommand(vd.keystrokes, keystrokes=vd.keystrokes)
             prefixWaiting = False
-        elif keystroke in vd.allPrefixes:
+        elif vd.keystrokes in vd.allPrefixes:
             prefixWaiting = True
         else:
             vd.status('no command for "%s"' % (vd.keystrokes))
@@ -249,12 +254,15 @@ def mainloop(vd, scr):
         # no idle redraw unless background threads are running
         time.sleep(0)  # yield to other threads which may not have started yet
         if vd._nextCommands:
-            vd.curses_timeout = int(vd.options.replay_wait*1000)
+            if vd.options.replay_wait > 0:
+                vd.curses_timeout = int(vd.options.replay_wait*1000)
+            else:
+                vd.curses_timeout = nonidle_timeout
         elif vd.unfinishedThreads:
             vd.curses_timeout = nonidle_timeout
         else:
             numTimeouts += 1
-            if vd.timeouts_before_idle >= 0 and numTimeouts > vd.timeouts_before_idle:
+            if vd.timeouts_before_idle >= 0 and numTimeouts >= vd.timeouts_before_idle:
                 vd.curses_timeout = -1
             else:
                 vd.curses_timeout = nonidle_timeout