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

visidata/__init__.py

@@ -1,6 +1,6 @@
 'VisiData: a curses interface for exploring and arranging tabular data'
 
-__version__ = '3.0.1'
+__version__ = '3.1'
 __version_info__ = 'VisiData v' + __version__
 __author__ = 'Saul Pwanson <vd@saul.pw>'
 __status__ = 'Production/Stable'
@@ -13,8 +13,7 @@ class EscapeException(BaseException):
 
 
 def addGlobals(*args, **kwargs):
-    '''Update the VisiData globals dict with items from *args* and *kwargs*, which are mappings of names to functions.
-    Importers can call ``addGlobals(globals())`` to have their globals accessible to execstrings.
+    '''Update the VisiData globals dict with items from *args* and *kwargs*; to add symbols available to command execstrings and eval strings like command expr.'
 
     Dunder methods are ignored, to prevent accidentally overwriting housekeeping methods.'''
     drop_dunder = lambda d: {k: v for k, v in d.items() if not k.startswith("__")}
@@ -140,13 +139,16 @@ def importFeatures():
     vd.importSubmodules('visidata.features')
     vd.importSubmodules('visidata.themes')
 
-    vd.importStar('visidata.deprecated')
+    import visidata.deprecated
 
-    vd.importStar('builtins')
-    vd.importStar('copy')
-    vd.importStar('math')
-    vd.importStar('random')
-    vd.importStar('itertools')
+    vd.importModule('copy', 'copy deepcopy'.split())
+    vd.importModule('builtins', 'abs all any ascii bin bool bytes callable chr complex dict dir divmod enumerate eval filter float format getattr hex int len list map max min next oct ord pow range repr reversed round set sorted str sum tuple type zip'.split())
+    vd.importModule('math', 'acos acosh asin asinh atan atan2 atanh ceil copysign cos cosh degrees dist erf erfc exp expm1 fabs factorial floor fmod frexp fsum gamma gcd hypot isclose isfinite isinf isnan isqrt lcm ldexp lgamma log log1p log10 log2 modf radians remainder sin sinh sqrt tan tanh trunc prod perm comb nextafter ulp pi e tau inf nan'.split())
+    vd.importModule('random', 'randrange randint choice choices sample uniform gauss lognormvariate'.split())
+    vd.importModule('string', 'ascii_letters ascii_lowercase ascii_uppercase digits hexdigits punctuation printable whitespace'.split())
+    vd.importModule('json')
+    vd.importModule('itertools')
+    vd.importModule('curses')
 
     import visidata.experimental  # import nothing by default but make package accessible
 
@@ -154,4 +156,4 @@ vd.finalInit()  # call all VisiData.init() from modules
 
 importFeatures()
 
-vd.addGlobals(globals())
+vd.addGlobals(vd=vd) # globals())

visidata/_input.py

@@ -4,7 +4,7 @@ import curses
 import visidata
 
 from visidata import EscapeException, ExpectedException, clipdraw, Sheet, VisiData, BaseSheet
-from visidata import vd, options, colors, dispwidth, ColorAttr
+from visidata import vd, colors, dispwidth, ColorAttr
 from visidata import AttrDict
 
 
@@ -14,7 +14,9 @@ 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.disp_help = 1  # current level of help shown (up to vd.options.disp_help as maximum)
+vd.disp_help = 0  # current page of help shown
+vd._help_sidebars = []  # list of (help:str|HelpPane, title:str)
+
 
 class AcceptInput(Exception):
     '*args[0]* is the input to be accepted'
@@ -64,7 +66,7 @@ class EnableCursor:
     def __exit__(self, exc_type, exc_val, tb):
         with suppress(curses.error):
             curses.curs_set(0)
-            if options.mouse_interval:
+            if vd.options.mouse_interval:
                 curses.mousemask(curses.MOUSE_ALL if hasattr(curses, "MOUSE_ALL") else 0xffffffff)
             else:
                 curses.mousemask(0)
@@ -89,155 +91,28 @@ 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=''):
+def drawInputHelp(vd, scr):
     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')
+    vd.drawSidebar(scr, sheet)
 
 
 def clean_printable(s):
     'Escape unprintable characters.'
-    return ''.join(c if c.isprintable() else options.disp_unprintable for c in str(s))
+    return ''.join(c if c.isprintable() else vd.options.disp_unprintable for c in str(s))
 
 
 def delchar(s, i, remove=1):
     'Delete `remove` characters from str `s` beginning at position `i`.'
     return s if i < 0 else s[:i] + s[i+remove:]
 
-
-class CompleteState:
-    def __init__(self, completer_func):
-        self.comps_idx = -1
-        self.completer_func = completer_func
-        self.former_i = None
-        self.just_completed = False
-
-    def complete(self, v, i, state_incr):
-        self.just_completed = True
-        self.comps_idx += state_incr
-
-        if self.former_i is None:
-            self.former_i = i
-        try:
-            r = self.completer_func(v[:self.former_i], self.comps_idx)
-        except Exception as e:
-            # raise  # beep/flash; how to report exception?
-            return v, i
-
-        if not r:
-            # beep/flash to indicate no matches?
-            return v, i
-
-        v = r + v[i:]
-        return v, len(v)
-
-    def reset(self):
-        if self.just_completed:
-            self.just_completed = False
-        else:
-            self.former_i = None
-            self.comps_idx = -1
-
-class HistoryState:
-    def __init__(self, history):
-        self.history = history
-        self.hist_idx = None
-        self.prev_val = None
-
-    def up(self, v, i):
-        if self.hist_idx is None:
-            self.hist_idx = len(self.history)
-            self.prev_val = v
-        if self.hist_idx > 0:
-            self.hist_idx -= 1
-            v = self.history[self.hist_idx]
-        i = len(str(v))
-        return v, i
-
-    def down(self, v, i):
-        if self.hist_idx is None:
-            return v, i
-        elif self.hist_idx < len(self.history)-1:
-            self.hist_idx += 1
-            v = self.history[self.hist_idx]
-        else:
-            v = self.prev_val
-            self.hist_idx = None
-        i = len(str(v))
-        return v, i
-
-
-# history: earliest entry first
-@VisiData.api
-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
-    first_action = True
-    v = str(value)  # value under edit
-
-    # i = 0  # index into v, initial value can be passed in as argument as of 1.2
-    if i != 0:
-        first_action = False
-
-    left_truncchar = right_truncchar = truncchar
-
-    def find_nonword(s, a, b, incr):
+def find_nonword(s, a, b, incr):
         if not s: return 0
         a = min(max(a, 0), len(s)-1)
         b = min(max(b, 0), len(s)-1)
@@ -255,50 +130,117 @@ def editline(vd, scr, y, x, w, i=0,
                 a += incr
             return min(max(a, 0), len(s))
 
-    while True:
-        updater(v)
+class InputWidget:
+    def __init__(self,
+                 value:str='',
+                 i=0,
+                 display=True,
+                 history=[],
+                 completer=lambda text,idx: None,
+                 options=None,
+                 fillchar=''):
+        '''
+            - value: starting value
+            - i: starting index into value
+            - display: False to not display input (for sensitive input, e.g. a password)
+            - history: list of strings; earliest entry first.
+            - completer: func(value:str, idx:int) takes the current value and tab completion index, and returns a string if there is a completion available, or None if not.
+            - options: sheet.options; defaults to vd.options.
+        '''
+        options = options or vd.options
+
+        self.orig_value = value
+        self.first_action = (i == 0)  # whether this would be the 'first action'; if so, clear text on input
+
+        # display theme
+        self.fillchar  = fillchar or options.disp_edit_fill
+        self.truncchar = options.disp_truncator
+        self.display = display  # if False, obscure before displaying
+
+        # main state
+        self.value = self.orig_value  # value under edit
+        self.current_i = i
+        self.insert_mode = True
+
+        # history state
+        self.history = history
+        self.hist_idx = None
+        self.prev_val = None
 
-        if display:
-            dispval = clean_printable(v)
+        # completion state
+        self.comps_idx = -1
+        self.completer_func = completer
+        self.former_i = None
+        self.just_completed = False
+
+    def editline(self, scr, y, x, w, attr=ColorAttr(), updater=lambda val: None, bindings={}, clear=True) -> str:
+        'If *clear* is True, clear whole editing area before displaying.'
+        with EnableCursor():
+            while True:
+                vd.drawSheet(scr, vd.activeSheet)
+                if updater:
+                    updater(self.value)
+
+                vd.drawInputHelp(scr)
+
+                self.draw(scr, y, x, w, attr, clear=clear)
+                ch = vd.getkeystroke(scr)
+                if ch in bindings:
+                    self.value, self.current_i = bindings[ch](self.value, self.current_i)
+                else:
+                    if self.handle_key(ch, scr):
+                        return self.value
+
+
+    def draw(self, scr, y, x, w, attr=ColorAttr(), clear=True):
+        i = self.current_i  # the onscreen offset within the field where v[i] is displayed
+        left_truncchar = right_truncchar = self.truncchar
+
+        if self.display:
+            dispval = clean_printable(self.value)
         else:
-            dispval = '*' * len(v)
+            dispval = '*' * len(self.value)
 
-        dispi = i  # the onscreen offset within the field where v[i] is displayed
         if len(dispval) < w:  # entire value fits
-            dispval += fillchar*(w-len(dispval)-1)
+            dispval += self.fillchar*(w-len(dispval)-1)
         elif i == len(dispval):  # cursor after value (will append)
-            dispi = w-1
-            dispval = left_truncchar + dispval[len(dispval)-w+2:] + fillchar
+            i = w-1
+            dispval = left_truncchar + dispval[len(dispval)-w+2:] + self.fillchar
         elif i >= len(dispval)-w//2:  # cursor within halfwidth of end
-            dispi = w-(len(dispval)-i)
+            i = w-(len(dispval)-i)
             dispval = left_truncchar + dispval[len(dispval)-w+1:]
         elif i <= w//2:  # cursor within halfwidth of beginning
             dispval = dispval[:w-1] + right_truncchar
         else:
-            dispi = w//2  # visual cursor stays right in the middle
+            i = w//2  # visual cursor stays right in the middle
             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, 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
+            dispval = left_truncchar + dispval[self.current_i-w//2+1:self.current_i+w//2-k] + right_truncchar
+
+        prew = clipdraw(scr, y, x, dispval[:i], attr, w, clear=clear, literal=True)
+        clipdraw(scr, y, x+prew, dispval[i:], attr, w-prew+1, clear=clear, literal=True)
+        if scr:
+            scr.move(y, x+prew)
+
+    def handle_key(self, ch:str, scr) -> bool:
+        'Return True to accept current input.  Raise EscapeException on Ctrl+C, Ctrl+Q, or ESC.'
+        i = self.current_i
+        v = self.value
+
+        if ch == '':                               return False
+        elif ch == 'KEY_IC':                       self.insert_mode = not self.insert_mode
         elif ch == '^A' or ch == 'KEY_HOME':       i = 0
         elif ch == '^B' or ch == 'KEY_LEFT':       i -= 1
-        elif ch in ('^C', '^Q', ESC):              raise EscapeException(ch)
+        elif ch in ('^C', '^Q', '^['):             raise EscapeException(ch)
         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':
-            disp_help.cycle()
-            continue  # not considered a first keypress
+            vd.cycleSidebar()
+            return False # 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 == '^I':                           v, i = self.completion(v, i, +1)
+        elif ch == 'KEY_BTAB':                     v, i = self.completion(v, i, -1)
+        elif ch in ['^J', '^M']:                   return True # ENTER to accept value
         elif ch == '^K':                           v = v[:i]  # ^Kill to end-of-line
         elif ch == '^N':
             c = ''
@@ -307,8 +249,8 @@ def editline(vd, scr, y, x, w, i=0,
             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 == '^O':                           self.value = vd.launchExternalEditor(v); return True  # auto-accept after $EDITOR
+        elif ch == '^R':                           v = self.orig_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
@@ -320,13 +262,13 @@ def editline(vd, scr, y, x, w, i=0,
         elif ch == 'kRIT5':                        i = find_nonword(v, i+1, len(v)-1, +1)+1; # word right
         elif ch == 'kUP5':                         pass
         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 self.history and ch == 'KEY_UP':    v, i = self.prev_history(v, i)
+        elif self.history and ch == 'KEY_DOWN':  v, i = self.next_history(v, i)
         elif len(ch) > 1:                          pass
         else:
-            if first_action:
+            if self.first_action:
                 v = ''
-            if insert_mode:
+            if self.insert_mode:
                 v = splice(v, i, ch)
             else:
                 v = v[:i] + ch + v[i+1:]
@@ -337,22 +279,87 @@ def editline(vd, scr, y, x, w, i=0,
         # v may have a non-str type with no len()
         v = str(v)
         if i > len(v): i = len(v)
-        first_action = False
-        complete_state.reset()
+        self.current_i = i
+        self.value = v
+        self.first_action = False
+        self.reset_completion()
+        return False
 
-    return v
+    def completion(self, v, i, state_incr):
+        self.just_completed = True
+        self.comps_idx += state_incr
+
+        if self.former_i is None:
+            self.former_i = i
+        try:
+            r = self.completer_func(v[:self.former_i], self.comps_idx)
+        except Exception as e:
+            # raise  # beep/flash; how to report exception?
+            return v, i
+
+        if not r:
+            # beep/flash to indicate no matches?
+            return v, i
+
+        v = r + v[i:]
+        return v, len(v)
+
+    def reset_completion(self):
+        if self.just_completed:
+            self.just_completed = False
+        else:
+            self.former_i = None
+            self.comps_idx = -1
+
+    def prev_history(self, v, i):
+        if self.hist_idx is None:
+            self.hist_idx = len(self.history)
+            self.prev_val = v
+        if self.hist_idx > 0:
+            self.hist_idx -= 1
+            v = self.history[self.hist_idx]
+        i = len(str(v))
+        return v, i
+
+    def next_history(self, v, i):
+        if self.hist_idx is None:
+            return v, i
+        elif self.hist_idx < len(self.history)-1:
+            self.hist_idx += 1
+            v = self.history[self.hist_idx]
+        else:
+            v = self.prev_val
+            self.hist_idx = None
+        i = len(str(v))
+        return v, i
 
 
 @VisiData.api
-def editText(vd, y, x, w, record=True, display=True, **kwargs):
+def editText(vd, y, x, w, attr=ColorAttr(), value='',
+             help='',
+             updater=None, bindings={},
+             display=True, record=True, clear=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.getCommandInput()
 
     if v is None:
+        if vd.options.batch:
+            return ''
+
+        if vd.activeSheet._scr is None:
+            raise Exception('active sheet does not have a screen')
+
+        if value is None:
+            value = ''
+
         try:
-            v = vd.editline(vd.activeSheet._scr, y, x, w, display=display, **kwargs)
+            widget = InputWidget(value=str(value), display=display, **kwargs)
+
+            with vd.AddedHelp(vd.getHelpPane('input', module='visidata'), 'Input Keystrokes Help'), \
+                 vd.AddedHelp(help, 'Input Field Help'):
+                v = widget.editline(vd.activeSheet._scr, y, x, w, attr=attr, updater=updater, bindings=bindings, clear=clear)
         except AcceptInput as e:
             v = e.args[0]
 
@@ -364,13 +371,13 @@ def editText(vd, y, x, w, record=True, display=True, **kwargs):
         if record and vd.cmdlog:
             vd.setLastArgs(v)
 
-    if 'value' in kwargs:
-        starting_value = kwargs['value']
-        if isinstance(starting_value, (int, float)) and v[-1] == '%':  #2082
+    if value:
+        if isinstance(value, (int, float)) and v[-1] == '%':  #2082
             pct = float(v[:-1])
-            v = pct*starting_value/100
+            v = pct*value/100
 
-        v = type(starting_value)(v)
+        # convert back to type of original value
+        v = type(value)(v)
 
     return v
 
@@ -408,17 +415,22 @@ def inputMultiple(vd, updater=lambda val: None, record=True, **kwargs):
 
     previnput = vd.getCommandInput()
     if previnput is not None:
+        ret = None
         if isinstance(previnput, str):
             if previnput.startswith('{'):
-                return json.loads(previnput)
+                ret = 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
+            ret = previnput
+
+        if ret:
+            if record and vd.cmdlog:
+                vd.setLastArgs(ret)
+            return ret
 
         assert False, type(previnput)
 
@@ -454,8 +466,7 @@ def inputMultiple(vd, updater=lambda val: None, record=True, **kwargs):
 
         return updater(val)
 
-    with HelpCycler() as disp_help:
-      while True:
+    while True:
         try:
             input_kwargs = kwargs[cur_input_key]
             input_kwargs['value'] = vd.input(**input_kwargs,
@@ -478,16 +489,16 @@ def inputMultiple(vd, updater=lambda val: None, record=True, **kwargs):
             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
+    lastargs = {}
+    for k, input_kwargs in kwargs.items():
+        v = input_kwargs.get('value', '')
+        retargs[k] = v
 
+        if input_kwargs.get('record', record):
             if input_kwargs.get('display', True):
                 lastargs[k] = v
                 vd.addInputHistory(v, input_kwargs.get('type', ''))
-
+    if record:
         if vd.cmdlog and lastargs:
             vd.setLastArgs(lastargs)
 
@@ -501,8 +512,8 @@ def input(vd, prompt, type=None, defaultLast=False, history=[], dy=0, attr=None,
         - *type*: string indicating the type of input to use for history.
         - *history*: list of strings to use for input history.
         - *defaultLast*:  on empty input, if True, return last history item.
-        - *display*: pass False to not display input (for sensitive input, e.g. a password).
-        - *record*: pass False to not record input on cmdlog (for sensitive or inconsequential input).
+        - *display*: pass False to not display input (for sensitive input, e.g. a password), and to also prevent recording input as if *record* is False
+        - *record*: pass False to not record input on cmdlog or input history (for sensitive or inconsequential input).
         - *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)
@@ -525,7 +536,8 @@ def input(vd, prompt, type=None, defaultLast=False, history=[], dy=0, attr=None,
             import getpass
             return getpass.getpass(prompt)
 
-    history = list(vd.inputHistory.setdefault(type, {}).keys())
+    if not history:
+        history = list(vd.inputHistory.setdefault(type, {}).keys())
 
     y = sheet.windowHeight-dy-1
     promptlen = dispwidth(prompt)
@@ -539,15 +551,14 @@ def input(vd, prompt, type=None, defaultLast=False, history=[], dy=0, attr=None,
     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,
+                        options=vd.options,
                         history=history,
                         updater=_drawPrompt,
                         **kwargs)
 
     if ret:
-        vd.addInputHistory(ret, type=type)
-
+        if kwargs.get('record', True) and kwargs.get('display', True):
+            vd.addInputHistory(ret, type=type)
     elif defaultLast:
         history or vd.fail("no previous input")
         ret = history[-1]
@@ -558,7 +569,7 @@ def input(vd, prompt, type=None, defaultLast=False, history=[], dy=0, attr=None,
 @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 and not options.interactive:
+    if vd.options.batch and not vd.options.interactive:
         return vd.fail('cannot confirm in batch mode: ' + prompt)
 
     yn = vd.input(prompt, value='no', record=False)[:1]
@@ -625,9 +636,7 @@ def editCell(self, vcolidx=None, rowidx=None, value=None, **kwargs):
     bindings.update(kwargs.get('bindings', {}))
     kwargs['bindings'] = bindings
 
-    editargs = dict(value=value,
-                    fillchar=self.options.disp_edit_fill,
-                    truncchar=self.options.disp_truncator)
+    editargs = dict(value=value, options=self.options)
 
     editargs.update(kwargs)  # update with user-specified args
     r = vd.editText(y, x, w, attr=colors.color_edit_cell, **editargs)
@@ -638,4 +647,4 @@ def editCell(self, vcolidx=None, rowidx=None, value=None, **kwargs):
     return r
 
 
-vd.addGlobals({'CompleteKey': CompleteKey, 'AcceptInput': AcceptInput})
+vd.addGlobals(CompleteKey=CompleteKey, AcceptInput=AcceptInput, InputWidget=InputWidget)

visidata/_open.py

@@ -1,5 +1,6 @@
 import os
 import os.path
+import sys
 
 from visidata import VisiData, vd, Path, BaseSheet, TableSheet, TextSheet, SettableColumn
 
@@ -154,6 +155,8 @@ def openSource(vd, p, filetype=None, create=False, **kwargs):
         if '://' in p:
             vs = vd.openPath(Path(p), filetype=filetype)  # convert to Path and recurse
         elif p == '-':
+            if sys.stdin.isatty():
+                vd.fail('cannot open stdin when it is a tty')
             vs = vd.openPath(vd.stdinSource, filetype=filetype)
         else:
             vs = vd.openPath(Path(p), filetype=filetype, create=create)  # convert to Path and recurse
@@ -177,7 +180,7 @@ def open_txt(vd, p):
                 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 TableSheet(p.base_stem, columns=[SettableColumn()], source=p)
+                return TableSheet(p.base_stem, columns=[SettableColumn(width=vd.options.default_width)], source=p)
     return TextSheet(p.base_stem, source=p)