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

visidata/_input.py

@@ -3,25 +3,48 @@ import curses
 
 import visidata
 
-from visidata import EscapeException, ExpectedException, clipdraw, Sheet, VisiData
-from visidata import vd, options, colors
-from visidata import suspend, ColumnItem, AttrDict
+from visidata import EscapeException, ExpectedException, clipdraw, Sheet, VisiData, BaseSheet
+from visidata import vd, options, colors, dispwidth, ColorAttr
+from visidata import AttrDict
 
 
-vd.option('color_edit_cell', 'white', 'cell color to use when editing cell')
-vd.option('disp_edit_fill', '_', 'edit field fill character')
-vd.option('disp_unprintable', '·', 'substitute character for unprintables')
+vd.theme_option('color_edit_unfocused', '238 on 110', 'display color for unfocused input in form')
+vd.theme_option('color_edit_cell', '233 on 110', 'cell color to use when editing cell')
+vd.theme_option('disp_edit_fill', '_', 'edit field fill character')
+vd.theme_option('disp_unprintable', '·', 'substitute character for unprintables')
+vd.theme_option('mouse_interval', 1, 'max time between press/release for click (ms)', sheettype=None)
 
-vd.option('input_history', '', 'basename of file to store persistent input history')
+vd.disp_help = 1  # current level of help shown (up to vd.options.disp_help as maximum)
 
 class AcceptInput(Exception):
     '*args[0]* is the input to be accepted'
 
-visidata.vd._nextCommands = []
+vd._injectedInput = None  # for vd.injectInput
+
+
+@VisiData.api
+def injectInput(vd, x):
+    'Use *x* as input to next command.'
+    assert vd._injectedInput is None, vd._injectedInput
+    vd._injectedInput = x
+
 
 @VisiData.api
-def queueCommand(vd, longname): #, input=None, sheet=None, col=None, row=None):
-    vd._nextCommands.append(longname)
+def getCommandInput(vd):
+    if vd._injectedInput is not None:
+        r = vd._injectedInput
+        vd._injectedInput = None
+        return r
+
+    return vd.getLastArgs()
+
+
+@BaseSheet.after
+def execCommand(sheet, longname, *args, **kwargs):
+    if vd._injectedInput is not None:
+        vd.debug(f'{longname} did not consume input "{vd._injectedInput}"')
+        vd._injectedInput = None
+
 
 def acceptThenFunc(*longnames):
     def _acceptthen(v, i):
@@ -52,10 +75,12 @@ def until_get_wch(scr):
     ret = None
     while not ret:
         try:
-            ret = scr.get_wch()
+            ret = vd.get_wch(scr)
         except curses.error:
             pass
 
+    if isinstance(ret, int):
+        return chr(ret)
     return ret
 
 
@@ -64,6 +89,48 @@ def splice(v:str, i:int, s:str):
     return v if i < 0 else v[:i] + s + v[i:]
 
 
+# vd.options.disp_help is the effective maximum disp_help.  The user can cycle through the various levels of help.
+class HelpCycler:
+    def __init__(self, scr=None, help=''):
+        self.help = help
+        self.scr = scr
+
+    def __enter__(self):
+        if self.scr:
+            vd.drawInputHelp(self.scr, self.help)
+
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    def cycle(self):
+        vd.disp_help = (vd.disp_help-1)%(vd.options.disp_help+1)
+        if self.scr:
+            vd.drawInputHelp(self.scr, self.help)
+
+
+@VisiData.api
+def drawInputHelp(vd, scr, help:str=''):
+    if not scr or not vd.cursesEnabled:
+        return
+
+    sheet = vd.activeSheet
+    if not sheet:
+        return
+    vd.drawSheet(scr, sheet)
+
+    curhelp = ''
+    if vd.disp_help == 0:
+        vd.drawSidebar(scr, sheet)
+    elif vd.disp_help == 1:
+        curhelp = help
+        sheet.drawSidebarText(scr, curhelp)
+    elif vd.disp_help >= 2:
+        curhelp = vd.getHelpPane('input', module='visidata')
+        sheet.drawSidebarText(scr, curhelp, title='Input Keystrokes Help')
+
+
 def clean_printable(s):
     'Escape unprintable characters.'
     return ''.join(c if c.isprintable() else options.disp_unprintable for c in str(s))
@@ -138,14 +205,26 @@ class HistoryState:
 
 # history: earliest entry first
 @VisiData.api
-def editline(vd, scr, y, x, w, i=0, attr=curses.A_NORMAL, value='', fillchar=' ', truncchar='-', unprintablechar='.', completer=lambda text,idx: None, history=[], display=True, updater=lambda val: None, bindings={}, clear=True):
+def editline(vd, scr, y, x, w, i=0,
+             attr=ColorAttr(),
+             value='',
+             fillchar=' ',
+             truncchar='-',
+             unprintablechar='.',
+             completer=lambda text,idx: None,
+             history=[],
+             display=True,
+             updater=lambda val: None,
+             bindings={},
+             help='',  # str|HelpPane
+             clear=True):
   '''A better curses line editing widget.
   If *clear* is True, clear whole editing area before displaying.
   '''
   with EnableCursor():
+   with HelpCycler(scr, help) as disp_help:
     ESC='^['
     TAB='^I'
-
     history_state = HistoryState(history)
     complete_state = CompleteState(completer)
     insert_mode = True
@@ -176,10 +255,8 @@ def editline(vd, scr, y, x, w, i=0, attr=curses.A_NORMAL, value='', fillchar=' '
                 a += incr
             return min(max(a, 0), len(s))
 
-
     while True:
         updater(v)
-        vd.getHelpPane('input', module=__name__).draw(scr, y=y)
 
         if display:
             dispval = clean_printable(v)
@@ -202,11 +279,12 @@ def editline(vd, scr, y, x, w, i=0, attr=curses.A_NORMAL, value='', fillchar=' '
             k = 1 if w%2==0 else 0  # odd widths have one character more
             dispval = left_truncchar + dispval[i-w//2+1:i+w//2-k] + right_truncchar
 
-        prew = clipdraw(scr, y, x, dispval[:dispi], attr, w, clear=clear)
-        clipdraw(scr, y, x+prew, dispval[dispi:], attr, w-prew+1, clear=clear)
-        scr.move(y, x+prew)
+        prew = clipdraw(scr, y, x, dispval[:dispi], attr, w, clear=clear, literal=True)
+        clipdraw(scr, y, x+prew, dispval[dispi:], attr, w-prew+1, clear=clear, literal=True)
+        if scr: scr.move(y, x+prew)
         ch = vd.getkeystroke(scr)
         if ch == '':                               continue
+        elif ch in bindings:                       v, i = bindings[ch](v, i)
         elif ch == 'KEY_IC':                       insert_mode = not insert_mode
         elif ch == '^A' or ch == 'KEY_HOME':       i = 0
         elif ch == '^B' or ch == 'KEY_LEFT':       i -= 1
@@ -214,20 +292,29 @@ def editline(vd, scr, y, x, w, i=0, attr=curses.A_NORMAL, value='', fillchar=' '
         elif ch == '^D' or ch == 'KEY_DC':         v = delchar(v, i)
         elif ch == '^E' or ch == 'KEY_END':        i = len(v)
         elif ch == '^F' or ch == 'KEY_RIGHT':      i += 1
-        elif ch == '^G':                           vd.show_help = not vd.show_help; continue # not a first keypress
+        elif ch == '^G':
+            disp_help.cycle()
+            continue  # not considered a first keypress
         elif ch in ('^H', 'KEY_BACKSPACE', '^?'):  i -= 1; v = delchar(v, i)
         elif ch == TAB:                            v, i = complete_state.complete(v, i, +1)
         elif ch == 'KEY_BTAB':                     v, i = complete_state.complete(v, i, -1)
         elif ch in ['^J', '^M']:                   break  # ENTER to accept value
         elif ch == '^K':                           v = v[:i]  # ^Kill to end-of-line
-        elif ch == '^O':                           v = vd.launchExternalEditor(v)
+        elif ch == '^N':
+            c = ''
+            while not c:
+                c = vd.getkeystroke(scr)
+            c = vd.prettykeys(c)
+            i += len(c)
+            v += c
+        elif ch == '^O':                           v = vd.launchExternalEditor(v); break
         elif ch == '^R':                           v = str(value)  # ^Reload initial value
         elif ch == '^T':                           v = delchar(splice(v, i-2, v[i-1:i]), i)  # swap chars
         elif ch == '^U':                           v = v[i:]; i = 0  # clear to beginning
         elif ch == '^V':                           v = splice(v, i, until_get_wch(scr)); i += 1  # literal character
         elif ch == '^W':                           j = find_nonword(v, 0, i-1, -1); v = v[:j+1] + v[i:]; i = j+1  # erase word
         elif ch == '^Y':                           v = splice(v, i, str(vd.memory.clipval))
-        elif ch == '^Z':                           suspend()
+        elif ch == '^Z':                           vd.suspend()
         # CTRL+arrow
         elif ch == 'kLFT5':                        i = find_nonword(v, 0, i-1, -1)+1; # word left
         elif ch == 'kRIT5':                        i = find_nonword(v, i+1, len(v)-1, +1)+1; # word right
@@ -235,7 +322,6 @@ def editline(vd, scr, y, x, w, i=0, attr=curses.A_NORMAL, value='', fillchar=' '
         elif ch == 'kDN5':                         pass
         elif history and ch == 'KEY_UP':           v, i = history_state.up(v, i)
         elif history and ch == 'KEY_DOWN':         v, i = history_state.down(v, i)
-        elif ch in bindings:                       v, i = bindings[ch](v, i)
         elif len(ch) > 1:                          pass
         else:
             if first_action:
@@ -254,7 +340,7 @@ def editline(vd, scr, y, x, w, i=0, attr=curses.A_NORMAL, value='', fillchar=' '
         first_action = False
         complete_state.reset()
 
-    return type(value)(v)
+    return v
 
 
 @VisiData.api
@@ -262,7 +348,7 @@ def editText(vd, y, x, w, record=True, display=True, **kwargs):
     'Invoke modal single-line editor at (*y*, *x*) for *w* terminal chars. Use *display* is False for sensitive input like passphrases.  If *record* is True, get input from the cmdlog in batch mode, and save input to the cmdlog if *display* is also True. Return new value as string.'
     v = None
     if record and vd.cmdlog:
-        v = vd.getLastArgs()
+        v = vd.getCommandInput()
 
     if v is None:
         try:
@@ -270,27 +356,32 @@ def editText(vd, y, x, w, record=True, display=True, **kwargs):
         except AcceptInput as e:
             v = e.args[0]
 
-        if vd.scrFull:  # check if curses initialised
+        if vd.cursesEnabled:
             # clear keyboard buffer to neutralize multi-line pastes (issue#585)
             curses.flushinp()
 
     if display:
-        vd.status('"%s"' % v)
         if record and vd.cmdlog:
             vd.setLastArgs(v)
 
-    return v
+    if 'value' in kwargs:
+        starting_value = kwargs['value']
+        if isinstance(starting_value, (int, float)) and v[-1] == '%':  #2082
+            pct = float(v[:-1])
+            v = pct*starting_value/100
+
+        v = type(starting_value)(v)
 
+    return v
 
 @VisiData.api
 def inputsingle(vd, prompt, record=True):
     'Display prompt and return single character of user input.'
     sheet = vd.activeSheet
-    rstatuslen = vd.drawRightStatus(sheet._scr, sheet)
 
     v = None
     if record and vd.cmdlog:
-        v = vd.getLastArgs()
+        v = vd.getCommandInput()
 
     if v is not None:
         return v
@@ -309,9 +400,102 @@ def inputsingle(vd, prompt, record=True):
 
     return v
 
+@VisiData.api
+def inputMultiple(vd, updater=lambda val: None, record=True, **kwargs):
+    'A simple form, where each input is an entry in `kwargs`, with the key being the key in the returned dict, and the value being a dictionary of kwargs to the singular input().'
+    sheet = vd.activeSheet
+    scr = sheet._scr
+
+    previnput = vd.getCommandInput()
+    if previnput is not None:
+        if isinstance(previnput, str):
+            if previnput.startswith('{'):
+                return json.loads(previnput)
+            else:
+                ret = {k:v.get('value', '') for k,v in kwargs.items()}
+                primekey = list(ret.keys())[0]
+                ret[primekey] = previnput
+                return ret
+
+        if isinstance(previnput, dict):
+            return previnput
+
+        assert False, type(previnput)
+
+    y = sheet.windowHeight-1
+    maxw = sheet.windowWidth//2
+    attr = colors.color_edit_unfocused
+
+    keys = list(kwargs.keys())
+    cur_input_key = keys[0]
+
+    if scr:
+        scr.erase()
+
+    for i, (k, v) in enumerate(kwargs.items()):
+        v['dy'] = i
+        v['w'] = maxw-dispwidth(v.get('prompt'))
+
+    class ChangeInput(Exception):
+        pass
+
+    def change_input(offset):
+        def _throw(v, i):
+            if scr:
+                scr.erase()
+            raise ChangeInput(v, offset)
+        return _throw
+
+    def _drawPrompt(val):
+        for k, v in kwargs.items():
+            maxw = min(sheet.windowWidth-1, max(dispwidth(v.get('prompt')), dispwidth(str(v.get('value', '')))))
+            promptlen = clipdraw(scr, y-v.get('dy'), 0, v.get('prompt'), attr, w=maxw)  #1947
+            promptlen = clipdraw(scr, y-v.get('dy'), promptlen, v.get('value', ''),  attr, w=maxw)
+
+        return updater(val)
+
+    with HelpCycler() as disp_help:
+      while True:
+        try:
+            input_kwargs = kwargs[cur_input_key]
+            input_kwargs['value'] = vd.input(**input_kwargs,
+                                             attr=colors.color_edit_cell,
+                                             updater=_drawPrompt,
+                                             record=False,
+                                             bindings={
+                'KEY_BTAB': change_input(-1),
+                '^I':       change_input(+1),
+                'KEY_SR':   change_input(-1),
+                'KEY_SF':   change_input(+1),
+                'kUP':      change_input(-1),
+                'kDN':      change_input(+1),
+            })
+            break
+        except ChangeInput as e:
+            input_kwargs['value'] = e.args[0]
+            offset = e.args[1]
+            i = keys.index(cur_input_key)
+            cur_input_key = keys[(i+offset)%len(keys)]
+
+    retargs = {}
+    if record:
+        lastargs = {}
+        for k, input_kwargs in kwargs.items():
+            v = input_kwargs.get('value', '')
+            retargs[k] = v
+
+            if input_kwargs.get('display', True):
+                lastargs[k] = v
+                vd.addInputHistory(v, input_kwargs.get('type', ''))
+
+        if vd.cmdlog and lastargs:
+            vd.setLastArgs(lastargs)
+
+    return retargs
+
 
 @VisiData.api
-def input(self, prompt, type=None, defaultLast=False, history=[], **kwargs):
+def input(vd, prompt, type=None, defaultLast=False, history=[], dy=0, attr=None, updater=lambda v: None, **kwargs):
     '''Display *prompt* and return line of user input.
 
         - *type*: string indicating the type of input to use for history.
@@ -322,23 +506,47 @@ def input(self, prompt, type=None, defaultLast=False, history=[], **kwargs):
         - *completer*: ``completer(val, idx)`` is called on TAB to get next completed value.
         - *updater*: ``updater(val)`` is called every keypress or timeout.
         - *bindings*: dict of keystroke to func(v, i) that returns updated (v, i)
+        - *dy*: number of lines from bottom of pane
+        - *attr*: curses attribute for prompt
+        - *help*: string to include in help
     '''
 
-    history = self.lastInputsSheet.history(type)
+    if attr is None:
+        attr = ColorAttr()
+    sheet = vd.activeSheet
+    if not vd.cursesEnabled:
+        if kwargs.get('record', True) and vd.cmdlog:
+            return vd.getCommandInput()
+
+        if kwargs.get('display', True):
+            import builtins
+            return builtins.input(prompt)
+        else:
+            import getpass
+            return getpass.getpass(prompt)
+
+    history = list(vd.inputHistory.setdefault(type, {}).keys())
+
+    y = sheet.windowHeight-dy-1
+    promptlen = dispwidth(prompt)
 
-    sheet = self.activeSheet
-    rstatuslen = self.drawRightStatus(sheet._scr, sheet)
-    attr = 0
-    promptlen = clipdraw(sheet._scr, sheet.windowHeight-1, 0, prompt, attr, w=sheet.windowWidth-rstatuslen-1)
-    ret = self.editText(sheet.windowHeight-1, promptlen, sheet.windowWidth-promptlen-rstatuslen-2,
+    def _drawPrompt(val=''):
+        rstatuslen = vd.drawRightStatus(sheet._scr, sheet)
+        clipdraw(sheet._scr, y, 0, prompt, attr, w=sheet.windowWidth-rstatuslen-1)
+        updater(val)
+        return sheet.windowWidth-promptlen-rstatuslen-2
+
+    w = kwargs.pop('w', _drawPrompt())
+    ret = vd.editText(y, promptlen, w=w,
                         attr=colors.color_edit_cell,
                         unprintablechar=options.disp_unprintable,
                         truncchar=options.disp_truncator,
                         history=history,
+                        updater=_drawPrompt,
                         **kwargs)
 
     if ret:
-        self.lastInputsSheet.appendRow(AttrDict(type=type, input=ret))
+        vd.addInputHistory(ret, type=type)
 
     elif defaultLast:
         history or vd.fail("no previous input")
@@ -350,7 +558,7 @@ def input(self, prompt, type=None, defaultLast=False, history=[], **kwargs):
 @VisiData.api
 def confirm(vd, prompt, exc=EscapeException):
     'Display *prompt* on status line and demand input that starts with "Y" or "y" to proceed.  Raise *exc* otherwise.  Return True.'
-    if options.batch:
+    if options.batch and not options.interactive:
         return vd.fail('cannot confirm in batch mode: ' + prompt)
 
     yn = vd.input(prompt, value='no', record=False)[:1]
@@ -403,17 +611,26 @@ def editCell(self, vcolidx=None, rowidx=None, value=None, **kwargs):
         'KEY_SF':     acceptThenFunc('go-down', 'rename-col' if rowidx < 0 else 'edit-cell'),
         'KEY_SRIGHT': acceptThenFunc('go-right', 'rename-col' if rowidx < 0 else 'edit-cell'),
         'KEY_SLEFT':  acceptThenFunc('go-left', 'rename-col' if rowidx < 0 else 'edit-cell'),
+        '^I':         acceptThenFunc('go-right', 'rename-col' if rowidx < 0 else 'edit-cell'),
+        'KEY_BTAB':   acceptThenFunc('go-left', 'rename-col' if rowidx < 0 else 'edit-cell'),
     }
 
+    if vcolidx >= self.nVisibleCols-1:
+        bindings['^I'] = acceptThenFunc('go-down', 'go-leftmost', 'edit-cell')
+
+    if vcolidx <= 0:
+        bindings['KEY_BTAB'] = acceptThenFunc('go-up', 'go-rightmost', 'edit-cell')
+
+    # update local bindings with kwargs.bindings instead of the inverse, to preserve kwargs.bindings for caller
     bindings.update(kwargs.get('bindings', {}))
     kwargs['bindings'] = bindings
 
     editargs = dict(value=value,
-                    fillchar=options.disp_edit_fill,
-                    truncchar=options.disp_truncator)
+                    fillchar=self.options.disp_edit_fill,
+                    truncchar=self.options.disp_truncator)
 
     editargs.update(kwargs)  # update with user-specified args
-    r = vd.editText(y, x, w, **editargs)
+    r = vd.editText(y, x, w, attr=colors.color_edit_cell, **editargs)
 
     if rowidx >= 0:  # if not header
         r = col.type(r)  # convert input to column type, let exceptions be raised
@@ -421,4 +638,4 @@ def editCell(self, vcolidx=None, rowidx=None, value=None, **kwargs):
     return r
 
 
-vd.addGlobals({'CompleteKey': CompleteKey})
+vd.addGlobals({'CompleteKey': CompleteKey, 'AcceptInput': AcceptInput})

visidata/_open.py

@@ -1,4 +1,7 @@
-from visidata import *
+import os
+import os.path
+
+from visidata import VisiData, vd, Path, BaseSheet, TableSheet, TextSheet, SettableColumn
 
 
 vd.option('filetype', '', 'specify file type', replay=True)
@@ -6,7 +9,13 @@ vd.option('filetype', '', 'specify file type', replay=True)
 
 @VisiData.api
 def inputFilename(vd, prompt, *args, **kwargs):
-    return vd.input(prompt, type="filename", *args, completer=_completeFilename, **kwargs).strip()
+    completer= _completeFilename
+    if not vd.couldOverwrite():  #1805 don't suggest an existing file
+        completer = None
+        v = kwargs.get('value', '')
+        if v and Path(v).exists():
+            kwargs['value'] = ''
+    return vd.input(prompt, type="filename", *args, completer=completer, **kwargs).strip()
 
 
 @VisiData.api
@@ -35,6 +44,38 @@ def _completeFilename(val, state):
     return files[state%len(files)]
 
 
+@VisiData.api
+def guessFiletype(vd, p, *args, funcprefix='guess_'):
+    '''Call all vd.guess_<filetype>(p) functions and return best candidate sheet based on file contents.'''
+
+    guessfuncs = [getattr(vd, x) for x in dir(vd) if x.startswith(funcprefix)]
+    filetypes = []
+    for f in guessfuncs:
+        try:
+            filetype = f(p, *args)
+            if filetype:
+                filetype['_guesser'] = f.__name__
+                filetypes.append(filetype)
+        except FileNotFoundError:
+            pass
+        except Exception as e:
+            vd.debug(f'{f.__name__}: {e}')
+
+    if filetypes:
+        return sorted(filetypes, key=lambda r: -r.get('_likelihood', 1))[0]
+
+    return {}
+
+
+@VisiData.api
+def guess_extension(vd, path):
+    # try auto-detect from extension
+    ext = path.suffix[1:].lower()
+    openfunc = getattr(vd, f'open_{ext}', vd.getGlobals().get(f'open_{ext}'))
+    if openfunc:
+        return dict(filetype=ext, _likelihood=3)
+
+
 @VisiData.api
 def openPath(vd, p, filetype=None, create=False):
     '''Call ``open_<filetype>(p)`` or ``openurl_<p.scheme>(p, filetype)``.  Return constructed but unloaded sheet of appropriate type.
@@ -53,27 +94,43 @@ def openPath(vd, p, filetype=None, create=False):
         return None
 
     if not filetype:
-        if p.is_dir():
-            filetype = 'dir'
-        else:
-            filetype = p.ext or options.filetype or 'txt'
+        filetype = p.ext or vd.options.filetype
 
     filetype = filetype.lower()
 
     if not p.exists():
-        if not create:
-            return None
         newfunc = getattr(vd, 'new_' + filetype, vd.getGlobals().get('new_' + filetype))
         if not newfunc:
             vd.warning('%s does not exist, creating new sheet' % p)
-            return vd.newSheet(p.name, 1, source=p)
+            return vd.newSheet(p.base_stem, 1, source=p)
 
         vd.status('creating blank %s' % (p.given))
         return newfunc(p)
 
-    openfunc = getattr(vd, 'open_' + filetype, vd.getGlobals().get('open_' + filetype))
+    if p.is_fifo():
+        # read the file as text, into a RepeatFile that can be opened multiple times
+        p = Path(p.given, fp=p.open(mode='rb'))
+
+    openfuncname = 'open_' + filetype
+    openfunc = getattr(vd, openfuncname, vd.getGlobals().get(openfuncname))
     if not openfunc:
+        opts = vd.guessFiletype(p)
+        if opts and 'filetype' in opts:
+            filetype = opts['filetype']
+            openfuncname = 'open_' + filetype
+            openfunc = getattr(vd, openfuncname, vd.getGlobals().get(openfuncname))
+            if not openfunc:
+                vd.error(f'guessed {filetype} but no {openfuncname}')
+
+            vs = openfunc(p)
+            for k, v in opts.items():
+                if k != 'filetype' and not k.startswith('_'):
+                    setattr(vs.options, k, v)
+            vd.warning('guessed "%s" filetype based on contents' % opts['filetype'])
+            return vs
+
         vd.warning('unknown "%s" filetype' % filetype)
+
         filetype = 'txt'
         openfunc = vd.open_txt
 
@@ -81,13 +138,16 @@ def openPath(vd, p, filetype=None, create=False):
 
     return openfunc(p)
 
-
 @VisiData.api
 def openSource(vd, p, filetype=None, create=False, **kwargs):
     '''Return unloaded sheet object for *p* opened as the given *filetype* and with *kwargs* as option overrides. *p* can be a Path or a string (filename, url, or "-" for stdin).
     when true, *create* will return a blank sheet, if file does not exist.'''
-    if not filetype:
-        filetype = options.getonly('filetype', 'global', '')
+
+    if isinstance(p, BaseSheet):
+        return p
+
+    filetype = filetype or vd.options.getonly('filetype', str(p), '')  #1710
+    filetype = filetype or vd.options.getonly('filetype', 'global', '')
 
     vs = None
     if isinstance(p, str):
@@ -111,26 +171,21 @@ def openSource(vd, p, filetype=None, create=False, **kwargs):
 def open_txt(vd, p):
     'Create sheet from `.txt` file at Path `p`, checking whether it is TSV.'
     if p.exists(): #1611
-        with p.open_text(encoding=vd.options.encoding) as fp:
+        with p.open(encoding=vd.options.encoding) as fp:
+            delimiter = vd.options.delimiter
             try:
-                if options.delimiter in next(fp):    # peek at the first line
+                if delimiter and delimiter in next(fp):    # peek at the first line
                     return vd.open_tsv(p)  # TSV often have .txt extension
             except StopIteration:
-                return Sheet(p.name, columns=[SettableColumn()], source=p)
-    return TextSheet(p.name, source=p)
-
-
-@VisiData.api
-def loadInternalSheet(vd, cls, p, **kwargs):
-    'Load internal sheet of given class.'
-    vs = cls(p.name, source=p, **kwargs)
-    options._set('encoding', 'utf8', vs)
-    if p.exists():
-#        vd.sheets.insert(0, vs) # broke replay with macros.reload()
-        vs.reload.__wrapped__(vs)
-#        vd.sheets.pop(0)
-    return vs
+                return TableSheet(p.base_stem, columns=[SettableColumn()], source=p)
+    return TextSheet(p.base_stem, source=p)
 
 
 BaseSheet.addCommand('o', 'open-file', 'vd.push(openSource(inputFilename("open: "), create=True))', 'Open file or URL')
 TableSheet.addCommand('zo', 'open-cell-file', 'vd.push(openSource(cursorDisplay) or fail(f"file {cursorDisplay} does not exist"))', 'Open file or URL from path in current cell')
+BaseSheet.addCommand('gU', 'undo-last-quit', 'push(allSheets[-1])', 'reopen most recently closed sheet')
+
+vd.addMenuItems('''
+    File > Open > input file/url > open-file
+    File > Reopen last closed > undo-last-quit
+''')